@uipath/maestro-builder-sdk 6.61.1 → 6.62.0

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,34 +1,44 @@
-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;
 }>;
 /**

package/dist/merge-compile.js

@@ -1,11 +1,13 @@
 /**
  * merge-compile — the compiles `flow merge --baseline-from` runs itself (#1134).
  *
- * 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 +15,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,7 +48,8 @@ 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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.61.1",
+  "version": "6.62.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": "2a6094aa49f4cbf18cb309ba93c33573f3e1f226"
 }