@uipath/maestro-builder-sdk 5.2.0

package/dist/library.d.ts

@@ -0,0 +1,6 @@
+/**
+ * library — compatibility re-export. The connector library resolver now lives
+ * in `core/` (shared across flow/case/bpmn); this shim preserves the historical
+ * `./library.js` import path.
+ */
+export * from './core/library.js';

package/dist/library.js

@@ -0,0 +1,6 @@
+/**
+ * library — compatibility re-export. The connector library resolver now lives
+ * in `core/` (shared across flow/case/bpmn); this shim preserves the historical
+ * `./library.js` import path.
+ */
+export * from './core/library.js';

package/dist/load.d.ts

@@ -0,0 +1,16 @@
+import type { BuiltFlow } from './flow-sdk.js';
+/** Resolve a user argument (a `.ts` path or a BaseName) to a flow source file. */
+export declare function resolveFlowFile(arg: string): string;
+export declare function loadBuiltFlow(file: string): Promise<BuiltFlow>;
+/**
+ * Turn a failed connector import into an error naming the file that exists.
+ *
+ * Exported for tests. It cannot be exercised through a real `import()` under
+ * vitest: vite resolves `./x.js` to `x.ts` itself, so the import succeeds and
+ * there is no resolution error to diagnose. Node's own loader — what runs in
+ * production — does not, which is the case this handles. So the tests hand it
+ * the error object Node produces instead of trying to provoke one.
+ *
+ * @internal
+ */
+export declare function connectorImportDiagnostic(error: unknown): Error | undefined;

package/dist/load.js

@@ -0,0 +1,95 @@
+/** Shared: dynamic-import an authored flow module and return its BuiltFlow. */
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { basename, dirname, join, resolve } from 'node:path';
+import { statSync } from 'node:fs';
+/** Resolve a user argument (a `.ts` path or a BaseName) to a flow source file. */
+export function resolveFlowFile(arg) {
+    const candidates = [arg, `${arg}.flow.ts`, `${arg}.ts`];
+    const resolvedArg = resolve(arg);
+    const argStat = statSync(resolvedArg, { throwIfNoEntry: false });
+    for (const candidate of candidates) {
+        const resolvedCandidate = resolve(candidate);
+        if (!statSync(resolvedCandidate, { throwIfNoEntry: false })?.isFile())
+            continue;
+        if (candidate !== arg && argStat?.isDirectory()) {
+            console.error(`flow source: "${resolvedArg}" is a directory; using "${resolvedCandidate}"`);
+        }
+        return resolvedCandidate;
+    }
+    throw new Error(`flow source not found: tried ${candidates.join(', ')}`);
+}
+export async function loadBuiltFlow(file) {
+    let mod;
+    try {
+        mod = await import(pathToFileURL(file).href);
+    }
+    catch (error) {
+        throw connectorImportDiagnostic(error) ?? error;
+    }
+    const exp = mod.default ?? mod.flow ?? mod.workflow;
+    if (!exp)
+        throw new Error(`${file} has no default export. Add: export default flow('id')...build();`);
+    const built = typeof exp.build === 'function' ? exp.build() : exp;
+    if (!built || !Array.isArray(built.steps))
+        throw new Error(`${file} default export is not a built flow. Did you call .build()?`);
+    return built;
+}
+/**
+ * Turn a failed connector import into an error naming the file that exists.
+ *
+ * Exported for tests. It cannot be exercised through a real `import()` under
+ * vitest: vite resolves `./x.js` to `x.ts` itself, so the import succeeds and
+ * there is no resolution error to diagnose. Node's own loader — what runs in
+ * production — does not, which is the case this handles. So the tests hand it
+ * the error object Node produces instead of trying to provoke one.
+ *
+ * @internal
+ */
+export function connectorImportDiagnostic(error) {
+    const resolutionError = error;
+    if (!error ||
+        typeof resolutionError.url !== 'string' ||
+        !['ERR_MODULE_NOT_FOUND', 'ERR_UNSUPPORTED_DIR_IMPORT'].includes(String(resolutionError.code))) {
+        return undefined;
+    }
+    let unresolved;
+    try {
+        unresolved = fileURLToPath(resolutionError.url);
+    }
+    catch {
+        return undefined;
+    }
+    // Both trees emit plain `.ts`, so the conventional `./x.js` specifier resolves
+    // to nothing. `connectors-local/` is written by `registry prepare` and keeps
+    // its descriptor data in a sibling directory; `connectors/` is written by
+    // `registry pull` and is modules only. Covering both matters because the pull
+    // is the FIRST thing an author does — without it that path fails with a bare
+    // "Cannot find module" and no clue that the extension is the problem.
+    const parent = basename(dirname(unresolved));
+    if (parent !== 'connectors-local' && parent !== 'connectors')
+        return undefined;
+    // The specifier an author actually writes is `./connectors/<key>.js` — the ESM
+    // convention of naming the compiled output. So the candidate is that path with
+    // `.js` SWAPPED for `.ts`, not `.ts` appended: appending produced
+    // `<key>.js.ts`, which never exists, so this diagnostic only fired for an
+    // extensionless import and was therefore unreachable in practice.
+    const stem = unresolved.endsWith('.js')
+        ? unresolved.slice(0, -'.js'.length)
+        : unresolved;
+    const moduleFile = `${stem}.ts`;
+    if (!statSync(moduleFile, { throwIfNoEntry: false })?.isFile()) {
+        return undefined;
+    }
+    if (parent === 'connectors') {
+        return new Error(`connector import "${unresolved}" does not name a file. The generated ` +
+            `descriptors are TypeScript, so the specifier keeps its real extension; ` +
+            `import "${moduleFile}"`);
+    }
+    const descriptorData = join(dirname(unresolved), 'descriptors', basename(stem));
+    if (!statSync(descriptorData, { throwIfNoEntry: false })?.isDirectory()) {
+        return undefined;
+    }
+    return new Error(`connector import "${unresolved}" does not name a file; module candidate ` +
+        `"${moduleFile}" and descriptor data "${descriptorData}" are separate; ` +
+        `import "${moduleFile}"`);
+}

package/dist/merge-cli.d.ts

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

package/dist/merge-cli.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+/**
+ * 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>]
+ *
+ * `edited.flow` is compile(decompile(original) after your edits). `--baseline`
+ * is compile(decompile(original)) BEFORE any edit — supplying it enables the
+ * delta merge (untouched nodes keep their original content, placeholder-safe);
+ * omit it for a two-way merge (take the edited graph, re-attach original layout).
+ * See merge.ts.
+ */
+import { readFileSync, writeFileSync } from 'node:fs';
+import { basename } from 'node:path';
+import { mergeFlow } from './merge.js';
+import { runWhenInvokedDirectly } from './cli-run.js';
+function opt(argv, name) {
+    const i = argv.indexOf(name);
+    return i >= 0 ? argv[i + 1] : undefined;
+}
+export 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>]');
+        return 2;
+    }
+    const flags = new Set(['-o', '--baseline']);
+    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 = opt(argv, '--baseline');
+    const baseline = baselinePath ? JSON.parse(readFileSync(baselinePath, 'utf8')) : undefined;
+    const merged = mergeFlow(original, edited, {
+        baseline,
+        warn: (m) => console.error(`flow-merge: warning: ${m}`),
+    });
+    const out = opt(argv, '-o') ?? 'merged.flow';
+    writeFileSync(out, JSON.stringify(merged, null, 2) + '\n');
+    console.log(`flow-merge: wrote ${basename(out)} (${(merged.nodes ?? []).length} nodes, ${(merged.edges ?? []).length} edges)`);
+    return 0;
+}
+runWhenInvokedDirectly(import.meta.url, 'flow-merge', run);

package/dist/merge.d.ts

@@ -0,0 +1,125 @@
+/**
+ * merge — write a decompiled-then-edited flow back into the ORIGINAL `.flow`
+ * JSON, splicing in only what changed and preserving everything cosmetic or
+ * mechanically-reconstructable.
+ *
+ * The brownfield pipeline is:
+ *
+ *   original.flow --decompile--> Flow.flow.ts --(edit)--> --compile--> edited.flow
+ *   mergeFlow(original, edited[, baseline]) --> merged.flow
+ *
+ * Why not just take `edited` wholesale? Because decompile is **semantically**
+ * lossless, not byte-for-byte: it discards layout, and it lowers node types it
+ * cannot yet fully invert (some agents / IxP / …) to `mock()` placeholders. A
+ * blind overwrite would flatten an untouched connector's layout and turn an
+ * untouched agent into a mock. So the merge is a **delta**:
+ *
+ *   - `baseline` (optional) = compile(decompile(original)) BEFORE any edit — i.e.
+ *     what a faithful round-trip of the original produces. When a node in
+ *     `edited` is byte-equal to its `baseline` counterpart, the user did NOT
+ *     touch it, so the merge keeps the ORIGINAL node verbatim (its real type,
+ *     inputs, layout — even for a placeholder). Only nodes the user actually
+ *     changed (or added) are taken from `edited`.
+ *   - Without a `baseline`, the merge is two-way: it takes `edited`'s graph and
+ *     re-attaches the original layout by node-id match. This is correct as long
+ *     as decompile was faithful for every node (the common case).
+ *
+ * Layout, `metadata`, `solutionId`, `projectId`, `runtime` and `layout` are
+ * preserved from the original; `definitions` and `bindings` are unioned
+ * (original wins on conflict, since the original's are the tenant-resolved
+ * authority). Node ids are stable by construction (decompile names every step by
+ * its node id), which is what lets every re-attach key on id.
+ *
+ * ## Definitions are keyed by `nodeType@version`, not by `nodeType`
+ *
+ * The node array a merge produces is deliberately MIXED: an untouched node is
+ * emitted from the original (so it keeps the original's `typeVersion`), while an
+ * edited or added one comes from `edited` (so it carries whatever version the
+ * SDK resolved). Both are correct. What was not correct was keying
+ * `definitions[]` by `nodeType` alone — one slot per type, original winning —
+ * because that dropped the edited file's definition for a type whose version
+ * differed, and left the added node pointing at a version the emitted
+ * `definitions[]` no longer contained:
+ *
+ *     nodes:       convertToCelsius core.action.script@1.0.0
+ *     definitions: core.action.script@1.0        <- original won, 1.0.0 discarded
+ *     → validate: Node type "core.action.script:1.0.0" has no matching definition
+ *
+ * That is flow-builder-sdk#673's second-order failure: it fires on any
+ * STRUCTURAL edit (add / move / remove / regroup a node) and never on an
+ * in-place field edit, because `nodeUnchanged` keys on type+inputs only. Every
+ * agent that hit it abandoned the merge and copied `edited.flow` over the
+ * target, which is how a brownfield edit silently rewrote every untouched
+ * node's version.
+ *
+ * So the union is keyed by the `(nodeType, version)` PAIR and selected by the
+ * pairs the final node array actually uses. Pair-keying also makes the emitted
+ * `definitions[]` able to hold two versions of one family at once — which the
+ * format always allowed, which the bundle already ships (`core.logic.loop@1.0.0`
+ * + `@2.4`), and which a flow legitimately needs when the author pins one node
+ * to an older version and takes the default on another.
+ *
+ * A node whose pair is in NEITHER file cannot be given a definition here, and a
+ * merge that stayed silent about it wrote a file it already knew would fail
+ * `validate`. Those are reported through {@link MergeOptions.warn}.
+ */
+interface AnyNode {
+    id: string;
+    type: string;
+    typeVersion?: string;
+    parentId?: string;
+    ui?: unknown;
+    display?: unknown;
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    [k: string]: unknown;
+}
+interface AnyEdge {
+    id?: string;
+    sourceNodeId: string;
+    sourcePort: string;
+    targetNodeId: string;
+    targetPort: string;
+    [k: string]: unknown;
+}
+interface AnyFlow {
+    id?: string;
+    name?: string;
+    version?: string;
+    nodes?: AnyNode[];
+    edges?: AnyEdge[];
+    definitions?: Array<{
+        nodeType?: string;
+        [k: string]: unknown;
+    }>;
+    variables?: unknown;
+    subflows?: Record<string, unknown>;
+    bindings?: Array<{
+        id?: string;
+        [k: string]: unknown;
+    }>;
+    metadata?: unknown;
+    solutionId?: unknown;
+    projectId?: unknown;
+    layout?: unknown;
+    runtime?: unknown;
+    [k: string]: unknown;
+}
+export interface MergeOptions {
+    /**
+     * compile(decompile(original)) captured BEFORE the user's edits. Enables the
+     * delta merge: a node byte-equal to its baseline is treated as untouched and
+     * kept from the original. Omit for a two-way merge (take `edited`, re-attach
+     * original layout by id).
+     */
+    baseline?: AnyFlow;
+    /**
+     * Called once per finding, mirroring `DecompileOptions.warn`. Today the only
+     * finding is a node whose `(type, typeVersion)` pair has no definition in
+     * either input — the one case where the merge cannot produce a self-consistent
+     * file and `validate` will refuse the result.
+     */
+    warn?: (message: string) => void;
+}
+export declare function mergeFlow(original: AnyFlow, edited: AnyFlow, options?: MergeOptions): AnyFlow;
+export {};

package/dist/migrate.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Bring a freshly-built FlowFile up to `target`, the file-format version the
+ * document will declare.
+ *
+ * @param flow - The serializer's in-progress FlowFile, mutated in place.
+ * @param target - The declared target version. Defaults to the profile pin, so
+ * every existing caller keeps its behaviour exactly.
+ */
+export declare function migrateToSchemaVersion(flow: any, target?: string): void;
+/**
+ * @deprecated Use {@link migrateToSchemaVersion}. Kept because the name says
+ * "1.6" while the function has emitted the profile's version for several floors
+ * now — the rename is the point, and callers that pass no target are unchanged.
+ */
+export declare function migrateTo16(flow: any): void;

package/dist/migrate.js

@@ -0,0 +1,245 @@
+/**
+ * Node inputs the wrap must LEAVE ALONE, keyed by node-type prefix.
+ *
+ * The envelope is the current file format's general spelling for a dynamic
+ * value, and wrapping by a blanket `startsWith('=')` rule is right almost
+ * everywhere. It is not right everywhere, and the platform's own migration says
+ * so out loud: `migrateV1_2_to_v1_3` skips `node.inputs` entirely for the agent
+ * families (`isAgentNodeType` / `isAgentResourceNodeType`, flow-v1
+ * `packages/migrations/src/migrations/v1.2-to-v1.3.ts:187`) because "their
+ * prompt/template inputs flow through agent.json + the PromptEditor, neither of
+ * which is EV-aware". This SDK mirrored the wrap without mirroring the
+ * exemption mechanism, and one field paid for it.
+ *
+ * **`uipath.ixp.*` → `fileRef`** (card ga7, measured 2026-08-01):
+ *
+ *   - `uip maestro flow validate` REFUSES the envelope outright. The product's
+ *     `ixp-node` validator tests `typeof fileRef !== 'string'` and errors with
+ *     *"inputs.fileRef must be a `=js:$vars.…` expression"*
+ *     (uipath-cli `packages/flow-tool/src/services/node-validators/ixp-node-validator.ts:78`).
+ *     That is criterion 1 of GA row 7, weight 3.0 — so every SDK-authored IxP
+ *     flow was failing 30% of that row's bar.
+ *   - The node's OWN registry manifest agrees: `inputDefinition.properties.fileRef`
+ *     is `{ type: 'string', minLength: 1 }` (`ixp-definition.json`, pulled
+ *     2026-07-31), and an object satisfies neither half.
+ *   - So does the deployed corpus: of the **150** v1-authored `uipath.ixp.*`
+ *     nodes in `~/root/workspaces/runs` that carry a `fileRef`, **150 carry a
+ *     STRING** (148 the `=js:$vars.…` expression form, 2 a literal) and **ZERO
+ *     carry an envelope**. The only 18 envelopes anywhere are this SDK's own
+ *     output. Spread across file versions 1.6, 1.8 AND 1.9, so this is NOT an
+ *     era difference — 1.9 is the newest era present and spells it the same way.
+ *     (Reproduce: `runs/flow-sdk-ga7-2026-08-01/ixp-fileref-scan.py`.)
+ *
+ * Why the bug survived a platform run: the RUNTIME accepts both. G-19/G-20's
+ * `flow debug` runs Completed with the envelope and really extracted six fields
+ * from the real PDF, so nothing before this card had reason to look. `flow
+ * validate` is the only reader that refuses it, and it was never run on an
+ * SDK-authored IxP flow until now (lesson 45, one family over).
+ */
+import { FLOW_FORMAT_PROFILE } from './format-profile.js';
+import { schemaVersionAtLeast } from './schema-version.js';
+import { readFlowGlobals } from './flow-variables.js';
+const UNWRAPPED_INPUTS = [
+    { typePrefix: 'uipath.ixp.', keys: new Set(['fileRef']) },
+];
+/** True if `key` on a node of type `nodeType` must stay a plain string. */
+function isUnwrappedInput(nodeType, key) {
+    if (typeof nodeType !== 'string')
+        return false;
+    return UNWRAPPED_INPUTS.some((r) => nodeType.startsWith(r.typePrefix) && r.keys.has(key));
+}
+/**
+ * The only `fieldType` values `@uipath/flow-schema`'s `expressionValueSchema`
+ * accepts (it is `.strict()`, so anything else fails the file's schema and with
+ * it every migration hop and `uip maestro flow validate`).
+ */
+const FIELD_TYPES = new Set(['string', 'number', 'boolean', 'object', 'array', 'null']);
+/**
+ * The emission steps that are CONDITIONAL on the target file-format version,
+ * newest gate last.
+ *
+ * The ladder exists because a declared version is a claim about the whole
+ * document (`schema-version.ts`), so "which target am I writing?" has to be
+ * able to change what gets written — the alternative is stamping a version and
+ * hoping the bytes match it. Today one step is version-gated and it is the
+ * expression envelope: the `{ type, expression, fieldType }` spelling is the
+ * 1.6-and-later form, so the gate is `>= 1.6` rather than unconditional.
+ *
+ * Nothing in this table distinguishes 1.9 from 1.10, and that is a READ result
+ * rather than an omission: `workflowSchemaV1_10` is `workflowSchemaV1_9.extend`
+ * with a new `version` literal, and the 1.9 -> 1.10 hop is a binding-name data
+ * repair for a defect this SDK cannot emit (see `FLOW_SCHEMA_VERSIONS`). The
+ * first genuine divergence gets a row here, and gets it in one place.
+ */
+const VERSION_CONDITIONAL = [
+    {
+        from: '1.6',
+        what: 'wrap dynamic values into the { type, expression, fieldType } envelope',
+        apply: wrapDynamicValues,
+    },
+];
+/**
+ * Bring a freshly-built FlowFile up to `target`, the file-format version the
+ * document will declare.
+ *
+ * @param flow - The serializer's in-progress FlowFile, mutated in place.
+ * @param target - The declared target version. Defaults to the profile pin, so
+ * every existing caller keeps its behaviour exactly.
+ */
+export function migrateToSchemaVersion(flow, target = FLOW_FORMAT_PROFILE.version) {
+    flow.version = target;
+    delete flow.metadata;
+    for (const step of VERSION_CONDITIONAL)
+        if (schemaVersionAtLeast(target, step.from))
+            step.apply(flow);
+}
+/**
+ * @deprecated Use {@link migrateToSchemaVersion}. Kept because the name says
+ * "1.6" while the function has emitted the profile's version for several floors
+ * now — the rename is the point, and callers that pass no target are unchanged.
+ */
+export function migrateTo16(flow) {
+    migrateToSchemaVersion(flow);
+}
+function wrapDynamicValues(flow) {
+    const schemaByType = new Map();
+    for (const d of flow.definitions ?? []) {
+        schemaByType.set(d.nodeType, {
+            inputs: d.inputDefinition?.properties,
+            outputs: d.outputDefinition?.properties,
+        });
+    }
+    const globalTypeByName = new Map();
+    for (const g of readFlowGlobals(flow.variables))
+        if (g.id && g.type)
+            globalTypeByName.set(g.id, g.type);
+    const subflows = (flow.subflows ?? {});
+    wrapNodes(flow.nodes ?? [], schemaByType, globalTypeByName, subflows);
+    wrapVariableUpdates(flow.variables, globalTypeByName);
+    for (const sub of Object.values(subflows)) {
+        // Each subflow body has its OWN globals — an End node inside it maps the
+        // subflow's outputs, not the parent flow's, so the fieldType lookup has to
+        // follow the scope. (Before subflows existed this always fell back to
+        // "string", which is right only by accident for a string-typed output.)
+        const scopeTypes = new Map();
+        for (const g of readFlowGlobals(sub?.variables))
+            if (g.id && g.type)
+                scopeTypes.set(g.id, g.type);
+        wrapNodes(sub?.nodes ?? [], schemaByType, scopeTypes, subflows);
+        wrapVariableUpdates(sub?.variables, scopeTypes);
+    }
+}
+function wrapNodes(nodes, schemaByType, globalTypeByName, subflows = {}) {
+    for (const n of nodes) {
+        const schema = schemaByType.get(n.type);
+        // A subflow node's inputs are declared by its BODY, not by its type
+        // (`core.subflow` has no inputDefinition), so its fieldTypes come from the
+        // subflow's `in` variables — keyed, as everywhere, by the node's own id.
+        const childInputType = new Map();
+        if (n.type === 'core.subflow') {
+            for (const g of readFlowGlobals(subflows[n.id]?.variables))
+                if (g?.direction === 'in' && g.id && g.type)
+                    childInputType.set(g.id, g.type);
+        }
+        if (n.inputs) {
+            for (const [k, v] of Object.entries(n.inputs)) {
+                if (typeof v !== 'string')
+                    continue;
+                if (isWrappedSource(v))
+                    continue;
+                // The platform reads a few inputs as plain `=js:` strings and refuses
+                // the envelope on them — see UNWRAPPED_INPUTS for each one's evidence.
+                if (isUnwrappedInput(n.type, k))
+                    continue;
+                const declared = fieldTypeOf(childInputType.get(k) ?? schema?.inputs?.[k]?.type);
+                if (v.startsWith('=') || declared !== 'string')
+                    n.inputs[k] = wrap(v, declared);
+            }
+        }
+        if (n.outputs) {
+            for (const [k, vobj] of Object.entries(n.outputs)) {
+                if (!vobj || typeof vobj !== 'object')
+                    continue;
+                const src = vobj.source;
+                if (typeof src !== 'string' || isWrappedSource(src))
+                    continue;
+                const declared = fieldTypeOf(n.type === 'core.control.end' || n.type === 'core.logic.terminate'
+                    ? globalTypeByName.get(k)
+                    : schema?.outputs?.[k]?.type);
+                vobj.source = wrap(src, declared);
+            }
+        }
+    }
+}
+/**
+ * `variables.variableUpdates[*][*].expression` — an ExpressionValue object, not
+ * a string, from file version **1.3** on: the 1.2→1.3 migration is what
+ * converted the legacy strings ("Migration v1.2 → v1.3 converts legacy
+ * strings", `v1_3VariableUpdateSchema` in `@uipath/flow-schema`), and every
+ * later version inherits that shape.
+ *
+ * Leaving them as raw strings while declaring 1.8 makes the file
+ * self-inconsistent, and the product rejects it at the first migration hop it
+ * tries — `uip maestro flow validate` reports
+ * `[MIGRATION] Workflow migration failed at 1.8→1.9 … Offending field(s):
+ * variables.variableUpdates.end.0.expression`, because each migration validates
+ * its input against that version's schema. (Only flows that write a variable —
+ * i.e. every flow with a `.return(…)` — carry the field at all, which is why
+ * connector-only fixtures passed while any flow with an End-node update failed.)
+ */
+function wrapVariableUpdates(variables, typeByName) {
+    const byNode = variables?.variableUpdates;
+    if (!byNode || typeof byNode !== 'object')
+        return;
+    for (const updates of Object.values(byNode)) {
+        for (const u of updates ?? []) {
+            if (!u || typeof u.expression !== 'string')
+                continue;
+            u.expression = wrap(u.expression, fieldTypeOf(typeByName.get(u.variableId)));
+        }
+    }
+}
+function isWrappedSource(v) {
+    return typeof v === 'object' && v !== null && 'type' in v && 'expression' in v && 'fieldType' in v;
+}
+/**
+ * Normalize a declared type to a `fieldType` the platform's schema accepts,
+ * mirroring flow-schema's own `jsonSchemaTypeToFieldType` +
+ * `expectedTypeToFieldType`: `integer`→`number`, `text`→`string`, a JSON-Schema
+ * type UNION (`["object","null"]`, which `core.action.http`'s
+ * `swaggerDefinition` declares) → its first mappable member, and anything else
+ * — including the SDK's own `types.file` / `types.any` — → `string`, the
+ * platform's own default.
+ *
+ * Without this a single `.output({ blob: types.any })` (or any node input typed
+ * `integer`, of which the connector library has 593) emitted `fieldType: "any"`
+ * and made the whole file unparseable: `expressionValueSchema` is `.strict()`
+ * over a six-value enum.
+ */
+function fieldTypeOf(declared) {
+    if (Array.isArray(declared)) {
+        for (const t of declared) {
+            const mapped = mapScalarType(t);
+            if (mapped)
+                return mapped;
+        }
+        return 'string';
+    }
+    return mapScalarType(declared) ?? 'string';
+}
+function mapScalarType(t) {
+    if (typeof t !== 'string')
+        return undefined;
+    if (FIELD_TYPES.has(t))
+        return t;
+    if (t === 'integer')
+        return 'number';
+    if (t === 'text')
+        return 'string';
+    return undefined;
+}
+function wrap(value, fieldType) {
+    if (value.startsWith('=js:'))
+        return { type: 'jsExpression', expression: value.slice(4), fieldType };
+    return { type: 'literal', expression: value, fieldType };
+}

package/dist/node-runtime.d.ts

@@ -0,0 +1,3 @@
+export type TypeStripDecision = 'native' | 'flag' | 'unsupported';
+export declare function typeStripDecision(version: string, execArgv?: readonly string[]): TypeStripDecision;
+export declare function ensureTypeScriptRuntime(): void;

package/dist/node-runtime.js

@@ -0,0 +1,22 @@
+import { spawnSync } from 'node:child_process';
+export function typeStripDecision(version, execArgv = []) {
+    const [major = 0, minor = 0] = version.split('.').map(Number);
+    if (major >= 23 || (major === 22 && minor >= 18))
+        return 'native';
+    if (major === 22 && minor >= 6) {
+        return execArgv.includes('--experimental-strip-types') ? 'native' : 'flag';
+    }
+    return 'unsupported';
+}
+export function ensureTypeScriptRuntime() {
+    const decision = typeStripDecision(process.versions.node, process.execArgv);
+    if (decision === 'native')
+        return;
+    if (decision === 'unsupported') {
+        throw new Error(`authoring TypeScript requires Node >= 22.6 (found ${process.versions.node}); install Node 22 LTS or newer`);
+    }
+    const child = spawnSync(process.execPath, ['--experimental-strip-types', ...process.execArgv, ...process.argv.slice(1)], { stdio: 'inherit', env: process.env });
+    if (child.error)
+        throw child.error;
+    process.exit(child.status ?? 1);
+}

package/dist/package-name.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The published package name, in one place.
+ *
+ * Four CLIs and the registry materializer bake this into the `import { … } from
+ * '…'` line of the source they emit, so that decompiled and generated files
+ * resolve for a package consumer rather than only inside this checkout. Before
+ * the rename to `@uipath/maestro-builder-sdk` those were five independent string
+ * literals; a sixth emitter would have been a sixth. Import the constant.
+ *
+ * These are the *defaults* — every emitter still takes `--import` to override
+ * the specifier, which is what an in-tree or vendored consumer uses.
+ */
+export declare const PACKAGE_NAME = "@uipath/maestro-builder-sdk";
+/** The `./case` subpath export. */
+export declare const CASE_IMPORT = "@uipath/maestro-builder-sdk/case";
+/** The `./bpmn` subpath export. */
+export declare const BPMN_IMPORT = "@uipath/maestro-builder-sdk/bpmn";

package/dist/package-name.js

@@ -0,0 +1,17 @@
+/**
+ * The published package name, in one place.
+ *
+ * Four CLIs and the registry materializer bake this into the `import { … } from
+ * '…'` line of the source they emit, so that decompiled and generated files
+ * resolve for a package consumer rather than only inside this checkout. Before
+ * the rename to `@uipath/maestro-builder-sdk` those were five independent string
+ * literals; a sixth emitter would have been a sixth. Import the constant.
+ *
+ * These are the *defaults* — every emitter still takes `--import` to override
+ * the specifier, which is what an in-tree or vendored consumer uses.
+ */
+export const PACKAGE_NAME = '@uipath/maestro-builder-sdk';
+/** The `./case` subpath export. */
+export const CASE_IMPORT = `${PACKAGE_NAME}/case`;
+/** The `./bpmn` subpath export. */
+export const BPMN_IMPORT = `${PACKAGE_NAME}/bpmn`;