@uipath/maestro-builder-sdk 6.62.0 → 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/merge-compile.d.ts

@@ -41,6 +41,15 @@ export declare function compileSourceDraftTolerant(file: string, opts?: Omit<Ser
 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,5 +1,6 @@
 /**
- * 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`) and run in collect
  * mode (`SerializeOpts.collect`), so a node that fails to lower is reported and
@@ -53,6 +54,17 @@ export async function compileSourceDraftTolerant(file, opts = {}) {
  * 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,
@@ -76,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.62.0",
+  "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": "2a6094aa49f4cbf18cb309ba93c33573f3e1f226"
+  "gitref": "a4d62ecfe71de0865a81621edbf878ae84d0152b"
 }