@uipath/maestro-builder-sdk 6.61.1 → 6.63.0

package/dist/check-cli.js

@@ -2,19 +2,31 @@
 /**
  * check-cli — static-validate an authored flow without emitting.
  *
- * Usage: node --experimental-strip-types check-cli.js <flow.ts | BaseName>
+ * Usage: node --experimental-strip-types check-cli.js [--baseline <original.flow>] <flow.ts | BaseName>
  * Prints diagnostics; exits non-zero if any errors.
+ *
+ * `--baseline <original.flow>` scopes the findings to the edit
+ * (docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.3-3.4): the original is decompiled
+ * and checked in memory the same way, and each finding is marked `(edited)` or
+ * `(pre-existing)`. A pre-existing finding (its node unchanged, and the
+ * original reports it too) is a warning, so only the edit's errors fail the
+ * check; a pre-existing lowering one is printed as a probable SDK defect.
+ * `--package <name>` trusts a node-type package the original names, as
+ * `flow merge` and `flow decompile` take it.
  */
-import { diagnosticLine, reportDiagnostics } from './cli-result.js';
+import { existsSync, readFileSync } from 'node:fs';
+import { diagnosticLine, reportDiagnostics, reportResult } from './cli-result.js';
 import { defaultBindingsFile } from './workdir.js';
 import { resolveFlowFile, loadBuiltFlow } from './load.js';
-import { check } from './check.js';
+import { check, checkCompiled, scopeToEdit } from './check.js';
 import { flowCheckOpts, openCliLibrary } from './cli-library.js';
 import { Bindings } from './bindings.js';
-import { runWhenInvokedDirectly } from './cli-run.js';
+import { flagValue, flagValues, runWhenInvokedDirectly } from './cli-run.js';
 import { ensureTypeScriptRuntime } from './node-runtime.js';
+import { withDecompiledOriginal } from './merge-compile.js';
+import { loadNodePackages } from './node-packages.js';
 /** Flags that take a value, so the value is never read as the source argument. */
-const VALUE_FLAGS = new Set(['--library', '--bindings', '--connectors-local']);
+const VALUE_FLAGS = new Set(['--library', '--bindings', '--connectors-local', '--baseline', '--package']);
 /**
  * Library lookups for the checks whose facts live in the connector corpus:
  * event parameters and measured list envelopes, and the library `check`'s
@@ -41,13 +53,21 @@ function checkOpts(argv) {
 export async function run(argv) {
     const arg = argv.find((a, i) => !a.startsWith('--') && !VALUE_FLAGS.has(argv[i - 1])) ?? argv[0];
     if (!arg || arg === '-h' || arg === '--help') {
-        console.error('usage: check [--library <dir>] [--connectors-local <dir>] [--bindings <file>] <flow.ts | BaseName>');
+        console.error('usage: check [--library <dir>] [--connectors-local <dir>] [--bindings <file>] [--baseline <original.flow> [--package <name>]] <flow.ts | BaseName>');
+        return 2;
+    }
+    const baselinePath = flagValue(argv, '--baseline');
+    const original = baselinePath !== undefined ? readBaseline(baselinePath) : undefined;
+    if (original instanceof Error) {
+        console.error(`check: ${original.message}`);
+        reportResult({ error: original.message });
         return 2;
     }
     const file = resolveFlowFile(arg);
     ensureTypeScriptRuntime();
     const built = await loadBuiltFlow(file);
-    const diags = check(built, checkOpts(argv));
+    const opts = checkOpts(argv);
+    const diags = baselinePath !== undefined ? await checkAgainstBaseline(built, baselinePath, original, opts, flagValues(argv, '--package')) : check(built, opts);
     reportDiagnostics(diags);
     if (diags.length === 0) {
         console.log('✓ no issues');
@@ -56,7 +76,58 @@ export async function run(argv) {
     for (const d of diags)
         console.log(diagnosticLine(d));
     const errors = diags.filter((d) => d.level === 'error').length;
-    console.log(`\n${errors} error(s), ${diags.length - errors} warning(s)`);
+    console.log(`\n${baselinePath !== undefined ? baselineSummary(diags) : `${errors} error(s), ${diags.length - errors} warning(s)`}`);
     return errors ? 1 : 0;
 }
+/**
+ * Check `built` and scope its findings to the edit ({@link scopeToEdit}). The
+ * baseline is the original decompiled and checked with the same options, as
+ * `flow merge --baseline-from` builds its baseline: first the node-type
+ * packages the original names are loaded, under the project's trust (or
+ * `--package`), so its nodes decompile to the same calls the edited source has.
+ */
+async function checkAgainstBaseline(built, originalPath, original, opts, packages) {
+    const loaded = await loadNodePackages(originalPath, original, packages);
+    for (const message of loaded.warnings)
+        console.error(`check: warning: ${message}`);
+    const baseline = await withDecompiledOriginal(originalPath, (b) => checkCompiled(b, opts), (m) => console.error(`check: decompile warning: ${m}`));
+    return scopeToEdit(checkCompiled(built, opts), baseline);
+}
+/**
+ * The `--baseline` file, parsed, or the usage error to refuse it with: a path
+ * that does not exist, or a file that is not a `.flow` (JSON with `nodes`),
+ * such as the `.flow.ts` source passed by mistake. Refused before anything is
+ * loaded, with the usage exit code, so a bad flag never reads as a failed check.
+ */
+function readBaseline(path) {
+    const usage = `--baseline must be the original .flow (JSON) the source was decompiled from: ${path}`;
+    if (!existsSync(path))
+        return new Error(`${usage} (no such file)`);
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(path, 'utf8'));
+    }
+    catch (error) {
+        return new Error(`${usage} (not JSON: ${error instanceof Error ? error.message : String(error)})`);
+    }
+    if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.nodes)) {
+        return new Error(`${usage} (no "nodes" array)`);
+    }
+    return parsed;
+}
+/**
+ * The `--baseline` summary: the errors that fail the check (the edit's), the
+ * pre-existing lowering findings (probable SDK defects) and the other
+ * pre-existing findings, and the edit's own warnings when there are any. For
+ * instance `1 error(s) in edited nodes, 1 pre-existing SDK defect(s), 1 pre-existing warning(s)`.
+ */
+function baselineSummary(diags) {
+    const edited = diags.filter((d) => d.origin !== 'pre-existing');
+    const pre = diags.filter((d) => d.origin === 'pre-existing');
+    const errors = edited.filter((d) => d.level === 'error').length;
+    const defects = pre.filter((d) => d.class === 'lowering').length;
+    const warnings = edited.length - errors;
+    return `${errors} error(s) in edited nodes, ${defects} pre-existing SDK defect(s), ${pre.length - defects} pre-existing warning(s)`
+        + (warnings ? `, ${warnings} warning(s) in edited nodes` : '');
+}
 runWhenInvokedDirectly(import.meta.url, 'check', run);

package/dist/check.d.ts

@@ -3,12 +3,34 @@ import type { BuiltFlow } from './flow-sdk.js';
 import { type EventCheckOpts } from './core/event-checks.js';
 export type { EventParamFields } from './core/event-checks.js';
 import { type ConnectorCheckOpts } from './core/connector-checks.js';
+import { type RefusalClass } from './core/refusals.js';
 export interface Diagnostic {
     level: 'error' | 'warning';
     code: string;
     message: string;
     step?: string;
     suggestion?: string;
+    /**
+     * The id of the node the finding is on, in the flow `compile` would write:
+     * the step's node, or for a step inside a subflow the node inside it.
+     * Absent for a finding that names no node (a flow-level rule, a refusal
+     * about the whole scope such as two steps with one name).
+     */
+    nodeId?: string;
+    /**
+     * The code's class (`core/refusals.ts`): `lint`, the flow is probably wrong
+     * but `compile` would still write it; `lowering`, `compile` cannot write a
+     * correct `.flow`; `draft`, an unfinished canvas node. Set on every finding
+     * whose code the table lists.
+     */
+    class?: RefusalClass;
+    /**
+     * Only when `check` is given a baseline (`flow check --baseline`, {@link scopeToEdit}):
+     * `pre-existing` when the finding's node is unchanged from the baseline and
+     * the baseline reports the same code on it, so the edit did not cause it
+     * (such a finding is a warning); `edited` for every other finding.
+     */
+    origin?: 'edited' | 'pre-existing';
 }
 export interface ListEnvelopeFields {
     envelope: string | null;
@@ -47,6 +69,64 @@ export interface CheckOpts extends ConnectorCheckOpts, EventCheckOpts {
     serializer?: false;
 }
 export declare function check(built: BuiltFlow, opts?: CheckOpts): Diagnostic[];
+/**
+ * What {@link checkCompiled} found, with the flow its serializer pass compiled,
+ * which {@link scopeToEdit} compares against a baseline.
+ */
+export interface CheckedFlow {
+    diagnostics: Diagnostic[];
+    /**
+     * The collect-mode compile, stand-ins and all (`SerializeOpts.collect`);
+     * nothing writes it. `undefined` when collection stopped or the serializer
+     * pass was skipped.
+     */
+    flow: any;
+    /**
+     * The refusal that stopped collection (a scope-level one, such as two Ends
+     * with one name), or the internal error that did: no serializer finding past
+     * it is reported. Absent when collection ran to the end or was skipped.
+     */
+    stoppedAt?: {
+        code?: string;
+        message: string;
+    };
+}
+/**
+ * `check`, keeping the flow its serializer pass compiled. Each finding is
+ * placed on its node (`nodeId`: a refusal on the node collect mode claimed for
+ * its step, any other finding on the node its step emitted) and given its
+ * code's `class`.
+ */
+export declare function checkCompiled(built: BuiltFlow, opts?: CheckOpts): CheckedFlow;
+/**
+ * Scope `edited`'s findings to the edit, against `baseline`: the original
+ * `.flow` decompiled and checked the same way (`flow check --baseline`,
+ * docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.3). Every finding gets an `origin`:
+ *
+ *   - `pre-existing` when its node is unchanged from the baseline (by id and
+ *     content, as merge judges it: `classifyDrafts`; a node inside a subflow
+ *     by its subflow) AND the baseline reports the same code on that node,
+ *     once per occurrence. A finding that names no node is `pre-existing` when
+ *     the baseline reports the same code and message (`splitUnplaced`).
+ *   - `edited` otherwise, including a finding on an untouched node that the
+ *     baseline does not have: an edit elsewhere caused it (a deleted variable
+ *     the node updates, a deleted step it reads).
+ *
+ * A pre-existing error becomes a warning, so it does not fail the check. A
+ * pre-existing `lowering` one also says it is probably an SDK defect, since the
+ * designer's node is one the SDK cannot write back: `compile` still refuses it,
+ * and `merge --baseline-from` keeps it as saved.
+ *
+ * When the edited flow's collection stopped at a scope-level refusal, the rest
+ * of the flow was never judged, so one more error, CHECK_INCOMPLETE (class
+ * `lowering`: `compile` stops at the refusal it names), says so:
+ * passing never means "not checked".
+ *
+ * For instance, an `EMPTY_ARM` on a branch the edit did not touch, which the
+ * baseline reports too, comes back as a `pre-existing` warning; the same
+ * finding after the edit changed that branch's condition is an `edited` error.
+ */
+export declare function scopeToEdit(edited: CheckedFlow, baseline: CheckedFlow): Diagnostic[];
 /**
  * The ISO-8601 repeating-interval pattern, copied VERBATIM from the
  * `core.trigger.scheduled@1.1` definition (`inputDefinition.then.properties.

package/dist/check.js

@@ -30,7 +30,18 @@ import { stepDeclaredVariables } from './flow-step-variables.js';
 import { plainHttpOnErrorMessage } from './nodes/http/flow/family.js';
 import { resolveVersion, resolveVersionCarried } from './core/nodes/versioned.js';
 import { loopParallelWarning, resolveLoopDefinition, loopVersion } from './loop-version.js';
+import { refusalClass } from './core/refusals.js';
+import { classifyDrafts, findingCounts, placeDiagnostics, splitUnplaced } from './edit-scope.js';
 export function check(built, opts = {}) {
+    return checkCompiled(built, opts).diagnostics;
+}
+/**
+ * `check`, keeping the flow its serializer pass compiled. Each finding is
+ * placed on its node (`nodeId`: a refusal on the node collect mode claimed for
+ * its step, any other finding on the node its step emitted) and given its
+ * code's `class`.
+ */
+export function checkCompiled(built, opts = {}) {
     // A connection two connectors use, and an agent resource's `nodeId` another
     // node of the file has, are the serializer's CONNECTION_CONNECTOR_CONFLICT /
     // INLINE_AGENT_RESOURCE_NODE_ID: it claims ids and resolves connections file-wide.
@@ -44,10 +55,109 @@ export function check(built, opts = {}) {
             ...(d.suggestion ? { suggestion: d.suggestion } : {}),
         });
     }
-    if (opts.serializer !== false)
-        diags.push(...serializerRefusals(built, { library: opts.library, bindings: opts.bindings }, diags));
-    return diags;
+    const serialized = opts.serializer !== false
+        ? serializerRefusals(built, { library: opts.library, bindings: opts.bindings }, diags)
+        : { diagnostics: [], flow: undefined };
+    diags.push(...serialized.diagnostics);
+    const placed = serialized.flow !== undefined ? placeDiagnostics(diags, serialized.flow) : undefined;
+    const diagnostics = diags.map((d, i) => {
+        const nodeId = d.nodeId ?? (placed?.[i].nodeId || undefined);
+        const cls = refusalClass(d.code);
+        return { ...d, ...(nodeId !== undefined ? { nodeId } : {}), ...(cls !== undefined ? { class: cls } : {}) };
+    });
+    return { diagnostics, flow: serialized.flow, ...(serialized.stoppedAt ? { stoppedAt: serialized.stoppedAt } : {}) };
+}
+/**
+ * Scope `edited`'s findings to the edit, against `baseline`: the original
+ * `.flow` decompiled and checked the same way (`flow check --baseline`,
+ * docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.3). Every finding gets an `origin`:
+ *
+ *   - `pre-existing` when its node is unchanged from the baseline (by id and
+ *     content, as merge judges it: `classifyDrafts`; a node inside a subflow
+ *     by its subflow) AND the baseline reports the same code on that node,
+ *     once per occurrence. A finding that names no node is `pre-existing` when
+ *     the baseline reports the same code and message (`splitUnplaced`).
+ *   - `edited` otherwise, including a finding on an untouched node that the
+ *     baseline does not have: an edit elsewhere caused it (a deleted variable
+ *     the node updates, a deleted step it reads).
+ *
+ * A pre-existing error becomes a warning, so it does not fail the check. A
+ * pre-existing `lowering` one also says it is probably an SDK defect, since the
+ * designer's node is one the SDK cannot write back: `compile` still refuses it,
+ * and `merge --baseline-from` keeps it as saved.
+ *
+ * When the edited flow's collection stopped at a scope-level refusal, the rest
+ * of the flow was never judged, so one more error, CHECK_INCOMPLETE (class
+ * `lowering`: `compile` stops at the refusal it names), says so:
+ * passing never means "not checked".
+ *
+ * For instance, an `EMPTY_ARM` on a branch the edit did not touch, which the
+ * baseline reports too, comes back as a `pre-existing` warning; the same
+ * finding after the edit changed that branch's condition is an `edited` error.
+ */
+export function scopeToEdit(edited, baseline) {
+    const locate = (c) => placeDiagnostics(c.diagnostics, c.flow)
+        .map((d, i) => ({ ...d, nodeId: c.diagnostics[i].nodeId ?? d.nodeId, index: i }));
+    const sorted = classifyDrafts(baseline.flow ?? {}, edited.flow ?? {}, baseline.flow, locate(edited));
+    // The baseline's findings on each node, by code; each one vouches for one edited finding.
+    const onNode = (f) => `${f.nodeId}\n${f.code}`;
+    const pool = new Map();
+    for (const b of locate(baseline)) {
+        if (b.nodeId === '')
+            continue;
+        pool.set(onNode(b), [...(pool.get(onNode(b)) ?? []), b.message]);
+    }
+    const preExisting = new Set();
+    // Exact messages are matched first: of two findings of one code on a node,
+    // the one the baseline has word for word is the pre-existing one. The second
+    // pass forgives wording the edit can shift without touching the finding (a
+    // "Known steps: ..." list), but only between messages that name the same
+    // quoted subjects: `UNKNOWN_REF "lookup" in "audit"` is a different finding
+    // from the baseline's `UNKNOWN_REF "ghost" in "audit"`, so it stays edited.
+    for (const exact of [true, false]) {
+        for (const f of sorted.kept) {
+            if (preExisting.has(f.index))
+                continue;
+            const messages = pool.get(onNode(f)) ?? [];
+            const j = exact ? messages.indexOf(f.message) : messages.findIndex((m) => quotedSubjects(m) === quotedSubjects(f.message));
+            if (j < 0)
+                continue;
+            messages.splice(j, 1);
+            preExisting.add(f.index);
+        }
+    }
+    for (const f of splitUnplaced(sorted.unplaced, findingCounts(baseline.diagnostics)).known)
+        preExisting.add(f.index);
+    const out = edited.diagnostics.map((d, i) => {
+        if (!preExisting.has(i))
+            return { ...d, origin: 'edited' };
+        const defect = d.level === 'error' && d.class === 'lowering';
+        return {
+            ...d,
+            level: 'warning',
+            message: defect ? `${d.message}\n  ${PRE_EXISTING_LOWERING_NOTE}` : d.message,
+            origin: 'pre-existing',
+        };
+    });
+    if (edited.stoppedAt) {
+        const at = edited.stoppedAt.code !== undefined ? `[${edited.stoppedAt.code}] ` : '';
+        out.push({
+            level: 'error', code: 'CHECK_INCOMPLETE',
+            message: `check stopped at ${at}${edited.stoppedAt.message} Nothing after that refusal was checked, so the edit is not judged. `
+                + 'Fix it, even if the original has it too, and run check again.',
+            class: refusalClass('CHECK_INCOMPLETE'), origin: 'edited',
+        });
+    }
+    return out;
+}
+/** The `"quoted"` names in a finding's message, in order: what it is about, apart from its wording. */
+function quotedSubjects(message) {
+    return JSON.stringify(message.match(/"[^"]*"/g) ?? []);
 }
+/** What a pre-existing lowering finding adds to its message ({@link scopeToEdit}). */
+const PRE_EXISTING_LOWERING_NOTE = 'This node is unchanged from the baseline, so this is probably an SDK defect: '
+    + 'the SDK cannot read what the designer wrote. `compile` refuses this node; `merge --baseline-from` keeps it as saved. '
+    + 'Report it: https://github.com/UiPath/builder-sdk/issues';
 /** The error-level diagnostics a custom node's own `diagnostics()` reported (see `serializerRefusals`). */
 const OWN_NODE_ERRORS = new WeakSet();
 /**
@@ -67,13 +177,20 @@ const OWN_NODE_ERRORS = new WeakSet();
  */
 function serializerRefusals(built, compile, found) {
     const collected = [];
+    let flow;
+    let stoppedAt;
     try {
-        serialize(built, { ...compile, collect: (r) => collected.push(r) });
+        flow = serialize(built, { ...compile, collect: (r) => collected.push(r) });
+        // Collection stopped: the refusal that stopped it is the last one reported.
+        const stop = collected[collected.length - 1];
+        if (flow === undefined && stop)
+            stoppedAt = { code: stop.code, message: stop.message };
     }
     catch (error) {
         // LIBRARY_REQUIRED is dropped below, so it does not count as something reported.
         if (!found.some((d) => d.level === 'error') && !collected.some((r) => r.code !== 'LIBRARY_REQUIRED'))
             throw error;
+        stoppedAt = { message: error instanceof Error ? error.message : String(error) };
     }
     const out = [];
     const seen = new Set();
@@ -100,9 +217,10 @@ function serializerRefusals(built, compile, found) {
             level: 'error', code: r.code, message,
             ...(step !== undefined ? { step } : {}),
             ...(r.suggestion !== undefined ? { suggestion: r.suggestion } : {}),
+            ...(r.nodeId !== undefined ? { nodeId: r.nodeId } : {}),
         });
     }
-    return out;
+    return { diagnostics: out, flow, ...(stoppedAt ? { stoppedAt } : {}) };
 }
 /**
  * `ancestors` is the chain of child flows currently being checked, innermost

package/dist/cli/commands/flow.js

@@ -40,7 +40,10 @@ export function registerFlowCommands(program) {
         .option('--source', 'check authored TypeScript')
         .addOption(retiredCompiledOption())
         .option('--library <dir>', 'connector library directory')
-        .option('--connectors-local <dir>', 'connection-resolved connector overlay');
+        .option('--connectors-local <dir>', 'connection-resolved connector overlay')
+        .option('--bindings <file>', 'bindings.json path')
+        .option('--baseline <file>', 'the original .flow the source was decompiled from (what merge --baseline-from takes, not the compiled baseline merge --baseline takes): findings on nodes the edit did not touch, which the original has too, become warnings')
+        .option('--package <name...>', 'trust and load this node-type package for --baseline (repeatable)');
     // Hidden, not removed: scripts that pass these keep parsing.
     for (const [flags, , description] of RETIRED_COMPILED_CHECK_FLAGS) {
         check.addOption(new Option(flags, description).hideHelp());
@@ -69,6 +72,10 @@ export function registerFlowCommands(program) {
             const argv = [input];
             addValue(argv, '--library', options.library);
             addValue(argv, '--connectors-local', options.connectorsLocal);
+            addValue(argv, '--bindings', options.bindings);
+            addValue(argv, '--baseline', options.baseline);
+            for (const name of options.package ?? [])
+                argv.push('--package', name);
             await invoke('flow check', () => import('../../check-cli.js'), argv);
             return;
         }

package/dist/cli-result.d.ts

@@ -24,30 +24,34 @@ export declare function reportResult(fields: Record<string, unknown>): void;
  * @param text - the result as text; a trailing newline is added.
  */
 export declare function printResult(text: string): void;
-/**
- * Report a check's diagnostics as `{ errors, warnings, diagnostics }`, the one
- * shape every family's check (and compile's check pass) uses.
- */
-export declare function reportDiagnostics(diags: ReadonlyArray<{
+/** A diagnostic as `reportDiagnostics` and `diagnosticLine` read it: any family's, with the fields it has. */
+interface ReportedDiagnostic {
     level: string;
     code: string;
     message: string;
     step?: string;
     suggestion?: string;
-}>): void;
+    nodeId?: string;
+    class?: string;
+    origin?: string;
+}
+/**
+ * Report a check's diagnostics as `{ errors, warnings, diagnostics }`, the one
+ * shape every family's check (and compile's check pass) uses. Each diagnostic
+ * keeps the optional fields it has: `step`, `suggestion`, and Flow's `nodeId`,
+ * `class` and (with `check --baseline`) `origin`.
+ */
+export declare function reportDiagnostics(diags: ReadonlyArray<ReportedDiagnostic>): void;
 /**
  * One diagnostic as `check` and `compile` print it: its mark and code, the
- * message, the step it is on (unless the message already names it), and the
- * suggestion. For instance
- * `✗ [STEP_SWITCH_EXIT_UNKNOWN] no exit named "maybe". … (step "route")`.
+ * message, the step it is on (unless the message already names it), the
+ * suggestion, and, with `check --baseline`, its origin. For instance
+ * `✗ [STEP_SWITCH_EXIT_UNKNOWN] no exit named "maybe". … (step "route")`, or
+ * `⚠ [EMPTY_ARM] … (pre-existing, not counted)`. With an origin, a message's
+ * later lines (the note on a pre-existing lowering finding) follow the line
+ * the origin ends.
  */
-export declare function diagnosticLine(d: {
-    level: string;
-    code: string;
-    message: string;
-    step?: string;
-    suggestion?: string;
-}): string;
+export declare function diagnosticLine(d: ReportedDiagnostic): string;
 /**
  * The error diagnostic for a throw that ends a compile: the error's own string
  * `code` when it carries one, else `COMPILE_FAILED`.
@@ -57,3 +61,4 @@ export declare function thrownDiagnostic(error: unknown): {
     code: string;
     message: string;
 };
+export {};

package/dist/cli-result.js

@@ -38,7 +38,9 @@ export function printResult(text) {
 }
 /**
  * Report a check's diagnostics as `{ errors, warnings, diagnostics }`, the one
- * shape every family's check (and compile's check pass) uses.
+ * shape every family's check (and compile's check pass) uses. Each diagnostic
+ * keeps the optional fields it has: `step`, `suggestion`, and Flow's `nodeId`,
+ * `class` and (with `check --baseline`) `origin`.
  */
 export function reportDiagnostics(diags) {
     reportResult({
@@ -48,21 +50,34 @@ export function reportDiagnostics(diags) {
             level: d.level, code: d.code, message: d.message,
             ...(d.step !== undefined ? { step: d.step } : {}),
             ...(d.suggestion ? { suggestion: d.suggestion } : {}),
+            ...(d.nodeId !== undefined ? { nodeId: d.nodeId } : {}),
+            ...(d.class !== undefined ? { class: d.class } : {}),
+            ...(d.origin !== undefined ? { origin: d.origin } : {}),
         })),
     });
 }
 /**
  * One diagnostic as `check` and `compile` print it: its mark and code, the
- * message, the step it is on (unless the message already names it), and the
- * suggestion. For instance
- * `✗ [STEP_SWITCH_EXIT_UNKNOWN] no exit named "maybe". … (step "route")`.
+ * message, the step it is on (unless the message already names it), the
+ * suggestion, and, with `check --baseline`, its origin. For instance
+ * `✗ [STEP_SWITCH_EXIT_UNKNOWN] no exit named "maybe". … (step "route")`, or
+ * `⚠ [EMPTY_ARM] … (pre-existing, not counted)`. With an origin, a message's
+ * later lines (the note on a pre-existing lowering finding) follow the line
+ * the origin ends.
  */
 export function diagnosticLine(d) {
     // A step inside a subflow is `<caller> › <step>`; the message names the innermost one.
     const named = d.step !== undefined && d.message.includes(`"${d.step.split(' › ').pop()}"`);
-    return `${d.level === 'error' ? '✗' : '⚠'} [${d.code}] ${d.message}`
-        + (d.step !== undefined && !named ? ` (step "${d.step}")` : '')
+    const suffix = (d.step !== undefined && !named ? ` (step "${d.step}")` : '')
         + (d.suggestion ? ` (did you mean "${d.suggestion}"?)` : '');
+    const mark = `${d.level === 'error' ? '✗' : '⚠'} [${d.code}]`;
+    if (d.origin === undefined)
+        return `${mark} ${d.message}${suffix}`;
+    // With a baseline the origin ends the finding's first line, where it is seen.
+    const origin = d.origin === 'edited' ? ' (edited)'
+        : d.class === 'lowering' ? ' (pre-existing)' : ' (pre-existing, not counted)';
+    const [first, ...rest] = d.message.split('\n');
+    return [`${mark} ${first}${suffix}${origin}`, ...rest].join('\n');
 }
 /**
  * The error diagnostic for a throw that ends a compile: the error's own string

package/dist/core/refusals.d.ts

@@ -55,6 +55,7 @@ export declare const REFUSALS: {
     readonly CARRIED_DEFINITION_CONFLICT: "lowering";
     readonly CARRIED_DEFINITION_INVALID: "lowering";
     readonly CEQL_UNPARSEABLE: "lowering";
+    readonly CHECK_INCOMPLETE: "lowering";
     readonly COMPILE_FAILED: "lowering";
     readonly CONNECTION_CONNECTOR_CONFLICT: "draft";
     readonly CONNECTION_STUB: "lint";

package/dist/core/refusals.js

@@ -93,6 +93,9 @@ export const REFUSALS = {
     CARRIED_DEFINITION_CONFLICT: 'lowering',
     CARRIED_DEFINITION_INVALID: 'lowering',
     CEQL_UNPARSEABLE: 'lowering',
+    // Only `check --baseline` reports it: collection stopped at a scope-level
+    // refusal, and `compile` (and `merge --baseline-from`) stops at that refusal.
+    CHECK_INCOMPLETE: 'lowering',
     // A throw that is no refusal, which `compile` cannot get past: check reports it on its step.
     COMPILE_FAILED: 'lowering',
     CONNECTION_CONNECTOR_CONFLICT: 'draft',

package/dist/edit-scope.d.ts

@@ -12,6 +12,9 @@
  *
  * For instance, a canvas Slack node with no connection yet that the author did
  * not touch is `kept`; the same node with a new message text is `refused`.
+ * A node the SDK cannot lower is compared by the stand-ins the two collect-mode
+ * compiles emit for it ({@link isStandIn}), and kept only when the original's
+ * own round trip refuses it too ({@link classifyLowering}).
  *
  * Pure: no file access, so a portable entry (`check.ts`, `merge.ts`) can use
  * it. Reading the original and compiling its baseline is merge-compile.ts's.
@@ -70,6 +73,13 @@ export declare function byId(nodes: AnyNode[] | undefined): Map<string, AnyNode>
  * decide "did the user edit this node?" against the baseline.
  */
 export declare function nodeUnchanged(a: AnyNode | undefined, b: AnyNode | undefined): boolean;
+/**
+ * Whether `n` is the opaque node a collect-mode compile emits in place of a
+ * step it could not lower (serialize.ts `standInNode`): the node type, the
+ * step's `{ version }`, and `inputs: { standIn: true, spec }`, the spec as
+ * authored. It is never written: merge restores the original node or refuses.
+ */
+export declare function isStandIn(n: AnyNode | undefined): boolean;
 /**
  * The keys of the subflows `mergeFlow` (merge.ts) takes from `edited` rather than
  * restoring from `original`: every subflow that is new, that the original does
@@ -96,9 +106,15 @@ export declare function isKept(e: AnyNode, origNodes: Map<string, AnyNode>, base
  * Why a finding is an error: `edited`, its node is one the author changed or
  * added; `subflow`, it sits in a subflow the edit changed, which merge takes
  * whole; `unplaced`, it names no node and the original's own round trip does
- * not report it, so the edit introduced it.
+ * not report it, so the edit introduced it. Two more are for a lowering
+ * refusal on a node merge would keep ({@link classifyLowering}):
+ * `introduced`, the original's own round trip does not report it on that node,
+ * so an edit elsewhere broke it; `unrestorable`, restoring the node from the
+ * original would not undo it; `uncompared`, the node is the original's, but
+ * there is no collect-mode compile of the original to compare its stand-in
+ * with (no `--baseline-from`), so merge cannot tell whether the edit touched it.
  */
-export type TakenReason = 'edited' | 'subflow' | 'unplaced';
+export type TakenReason = 'edited' | 'subflow' | 'unplaced' | 'introduced' | 'unrestorable' | 'uncompared';
 /**
  * A finding on a node merge takes from the edited flow, with the reason it
  * takes it: `edited`, the author changed or added the node; `subflow`, the
@@ -135,6 +151,47 @@ export declare function classifyDrafts<T extends {
     refused: Refused<T>[];
     unplaced: T[];
 };
+/** A refusal a compile reported on the node `nodeId` (`''` when it names none). */
+export interface NodeRefusal {
+    nodeId: string;
+    code: string;
+    message: string;
+}
+/**
+ * Sort the lowering refusals of a collect-mode compile of the edited flow
+ * (`SerializeOpts.collect`, design D3) by what merge does with their node, as
+ * {@link classifyDrafts} does for drafts, then hold a kept one to the rest of
+ * what "pre-existing" means (docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.3). It
+ * stays `kept`, and merge restores the original node, only when:
+ *
+ *   - the ORIGINAL's own round trip (`baselineRefusals`, the baseline compiled
+ *     in collect mode) reports the same code on the same node; else it is
+ *     refused as `introduced`: an edit elsewhere broke a node the author did
+ *     not touch (a deleted node it reads), and restoring it would keep the
+ *     break;
+ *   - restoring the node undoes the refusal; else it is refused as
+ *     `unrestorable`. That holds for a root node the compile stood in for
+ *     ({@link isStandIn}: its own emission failed, and its edges are wired as
+ *     any node's), and for any node of an untouched subflow, which merge
+ *     restores whole. A refusal on a root node that did lower (an edge out of
+ *     it, a join it feeds) is about edges merge takes from the edited flow.
+ *     The {@link NEVER_KEPT_CODES} are `unrestorable` too.
+ *
+ * `baselineRefusals` is `undefined` when the baseline was not compiled in
+ * collect mode (a precompiled `--baseline` file, or none). Then a stand-in has
+ * nothing to equal (a precompiled baseline holds the node lowered, or the file
+ * would not exist), and nothing says how the original's round trip treats the
+ * node, so every refusal on a node the original has is `uncompared`, never
+ * `edited`: the author may not have touched it.
+ *
+ * For instance a canvas Jira node whose input the SDK cannot read, untouched,
+ * is `kept`; the same node with a changed summary is `refused` as `edited`.
+ */
+export declare function classifyLowering<T extends NodeRefusal>(original: any, edited: any, baseline: any, refusals: readonly T[], baselineRefusals: readonly NodeRefusal[] | undefined): {
+    kept: Kept<T>[];
+    refused: Refused<T>[];
+    unplaced: T[];
+};
 /**
  * A `check()` diagnostic, placed on the node its step emitted (`''` when it
  * names no node); `subflow` is the calling step when the finding is inside a

package/dist/edit-scope.js

@@ -15,9 +15,25 @@ export function nodeUnchanged(a, b) {
         return false;
     if (a.type !== b.type)
         return false;
+    // A step that fails to lower has no compiled node on either side, only the
+    // collect-mode stand-in (D5): equal stand-ins mean the edit did not touch the
+    // spec. Its `typeVersion` is the author's `{ version }` pin, so it counts.
+    if (isStandIn(a) || isStandIn(b)) {
+        return isStandIn(a) && isStandIn(b) && a.typeVersion === b.typeVersion
+            && JSON.stringify(a.inputs) === JSON.stringify(b.inputs);
+    }
     return JSON.stringify(a.inputs ?? {}) === JSON.stringify(b.inputs ?? {})
         && JSON.stringify(outputSources(a)) === JSON.stringify(outputSources(b));
 }
+/**
+ * Whether `n` is the opaque node a collect-mode compile emits in place of a
+ * step it could not lower (serialize.ts `standInNode`): the node type, the
+ * step's `{ version }`, and `inputs: { standIn: true, spec }`, the spec as
+ * authored. It is never written: merge restores the original node or refuses.
+ */
+export function isStandIn(n) {
+    return n?.inputs?.standIn === true;
+}
 /** Each output's `source` by output name; outputs without one are left out. */
 function outputSources(n) {
     const sources = {};
@@ -160,6 +176,72 @@ export function classifyDrafts(original, edited, baseline, findings) {
     }
     return { kept, refused, unplaced };
 }
+/**
+ * Lowering codes merge never keeps as saved, even on an untouched node:
+ * `COMPILE_FAILED` is a throw the SDK has no refusal for (a crash, not a
+ * finding to step over), and `LIBRARY_REQUIRED` is about compile's inputs,
+ * not about the node.
+ */
+const NEVER_KEPT_CODES = new Set(['COMPILE_FAILED', 'LIBRARY_REQUIRED']);
+/**
+ * Sort the lowering refusals of a collect-mode compile of the edited flow
+ * (`SerializeOpts.collect`, design D3) by what merge does with their node, as
+ * {@link classifyDrafts} does for drafts, then hold a kept one to the rest of
+ * what "pre-existing" means (docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.3). It
+ * stays `kept`, and merge restores the original node, only when:
+ *
+ *   - the ORIGINAL's own round trip (`baselineRefusals`, the baseline compiled
+ *     in collect mode) reports the same code on the same node; else it is
+ *     refused as `introduced`: an edit elsewhere broke a node the author did
+ *     not touch (a deleted node it reads), and restoring it would keep the
+ *     break;
+ *   - restoring the node undoes the refusal; else it is refused as
+ *     `unrestorable`. That holds for a root node the compile stood in for
+ *     ({@link isStandIn}: its own emission failed, and its edges are wired as
+ *     any node's), and for any node of an untouched subflow, which merge
+ *     restores whole. A refusal on a root node that did lower (an edge out of
+ *     it, a join it feeds) is about edges merge takes from the edited flow.
+ *     The {@link NEVER_KEPT_CODES} are `unrestorable` too.
+ *
+ * `baselineRefusals` is `undefined` when the baseline was not compiled in
+ * collect mode (a precompiled `--baseline` file, or none). Then a stand-in has
+ * nothing to equal (a precompiled baseline holds the node lowered, or the file
+ * would not exist), and nothing says how the original's round trip treats the
+ * node, so every refusal on a node the original has is `uncompared`, never
+ * `edited`: the author may not have touched it.
+ *
+ * For instance a canvas Jira node whose input the SDK cannot read, untouched,
+ * is `kept`; the same node with a changed summary is `refused` as `edited`.
+ */
+export function classifyLowering(original, edited, baseline, refusals, baselineRefusals) {
+    const sorted = classifyDrafts(original, edited, baseline, refusals);
+    if (baselineRefusals === undefined) {
+        const originalIds = new Set([
+            ...(original?.nodes ?? []).map((n) => n.id),
+            ...Object.values(original?.subflows ?? {}).flatMap((sf) => (sf?.nodes ?? []).map((n) => n.id)),
+        ]);
+        const refused = [...sorted.kept, ...sorted.refused].map((f) => ({
+            ...f,
+            reason: originalIds.has(f.nodeId) ? 'uncompared' : f.reason ?? 'edited',
+        }));
+        return { kept: [], refused, unplaced: sorted.unplaced };
+    }
+    const onNode = (r) => `${r.nodeId}\n${r.code}`;
+    const inBaseline = new Set(baselineRefusals.filter((r) => r.nodeId !== '').map(onNode));
+    const editedNodes = byId(edited?.nodes);
+    const kept = [];
+    const refused = [...sorted.refused];
+    for (const f of sorted.kept) {
+        const restorable = !NEVER_KEPT_CODES.has(f.code) && (f.subflow !== undefined || isStandIn(editedNodes.get(f.nodeId)));
+        if (!restorable)
+            refused.push({ ...f, reason: 'unrestorable' });
+        else if (!inBaseline.has(onNode(f)))
+            refused.push({ ...f, reason: 'introduced' });
+        else
+            kept.push(f);
+    }
+    return { kept, refused, unplaced: sorted.unplaced };
+}
 /**
  * Place each `check()` diagnostic on the node its step emitted in `editedFlow`, so
  * {@link classifyDrafts} can sort it: a root step on its node (by label, then

package/dist/merge-cli.js

@@ -9,8 +9,14 @@
  * `--baseline-from <original.flow>` makes merge build the baseline itself
  * (decompile + compile, nothing written), and an edited `.flow.ts` makes merge
  * compile it: both compiles tolerate DRAFT nodes, and merge refuses a draft
- * only where it would take the node from the edited flow. See merge-compile.ts
- * and edit-scope.ts.
+ * only where it would take the node from the edited flow. Both also run in
+ * collect mode, so a node the SDK cannot lower (#1402) is stood in for: merge
+ * restores it from the original when the edit did not touch it and the
+ * original's own round trip refuses it too (`LOWERING_NODE_KEPT`, printed as a
+ * probable SDK defect), and refuses the write when the edit changed it. See
+ * merge-compile.ts and edit-scope.ts. Neither warning depends on `--strict`:
+ * both nodes are written as the canvas saved them; `--strict` still refuses a
+ * stand-in whose wiring changed the round trip.
  *
  * `edited.flow` is compile(decompile(original) after your edits). `--baseline`
  * is compile(decompile(original)) BEFORE any edit — supplying it enables the
@@ -57,7 +63,7 @@ import { Bindings } from './bindings.js';
 import { defaultBindingsFile } from './workdir.js';
 import { loadNodePackages } from './node-packages.js';
 import { baselineFromOriginal, checkEdited, compileSourceDraftTolerant } from './merge-compile.js';
-import { classifyDrafts, findingCounts, splitUnplaced } from './edit-scope.js';
+import { classifyDrafts, classifyLowering, findingCounts, splitUnplaced } from './edit-scope.js';
 const USAGE = 'usage: flow-merge <original.flow> <edited.flow | Edited.flow.ts> [-o merged.flow] '
     + '[--baseline <baseline.flow> | --baseline-from <original.flow>] [--library <dir>] [--bindings <file>] [--strict]';
 /**
@@ -185,6 +191,7 @@ export async function run(argv) {
     const compileOpts = { library, bindings };
     const original = JSON.parse(readFileSync(originalPath, 'utf8'));
     let drafts = [];
+    let lowering = [];
     let diagnostics = [];
     let edited;
     let editedSidecars;
@@ -198,6 +205,7 @@ export async function run(argv) {
         edited = compiled.flow;
         editedSidecars = compiled.sidecars;
         drafts = compiled.drafts;
+        lowering = compiled.lowering.map(onNode);
         diagnostics = checkEdited(compiled.built, edited, flowCheckOpts(library, bindings));
     }
     else {
@@ -229,6 +237,9 @@ export async function run(argv) {
     // check()'s errors follow the same rule; its warnings are printed as compile prints them.
     const { kept, refused, unplaced } = classifyDrafts(original, edited, baseline, drafts);
     const checked = classifyDrafts(original, edited, baseline, diagnostics.filter((d) => d.level === 'error'));
+    // A node the SDK cannot lower follows the draft rule, held to the baseline:
+    // kept only when the original's own round trip refuses it the same way.
+    const lowered = classifyLowering(original, edited, baseline, lowering, baselineCompile?.lowering.map(onNode));
     for (const d of diagnostics)
         if (d.level === 'warning')
             console.error(`  ⚠ [${d.code}] ${d.message}`);
@@ -237,6 +248,14 @@ export async function run(argv) {
             ? `  ⚠ [DRAFT_NODE_KEPT] "${d.nodeId}" is unfinished in the original (${d.code}); it is inside subflow "${d.subflow}", which the edit did not touch, so the original subflow is kept as is.`
             : `  ⚠ [DRAFT_NODE_KEPT] "${d.nodeId}" is unfinished in the original (${d.code}); it is untouched, so the original node is kept as is.`);
     }
+    for (const d of lowered.kept) {
+        const where = d.subflow !== undefined
+            ? `is inside subflow "${d.subflow}", which the edit did not touch, so the original subflow is kept as is`
+            : 'is untouched, so the original node is kept as is';
+        console.error(`  ⚠ [LOWERING_NODE_KEPT] "${d.nodeId}" ${where}, but the SDK cannot compile it (${d.code}). `
+            + 'This is probably an SDK defect: the SDK cannot read what the designer wrote. Report it: https://github.com/UiPath/builder-sdk/issues');
+        console.error(`      ${d.message}`);
+    }
     // A finding merge cannot place on a node — an unnamed End's `.return`, a
     // flow-level finding — is printed when the ORIGINAL's own round trip reports
     // it too (the designer's file had it; check has already said it), and
@@ -245,16 +264,18 @@ export async function run(argv) {
     // one is refused, as before.
     const baselineFindings = baselineCompile === undefined ? undefined : findingCounts([
         ...baselineCompile.drafts,
+        ...baselineCompile.lowering,
         ...checkEdited(baselineCompile.built, baselineCompile.flow, flowCheckOpts(library, bindings)).filter((d) => d.level === 'error'),
     ]);
     const unplacedDrafts = splitUnplaced(unplaced, baselineFindings);
     const unplacedChecks = splitUnplaced(checked.unplaced, baselineFindings);
-    for (const d of [...unplacedDrafts.known, ...unplacedChecks.known]) {
+    const unplacedLowering = splitUnplaced(lowered.unplaced, baselineFindings);
+    for (const d of [...unplacedDrafts.known, ...unplacedChecks.known, ...unplacedLowering.known]) {
         console.error(`  ⚠ [CHECK_FINDING_UNPLACED] ${d.code} names no node, and the original's own round trip reports it too, so it does not stop the write: ${d.message}`);
     }
     const errors = [
-        ...refused, ...checked.refused,
-        ...[...unplacedDrafts.introduced, ...unplacedChecks.introduced].map((d) => ({ ...d, reason: 'unplaced' })),
+        ...refused, ...checked.refused, ...lowered.refused,
+        ...[...unplacedDrafts.introduced, ...unplacedChecks.introduced, ...unplacedLowering.introduced].map((d) => ({ ...d, reason: 'unplaced' })),
     ];
     if (errors.length) {
         for (const d of errors) {
@@ -262,10 +283,17 @@ export async function run(argv) {
                 ? 'the edited flow (this finding names no node, and the original\'s own round trip does not report it, so the edit introduced it)'
                 : d.reason === 'subflow'
                     ? `"${d.nodeId}" is inside subflow "${d.subflow}", which the edit changed, so merge takes that subflow whole; finish it`
-                    : `"${d.nodeId}" is changed or new in the edited flow`;
+                    : d.reason === 'introduced'
+                        ? `"${d.nodeId}" is untouched, but the original's own round trip does not refuse it, so an edit elsewhere broke it`
+                        : d.reason === 'unrestorable'
+                            ? unrestorable(d.nodeId, d.code)
+                            : d.reason === 'uncompared'
+                                ? `"${d.nodeId}" is the original's, but the SDK cannot compile it, and ${baseline ? 'a precompiled --baseline has no record of' : 'with no baseline merge cannot tell'} `
+                                    + 'whether the edit touched it; pass --baseline-from <original.flow> (instead of --baseline) so merge compiles the original itself and can compare the node'
+                                : `"${d.nodeId}" is changed or new in the edited flow`;
             console.error(`  ✗ [${d.code}] ${where}: ${d.message}`);
         }
-        console.error(`flow-merge: ${errors.length} error(s) in nodes merge takes from the edited flow; finish them or revert the edit. Nothing written.`);
+        console.error(`flow-merge: ${errors.length} error(s) in nodes merge takes from the edited flow; each line says what to do (finish the node, revert the edit, or pass what merge needs). Nothing written.`);
         return 1;
     }
     // Each compile writes `<source>/` beside its own output, so a baseline in the
@@ -345,4 +373,23 @@ export async function run(argv) {
     });
     return 0;
 }
+/**
+ * The error for a refusal on an untouched node that restoring it from the
+ * original would not undo, with the step to take: a crash is an SDK defect;
+ * a missing input to compile (the node library) is the caller's to pass; any
+ * other is about the edges merge takes from the edited flow.
+ */
+function unrestorable(nodeId, code) {
+    const report = 'https://github.com/UiPath/builder-sdk/issues';
+    if (code === 'COMPILE_FAILED')
+        return `"${nodeId}" is untouched, but the SDK failed while compiling it; this is an SDK defect, report it: ${report}`;
+    if (code === 'LIBRARY_REQUIRED')
+        return `"${nodeId}" is untouched, but compiling it needs the node library; pass --library <dir> and merge again`;
+    return `"${nodeId}" is untouched, but restoring it from the original would not undo this: revert the edit's changes to the edges `
+        + `into or out of it; if there are none, this is an SDK defect, report it: ${report}`;
+}
+/** A collect-mode refusal as edit-scope.ts sorts it: on its node, or on none (`''`). */
+function onNode(r) {
+    return { nodeId: r.nodeId ?? '', code: r.code, message: r.message };
+}
 runWhenInvokedDirectly(import.meta.url, 'flow-merge', run);

package/dist/merge-compile.d.ts

@@ -1,36 +1,55 @@
-import { type DraftFinding, type SerializeOpts } from './serialize.js';
+import { type CollectedRefusal, type DraftFinding, type SerializeOpts } from './serialize.js';
 import { type CheckOpts } from './check.js';
 import { type PlacedDiagnostic } from './edit-scope.js';
 import type { BuiltFlow } from './flow-sdk.js';
 /**
- * A compile's flow, the draft refusals it reported instead of throwing, and the
- * agent sidecars (`<source>/agent.json`, resource files) it produced, none written.
+ * A compile's flow, the draft refusals it reported instead of throwing, the
+ * lowering refusals collect mode reported on the steps it stood in for (or on
+ * no step), and the agent sidecars (`<source>/agent.json`, resource files) it
+ * produced, none written.
  */
 export interface DraftTolerantCompile {
     flow: any;
     drafts: DraftFinding[];
+    lowering: CollectedRefusal[];
     sidecars: Array<{
         path: string;
         json: unknown;
     }>;
 }
-/** Compile `built` with draft tolerance. Every other refusal still throws. */
-export declare function compileDraftTolerant(built: BuiltFlow, opts?: Omit<SerializeOpts, 'draft'>): DraftTolerantCompile;
+/**
+ * Compile `built` with draft tolerance, in collect mode: a step whose
+ * emission is refused is reported in `lowering` and stood in for, so the
+ * rest of the flow is still compiled. A scope-level refusal (two steps with
+ * one name, a variable plan) leaves no flow to merge, so it is thrown, as an
+ * ordinary compile throws it.
+ */
+export declare function compileDraftTolerant(built: BuiltFlow, opts?: Omit<SerializeOpts, 'draft' | 'collect'>): DraftTolerantCompile;
 /**
  * Load a `.flow.ts` source and compile it with draft tolerance.
  * The caller has already called `ensureTypeScriptRuntime()`.
  */
-export declare function compileSourceDraftTolerant(file: string, opts?: Omit<SerializeOpts, 'draft'>): Promise<DraftTolerantCompile & {
+export declare function compileSourceDraftTolerant(file: string, opts?: Omit<SerializeOpts, 'draft' | 'collect'>): Promise<DraftTolerantCompile & {
     built: BuiltFlow;
 }>;
 /**
  * The baseline of `originalPath`: decompile it (reading agent sidecars beside
- * it, as `flow decompile` does), then compile the source with draft tolerance.
+ * it, as `flow decompile` does), then compile the source with draft tolerance,
+ * in collect mode ({@link compileDraftTolerant}).
  * The source goes to a temporary directory that is removed afterwards.
  */
-export declare function baselineFromOriginal(originalPath: string, opts?: Omit<SerializeOpts, 'draft'>, warn?: (message: string) => void): Promise<DraftTolerantCompile & {
+export declare function baselineFromOriginal(originalPath: string, opts?: Omit<SerializeOpts, 'draft' | 'collect'>, warn?: (message: string) => void): Promise<DraftTolerantCompile & {
     built: BuiltFlow;
 }>;
+/**
+ * Decompile the `.flow` at `originalPath` (reading agent sidecars beside it, as
+ * `flow decompile` does), load the source, and hand the built flow to `use`
+ * while the source is still on disk. `flow merge --baseline-from` compiles it
+ * ({@link baselineFromOriginal}); `flow check --baseline` checks it. The source
+ * goes to a temporary directory that is removed afterwards. The caller has
+ * already called `ensureTypeScriptRuntime()`.
+ */
+export declare function withDecompiledOriginal<T>(originalPath: string, use: (built: BuiltFlow) => T | Promise<T>, warn?: (message: string) => void): Promise<T>;
 /**
  * Run `check()` on the edited source, as `compile` does, and place each
  * diagnostic on its node ({@link placeDiagnostics}). The `check()` call stays

package/dist/merge-compile.js

@@ -1,11 +1,14 @@
 /**
- * merge-compile — the compiles `flow merge --baseline-from` runs itself (#1134).
+ * merge-compile — the compiles `flow merge --baseline-from` runs itself (#1134),
+ * and the decompile of an original `.flow` that it and `flow check --baseline` share.
  *
- * Both compiles tolerate draft nodes (`SerializeOpts.draft`). A draft on a node
- * merge keeps from the original is a warning; a draft or `check()` error on a
- * node merge takes from the edited flow is an error. Nothing draft-tolerant is
- * written to disk. Which nodes count as edited, and how each finding is sorted,
- * is edit-scope.ts's.
+ * Both compiles tolerate draft nodes (`SerializeOpts.draft`) and run in collect
+ * mode (`SerializeOpts.collect`), so a node that fails to lower is reported and
+ * stood in for instead of stopping the compile. A draft or lowering refusal on
+ * a node merge keeps from the original is a warning; one on a node merge takes
+ * from the edited flow, like a `check()` error there, is an error. Nothing
+ * these compiles produce is written to disk. Which nodes count as edited, and
+ * how each finding is sorted, is edit-scope.ts's.
  */
 import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
@@ -13,15 +16,28 @@ import { dirname, join, resolve } from 'node:path';
 import { decompile } from './decompile.js';
 import { loadBuiltFlow } from './load.js';
 import { serialize } from './serialize.js';
+import { CompileRefusal } from './core/compile-refusal.js';
 import { PACKAGE_NAME } from './package-name.js';
 import { check } from './check.js';
 import { placeDiagnostics } from './edit-scope.js';
-/** Compile `built` with draft tolerance. Every other refusal still throws. */
+/**
+ * Compile `built` with draft tolerance, in collect mode: a step whose
+ * emission is refused is reported in `lowering` and stood in for, so the
+ * rest of the flow is still compiled. A scope-level refusal (two steps with
+ * one name, a variable plan) leaves no flow to merge, so it is thrown, as an
+ * ordinary compile throws it.
+ */
 export function compileDraftTolerant(built, opts = {}) {
     const drafts = [];
+    const lowering = [];
     const sidecars = [];
-    const flow = serialize(built, { ...opts, draft: (f) => drafts.push(f), sidecars });
-    return { flow, drafts, sidecars };
+    const flow = serialize(built, { ...opts, draft: (f) => drafts.push(f), collect: (r) => lowering.push(r), sidecars });
+    if (flow === undefined) {
+        // Collection stopped: the refusal that stopped it is the last one reported.
+        const stop = lowering[lowering.length - 1];
+        throw new CompileRefusal(stop.code, stop.message, stop.suggestion);
+    }
+    return { flow, drafts, lowering, sidecars };
 }
 /**
  * Load a `.flow.ts` source and compile it with draft tolerance.
@@ -33,10 +49,22 @@ export async function compileSourceDraftTolerant(file, opts = {}) {
 }
 /**
  * The baseline of `originalPath`: decompile it (reading agent sidecars beside
- * it, as `flow decompile` does), then compile the source with draft tolerance.
+ * it, as `flow decompile` does), then compile the source with draft tolerance,
+ * in collect mode ({@link compileDraftTolerant}).
  * The source goes to a temporary directory that is removed afterwards.
  */
 export async function baselineFromOriginal(originalPath, opts = {}, warn) {
+    return withDecompiledOriginal(originalPath, (built) => ({ ...compileDraftTolerant(built, opts), built }), warn);
+}
+/**
+ * Decompile the `.flow` at `originalPath` (reading agent sidecars beside it, as
+ * `flow decompile` does), load the source, and hand the built flow to `use`
+ * while the source is still on disk. `flow merge --baseline-from` compiles it
+ * ({@link baselineFromOriginal}); `flow check --baseline` checks it. The source
+ * goes to a temporary directory that is removed afterwards. The caller has
+ * already called `ensureTypeScriptRuntime()`.
+ */
+export async function withDecompiledOriginal(originalPath, use, warn) {
     const original = JSON.parse(readFileSync(originalPath, 'utf8'));
     const source = decompile(original, {
         importSpecifier: PACKAGE_NAME,
@@ -60,7 +88,7 @@ export async function baselineFromOriginal(originalPath, opts = {}, warn) {
         writeFileSync(join(dir, 'package.json'), '{"type":"module"}\n');
         const file = join(dir, 'Baseline.flow.ts');
         writeFileSync(file, source);
-        return await compileSourceDraftTolerant(file, opts);
+        return await use(await loadBuiltFlow(file));
     }
     finally {
         rmSync(dir, { recursive: true, force: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.61.1",
+  "version": "6.63.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "b4aa73a5f403c78c1b6bae2c136f6b281ba8fbac"
+  "gitref": "a4d62ecfe71de0865a81621edbf878ae84d0152b"
 }