@uipath/maestro-builder-sdk 6.15.5 → 6.16.0

package/dist/decompile.js

@@ -1739,7 +1739,7 @@ function typeExpr(type, imp) {
  * (`{ type: types.x, description, subType, schema }`); a bare one keeps the
  * compact `name: types.x` form.
  */
-function declExpr(g, withDefault, imp) {
+function declExpr(g, withDefault, imp, shared) {
     const meta = [];
     if (withDefault && g.defaultValue !== undefined)
         meta.push(`default: ${literal(g.defaultValue)}`);
@@ -1749,16 +1749,58 @@ function declExpr(g, withDefault, imp) {
         meta.push(`subType: ${str(g.subType)}`);
     if (g.schema !== undefined)
         meta.push(`schema: ${literal(g.schema)}`);
+    if (shared !== undefined)
+        meta.push(`shared: ${str(shared)}`);
     if (meta.length === 0)
         return typeExpr(g.type, imp);
     return `{ type: ${typeExpr(g.type, imp)}, ${meta.join(', ')} }`;
 }
-function emitVariables(e, depth, flow, imp) {
+function sharedCopies(flow, triggers) {
     const globals = readFlowGlobals(flow.variables, runStrict);
-    const inputs = globals.filter((g) => g.direction === 'in');
+    const byInput = new Map();
+    const unrecognized = [];
+    const fed = new Map();
+    for (const t of triggers) {
+        const rows = flow.variables?.variableUpdates?.[t.id] ?? [];
+        const seenOnRoot = new Set();
+        for (const row of rows) {
+            const src = unwrapSource(row.expression);
+            const m = src?.startsWith('=js:') ? /^\$vars\.([A-Za-z0-9_]+)\.output\.([A-Za-z0-9_]+)$/.exec(src.slice(4).trim()) : null;
+            const inp = m && m[1] === t.id
+                ? globals.find((g) => g.direction === 'in' && g.id === m[2] && g.triggerNodeId === t.id)
+                : undefined;
+            const target = globals.find((g) => g.id === row.variableId && g.direction !== 'in');
+            const ok = inp !== undefined && target !== undefined && target.type === inp.type
+                && !byInput.has(`${t.id}\0${inp.id}`) && !seenOnRoot.has(row.variableId);
+            if (!ok) {
+                unrecognized.push({ trigger: t.id, variableId: row.variableId });
+                continue;
+            }
+            seenOnRoot.add(row.variableId);
+            byInput.set(`${t.id}\0${inp.id}`, row.variableId);
+            fed.set(row.variableId, (fed.get(row.variableId) ?? 0) + 1);
+        }
+    }
+    const auto = new Set();
+    for (const name of fed.keys()) {
+        const g = globals.find((x) => x.id === name);
+        if (g.direction === 'inout' && g.defaultValue === undefined && g.description === undefined
+            && g.subType === undefined && g.schema === undefined)
+            auto.add(name);
+    }
+    return { byInput, auto, unrecognized };
+}
+function emitVariables(e, depth, flow, imp, epTriggers = new Set(), shared) {
+    const globals = readFlowGlobals(flow.variables, runStrict);
+    // `.input()` declares the DEFAULT root's inputs. An input bound to another
+    // root comes back on that root's `.entryPoint(…, { inputs })` instead —
+    // listing it here too declared it twice, which recompiles to
+    // ENTRY_POINT_INPUT_COLLISION.
+    const inputs = globals.filter((g) => g.direction === 'in' && !(g.triggerNodeId !== undefined && epTriggers.has(g.triggerNodeId)));
     const outputs = globals.filter((g) => g.direction === 'out');
-    const inouts = globals.filter((g) => g.direction === 'inout');
-    const shape = (list, withDefault) => `{ ${list.map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, withDefault, imp)}`).join(', ')} }`;
+    const inouts = globals.filter((g) => g.direction === 'inout' && !shared?.auto.has(g.id));
+    const sharedOf = (g) => g.triggerNodeId !== undefined ? shared?.byInput.get(`${g.triggerNodeId}\0${g.id}`) : undefined;
+    const shape = (list, withDefault) => `{ ${list.map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, withDefault, imp, sharedOf(g))}`).join(', ')} }`;
     if (inputs.length)
         e.line(depth, `.input(${shape(inputs, true)})`);
     if (outputs.length)
@@ -2652,9 +2694,22 @@ export function decompile(flow, options = {}) {
             e.line(d, `// TODO: node ${str(n.id)} (${n.type}) is not reachable from any trigger and is NOT in this source; recompiling drops it. Connect it in the .flow or edit its JSON directly.`);
         }
     }
-    emitVariables(e, d, flow, imp);
+    // `{ shared }` input copies on the roots (#924). Any other trigger-level
+    // update has no builder spelling: say so instead of dropping it.
+    const shared = sharedCopies(flow, triggerNodes);
+    if (shared.unrecognized.length) {
+        const listing = shared.unrecognized.map((u) => `${str(u.variableId)} on ${str(u.trigger)}`).join(', ');
+        const message = `${shared.unrecognized.length} variable update(s) on a trigger node are not a { shared } input copy: ${listing}. `
+            + 'The builder writes a trigger-level update only for { type, shared: \'<var>\' } (the row `<var> ← $vars.<trigger>.output.<input>`), '
+            + 'so this source omits them and recompiling drops them.';
+        if (runStrict)
+            throw new Error(`decompile: ${message}`);
+        warnOnce(message);
+        e.line(d, `// TODO: ${message}`);
+    }
+    emitVariables(e, d, flow, imp, new Set(triggerNodes.filter((t) => t !== trigger).map((t) => t.id)), shared);
     // Reconstruct the body: structured control flow recovered from the graph.
-    const ctx = { graph, flow, imp, inputNames, o: options, emitted: new Set() };
+    const ctx = { graph, flow, imp, inputNames, o: options, emitted: new Set(), shared };
     const scope = scopeIds(flow.nodes ?? [], undefined);
     const startId = trigger?.id ?? 'start';
     const first = scopeSucc(graph, startId, scope)[0];
@@ -2746,7 +2801,8 @@ function entryPointSeg(t, scope, ipdom, ctx) {
         .filter((g) => g.direction === 'in' && g.triggerNodeId === t.id);
     const optParts = [];
     if (scoped.length) {
-        optParts.push(`inputs: { ${scoped.map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, true, ctx.imp)}`).join(', ')} }`);
+        const sharedOf = (g) => ctx.shared?.byInput.get(`${t.id}\0${g.id}`);
+        optParts.push(`inputs: { ${scoped.map((g) => `${key(g.name ?? g.id)}: ${declExpr(g, true, ctx.imp, sharedOf(g))}`).join(', ')} }`);
     }
     const ver = verClause(t);
     if (ver)

package/dist/flow-expr-check.js

@@ -58,6 +58,12 @@ function globalRoots(built) {
     roots.add('start');
     if (built.triggerId)
         roots.add(built.triggerId);
+    // A variable an input feeds with `{ shared }` is declared by the SDK when the
+    // author did not declare it — readable as `v('<name>')` all the same (#924).
+    for (const inp of [...built.inputs, ...(built.entryPoints ?? []).flatMap((ep) => ep.inputs)]) {
+        if (inp.shared !== undefined)
+            roots.add(inp.shared);
+    }
     for (const ep of built.entryPoints ?? []) {
         roots.add(ep.id);
         addStepNames(ep.steps, roots);

package/dist/flow-sdk.d.ts

@@ -54,6 +54,8 @@ export interface VarDecl {
     subType?: string;
     /** JSON schema for complex type validation (object/array shapes). */
     schema?: Record<string, unknown>;
+    /** Inputs only: the flow variable this root's input is copied into when the root fires. See {@link VarSpec.shared}. */
+    shared?: string;
 }
 /**
  * The rich spelling of a variable declaration: pass it instead of a bare
@@ -77,6 +79,39 @@ export interface VarSpec {
      * `.output({ product: { type: types.number, default: 1 } })`.
      */
     default?: unknown;
+    /**
+     * Inputs only: copy this input into the flow variable named here when its
+     * root fires, so a body shared by several roots reads one variable,
+     * `v('<shared>')`, whichever root started the run.
+     *
+     * @remarks
+     * For a flow with more than one root: the default `.input()` root plus
+     * `.entryPoint(...)` roots. Each root keeps its own input name. The format
+     * keys every global, and every entry point's caller-facing input, by one
+     * unique id, so two roots cannot both take `x`. `shared` names the variable
+     * they all feed.
+     *
+     * - The variable is declared for you unless a `.var()` or `.output()` of that
+     *   name exists. Declare the `.var()` yourself to give it a default.
+     * - The copy is a `variableUpdates` row on the root's TRIGGER node,
+     *   `<shared> ← $vars.<triggerId>.output.<input>`. So it is done before the
+     *   root's own prefix steps run.
+     * - A root that feeds nothing leaves the variable at its default, or null
+     *   if it has none.
+     * - Every input feeding one variable must have that variable's type, or
+     *   `check` reports `SHARED_INPUT_TYPE_MISMATCH`.
+     * - Not accepted on a subflow child's input. A subflow has one root, its
+     *   caller, so there is nothing to merge.
+     *
+     * @example
+     * ```ts
+     * flow('order')
+     *   .input({ orderAmount: { type: types.number, shared: 'amount' } })
+     *   .entryPoint('retry', manual(), { inputs: { retryAmount: { type: types.number, shared: 'amount' } } })
+     *   .step('double', script({ code: 'return $vars.amount * 2;', returns: 'number' }))   // v('amount') in an Expr slot
+     * ```
+     */
+    shared?: string;
 }
 /**
  * The eight intervals the designer offers in its Frequency dropdown. Any other
@@ -1229,6 +1264,18 @@ declare class FlowBuilder extends StepList {
      *   .step('normalize', script({ code: 'return 1;' }))    // shared body
      * ```
      *
+     * **Sharing an input across roots.** Mark each root's input with the variable
+     * it feeds, `{ type, shared: '<var>' }`. The SDK copies it on that root's
+     * trigger node, and the shared body reads `v('<var>')` whichever root fired.
+     * See {@link VarSpec.shared}.
+     *
+     * ```ts
+     * flow('order')
+     *   .input({ orderAmount: { type: types.number, shared: 'amount' } })
+     *   .entryPoint('retry', manual(), { inputs: { retryAmount: { type: types.number, shared: 'amount' } } })
+     *   .step('double', script({ code: 'return $vars.amount * 2;', returns: 'number' }))   // v('amount') in an Expr slot
+     * ```
+     *
      * @param id - The root's trigger-node id — unique among entry points, steps,
      * and the default trigger id. Expressions read it as `$vars.<id>.output.*`.
      * @param trigger - What fires this root: `manual()`, `scheduled(...)`, or
@@ -1319,6 +1366,11 @@ declare class FlowBuilder extends StepList {
     /**
      * Declare the flow's inputs. Read them with `input('<name>')`.
      *
+     * @remarks
+     * In a flow with several roots, give an input `{ type, shared: '<var>' }` to
+     * copy it into a flow variable the shared body reads with `v('<var>')`. See
+     * {@link VarSpec.shared}.
+     *
      * @param shape - Input names to type descriptors, e.g. `{ amount: types.number }`.
      * @returns This builder, so calls chain.
      * @see input

package/dist/flow-sdk.js

@@ -71,12 +71,24 @@ function varDeclOf(method, name, value) {
     if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
         const spec = value;
         assertType(method, name, spec.type);
+        if (spec.shared !== undefined) {
+            if (method !== 'input') {
+                throw new TypeError(`.${method}() declared ${JSON.stringify(name)} with { shared }, which only an input takes: it names `
+                    + `the flow variable a root's input is copied into. Declare the variable with .var() and feed it from `
+                    + `.input({ <name>: { type, shared: ${JSON.stringify(spec.shared)} } }).`);
+            }
+            if (typeof spec.shared !== 'string' || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(spec.shared)) {
+                throw new TypeError(`Input ${JSON.stringify(name)}: { shared } must be a variable name (letters, digits, _), got `
+                    + `${JSON.stringify(spec.shared)}.`);
+            }
+        }
         return {
             type: spec.type,
             ...(spec.default !== undefined ? { default: spec.default } : {}),
             ...(spec.description !== undefined ? { description: spec.description } : {}),
             ...(spec.subType !== undefined ? { subType: spec.subType } : {}),
             ...(spec.schema !== undefined ? { schema: spec.schema } : {}),
+            ...(spec.shared !== undefined ? { shared: spec.shared } : {}),
         };
     }
     assertType(method, name, value);
@@ -967,6 +979,18 @@ class FlowBuilder extends StepList {
      *   .step('normalize', script({ code: 'return 1;' }))    // shared body
      * ```
      *
+     * **Sharing an input across roots.** Mark each root's input with the variable
+     * it feeds, `{ type, shared: '<var>' }`. The SDK copies it on that root's
+     * trigger node, and the shared body reads `v('<var>')` whichever root fired.
+     * See {@link VarSpec.shared}.
+     *
+     * ```ts
+     * flow('order')
+     *   .input({ orderAmount: { type: types.number, shared: 'amount' } })
+     *   .entryPoint('retry', manual(), { inputs: { retryAmount: { type: types.number, shared: 'amount' } } })
+     *   .step('double', script({ code: 'return $vars.amount * 2;', returns: 'number' }))   // v('amount') in an Expr slot
+     * ```
+     *
      * @param id - The root's trigger-node id — unique among entry points, steps,
      * and the default trigger id. Expressions read it as `$vars.<id>.output.*`.
      * @param trigger - What fires this root: `manual()`, `scheduled(...)`, or
@@ -1081,6 +1105,11 @@ class FlowBuilder extends StepList {
     /**
      * Declare the flow's inputs. Read them with `input('<name>')`.
      *
+     * @remarks
+     * In a flow with several roots, give an input `{ type, shared: '<var>' }` to
+     * copy it into a flow variable the shared body reads with `v('<var>')`. See
+     * {@link VarSpec.shared}.
+     *
      * @param shape - Input names to type descriptors, e.g. `{ amount: types.number }`.
      * @returns This builder, so calls chain.
      * @see input

package/dist/flow-variables.d.ts

@@ -77,3 +77,77 @@ export declare function planFlowGlobals<D extends DeclaredVariable>(decl: {
     outputs: readonly D[];
     vars: readonly D[];
 }): FlowGlobalsPlan<D>;
+/** One root's input that feeds a shared variable. */
+export interface SharedInputFeed {
+    /** The root's trigger-node id at AUTHORING time: `start` for the default root, else the entry-point id. */
+    root: string;
+    /** The input's declared name on that root (its global id). */
+    input: string;
+    type: string;
+}
+/** One variable that inputs feed with `{ shared: '<name>' }`. */
+export interface SharedInputTarget {
+    name: string;
+    type: string;
+    /** What declares it: an explicit `.var()` / `.output()`, or the SDK (`auto`). */
+    declaredAs: 'var' | 'output' | 'auto';
+    hasDefault: boolean;
+    feeds: SharedInputFeed[];
+}
+export interface SharedInputsProblem {
+    level: 'error' | 'warning';
+    code: 'SHARED_INPUT_TARGET_IS_INPUT' | 'SHARED_INPUT_TYPE_MISMATCH' | 'SHARED_INPUT_SAME_ROOT' | 'SHARED_INPUT_ROOT_MISSING';
+    name: string;
+    message: string;
+    suggestion?: string;
+}
+export interface SharedInputsPlan {
+    /** Every shared variable, in order of its first feeding input. */
+    targets: SharedInputTarget[];
+    /** The `.var()` declarations the SDK adds — one per `auto` target, emitted after the explicit vars. */
+    autoVars: {
+        name: string;
+        type: string;
+    }[];
+    problems: SharedInputsProblem[];
+}
+/** The `{ shared }` slice of an input declaration. */
+interface SharedCapable extends DeclaredVariable {
+    shared?: string;
+}
+/**
+ * Plan the variables that root inputs feed with `{ shared: '<var>' }`.
+ *
+ * Shared by `check` and the serializer, so the two cannot disagree about which
+ * variable exists, what type it is, or which problems refuse the flow (the
+ * #899/#904 lesson: `check` said `Errors: 0`, validate refused the file).
+ *
+ * Why the inputs keep their own names: `flow validate` refuses a repeated id in
+ * `variables.globals` whatever its `triggerNodeId`, and each entry point's
+ * caller-facing input schema is keyed by that id. So every root's input is a
+ * distinct global, and the variable they feed is a distinct one too.
+ */
+export declare function planSharedInputs(decl: {
+    roots: readonly {
+        id: string;
+        inputs: readonly SharedCapable[];
+    }[];
+    outputs: readonly DeclaredVariable[];
+    vars: readonly DeclaredVariable[];
+}): SharedInputsPlan;
+/**
+ * A flow's roots for {@link planSharedInputs}: the default root first (under
+ * its EMITTED trigger id, `.triggerId()` applied), then each `.entryPoint()`.
+ */
+export declare function sharedInputRoots(built: {
+    inputs: readonly SharedCapable[];
+    entryPoints?: readonly {
+        id: string;
+        inputs: readonly SharedCapable[];
+    }[];
+    triggerId?: string;
+}): {
+    id: string;
+    inputs: readonly SharedCapable[];
+}[];
+export {};

package/dist/flow-variables.js

@@ -124,3 +124,104 @@ export function planFlowGlobals(decl) {
     const vars = decl.vars.filter((vd) => !mergedSet.has(vd.name));
     return { outputs, vars, merged, problems };
 }
+/**
+ * Plan the variables that root inputs feed with `{ shared: '<var>' }`.
+ *
+ * Shared by `check` and the serializer, so the two cannot disagree about which
+ * variable exists, what type it is, or which problems refuse the flow (the
+ * #899/#904 lesson: `check` said `Errors: 0`, validate refused the file).
+ *
+ * Why the inputs keep their own names: `flow validate` refuses a repeated id in
+ * `variables.globals` whatever its `triggerNodeId`, and each entry point's
+ * caller-facing input schema is keyed by that id. So every root's input is a
+ * distinct global, and the variable they feed is a distinct one too.
+ */
+export function planSharedInputs(decl) {
+    const problems = [];
+    const inputNames = new Set(decl.roots.flatMap((r) => r.inputs.map((i) => i.name)));
+    const byName = new Map();
+    for (const root of decl.roots) {
+        for (const inp of root.inputs) {
+            if (inp.shared === undefined)
+                continue;
+            const name = inp.shared;
+            let target = byName.get(name);
+            if (!target) {
+                const vd = decl.vars.find((x) => x.name === name);
+                const od = decl.outputs.find((x) => x.name === name);
+                const declared = od ?? vd;
+                target = {
+                    name,
+                    type: declared ? String(declared.type) : String(inp.type),
+                    declaredAs: od ? 'output' : vd ? 'var' : 'auto',
+                    hasDefault: (od?.default ?? vd?.default) !== undefined,
+                    feeds: [],
+                };
+                byName.set(name, target);
+            }
+            target.feeds.push({ root: root.id, input: inp.name, type: String(inp.type) });
+        }
+    }
+    for (const t of byName.values()) {
+        if (inputNames.has(t.name)) {
+            problems.push({
+                level: 'error', code: 'SHARED_INPUT_TARGET_IS_INPUT', name: t.name,
+                message: `{ shared: ${JSON.stringify(t.name)} } names a flow INPUT. The shared variable is its own global, and `
+                    + `\`flow validate\` refuses two globals with one id, so it needs a name no input uses.`,
+                suggestion: `Rename the variable, e.g. { shared: '${t.name}Value' }, and read it with v('${t.name}Value').`,
+            });
+            continue;
+        }
+        const wrong = t.feeds.filter((f) => f.type !== t.type);
+        if (wrong.length) {
+            const source = t.declaredAs === 'auto'
+                ? `the first input feeding it ("${t.feeds[0].input}" on root "${t.feeds[0].root}") is ${t.type}`
+                : `it is declared by .${t.declaredAs}() as ${t.type}`;
+            problems.push({
+                level: 'error', code: 'SHARED_INPUT_TYPE_MISMATCH', name: t.name,
+                message: `Shared variable "${t.name}": ${source}, but `
+                    + wrong.map((f) => `"${f.input}" on root "${f.root}" is ${f.type}`).join(', ')
+                    + `. Every input copied into one variable must have that variable's type.`,
+            });
+        }
+        const perRoot = new Map();
+        for (const f of t.feeds)
+            (perRoot.get(f.root) ?? perRoot.set(f.root, []).get(f.root)).push(f.input);
+        for (const [root, inputs] of perRoot) {
+            if (inputs.length > 1) {
+                problems.push({
+                    level: 'error', code: 'SHARED_INPUT_SAME_ROOT', name: t.name,
+                    message: `Root "${root}" feeds shared variable "${t.name}" from ${inputs.length} inputs `
+                        + `(${inputs.map((i) => `"${i}"`).join(', ')}). A root's copy writes the variable once, so only one of `
+                        + `its inputs can feed it.`,
+                });
+            }
+        }
+        if (decl.roots.length > 1 && !t.hasDefault) {
+            const missing = decl.roots.filter((r) => !perRoot.has(r.id)).map((r) => r.id);
+            if (missing.length) {
+                problems.push({
+                    level: 'warning', code: 'SHARED_INPUT_ROOT_MISSING', name: t.name,
+                    message: `Shared variable "${t.name}" is fed by ${[...perRoot.keys()].map((r) => `"${r}"`).join(', ')} but not by `
+                        + `${missing.map((r) => `"${r}"`).join(', ')}. A run started there reads it as null.`,
+                    suggestion: `Feed it from that root too, or declare it with a default: .var('${t.name}', types.${t.type}, <default>).`,
+                });
+            }
+        }
+    }
+    const targets = [...byName.values()];
+    // A target that names an input is already refused above; leaving it out here
+    // keeps the global plan from reporting the same name a second time.
+    const autoVars = targets.filter((t) => t.declaredAs === 'auto' && !inputNames.has(t.name)).map((t) => ({ name: t.name, type: t.type }));
+    return { targets, autoVars, problems };
+}
+/**
+ * A flow's roots for {@link planSharedInputs}: the default root first (under
+ * its EMITTED trigger id, `.triggerId()` applied), then each `.entryPoint()`.
+ */
+export function sharedInputRoots(built) {
+    return [
+        { id: built.triggerId ?? 'start', inputs: built.inputs },
+        ...(built.entryPoints ?? []).map((ep) => ({ id: ep.id, inputs: ep.inputs })),
+    ];
+}

package/dist/serialize.js

@@ -45,7 +45,7 @@ import { declaredScriptShape, inferScriptShape } from './core/script-return.js';
 import { migrateToSchemaVersion } from './migrate.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { resolveSchemaVersion } from './schema-version.js';
-import { planFlowGlobals } from './flow-variables.js';
+import { planFlowGlobals, planSharedInputs, sharedInputRoots } from './flow-variables.js';
 import { prepareCommand } from './core/cli-spelling.js';
 import { QUEUE_ITEM_RECORD_SCHEMA } from './core/queue-record.js';
 const HERE = dirname(fileURLToPath(import.meta.url));
@@ -3959,16 +3959,38 @@ function misplacedLookupMessage(token) {
  * (`compile --no-check`, `emitFlow`, a direct `serialize()`) cannot write a
  * file `flow validate` rejects for a duplicate variable id.
  */
-function emittableGlobals(built, where) {
+function emittableGlobals(built, where, kind = 'root') {
     // Entry-point inputs are rows of the same globals[], so they share the
     // namespace; `check` reports those as ENTRY_POINT_INPUT_COLLISION.
     const inputs = [...built.inputs, ...(built.entryPoints ?? []).flatMap((ep) => ep.inputs)];
-    const plan = planFlowGlobals({ inputs, outputs: built.outputs, vars: built.vars });
+    // A variable an input feeds with `{ shared }` (#924) is one more `.var()`
+    // unless the author declared it, so it goes through the same collision plan.
+    const shared = sharedInputsOf(built, where, kind);
+    const plan = planFlowGlobals({ inputs, outputs: built.outputs, vars: [...built.vars, ...shared.autoVars] });
     if (plan.problems.length) {
         throw new Error(`${where}: ${plan.problems.map((p) => `[${p.code}] ${p.message}`).join(' ')}`);
     }
     return plan;
 }
+/**
+ * The flow's `{ shared }` input plan (#924), refused here as `check` refuses it
+ * — so `compile --no-check` cannot write what `check` would have stopped.
+ * Warnings (a root that feeds nothing) are `check`'s alone.
+ */
+function sharedInputsOf(built, where, kind) {
+    if (kind === 'subflow') {
+        const marked = built.inputs.filter((i) => i.shared !== undefined);
+        if (marked.length) {
+            throw new Error(`${where}: [SHARED_INPUT_IN_SUBFLOW] input "${marked[0].name}" has { shared: "${marked[0].shared}" }, but a subflow `
+                + `has one root — its caller — so there is nothing to merge. Read the input with input('${marked[0].name}').`);
+        }
+    }
+    const plan = planSharedInputs({ roots: sharedInputRoots(built), outputs: built.outputs, vars: built.vars });
+    const errors = plan.problems.filter((p) => p.level === 'error');
+    if (errors.length)
+        throw new Error(`${where}: ${errors.map((p) => `[${p.code}] ${p.message}`).join(' ')}`);
+    return plan;
+}
 function newScope(outputs, vars = []) {
     return {
         nodes: [],
@@ -4417,7 +4439,7 @@ export function serialize(built, opts = {}) {
      * a null. It is emitted here, always, so it cannot be forgotten.
      */
     function emitSubflowBody(child, nodeId) {
-        const childGlobals = emittableGlobals(child, `subflow "${nodeId}"`);
+        const childGlobals = emittableGlobals(child, `subflow "${nodeId}"`, 'subflow');
         const scope = newScope(childGlobals.outputs, childGlobals.vars);
         // Claim this copy's node ids UP FRONT, so the rename map is complete before
         // the first expression renders. A child's step names are free the first
@@ -6544,6 +6566,30 @@ export function serialize(built, opts = {}) {
             }
         }
     }
+    // ── Shared root inputs (#924) ────────────────────────────────────────────
+    // An input marked `{ shared: '<var>' }` is copied into that variable on its
+    // root's TRIGGER node: a `variableUpdates[<triggerId>]` row, the same
+    // construct `{ updates }` writes for a step. On the trigger, the copy is done
+    // before the root's own prefix steps run. The platform engine applies a start
+    // event's output rows in order, so the row sees the trigger's input mapping
+    // (measured live, #924). The default root's row is written against `start`
+    // and renamed with every other `input()` read, so `.triggerId()` follows.
+    {
+        const roots = [
+            { node: built.triggerId ?? 'start', read: 'start', inputs: built.inputs },
+            ...entryPoints.map((ep) => ({ node: ep.id, read: ep.id, inputs: ep.inputs })),
+        ];
+        for (const r of roots) {
+            const copies = {};
+            for (const inp of r.inputs) {
+                if (inp.shared !== undefined)
+                    copies[inp.shared] = new Expr(`$vars.${r.read}.output.${inp.name}`);
+            }
+            if (Object.keys(copies).length === 0)
+                continue;
+            root.variableUpdates[r.node] = [...(root.variableUpdates[r.node] ?? []), ...renderUpdates(copies, root.rename)];
+        }
+    }
     const globals = [];
     const triggerNodeId = built.triggerId ?? 'start';
     for (const inp of built.inputs)

package/package.json

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