@uipath/maestro-builder-sdk 6.14.0 → 6.14.1

package/dist/bpmn/decompile.js

@@ -54,7 +54,7 @@
  */
 import BpmnModdle from 'bpmn-moddle';
 import { createRequire } from 'node:module';
-import { registryType } from './typed-node.js';
+import { registryType, rowDeclaration } from './typed-node.js';
 import { errorSchema, errorSchemaWithResponse } from './bpmn-sdk.js';
 import { BPMN_SCHEMA_VERSIONS } from './format-profile.js';
 import { preserveSchemaVersion } from '../schema-version.js';
@@ -66,6 +66,15 @@ const uipathDescriptor = require('./uipath-moddle.v1.json');
  * then double every edge, so the body pins `.flowMode('explicit')` for itself.
  */
 let pinExplicitInBodies = false;
+/**
+ * Variable id → the schema expression its declaration carries, for declarations being
+ * FOLDED onto the output row that fills them (`TypedOutputRow.varSchema`).
+ *
+ * Set for the length of one decompile, beside `pinExplicitInBodies` and for the same
+ * reason: the row emitters are reached through a dozen element emitters that have no
+ * business carrying a document-wide table.
+ */
+let foldedVarSchemas;
 // ─── Source emitters ──────────────────────────────────────────────────────────
 /**
  * A JS/TS string literal.
@@ -191,6 +200,14 @@ function opts(entries) {
     const parts = entries.filter(([, v]) => v !== undefined).map(([k, v]) => `${key(k)}: ${v}`);
     return parts.length ? `{ ${parts.join(', ')} }` : '';
 }
+/**
+ * The same option pairs as {@link opts}, but as the TAIL of a literal that already has
+ * a field — `{ id: 'x'` + `, name: 'y', … }` — for the array forms.
+ */
+function inner(entries) {
+    const parts = entries.filter(([, v]) => v !== undefined).map(([k, v]) => `${key(k)}: ${v}`);
+    return parts.length ? `, ${parts.join(', ')}` : '';
+}
 /** A record literal, or `undefined` when the record is empty. */
 function record(r) {
     if (!r || Object.keys(r).length === 0)
@@ -199,6 +216,17 @@ function record(r) {
         .map(([k, v]) => `${key(k)}: ${typeof v === 'string' ? str(v) : literal(v)}`)
         .join(', ')} }`;
 }
+/**
+ * An array-form call — `.bindings([…])`, `.vars([…])`, `.schemas([…])` — one entry per
+ * line, indented under the method.
+ *
+ * The singular calls still exist and still work; this is what `decompile` writes,
+ * because a real process declares dozens of each and a column of repeated method
+ * names is a wall to read past rather than a table to read.
+ */
+function arrayCall(method, entries, indent) {
+    return `.${method}([\n${entries.map((e) => `${indent}  ${e},`).join('\n')}\n${indent}])`;
+}
 /** A collector for the fluent chain's lines. */
 class Chain {
     indent;
@@ -436,6 +464,8 @@ function outputRowsNeedSpellingOut(payload) {
         row.custom !== undefined ||
         row.description !== undefined ||
         row.target !== undefined ||
+        // A folded declaration lives in `varSchema`, which only the long form has.
+        (row.var !== undefined && foldedVarSchemas?.has(row.var) === true) ||
         (row.var !== undefined && row.var !== row.name));
 }
 /** The output rows as `TypedOutputRow` option source, in document order. */
@@ -455,6 +485,8 @@ function emitOutputRows(payload) {
         // schema is carried, never interpreted, so nothing here can reorder its keys
         // or drop a field this SDK does not know about.
         ['schema', row.body !== undefined ? jsonLiteral(row.body) : undefined],
+        // The declaration this row fills, folded onto the row — see `derivedVariableIds`.
+        ['varSchema', row.var !== undefined ? foldedVarSchemas?.get(row.var) : undefined],
     ]));
     return `[${rendered.join(', ')}]`;
 }
@@ -1672,33 +1704,77 @@ defaultScope = () => ownerId) {
         return;
     const groups = [
         ['input', 'input'],
-        ['inputOutput', 'var'],
+        ['inputOutput', 'inputOutput'],
         ['output', 'output'],
     ];
-    for (const [prop, method] of groups) {
+    // One `.vars([…])` for all three directions, in document order, so the block reads as
+    // the table the variables panel shows. `direction` is written only where it is not
+    // the `inputOutput` default — the shape `.var()` has always had.
+    const entries = [];
+    for (const [prop, direction] of groups) {
         for (const v of vars[prop] ?? []) {
             if (skip.has(v.id))
                 continue;
             const type = varType(v.type);
             const def = v.default === undefined ? undefined : decodeDefault(v.default, v.type);
-            chain.add(`.${method}(${str(v.id)}, ${str(type)}${optionalArg(opts([
+            entries.push(`{ id: ${str(v.id)}, type: ${str(type)}${inner([
+                ['direction', direction === 'inputOutput' ? undefined : str(direction)],
                 ['name', v.name !== undefined && v.name !== v.id ? str(v.name) : undefined],
                 ['default', def],
                 ['schema', v.body !== undefined ? (plan?.ref.get(String(v.body)) ?? jsonLiteral(v.body)) : undefined],
                 ['required', v.required !== undefined ? 'true' : undefined],
+                ['custom', v.custom !== undefined ? 'true' : undefined],
+                ['internal', v.internal !== undefined ? 'true' : undefined],
+                ['subType', v.subType !== undefined ? str(v.subType) : undefined],
                 ['elementId', emitElementId(v.elementId, defaultScope(prop, v), rehome)],
-            ]))})`);
+            ])} }`);
         }
     }
+    if (entries.length)
+        chain.add(arrayCall('vars', entries, chain.indent));
 }
-/** A variable `default` attribute back into the TS literal it came from. */
+/**
+ * Whether anything in the document reads this binding.
+ *
+ * Deliberately textual and deliberately over-eager: a reference is written
+ * `=bindings.<id>` in a context value, but it can also sit inside a CDATA body, a
+ * script, or designer metadata, and a structural walk that missed one would DELETE a
+ * live binding. Matching the id anywhere in the raw XML, on a word boundary, can only
+ * err by keeping a dead row.
+ *
+ * The id is escaped because a binding id is free text: a hand-authored one is a label
+ * (`slack`, `shared`), not the `b`-prefixed nonce the designer generates.
+ */
+function bindingIsReferenced(xml, id) {
+    if (!id)
+        return true;
+    return new RegExp(String.raw `bindings\.${id.replace(/[.*+?^${}()|[\]\\]/g, String.raw `\$&`)}\b`).test(xml);
+}
+/**
+ * A variable `default` attribute back into the TS literal it came from.
+ *
+ * A default is not always a literal of the declared type: the product lets one be an
+ * `=`-EXPRESSION, evaluated at instance start, whatever the variable's type. Such a
+ * default has to survive as its own text. The boolean arm used to decide `raw ===
+ * 'true' ? 'true' : 'false'`, which is total — so a real export's
+ * `type="boolean" default="=js:true"` came back `default="false"`, silently inverting
+ * a process input that gates a whole branch (`claims-intake-hitl`'s
+ * `in_usePlaceholderData`). The number arm already fell through to a string on
+ * anything non-finite, so it was right by accident; this makes the rule explicit for
+ * every type.
+ */
 function decodeDefault(raw, wire) {
+    if (raw.startsWith('='))
+        return str(raw); // an expression, not a value of `wire`
     if (wire === 'json')
         return raw; // already JSON — emit it verbatim
     if (wire === 'number')
         return Number.isFinite(Number(raw)) ? String(Number(raw)) : str(raw);
+    // Only the two literals are booleans. Anything else — an empty `default=""`, which
+    // a real export writes to mean "no value" — is text, and collapsing it to `false`
+    // is the same silent inversion as the expression case above.
     if (wire === 'boolean' || wire === 'bool')
-        return raw === 'true' ? 'true' : 'false';
+        return raw === 'true' || raw === 'false' ? raw : str(raw);
     return str(raw);
 }
 // ─── Entry point ──────────────────────────────────────────────────────────────
@@ -1805,44 +1881,82 @@ export async function decompile(xml, options = {}) {
     // Bindings next: a typed node may reference one, and reading the declarations
     // before the nodes keeps the emitted source in dependency order.
     const bindings = (host.container.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:Bindings');
+    const droppedBindings = [];
+    const bindingEntries = [];
     for (const b of bindings?.binding ?? []) {
-        chain.add(`.binding(${str(b.id)}, ${opts([
+        if (!options.keepUnusedBindings && !bindingIsReferenced(xml, b.id)) {
+            droppedBindings.push(b.id);
+            continue;
+        }
+        bindingEntries.push(`{ id: ${str(b.id)}${inner([
             ['name', b.name !== undefined && b.name !== b.id ? str(b.name) : undefined],
             ['value', b.default !== undefined ? str(b.default) : undefined],
             ['resource', b.resource !== undefined && b.resource !== 'custom' ? str(b.resource) : undefined],
             ['resourceKey', b.resourceKey !== undefined && b.resourceKey !== b.default ? str(b.resourceKey) : undefined],
             ['propertyAttribute', b.propertyAttribute !== undefined && b.propertyAttribute !== 'value' ? str(b.propertyAttribute) : undefined],
             ['resourceSubType', b.resourceSubType !== undefined ? str(b.resourceSubType) : undefined],
-        ])})`);
+        ])} }`);
     }
-    // Variables the serializer DERIVES from a node's output are re-derived on
-    // recompile, so echoing them would double-declare. Skip exactly those.
-    const derived = derivedVariableIds(process);
+    if (bindingEntries.length)
+        chain.add(arrayCall('bindings', bindingEntries, chain.indent));
+    if (droppedBindings.length)
+        options.onPrune?.(droppedBindings);
     // Count the bodies first: whether one is written inline or shared depends on how
     // many variables carry it, which is only knowable across the whole document.
     const varsExt = (host.container.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:Variables');
+    // Variables the serializer DERIVES from a node's output are re-derived on
+    // recompile, so echoing them would double-declare. Skip exactly those.
+    //
+    // The declarations come from `host.container`, not from `process`: a pool-shaped
+    // export hangs them off the `bpmn:collaboration`, and reading them off the process
+    // found none, so NOTHING was recognised as derived and every declaration was echoed
+    // by hand. That was invisible — an echoed declaration takes the id before
+    // `implicitNodeVars` can claim it, so the output was correct, just 112 lines of it.
+    const { ids: derived, folds } = derivedVariableIds(process, varsExt, host.rehome);
     const schemaPlan = planSchemas([
         ...(varsExt?.input ?? []),
         ...(varsExt?.inputOutput ?? []),
         ...(varsExt?.output ?? []),
     ]);
-    for (const [id, body] of schemaPlan.declare)
-        chain.add(`.schema(${str(id)}, ${body})`);
-    emitVariablesInto(chain, host.container, host.rehome?.to ?? host.container.id, derived, host.rehome, schemaPlan, publicDeclarationScopeOf(process, host.rehome?.to ?? host.container.id));
-    if (options.style === 'nested') {
-        const sequence = options.sequenceMode ?? true;
-        const summary = { handlers: 0, branches: 0, nets: 0, leftFlat: [], renamedFlows: [], sequence };
-        pinExplicitInBodies = sequence;
-        try {
-            emitScopeNested(chain, process, 0, indent, summary, options.relabelFlows ?? true, sequence);
+    const schemaEntries = [...schemaPlan.declare].map(([id, body]) => `{ id: ${str(id)}, body: ${body} }`);
+    if (schemaEntries.length)
+        chain.add(arrayCall('schemas', schemaEntries, chain.indent));
+    // A folded body is written the way a declaration's would be — through the shared
+    // `.schema()` plan when the document repeats it, inline when it does not — so
+    // folding a declaration onto its row does not un-share a schema 27 nodes use.
+    foldedVarSchemas = new Map([...folds].map(([id, body]) => [id, schemaPlan.ref.get(String(body)) ?? jsonLiteral(body)]));
+    // A folded declaration is not written as a `.var()`, so its POSITION in the block
+    // would be lost — derived declarations are appended after the declared ones, and the
+    // designer's order is not recoverable from anything else (it follows the owning
+    // element's document order in none of the five corpus files). Carry it in the
+    // preservation block, which is where state like this goes and what says "not for
+    // hand-editing". Only when something was actually folded: a document of explicit
+    // `.var()` calls already states its order by their position, and the extra line would
+    // be noise.
+    if (derived.size) {
+        const ids = [...(varsExt?.input ?? []), ...(varsExt?.inputOutput ?? []), ...(varsExt?.output ?? [])].map((v) => v.id);
+        chain.add(`.preserve({ variableOrder: [${ids.map(str).join(', ')}] })`);
+    }
+    try {
+        emitVariablesInto(chain, host.container, host.rehome?.to ?? host.container.id, derived, host.rehome, schemaPlan, publicDeclarationScopeOf(process, host.rehome?.to ?? host.container.id));
+        if (options.style === 'nested') {
+            const sequence = options.sequenceMode ?? true;
+            const summary = { handlers: 0, branches: 0, nets: 0, leftFlat: [], renamedFlows: [], sequence };
+            pinExplicitInBodies = sequence;
+            try {
+                emitScopeNested(chain, process, 0, indent, summary, options.relabelFlows ?? true, sequence);
+            }
+            finally {
+                pinExplicitInBodies = false;
+            }
+            options.onLift?.(summary);
         }
-        finally {
-            pinExplicitInBodies = false;
+        else {
+            emitScope(chain, process, 0, indent);
         }
-        options.onLift?.(summary);
     }
-    else {
-        emitScope(chain, process, 0, indent);
+    finally {
+        foldedVarSchemas = undefined;
     }
     const importFrom = options.importSpecifier ?? './bpmn-sdk.js';
     const imported = ['bpmn', ...[...schemaPlan.imports].sort()].join(', ');
@@ -1876,8 +1990,10 @@ export async function decompile(xml, options = {}) {
  * the HITL case in the round-trip table missed it only because its mapped row writes
  * `decision` while its declared variable is `o`.
  */
-function derivedVariableIds(process) {
-    // var id -> [owner element id, wire type the derived declaration carries]
+function derivedVariableIds(process, varsExt, 
+/** The collaboration→process re-parenting, so `elementId` is compared post-move. */
+rehome) {
+    // var id -> the declaration `implicitNodeVars` would derive for it
     const candidates = new Map();
     const walk = (container) => {
         for (const el of container.flowElements ?? []) {
@@ -1887,11 +2003,29 @@ function derivedVariableIds(process) {
             // not derived. A script task's `outputs` rows ARE — serialize declares each as a
             // `string` owned by the task, because the validator does not read the row as a
             // declaration — so they are candidates with the type that shape carries.
-            if (payload && type && type !== 'BPMN.Variables') {
-                const wire = type === 'BPMN.ScriptTask' ? 'string' : 'json';
-                for (const row of payload.output ?? [])
-                    if (row.var)
-                        candidates.set(row.var, [el.id, wire]);
+            // `implicitNodeVars` derives from a node the SDK models as TYPED — a connector,
+            // a connector event, an external task, a trigger start, a script task. It derives
+            // nothing from an element whose payload merely DECORATES it: a boundary event's
+            // `=Error` row is written by `errorVar` sugar, or declared by hand, but never by
+            // the derivation. So the same G1 discriminator that picks the emitter picks the
+            // candidates, and the two sets stay equal.
+            //
+            // Without it this set grew wider than serialize's the moment the schema fold let
+            // a bodied declaration through: ten `error<n>` declarations owned by boundary
+            // events in `claims-triage` were skipped as derived and then nobody derived them
+            // — they vanished from the recompiled process.
+            if (payload && type && type !== 'BPMN.Variables' && typeDescribesElement(localName(el.$type), type)) {
+                for (const row of payload.output ?? []) {
+                    if (!row.var)
+                        continue;
+                    // A script task's rows are NOT spelled-out `outputRows` on the way back —
+                    // `implicitNodeVars` derives its declarations from `outputs` keys, so they
+                    // carry the id as the name and that arm's own wire type. Every other typed
+                    // node's rows go through `rowDeclaration`, the same call the serializer makes.
+                    candidates.set(row.var, type === 'BPMN.ScriptTask'
+                        ? { owner: el.id, wire: 'string' }
+                        : { owner: el.id, ...rowDeclaration({ name: row.name, type: row.type, schema: row.body }) });
+                }
             }
             if (el.$type === 'bpmn:SubProcess')
                 walk(el);
@@ -1905,18 +2039,38 @@ function derivedVariableIds(process) {
     // — including the older shape with no `elementId`, which recompiles identically only
     // because `emitVariablesInto` then writes it as `elementId: null`.
     const out = new Set();
-    const vars = (process.extensionElements?.values ?? []).find((x) => x.$type === 'uipath:Variables');
-    for (const v of vars?.inputOutput ?? []) {
+    // Declarations whose only difference from a derived one is the schema body they
+    // carry — foldable onto the row as `varSchema`, which derives them exactly.
+    const folds = new Map();
+    for (const v of varsExt?.inputOutput ?? []) {
         const c = candidates.get(v.id);
         if (!c)
             continue;
-        if (v.name !== undefined && v.name !== v.id)
+        // The derived declaration takes the ROW's name when it has one, the id otherwise.
+        if ((v.name ?? v.id) !== (c.name ?? v.id))
             continue;
-        if (v.type !== c[1])
+        if (v.type !== c.wire)
             continue;
-        if (v.default !== undefined || v.elementId !== c[0])
+        const elementId = rehome && v.elementId === rehome.from ? rehome.to : v.elementId;
+        if (v.default !== undefined || elementId !== c.owner)
             continue;
+        // `implicitNodeVars` writes none of these, so a declaration carrying one was not
+        // derived however well the rest of it matches — and omitting it here re-derived a
+        // plain copy, dropping the attribute. 22 declarations in the corpus.
+        if (v.custom !== undefined || v.internal !== undefined || v.subType !== undefined)
+            continue;
+        // The body. A declaration with none matches a row with none. One that carries a
+        // body is still derivable IF the row can be made to state it — `varSchema` — and
+        // the row does not already claim a different body for the variable. This is the
+        // common case by a wide margin: 409 declarations in the corpus carry a body
+        // against 28 rows, so without the fold almost every structured output stays an
+        // explicit `.var()`.
+        if (String(v.body ?? '') !== String(c.schema ?? '')) {
+            if (c.schema !== undefined || v.body === undefined)
+                continue;
+            folds.set(v.id, v.body);
+        }
         out.add(v.id);
     }
-    return out;
+    return { ids: out, folds };
 }

package/dist/bpmn/serialize.js

@@ -18,7 +18,7 @@ import { createRequire } from 'node:module';
 import { connectorOutputVars, } from './bpmn-sdk.js';
 import { createConnectorTask } from './connector.js';
 import { createConnectorEvent, createExternalTask, intsvcOutputVar } from './intsvc.js';
-import { createExtensionPayload, createTypedNode, typedNodeOutputVar, verbatimOutputRows } from './typed-node.js';
+import { createExtensionPayload, createTypedNode, rowDeclaration, typedNodeOutputVar, verbatimOutputRows } from './typed-node.js';
 import { typedNodeDeclaredVars } from './bpmn-sdk.js';
 const require = createRequire(import.meta.url);
 const uipathDescriptor = require('./uipath-moddle.v1.json');
@@ -84,6 +84,7 @@ export async function serialize(built, opts = {}) {
         library: opts.library,
         bindings: opts.bindings,
         schemas: built.schemas,
+        variableOrder: built.preservation?.variableOrder,
         bindingSink: new Map(),
         varTypeOf: (varId) => authoredVarType.get(varId),
     };
@@ -104,7 +105,7 @@ export async function serialize(built, opts = {}) {
     // effect — then assemble the process extensionElements from the result.
     const flowElements = buildScope(ctx, built.nodes, built.flows);
     const processExt = [];
-    const varsExt = buildVariablesExt(ctx, rootVars, built.id, publicDeclarationScope(built.nodes, built.id));
+    const varsExt = buildVariablesExt(ctx, rootVars, built.id, publicDeclarationScope(built.nodes, built.id), built.preservation?.variableOrder);
     if (varsExt)
         processExt.push(varsExt);
     // Author-declared bindings first, then the ones connector wiring derived —
@@ -507,7 +508,7 @@ function createSubProcess(ctx, n) {
     // DUPLICATE_DOCUMENT_ID the emitter goes out of its way to avoid everywhere else
     // (the XML parser drops the second element that reuses an id).
     const enclosing = [...n.variables, ...[...ctx.varType.keys()].map((id) => ({ id }))];
-    const varsExt = buildVariablesExt(ctx, [...n.variables, ...implicitNodeVars(n.nodes, enclosing)], n.id);
+    const varsExt = buildVariablesExt(ctx, [...n.variables, ...implicitNodeVars(n.nodes, enclosing)], n.id, undefined, ctx.variableOrder);
     if (varsExt)
         values.push(varsExt);
     if (values.length)
@@ -629,11 +630,13 @@ function assignmentSource(value) {
 export function implicitNodeVars(nodes, declared) {
     const taken = new Set(declared.map((v) => v.id));
     const out = [];
-    const claim = (id, ownerId, type = 'object') => {
+    const claim = (id, ownerId, type = 'object', 
+    /** The row that implies it, when one spelled the declaration out — see `rowDeclaration`. */
+    from) => {
         if (!id || taken.has(id))
             return;
         taken.add(id);
-        out.push({ id, name: id, type, direction: 'inputOutput', elementId: ownerId });
+        out.push({ id, name: from?.name ?? id, type, direction: 'inputOutput', elementId: ownerId, schema: from?.schema });
     };
     for (const n of nodes) {
         if (n.kind === 'connector') {
@@ -647,8 +650,23 @@ export function implicitNodeVars(nodes, declared) {
             // skips re-declaring EVERY output row's variable, so a row claimed by neither
             // side vanishes from the recompiled process. Measured on a Slack connector —
             // `send_Error` was declared in the original and absent after the round trip.
-            for (const varId of typedNodeDeclaredVars(n))
-                claim(varId, n.id);
+            //
+            // A SPELLED-OUT row states the declaration too — its `name`, `type` and schema
+            // body are what the product copies onto the variable — so the derived one is
+            // built from the row rather than left as a bare `json` named after its id. That
+            // is what keeps a node's own outputs inside the node: 83 of the 112 declarations
+            // in `claims-intake-hitl` are this shape, and every one of them had to be
+            // restated as a `.var()` because the derivation could not reach the row.
+            if (n.outputRows) {
+                for (const row of n.outputRows) {
+                    const d = rowDeclaration(row);
+                    claim(row.var, n.id, d.type, d);
+                }
+            }
+            else {
+                for (const varId of typedNodeDeclaredVars(n))
+                    claim(varId, n.id);
+            }
         }
         else if (n.kind === 'connectorEvent' || n.kind === 'externalTask') {
             // Same reason as the typed and connector arms: the node's output rows
@@ -808,12 +826,15 @@ function defaultAttr(value, mappedType) {
  */
 function buildVariablesExt(ctx, vars, ownerId, 
 /** The default scope of a declaration the author left unscoped; the owner when absent. */
-scopeOf = () => ownerId) {
+scopeOf = () => ownerId, 
+/** Declaration order pinned by `.preserve()`; ids it omits keep their relative order, after. */
+order) {
     const { m } = ctx;
     if (!vars.length)
         return undefined;
     const groups = { input: [], inputOutput: [], output: [] };
-    for (const v of vars) {
+    const ordered = orderVars(vars, order);
+    for (const v of ordered) {
         const el = m.create('uipath:Variable', {
             id: v.id,
             name: v.name,
@@ -823,6 +844,10 @@ scopeOf = () => ownerId) {
             // Carried, never interpreted — a schema field this SDK does not model survives.
             body: schemaBody(ctx, v.schema),
             required: v.required ? 'true' : undefined,
+            // Designer bookkeeping, carried rather than interpreted — see `VarOpts.custom`.
+            custom: v.custom ? 'true' : undefined,
+            internal: v.internal ? 'true' : undefined,
+            subType: v.subType,
         });
         groups[v.direction].push(el);
     }
@@ -835,6 +860,24 @@ scopeOf = () => ownerId) {
         props.output = groups.output;
     return m.create('uipath:Variables', props);
 }
+/**
+ * Declarations in the order `.preserve({ variableOrder })` pinned, stably.
+ *
+ * A derived declaration is appended to the author's list (`rootVars`), so without a
+ * pinned order every variable a node's output row fills lands after every declared one
+ * — which is not where the document had it, and the variables panel is a list a person
+ * reads. An id the order omits keeps its relative position, after the ones it names,
+ * so a partial order is still useful and an unknown id is never dropped.
+ */
+function orderVars(vars, order) {
+    if (!order?.length)
+        return vars;
+    const rank = new Map(order.map((id, i) => [id, i]));
+    return vars
+        .map((v, i) => ({ v, i, r: rank.get(v.id) ?? Number.POSITIVE_INFINITY }))
+        .sort((a, b) => a.r - b.r || a.i - b.i)
+        .map((e) => e.v);
+}
 /**
  * Where an unscoped PUBLIC declaration belongs at the top level of a process.
  *

package/dist/bpmn/typed-node.d.ts

@@ -15,6 +15,7 @@
  */
 import type BpmnModdle from 'bpmn-moddle';
 import type { ModdleElement } from 'bpmn-moddle';
+import { type TypeDesc } from '../core/expr.js';
 type El = ModdleElement;
 /** One context field of a typed node, as the registry describes it. */
 export interface RegistryContextField {
@@ -206,6 +207,42 @@ export interface TypedInputRow {
     /** The row's CDATA body, for a `json` row — the value itself, or a string when the exact bytes matter. */
     body?: unknown;
 }
+/**
+ * The variable declaration a spelled-out output row implies.
+ *
+ * A node's output row and the declaration that receives it are two halves of one
+ * fact, and the product writes them that way: the row's `name`, `type` and schema
+ * body are copied onto the `uipath:inputOutput` it fills. Measured over
+ * `research/bpmn-roundtrip/corpus/`, 688 of 842 declarations are exactly this — a
+ * node's own output, attributed to the node, with no `custom` flag — against 119 an
+ * author typed into the variables panel.
+ *
+ * So the row is the source of truth and the declaration is derived from it, rather
+ * than the author stating the same `name`/`type`/schema twice. `implicitNodeVars`
+ * builds the declaration from this, and `derivedVariableIds` uses `wire` to decide
+ * that a declaration on disk looks derived and must not be echoed. **Both call this
+ * function**: the two sets have to be equal, and the way they stayed unequal before
+ * was each computing the shape for itself.
+ *
+ * A row's type is carried onto the declaration only when it NAMES a variable type.
+ * A row may instead be typed with the node's registry type — `type="Actions.HITL"` on
+ * the response row `typedNodeOutputVar` derives — and the variable behind that is
+ * `json`, not a type called `Actions.HITL`. `undefined` lands there too: `json` is
+ * what every derived declaration carried before the row was consulted, and a row with
+ * no type states nothing to the contrary.
+ *
+ * Where a row does name one, the product agrees with it: 776 of the 796 row/declaration
+ * pairs in the corpus carry the same type. The 20 that differ (a `json` row against a
+ * `jsonSchema` declaration, and four one-offs) simply fail the match and stay explicit
+ * `.var()` lines, which is the safe direction — a declaration that does not look
+ * derived is the author's.
+ */
+export declare function rowDeclaration(row: TypedOutputRow): {
+    type: TypeDesc;
+    wire: string;
+    name?: string;
+    schema?: unknown;
+};
 export interface TypedOutputRow {
     /** Row name, e.g. `response` or `Error`. */
     name: string;
@@ -217,6 +254,21 @@ export interface TypedOutputRow {
     source?: string;
     /** The row's body — a JSON Schema for a `jsonSchema` row. */
     schema?: unknown;
+    /**
+     * The schema body of the VARIABLE this row fills — not the row's own `schema`.
+     *
+     * The two are different places on the wire, and the product uses the second one:
+     * across `research/bpmn-roundtrip/corpus/` only 28 output rows carry a body of their
+     * own, while 409 declarations do. So a `jsonSchema` output is normally a bare row
+     * plus a `uipath:inputOutput` carrying the shape — which is why stating the row was
+     * not enough to derive the declaration, and why a node's outputs had to be restated
+     * as `.var()` lines beside it.
+     *
+     * Setting this keeps the whole declaration on the row: `implicitNodeVars` builds the
+     * variable with this as its body, and nothing about the emitted XML changes — the
+     * body still lands on the declaration, never on the row.
+     */
+    varSchema?: unknown;
     /**
      * Mark the row `custom="true"` — the product's flag for a row an author added
      * rather than one the node's type declares.

package/dist/bpmn/typed-node.js

@@ -1,5 +1,6 @@
 import { createRequire } from 'node:module';
 import { resolveFromRegistry } from './registry-fallback.js';
+import { types } from '../core/expr.js';
 const require = createRequire(import.meta.url);
 const REGISTRY = require('./registry-types.json');
 /** Every extension type in the snapshot, sorted. */
@@ -115,6 +116,48 @@ export const REGISTRY_GAPS = {
     // same spec, opposite enforcement.
     'Maestro.ReceiveMessageEvent': { outputRowsFixed: true },
 };
+/**
+ * The variable declaration a spelled-out output row implies.
+ *
+ * A node's output row and the declaration that receives it are two halves of one
+ * fact, and the product writes them that way: the row's `name`, `type` and schema
+ * body are copied onto the `uipath:inputOutput` it fills. Measured over
+ * `research/bpmn-roundtrip/corpus/`, 688 of 842 declarations are exactly this — a
+ * node's own output, attributed to the node, with no `custom` flag — against 119 an
+ * author typed into the variables panel.
+ *
+ * So the row is the source of truth and the declaration is derived from it, rather
+ * than the author stating the same `name`/`type`/schema twice. `implicitNodeVars`
+ * builds the declaration from this, and `derivedVariableIds` uses `wire` to decide
+ * that a declaration on disk looks derived and must not be echoed. **Both call this
+ * function**: the two sets have to be equal, and the way they stayed unequal before
+ * was each computing the shape for itself.
+ *
+ * A row's type is carried onto the declaration only when it NAMES a variable type.
+ * A row may instead be typed with the node's registry type — `type="Actions.HITL"` on
+ * the response row `typedNodeOutputVar` derives — and the variable behind that is
+ * `json`, not a type called `Actions.HITL`. `undefined` lands there too: `json` is
+ * what every derived declaration carried before the row was consulted, and a row with
+ * no type states nothing to the contrary.
+ *
+ * Where a row does name one, the product agrees with it: 776 of the 796 row/declaration
+ * pairs in the corpus carry the same type. The 20 that differ (a `json` row against a
+ * `jsonSchema` declaration, and four one-offs) simply fail the match and stay explicit
+ * `.var()` lines, which is the safe direction — a declaration that does not look
+ * derived is the author's.
+ */
+export function rowDeclaration(row) {
+    const type = (() => {
+        if (row.type === undefined || row.type === 'json')
+            return 'object';
+        if (row.type === 'bool')
+            return 'boolean';
+        return Object.hasOwn(types, row.type) ? row.type : 'object';
+    })();
+    // The serializer's `mapType`, which collapses the three structured descriptors.
+    const wire = type === 'object' || type === 'array' || type === 'any' ? 'json' : type;
+    return { type, wire, name: row.name, schema: row.varSchema };
+}
 /**
  * An output name reduced to something an expression can actually read.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.14.0",
+  "version": "6.14.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": "84bd49a28ffaae311bcb7b3207a311dfeaf1c08f"
+  "gitref": "00178a53b6c63ad810cda275b16ac8170422f9ae"
 }