@uipath/maestro-builder-sdk 6.14.5 → 6.15.1

package/dist/registry/prepare/source-labels.js

@@ -46,7 +46,15 @@ import { GUID_RE } from "../../core/binding-messages.js";
 import { relativePosix } from "../compat/paths.js";
 import { canonicalPath, flowSources, isRelativeSpecifier } from "./source-import.js";
 import { inWorkDir } from "../../workdir.js";
-const CALLEES = new Set(["connector", "onEvent", "waitForEvent"]);
+const CALLEES = new Set([
+    "connector", "onEvent", "waitForEvent", "eventTrigger", "dataService",
+]);
+/**
+ * Data Fabric's connector key, spelled here rather than imported from
+ * `bpmn/data-service.ts` — `registry/` does not depend on a family's emitter.
+ * `.dataService()` is the one call that binds a connection without naming one.
+ */
+const DATA_SERVICE_KEY = "uipath-uipath-dataservice";
 function isFile(path) {
     try {
         return statSync(path).isFile();
@@ -81,7 +89,8 @@ export function sourceBindingLabels(options) {
         catch {
             continue; // unreadable: it cannot be the author's working source
         }
-        readFile(file, relativePosix(root, file), text, options.connectorKey, moduleDirs, result);
+        const family = file.endsWith(".bpmn.ts") ? "bpmn" : "flow";
+        readFile(file, relativePosix(root, file), text, options.connectorKey, moduleDirs, result, family);
     }
     return result;
 }
@@ -115,7 +124,7 @@ function propertyName(name) {
         return name.text;
     return undefined;
 }
-function readFile(file, shown, text, connectorKey, moduleDirs, result) {
+function readFile(file, shown, text, connectorKey, moduleDirs, result, family) {
     const sf = ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
     // `parseDiagnostics` is where the scanner records syntax problems (see core/expr-check.ts).
     const problems = sf.parseDiagnostics;
@@ -316,6 +325,24 @@ function readFile(file, shown, text, connectorKey, moduleDirs, result) {
                     unplaceable(at, args.why);
                 else if (args.length === 0)
                     unplaceable(at, "spreads an empty array");
+                else if (family === "bpmn") {
+                    // Every BPMN call leads with the ELEMENT ID, so the key is one further
+                    // along than Flow's and the options are last. `.dataService()` names no
+                    // connector at all — there is only one it can mean.
+                    if (callee === "dataService") {
+                        record(DATA_SERVICE_KEY, args[1], at);
+                    }
+                    else if (callee === "connector" || callee === "eventTrigger" || callee === "waitForEvent") {
+                        const key = constString(args[1]);
+                        // A computed key is not a reason to distrust the whole file here: a
+                        // BPMN options object is a literal at the call site, and the label
+                        // this reads is the author's own name for a binding, not a fact the
+                        // emitter depends on. Flow's `unplaceable` exists because its first
+                        // argument may be a DESCRIPTOR whose key decides everything.
+                        if (key !== undefined)
+                            record(key, args[callee === "connector" ? 4 : 3], at);
+                    }
+                }
                 else if (callee === "connector") {
                     const [first] = args;
                     const literalKey = constString(first);
@@ -325,7 +352,7 @@ function readFile(file, shown, text, connectorKey, moduleDirs, result) {
                     else
                         record(key, args[literalKey !== undefined ? 3 : 2], at);
                 }
-                else {
+                else if (callee === "onEvent" || callee === "waitForEvent") {
                     const [first] = args;
                     const subscription = constObject(first);
                     if (subscription) {

package/dist/serialize.d.ts

@@ -1,7 +1,16 @@
 import type { BuiltFlow } from './flow-sdk.js';
-import type { Library, ResolvedConnector } from './library.js';
+import type { Library } from './library.js';
 import type { Bindings } from './bindings.js';
-import { type LookupResolutions, type LookupSpec } from './core/lookups.js';
+import { connectorInputErrors as coreConnectorInputErrors } from './core/connector-inputs.js';
+/**
+ * What `compile` would refuse these connector inputs with, or `undefined` when it
+ * would accept them — Flow's binding of the shared validator.
+ *
+ * `render` is not optional here: `renderDeep` is what REFUSES a lookup token in a
+ * position no lookup is resolved from (inside an opaque `object` input, say), and
+ * dropping it would make `check` quietly accept what `compile` throws on.
+ */
+export declare function connectorInputErrors(rc: Parameters<typeof coreConnectorInputErrors>[0], inputs: Record<string, unknown>, resolutions?: Parameters<typeof coreConnectorInputErrors>[2], lookups?: Parameters<typeof coreConnectorInputErrors>[3]): string | undefined;
 /**
  * A compile-time observation that does not stop emission. `check()` has its
  * diagnostics; this is the serializer's own channel for things it can only see
@@ -82,12 +91,3 @@ export declare function serialize(built: BuiltFlow, opts?: SerializeOpts): any;
  * placeholder and the step that carries it.
  */
 export declare function assertBindingPlaceholdersResolve(flow: any): void;
-/**
- * What `compile` would refuse these connector inputs with, or `undefined` when it
- * would accept them — the SAME code path `buildConnectorInputs` runs at emit time,
- * so `check` and `compile` cannot disagree about a missing required field, an
- * unknown or mistyped input, or a container part passed as a value. Unresolved
- * lookups are the one thing skipped: `check` already reports them as
- * LOOKUP_UNRESOLVED with the resolution recipe.
- */
-export declare function connectorInputErrors(rc: ResolvedConnector, inputs: Record<string, unknown>, resolutions?: LookupResolutions, lookups?: Readonly<Record<string, LookupSpec>>): string | undefined;

package/dist/serialize.js

@@ -23,7 +23,23 @@ import { declaredExits, hasExits, stopsAtEnd } from './core/step-ports.js';
 import { assertNodeEnvelope } from './core/node-envelope.js';
 import { buildConfiguration, transportHttpMethod } from './config.js';
 import { stableId } from './core/stable-id.js';
-import { readEventFilter, eventFilterProblem, eventFilterJmes, eventFilterTreeLeaf } from './event-filters.js';
+import { readEventFilter, eventFilterProblem, eventFilterJmes, eventFilterTreeLeaf } from './core/event-filters.js';
+import { FLOW_EXPR_DIALECT } from './core/connector-checks.js';
+import { buildConnectorInputs, connectorInputErrors as coreConnectorInputErrors, multipartBodyFieldName } from './core/connector-inputs.js';
+/**
+ * What `compile` would refuse these connector inputs with, or `undefined` when it
+ * would accept them — Flow's binding of the shared validator.
+ *
+ * `render` is not optional here: `renderDeep` is what REFUSES a lookup token in a
+ * position no lookup is resolved from (inside an opaque `object` input, say), and
+ * dropping it would make `check` quietly accept what `compile` throws on.
+ */
+export function connectorInputErrors(rc, inputs, resolutions = {}, lookups = {}) {
+    return coreConnectorInputErrors(rc, inputs, resolutions, lookups, {
+        dialect: FLOW_EXPR_DIALECT,
+        render: (value) => renderDeep(value, NO_RENAME),
+    });
+}
 import { isLookupToken, resolvedValue, unresolvedLookupMessage, } from './core/lookups.js';
 import { declaredScriptShape, inferScriptShape } from './core/script-return.js';
 import { migrateToSchemaVersion } from './migrate.js';
@@ -4654,12 +4670,16 @@ export function serialize(built, opts = {}) {
             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);
-            const connectorInputs = buildConnectorInputs(rc, spec.inputs, scope.rename, opts.library.lookupResolutions ?? {}, 
-            // Only for the missing-required hint; a test double that is not a full
-            // Library simply gets the plain message.
-            typeof opts.library.lookupSpecs === 'function'
-                ? opts.library.lookupSpecs(spec.key, spec.action, spec.version, spec.object)
-                : {});
+            const connectorInputs = buildConnectorInputs(rc, spec.inputs, {
+                dialect: FLOW_EXPR_DIALECT,
+                render: (value) => renderDeep(value, scope.rename),
+                resolutions: opts.library.lookupResolutions ?? {},
+                // Only for the missing-required hint; a test double that is not a full
+                // Library simply gets the plain message.
+                lookups: typeof opts.library.lookupSpecs === 'function'
+                    ? opts.library.lookupSpecs(spec.key, spec.action, spec.version, spec.object)
+                    : {},
+            });
             const replayInputs = {
                 ...(connectorInputs.bodyParameters ?? {}),
                 ...(connectorInputs.pathParameters ?? {}),
@@ -6615,419 +6635,6 @@ export function assertBindingPlaceholdersResolve(flow) {
         + `"invalid GUID <bindings.…>") and refuses to publish. This is a serializer defect, not an authoring `
         + `error; report it with the flow source.`);
 }
-/**
- * Validate a connector's activity inputs against its declared field list and
- * return them ROUTED to the wire slots the platform reads. Catches the three
- * connector-input mistakes — missing required, unknown key, type mismatch — at
- * compile, where the author can act on them.
- *
- * Generated descriptors accept natural nested objects and arrays; the legacy
- * string form also accepts exact flat registry field ids. Routing remains the
- * library's business because a field's location is a property of the operation.
- * Each projected registry field lands in the slot its declaration names:
- *
- * ```jsonc
- * // connector('uipath-atlassian-jira','get-issue', { issueId: …, project: 'IN', issuetype: 'Task' })
- * "inputs": { "detail": {
- *   "endpoint":        "/curated_get_issue/{issueId}",
- *   "pathParameters":  { "issueId": "IN-28" },
- *   "queryParameters": { "project": "IN", "issuetype": "Task" },
- *   "bodyParameters":  {} } }
- * ```
- *
- * That is the platform's own encoding, measured on the deployed corpus: 1,283
- * connector nodes in the nightly artifacts, 384 carrying `pathParameters` and
- * 576 carrying `queryParameters`, always as a FLAT map keyed by the parameter's
- * DECLARED name (`send_as`, `issuetype`, `channel_id` keep their spelling — no
- * camelCasing) and always as a SIBLING of `bodyParameters` rather than as a
- * location-tagged entry inside it.
- */
-/** For a missing required lookup field: what it sends and how to resolve it. Empty for a plain field. */
-function missingLookupHint(field, lookup) {
-    if (!lookup)
-        return '';
-    const target = `${lookup.objectName ?? lookup.path}.${lookup.value}`;
-    const alias = Object.keys(lookup.aliases)[0];
-    const call = alias
-        ? `lookup(<Descriptor>, '${field}').${alias}('<value>')`
-        : `lookup(<Descriptor>, '${field}').by('${lookup.by[0] ?? 'id'}', '<value>')`;
-    return ` — a lookup id (\`${target}\`), not a name or address: ${call}`;
-}
-/**
- * What `compile` would refuse these connector inputs with, or `undefined` when it
- * would accept them — the SAME code path `buildConnectorInputs` runs at emit time,
- * so `check` and `compile` cannot disagree about a missing required field, an
- * unknown or mistyped input, or a container part passed as a value. Unresolved
- * lookups are the one thing skipped: `check` already reports them as
- * LOOKUP_UNRESOLVED with the resolution recipe.
- */
-export function connectorInputErrors(rc, inputs, resolutions = {}, lookups = {}) {
-    try {
-        buildConnectorInputs(rc, inputs, NO_RENAME, resolutions, lookups, { unresolvedLookups: 'ignore' });
-        return undefined;
-    }
-    catch (e) {
-        return e instanceof Error ? e.message : String(e);
-    }
-}
-function buildConnectorInputs(rc, inputs, rename = NO_RENAME, resolutions = {}, lookups = {}, policy = {}) {
-    const fields = (rc.fields ?? []);
-    const byName = new Map(fields.map((f) => [f.name, f]));
-    const errs = validateNestedConnectorKeys(fields, inputs, byName);
-    const routed = {
-        bodyParameters: {}, pathParameters: {}, queryParameters: {},
-    };
-    // The author's values for FILE parts, by part name. The part LIST itself comes
-    // from the library (`rc.multipartParts`): a string-typed part is a transport
-    // container the runtime composes from `bodyParameters`, so it is listed without
-    // a value and is never an author input — see `readFields` in core/library.ts.
-    const partValues = new Map();
-    for (const f of fields) {
-        const flat = Object.prototype.hasOwnProperty.call(inputs, f.name);
-        let nested = flat
-            ? { found: true, value: inputs[f.name], projectedArrays: 0 }
-            : readConnectorPath(inputs, f.name);
-        if (!nested.found) {
-            // A required LOOKUP field is missing far more often because the author does
-            // 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])}`);
-            continue;
-        }
-        // An unresolved lookup is swapped for its recorded id, or reported. It is
-        // NOT rendered as a placeholder: emitting something for a value nobody
-        // resolved would produce a flow that compiles and then talks to the wrong
-        // record, which is exactly the failure the lookup surface exists to remove.
-        //
-        // A token is swapped wherever the field's value can hold one: the whole
-        // value, or an element of an array at any depth. A multiselect is
-        // `users: [lookup(…), lookup(…)]` — the form `ConnectorLookupValue`'s array
-        // branch types and the generated `## Example` prints — and until this swapped
-        // only the whole-value case, so every token inside the array reached
-        // validation as an object ("expected string, got object") with every lookup
-        // recorded. An unresolved element under 'ignore' becomes `null`, which
-        // validation skips, so `check` still type-checks the resolved siblings.
-        const unresolved = [];
-        const swapped = swapLookupTokens(nested.value, resolutions, unresolved);
-        if (unresolved.length) {
-            if (policy.unresolvedLookups !== 'ignore') {
-                for (const token of unresolved)
-                    errs.push(unresolvedLookupMessage(token));
-                continue;
-            }
-            if (isLookupToken(nested.value))
-                continue;
-        }
-        nested = { ...nested, value: swapped };
-        // A FLAT key whose wire name ends in `[*]` names one array: an array value
-        // there is checked element by element, as the nested form is. A flat scalar
-        // keeps depth 0 and is emitted as the scalar it is — the product wraps it
-        // into a one-element list (flow-v1 `convertDotNotationToNested`).
-        const depth = flat
-            ? (f.name.endsWith('[*]') && Array.isArray(nested.value) ? 1 : 0)
-            : nested.projectedArrays;
-        validateConnectorFieldValue(f, nested.value, depth, errs);
-        if (f.location === 'multipart') {
-            partValues.set(f.name, renderDeep(nested.value, rename));
-            continue;
-        }
-        const slot = SLOT_FOR_LOCATION[f.location ?? 'body'] ?? 'bodyParameters';
-        routed[slot][f.name] = renderDeep(nested.value, rename);
-    }
-    if (errs.length) {
-        // Name the location of each required field: a "missing required input" on a
-        // path parameter reads very differently from one on a body field, and the
-        // author's fix is the same either way (add it to the same flat `inputs` map).
-        const req = fields
-            .filter((f) => f.required)
-            .map((f) => (f.location && f.location !== 'body' ? `${f.name} (${f.location})` : f.name))
-            .join(', ') || '(none required)';
-        // Phase 1 propagates connector discovery capability to every activity. When
-        // one of those activities rejects an unknown field, point at the live-schema
-        // preparation path; fully static activities on the same connector still
-        // compile normally and never reach this hint.
-        const schemaDynamic = !!rc.entry?.runtime?.requiresConnectionForSchema;
-        const hasUnknown = errs.some((e) => e.startsWith('unknown input'));
-        let hint = '';
-        if (schemaDynamic && hasUnknown) {
-            const prefix = `uipath.connector.${rc.connectorKey}.`;
-            const action = String(rc.nodeType).startsWith(prefix)
-                ? String(rc.nodeType).slice(prefix.length)
-                // `.pop()` on a split is never empty at runtime, but its type admits
-                // `undefined`; the node type itself is the only sane fallback.
-                : String(rc.nodeType).split('.').pop() ?? String(rc.nodeType);
-            hint =
-                ` This connector supports connection-specific object or field discovery, and the ` +
-                    `static library does not contain this input. Run ` +
-                    `\`${prepareCommand(rc.connectorKey, action)}\` ` +
-                    `to load them ` +
-                    `(writes ./.flow-sdk/connectors-local/, which the compiler auto-detects). If that still ` +
-                    `does not carry this input, the operation resolves its fields from the VALUES of ` +
-                    `parent inputs: resolve every parent and re-run with ` +
-                    `\`-f <parent-field>=<value>\` for each — too few parents is refused, and a ` +
-                    `wrong value resolves back to just the parents. ` +
-                    `See the connector guide's parent-field loop.`;
-        }
-        throw new Error(`connector ${rc.nodeType}: ${errs.join('; ')}. Required fields: ${req}.${hint}`);
-    }
-    // Every declared part, in declaration order, as the designer lists them: the
-    // container part valueless, a file part with the author's value when given. A
-    // test double that resolves no `multipartParts` falls back to its multipart
-    // fields, which are all file parts by construction.
-    const declaredParts = rc.multipartParts
-        ?? fields.filter((f) => f.location === 'multipart').map((f) => ({ name: f.name, dataType: f.type ?? 'string' }));
-    const multipartParameters = declaredParts.map((part) => (partValues.has(part.name)
-        ? { name: part.name, dataType: part.dataType, value: partValues.get(part.name) }
-        : { name: part.name, dataType: part.dataType }));
-    // A FIXED slot order, so a recompile is byte-identical no matter which order
-    // the author listed the inputs in.
-    const slots = multipartParameters.length === 0 || Object.keys(routed.bodyParameters).length > 0
-        ? { bodyParameters: routed.bodyParameters }
-        : {};
-    if (Object.keys(routed.pathParameters).length)
-        slots.pathParameters = routed.pathParameters;
-    if (Object.keys(routed.queryParameters).length)
-        slots.queryParameters = routed.queryParameters;
-    if (multipartParameters.length) {
-        slots.multipartParameters = multipartParameters;
-        slots.inputMetadata = { type: 'multipart', multipart: { bodyFieldName: multipartBodyFieldName(declaredParts) } };
-    }
-    return slots;
-}
-/**
- * `value` with every lookup token swapped for its recorded id: the value itself,
- * or the elements of an array at any depth. An unrecorded token is pushed to
- * `unresolved` and stands as `null`, so an array keeps its length.
- *
- * Objects are NOT descended: a lookup's place is a field's value or an element
- * of an array field (`ConnectorLookupValue`), and a nested path such as
- * `contacts[*].id` reaches here already projected to its leaf array. A token
- * anywhere else is refused by {@link renderDeep}.
- */
-function swapLookupTokens(value, resolutions, unresolved) {
-    if (isLookupToken(value)) {
-        const resolved = resolvedValue(value, resolutions);
-        if (resolved === undefined) {
-            unresolved.push(value);
-            return null;
-        }
-        return resolved;
-    }
-    if (Array.isArray(value))
-        return value.map((item) => swapLookupTokens(item, resolutions, unresolved));
-    return value;
-}
-/**
- * `inputMetadata.multipart.bodyFieldName` names the CONTAINER part — the one the
- * runtime composes from `bodyParameters`. Measured on the designer's own nodes in
- * the eval archive: `body` ×413, `RagRequest` ×1 (GenAI `content-generation`, whose
- * string part is named that), and `body` on 91 of 93 file-only operations. A
- * mis-named container is fatal at dispatch — hardcoding `body` for GenAI made
- * Integration Service answer `400 The request body is empty` (verified live
- * 2026-09-02) — so it is the string part's own name, with `body` only as the
- * default for an operation that has no string part.
- */
-function multipartBodyFieldName(parts) {
-    const containers = parts.filter((p) => p.dataType.toLowerCase() !== 'file');
-    return containers.length === 1 ? containers[0].name : 'body';
-}
-const SLOT_FOR_LOCATION = {
-    body: 'bodyParameters',
-    query: 'queryParameters',
-    path: 'pathParameters',
-};
-function connectorPath(name) {
-    return name.split('.').map((raw) => ({
-        key: raw.endsWith('[*]') ? raw.slice(0, -3) : raw,
-        array: raw.endsWith('[*]'),
-    }));
-}
-/** Read a natural nested authoring value using a registry path such as
- * `contacts[*].id`. Wildcards project one value per array element so the Flow
- * bodyParameters map can retain the registry's exact field ids. */
-function readConnectorPath(inputs, name) {
-    const parts = connectorPath(name);
-    const read = (value, index) => {
-        if (index >= parts.length)
-            return { found: true, value, projectedArrays: 0 };
-        if (!value || typeof value !== 'object' || value instanceof Expr || Array.isArray(value))
-            return { found: false, projectedArrays: 0 };
-        const part = parts[index];
-        const object = value;
-        if (!Object.prototype.hasOwnProperty.call(object, part.key))
-            return { found: false, projectedArrays: 0 };
-        const next = object[part.key];
-        if (!part.array)
-            return read(next, index + 1);
-        if (!Array.isArray(next))
-            return { found: false, projectedArrays: 0 };
-        if (index === parts.length - 1)
-            return { found: true, value: next, projectedArrays: 1 };
-        const projected = next.map((item) => read(item, index + 1));
-        if (!projected.some((item) => item.found))
-            return { found: false, projectedArrays: 0 };
-        return {
-            found: true,
-            value: projected.map((item) => item.found ? item.value : null),
-            projectedArrays: 1 + Math.max(0, ...projected.map((item) => item.projectedArrays)),
-        };
-    };
-    return read(inputs, 0);
-}
-function buildConnectorInputTrie(fields) {
-    const root = { children: new Map(), array: false };
-    for (const field of fields) {
-        let cursor = root;
-        for (const part of connectorPath(field.name)) {
-            let child = cursor.children.get(part.key);
-            if (!child) {
-                child = { children: new Map(), array: part.array };
-                cursor.children.set(part.key, child);
-            }
-            child.array ||= part.array;
-            cursor = child;
-        }
-        cursor.terminal = field;
-    }
-    return root;
-}
-/** Reject nested typos with the same unknown-key message as flat keys. */
-function validateNestedConnectorKeys(fields, inputs, exact) {
-    const root = buildConnectorInputTrie(fields);
-    const errs = [];
-    const visit = (value, node, path) => {
-        if (value instanceof Expr)
-            return;
-        if (node.array) {
-            if (!Array.isArray(value)) {
-                errs.push(`input "${path}" expected array, got ${typeof value}`);
-                return;
-            }
-            for (const item of value)
-                visit(item, { ...node, array: false }, `${path}[*]`);
-            return;
-        }
-        // An opaque object/array terminal owns its complete value; there is no
-        // child metadata with which to validate its internal keys.
-        if (node.terminal && node.children.size === 0)
-            return;
-        if (!value || typeof value !== 'object' || Array.isArray(value)) {
-            if (node.children.size > 0)
-                errs.push(`input "${path}" expected object, got ${Array.isArray(value) ? 'array' : typeof value}`);
-            return;
-        }
-        for (const [key, childValue] of Object.entries(value)) {
-            const child = node.children.get(key);
-            const childPath = path ? `${path}.${key}` : key;
-            if (!child) {
-                const near = nearestField(childPath, fields.map((f) => f.name));
-                errs.push(`unknown input "${childPath}"${near ? ` — did you mean "${near}"?` : ''}`);
-            }
-            else {
-                visit(childValue, child, childPath);
-            }
-        }
-    };
-    for (const [key, value] of Object.entries(inputs)) {
-        if (exact.has(key))
-            continue; // backwards-compatible flat authoring
-        const node = root.children.get(key);
-        if (!node) {
-            const near = nearestField(key, [...exact.keys()]);
-            errs.push(`unknown input "${key}"${near ? ` — did you mean "${near}"?` : ''}`);
-        }
-        else {
-            visit(value, node, key);
-        }
-    }
-    return errs;
-}
-function validateConnectorFieldValue(field, value, projectedArrays, errs) {
-    if (projectedArrays > 0) {
-        if (!Array.isArray(value)) {
-            errs.push(`input "${field.name}" expected array projection, got ${typeof value}`);
-            return;
-        }
-        for (const item of value) {
-            if (item !== null && item !== undefined)
-                validateConnectorFieldValue(field, item, projectedArrays - 1, errs);
-        }
-        return;
-    }
-    if (value instanceof Expr || value === null || value === undefined)
-        return;
-    if (field.type === 'array') {
-        if (!Array.isArray(value))
-            errs.push(`input "${field.name}" expected array, got ${typeof value}`);
-        return;
-    }
-    if (field.type === 'object') {
-        if (typeof value !== 'object' || Array.isArray(value))
-            errs.push(`input "${field.name}" expected object, got ${Array.isArray(value) ? 'array' : typeof value}`);
-        return;
-    }
-    if (field.type === 'string' || field.type === 'number' || field.type === 'boolean') {
-        const actual = typeof value;
-        const ok = actual === field.type ||
-            (field.type === 'number' && actual === 'string' && value !== '' && !isNaN(Number(value)));
-        if (!ok)
-            errs.push(`input "${field.name}" expected ${field.type}, got ${actual}`);
-    }
-}
-/**
- * The closest declared field name to `key`, for the "did you mean …?" half of an
- * unknown-input error.
- *
- * Three rules, tried in order: an exact case-insensitive match (`pagesize` →
- * `pageSize`), a substring either way (`summary` → `fields.summary`), and — the
- * one added for query/path parameters — a small EDIT DISTANCE. The first two miss
- * every substitution typo: `projekt` and `project` share no containment, so the
- * suggestion was simply absent, and it is absent exactly where it is needed most.
- * Parameter names are unfamiliar (`issuetype`, `nextPage`, `expansionLevel`), so
- * the author has no memory to fall back on.
- *
- * The threshold scales with the name's length (⌈len/4⌉, at least 1, at most 3), so
- * a short name needs a near-exact miss and a long one may be off by a few — and
- * two genuinely different fields are never conflated.
- */
-function nearestField(key, names) {
-    const lk = key.toLowerCase();
-    const exact = names.find((n) => n.toLowerCase() === lk);
-    if (exact)
-        return exact;
-    const contained = names.find((n) => n.toLowerCase().includes(lk) || lk.includes(n.toLowerCase()));
-    if (contained)
-        return contained;
-    const budget = Math.min(3, Math.max(1, Math.ceil(lk.length / 4)));
-    let best;
-    let bestD = budget + 1;
-    for (const n of names) {
-        const d = editDistance(lk, n.toLowerCase());
-        if (d < bestD) {
-            bestD = d;
-            best = n;
-        }
-    }
-    return bestD <= budget ? best : undefined;
-}
-/** Levenshtein distance, two rows — enough for field-name suggestions. */
-function editDistance(a, b) {
-    if (a === b)
-        return 0;
-    if (Math.abs(a.length - b.length) > 3)
-        return 99; // cheap bail: beyond any budget
-    let prev = Array.from({ length: b.length + 1 }, (_, j) => j);
-    for (let i = 1; i <= a.length; i++) {
-        const row = [i];
-        for (let j = 1; j <= b.length; j++) {
-            row[j] = Math.min(prev[j] + 1, row[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-        }
-        prev = row;
-    }
-    return prev[b.length];
-}
 /**
  * Emit a transform's `inputs` in the canonical shape the node's runtime reads:
  * `collection` as a BARE variable path (not `=js:`-prefixed — it is a path

package/dist/workdir.d.ts

@@ -33,3 +33,13 @@ export declare function ensureWorkDir(cwd?: string): void;
 export declare function workDirBeside(path: string): string;
 /** The default path of a decompiled source named `file`, creating the work directory. */
 export declare function defaultSourceOut(file: string): string;
+/**
+ * Write a decompiled source to `path`, creating its folder first if it is
+ * missing (`recursive: true`: an existing folder is not an error).
+ *
+ * `-o .flow-sdk/Order.flow.ts` on a fresh workspace has no `.flow-sdk/` yet;
+ * only the default path ({@link defaultSourceOut}) used to create it, so the
+ * documented explicit form failed with ENOENT and the author had to
+ * `mkdir -p` and retry.
+ */
+export declare function writeSource(path: string, text: string): void;

package/dist/workdir.js

@@ -24,7 +24,7 @@
  * rather than split across two places. When both exist, `.flow-sdk/` wins and
  * stderr says the root one is ignored.
  */
-import { existsSync, mkdirSync } from 'node:fs';
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 /** The hidden directory, relative to the current directory. */
 export const WORK_DIR = '.flow-sdk';
@@ -94,3 +94,16 @@ export function defaultSourceOut(file) {
     ensureWorkDir();
     return inWorkDir(file);
 }
+/**
+ * Write a decompiled source to `path`, creating its folder first if it is
+ * missing (`recursive: true`: an existing folder is not an error).
+ *
+ * `-o .flow-sdk/Order.flow.ts` on a fresh workspace has no `.flow-sdk/` yet;
+ * only the default path ({@link defaultSourceOut}) used to create it, so the
+ * documented explicit form failed with ENOENT and the author had to
+ * `mkdir -p` and retry.
+ */
+export function writeSource(path, text) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, text);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.14.5",
+  "version": "6.15.1",
   "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": "b72c8363cd37e75fdd992cfa007d6c6c77c67766"
+  "gitref": "a3707b159a49ed3b6611c55bed66622cb6dd1972"
 }