@uipath/maestro-builder-sdk 6.63.0 → 6.64.0

package/dist/compile-cli.js

@@ -10,12 +10,17 @@
  * --library defaults to $FLOW_SDK_LIBRARY_JSON; --bindings defaults to
  * .flow-sdk/bindings.json (or a legacy ./bindings.json) when present. Connector actions require a library.
  *
- * `--no-check` skips the SDK's static `check()` pass and emits whatever
- * `.build()` produced. It exists for loops whose verification is somewhere else
- * entirely — e.g. authoring against the product CLI (`uip maestro flow
- * validate` / `debug`), where a pre-emit static pass would answer questions the
- * product's own gates are supposed to answer. `.build()` still throws on
- * structural problems; only the diagnostic pass is skipped.
+ * `compile` only serializes (docs/CHECK_COMPILE_CONTRACT_DESIGN.md D1, D2). It
+ * does not run `check()`'s lint rules: run `flow check` first for those. It
+ * stops only when it cannot write a correct `.flow`, a refusal the serializer
+ * throws. A draft node (a connector with no connection, an empty required
+ * input) the canvas saved is written, with a warning: decompile marks its step
+ * `{ draft: true }` and carries its definition in `.definitions([...])`. Any
+ * other draft, such as one an agent just wrote (even of an operation the canvas
+ * has a draft of), is refused.
+ *
+ * `--no-check` is a deprecated no-op: it is accepted for one minor version, with
+ * a warning, and then removed.
  */
 import { diagnosticLine, reportDiagnostics, reportResult, thrownDiagnostic } from './cli-result.js';
 import { writeJsonFile } from './core/json-file.js';
@@ -24,8 +29,7 @@ import { basename, dirname, join, relative, resolve } from 'node:path';
 import { resolveFlowFile, loadBuiltFlow } from './load.js';
 import { serializeWithSidecars } from './serialize.js';
 import { compileOwnsResource } from './core/agent-tool-resources.js';
-import { check } from './check.js';
-import { flowCheckOpts, openCliLibrary } from './cli-library.js';
+import { openCliLibrary } from './cli-library.js';
 import { Bindings } from './bindings.js';
 import { flagValue, runWhenInvokedDirectly } from './cli-run.js';
 import { connectionResources, inlineAgentResources, mergeBindingsV2, refreshInlineAgentRows } from './bindings-v2.js';
@@ -35,8 +39,8 @@ import { defaultBindingsFile } from './workdir.js';
 import { isWithin } from './path-within.js';
 import { flowSources, resourceSourcesOfOtherFlows } from './project-resource-users.js';
 import { fnv1aX4Uuid } from './core/stable-id.js';
-import { BindingRefusal } from './core/binding-messages.js';
-import { ByoaRefusal } from './core/byoa.js';
+import { CompileRefusal } from './core/compile-refusal.js';
+import { cliSpelling } from './core/cli-spelling.js';
 /** An agent folder name: a uuid, any case. */
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 export async function run(argv) {
@@ -45,7 +49,9 @@ export async function run(argv) {
         return 2;
     }
     const flags = new Set(['-o', '--library', '--bindings', '--connectors-local']);
-    const noCheck = argv.includes('--no-check');
+    if (argv.includes('--no-check')) {
+        console.error(`compile: --no-check is deprecated and does nothing: compile no longer runs check. Run \`${cliSpelling()} flow check\` before \`compile\`; the flag will be removed.`);
+    }
     const pos = argv.find((a, i) => !flags.has(a) && !flags.has(argv[i - 1]));
     if (!pos) {
         console.error('compile: missing <flow.ts | BaseName>');
@@ -66,37 +72,20 @@ export async function run(argv) {
     // (e.g. HTTP-only) then compile fine even if the connector cache isn't built.
     // A connector action with no library resolves to a clear error in serialize().
     //
-    // Loaded BEFORE check() on purpose: one of check's rules (whether a connector
-    // event operation declares any event parameters) can only be answered from the
-    // library, and answering it from an assumption instead is what made
-    // EVENT_NO_SCOPE an error for HTTP Webhook, whose only correct `where` is empty.
     const library = openCliLibrary(argv);
     const bindFile = flagValue(argv, '--bindings') ?? defaultBindingsFile();
     const bindings = new Bindings(bindFile);
     // One list per run; every exit path reports it (reportResult overwrites keys).
     const diagnostics = [];
-    if (!noCheck) {
-        // Same options as `flow check`, so the two cannot disagree.
-        const diags = check(built, flowCheckOpts(library, bindings));
-        const errors = diags.filter((d) => d.level === 'error');
-        for (const d of diags)
-            console.error(`  ${diagnosticLine(d)}`);
-        diagnostics.push(...diags);
-        if (errors.length) {
-            reportDiagnostics(diagnostics);
-            console.error(`compile: ${errors.length} error(s); not emitting.`);
-            return 1;
-        }
-    }
     // The serializer's own observations — a connection or folder value that can
-    // never be a tenant resource key — printed in the same `⚠ [CODE]` shape as
-    // check()'s. Warnings are never fatal: the .flow is still written, exit stays 0.
-    // A binding LABEL the serializer refuses (its own name as the resourceKey, or a
-    // label a populated bindings.json does not declare) is an error, not a
-    // warning, and so is a BYOA-only event on a connection `prepare` never checked
-    // (EVENT_BYOA_UNVERIFIED): the check pass above reports each first, and this is
-    // the same refusal in the same `✗ [CODE]` shape when that pass was skipped
-    // (`--no-check`, or an emit-only project). Nothing is written.
+    // never be a tenant resource key, a draft node written from its carried
+    // definition — printed in the same `⚠ [CODE]` shape as check()'s. Warnings are
+    // never fatal: the .flow is still written, exit stays 0. A binding LABEL the
+    // serializer refuses (its own name as the resourceKey, or a label a populated
+    // bindings.json does not declare) is an error, not a warning, and so is a
+    // BYOA-only event on a connection `prepare` never checked
+    // (EVENT_BYOA_UNVERIFIED): printed in the same `✗ [CODE]` shape `check` uses
+    // for it. Nothing is written.
     const out = flagValue(argv, '-o') ?? `${built.name || basename(file).replace(/\.flow\.ts$|\.ts$/, '')}.flow`;
     const outDir = dirname(resolve(out));
     // ONE FOLDER, ONE FLOW (#1184). An agent's `source` is the name of the folder
@@ -147,28 +136,37 @@ export async function run(argv) {
     const warnings = [];
     let emitted;
     try {
-        emitted = serializeWithSidecars(built, { library, bindings, warn: (w) => warnings.push(w), agentSource });
+        emitted = serializeWithSidecars(built, {
+            library, bindings, warn: (w) => warnings.push(w), agentSource,
+            carriedDrafts: (d) => warnings.push(draftWarning(d)),
+        });
     }
     catch (error) {
         for (const w of warnings)
-            console.error(`  ⚠ [${w.code}] ${w.message}`);
+            console.error(`  ${diagnosticLine(serializeWarningDiagnostic(w))}`);
         diagnostics.push(...warnings.map(serializeWarningDiagnostic));
-        if (!(error instanceof BindingRefusal || error instanceof ByoaRefusal)) {
-            // Any other throw still ends the run through the caller (exit 1, `--json`
-            // `error`); the list is reported first.
+        if (!(error instanceof CompileRefusal)) {
+            // Any other throw (an internal SDK error) still ends the run through the
+            // caller (exit 1, `--json` `error`); the list is reported first.
             diagnostics.push(thrownDiagnostic(error));
             reportDiagnostics(diagnostics);
             throw error;
         }
-        console.error(`  ✗ [${error.code}] ${error.message}`);
-        diagnostics.push({ level: 'error', code: error.code, message: error.message });
+        // A coded refusal: the serializer cannot write a correct `.flow`. Printed in
+        // `check`'s `✗ [CODE]` shape, which `check` reports for it too.
+        const refused = {
+            level: 'error', code: error.code, message: error.message,
+            ...(error.suggestion !== undefined ? { suggestion: error.suggestion } : {}),
+        };
+        console.error(`  ${diagnosticLine(refused)}`);
+        diagnostics.push(refused);
         reportDiagnostics(diagnostics);
         console.error('compile: 1 error(s); not emitting.');
         return 1;
     }
     const { flow: flowJson, sidecars } = emitted;
     for (const w of warnings)
-        console.error(`  ⚠ [${w.code}] ${w.message}`);
+        console.error(`  ${diagnosticLine(serializeWarningDiagnostic(w))}`);
     diagnostics.push(...warnings.map(serializeWarningDiagnostic));
     // An inline agent is TWO artifacts: the node, and the agent's own configuration
     // at `<source>/agent.json` — which is where flow-v1's serializer points the
@@ -325,7 +323,19 @@ export async function run(argv) {
     return 0;
 }
 function serializeWarningDiagnostic(w) {
-    return { level: 'warning', code: w.code, message: w.message };
+    return { level: 'warning', code: w.code, message: w.message, ...(w.step !== undefined ? { step: w.step } : {}) };
+}
+/**
+ * A draft node written from its carried definition, as a warning: the node is
+ * in the `.flow` as the canvas saved it, unfinished. For instance
+ * `⚠ [BINDING_MISSING] … written as a draft from its carried definition`.
+ */
+function draftWarning(d) {
+    return {
+        code: String(d.code),
+        message: `${d.message} Written as a draft, with the definition the source carries; finish the node before the flow runs.`,
+        ...(d.step !== undefined ? { step: d.step } : {}),
+    };
 }
 runWhenInvokedDirectly(import.meta.url, 'compile', run);
 /** A JSON file's contents, or `undefined` when it is missing or unreadable. */

package/dist/decompile-cli.js

@@ -159,7 +159,7 @@ if (!existsSync(BASELINE)) {
   // ── Step 1: capture the baseline = compile of the PRISTINE decompiled code,
   //    BEFORE any edit. Run this once right after decompiling, then edit. ──
   mkdirSync(dirname(BASELINE), { recursive: true });
-  run('compile', [TS, '-o', BASELINE, '--no-check']);
+  run('compile', [TS, '-o', BASELINE]);
   console.log('\\n>>> Baseline captured. Now EDIT ' + ${JSON.stringify(basename(tsPath))} + ', then re-run this script to compile + merge.');
 } else {
   // ── Step 2: compile your edits, then merge them back into the original. ──
@@ -182,7 +182,7 @@ if (!existsSync(BASELINE)) {
     process.exit(2);
   }
   mkdirSync(dirname(EDITED), { recursive: true });
-  run('compile', [TS, '-o', EDITED, '--no-check']);
+  run('compile', [TS, '-o', EDITED]);
 
   // ── DIFF GATE (seam) ──────────────────────────────────────────────────────
   // A future step can diff ORIGINAL vs the about-to-be-written MERGED here and

package/dist/decompile.js

@@ -298,6 +298,11 @@ function optsArgWith(node, ctx, extra) {
         const entries = updates.map((u) => `${key(u.variableId)}: ${emitVal(u.expression, ctx.imp, ctx.inputNames)}`);
         parts.push(`updates: { ${entries.join(', ')} }`);
     }
+    // A draft the canvas saved: `compile` writes it back only when the step says
+    // so AND the source carries its definition (carriedPairs), so a draft an agent
+    // adds of the same operation is still refused (StepOptions.draft).
+    if (isCanvasDraft(node))
+        parts.push('draft: true');
     return parts.length ? `, { ${parts.join(', ')} }` : '';
 }
 // ─── Node type constants (mirror of serialize.ts NODE_TYPE) ───────────────────
@@ -957,8 +962,9 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
 /**
  * A connector-bound node the file carries UNBOUND: Studio Web saves a draft whose
  * connection was never picked as `connectionId: null`. The source cannot invent
- * labels for it, and `compile` refuses a node without both (BINDING_MISSING, the
- * rule `flow validate` applies too: flow-builder-sdk#890). So the source says so
+ * labels for it, and `check` refuses a node without both (BINDING_MISSING, the
+ * rule `flow validate` applies too: flow-builder-sdk#890), and so does `compile`
+ * unless it is a carried canvas draft (`{ draft: true }`). So the source says so
  * at the node and the run warns once, instead of handing back a file whose first
  * compile fails with no context. Returns the inline marker, or '' when bound.
  */
@@ -968,10 +974,12 @@ function unboundMarker(node, labels, key, action) {
         return '';
     const names = missing.join(' and ');
     warnOnce(`node ${tsLiteral(node.id)} (${node.type}) has no ${missing.join(' or ')} in the .flow (an unbound draft). `
-        + `The source leaves ${missing.length > 1 ? 'them' : 'it'} out, and compile refuses the node (BINDING_MISSING) `
-        + `until it names both labels: run \`${prepareCommand(key, action ?? '<action>')}\`, then pass `
+        + `The source leaves ${missing.length > 1 ? 'them' : 'it'} out${isCanvasDraft(node)
+            ? ' and marks the step `{ draft: true }`: compile writes it as a draft, and check refuses it'
+            : ', and compile and check refuse it'} (BINDING_MISSING) until it names both labels: `
+        + `run \`${prepareCommand(key, action ?? '<action>')}\`, then pass `
         + `\`connection\` and \`folder\`.`);
-    return ` /* TODO: bind ${commentText(names)}; compile refuses this node until it has both labels (BINDING_MISSING) */`;
+    return ` /* TODO: bind ${commentText(names)}; check refuses this node until it has both labels (BINDING_MISSING) */`;
 }
 function emitEventSubscription(node, imp, inputNames) {
     const prefix = node.type.startsWith('uipath.connector.event.') ? 'uipath.connector.event.'
@@ -1071,11 +1079,27 @@ function unsupportedSpec(node, imp, o) {
     return `${imp.use('mock')}() /* TODO: unsupported node type ${commentText(node.type)} */`;
 }
 /**
- * Every pinned `<type>@<version>` in the file (root and subflows) that this SDK
- * cannot resolve, for a type it ships at some version, and that the file's
- * `definitions[]` holds — mapped to the const name decompile hoists the
- * definition under. For instance a quick-form node at 1.6 maps
- * `uipath.human-in-the-loop.quick-form@1.6` → `quickFormV1_6Definition`.
+ * Whether `node` is a draft the canvas saved whose definition the file holds
+ * (its node type's `isDraft`). Decompile carries that definition and marks the
+ * step `{ draft: true }`. For instance a Slack send with `detail.connectionId: null`.
+ */
+function isCanvasDraft(node) {
+    const key = `${node.type}@${node.typeVersion}`;
+    return !!node.typeVersion && runDefs.has(key) && registeredImpl(node)?.isDraft?.(node, runDefs.get(key)) === true;
+}
+/**
+ * Every `<type>@<version>` in the file (root and subflows) whose definition the
+ * source must carry, and that the file's `definitions[]` holds — mapped to the
+ * const name decompile hoists the definition under. Two kinds of node need it:
+ *
+ * - a pin this SDK cannot resolve, for a type it ships at some version. For
+ *   instance a quick-form node at 1.6 maps
+ *   `uipath.human-in-the-loop.quick-form@1.6` → `quickFormV1_6Definition`.
+ * - a DRAFT the canvas saved (its node type's `isDraft`): `compile`
+ *   writes a draft node only with the definition the source carries for it
+ *   (docs/CHECK_COMPILE_CONTRACT_DESIGN.md D2), so an untouched canvas draft
+ *   compiles back. The step is also marked `{ draft: true }`, so a draft an
+ *   agent writes, even of the same operation, is refused.
  */
 function carriedPairs(flow) {
     const out = new Map();
@@ -1086,7 +1110,8 @@ function carriedPairs(flow) {
         if (!n.typeVersion || out.has(key) || !runDefs.has(key))
             continue;
         const shipped = shippedVersions(n.type);
-        if (shipped.length === 0 || shipped.includes(n.typeVersion))
+        const unresolvable = shipped.length > 0 && !shipped.includes(n.typeVersion);
+        if (!unresolvable && !isCanvasDraft(n))
             continue;
         const base = `${camel(String(n.type).split('.').pop() ?? 'node')}V${String(n.typeVersion).replace(/[^A-Za-z0-9]+/g, '_')}Definition`;
         let name = base;

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

@@ -484,6 +484,15 @@ export interface FlowRawNodeAdvice {
 }
 /** One Flow node type at one version. */
 export interface FlowNodeType<Spec> extends NodeType<Spec, FlowNodeContribution, FlowContexts> {
+    /**
+     * Whether a serialized node of this type is a DRAFT the canvas saved: one an
+     * ordinary compile refuses only for a draft code (a connector with no
+     * connection, an empty required input). Decompile then copies the node's
+     * definition from the file into `.definitions([...])`, and `compile` writes
+     * the draft back with it (`SerializeOpts.carriedDrafts`). `definition` is the
+     * file's own `definitions[]` entry for the node, if any. Absent: never a draft.
+     */
+    isDraft?(node: unknown, definition: unknown): boolean;
     /**
      * The node-level `model` every node of this type carries, whichever path emits
      * it — this type's `serialize`, or a `rawNode` of its definition. `'omit'`: none

package/dist/flow-sdk.d.ts

@@ -444,6 +444,27 @@ export interface NodeOptions {
      */
     label?: string;
 }
+/**
+ * The options of `.step()`: the {@link NodeOptions}, plus `draft` for a node the
+ * canvas saved unfinished.
+ */
+export interface StepOptions extends NodeOptions {
+    /**
+     * This node is a DRAFT the canvas saved: a connector with no connection, or
+     * with an empty required input. Decompile sets it on such a node, and also
+     * carries the node's definition in `.definitions([...])`. `compile` then
+     * writes the node with that carried definition and the inputs it has, and
+     * prints a warning (`BINDING_MISSING`, `CONNECTOR_INPUT_MISSING`) instead of
+     * refusing. Without the flag, or without a carried definition for the node's
+     * exact type and version, the draft is refused as usual. `check` reports the
+     * draft either way.
+     *
+     * Do not set it on a node you write: finish the node instead. For instance
+     * decompile prints `.step('notify', connector(SLACK, SEND, { ... }), { draft: true })`
+     * for a Slack send saved with no connection.
+     */
+    draft?: boolean;
+}
 /**
  * The options of `.parallel()`: the join's {@link NodeOptions}, plus the fork
  * node when the flow has one.
@@ -558,7 +579,7 @@ export type Step = {
     kind: 'action';
     name: string;
     spec: FlowActionSpec;
-    options?: NodeOptions;
+    options?: StepOptions;
 } | {
     kind: 'branch';
     name: string;
@@ -920,10 +941,10 @@ declare class StepList {
      * so it must be unique within the flow.
      * @param spec - What the node does, from an action factory.
      * @param options - Node options; `version` selects the exact definition
-     * version (see {@link NodeOptions}).
+     * version (see {@link StepOptions}).
      * @returns This builder, so calls chain.
      */
-    step(name: string, spec: FlowActionSpec | FlowAction, options?: NodeOptions): this;
+    step(name: string, spec: FlowActionSpec | FlowAction, options?: StepOptions): this;
     /**
      * Add an action node and route EVERY exit it declares, one arm per exit.
      *

package/dist/flow-sdk.js

@@ -388,7 +388,7 @@ class StepList {
      * so it must be unique within the flow.
      * @param spec - What the node does, from an action factory.
      * @param options - Node options; `version` selects the exact definition
-     * version (see {@link NodeOptions}).
+     * version (see {@link StepOptions}).
      * @returns This builder, so calls chain.
      */
     step(name, spec, options) {

package/dist/nodes/agent/flow/check.js

@@ -340,15 +340,15 @@ export function checkInlineAgent(inputs, ctx) {
     //
     // An artifact that compiles and can never validate is the worst of the two
     // failures, so this is said here — before the emit — rather than left to a rung.
-    // It is an ERROR because there is no spelling that works today, and `--no-check`
-    // remains the escape for a tenant whose manifest does declare the handle.
+    // It is an ERROR because there is no spelling that works today. `compile` does
+    // not run check, so a tenant whose manifest does declare the handle still compiles it.
     if (inputs?.memory !== undefined) {
         at('AGENT_MEMORY_NOT_AUTHORABLE', `Inline agent step "${step}" attaches \`memory\`, which the platform cannot resolve: the tenant's `
             + `\`uipath.agent.autonomous\` manifest declares no \`memory\` handle (only escalation, context, tool, `
             + `success, error) and the registry serves no \`uipath.agent.resource.memory.*\` node type. The flow `
             + `compiles and then fails \`uip maestro flow validate\` as RetryWillNotFix. Drop \`memory\`; for `
             + `retrieval over a knowledge source use a context index instead (\`tools\`/context grounding). `
-            + `Pass --no-check only on a tenant whose manifest does declare the handle.`);
+            + `On a tenant whose manifest does declare the handle, ignore this finding: \`compile\` does not run check.`);
     }
     // A context `query` is what the RUNTIME searches with, and it is not an
     // expression slot. A plain string is the model-invoked `dynamic` variant: the
@@ -468,7 +468,7 @@ export function checkInlineAgent(inputs, ctx) {
                 + `of the prompt) with one line per field, in the platform's own wording: "${rewrite}" Declare a field \`'object'\` or `
                 + `\`'array'\` if it should carry structure. \`uip maestro flow validate\` accepts this prompt, so `
                 + `nothing later catches it. If this is a false positive (the prompt only mentions JSON as data), `
-                + `compile with --no-check.`);
+                + `ignore this finding: \`compile\` does not run check.`);
         }
     }
     // The prompts-vs-variables agreement, in both directions. Both prompts are

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

@@ -270,6 +270,40 @@ function liftConnector(node, ctx) {
         missing,
     };
 }
+/**
+ * Whether a connector operation node is a draft the canvas saved, by what the
+ * file itself shows: no connection or folder (`BINDING_MISSING`), or a field its
+ * own definition marks `required` that the node gives no value
+ * (`CONNECTOR_INPUT_MISSING`). For instance a Slack send saved before a
+ * connection was picked has `detail.connectionId: null`. An operation with no
+ * object picked is not one: `compile` can only stand in for it, so it is never
+ * written either way.
+ */
+function isConnectorDraft(node, definition) {
+    const detail = (node.inputs?.detail ?? {});
+    const label = (v) => (typeof v === 'string' ? v : undefined);
+    if (missingBindingLabels({ connection: label(detail.connectionId), folder: label(detail.connectionFolderKey) }).length > 0)
+        return true;
+    const fields = definition?.inputDefinition?.fields;
+    if (!Array.isArray(fields))
+        return false;
+    const slots = ['bodyParameters', 'queryParameters', 'pathParameters']
+        .map((slot) => detail[slot])
+        .filter((m) => !!m && typeof m === 'object' && !Array.isArray(m));
+    const parts = Array.isArray(detail.multipartParameters) ? detail.multipartParameters : [];
+    const given = (name) => parts.some((p) => p?.name === name) || slots.some((m) => {
+        if (Object.prototype.hasOwnProperty.call(m, name))
+            return true;
+        let at = m;
+        for (const seg of name.split('.')) {
+            if (!at || typeof at !== 'object' || !Object.prototype.hasOwnProperty.call(at, seg))
+                return false;
+            at = at[seg];
+        }
+        return true;
+    });
+    return fields.some((f) => f?.required === true && typeof f.name === 'string' && !given(f.name));
+}
 function printConnector(l, ctx) {
     // A present input whose value is `undefined` (the inputs check accepts one, and
     // serialize keeps it in memory) prints as `undefined`, as it did before the port.
@@ -284,7 +318,7 @@ function printConnector(l, ctx) {
             ['object', optional(l.object)],
         ],
         ...(l.missing.length > 0
-            ? { comment: `TODO: bind ${l.missing.join(' and ')}; compile refuses this node until it has both labels (BINDING_MISSING)` }
+            ? { comment: `TODO: bind ${l.missing.join(' and ')}; check refuses this node until it has both labels (BINDING_MISSING)` }
             : {}),
     };
 }
@@ -302,6 +336,7 @@ const connector10 = {
     },
     serialize: (spec, ctx) => serializeConnector(spec, ctx),
     deserialize: (node, ctx) => liftConnector(node, ctx),
+    isDraft: (node, definition) => isConnectorDraft(node, definition),
     print: (spec, ctx) => printConnector(spec, ctx),
     check: (spec, ctx) => ctx.connector(spec),
     // Every Expr in the inputs, nested ones included, resolves against the flow's names.

package/dist/serialize.d.ts

@@ -29,6 +29,8 @@ export type DraftCode = BindingRefusalCode | typeof CONNECTOR_INPUT_MISSING | 'C
 export interface DraftFinding {
     /** The emitted node's id. */
     nodeId: string;
+    /** The step whose node it is. Set by a carried-drafts compile ({@link SerializeOpts.carriedDrafts}). */
+    step?: string;
     /** A {@link DraftCode}, or a node-type package's own code reported through `ctx.draft`. */
     code: DraftCode | string;
     /** The sentence the strict compile refuses with. */
@@ -71,6 +73,28 @@ export interface SerializeOpts {
      * ordinary compile), behaviour is unchanged.
      */
     draft?: (finding: DraftFinding) => void;
+    /**
+     * Carried drafts, for `compile` (docs/CHECK_COMPILE_CONTRACT_DESIGN.md D2).
+     *
+     * A step marked `{ draft: true }` ({@link StepOptions.draft}) that the
+     * ordinary compile refuses only for draft findings ({@link DraftCode}: a
+     * connector with no connection, an empty required input) is written anyway
+     * when the flow CARRIES the definition of the node it emits
+     * (`.definitions([...])`). Decompile sets both for a canvas draft node. The
+     * node is written with that definition and the inputs it has, and each
+     * finding is reported here. A draft with no flag, or no carried definition,
+     * or one the node type can only stand in for (a generic operation with no
+     * object), is refused exactly as without this option. So is any other
+     * refusal. A flow with no draft compiles byte for byte as without it.
+     *
+     * For instance, a decompiled canvas flow whose Slack send has no `messageToSend`
+     * compiles with a `CONNECTOR_INPUT_MISSING` finding here, and a second Slack
+     * send written by hand with no `messageToSend` (no flag) is refused, though
+     * the flow carries the definition of that operation.
+     *
+     * Ignored when {@link draft} is given (merge's compile tolerates every draft).
+     */
+    carriedDrafts?: (finding: DraftFinding) => void;
     /**
      * Collect mode, for `check` (docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.5).
      *

package/dist/serialize.js

@@ -2542,6 +2542,76 @@ function serializeFlow(built, opts) {
         }
         return [{ node: id, port }];
     }
+    /**
+     * Run a node type's `serialize`, and in a carried-drafts compile
+     * ({@link SerializeOpts.carriedDrafts}) try a refused `{ draft: true }` step
+     * once more as a draft. The ordinary emission runs first, so a flow with no draft compiles
+     * exactly as it would without the option. When it throws a refusal and the flow
+     * carries any definition, what that emission bound is undone and the node is
+     * emitted again with `drafting` on. That second contribution is returned with
+     * the first refusal as `strict` when it reported a draft finding; the caller
+     * writes it only with a carried definition, and throws `strict` otherwise. A
+     * second emission that throws, or reports no finding, ends in `strict` too, so
+     * a refusal that is not a draft reads as it always has.
+     */
+    function serializeCarriedDraft(impl, spec, ctx, scope, id, bound, stepOptions, findings, enableDrafting, warnings) {
+        if (!opts.carriedDrafts || opts.draft || opts.collect || carriedDefs.size === 0 || stepOptions?.draft !== true) {
+            return { contribution: impl.serialize(spec, ctx) };
+        }
+        const mark = {
+            resources: new Set(resourceBindings.keys()), sidecars: sidecars.length,
+            agentSchemas: scope.agentSchemas.length, unbound: unboundDrafts.has(id),
+        };
+        // Each emission's warnings are held, so a node emitted twice reports only
+        // the warnings of the emission that is kept (or of the refused one).
+        const flush = (held) => { for (const w of held)
+            opts.warn?.(w); };
+        const first = [];
+        warnings.held = first;
+        try {
+            const contribution = impl.serialize(spec, ctx);
+            warnings.held = undefined;
+            flush(first);
+            return { contribution };
+        }
+        catch (error) {
+            warnings.held = undefined;
+            if (!(error instanceof CompileRefusal)) {
+                flush(first);
+                throw error;
+            }
+            for (const key of [...resourceBindings.keys()])
+                if (!mark.resources.has(key))
+                    resourceBindings.delete(key);
+            for (const f of sidecars.splice(mark.sidecars)) {
+                if (!sidecars.some((kept) => kept.path === f.path))
+                    explicitSidecars.delete(f.path);
+            }
+            scope.agentSchemas.length = mark.agentSchemas;
+            if (!mark.unbound)
+                unboundDrafts.delete(id);
+            bound.length = 0;
+            enableDrafting();
+            const second = [];
+            warnings.held = second;
+            let contribution;
+            try {
+                contribution = impl.serialize(spec, ctx);
+            }
+            catch {
+                flush(first);
+                throw error;
+            }
+            finally {
+                warnings.held = undefined;
+            }
+            if (findings.length === 0) {
+                flush(first);
+                throw error;
+            }
+            return { contribution, strict: error, strictWarnings: first, draftWarnings: second };
+        }
+    }
     /**
      * Lower a step whose kind is a registered node type (flow-node-registry.ts):
      * the node type serializes its spec through a context, and this owns the rest —
@@ -2572,6 +2642,19 @@ function serializeFlow(built, opts) {
                 rendered.add(copy);
             return copy;
         };
+        // Merge's compile drafts every node; `compile` (carriedDrafts) drafts a node
+        // only on a second try, after the ordinary emission refused it.
+        let drafting = opts.draft !== undefined;
+        const carriedFindings = [];
+        // Where this step's warnings go: `opts.warn`, or held while a carried-drafts
+        // compile does not yet know which emission it keeps (serializeCarriedDraft).
+        const warnings = {};
+        const bindingOpts = opts.warn
+            ? { ...opts, warn: (w) => { if (warnings.held)
+                    warnings.held.push(w);
+                else
+                    opts.warn(w); } }
+            : opts;
         const ctx = {
             step: step.name,
             nodeId: id,
@@ -2598,7 +2681,7 @@ function serializeFlow(built, opts) {
                 ? resolved.carried
                 : bundledDefinition(typeName, v) ?? carriedFor(typeName, v)),
             bindings: resourceBindings,
-            resolveBinding: ((name, attribute, at, target) => resolveBinding(opts, name, attribute, at, target)),
+            resolveBinding: ((name, attribute, at, target) => resolveBinding(bindingOpts, name, attribute, at, target)),
             bindConnection: (c) => {
                 const { entries } = connectionResourceBindings({
                     def: { model: c.model },
@@ -2625,15 +2708,26 @@ function serializeFlow(built, opts) {
                 const out = renderDeep(value, scope.rename, rendered);
                 return out !== null && typeof out === 'object' ? fileCopy(out) : out;
             },
-            drafting: opts.draft !== undefined,
+            get drafting() { return drafting; },
             draft: (code, message) => {
                 if (code === 'BINDING_MISSING')
                     unboundDrafts.add(id);
-                opts.draft?.({ nodeId: id, code: code, message });
+                if (opts.draft)
+                    opts.draft({ nodeId: id, code: code, message });
+                else
+                    carriedFindings.push({ nodeId: id, step: step.name, code: code, message });
             },
         };
         const bound = [];
-        const contribution = impl.serialize(spec, ctx);
+        const { contribution, strict, strictWarnings, draftWarnings } = serializeCarriedDraft(impl, spec, ctx, scope, id, bound, step.options, carriedFindings, () => { drafting = true; }, warnings);
+        // A carried draft refused after all reports the warnings of the refused emission.
+        const refuse = () => {
+            for (const w of strictWarnings ?? [])
+                opts.warn?.(w);
+            throw strict;
+        };
+        if (strict !== undefined && contribution.standIn !== undefined)
+            refuse();
         if (contribution.standIn !== undefined) {
             // A draft stand-in: the node as the draft has it, with no definition to
             // place it against (see FlowNodeContribution.standIn).
@@ -2677,6 +2771,22 @@ function serializeFlow(built, opts) {
             const origin = entry.family.package;
             def = { ...def, source: { package: origin.name, ...(origin.version !== undefined ? { version: origin.version } : {}) } };
         }
+        // A draft `compile` writes: only a step marked `{ draft: true }` (checked in
+        // serializeCarriedDraft) with the definition the flow carries for the node it
+        // emits (decompile's copy of the canvas file's entry), else refused as the
+        // ordinary emission refused it (SerializeOpts.carriedDrafts).
+        if (strict !== undefined) {
+            const carried = typeof def?.nodeType === 'string' && typeof def?.version === 'string'
+                ? carriedFor(def.nodeType, def.version)
+                : undefined;
+            if (carried === undefined)
+                refuse();
+            def = carried;
+            for (const w of draftWarnings ?? [])
+                opts.warn?.(w);
+            for (const f of carriedFindings)
+                opts.carriedDrafts?.(f);
+        }
         // A type that owns a family of names (`typeNamePrefix`) is placed under the
         // name its definition carries — `uipath.core.function.<key>`, not the prefix.
         // The bare prefix is allowed: an empty `key` builds it, check refuses that