@uipath/maestro-builder-sdk 6.42.0 → 6.44.0

package/dist/decompile.js

@@ -35,10 +35,7 @@ import { DEFAULT_TRIGGER_ID, Expr } from './core/expr.js';
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { SUBFLOW_START_LABEL } from './core/subflow-start.js';
 import { commentText } from './core/comment-text.js';
-import { tsLiteral, tsNumber, tsText } from './core/ts-literal.js';
-import { ownEntry } from './core/own-entry.js';
-import { CONTEXT_INDEX_DEFAULTS, CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, contextIndexSlug, parseContextIndexType, } from './core/context-index.js';
-import { derivedContextSource, derivedEscalationSource, derivedResourceNodeId, derivedToolSource, } from './core/agent-resource-identity.js';
+import { tsKey as key, tsLiteral, tsNumber, tsObject as objLit, tsOptions as opts, tsText } from './core/ts-literal.js';
 import { wireExprBody } from './core/wire-expr.js';
 import { hasExits } from './core/step-ports.js';
 import { parseIxpProjectType } from './core/actions.js';
@@ -51,7 +48,6 @@ import { OUTCOME_HANDLE_NODE_TYPES } from './core/hitl-routing.js';
 import { contributionPort, forwardFanOut } from './core/definition-handles.js';
 import { STICKY_NOTE_TYPE } from './core/definitionless-node-types.js';
 import { eventFilterFromTreeLeaf } from './core/event-filters.js';
-import { formFieldRowLoss, formFieldRowLossMessage, formFieldSettingsSource, liftFormFieldSettings, sourceFormFieldType, } from './core/form-field-type.js';
 /**
  * The trigger id of the flow currently being decompiled, so a reference through a
  * RENAMED trigger is still recognized as `input('x')` rather than falling back to
@@ -195,14 +191,30 @@ function shippedVersions(type) {
  * The options argument of `.branch()`, `.switch()` and `.parallel()`: the exact
  * `version`, and a canvas `label` that differs from the node id (what compile
  * writes when none is given). No `updates`: those constructs refuse them.
+ *
+ * `node` is the construct's own node (a `.parallel`'s join); `fork` is the
+ * merge node a designer-drawn parallel split leaves from, written as
+ * `{ fork }` (#1310). A `.parallel` whose arms rejoin on a plain step has no
+ * join node, so `node` may be absent; the fork then supplies the version.
  */
-function forkOptsArg(node) {
+function forkOptsArg(node, fork) {
     const parts = [];
-    const ver = verClause(node);
+    const ver = node ? verClause(node) : fork ? verClause(fork) : '';
     if (ver)
         parts.push(ver);
-    if (hasRenamedLabel(node, node.id))
+    if (node && hasRenamedLabel(node, node.id))
         parts.push(`label: ${tsLiteral(node.display.label)}`);
+    if (fork) {
+        // The fork's own version, when the join's clause does not already say it
+        // (no join node, or a different version on each).
+        const forkVer = node && node.typeVersion !== fork.typeVersion ? verClause(fork) : '';
+        const forkParts = [
+            `name: ${tsLiteral(fork.id)}`,
+            ...(hasRenamedLabel(fork, fork.id) ? [`label: ${tsLiteral(fork.display.label)}`] : []),
+            ...(forkVer ? [forkVer] : []),
+        ];
+        parts.push(forkParts.length === 1 ? `fork: ${tsLiteral(fork.id)}` : `fork: { ${forkParts.join(', ')} }`);
+    }
     return parts.length ? `, { ${parts.join(', ')} }` : '';
 }
 /**
@@ -263,12 +275,7 @@ const T = {
     triggerForm: 'core.trigger.form',
     triggerConversation: 'core.trigger.conversation',
     hitl: 'uipath.human-in-the-loop',
-    inlineAgent: 'uipath.agent.autonomous',
-    conversationalAgent: 'uipath.agent.conversational',
-    voiceAgent: 'uipath.agent.voice',
     triggerVoice: 'core.trigger.voice',
-    createOutgoingCall: 'uipath.conversational.voice.create-outgoing-call',
-    endCall: 'uipath.conversational.voice.end-call',
     decision: 'core.logic.decision',
     switch: 'core.logic.switch',
     merge: 'core.logic.merge',
@@ -287,28 +294,6 @@ function isTrigger(type) {
 function boolLit(v) {
     return v ? 'true' : 'false';
 }
-/** An object key: a bare identifier when legal, otherwise a quoted string. */
-function key(k) {
-    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(k) ? k : tsLiteral(k);
-}
-/** Render an options object from present entries; '' when nothing is present. */
-function opts(entries) {
-    const parts = entries.filter(([, v]) => v !== undefined).map(([k, v]) => `${key(k)}: ${v}`);
-    return parts.length ? `{ ${parts.join(', ')} }` : '';
-}
-/**
- * Plain JSON data as source, in the `{ k: v }` / `[a, b]` spelling the
- * printers use (a form field's `options`, `rules`, `defaultValue`).
- */
-function dataSource(v) {
-    if (Array.isArray(v))
-        return `[${v.map(dataSource).join(', ')}]`;
-    if (v !== null && typeof v === 'object') {
-        const parts = Object.entries(v).filter(([, x]) => x !== undefined).map(([k, x]) => `${key(k)}: ${dataSource(x)}`);
-        return parts.length ? `{ ${parts.join(', ')} }` : '{}';
-    }
-    return tsLiteral(v);
-}
 /** A collector for indented source lines. */
 class Emit {
     indentUnit;
@@ -353,6 +338,19 @@ function unwrapSource(v) {
     }
     return undefined;
 }
+/**
+ * The JS body of a condition slot (a decision's `expression`, a switch case's
+ * `expression`), whichever spelling the file uses: a bare JS string (the classic
+ * CLI), a `{ type: 'jsExpression', expression }` envelope (what Studio Web
+ * writes), or a `=js:`-prefixed string, with or without a space after the colon
+ * (`=js: ($vars.x ?? 0) > 0`). Before this, the envelope was stringified to
+ * `[object Object]` and the prefixed spelling was kept inside the template, so
+ * every designer-saved decision came back as source compile refused (#1308).
+ */
+function conditionText(v) {
+    const raw = unwrapSource(v);
+    return raw === undefined ? String(v ?? '') : wireExprBody(raw).trim();
+}
 /** A plain (boolean/number) input value, unwrapping a literal EV envelope if present. */
 function unwrapPlain(v) {
     if (v && typeof v === 'object' && 'expression' in v && v.type === 'literal') {
@@ -445,12 +443,6 @@ function emitVal(v, imp, inputNames) {
 function emitBareExpr(raw, imp, inputNames) {
     return emitRef(raw, imp, inputNames);
 }
-/** Render an object literal `{ k: <src>, … }` from pre-rendered value sources; '' when empty. */
-function objLit(entries) {
-    if (entries.length === 0)
-        return '';
-    return `{ ${entries.map(([k, v]) => `${key(k)}: ${v}`).join(', ')} }`;
-}
 /** A map of `{name: value}` inputs (headers / query / connector fields) → object-literal source. */
 function emitValMap(m, imp, inputNames) {
     if (!m || typeof m !== 'object')
@@ -652,6 +644,26 @@ function liftRegistered(node, impl = registeredImpl(node), graph) {
                 throw new Error(`decompile: ${message}`);
             warnOnce(message);
         },
+        sidecar: (path) => runReadSidecar?.(path),
+        flowId: runFlowId,
+        definitionOf: (n) => runDefs.get(`${n.type}@${n.typeVersion}`) ?? runDefs.get(n.type),
+        attached: (port, limit = Infinity) => {
+            const found = [];
+            for (const e of graph?.outEdges(node.id) ?? []) {
+                if (e.sourcePort !== port || found.length >= limit)
+                    continue;
+                const n = graph.byId.get(e.targetNodeId);
+                if (n === undefined)
+                    continue;
+                graph.accounted.add(e);
+                found.push(n);
+            }
+            return found;
+        },
+        attachedIds: (port) => (graph?.outEdges(node.id) ?? [])
+            .filter((e) => e.sourcePort === port && graph.byId.has(e.targetNodeId))
+            .map((e) => e.targetNodeId),
+        absorb: (id, compiledId) => { runAbsorbed.set(id, compiledId); },
         outPorts: () => (graph?.outEdges(node.id) ?? []).map((e) => e.sourcePort),
         convergedFanOut: () => graph?.convergedFanOut(node.id) === true,
     };
@@ -713,35 +725,12 @@ function emitStepSpec(node, imp, inputNames, o, graph) {
     if (lifted !== undefined)
         return lifted;
     switch (node.type) {
-        case T.createOutgoingCall:
-        case T.endCall: {
-            const i = (node.inputs ?? {});
-            const v = (x) => {
-                const raw = typeof x === 'string' ? x : String(x?.expression ?? x ?? '');
-                return raw.startsWith('=js:') ? emitBareExpr(raw.slice(4), imp, inputNames)
-                    : raw.startsWith('$vars.') ? emitBareExpr(raw, imp, inputNames)
-                        : tsLiteral(raw);
-            };
-            if (node.type === T.createOutgoingCall) {
-                return `${imp.use('createOutgoingCall')}(${opts([['from', v(i.from)], ['to', v(i.to)]])})`;
-            }
-            return `${imp.use('endCall')}(${opts([['callContext', v(i.callContext)]])})`;
-        }
-        case T.inlineAgent:
-        case T.conversationalAgent:
-        case T.voiceAgent:
-            return emitAgentCluster(node, imp, inputNames, graph);
         default:
             // A connector action node: `uipath.connector.<key>.<action>` (but NOT the
             // event nodes `uipath.connector.event.*` / `.trigger.*`, which are triggers).
             if (node.type.startsWith('uipath.connector.') && !node.type.startsWith('uipath.connector.event.') && !node.type.startsWith('uipath.connector.trigger.')) {
                 return emitConnector(node, imp, inputNames, o);
             }
-            {
-                const published = emitPublishedResource(node, imp, inputNames);
-                if (published !== undefined)
-                    return published;
-            }
             // A mid-flow connector EVENT wait (`uipath.connector.event.<key>.<event>`
             // placed as a step rather than as the start node).
             if (node.type.startsWith('uipath.connector.event.')) {
@@ -837,688 +826,6 @@ function connectorObjectName(configuration) {
  * Returns `undefined` when the node is not one of them, so the caller can fall
  * through to the next arm.
  */
-/** The `maxIterations` Studio Web writes into every inline agent's `agent.json` (flow-workbench `getDefaultAgentContent()`). */
-const STUDIO_WEB_DEFAULT_MAX_ITERATIONS = 25;
-/**
- * The agent configuration a SHELL agent node keeps in its sidecar, read from
- * `<source>/agent.json` in the node's own input names: the prompts, the model,
- * the run settings (`temperature`, `maxTokenPerResponse`, `maxIterations`,
- * `mode`), the `guardrails` and (voice) the `voice` settings. Empty when the
- * node carries prompts itself (an embedded node, e.g. a `.flow` saved by Studio
- * Web with the self-contained flag on), or when no sidecar can be read.
- *
- * A run setting equal to the default a sidecar writer fills in (`temperature`
- * 0, `maxTokens` 16384, `mode` `'standard'`) is not recovered: recompiling
- * without it writes the same sidecar, and recovering it would add an argument
- * the author never wrote to every agent. `mode: 'standard'` is the exception on
- * a 1.3 node, where naming it is what selected that definition. The same goes
- * for the inline agent's `maxIterations` 25: the SDK omits it when unset, but
- * Studio Web always writes it (its `getDefaultAgentContent()` default), so
- * every Studio Web-saved agent would otherwise decompile with `maxIterations: 25`.
- */
-function sidecarAgentInputs(node) {
-    const inputs = (node.inputs ?? {});
-    if (typeof inputs.systemPrompt === 'string' || typeof inputs.userPrompt === 'string')
-        return {};
-    const source = unwrapSource(inputs.source);
-    if (!source)
-        return {};
-    const path = `${source}/agent.json`;
-    const raw = runReadSidecar?.(path);
-    if (raw === undefined) {
-        warnOnce(`agent step "${node.id}" carries no prompts and ${path} was not found beside the .flow, `
-            + 'so its prompts, model and run settings decompile empty. Keep <source>/agent.json beside the .flow '
-            + '(download the whole project, not just the .flow).');
-        return {};
-    }
-    let agent;
-    try {
-        agent = JSON.parse(raw);
-    }
-    catch {
-        warnOnce(`agent step "${node.id}": ${path} is not valid JSON, so its prompts, model and run settings decompile empty.`);
-        return {};
-    }
-    const messages = (Array.isArray(agent?.messages) ? agent.messages : []);
-    const content = (role) => {
-        const c = messages.find((m) => m.role === role)?.content;
-        return typeof c === 'string' ? c : undefined;
-    };
-    const settings = (agent?.settings ?? {});
-    const system = content('system');
-    const user = content('user');
-    const isVoice = node.type === T.voiceAgent;
-    const numberUnless = (v, dflt) => typeof v === 'number' && v !== dflt ? v : undefined;
-    // The voice agent's temperature and token cap live in `settings.voice`, not here.
-    const temperature = isVoice ? undefined : numberUnless(settings.temperature, 0);
-    const maxTokenPerResponse = isVoice ? undefined : numberUnless(settings.maxTokens, 16384);
-    // Studio Web's default for the inline agent; the other families keep any value.
-    const maxIterations = node.type === T.inlineAgent
-        ? numberUnless(settings.maxIterations, STUDIO_WEB_DEFAULT_MAX_ITERATIONS)
-        : typeof settings.maxIterations === 'number' ? settings.maxIterations : undefined;
-    // `mode` is a harness choice on the inline agent only; the conversational and
-    // voice sidecars always carry their family's fixed value. `'standard'` is the
-    // sidecar's default, so only another value is the author's. (Naming it no
-    // longer selects a definition version — the node's `{ version }` carries that,
-    // flow-builder-sdk#956.)
-    const mode = node.type === T.inlineAgent && typeof settings.mode === 'string'
-        && settings.mode !== 'standard'
-        ? settings.mode : undefined;
-    return {
-        ...(system === undefined ? {} : { systemPrompt: system }),
-        ...(user === undefined ? {} : { userPrompt: user }),
-        ...(typeof settings.model === 'string' ? { model: settings.model } : {}),
-        ...(temperature === undefined ? {} : { temperature }),
-        ...(maxTokenPerResponse === undefined ? {} : { maxTokenPerResponse }),
-        ...(maxIterations === undefined ? {} : { maxIterations }),
-        ...(mode === undefined ? {} : { mode }),
-        ...(Array.isArray(agent?.guardrails) && agent.guardrails.length > 0 ? { guardrails: agent.guardrails } : {}),
-        ...(isVoice && settings.voice && typeof settings.voice === 'object' ? { voice: settings.voice } : {}),
-    };
-}
-/**
- * Where a context-index resource node keeps its identity, read in the order
- * that holds for every writer.
- *
- * SDK compile writes `indexId` / `indexName` / `folderPath` onto the node. The
- * canvas and the CLI do not: their node carries only `inputs.source`, and the
- * identity lives in two other places.
- *
- *  - The node TYPE, `…context.index.<slug>.<uuid>`: the uuid is the index id
- *    (the `ContextIndexRef.id` JSDoc says to read it there).
- *  - The resource sidecar `<agent source>/resources/<inputs.source>/resource.json`,
- *    whose `name` is the index's real name (the one the slug is made from) and
- *    whose `folderPath` is its folder. `display.label` is only what the canvas
- *    shows, and a canvas rename changes it.
- *
- * So the id comes from the type (then `inputs.indexId`). The name is the first
- * of `inputs.indexName`, sidecar `name`, sidecar `indexName`, label that slugs to
- * the type's slug, else the first one present in that order. Compile derives
- * the type from `slug(name)` + id, so when the chosen name does not slug back to
- * the type's slug the recompiled node gets a different type, and that is warned.
- */
-function contextIndexIdentity(agent, c, rPlain) {
-    const fromType = parseContextIndexType(c.type);
-    const sidecar = contextResourceSidecar(agent, c);
-    const sidecarText = (k) => typeof sidecar?.[k] === 'string' && sidecar[k] !== '' ? sidecar[k] : undefined;
-    const label = typeof c.display?.label === 'string' && c.display.label !== '' ? c.display.label : undefined;
-    // The canvas can set both sidecar `name` and `indexName`, and they can differ.
-    // The one that slugs to the type's slug is the one the type was built from, so
-    // it wins; the fixed order is the fallback when none matches.
-    const candidates = [rPlain(c, 'indexName'), sidecarText('name'), sidecarText('indexName'), label]
-        .filter((n) => n !== undefined);
-    const name = (fromType?.slug ? candidates.find((n) => contextIndexSlug(n) === fromType.slug) : undefined)
-        ?? candidates[0] ?? '';
-    const id = (fromType?.id || undefined) ?? rPlain(c, 'indexId') ?? '';
-    if (fromType !== undefined && fromType.slug !== '' && contextIndexSlug(name) !== fromType.slug) {
-        warnOnce(`context index "${c.id}" on agent "${agent.id}": its node type names the index "${fromType.slug}", `
-            + `but the name decompile recovered, ${JSON.stringify(name)}, slugs to "${contextIndexSlug(name)}", so compile `
-            + `will write a different node type. Set \`name\` to the index's real name`
-            + (sidecar === undefined ? ', or keep the resources/ folder beside the .flow so decompile can read it.' : '.'));
-    }
-    return { name, id, folderPath: rPlain(c, 'folderPath') ?? sidecarText('folderPath'), sidecar };
-}
-/** The retrieval modes `ContextIndexRef.retrievalMode` can hold. */
-const CONTEXT_RETRIEVAL_MODES = new Set(['semantic', 'structured', 'deeprag', 'batchtransform']);
-/** The `settings` keys of a context `resource.json` that {@link contextIndexSettings} reads or checks. */
-const CONTEXT_SETTINGS_KEYS = new Set([
-    'retrievalMode', 'query', 'folderPathPrefix', 'threshold', 'resultCount', 'fileExtension',
-    'citationMode', 'webSearchGrounding', 'outputColumns',
-]);
-/**
- * A context index's retrieval settings, as the `context: [...]` entry's option
- * rows (`retrievalMode`, `query`, `threshold`, `resultCount`, `fileExtension`),
- * each left out when it is what compile writes anyway.
- *
- * The inverse of `contextResourceJson` (serialize.ts). Read from the sidecar's
- * `settings` first: a node the canvas or the CLI placed keeps its inputs minimal
- * (`inputs.source`), so `resource.json` is the only copy, and it is what the
- * runtime reads. The node's own inputs (the SDK writes both) answer when there
- * is no sidecar. Before #1183 neither was read, so a no-edit round trip reset
- * every setting to the SDK default without a word.
- *
- * The query is variant-tagged in the sidecar and mode-tagged on the node:
- *
- *  - `dynamic` / `prompt` → a plain string (the guidance the model reads);
- *  - `static` / `text-builder` whose text is a `=js:` expression → that
- *    expression, which compile writes back as `text-builder` / `static`;
- *  - `static` with `''` is the canvas's spelling of "no query", as the SDK's
- *    `dynamic` with `''` is: left out.
- *
- * A setting the SDK cannot express (a `static` query of plain text, an
- * `argument` query, deeprag citations off, batchtransform web grounding off or
- * output columns, a folder-path prefix, an unknown mode or key) is reported:
- * a warning, or an error under `--strict`. Compile would write the SDK's
- * value instead, so it is never dropped silently.
- */
-function contextIndexSettings(agent, c, sidecar) {
-    const settings = sidecar?.settings && typeof sidecar.settings === 'object' && !Array.isArray(sidecar.settings)
-        ? sidecar.settings : undefined;
-    const ni = (c.inputs ?? {});
-    const where = `context index "${c.id}" on agent "${agent.id}"`;
-    const lossy = (what) => {
-        const message = `${where}: ${what}, which \`context: [...]\` cannot express, so compile writes the SDK's `
-            + `value instead. Edit that setting in the canvas after merging, or keep the original resource.json.`;
-        if (runStrict)
-            throw new Error(`decompile: ${message}`);
-        warnOnce(message);
-    };
-    const textOf = (v) => (typeof v === 'string' ? v : undefined);
-    const numOf = (v) => {
-        const raw = unwrapPlain(v);
-        return typeof raw === 'number' && Number.isFinite(raw) ? raw : undefined;
-    };
-    const valueOf = (v) => (v && typeof v === 'object' ? v.value : undefined);
-    // Retrieval mode.
-    const rawMode = textOf(settings?.retrievalMode) ?? textOf(unwrapSource(ni.retrievalMode));
-    let mode = CONTEXT_INDEX_DEFAULTS.retrievalMode;
-    if (rawMode !== undefined && rawMode !== '') {
-        if (CONTEXT_RETRIEVAL_MODES.has(rawMode))
-            mode = rawMode;
-        else
-            lossy(`its retrieval mode is ${JSON.stringify(rawMode)}`);
-    }
-    const sidecarQuery = (() => {
-        const q = settings?.query;
-        if (!q || typeof q !== 'object')
-            return undefined;
-        if (q.variant === 'dynamic')
-            return { kind: 'prompt', text: textOf(q.description) ?? '' };
-        if (q.variant === 'static')
-            return { kind: 'text', text: textOf(q.value) ?? '' };
-        if (q.variant === 'argument')
-            return { kind: 'argument', text: textOf(q.value) ?? '' };
-        lossy(`its query has variant ${JSON.stringify(q.variant)}`);
-        return undefined;
-    })();
-    const nodeQuery = (() => {
-        const q = ni.query;
-        if (typeof q === 'string')
-            return q === '' ? undefined : { kind: q.startsWith('=js:') ? 'text' : 'prompt', text: q };
-        if (!q || typeof q !== 'object')
-            return undefined;
-        const t = q;
-        if (t.mode === 'text-builder')
-            return { kind: 'text', text: textOf(t.textValue) ?? '' };
-        if (t.mode === 'variable')
-            return { kind: 'argument', text: textOf(t.argumentPath) ?? '' };
-        return { kind: 'prompt', text: textOf(t.promptValue) ?? '' };
-    })();
-    const query = sidecarQuery ?? nodeQuery;
-    let querySrc;
-    if (query?.kind === 'prompt' && query.text !== '')
-        querySrc = tsLiteral(query.text);
-    else if (query?.kind === 'text' && query.text.startsWith('=js:'))
-        querySrc = tsLiteral(query.text);
-    else if (query?.kind === 'text' && query.text !== '')
-        lossy(`its query is static text (${JSON.stringify(query.text)})`);
-    else if (query?.kind === 'argument')
-        lossy(`its query is the agent argument ${JSON.stringify(query.text)}`);
-    // Numbers and the file extension.
-    const threshold = numOf(settings?.threshold) ?? numOf(ni.threshold);
-    const resultCount = numOf(settings?.resultCount) ?? numOf(ni.resultCount);
-    const fileExtension = textOf(valueOf(settings?.fileExtension)) ?? textOf(unwrapSource(ni.fileExtension));
-    // The node's flat `All` is the platform's node default for every mode; only
-    // the resource's per-mode default is what compile would write anyway.
-    const defaultExtension = ownEntry(CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, mode) ?? 'All';
-    const extensionSrc = fileExtension === undefined || fileExtension === '' || fileExtension === defaultExtension
-        || (settings?.fileExtension === undefined && fileExtension === 'All')
-        ? undefined : tsLiteral(fileExtension);
-    // What compile writes as constants; anything else has no field.
-    if (mode === 'deeprag') {
-        const citation = textOf(valueOf(settings?.citationMode)) ?? textOf(unwrapSource(ni.citations));
-        if (citation !== undefined && !['Inline', 'enabled'].includes(citation))
-            lossy(`its citation mode is ${JSON.stringify(citation)}`);
-    }
-    if (mode === 'batchtransform') {
-        const grounding = textOf(valueOf(settings?.webSearchGrounding)) ?? textOf(valueOf(ni.webSearchGrounding));
-        if (grounding !== undefined && !['Enabled', 'enabled'].includes(grounding))
-            lossy(`its web search grounding is ${JSON.stringify(grounding)}`);
-        const columns = settings?.outputColumns ?? ni.outputColumns;
-        if (Array.isArray(columns) && columns.length > 0)
-            lossy(`it has ${columns.length} output column(s)`);
-    }
-    // The folder-path prefix: variant-tagged in the sidecar, mode-tagged on the node.
-    const field = (v, k) => (v && typeof v === 'object' ? textOf(v[k]) : undefined);
-    const prefixText = settings?.folderPathPrefix !== undefined
-        ? field(settings.folderPathPrefix, 'value') ?? field(settings.folderPathPrefix, 'description') ?? ''
-        : field(ni.folderPathPrefix, 'textValue') ?? field(ni.folderPathPrefix, 'promptValue') ?? '';
-    if (prefixText !== '')
-        lossy(`its folder-path prefix is ${JSON.stringify(prefixText)}`);
-    for (const k of Object.keys(settings ?? {})) {
-        if (!CONTEXT_SETTINGS_KEYS.has(k))
-            lossy(`its resource.json settings carry ${JSON.stringify(k)}`);
-    }
-    return [
-        ['query', querySrc],
-        ['retrievalMode', mode !== CONTEXT_INDEX_DEFAULTS.retrievalMode ? tsLiteral(mode) : undefined],
-        ['threshold', threshold !== undefined && threshold !== CONTEXT_INDEX_DEFAULTS.threshold ? tsNumber(threshold) : undefined],
-        ['resultCount', resultCount !== undefined && resultCount !== CONTEXT_INDEX_DEFAULTS.resultCount ? tsNumber(resultCount) : undefined],
-        ['fileExtension', extensionSrc],
-    ];
-}
-/**
- * A context resource's `resource.json` sidecar, parsed; `undefined` when it is
- * not beside the `.flow`, or (with a warning) when it is not a JSON object.
- */
-function contextResourceSidecar(agent, c) {
-    const agentSource = unwrapSource(agent.inputs?.source);
-    const resourceSource = unwrapSource(c.inputs?.source);
-    if (!agentSource || !resourceSource)
-        return undefined;
-    const path = `${agentSource}/resources/${resourceSource}/resource.json`;
-    const raw = runReadSidecar?.(path);
-    if (raw === undefined)
-        return undefined;
-    try {
-        const json = JSON.parse(raw);
-        if (json && typeof json === 'object' && !Array.isArray(json))
-            return json;
-    }
-    catch {
-        // Reported below with the non-object case.
-    }
-    warnOnce(`context index "${c.id}": ${path} is not valid JSON, so its name and folder decompile from the node.`);
-    return undefined;
-}
-/**
- * An AGENT and its attached resources — the inline autonomous agent, the
- * conversational agent, and the voice agent.
- *
- * The cluster is a node plus artifact nodes on its `tool` / `context` /
- * `escalation` / `memory` handles, so this walks those edges and recovers each
- * resource as an argument rather than as a step (see {@link ARTIFACT_PORTS}).
- *
- * **The author's input NAMES are not recoverable, and that is by design.** The
- * platform does not send an agent the names you declared: it keys each argument
- * by the reference PATH, `__`-joined (`$vars.prep.output` → `prep__output`), and
- * only those flat names survive in the emitted file. Recovery therefore uses
- * them for both the `inputs` keys and the `{{input.…}}` placeholders — the same
- * arguments reach the model, spelled the platform's way. (Node ids are
- * preserved exactly; only these logical names change.)
- */
-function emitAgentCluster(node, imp, inputNames, graph) {
-    // A key on the node wins over the sidecar's copy of it.
-    const i = { ...sidecarAgentInputs(node), ...(node.inputs ?? {}) };
-    const plain = (v) => {
-        const raw = unwrapSource(v);
-        return raw === undefined || raw === '' ? undefined : raw;
-    };
-    const num = (v) => {
-        const raw = unwrapPlain(v);
-        return typeof raw === 'number' ? String(raw) : undefined;
-    };
-    // Prompts. A sidecar prompt already speaks `{{input.<flatName>}}`, so this
-    // leaves it alone. An EMBEDDED node's prompt (Studio Web with the
-    // self-contained flag on, or an SDK before #927) carries each input as its
-    // rendered binding instead; the bindings in `agentInputVariables` are exactly
-    // what to put back — longest first, so a shorter binding cannot eat a longer
-    // one's prefix.
-    const vars = (Array.isArray(i.agentInputVariables) ? i.agentInputVariables : []);
-    const refs = vars
-        .filter((v) => typeof v.id === 'string' && typeof v.binding === 'string')
-        .map((v) => ({ flatName: v.id, binding: v.binding }))
-        .sort((a, b) => b.binding.length - a.binding.length);
-    const unrender = (text) => {
-        let out = text;
-        for (const r of refs)
-            out = out.split(r.binding).join(`{{input.${r.flatName}}}`);
-        return out;
-    };
-    const promptSrc = (v) => {
-        const raw = plain(v);
-        return raw === undefined ? undefined : tsLiteral(unrender(raw));
-    };
-    const inputRows = refs
-        // Emit in the file's own order, not the length-sorted one.
-        .slice()
-        .sort((a, b) => vars.findIndex((v) => v.id === a.flatName) - vars.findIndex((v) => v.id === b.flatName))
-        .map((r) => {
-        return [r.flatName, emitBareExpr(wireExprBody(r.binding), imp, inputNames)];
-    });
-    const outVars = (Array.isArray(i.agentOutputVariables) ? i.agentOutputVariables : []);
-    const returns = outVars.length
-        ? objLit(outVars.map((v) => [String(v.id ?? ''), tsLiteral(String(v.type ?? 'string'))]))
-        : undefined;
-    // The resources, from the agent's own artifact edges. Each edge read here is
-    // carried by the agent spec (edge accounting, #1125); `limit` is for a port
-    // the spec carries only one resource on.
-    const resource = (port, limit = Infinity) => {
-        const found = [];
-        for (const e of graph?.outEdges(node.id) ?? []) {
-            if (e.sourcePort !== port || found.length >= limit)
-                continue;
-            const n = graph.byId.get(e.targetNodeId);
-            if (n === undefined)
-                continue;
-            graph.accounted.add(e);
-            found.push(n);
-        }
-        return found;
-    };
-    // Record what compile will call each folded resource node. Serialize mints
-    // `uid(scope, \`${step.name}<Kind>\`)` per resource, in spec order, and the
-    // spec order is this edge order: the first is `<agent><Kind>`, the n-th
-    // `<agent><Kind><n>` (claimId's dedupe). Only the first memory is recovered,
-    // so every further memory maps to `undefined`.
-    //
-    // When a port's nodes do not ALL carry those ids (the canvas or the CLI named
-    // them), every resource on the port is written with its own `nodeId`, and
-    // compile keeps the file's ids. All of them, not only the odd one: compile
-    // numbers the derived ids in order, so a derived id after an explicit one
-    // would come out one lower than the file's.
-    // This reads the edges directly, not through `resource()`: it must see EVERY
-    // artifact edge, including ones the spec does not carry, and it must not
-    // account for any edge.
-    const keepIds = new Set();
-    for (const [port, kind, emittedCount] of [
-        ['context', 'Context', Infinity], ['tool', 'Tool', Infinity],
-        ['escalation', 'Escalation', Infinity], ['memory', 'Memory', 1],
-    ]) {
-        const targets = (graph?.outEdges(node.id) ?? [])
-            .filter((e) => e.sourcePort === port && graph.byId.has(e.targetNodeId))
-            .map((e) => e.targetNodeId);
-        const keep = port !== 'memory'
-            && targets.some((id, k) => id !== derivedResourceNodeId(node.id, kind, k));
-        targets.forEach((id, k) => {
-            if (keep)
-                keepIds.add(id);
-            runAbsorbed.set(id, keep ? id : k >= emittedCount ? undefined : derivedResourceNodeId(node.id, kind, k));
-        });
-    }
-    /**
-     * The `nodeId` / `source` entries for resource node `r`: each only when it
-     * differs from what compile derives (`derivedSource`), so a flow compile
-     * wrote decompiles without them.
-     */
-    const placement = (r, derivedSource) => {
-        const source = unwrapSource((r.inputs ?? {}).source);
-        return [
-            ['nodeId', keepIds.has(r.id) ? tsLiteral(r.id) : undefined],
-            ['source', source !== undefined && source !== '' && source !== derivedSource ? tsLiteral(source) : undefined],
-        ];
-    };
-    /** A tool's options plus its placement; `seed` is the ref compile derives the tool's directory from. */
-    const toolOpts = (t, seed, entries) => opts([...entries, ...placement(t, derivedToolSource(runFlowId, node.id, seed))]);
-    const rInputs = (n) => (n.inputs ?? {});
-    const rPlain = (n, k) => {
-        const raw = unwrapSource(rInputs(n)[k]);
-        return raw === undefined || raw === '' ? undefined : raw;
-    };
-    const toolSrc = resource('tool').map((t) => {
-        const ti = rInputs(t);
-        const type = t.type;
-        if (type === 'uipath.agent.resource.tool.clientside') {
-            const schemaTypes = (v) => {
-                const props = v?.properties;
-                if (!props || Object.keys(props).length === 0)
-                    return undefined;
-                return objLit(Object.entries(props).map(([k, x]) => [k, tsLiteral(String(x?.type ?? 'string'))]));
-            };
-            return toolOpts(t, { kind: 'clientside', name: rPlain(t, 'name') ?? '' }, [
-                ['kind', tsLiteral('clientside')],
-                ['name', tsLiteral(rPlain(t, 'name') ?? '')],
-                ['description', rPlain(t, 'description') !== undefined ? tsLiteral(rPlain(t, 'description')) : undefined],
-                ['inputs', schemaTypes(ti.inputSchema)],
-                ['returns', schemaTypes(ti.outputSchema)],
-            ]);
-        }
-        if (type === 'uipath.agent.resource.tool.builtin.httprequest') {
-            // A field is authored only when it left prompt mode (text-builder).
-            const fixed = (k) => {
-                const row = ti[k];
-                if (!row || row.mode !== 'text-builder')
-                    return undefined;
-                const v = row.textValue;
-                return typeof v === 'number' ? String(v) : typeof v === 'string' ? tsLiteral(v) : JSON.stringify(v);
-            };
-            // `name` is not recovered, so compile derives the directory from the default.
-            return toolOpts(t, { kind: 'httpRequest' }, [
-                ['kind', tsLiteral('httpRequest')],
-                ['url', fixed('url')], ['method', fixed('method')],
-                ['headers', fixed('headers')], ['params', fixed('params')],
-                ['body', fixed('body')], ['timeout', fixed('timeout')],
-            ]);
-        }
-        if (type.startsWith('uipath.agent.resource.tool.mcp.')) {
-            return toolOpts(t, { kind: 'mcp', name: '', key: rPlain(t, 'referenceKey') ?? '' }, [
-                ['kind', tsLiteral('mcp')],
-                ['name', tsLiteral(rPlain(t, 'name') ?? '')],
-                ['key', tsLiteral(rPlain(t, 'referenceKey') ?? '')],
-                // The mapper's field name for the canonical server slug.
-                ['slug', rPlain(t, 'serverUrl') !== undefined ? tsLiteral(rPlain(t, 'serverUrl')) : undefined],
-                ['folderPath', rPlain(t, 'folderPath') !== undefined ? tsLiteral(rPlain(t, 'folderPath')) : undefined],
-                ['mcpType', rPlain(t, 'mcpType') !== undefined ? tsLiteral(rPlain(t, 'mcpType')) : undefined],
-            ]);
-        }
-        if (type.startsWith('uipath.agent.resource.tool.a2a.')) {
-            return toolOpts(t, { kind: 'a2a', name: '', slug: '', key: rPlain(t, 'referenceKey') ?? '' }, [
-                ['kind', tsLiteral('a2a')],
-                ['name', tsLiteral(rPlain(t, 'name') ?? '')],
-                ['key', tsLiteral(rPlain(t, 'referenceKey') ?? '')],
-                ['slug', tsLiteral(rPlain(t, 'slug') ?? '')],
-                ['folderPath', rPlain(t, 'folderPath') !== undefined ? tsLiteral(rPlain(t, 'folderPath')) : undefined],
-            ]);
-        }
-        if (type.startsWith('uipath.agent.resource.tool.builtin.')) {
-            const tool = type.slice('uipath.agent.resource.tool.builtin.'.length);
-            return toolOpts(t, { kind: 'builtin', tool }, [
-                ['kind', tsLiteral('builtin')],
-                ['tool', tsLiteral(tool)],
-                ['description', rPlain(t, 'description') !== undefined ? tsLiteral(rPlain(t, 'description')) : undefined],
-            ]);
-        }
-        if (type.startsWith('uipath.agent.resource.tool.ixp.')) {
-            const tail = type.slice('uipath.agent.resource.tool.ixp.'.length);
-            const projectId = tail.slice(tail.indexOf('.') + 1);
-            return toolOpts(t, { kind: 'ixp', name: '', projectId }, [
-                ['kind', tsLiteral('ixp')],
-                ['projectId', tsLiteral(projectId)],
-                ['name', tsLiteral(rPlain(t, 'name') ?? '')],
-            ]);
-        }
-        // The per-instance resource kinds (process / api / flow / maestro / agent /
-        // function): the key is the node type's tail, the rest is a binding pair.
-        const PROCESS_NS = [
-            ['uipath.agent.resource.tool.processorchestration.', 'maestro'],
-            ['uipath.agent.resource.tool.process.', 'process'],
-            ['uipath.agent.resource.tool.function.', 'function'],
-            ['uipath.agent.resource.tool.api.', 'api'],
-            ['uipath.agent.resource.tool.flow.', 'flow'],
-            ['uipath.agent.resource.tool.agent.', 'agent'],
-        ];
-        const ns = PROCESS_NS.find(([prefix]) => type.startsWith(prefix));
-        if (ns) {
-            const def = runDefs.get(`${type}@${t.typeVersion}`) ?? runDefs.get(type);
-            const values = (def?.model?.bindings?.values ?? []);
-            const bound = (n) => {
-                const row = values.find((v) => v.name === n);
-                return typeof row?.default === 'string' ? row.default : undefined;
-            };
-            const key = type.slice(ns[0].length);
-            return toolOpts(t, { kind: 'process', name: '', folderPath: '', key }, [
-                ['kind', tsLiteral(ns[1])],
-                ['key', tsLiteral(key)],
-                ['name', tsLiteral(bound('name') ?? rPlain(t, 'name') ?? '')],
-                ['folderPath', tsLiteral(bound('folderPath') ?? '')],
-            ]);
-        }
-        return opts([['kind', tsLiteral('builtin')], ['tool', tsLiteral('summarize')]]); // unreachable in practice
-    });
-    const contextSrc = resource('context').map((c) => {
-        const { name, id, folderPath, sidecar } = contextIndexIdentity(node, c, rPlain);
-        // Compile labels the node with `name`; a canvas rename is kept as `label`.
-        const label = typeof c.display?.label === 'string' && c.display.label !== '' && c.display.label !== name
-            ? c.display.label : undefined;
-        return opts([
-            ['name', tsLiteral(name)],
-            ['id', tsLiteral(id)],
-            ['folderPath', folderPath !== undefined ? tsLiteral(folderPath) : undefined],
-            ['folderKey', rPlain(c, 'folderKey') !== undefined ? tsLiteral(rPlain(c, 'folderKey')) : undefined],
-            // `query` and the retrieval settings, from resource.json or the node (#1183).
-            ...contextIndexSettings(node, c, sidecar),
-            ['label', label !== undefined ? tsLiteral(label) : undefined],
-            ...placement(c, derivedContextSource(runFlowId, node.id, id)),
-        ]);
-    });
-    const escalationSrc = resource('escalation').map((e) => {
-        const ei = rInputs(e);
-        const recipients = Array.isArray(ei.recipients)
-            ? ei.recipients.map((r) => tsText(r.value))
-            : [];
-        const outcomeNames = Object.keys((ei.outcomeMapping ?? {}));
-        const isQuickForm = e.type === 'uipath.agent.resource.escalation.quick-form';
-        const rows = isQuickForm
-            ? (ei.schema?.fields ?? [])
-            : [];
-        const app = ei.app;
-        const extra = (ei._additionalProps ?? {});
-        return opts([
-            ['variant', isQuickForm ? tsLiteral('quick-form') : undefined],
-            ['name', tsLiteral(rPlain(e, 'name') ?? '')],
-            ['description', rPlain(e, 'description') !== undefined ? tsLiteral(rPlain(e, 'description')) : undefined],
-            ['fields', rows.length ? `[${rows.map((f) => {
-                    const id = String(f.id ?? '');
-                    const direction = String(f.direction ?? 'output');
-                    // Every row key the source cannot carry is reported, never dropped
-                    // silently: a warning, an error under --strict (#1250).
-                    const loss = formFieldRowLoss(f, 'escalation');
-                    if (loss.length > 0) {
-                        const message = formFieldRowLossMessage(`quick-form escalation ${JSON.stringify(rPlain(e, 'name') ?? e.id)} on agent ${JSON.stringify(node.id)}`, id, loss);
-                        if (runStrict)
-                            throw new Error(`decompile: ${message}`);
-                        warnOnce(message);
-                    }
-                    return opts([
-                        ['id', tsText(f.id)],
-                        // serialize defaults a row's label to its id.
-                        ['label', typeof f.label === 'string' && f.label !== id ? tsLiteral(f.label) : undefined],
-                        ['type', tsLiteral(sourceFormFieldType(f.type ?? 'string'))],
-                        ['direction', tsLiteral(direction)],
-                        ['required', typeof f.required === 'boolean' && direction !== 'input' ? String(f.required) : undefined],
-                        ...formFieldSettingsSource(liftFormFieldSettings(f), dataSource),
-                    ]);
-                }).join(', ')}]` : undefined],
-            ['app', app === undefined ? undefined : opts([
-                    ['key', tsText(app.key)],
-                    ['name', tsText(app.name)],
-                    ['folderPath', typeof app.folderPath === 'string' && app.folderPath !== '' ? tsLiteral(app.folderPath) : undefined],
-                ])],
-            ['recipients', recipients.length ? `[${recipients.join(', ')}]` : undefined],
-            ['outcomes', outcomeNames.length ? `[${outcomeNames.map((o) => tsLiteral(o)).join(', ')}]` : undefined],
-            ['taskTitle', typeof extra.taskTitle === 'string' && extra.taskTitle !== '' ? tsLiteral(extra.taskTitle) : undefined],
-            // 'medium' is the platform default.
-            ['priority', typeof extra.priority === 'string' && extra.priority !== 'medium' ? tsLiteral(extra.priority) : undefined],
-            ...placement(e, derivedEscalationSource(runFlowId, node.id, rPlain(e, 'name') ?? '')),
-        ]);
-    });
-    const mem = resource('memory', 1)[0];
-    const memorySrc = mem === undefined ? undefined : (() => {
-        // The memory's id is the node type's tail; the def carries it too.
-        const tail = mem.type.slice('uipath.agent.resource.memory.'.length);
-        const id = tail.slice(tail.indexOf('.') + 1);
-        const mi = rInputs(mem);
-        return opts([
-            ['name', tsLiteral(rPlain(mem, 'name') ?? '')],
-            ['id', tsLiteral(id)],
-            ['description', rPlain(mem, 'description') !== undefined ? tsLiteral(rPlain(mem, 'description')) : undefined],
-            // The platform defaults: few-shot on, similarity 0, k 3, hybrid search.
-            ['dynamicFewShotLearning', unwrapPlain(mi.dynamicFewShotLearning) === false ? 'false' : undefined],
-            ['semanticSimilarity', num(mi.semanticSimilarity) !== undefined && num(mi.semanticSimilarity) !== '0' ? num(mi.semanticSimilarity) : undefined],
-            ['kValue', num(mi.kValue) !== undefined && num(mi.kValue) !== '3' ? num(mi.kValue) : undefined],
-            ['searchMode', rPlain(mem, 'searchMode') !== undefined && rPlain(mem, 'searchMode') !== 'hybrid'
-                    ? tsLiteral(rPlain(mem, 'searchMode')) : undefined],
-        ]);
-    })();
-    const guardrails = Array.isArray(i.guardrails) && i.guardrails.length > 0
-        ? JSON.stringify(i.guardrails)
-        : undefined;
-    const list = (items) => (items.length ? `[${items.join(', ')}]` : undefined);
-    if (node.type === T.voiceAgent) {
-        const v = (i.voice ?? {});
-        const voiceSrc = Object.keys(v).length === 0 ? undefined : opts([
-            ['model', typeof v.model === 'string' ? tsLiteral(v.model) : undefined],
-            ['persona', typeof v.persona === 'string' ? tsLiteral(v.persona) : undefined],
-            ['temperature', num(v.temperature)],
-            ['maxTokens', num(v.maxTokens)],
-        ]);
-        return `${imp.use('voiceAgent')}(${opts([
-            ['systemPrompt', promptSrc(i.systemPrompt) ?? tsLiteral('')],
-            ['inputs', inputRows.length ? objLit(inputRows) : undefined],
-            ['callContext', (() => {
-                    const raw = plain(i.callContext) ?? '';
-                    const js = wireExprBody(raw);
-                    // Anything but a `$vars.` reference stays the wire text verbatim.
-                    return js.startsWith('$vars.') ? emitBareExpr(js, imp, inputNames) : tsLiteral(raw);
-                })()],
-            ['voice', voiceSrc],
-            ['maxIterations', num(i.maxIterations)],
-            ['source', tsLiteral(plain(i.source) ?? '')],
-        ])})`;
-    }
-    if (node.type === T.conversationalAgent) {
-        const st = (i.conversationalAgentSettings ?? {});
-        const settingExpr = (k) => {
-            // `unwrapSource` rather than a string test: since the envelope reaches
-            // these five keys (migrate's `NESTED_BINDING_INPUTS`), a bare string is
-            // only what a pre-1.6 file carries. Reading strings alone made every
-            // modern file decompile to a conversational agent with no turn wiring.
-            const raw = unwrapSource(st[k]);
-            if (raw === undefined || raw === '' || raw === '=js:')
-                return undefined;
-            // Only a `=js:` value is an expression: `emitRef` lowers a single path to
-            // `out(...)` and anything composite to a `js` template. Any other string
-            // is literal text, as the product reads it (flow-schema
-            // `coerceToExpressionValue`), even when it looks like `$vars.…`.
-            return raw.startsWith('=js:') ? emitRef(raw.slice(4), imp, inputNames) : tsLiteral(raw);
-        };
-        // `'simple'` mode DERIVES the four runtime fields from `context`, so only
-        // the context binding is the author's; recovering the derived ones would
-        // re-emit them as hand-bound custom fields.
-        const mode = typeof st.mode === 'string' ? st.mode : 'simple';
-        const settingsSrc = mode === 'custom'
-            ? opts([
-                ['mode', tsLiteral('custom')],
-                ['conversationId', settingExpr('conversationId')],
-                ['exchangeId', settingExpr('exchangeId')],
-                ['messages', settingExpr('messages')],
-                ['userSettings', settingExpr('userSettings')],
-            ])
-            : opts([['context', settingExpr('context')]]);
-        return `${imp.use('conversationalAgent')}(${opts([
-            ['model', tsLiteral(plain(i.model) ?? '')],
-            ['systemPrompt', promptSrc(i.systemPrompt) ?? tsLiteral('')],
-            // `settings` is required on ConversationalAgentInputs, so an empty one
-            // stays as `{}`, which check then reports as CONV_AGENT_NO_TURN.
-            ['settings', settingsSrc || '{}'],
-            ['temperature', num(i.temperature)],
-            ['maxTokenPerResponse', num(i.maxTokenPerResponse)],
-            ['maxIterations', num(i.maxIterations)],
-            ['guardrails', guardrails],
-            ['source', tsLiteral(plain(i.source) ?? '')],
-        ])})`;
-    }
-    return `${imp.use('inlineAgent')}(${opts([
-        ['model', tsLiteral(plain(i.model) ?? '')],
-        ['systemPrompt', promptSrc(i.systemPrompt) ?? tsLiteral('')],
-        ['userPrompt', promptSrc(i.userPrompt) ?? tsLiteral('')],
-        ['inputs', inputRows.length ? objLit(inputRows) : undefined],
-        ['returns', returns],
-        ['temperature', num(i.temperature)],
-        ['maxTokenPerResponse', num(i.maxTokenPerResponse)],
-        ['maxIterations', num(i.maxIterations)],
-        ['mode', plain(i.mode) !== undefined ? tsLiteral(plain(i.mode)) : undefined],
-        ['guardrails', guardrails],
-        ['context', list(contextSrc)],
-        ['tools', list(toolSrc)],
-        ['escalation', list(escalationSrc)],
-        ['memory', memorySrc],
-        // The agent's directory uuid is derived from the flow and step ids, but a
-        // decompiled flow must keep the ORIGINAL — the sidecar lives at
-        // `<source>/agent.json`, so a re-derived one would point at nothing.
-        ['source', tsLiteral(plain(i.source) ?? '')],
-    ])})`;
-}
 /**
  * A connector EVENT subscription, shared by the trigger (`onEvent`) and the
  * mid-flow wait (`waitForEvent`) — the same node body in both places, so the
@@ -1608,83 +915,6 @@ function emitEventSubscription(node, imp, inputNames) {
         ['folder', folder !== undefined ? tsLiteral(folder) : undefined],
     ]) + unboundMarker(node, { connection: conn, folder }, connector, event);
 }
-/**
- * Read back the expression template older SDK builds emitted on an in-solution
- * `agent()` input (#1013): `{ type: 'literal', expression: '{{ <js> }}' }`.
- * serialize now emits the platform's `{ type: 'jsExpression', expression }`
- * instead, but `.flow` files written between 2026-08-10 and the fix still carry
- * the template, and the runtime evaluates it (the agent receives the value, not
- * the braces). So on an in-solution agent node a literal that is exactly one
- * `{{ … }}` is that expression, and it decompiles to the reference it was
- * written from rather than to a string. Anything else is returned unchanged.
- */
-function legacyAgentTemplateInput(v) {
-    if (!v || typeof v !== 'object' || Array.isArray(v))
-        return v;
-    const o = v;
-    if (o.type !== 'literal' || typeof o.expression !== 'string')
-        return v;
-    const m = /^\{\{\s*([\s\S]+?)\s*\}\}$/.exec(o.expression);
-    if (!m || m[1].includes('}}') || m[1].includes('{{'))
-        return v;
-    return { ...o, type: 'jsExpression', expression: m[1] };
-}
-function emitPublishedResource(node, imp, inputNames) {
-    // The published AGENT resource — the same shape as the process family's
-    // node types (identity in the definition's binding pair, contract in its
-    // output schema), which lift themselves (nodes/process/flow/).
-    const FAMILIES = [
-        { prefix: 'uipath.core.agent.', factory: 'agent' },
-    ];
-    const family = FAMILIES.find((f) => node.type.startsWith(f.prefix));
-    if (!family)
-        return undefined;
-    const key = node.type.slice(family.prefix.length);
-    const def = runDefs.get(`${node.type}@${node.typeVersion}`) ?? runDefs.get(node.type);
-    const values = (def?.model?.bindings?.values ?? []);
-    const binding = (name) => {
-        const row = values.find((v) => v.name === name);
-        return typeof row?.default === 'string' ? row.default : undefined;
-    };
-    // The binding pair is the identity the runtime resolves by; without a
-    // definition to read there is nothing to recover it from.
-    const name = binding('name');
-    const folderPath = binding('folderPath');
-    // A sibling project of the same solution (#951): the model names its project
-    // instead of a folder. `isInSolution` is flow-core's marker; an in-solution
-    // agent emitted before #951 carries only `projectId`. Read back as
-    // `location: 'in-solution'` so the recompile takes the in-solution path
-    // instead of a published one with an empty folder.
-    const projectId = typeof def?.model?.projectId === 'string' ? def.model.projectId : undefined;
-    const inSolution = def?.model?.isInSolution === true || projectId !== undefined;
-    const inputs = { ...(node.inputs ?? {}) };
-    // The design-time fire-and-forget switch is an OPTION on the factory, not a
-    // process argument — serialize adds it to `inputs` after rendering the
-    // author's map, so it comes back off here.
-    const fireAndForget = unwrapPlain(inputs.fireAndForget) === true;
-    delete inputs.fireAndForget;
-    if (family.factory === 'agent' && (def?.model?.isInSolution === true || def?.model?.projectId !== undefined)) {
-        for (const [k, v] of Object.entries(inputs))
-            inputs[k] = legacyAgentTemplateInput(v);
-    }
-    const inputRows = Object.entries(inputs)
-        .map(([k, v]) => [k, emitVal(v, imp, inputNames)]);
-    const schema = def?.outputDefinition?.output?.schema?.properties;
-    const returns = schema && Object.keys(schema).length > 0
-        ? objLit(Object.entries(schema).map(([k, v]) => [k, tsLiteral(String(v?.type ?? 'string'))]))
-        : undefined;
-    return `${imp.use(family.factory)}(${opts([
-        ['key', tsLiteral(key)],
-        ['name', name !== undefined ? tsLiteral(name) : undefined],
-        ['location', inSolution ? tsLiteral('in-solution') : undefined],
-        ['folderPath', !inSolution && folderPath !== undefined ? tsLiteral(folderPath) : undefined],
-        ['projectId', inSolution && projectId !== undefined ? tsLiteral(projectId) : undefined],
-        ['inputs', inputRows.length ? objLit(inputRows) : undefined],
-        ['returns', returns],
-        ['form', family.form !== undefined ? tsLiteral(family.form) : undefined],
-        ['completion', fireAndForget ? tsLiteral('fire-and-forget') : undefined],
-    ])})`;
-}
 function emitConnector(node, imp, inputNames, o) {
     const split = splitConnector(node.type);
     const detail = (node.inputs?.detail ?? {});
@@ -2312,7 +1542,11 @@ function forkRegion(edges, stop, scope, ipdom, ctx, refInto) {
     const targets = edges.map((e) => e.targetNodeId);
     const join = commonPostDominator(targets, ipdom);
     const joinNode = join !== undefined ? ctx.graph.byId.get(join) : undefined;
-    if (join === undefined || join === stop || joinNode?.type !== T.merge) {
+    // Arms may rejoin at the region's own continuation (`stop`) when that is a
+    // plain step: the arms end in `.stepToRef(stop)` and nothing follows them
+    // here. Not at a merge node that is `stop`: the enclosing construct continues
+    // from it, so a `.parallel` inside this arm cannot also own it.
+    if (join === undefined || joinNode === undefined || !parallelJoinable(joinNode) || (join === stop && joinNode.type === T.merge)) {
         if (ctx.o.bestEffort === false)
             throw new Error(`decompile: unstructured fan-out (${edges.length} edges).`);
         ctx.graph.accounted.add(edges[0]);
@@ -2324,22 +1558,75 @@ function forkRegion(edges, stop, scope, ipdom, ctx, refInto) {
     }
     for (const e of edges)
         ctx.graph.accounted.add(e);
-    const fork = parallelSeg(join, joinNode, targets, scope, ipdom, ctx, refInto);
+    const fork = parallelSeg(join, joinNode, targets, scope, ipdom, ctx, refInto, undefined, edges[0].sourceNodeId);
     if (fork.next.brk || fork.next.cont)
         return [fork.seg, fork.next.brk ? '.break()' : '.continue()'];
     return [fork.seg, ...region(fork.next.cursor, stop, scope, ipdom, ctx, refInto)];
 }
 /**
- * The `.parallel(join, [arms])` segment for a fork whose `targets` (one per
- * edge; the caller accounts those edges) meet at the merge node `join`. Each
- * arm is the region up to `join`. `next` is where the walk goes after the
- * merge: its `output` edge, accounted by `continueOn` (`brk` / `cont` when
- * that edge leaves through the enclosing loop's `break` / spelled `continue`).
+ * Whether a fan-out whose arms all reconverge at `join` folds to a
+ * `.parallel(...)`: at a merge node, the SDK's own join; at any other step (a
+ * step, a decision, a loop, …), the canvas shape of several steps feeding one
+ * (#1310), which the arms spell by ending in `.stepToRef(join)` — serialize
+ * writes no merge node when no arm hands it a tail. Not at an End or a
+ * Terminate: arms that all end share the End by name (#1231/#1239) and nothing
+ * follows, which is another fold (#1267).
  */
-function parallelSeg(join, joinNode, targets, scope, ipdom, ctx, refInto) {
-    const arms = targets.map((t, i) => armCb(`a${i}`, region(t, join, scope, ipdom, ctx, refInto)));
-    const seg = `.parallel(${tsLiteral(join)}, [\n${arms.map((a) => reindent(a, '  ')).join(',\n')},\n]${forkOptsArg(joinNode)})`;
-    return { seg, next: continueOn(joinNode, 'output', ctx, refInto) };
+function parallelJoinable(join) {
+    return join.type !== T.end && join.type !== T.terminate;
+}
+/**
+ * The `.parallel(join, [arms])` segment for a fork whose `targets` (one per
+ * edge; the caller accounts those edges) meet at `join`. Each arm is the
+ * region up to `join`.
+ *
+ * At a merge node, `join` names the `.parallel` and `next` is where the walk
+ * goes after it: its `output` edge, accounted by `continueOn` (`brk` / `cont`
+ * when that edge leaves through the enclosing loop's `break` / spelled
+ * `continue`). At any other step (#1310) the arms end in `.stepToRef(join)`,
+ * the `.parallel` gets a fresh name (`forkName`, after `source`) because no
+ * node carries one, and `next` is `join` itself: the main path emits it, and
+ * its only incoming edges are the arms' refs.
+ *
+ * `fork` is the merge node a designer-drawn split leaves from, written as
+ * `{ fork }` (#1310); the caller accounts its outgoing edges.
+ */
+function parallelSeg(join, joinNode, targets, scope, ipdom, ctx, refInto, fork, source) {
+    const atMerge = joinNode.type === T.merge;
+    const name = atMerge ? join : forkName(source ?? fork?.id, ctx);
+    const arms = targets.map((t, i) => {
+        const segs = region(t, join, scope, ipdom, ctx, refInto);
+        // The arm hands the join a tail only when its walk ran up to the join; a
+        // path that already left (`.break()`, `.continue()`, a ref, an End, a
+        // Terminate) needs no ref — and gets none.
+        if (!atMerge && !endsPath(segs[segs.length - 1]))
+            segs.push(`.stepToRef(${tsLiteral(join)})`);
+        return armCb(`a${i}`, segs);
+    });
+    const seg = `.parallel(${tsLiteral(name)}, [\n${arms.map((a) => reindent(a, '  ')).join(',\n')},\n]${forkOptsArg(atMerge ? joinNode : undefined, fork)})`;
+    return { seg, next: atMerge ? continueOn(joinNode, 'output', ctx, refInto) : { cursor: join } };
+}
+/** Whether a chain segment ends its path, so nothing may follow it in the same list. */
+function endsPath(seg) {
+    return seg !== undefined && /^\.(stepToRef|break|continue|return|terminate)\(/.test(seg);
+}
+/**
+ * A name for a `.parallel(...)` that creates no merge node: `<source>Fork`,
+ * numbered when that is a node id, a declared input, variable or output, or a
+ * name already minted. No node carries it (the arms join on a plain step by
+ * ref), but it must still not collide with any of those: check reads a
+ * `$vars.<name>` of a parallel's name as a read of its merge, so a variable
+ * of that name would fail PARALLEL_HAS_NO_OUTPUT on recompile.
+ */
+function forkName(source, ctx) {
+    const base = `${source ?? 'parallel'}Fork`;
+    const globals = new Set(readFlowGlobals(ctx.flow.variables).map((g) => g.name ?? g.id));
+    const taken = (n) => ctx.graph.byId.has(n) || globals.has(n) || (ctx.forkNames?.has(n) ?? false);
+    let name = base;
+    for (let i = 2; taken(name); i++)
+        name = `${base}${i}`;
+    (ctx.forkNames ??= new Set()).add(name);
+    return name;
 }
 /** Re-indent every non-empty line of a (possibly multi-line) segment by `pad`. */
 function reindent(seg, pad) {
@@ -2506,21 +1793,50 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
             return segs;
         }
         if (node.type === T.merge) {
-            // A bare merge reached on the main path (its fork was not detected as a
-            // parallel). Skip it and continue from its output — best effort.
-            const next = continueOn(node, 'output', ctx, refInto);
-            if (next.brk || next.cont) {
-                segs.push(next.brk ? '.break()' : '.continue()');
+            // A merge node with several `output` edges is a FORK the designer drew
+            // (#1310): Studio Web's parallel split is a `core.logic.merge` with one
+            // incoming edge and one edge per arm, the arms rejoining at a second
+            // merge node (or at a plain step). `.parallel(join, arms, { fork })`
+            // recreates both nodes and every edge.
+            const outs = scopeSuccEdges(ctx.graph, node.id, scope).filter((e) => e.sourcePort === 'output');
+            const join = outs.length >= 2 ? ipdom.get(node.id) : undefined;
+            const joinNode = join !== undefined && join !== EXIT ? ctx.graph.byId.get(join) : undefined;
+            // As in `forkRegion`: a plain-step join may be the region's own `stop`.
+            if (join !== undefined && joinNode !== undefined && parallelJoinable(joinNode) && !(join === stop && joinNode.type === T.merge)) {
+                const targets = outs.map((e) => follow(ctx.graph, node.id, e.targetNodeId));
+                const fork = parallelSeg(join, joinNode, targets, scope, ipdom, ctx, refInto, node);
+                segs.push(fork.seg);
                 flagDropped(node, ctx, segs);
-                return segs;
+                if (fork.next.brk || fork.next.cont) {
+                    segs.push(fork.next.brk ? '.break()' : '.continue()');
+                    return segs;
+                }
+                cursor = fork.next.cursor;
+                continue;
+            }
+            // A merge node with one edge in and one out is a pass-through the
+            // designer left in place (a join whose arms were later removed). The
+            // layout names it, so it is kept: it falls through to the regular step
+            // path below and comes back as the raw node of its own definition
+            // (#1310). Skipping it dropped the node, and compile then refused the
+            // `.layout()` key. A bare merge with several edges in (a join whose fork
+            // was not detected) is still skipped — best effort.
+            const ins = ctx.graph.inEdges(node.id).filter((e) => scope.has(e.sourceNodeId));
+            if (outs.length !== 1 || ins.length !== 1) {
+                const next = continueOn(node, 'output', ctx, refInto);
+                if (next.brk || next.cont) {
+                    segs.push(next.brk ? '.break()' : '.continue()');
+                    flagDropped(node, ctx, segs);
+                    return segs;
+                }
+                cursor = next.cursor;
+                flagDropped(node, ctx, segs);
+                continue;
             }
-            cursor = next.cursor;
-            flagDropped(node, ctx, segs);
-            continue;
         }
         if (node.type === T.decision) {
             const r = ipdom.get(node.id) ?? stop;
-            const cond = emitBareExpr(String((node.inputs ?? {}).expression ?? ''), ctx.imp, ctx.inputNames);
+            const cond = emitBareExpr(conditionText((node.inputs ?? {}).expression), ctx.imp, ctx.inputNames);
             const thenSegs = forkRegion(portEdges(ctx.graph, node.id, 'true'), r, scope, ipdom, ctx, refInto);
             const elseSegs = forkRegion(portEdges(ctx.graph, node.id, 'false'), r, scope, ipdom, ctx, refInto);
             const labels = armLabels(node);
@@ -2603,7 +1919,14 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
         }
         if (node.type === T.subflow) {
             segs.push(`.step(${tsLiteral(node.id)}, ${emitSubflow(node, ctx)}${optsArg(node, ctx)})`);
-            cursor = follow(ctx.graph, node.id, scopeSucc(ctx.graph, node.id, scope)[0]);
+            // A subflow step guards its body like any step: `core.subflow` declares
+            // the `error` handle, and `.onError()` after the step authors it. Without
+            // this the handler's edge had no spelling and a recompile dropped it.
+            const subflowSucc = scopeSucc(ctx.graph, node.id, scope);
+            const subflowHandler = errorHandlerSeg(node.id, subflowSucc, scope, ipdom, ctx);
+            if (subflowHandler)
+                segs.push(subflowHandler);
+            cursor = follow(ctx.graph, node.id, subflowSucc[0]);
             if (cursor === undefined)
                 accountImplicitTail(node, ctx, refInto);
             flagDropped(node, ctx, segs);
@@ -2719,11 +2042,13 @@ function region(cursor, stop, scope, ipdom, ctx, refInto) {
             flagDropped(node, ctx, segs);
             continue;
         }
-        // Parallel: the fork's ipdom is the merge join; each successor is one arm.
+        // Parallel: the fork's ipdom is the join — the merge node of a `.parallel`,
+        // or a plain step several steps feed (#1310); each successor is one arm.
         const join = ipdom.get(node.id);
         const joinNode = join !== undefined ? ctx.graph.byId.get(join) : undefined;
-        if (join && join !== EXIT && joinNode?.type === T.merge) {
-            const fork = parallelSeg(join, joinNode, succ.map((t) => follow(ctx.graph, node.id, t)), scope, ipdom, ctx, refInto);
+        // A plain-step join may be the region's own `stop`: the arms end in refs to it and the walk ends there.
+        if (join && join !== EXIT && joinNode && parallelJoinable(joinNode)) {
+            const fork = parallelSeg(join, joinNode, succ.map((t) => follow(ctx.graph, node.id, t)), scope, ipdom, ctx, refInto, undefined, node.id);
             segs.push(fork.seg);
             flagDropped(node, ctx, segs);
             if (fork.next.brk || fork.next.cont) {
@@ -2963,7 +2288,7 @@ function emitSwitch(node, ipdom, scope, ctx, stop, refInto) {
     // First pass: is every case one shared `<disc> === <literal>`? If not, every
     // case is emitted as `when:` with its expression as written.
     const parsed = cases.map((c) => {
-        const p = parseSwitchCase(String(c.expression ?? ''));
+        const p = parseSwitchCase(conditionText(c.expression));
         if (p) {
             if (disc === undefined)
                 disc = p.lhs;
@@ -2985,13 +2310,13 @@ function emitSwitch(node, ipdom, scope, ctx, stop, refInto) {
         // edges leave from the ORIGINAL node's handles, which merge keeps (#1130).
         const idPart = typeof c.id === 'string' && c.id !== '' && c.id !== `case_${caseIndex}` ? `, id: ${tsLiteral(c.id)}` : '';
         const head = nonUniform || !p
-            ? `when: ${emitBareExpr(String(c.expression ?? ''), ctx.imp, ctx.inputNames)}`
+            ? `when: ${emitBareExpr(conditionText(c.expression), ctx.imp, ctx.inputNames)}`
             : `value: ${p.value}`;
         return `{ ${head}${labelPart}${idPart}, body: ${armCb('b', armSegs)} }`;
     });
     // A case with no condition has no `when:` that compiles: emitting `js\`\``
     // would fail at compile ([EXPR_SYNTAX]) with no warning here.
-    const empty = cases.filter((c) => String(c.expression ?? '').trim() === '');
+    const empty = cases.filter((c) => conditionText(c.expression) === '');
     if (empty.length > 0) {
         const listing = empty.map((c) => tsLiteral(c.label ?? c.id)).join(', ');
         const message = `switch ${tsLiteral(node.id)} has a case with no condition (${listing}). `
@@ -3084,13 +2409,24 @@ function layoutSeg(flow, nodes, edges) {
     // compile refuses the whole `.layout()`. So its entry, and any edge route that
     // ends at it, is left out and compile places the node itself.
     const renamed = (id) => runAbsorbed.has(id) && runAbsorbed.get(id) !== id;
+    // A resource attached to a node whose spec cannot carry it (a tool on a voice
+    // agent) is reached only over artifact edges, and no spec folded it in: the
+    // source has no spelling for it, so the recompiled flow has no such node, and
+    // a layout entry for it would make compile refuse the whole `.layout()`.
+    const incoming = new Map();
+    for (const e of edges)
+        (incoming.get(e.targetNodeId) ?? incoming.set(e.targetNodeId, []).get(e.targetNodeId)).push(e);
+    const unspelled = (id) => {
+        const ins = incoming.get(id) ?? [];
+        return ins.length > 0 && !runAbsorbed.has(id) && ins.every((e) => ARTIFACT_PORTS.has(e.sourcePort));
+    };
     const nodeEntries = [];
     for (const n of nodes) {
         // A sticky note carries its own geometry in `.stickyNotes()`; a layout entry
         // for it would be a second, competing source for the same coordinates.
         if (n.type === STICKY_NOTE_TYPE)
             continue;
-        if (renamed(n.id))
+        if (renamed(n.id) || unspelled(n.id))
             continue;
         const ui = { ...(n.ui ?? {}), ...(hoisted[n.id] ?? {}) };
         const pos = ui.position;
@@ -3128,7 +2464,7 @@ function layoutSeg(flow, nodes, edges) {
         }
         if (!parts.length)
             continue;
-        if (renamed(e.sourceNodeId) || renamed(e.targetNodeId))
+        if (renamed(e.sourceNodeId) || renamed(e.targetNodeId) || unspelled(e.targetNodeId))
             continue;
         const pair = `${e.sourceNodeId}->${e.targetNodeId}`;
         if ((pairCount.get(pair) ?? 0) !== 1)
@@ -3153,7 +2489,10 @@ function layoutSeg(flow, nodes, edges) {
  */
 function emitSubflow(node, ctx) {
     const child = ctx.flow.subflows?.[node.id];
-    const inputsSrc = emitValMap(node.inputs, ctx.imp, ctx.inputNames) || '{}';
+    // `errorHandlingEnabled` is the flag serialize sets for `.onError()`, not a
+    // child input; `.onError(...)` after the step puts it back.
+    const { errorHandlingEnabled: _handled, ...inputs } = (node.inputs ?? {});
+    const inputsSrc = emitValMap(inputs, ctx.imp, ctx.inputNames) || '{}';
     if (!child) {
         if (ctx.o.bestEffort === false)
             throw new Error(`decompile: subflow "${node.id}" has no body in subflows[].`);
@@ -3169,7 +2508,52 @@ function emitSubflow(node, ctx) {
  * own scope; the child's trigger is its `<caller>Start` node, written as
  * `.trigger(manual(), { label })` only when its label is not `SUBFLOW_START_LABEL`.
  */
-function emitChildFlow(name, child, ctx) {
+function emitChildFlow(name, childFile, ctx) {
+    // Body: the child's trigger is its own manual Start; walk from its successor.
+    const trigger = (childFile.nodes ?? []).find((n) => isTrigger(n.type) && !(childFile.edges ?? []).some((e) => e.targetNodeId === n.id));
+    // The child's nodes read its inputs through that Start (`$vars.<caller>Start.
+    // output.<input>`); read it back as `start`, the one name both `input()` and
+    // check know a child's trigger by (#1313). Not when a child node is itself
+    // named `start`: the rename would then point the reads at that node.
+    const readAsStart = trigger !== undefined && trigger.id !== DEFAULT_TRIGGER_ID
+        && !(childFile.nodes ?? []).some((n) => n.id === DEFAULT_TRIGGER_ID);
+    const child = readAsStart ? readChildStartAsStart(childFile, trigger.id) : childFile;
+    const outerTriggerId = currentTriggerId;
+    currentTriggerId = readAsStart ? DEFAULT_TRIGGER_ID : (trigger?.id ?? DEFAULT_TRIGGER_ID);
+    try {
+        return emitChildFlowIn(name, child, trigger, ctx);
+    }
+    finally {
+        currentTriggerId = outerTriggerId;
+    }
+}
+/**
+ * A child flow's reads of its own Start node, `$vars.<caller>Start…`, read as
+ * `$vars.start…`. serialize names a child's trigger `<caller>Start` and renames
+ * `start` to it in the child scope, so `input('x')` — which lowers to
+ * `$vars.start.output.x` — reaches it; this is the inverse. Rewritten in code
+ * spans (`renameVarRoot`: `=js:` values, bare `$vars.` paths, the raw-JS
+ * fields) and in the BINDING slots that hold a variable path instead of an
+ * expression: a form row's `binding` (`vars.<caller>Start.output.x`), an agent
+ * input's `binding`, and an action app's `appInputBindings` (`=vars.…`). Only
+ * those: a literal string elsewhere that happens to read `vars.<caller>Start…`
+ * (a variable's default, a label) is data and stays as written.
+ */
+function readChildStartAsStart(child, startId) {
+    const renamed = renameVarRoot(child, startId, DEFAULT_TRIGGER_ID);
+    const path = new RegExp(`^(=?vars\\.)${startId.replace(/[$]/g, '\\$&')}(?![A-Za-z0-9_$])`);
+    const walk = (x, key, parentKey) => {
+        if (typeof x === 'string')
+            return key === 'binding' || parentKey === 'appInputBindings' ? x.replace(path, `$1${DEFAULT_TRIGGER_ID}`) : x;
+        if (Array.isArray(x))
+            return x.map((y) => walk(y, key, parentKey));
+        if (x && typeof x === 'object')
+            return Object.fromEntries(Object.entries(x).map(([k, y]) => [k, walk(y, k, key)]));
+        return x;
+    };
+    return walk(renamed);
+}
+function emitChildFlowIn(name, child, trigger, ctx) {
     const globals = readFlowGlobals(child.variables, runStrict);
     const childCtx = {
         graph: new Graph(child.nodes ?? [], child.edges ?? []),
@@ -3193,8 +2577,6 @@ function emitChildFlow(name, child, ctx) {
         const def = g.defaultValue !== undefined ? `, ${tsLiteral(g.defaultValue)}` : '';
         parts.push(`.var(${tsLiteral(g.name ?? g.id)}, ${declExpr(g, false, ctx.imp)}${def})`);
     }
-    // Body: the child's trigger is its own manual Start; walk from its successor.
-    const trigger = (child.nodes ?? []).find((n) => isTrigger(n.type) && !(child.edges ?? []).some((e) => e.targetNodeId === n.id));
     if (trigger?.type === T.triggerManual && hasRenamedLabel(trigger, SUBFLOW_START_LABEL)) {
         parts.push(`.trigger(${ctx.imp.use('manual')}(), { ${triggerOptParts(trigger, SUBFLOW_START_LABEL).join(', ')} })`);
     }