@uipath/maestro-builder-sdk 6.44.2 → 6.44.4

package/dist/check.js

@@ -22,6 +22,7 @@ import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { compareSchemaVersions, schemaVersionRefusal } from './schema-version.js';
 import { planFlowGlobals, planSharedInputs, sharedInputRoots } from './flow-variables.js';
 import { planOutputBacking } from './flow-output-backing.js';
+import { VARS_READ_RE } from './core/vars-read.js';
 import { terminateStepClashMessage, terminateTwiceMessage } from './flow-terminate-names.js';
 import { endContentKey } from './flow-end-content.js';
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
@@ -781,9 +782,12 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
                 }
             }
             else if (s.kind === 'return') {
+                // A named End (`.return({…}, { name })`) is a node merge can place a
+                // finding on, so its expressions report under that name (#1322); an
+                // unnamed one has no id until compile, so it stays `return`.
                 for (const [name, e] of Object.entries(s.values)) {
-                    addExpr(e.js, 'return');
-                    checkOutputCategory(name, e, outputType, typeOf, diags, triggerId);
+                    addExpr(e.js, s.options?.name ?? 'return');
+                    checkOutputCategory(name, e, outputType, typeOf, diags, triggerId, s.options?.name ?? 'return');
                 }
             }
             // AFTER the dispatch chain, not inside it: `s` was normalised to an action
@@ -1056,7 +1060,7 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
         // subflow read, where the value lives one level deeper
         // (`$vars.<call>.output.<childOutput>`). Every other rule reads only the
         // first two segments, exactly as before.
-        for (const m of js.matchAll(/\$vars\.([A-Za-z0-9_]+)(?:\??\.([A-Za-z0-9_]+))?((?:\??\.[A-Za-z0-9_]+)*)/g)) {
+        for (const m of js.matchAll(VARS_READ_RE)) {
             const [, name, field] = m;
             // `?.` reads the same path as `.`, and the rules below parse the tail as `.a.b`.
             const rest = m[3].replace(/\?\./g, '.');
@@ -1157,7 +1161,10 @@ function checkFlow(built, ancestors, opts = {}, ledger = newResourceIdLedger())
             // (`<step>.error`), which is what `err()` writes; on managed http it is the
             // output itself, and `serialize` rewrites the read to match. Either way this
             // spelling resolves to nothing, silently: the handler runs and reports empty.
-            if (field === 'output' && rest.startsWith('.error')) {
+            // The FIELD `error`, not a prefix: `error_type`, `error_message`,
+            // `errors` are success fields a function returns on its happy path, and
+            // two designer-saved flows report outcomes that way (#1321).
+            if (field === 'output' && /^\.error(?:\.|$)/.test(rest)) {
                 const wanted = /^\.error\.([A-Za-z0-9_]+)/.exec(rest);
                 diags.push({
                     level: 'error',
@@ -1734,7 +1741,7 @@ function typeCategory(t) {
  * its declared type is known. A `tmpl`/`js` expression produces text or something
  * unknowable, so it is left alone.
  */
-function checkOutputCategory(name, e, outputType, typeOf, diags, triggerId) {
+function checkOutputCategory(name, e, outputType, typeOf, diags, triggerId, step = 'return') {
     const declaredOut = outputType.get(name);
     if (!declaredOut || e.literal)
         return;
@@ -1756,7 +1763,7 @@ function checkOutputCategory(name, e, outputType, typeOf, diags, triggerId) {
         message: `Output "${name}" is declared ${declaredOut} but returns "${refName}", which is `
             + `${typeOf.get(refName)}. That is a type error, so the output would come back `
             + `empty at run time.`,
-        step: 'return',
+        step,
         suggestion: fix,
     });
 }

package/dist/core/vars-read.d.ts

@@ -0,0 +1,6 @@
+/**
+ * A dotted `$vars` read: `$vars.<name>`, an optional `.<field>`, then the dotted
+ * `rest`, each dot optionally `?.`. It stops at the first bracket. Check and
+ * decompile both scan with it, so decompile declares the body fields check reads.
+ */
+export declare const VARS_READ_RE: RegExp;

package/dist/core/vars-read.js

@@ -0,0 +1,6 @@
+/**
+ * A dotted `$vars` read: `$vars.<name>`, an optional `.<field>`, then the dotted
+ * `rest`, each dot optionally `?.`. It stops at the first bracket. Check and
+ * decompile both scan with it, so decompile declares the body fields check reads.
+ */
+export const VARS_READ_RE = /\$vars\.([A-Za-z0-9_]+)(?:\??\.([A-Za-z0-9_]+))?((?:\??\.[A-Za-z0-9_]+)*)/g;

package/dist/decompile.js

@@ -42,6 +42,7 @@ import { parseIxpProjectType } from './core/actions.js';
 import { readFlowGlobals } from './flow-variables.js';
 import { outputBackingGlobal, outputBackingName } from './flow-output-backing.js';
 import { mapJsCode } from './core/js-code-spans.js';
+import { VARS_READ_RE } from './core/vars-read.js';
 import { missingBindingLabels } from './core/binding-messages.js';
 import { prepareCommand } from './core/cli-spelling.js';
 import { OUTCOME_HANDLE_NODE_TYPES } from './core/hitl-routing.js';
@@ -459,6 +460,30 @@ function emitValMap(m, imp, inputNames) {
  */
 const ARTIFACT_PORTS = new Set(['tool', 'context', 'escalation', 'memory']);
 // ─── Graph model ──────────────────────────────────────────────────────────────
+/** An index right after a read: `[0]`, `[i]`, `?.["k"]`. */
+const INDEX_NEXT_RE = /^\s*(?:\?\.)?\[/;
+/** A read's tail when an index follows it, whatever the index: `.output.body.items[]`. */
+const INDEX_MARK = '[]';
+/** Every `$vars` read in `values`' strings, by id, with `?.` read as `.`. */
+function scopeReads(values) {
+    const reads = new Map();
+    const visit = (v) => {
+        if (typeof v === 'string') {
+            for (const m of v.matchAll(VARS_READ_RE)) {
+                const [read, id, field, rest] = m;
+                const path = field === undefined ? '' : `.${field}${rest.replace(/\?\./g, '.')}`;
+                const indexed = INDEX_NEXT_RE.test(v.slice(m.index + read.length));
+                (reads.get(id) ?? reads.set(id, []).get(id)).push(indexed ? path + INDEX_MARK : path);
+            }
+            return;
+        }
+        if (v && typeof v === 'object')
+            for (const x of Object.values(v))
+                visit(x);
+    };
+    visit(values);
+    return reads;
+}
 class Graph {
     byId = new Map();
     out = new Map();
@@ -474,8 +499,11 @@ class Graph {
      */
     accounted = new Set();
     edges;
-    constructor(nodes, edges) {
+    variables;
+    reads;
+    constructor(nodes, edges, variables) {
         this.edges = edges;
+        this.variables = variables;
         for (const n of nodes)
             this.byId.set(n.id, n);
         for (const e of edges) {
@@ -483,6 +511,11 @@ class Graph {
             (this.inc.get(e.targetNodeId) ?? this.inc.set(e.targetNodeId, []).get(e.targetNodeId)).push(e);
         }
     }
+    /** The tails this scope's inputs, outputs and updates read off `$vars.<id>`, e.g. `.output.body.current`. */
+    readsOf(id) {
+        this.reads ??= scopeReads([...[...this.byId.values()].flatMap((n) => [n.inputs, n.outputs]), this.variables?.variableUpdates]);
+        return this.reads.get(id) ?? [];
+    }
     outEdges(id) {
         return this.out.get(id) ?? [];
     }
@@ -666,6 +699,7 @@ function liftRegistered(node, impl = registeredImpl(node), graph) {
         absorb: (id, compiledId) => { runAbsorbed.set(id, compiledId); },
         outPorts: () => (graph?.outEdges(node.id) ?? []).map((e) => e.sourcePort),
         convergedFanOut: () => graph?.convergedFanOut(node.id) === true,
+        reads: () => graph?.readsOf(node.id) ?? [],
     };
     const spec = impl.deserialize(node, ctx);
     return spec === undefined ? undefined : { impl, spec };
@@ -2556,7 +2590,7 @@ function readChildStartAsStart(child, startId) {
 function emitChildFlowIn(name, child, trigger, ctx) {
     const globals = readFlowGlobals(child.variables, runStrict);
     const childCtx = {
-        graph: new Graph(child.nodes ?? [], child.edges ?? []),
+        graph: new Graph(child.nodes ?? [], child.edges ?? [], child.variables),
         flow: child,
         imp: ctx.imp,
         inputNames: new Set(globals.filter((g) => g.direction === 'in').map((g) => g.name ?? g.id)),
@@ -2721,7 +2755,7 @@ export function decompile(flow, options = {}) {
     }
     runCarried = carriedPairs(flow);
     const imp = new Imports();
-    const graph = new Graph(flow.nodes ?? [], flow.edges ?? []);
+    const graph = new Graph(flow.nodes ?? [], flow.edges ?? [], flow.variables);
     const globals = readFlowGlobals(flow.variables, runStrict);
     const inputNames = new Set(globals.filter((g) => g.direction === 'in').map((g) => g.name ?? g.id));
     // Trigger-bound globals name the node they came from; fall back to the graph's

package/dist/flow-node-type.d.ts

@@ -281,6 +281,8 @@ export interface FlowDeserializeContext {
      * the type's `exits()`, so it is `false` for any other node.
      */
     convergedFanOut(): boolean;
+    /** The tails the node's scope reads off `$vars.<nodeId>`, e.g. `.output.body.current`, `.output.body.items[]` for an indexed read. */
+    reads(): readonly string[];
 }
 /** What `print` may ask of the decompiler. Every method returns source text. */
 export interface FlowPrintContext {

package/dist/merge-cli.js

@@ -54,7 +54,7 @@ import { ensureTypeScriptRuntime } from './node-runtime.js';
 import { flowCheckOpts, openCliLibrary } from './cli-library.js';
 import { Bindings } from './bindings.js';
 import { defaultBindingsFile } from './workdir.js';
-import { baselineFromOriginal, checkEdited, classifyDrafts, compileSourceDraftTolerant } from './merge-compile.js';
+import { baselineFromOriginal, checkEdited, classifyDrafts, compileSourceDraftTolerant, findingCounts, splitUnplaced } from './merge-compile.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]';
 /**
@@ -215,19 +215,41 @@ export async function run(argv) {
     // acceptable only where merge restores the ORIGINAL node; one the author
     // changed or added gets the strict compile's refusal (#1134).
     // check()'s errors follow the same rule; its warnings are printed as compile prints them.
-    const { kept, refused } = classifyDrafts(original, edited, baseline, drafts);
+    const { kept, refused, unplaced } = classifyDrafts(original, edited, baseline, drafts);
     const checked = classifyDrafts(original, edited, baseline, diagnostics.filter((d) => d.level === 'error'));
     for (const d of diagnostics)
         if (d.level === 'warning')
             console.error(`  ⚠ [${d.code}] ${d.message}`);
     for (const d of [...kept, ...checked.kept]) {
-        console.error(`  ⚠ [DRAFT_NODE_KEPT] "${d.nodeId}" is unfinished in the original (${d.code}); it is untouched, so the original node is kept as is.`);
+        console.error(d.subflow !== undefined
+            ? `  ⚠ [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.`);
     }
-    const errors = [...refused, ...checked.refused];
+    // 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
+    // refused when it does not: then the edit introduced it (#1322). With a
+    // precompiled --baseline file there is nothing to compare against, so every
+    // one is refused, as before.
+    const baselineFindings = baselineCompile === undefined ? undefined : findingCounts([
+        ...baselineCompile.drafts,
+        ...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]) {
+        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' })),
+    ];
     if (errors.length) {
         for (const d of errors) {
-            const where = d.nodeId === '' ? 'the edited flow'
-                : d.reason === 'subflow' ? `"${d.nodeId}" is inside a subflow, which merge takes whole; finish it`
+            const where = d.reason === 'unplaced'
+                ? '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`;
             console.error(`  ✗ [${d.code}] ${where}: ${d.message}`);
         }

package/dist/merge-compile.d.ts

@@ -27,36 +27,97 @@ export declare function compileSourceDraftTolerant(file: string, opts?: Omit<Ser
  * it, as `flow decompile` does), then compile the source with draft tolerance.
  * 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>;
-/** Why merge takes a node from the edited flow, so a finding on it is an error. */
-export type TakenReason = 'edited' | 'subflow';
-/** A finding on a node merge takes from the edited flow, with the reason it takes it. */
+export declare function baselineFromOriginal(originalPath: string, opts?: Omit<SerializeOpts, 'draft'>, warn?: (message: string) => void): Promise<DraftTolerantCompile & {
+    built: BuiltFlow;
+}>;
+/**
+ * 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.
+ */
+export type TakenReason = 'edited' | 'subflow' | 'unplaced';
+/**
+ * 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
+ * node sits in a subflow the edit changed, which merge takes whole (`subflow`
+ * names it).
+ */
 export type Refused<T> = T & {
     reason: TakenReason;
+    subflow?: string;
+};
+/** A finding on a node merge restores from the original; `subflow` names the untouched subflow it sits in. */
+export type Kept<T> = T & {
+    subflow?: string;
 };
 /**
  * Sort each finding by what merge does with its node: `refused` when the node
  * comes from the edited flow (reason `edited`: the author changed or added it;
- * reason `subflow`: it sits in a subflow, which merge takes from `edited`
- * whole), `kept` when merge restores the original node.
+ * reason `subflow`: it sits in a subflow the edit changed, which merge takes
+ * whole), `kept` when merge restores the original node — a root node the edit
+ * did not touch, or any node of a subflow the edit did not touch (#1322) — and
+ * `unplaced` when the finding names no node merge knows (an unnamed End's
+ * `.return`, a flow-level finding). The caller sorts those again with
+ * {@link splitUnplaced}: one the original's own round trip reports too is
+ * printed, one the edit introduced is refused.
  *
  * For instance a Slack node with no connection that the author did not touch
  * is `kept`; the same node with a new message text is `refused` as `edited`.
  */
 export declare function classifyDrafts<T extends {
     nodeId: string;
+    subflow?: string;
 }>(original: any, edited: any, baseline: any, findings: readonly T[]): {
-    kept: T[];
+    kept: Kept<T>[];
     refused: Refused<T>[];
+    unplaced: T[];
 };
-/** A `check()` diagnostic, placed on the root node its step emitted (`''` when it names no root step). */
+/**
+ * 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
+ * subflow, which then decides how it is classified.
+ */
 export type PlacedDiagnostic = Diagnostic & {
     nodeId: string;
+    subflow?: string;
 };
 /**
  * Run `check()` on the edited source, as `compile` does, and place each
  * diagnostic on the node its step emitted in `editedFlow`, so
- * {@link classifyDrafts} can sort it. A diagnostic with no step, or a step
- * with no root node, gets nodeId `''`, which is always refused.
+ * {@link classifyDrafts} can sort it: a root step on its node (by label, then
+ * id); a step inside a subflow (`check` reports it as `<caller> › <step>`, one
+ * segment per level) on the deepest step the path resolves to, with `subflow`
+ * set to the deepest subflow on that path, which is what decides; a named End
+ * on its End node (#1322). A diagnostic with no step, or one no node answers
+ * to, gets nodeId `''`.
  */
 export declare function checkEdited(built: BuiltFlow, editedFlow: any, opts: CheckOpts): PlacedDiagnostic[];
+/** The identity of a finding for the introduced-or-not comparison: its code and message. */
+export declare function findingKey(f: {
+    code: string;
+    message: string;
+}): string;
+/** How many times each {@link findingKey} occurs, for {@link splitUnplaced}'s baseline. */
+export declare function findingCounts(findings: ReadonlyArray<{
+    code: string;
+    message: string;
+}>): Map<string, number>;
+/**
+ * Sort findings merge could not place on a node by whether the edit introduced
+ * them: `known` when the ORIGINAL's own round trip (`baseline`, the decompiled
+ * original compiled and checked, as {@link findingCounts}) reports the same
+ * code and message — once per occurrence, so a second copy of a finding the
+ * original has once is `introduced` — so the finding predates the edit and
+ * only prints; `introduced` otherwise, which is refused like any error on an
+ * edited node (#1322). With no baseline findings to compare against (a
+ * precompiled `--baseline` file), every one is `introduced`, as merge treated
+ * them before.
+ */
+export declare function splitUnplaced<T extends {
+    code: string;
+    message: string;
+}>(unplaced: readonly T[], baseline: ReadonlyMap<string, number> | undefined): {
+    known: T[];
+    introduced: T[];
+};

package/dist/merge-compile.js

@@ -13,7 +13,7 @@ import { decompile } from './decompile.js';
 import { loadBuiltFlow } from './load.js';
 import { serialize } from './serialize.js';
 import { check } from './check.js';
-import { nodesTakenFromEdited } from './merge.js';
+import { nodesTakenFromEdited, subflowsTakenFromEdited } from './merge.js';
 import { PACKAGE_NAME } from './package-name.js';
 /** Compile `built` with draft tolerance. Every other refusal still throws. */
 export function compileDraftTolerant(built, opts = {}) {
@@ -63,32 +63,62 @@ export async function baselineFromOriginal(originalPath, opts = {}, warn) {
 /**
  * Sort each finding by what merge does with its node: `refused` when the node
  * comes from the edited flow (reason `edited`: the author changed or added it;
- * reason `subflow`: it sits in a subflow, which merge takes from `edited`
- * whole), `kept` when merge restores the original node.
+ * reason `subflow`: it sits in a subflow the edit changed, which merge takes
+ * whole), `kept` when merge restores the original node — a root node the edit
+ * did not touch, or any node of a subflow the edit did not touch (#1322) — and
+ * `unplaced` when the finding names no node merge knows (an unnamed End's
+ * `.return`, a flow-level finding). The caller sorts those again with
+ * {@link splitUnplaced}: one the original's own round trip reports too is
+ * printed, one the edit introduced is refused.
  *
  * For instance a Slack node with no connection that the author did not touch
  * is `kept`; the same node with a new message text is `refused` as `edited`.
  */
 export function classifyDrafts(original, edited, baseline, findings) {
     const fromEdited = new Set(nodesTakenFromEdited(original, edited, baseline));
+    const takenSubflows = new Set(subflowsTakenFromEdited(original, edited, baseline));
     const rootIds = new Set((edited?.nodes ?? []).map((n) => n.id));
+    /** A subflow's own node ids → the key (the calling step) of the subflow holding them. */
+    const subflowOfNode = new Map();
+    for (const [key, sf] of Object.entries(edited?.subflows ?? {})) {
+        for (const n of sf?.nodes ?? [])
+            subflowOfNode.set(n.id, key);
+    }
     const kept = [];
     const refused = [];
+    const unplaced = [];
     for (const f of findings) {
-        if (!rootIds.has(f.nodeId))
-            refused.push({ ...f, reason: 'subflow' });
-        else if (fromEdited.has(f.nodeId))
-            refused.push({ ...f, reason: 'edited' });
-        else
-            kept.push(f);
+        // A finding inside a subflow — placed on the calling step by `checkEdited`
+        // (`subflow` set), or a draft on one of the subflow's own nodes — is judged
+        // by the SUBFLOW: taken whole when the edit changed it, else the original's.
+        const subflow = f.subflow ?? subflowOfNode.get(f.nodeId);
+        if (subflow !== undefined) {
+            if (takenSubflows.has(subflow))
+                refused.push({ ...f, reason: 'subflow', subflow });
+            else
+                kept.push({ ...f, subflow });
+        }
+        else if (rootIds.has(f.nodeId)) {
+            if (fromEdited.has(f.nodeId))
+                refused.push({ ...f, reason: 'edited' });
+            else
+                kept.push(f);
+        }
+        else {
+            unplaced.push(f);
+        }
     }
-    return { kept, refused };
+    return { kept, refused, unplaced };
 }
 /**
  * Run `check()` on the edited source, as `compile` does, and place each
  * diagnostic on the node its step emitted in `editedFlow`, so
- * {@link classifyDrafts} can sort it. A diagnostic with no step, or a step
- * with no root node, gets nodeId `''`, which is always refused.
+ * {@link classifyDrafts} can sort it: a root step on its node (by label, then
+ * id); a step inside a subflow (`check` reports it as `<caller> › <step>`, one
+ * segment per level) on the deepest step the path resolves to, with `subflow`
+ * set to the deepest subflow on that path, which is what decides; a named End
+ * on its End node (#1322). A diagnostic with no step, or one no node answers
+ * to, gets nodeId `''`.
  */
 export function checkEdited(built, editedFlow, opts) {
     const byStep = new Map();
@@ -98,8 +128,75 @@ export function checkEdited(built, editedFlow, opts) {
             byStep.set(label, n.id);
     }
     const ids = new Set((editedFlow?.nodes ?? []).map((n) => n.id));
-    return check(built, opts).map((d) => ({
-        ...d,
-        nodeId: d.step === undefined ? '' : byStep.get(d.step) ?? (ids.has(d.step) ? d.step : ''),
-    }));
+    /** `name` as a node id in `nodes`: by label, then by id; `''` when neither answers. */
+    const resolveIn = (nodes, name) => {
+        const byLabel = nodes.find((n) => n?.display?.label === name);
+        if (byLabel)
+            return byLabel.id;
+        return nodes.some((n) => n?.id === name) ? name : '';
+    };
+    // `subflows` is flat, keyed by each caller's id at every depth, and check
+    // prefixes a finding at every level (`outer › inner › x`): the subflow that
+    // decides is the DEEPEST one on the path, since merge keeps or takes each
+    // subflow on its own (an edit inside `inner` leaves `outer` kept).
+    const place = (step) => {
+        if (step === undefined)
+            return { nodeId: '' };
+        const segments = step.split(SUBFLOW_STEP_SEPARATOR);
+        let scope = editedFlow?.nodes ?? [];
+        let subflow;
+        let nodeId = '';
+        for (const [i, segment] of segments.entries()) {
+            const id = i === 0 ? (byStep.get(segment) ?? (ids.has(segment) ? segment : '')) : resolveIn(scope, segment);
+            if (id === '')
+                break;
+            nodeId = id;
+            const child = i < segments.length - 1 ? editedFlow?.subflows?.[id] : undefined;
+            if (child === undefined)
+                break;
+            subflow = id;
+            scope = child.nodes ?? [];
+        }
+        return subflow !== undefined ? { nodeId: nodeId === '' ? subflow : nodeId, subflow } : { nodeId };
+    };
+    return check(built, opts).map((d) => ({ ...d, ...place(d.step) }));
+}
+/** The identity of a finding for the introduced-or-not comparison: its code and message. */
+export function findingKey(f) {
+    return `${f.code}\n${f.message}`;
+}
+/** How many times each {@link findingKey} occurs, for {@link splitUnplaced}'s baseline. */
+export function findingCounts(findings) {
+    const counts = new Map();
+    for (const f of findings)
+        counts.set(findingKey(f), (counts.get(findingKey(f)) ?? 0) + 1);
+    return counts;
+}
+/**
+ * Sort findings merge could not place on a node by whether the edit introduced
+ * them: `known` when the ORIGINAL's own round trip (`baseline`, the decompiled
+ * original compiled and checked, as {@link findingCounts}) reports the same
+ * code and message — once per occurrence, so a second copy of a finding the
+ * original has once is `introduced` — so the finding predates the edit and
+ * only prints; `introduced` otherwise, which is refused like any error on an
+ * edited node (#1322). With no baseline findings to compare against (a
+ * precompiled `--baseline` file), every one is `introduced`, as merge treated
+ * them before.
+ */
+export function splitUnplaced(unplaced, baseline) {
+    const known = [];
+    const introduced = [];
+    const left = new Map(baseline ?? []);
+    for (const f of unplaced) {
+        const n = left.get(findingKey(f)) ?? 0;
+        if (n > 0) {
+            left.set(findingKey(f), n - 1);
+            known.push(f);
+        }
+        else
+            introduced.push(f);
+    }
+    return { known, introduced };
 }
+/** How `check` joins a subflow's calling step and the step inside it in a diagnostic's `step`. */
+const SUBFLOW_STEP_SEPARATOR = ' › ';

package/dist/merge.d.ts

@@ -181,6 +181,16 @@ export interface MergeOptions {
  * `original`, the answer is `[]` — a no-edit merge keeps them all.
  */
 export declare function nodesTakenFromEdited(original: AnyFlow, edited: AnyFlow, baseline?: AnyFlow): string[];
+/**
+ * The keys of the subflows {@link mergeFlow} takes from `edited` rather than
+ * restoring from `original`: every subflow that is new, that the original does
+ * not have, or that differs from its `baseline` counterpart in any way the
+ * author can edit — a node's inputs, output sources or label, an edge, the
+ * scope's `variables` or `layout` (`subflowUnchanged`, #1322). With no
+ * baseline, that is every subflow. A kept subflow is the original's whole: its
+ * nodes, edges, variables and layout.
+ */
+export declare function subflowsTakenFromEdited(original: AnyFlow, edited: AnyFlow, baseline?: AnyFlow): string[];
 export declare function mergeFlow(original: AnyFlow, edited: AnyFlow, options?: MergeOptions): AnyFlow;
 /**
  * `mergeFlow`, plus the agent sidecar files the merged flow needs written beside

package/dist/merge.js

@@ -138,6 +138,68 @@ export function nodesTakenFromEdited(original, edited, baseline) {
     const baseNodes = byId(baseline?.nodes);
     return (edited.nodes ?? []).filter((e) => !isKept(e, origNodes, baseNodes, baseline)).map((e) => e.id);
 }
+/**
+ * The keys of the subflows {@link mergeFlow} takes from `edited` rather than
+ * restoring from `original`: every subflow that is new, that the original does
+ * not have, or that differs from its `baseline` counterpart in any way the
+ * author can edit — a node's inputs, output sources or label, an edge, the
+ * scope's `variables` or `layout` (`subflowUnchanged`, #1322). With no
+ * baseline, that is every subflow. A kept subflow is the original's whole: its
+ * nodes, edges, variables and layout.
+ */
+export function subflowsTakenFromEdited(original, edited, baseline) {
+    return Object.keys(edited.subflows ?? {}).filter((key) => {
+        const orig = original.subflows?.[key];
+        const base = baseline?.subflows?.[key];
+        return !baseline || orig === undefined || base === undefined
+            || !subflowUnchanged(edited.subflows[key], base);
+    });
+}
+/** A node's canvas label, when it has one. */
+const labelOf = (n) => n?.display?.label;
+/**
+ * Whether an edited subflow equals its baseline: the same node ids, each node
+ * unchanged (`nodeUnchanged`) and under the same label, the same edges by
+ * their endpoints and handles (ids are compile's own), and the same
+ * `variables` and `layout` byte for byte. The scope's variables carry what the
+ * nodes do not — a step's `{ updates }` row, a child `.input()` type, a `.var()`
+ * default — and a kept subflow is the original's whole, so any of them changing
+ * has to make the subflow a taken one.
+ */
+function subflowUnchanged(e, b) {
+    const eNodes = byId(e.nodes);
+    const bNodes = byId(b.nodes);
+    if (eNodes.size !== bNodes.size)
+        return false;
+    for (const [id, n] of eNodes) {
+        const base = bNodes.get(id);
+        if (!nodeUnchanged(n, base) || labelOf(n) !== labelOf(base))
+            return false;
+    }
+    if (JSON.stringify(e.variables ?? null) !== JSON.stringify(b.variables ?? null))
+        return false;
+    // `layout.edges` is keyed by edge id, and ids come from one file-wide
+    // counter: a step added before the call shifts every id in the subflow
+    // without touching it. So routes are compared by the endpoints the id names
+    // (as the edges themselves are), and `layout.nodes` as it is.
+    if (JSON.stringify(layoutByEndpoints(e)) !== JSON.stringify(layoutByEndpoints(b)))
+        return false;
+    const eEdges = (e.edges ?? []).map(edgeKey).sort();
+    const bEdges = (b.edges ?? []).map(edgeKey).sort();
+    return eEdges.length === bEdges.length && eEdges.every((k, i) => k === bEdges[i]);
+}
+/** `<source>@<port>-><target>@<port>`: an edge's identity apart from its id. */
+const edgeKey = (x) => `${x.sourceNodeId}@${x.sourcePort}->${x.targetNodeId}@${x.targetPort}`;
+/** A scope's layout with its `edges` re-keyed by endpoints, so an id shift does not read as a change. */
+function layoutByEndpoints(sf) {
+    const layout = sf.layout;
+    if (!layout || typeof layout !== 'object')
+        return layout ?? null;
+    const byId = new Map((sf.edges ?? []).map((x) => [x.id, edgeKey(x)]));
+    const { edges, ...rest } = layout;
+    const routes = Object.entries(edges ?? {}).map(([id, route]) => [byId.get(id) ?? id, route]).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    return { ...rest, edges: Object.fromEntries(routes) };
+}
 /**
  * Whether merge restores `e`'s ORIGINAL node instead of taking `e`: there is a
  * baseline, the original has the node, and `e` equals its baseline counterpart.
@@ -343,15 +405,44 @@ function mergeFlowFindings(original, edited, options) {
     result.nodes = finalNodes;
     // Nodes present in the original but absent from `edited` were deleted by the
     // user; they are simply not carried over.
-    // ── Subflows: the edited flow is authoritative (the user's graph). ──
+    // ── Subflows: the edited flow is authoritative (the user's graph) — except a
+    //    subflow the edit never touched, which is the original's, whole: the same
+    //    `kept` rule as a root node, one level down (#1322). Before, every subflow
+    //    came from the edited compile, so a no-edit round trip rewrote each one
+    //    in the SDK's shape, and a check error inside one refused the write. ──
     result.subflows = jsonClone(edited.subflows ?? {});
-    // A subflow is taken from `edited` whole, so an embedded agent inside one
-    // would flip to the edited shell even with no edit. Keep it embedded too.
+    const takenSubflows = new Set(subflowsTakenFromEdited(original, edited, options.baseline));
+    for (const key of Object.keys(result.subflows)) {
+        if (!takenSubflows.has(key))
+            result.subflows[key] = jsonClone(original.subflows[key]);
+    }
+    // A kept subflow carries the original's edge ids and a taken one the
+    // recompile's, from two different counters, so a taken subflow's edges are
+    // renumbered against every id a kept one holds (and against the taken ones
+    // before it), the way the root's are below.
+    const idScopes = Object.entries(result.subflows).filter(([k]) => !takenSubflows.has(k)).map(([, sf]) => sf);
+    for (const key of Object.keys(result.subflows)) {
+        if (!takenSubflows.has(key))
+            continue;
+        const sf = result.subflows[key];
+        const { edges: renumbered, renamed } = withFileUniqueEdgeIds(sf.edges ?? [], idScopes);
+        sf.edges = renumbered;
+        // A route in `layout.edges` is keyed by the edge's id, so it follows the rename.
+        const layout = sf.layout;
+        if (renamed.size > 0 && layout?.edges) {
+            layout.edges = Object.fromEntries(Object.entries(layout.edges).map(([id, route]) => [renamed.get(id) ?? id, route]));
+        }
+        idScopes.push(sf);
+    }
+    // A subflow taken from `edited` whole would flip an embedded agent inside it
+    // to the edited shell even with no edit to that node. Keep it embedded too.
     // This runs before the source fix-up below: it compares each node with the
-    // baseline to tell which ones the author edited.
-    const subflowEdited = keepEmbeddedAgentsInSubflows(original, result.subflows, options.baseline);
+    // baseline to tell which ones the author edited. A kept subflow is the
+    // original's already, so neither fix-up looks at it.
+    const takenEntries = Object.fromEntries(Object.entries(result.subflows).filter(([key]) => takenSubflows.has(key)));
+    const subflowEdited = keepEmbeddedAgentsInSubflows(original, takenEntries, options.baseline);
     if (options.baseline)
-        keepOriginalSourcesInSubflows(original, result.subflows, options.baseline);
+        keepOriginalSourcesInSubflows(original, takenEntries, options.baseline);
     const subflowScopes = Object.values(result.subflows);
     // ── Variables: the same delta as nodes, per entry — what the author did not
     //    change stays the original's, so compile's own spellings (an added
@@ -380,7 +471,7 @@ function mergeFlowFindings(original, edited, options) {
     //    document (it drops one element or crashes). Only an edge with no id, or
     //    one already taken elsewhere in the file, gets a fresh id, from ids unused
     //    anywhere in the file. ──
-    result.edges = withFileUniqueEdgeIds(edited.edges ?? [], subflowScopes);
+    result.edges = withFileUniqueEdgeIds(edited.edges ?? [], subflowScopes).edges;
     // ── Placement: a node the edit ADDED has no original position. Unless the
     //    author set one, it has compile's placeholder, an emission-index slot
     //    that can land on an original node. Put it next to its predecessor,
@@ -511,11 +602,16 @@ function withFileUniqueEdgeIds(edges, subflows) {
             n++;
         return `edge_${n++}`;
     };
-    return edges.map((e) => {
+    /** Old id → new id, for every edge that had to move (a route keyed by the old id follows it). */
+    const renamed = new Map();
+    const out = edges.map((e) => {
         const id = typeof e.id === 'string' && !taken.has(e.id) ? e.id : fresh();
+        if (typeof e.id === 'string' && id !== e.id)
+            renamed.set(e.id, id);
         taken.add(id);
         return { ...jsonClone(e), id };
     });
+    return { edges: out, renamed };
 }
 /** The `nodeType@version` identity of a definition row or of a node's type pin. */
 function defKey(nodeType, version) {

package/dist/nodes/http/flow/node-type.js

@@ -245,6 +245,27 @@ function liftReturns(node) {
         .map(([k, v]) => [k, v.type]);
     return entries.length ? Object.fromEntries(entries) : undefined;
 }
+/** A read of a body field: the field, then whatever the read goes on to. */
+const BODY_READ_RE = /^\.output\.body\.([A-Za-z0-9_]+)(.*)$/;
+/**
+ * The `returns` a node with no body schema needs for the body fields its flow
+ * already reads, so the source decompile prints compiles. A field read further
+ * in (`body.current.time`) is an `object`; a field read whole is a `string`, the
+ * type the check suggests. Undefined when nothing reads the body.
+ */
+function returnsFromReads(reads) {
+    const fields = new Map();
+    for (const read of reads) {
+        const m = BODY_READ_RE.exec(read);
+        if (!m)
+            continue;
+        if (m[2] !== '')
+            fields.set(m[1], 'object');
+        else if (!fields.has(m[1]))
+            fields.set(m[1], 'string');
+    }
+    return fields.size ? Object.fromEntries(fields) : undefined;
+}
 /**
  * Invert an HTTP node. The plain node keeps its request at the top level
  * (`url` / `method` / `headers` / `queryParams` / `body` / `contentType`); the
@@ -275,7 +296,7 @@ function liftHttp(node, ctx, managed) {
         throw new Error(`decompile: expected a number, got ${JSON.stringify(inputs.retryCount)}.`);
     }
     const branchRows = Array.isArray(inputs.branches) ? inputs.branches : [];
-    const returns = liftReturns(node);
+    const returns = liftReturns(node) ?? returnsFromReads(ctx.reads());
     const spec = {
         url: value(req.url ?? ''),
         ...(text(req.method) !== undefined && req.method !== 'GET' ? { method: req.method } : {}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.44.2",
+  "version": "6.44.4",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -93,5 +93,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "7afed05cfe5a6856deb6fe7984a5cf2b31a2dd20"
+  "gitref": "cbc51e1db2b0ffabe85f841dee73f5a6301192d2"
 }