@uipath/maestro-builder-sdk 6.27.1 → 6.28.0

package/dist/cli/commands/flow.js

@@ -104,11 +104,14 @@ export function registerFlowCommands(program) {
     });
     flow.command('merge')
         .description('Merge an edited flow with its original artifact.')
-        .argument('<edited>', 'edited .flow path')
+        .argument('<edited>', 'edited .flow path, or the edited .flow.ts source (merge compiles it, tolerating untouched draft nodes)')
         .option('--original <file>', '(required) original .flow path, the artifact to merge into')
         .option('-o, --output <file>', 'merged output path')
         .option('--baseline <file>', 'compiled pristine decompile')
-        .option('--strict', 'refuse when the no-edit round trip (--baseline) differs from the original')
+        .option('--baseline-from <file>', 'build the baseline from this original .flow (decompile + compile, tolerating draft nodes) instead of --baseline')
+        .option('--library <dir>', 'connector library, for compiling with --baseline-from or a .flow.ts edited source')
+        .option('--bindings <file>', 'bindings.json, for the same compiles')
+        .option('--strict', 'refuse when the no-edit round trip (the baseline) differs from the original')
         .allowExcessArguments()
         .action(async (_edited, options, command) => {
         const pair = namedOrLegacySecond(command, {
@@ -121,6 +124,9 @@ export function registerFlowCommands(program) {
         const argv = [original, edited];
         addValue(argv, '-o', options.output);
         addValue(argv, '--baseline', options.baseline);
+        addValue(argv, '--baseline-from', options.baselineFrom);
+        addValue(argv, '--library', options.library);
+        addValue(argv, '--bindings', options.bindings);
         if (options.strict)
             argv.push('--strict');
         await invoke('flow merge', () => import('../../merge-cli.js'), argv);

package/dist/core/connector-inputs.d.ts

@@ -37,6 +37,12 @@ export interface ConnectorInputOpts {
     lookups?: Readonly<Record<string, LookupSpec>>;
     /** `ignore` skips an unresolved lookup instead of refusing it — what `check` wants. */
     unresolvedLookups?: 'error' | 'ignore';
+    /**
+     * Receives a missing REQUIRED input instead of refusing it — the draft
+     * tolerance of a merge-owned compile (#1134). Every other input error still
+     * refuses.
+     */
+    onMissingRequired?: (message: string) => void;
 }
 /** Flow's dialect, re-exported so `serialize.ts` need not reach past this module. */
 export { FLOW_EXPR_DIALECT } from './connector-checks.js';

package/dist/core/connector-inputs.js

@@ -116,8 +116,13 @@ export function buildConnectorInputs(rc, inputs, opts) {
             // not know what to put in it than because they forgot it exists: name the
             // id it sends and the helper that finds one, so "(string)" is not read as
             // "any string" — an e-mail into `fields.reporter.id` is exactly that misreading.
-            if (f.required)
-                errs.push(`missing required input "${f.name}" (${f.type ?? 'value'})${missingLookupHint(f.name, lookups[f.name], rc, dialect.descriptors)}`);
+            if (f.required) {
+                const message = `missing required input "${f.name}" (${f.type ?? 'value'})${missingLookupHint(f.name, lookups[f.name], rc, dialect.descriptors)}`;
+                if (opts.onMissingRequired)
+                    opts.onMissingRequired(message);
+                else
+                    errs.push(message);
+            }
             continue;
         }
         // An unresolved lookup is swapped for its recorded id, or reported. It is

package/dist/merge-cli.d.ts

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
 import { type CliExitCode } from './cli-run.js';
-export declare function run(argv: string[]): CliExitCode;
+export declare function run(argv: string[]): Promise<CliExitCode>;

package/dist/merge-cli.js

@@ -3,7 +3,13 @@
  * merge-cli — merge an edited flow back into the original `.flow` (bin `flow-merge`)
  *
  * Usage:
- *   flow-merge <original.flow> <edited.flow> [-o merged.flow] [--baseline <baseline.flow>] [--strict]
+ *   flow-merge <original.flow> <edited.flow | Edited.flow.ts> [-o merged.flow]
+ *              [--baseline <baseline.flow> | --baseline-from <original.flow>] [--strict]
+ *
+ * `--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.
  *
  * `edited.flow` is compile(decompile(original) after your edits). `--baseline`
  * is compile(decompile(original)) BEFORE any edit — supplying it enables the
@@ -19,27 +25,88 @@ import { readFileSync } from 'node:fs';
 import { basename, resolve } from 'node:path';
 import { MergeRefusedError, mergeFlow } from './merge.js';
 import { flagValue, runWhenInvokedDirectly } from './cli-run.js';
-export function run(argv) {
+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';
+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]';
+export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
-        console.error('usage: flow-merge <original.flow> <edited.flow> [-o merged.flow] [--baseline <baseline.flow>] [--strict]');
+        console.error(USAGE);
         return 2;
     }
-    const flags = new Set(['-o', '--baseline']);
+    const flags = new Set(['-o', '--baseline', '--baseline-from', '--library', '--bindings', '--connectors-local']);
     const positionals = argv.filter((a, i) => !flags.has(a) && !flags.has(argv[i - 1]) && !a.startsWith('-'));
     const [originalPath, editedPath] = positionals;
     if (!originalPath || !editedPath) {
         console.error('flow-merge: need <original.flow> and <edited.flow>');
         return 2;
     }
-    const original = JSON.parse(readFileSync(originalPath, 'utf8'));
-    const edited = JSON.parse(readFileSync(editedPath, 'utf8'));
     const baselinePath = flagValue(argv, '--baseline');
-    const baseline = baselinePath ? JSON.parse(readFileSync(baselinePath, 'utf8')) : undefined;
+    const baselineFrom = flagValue(argv, '--baseline-from');
+    if (baselinePath && baselineFrom) {
+        console.error('flow-merge: pass --baseline or --baseline-from, not both');
+        return 2;
+    }
+    const editedIsSource = /\.ts$/.test(editedPath);
+    // Merge compiles a side itself only for --baseline-from or a .flow.ts edited
+    // source; both load TypeScript, so both need the type-stripping runtime.
+    if (baselineFrom || editedIsSource)
+        ensureTypeScriptRuntime();
+    const library = baselineFrom || editedIsSource ? openCliLibrary(argv) : undefined;
+    const bindings = baselineFrom || editedIsSource ? new Bindings(flagValue(argv, '--bindings') ?? defaultBindingsFile()) : undefined;
+    const compileOpts = { library, bindings };
+    const original = JSON.parse(readFileSync(originalPath, 'utf8'));
+    let drafts = [];
+    let diagnostics = [];
+    let edited;
+    if (editedIsSource) {
+        // The edited source gets what `compile` gives it: check() with the same
+        // options, and the serializer's warnings (CONNECTION_STUB, ...) printed.
+        const compiled = await compileSourceDraftTolerant(resolve(editedPath), {
+            ...compileOpts,
+            warn: (w) => console.error(`  ⚠ [${w.code}] ${w.message}`),
+        });
+        edited = compiled.flow;
+        drafts = compiled.drafts;
+        diagnostics = checkEdited(compiled.built, edited, flowCheckOpts(library, bindings));
+    }
+    else {
+        edited = JSON.parse(readFileSync(editedPath, 'utf8'));
+    }
+    const baseline = baselineFrom
+        ? (await baselineFromOriginal(baselineFrom, compileOpts, (m) => console.error(`flow-merge: decompile warning: ${m}`))).flow
+        : baselinePath ? JSON.parse(readFileSync(baselinePath, 'utf8')) : undefined;
     const strict = argv.includes('--strict');
     if (strict && !baseline) {
-        console.error('flow-merge: --strict compares the no-edit round trip with the original; pass --baseline <baseline.flow>');
+        console.error('flow-merge: --strict compares the no-edit round trip with the original; pass --baseline <baseline.flow> or --baseline-from <original.flow>');
         return 2;
     }
+    // A draft node (no connection, an empty required input, no object) is
+    // 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 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.`);
+    }
+    const errors = [...refused, ...checked.refused];
+    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`
+                    : `"${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.`);
+        return 1;
+    }
     let merged;
     try {
         merged = mergeFlow(original, edited, {

package/dist/merge-compile.d.ts

@@ -0,0 +1,55 @@
+import { type DraftFinding, type SerializeOpts } from './serialize.js';
+import { type CheckOpts, type Diagnostic } from './check.js';
+import type { BuiltFlow } from './flow-sdk.js';
+/** A compile's flow and the draft refusals it reported instead of throwing. */
+export interface DraftTolerantCompile {
+    flow: any;
+    drafts: DraftFinding[];
+}
+/** Compile `built` with draft tolerance. Every other refusal still throws. */
+export declare function compileDraftTolerant(built: BuiltFlow, opts?: Omit<SerializeOpts, 'draft'>): 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 & {
+    built: BuiltFlow;
+}>;
+/**
+ * The baseline of `originalPath`: decompile it (reading agent sidecars beside
+ * 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 type Refused<T> = T & {
+    reason: TakenReason;
+};
+/**
+ * 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.
+ *
+ * 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;
+}>(original: any, edited: any, baseline: any, findings: readonly T[]): {
+    kept: T[];
+    refused: Refused<T>[];
+};
+/** A `check()` diagnostic, placed on the root node its step emitted (`''` when it names no root step). */
+export type PlacedDiagnostic = Diagnostic & {
+    nodeId: 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.
+ */
+export declare function checkEdited(built: BuiltFlow, editedFlow: any, opts: CheckOpts): PlacedDiagnostic[];

package/dist/merge-compile.js

@@ -0,0 +1,104 @@
+/**
+ * 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.
+ */
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+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 { PACKAGE_NAME } from './package-name.js';
+/** Compile `built` with draft tolerance. Every other refusal still throws. */
+export function compileDraftTolerant(built, opts = {}) {
+    const drafts = [];
+    const flow = serialize(built, { ...opts, draft: (f) => drafts.push(f) });
+    return { flow, drafts };
+}
+/**
+ * Load a `.flow.ts` source and compile it with draft tolerance.
+ * The caller has already called `ensureTypeScriptRuntime()`.
+ */
+export async function compileSourceDraftTolerant(file, opts = {}) {
+    const built = await loadBuiltFlow(file);
+    return { ...compileDraftTolerant(built, opts), built };
+}
+/**
+ * The baseline of `originalPath`: decompile it (reading agent sidecars beside
+ * it, as `flow decompile` does), then compile the source with draft tolerance.
+ * The source goes to a temporary directory that is removed afterwards.
+ */
+export async function baselineFromOriginal(originalPath, opts = {}, warn) {
+    const original = JSON.parse(readFileSync(originalPath, 'utf8'));
+    const source = decompile(original, {
+        importSpecifier: PACKAGE_NAME,
+        warn,
+        readSidecar: (relativePath) => {
+            try {
+                return readFileSync(join(dirname(resolve(originalPath)), relativePath), 'utf8');
+            }
+            catch {
+                return undefined;
+            }
+        },
+    });
+    const dir = mkdtempSync(join(tmpdir(), 'flow-merge-baseline-'));
+    try {
+        writeFileSync(join(dir, 'package.json'), '{"type":"module"}\n');
+        const file = join(dir, 'Baseline.flow.ts');
+        writeFileSync(file, source);
+        return await compileSourceDraftTolerant(file, opts);
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+/**
+ * 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.
+ *
+ * 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 rootIds = new Set((edited?.nodes ?? []).map((n) => n.id));
+    const kept = [];
+    const refused = [];
+    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);
+    }
+    return { kept, refused };
+}
+/**
+ * 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.
+ */
+export function checkEdited(built, editedFlow, opts) {
+    const byStep = new Map();
+    for (const n of editedFlow?.nodes ?? []) {
+        const label = n?.display?.label;
+        if (typeof label === 'string' && !byStep.has(label))
+            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 : ''),
+    }));
+}

package/dist/merge.d.ts

@@ -152,4 +152,13 @@ export interface MergeOptions {
      */
     strict?: boolean;
 }
+/**
+ * The ids of the root nodes {@link mergeFlow} takes from `edited` rather than
+ * restoring from `original`: every node that is new, or that differs from its
+ * `baseline` counterpart. With no baseline, that is every node.
+ *
+ * For instance, with a baseline equal to `edited` and every node present in
+ * `original`, the answer is `[]` — a no-edit merge keeps them all.
+ */
+export declare function nodesTakenFromEdited(original: AnyFlow, edited: AnyFlow, baseline?: AnyFlow): string[];
 export declare function mergeFlow(original: AnyFlow, edited: AnyFlow, options?: MergeOptions): AnyFlow;

package/dist/merge.js

@@ -97,6 +97,27 @@ function nodeUnchanged(a, b) {
         return false;
     return JSON.stringify(a.inputs ?? {}) === JSON.stringify(b.inputs ?? {});
 }
+/**
+ * The ids of the root nodes {@link mergeFlow} takes from `edited` rather than
+ * restoring from `original`: every node that is new, or that differs from its
+ * `baseline` counterpart. With no baseline, that is every node.
+ *
+ * For instance, with a baseline equal to `edited` and every node present in
+ * `original`, the answer is `[]` — a no-edit merge keeps them all.
+ */
+export function nodesTakenFromEdited(original, edited, baseline) {
+    const origNodes = byId(original.nodes);
+    const baseNodes = byId(baseline?.nodes);
+    return (edited.nodes ?? []).filter((e) => !isKept(e, origNodes, baseNodes, baseline)).map((e) => e.id);
+}
+/**
+ * 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.
+ * {@link mergeFlow}'s node loop and {@link nodesTakenFromEdited} both ask this.
+ */
+function isKept(e, origNodes, baseNodes, baseline) {
+    return !!baseline && origNodes.has(e.id) && nodeUnchanged(e, baseNodes.get(e.id));
+}
 /**
  * Give an edited node the original's position, by id.
  *
@@ -132,7 +153,7 @@ export function mergeFlow(original, edited, options = {}) {
     const finalNodes = [];
     for (const e of edited.nodes ?? []) {
         const orig = origNodes.get(e.id);
-        if (options.baseline && orig && nodeUnchanged(e, baseNodes.get(e.id))) {
+        if (isKept(e, origNodes, baseNodes, options.baseline) && orig) {
             // Untouched by the user (equal to the faithful baseline) → keep the
             // original node exactly, placeholder-safe.
             finalNodes.push(jsonClone(orig));

package/dist/serialize.d.ts

@@ -1,6 +1,7 @@
 import type { DefinitionReference } from './core/node-classes.js';
 import type { BuiltFlow } from './flow-sdk.js';
 import type { Library } from './library.js';
+import { type BindingRefusalCode } from './core/binding-messages.js';
 import type { Bindings } from './bindings.js';
 import { connectorInputErrors as coreConnectorInputErrors } from './core/connector-inputs.js';
 /**
@@ -47,6 +48,18 @@ export interface SerializeWarning {
     code: string;
     message: string;
 }
+/** A required connector input left empty — the one draft code with no error class of its own. */
+export declare const CONNECTOR_INPUT_MISSING = "CONNECTOR_INPUT_MISSING";
+/** The refusals a draft-tolerant compile reports instead of throwing. */
+export type DraftCode = BindingRefusalCode | typeof CONNECTOR_INPUT_MISSING | 'CONNECTOR_OBJECT_REQUIRED';
+/** A refusal a draft-tolerant compile reported instead of throwing (see {@link SerializeOpts.draft}). */
+export interface DraftFinding {
+    /** The emitted node's id. */
+    nodeId: string;
+    code: DraftCode;
+    /** The sentence the strict compile refuses with. */
+    message: string;
+}
 export interface SerializeOpts {
     library?: Library;
     bindings?: Bindings;
@@ -56,6 +69,19 @@ export interface SerializeOpts {
      * hears nothing, which keeps `serialize()` silent in tests and libraries.
      */
     warn?: (warning: SerializeWarning) => void;
+    /**
+     * Draft tolerance, for a compile whose output only `merge` reads (#1134).
+     *
+     * A canvas flow often holds DRAFT nodes — a connector with no connection, an
+     * empty required input, a generic operation with no object — which the
+     * canvas saves and compile refuses. In a brownfield merge an untouched node
+     * is restored from the original anyway, so refusing it only blocks the edit.
+     * When this callback is given, those three refusals are reported here, with
+     * the node's id, and the node is emitted with what it has; `merge` then
+     * refuses any such node it would take from the edited flow. Absent (every
+     * ordinary compile), behaviour is unchanged.
+     */
+    draft?: (finding: DraftFinding) => void;
     /**
      * Filled in by `serialize` with the extra files the flow needs beside the
      * `.flow`, relative to it: one `<source>/agent.json` per inline agent, plus a

package/dist/serialize.js

@@ -20,6 +20,7 @@ import { stepExits } from './flow-step-exits.js';
 import { resolveVersionCarried } from './core/nodes/versioned.js';
 import { indexCarriedDefinitions } from './core/carried-definitions.js';
 import { FORM_FIELD_JSON_TYPE } from './core/form-field-type.js';
+import { ConnectorResolveError } from './core/library.js';
 import { connectionConnectors } from './bindings-v2.js';
 import { BindingRefusal, GUID_RE, bindingLabelRefusal, bindingMissingMessage, missingBindingLabels } from './core/binding-messages.js';
 import { ByoaRefusal, byoaUnverified } from './core/byoa.js';
@@ -2999,6 +3000,8 @@ function scheduleInputs(inputs, nodeId) {
 function outcomeId(name, index) {
     return outcomeSlug(name, index);
 }
+/** A required connector input left empty — the one draft code with no error class of its own. */
+export const CONNECTOR_INPUT_MISSING = 'CONNECTOR_INPUT_MISSING';
 /**
  * `serialize`, plus the extra files the flow needs on disk beside it.
  *
@@ -4958,20 +4961,67 @@ export function serialize(built, opts = {}) {
         if (spec.kind === 'connector') {
             if (!opts.library)
                 throw new Error(`connector "${step.name}" needs a library (pass --library / set $FLOW_SDK_LIBRARY_JSON).`);
-            const rc = opts.library.resolve(spec.key, spec.action, spec.version, spec.object);
+            let rc;
+            try {
+                rc = opts.library.resolve(spec.key, spec.action, spec.version, spec.object);
+            }
+            catch (error) {
+                if (!opts.draft || !(error instanceof ConnectorResolveError) || error.code !== 'CONNECTOR_OBJECT_REQUIRED')
+                    throw error;
+                // A generic operation saved before its object was picked has no
+                // definition to emit against. Draft tolerance emits a stable stand-in
+                // under the node's id; merge restores the original when it is untouched
+                // and refuses it otherwise.
+                const id = stepUid(scope, step.name);
+                opts.draft({ nodeId: id, code: error.code, message: error.message });
+                // It leaves on the port every connector action leaves on, so the
+                // no-edit round trip rewires nothing. Its inputs carry what the author
+                // wrote, so an edit to the node (an input, a connection) shows up as a
+                // change and merge refuses it instead of restoring the original.
+                const type = `uipath.connector.${spec.key}.${spec.action}`;
+                scope.nodes.push({
+                    id, type, typeVersion: spec.version ?? '1.0.0',
+                    ...(parentId ? { parentId } : {}), display: { label: step.name },
+                    inputs: {
+                        draft: true,
+                        spec: renderDeep(spec.inputs ?? {}, scope.rename),
+                        ...(spec.connection !== undefined ? { connection: spec.connection } : {}),
+                        ...(spec.folder !== undefined ? { folder: spec.folder } : {}),
+                    },
+                });
+                for (const t of tails)
+                    addEdge(scope, t, id);
+                return [{ node: id, port: successPort(type) }];
+            }
             const id = stepUid(scope, step.name);
             const node = makeNode(rc.nodeType, id, step.name, { parentId, requestedVersion: step.options?.version, def: rc.v1def });
             declareListOutputType(node, rc);
-            requireBindingPair(`connector "${step.name}"`, spec, { key: spec.key, action: spec.action });
+            // A draft that names no connection gets no binding rows either: there
+            // is nothing to bind, and rows with an empty resourceKey would leak into
+            // the merged file through merge's bindings union.
+            let unbound = false;
+            try {
+                requireBindingPair(`connector "${step.name}"`, spec, { key: spec.key, action: spec.action });
+            }
+            catch (error) {
+                if (!opts.draft || !(error instanceof BindingRefusal))
+                    throw error;
+                opts.draft({ nodeId: id, code: error.code, message: error.message });
+                unbound = true;
+            }
             const conn = resolveBinding(opts, spec.connection, 'connection', `connector "${step.name}"`, { key: spec.key, action: spec.action });
             const folder = resolveBinding(opts, spec.folder, 'folder', `connector "${step.name}"`, { key: spec.key, action: spec.action });
             // The platform reaches the connection through the flow's `bindings[]`,
             // never through `inputs.detail` — without this pair the run faults with
             // `[102010]` (board G-19; see connectionResourceBindings).
             const { entries: connBindings } = connectionResourceBindings({ def: rc.v1def, connectorKey: rc.connectorKey, connectionId: conn, folderKey: folder }, resourceBindings);
-            for (const b of connBindings)
-                resourceBindings.set(b.id, b);
+            if (!unbound)
+                for (const b of connBindings)
+                    resourceBindings.set(b.id, b);
             const connectorInputs = buildConnectorInputs(rc, spec.inputs, {
+                ...(opts.draft
+                    ? { onMissingRequired: (m) => opts.draft({ nodeId: id, code: CONNECTOR_INPUT_MISSING, message: `connector ${rc.nodeType}: ${m}` }) }
+                    : {}),
                 dialect: FLOW_EXPR_DIALECT,
                 render: (value) => renderDeep(value, scope.rename),
                 resolutions: opts.library.lookupResolutions ?? {},

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.27.1",
+  "version": "6.28.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "c635f8993b10e795715c85109080ec8e2e2f28d2"
+  "gitref": "2129535cf7f13d90345db00a5d72d096c69fce04"
 }