@uipath/maestro-builder-sdk 6.16.6 → 6.16.7

package/dist/bpmn/bpmn-expr-check.d.ts

@@ -22,7 +22,7 @@
  * Variables are SCOPED: a sub-process sees the enclosing variables plus its own.
  */
 import { type ExprDiagnostic } from '../core/expr-check.js';
-import { type BuiltBpmn } from './bpmn-sdk.js';
+import type { BuiltBpmn } from './bpmn-sdk.js';
 /** A diagnostic plus the element it was found in. */
 export interface BpmnLocatedDiagnostic extends ExprDiagnostic {
     where: string;

package/dist/bpmn/bpmn-expr-check.js

@@ -22,7 +22,7 @@
  * Variables are SCOPED: a sub-process sees the enclosing variables plus its own.
  */
 import { checkExpression } from '../core/expr-check.js';
-import { nodeDeclaredVars } from './bpmn-sdk.js';
+import { nodeDeclaredVars } from './declared-vars.js';
 const NOUN = 'variable';
 const NAMESPACE = 'vars';
 const BINDING_NOUN = 'binding';

package/dist/bpmn/bpmn-sdk.d.ts

@@ -27,6 +27,7 @@ import { type DataServiceOperation } from './data-service.js';
 export type { DataServiceOperation } from './data-service.js';
 export { BpmnBuildError } from './bpmn-expr-check.js';
 export type { BpmnLocatedDiagnostic } from './bpmn-expr-check.js';
+export { connectorOutputVars, nodeDeclaredVars, typedNodeDeclaredVars } from './declared-vars.js';
 /** ISO-8601 timer specification (one of duration / date / cycle). */
 export interface TimerSpec {
     /** Fire after this ISO-8601 duration, e.g. `'PT30S'`. */
@@ -3135,58 +3136,6 @@ export type BpmnConnectorOpts = ConnectorOpts & ActivityOpts & {
      */
     outputVar?: string;
 };
-/**
- * The variables a connector task's output rows land in.
- *
- * Per-node by default, because a `uipath:output`'s `var` IS the variable
- * declaration as far as the platform is concerned (its canvas model maps every
- * node output to a variable keyed by `var`). A shared name would therefore mean
- * two connectors writing one variable, with the second silently clobbering the
- * first — and it is the reason both the serializer and the expression check need
- * the same answer, hence one function.
- *
- * @param n - The connector node.
- * @returns The response and error variable names.
- *
- * @internal
- */
-export declare function connectorOutputVars(n: Extract<BpmnNode, {
-    kind: 'connector';
-}>): {
-    response: string;
-    error: string;
-};
-/**
- * The variables a typed node writes — the ONE definition of that set.
- *
- * It had grown three: this one (what an expression may read), `implicitNodeVars` in
- * serialize (what gets declared in `uipath:variables`), and `derivedVariableIds` in
- * decompile (what a decompiled file must NOT re-declare). All three must agree, and
- * adding `outputRows` proved they do not stay agreed on their own: two were updated,
- * this one was missed, and a human task's mapped output stopped being visible to the
- * expression checker — `vars.decision` reported undeclared for a variable the node
- * plainly writes. So serialize now calls this instead of repeating it, and only
- * decompile's copy is separate, which its own comment already flags as load-bearing.
- *
- * @param n - The typed node.
- * @returns The variable ids its output rows write.
- * @internal
- */
-export declare function typedNodeDeclaredVars(n: Extract<BpmnNode, {
-    kind: 'typed';
-}>): string[];
-/**
- * Every variable name a node DECLARES by writing to it — the platform counts a
- * node's output `var` as a declaration, so a downstream `=vars.<name>` resolves
- * against it without any `uipath:variables` entry. The expression check mirrors
- * that, or it would reject reads the platform accepts.
- *
- * @param n - The node to inspect.
- * @returns The variable names it declares, if any.
- *
- * @internal
- */
-export declare function nodeDeclaredVars(n: BpmnNode): string[];
 /** A sub-process body: the same graph methods, plus an internal node builder. */
 export declare class SubProcessBuilder extends ScopeBuilder {
     /**

package/dist/bpmn/bpmn-sdk.js

@@ -2,9 +2,11 @@ import { connector as makeConnector } from '../core/actions.js';
 import { checkBpmnExpressions, BpmnBuildError } from './bpmn-expr-check.js';
 import { BPMN_SCHEMA_VERSIONS } from './format-profile.js';
 import { schemaVersionRefusal } from '../schema-version.js';
-import { bindingRequiredFields, REGISTRY_GAPS, registryType, typedNodeOutputVar } from './typed-node.js';
+import { bindingRequiredFields, REGISTRY_GAPS, registryType } from './typed-node.js';
 import { DATA_SERVICE_ACTIVITY_TYPE, DATA_SERVICE_CONNECTOR_KEY, dataServiceWire } from './data-service.js';
 export { BpmnBuildError } from './bpmn-expr-check.js';
+// @internal helpers kept on the published /bpmn subpath; SDK code imports declared-vars.js.
+export { connectorOutputVars, nodeDeclaredVars, typedNodeDeclaredVars } from './declared-vars.js';
 function normTimer(t) {
     return typeof t === 'string' ? { duration: t } : t;
 }
@@ -2264,47 +2266,6 @@ class ScopeBuilder {
         return this;
     }
 }
-/**
- * The variables a connector task's output rows land in.
- *
- * Per-node by default, because a `uipath:output`'s `var` IS the variable
- * declaration as far as the platform is concerned (its canvas model maps every
- * node output to a variable keyed by `var`). A shared name would therefore mean
- * two connectors writing one variable, with the second silently clobbering the
- * first — and it is the reason both the serializer and the expression check need
- * the same answer, hence one function.
- *
- * @param n - The connector node.
- * @returns The response and error variable names.
- *
- * @internal
- */
-export function connectorOutputVars(n) {
-    return { response: n.outputVar ?? `${n.id}_response`, error: `${n.id}_Error` };
-}
-/**
- * The variables a typed node writes — the ONE definition of that set.
- *
- * It had grown three: this one (what an expression may read), `implicitNodeVars` in
- * serialize (what gets declared in `uipath:variables`), and `derivedVariableIds` in
- * decompile (what a decompiled file must NOT re-declare). All three must agree, and
- * adding `outputRows` proved they do not stay agreed on their own: two were updated,
- * this one was missed, and a human task's mapped output stopped being visible to the
- * expression checker — `vars.decision` reported undeclared for a variable the node
- * plainly writes. So serialize now calls this instead of repeating it, and only
- * decompile's copy is separate, which its own comment already flags as load-bearing.
- *
- * @param n - The typed node.
- * @returns The variable ids its output rows write.
- * @internal
- */
-export function typedNodeDeclaredVars(n) {
-    // Spelled-out rows REPLACE the derived pair, so they are the whole answer.
-    if (n.outputRows)
-        return n.outputRows.map((r) => r.var).filter((v) => v !== undefined);
-    const v = typedNodeOutputVar(n.id, n.type, n.outputVar, n.spec);
-    return [...(v ? [v] : []), ...Object.keys(n.outputs ?? {})];
-}
 /**
  * Fill in `activity` on a connector task from the `operation` beside it.
  *
@@ -2348,30 +2309,6 @@ function defaultActivityIdentityRows(type, context, rows) {
         return rows;
     return [...rows, { name: 'activity', type: 'string', value: operation }];
 }
-/**
- * Every variable name a node DECLARES by writing to it — the platform counts a
- * node's output `var` as a declaration, so a downstream `=vars.<name>` resolves
- * against it without any `uipath:variables` entry. The expression check mirrors
- * that, or it would reject reads the platform accepts.
- *
- * @param n - The node to inspect.
- * @returns The variable names it declares, if any.
- *
- * @internal
- */
-export function nodeDeclaredVars(n) {
-    if (n.kind === 'connector') {
-        const { response, error } = connectorOutputVars(n);
-        return [response, error];
-    }
-    if (n.kind === 'typed')
-        return typedNodeDeclaredVars(n);
-    if (n.kind === 'scriptTask')
-        return Object.keys(n.outputs);
-    if (n.kind === 'task')
-        return Object.keys(n.set);
-    return [];
-}
 /** A sub-process body: the same graph methods, plus an internal node builder. */
 export class SubProcessBuilder extends ScopeBuilder {
     /**

package/dist/bpmn/check.d.ts

@@ -15,7 +15,7 @@
  * implicit join — the diagnostic is a `warning`, and its comment says which
  * platform rule it corresponds to and how the two differ.
  */
-import { type BuiltBpmn } from './bpmn-sdk.js';
+import type { BuiltBpmn } from './bpmn-sdk.js';
 import { type ConnectorCheckOpts } from '../core/connector-checks.js';
 import { type EventCheckOpts } from '../core/event-checks.js';
 export interface Diagnostic {

package/dist/bpmn/check.js

@@ -1,21 +1,4 @@
-/**
- * bpmn/check — fast static validation of a BuiltBpmn before serialization.
- *
- * Surfaces the common Maestro canvas-rule failures early (dangling flow refs,
- * duplicate ids, a gateway branch with no condition, a superfluous gateway, an
- * implicit join, a missing start event, a boundary event attached to nothing, an
- * empty timer) so authoring gets instant feedback. The authoritative gate is
- * still `uip maestro bpmn validate` (`validateBpmnCanvas`) on the emitted
- * `.bpmn`.
- *
- * **An `error` here must mirror a real platform rule.** Being stricter than
- * `validate` is worse than being looser: it refuses processes that deploy and run
- * correctly, and the author has no way to appeal. Where this file is deliberately
- * stricter than the platform — an unconditioned inclusive-gateway branch, an
- * implicit join — the diagnostic is a `warning`, and its comment says which
- * platform rule it corresponds to and how the two differ.
- */
-import { nodeDeclaredVars } from './bpmn-sdk.js';
+import { nodeDeclaredVars } from './declared-vars.js';
 import { allNodes, folderCompanionKeys, implicitNodeVars, processId } from './serialize.js';
 import { KNOWN_METHOD_SET } from './known-methods.js';
 import { EQUALS_EXPR_DIALECT, checkConnectorContract, checkConnectorLookups, checkConnectorSchema, checkBindingLabels, } from '../core/connector-checks.js';

package/dist/bpmn/connector.d.ts

@@ -20,7 +20,7 @@
  */
 import type BpmnModdle from 'bpmn-moddle';
 import type { ModdleElement } from 'bpmn-moddle';
-import { type BpmnNode } from './bpmn-sdk.js';
+import type { BpmnNode } from './bpmn-sdk.js';
 import type { Library } from '../core/library.js';
 import type { Bindings } from '../core/bindings.js';
 type El = ModdleElement;

package/dist/bpmn/connector.js

@@ -1,4 +1,4 @@
-import { connectorOutputVars } from './bpmn-sdk.js';
+import { connectorOutputVars } from './declared-vars.js';
 import { EQUALS_EXPR_DIALECT } from '../core/connector-checks.js';
 import { buildConnectorInputs, nestConnectorBody, transportHttpMethod } from '../core/connector-inputs.js';
 export function createConnectorTask(ctx, n) {

package/dist/bpmn/declared-vars.d.ts

@@ -0,0 +1,60 @@
+/**
+ * bpmn/declared-vars — which variables a BPMN node declares by writing to them.
+ *
+ * The builder, the expression check and the serializer all need the one answer.
+ * It lives outside `bpmn-sdk.ts` so the checker does not import the builder back
+ * (the runtime import cycle FB003 reported).
+ */
+import type { BpmnNode } from './bpmn-sdk.js';
+/**
+ * The variables a connector task's output rows land in.
+ *
+ * Per-node by default, because a `uipath:output`'s `var` IS the variable
+ * declaration as far as the platform is concerned (its canvas model maps every
+ * node output to a variable keyed by `var`). A shared name would therefore mean
+ * two connectors writing one variable, with the second silently clobbering the
+ * first — and it is the reason both the serializer and the expression check need
+ * the same answer, hence one function.
+ *
+ * @param n - The connector node.
+ * @returns The response and error variable names.
+ *
+ * @internal
+ */
+export declare function connectorOutputVars(n: Extract<BpmnNode, {
+    kind: 'connector';
+}>): {
+    response: string;
+    error: string;
+};
+/**
+ * The variables a typed node writes — the ONE definition of that set.
+ *
+ * It had grown three: this one (what an expression may read), `implicitNodeVars` in
+ * serialize (what gets declared in `uipath:variables`), and `derivedVariableIds` in
+ * decompile (what a decompiled file must NOT re-declare). All three must agree, and
+ * adding `outputRows` proved they do not stay agreed on their own: two were updated,
+ * this one was missed, and a human task's mapped output stopped being visible to the
+ * expression checker — `vars.decision` reported undeclared for a variable the node
+ * plainly writes. So serialize now calls this instead of repeating it, and only
+ * decompile's copy is separate, which its own comment already flags as load-bearing.
+ *
+ * @param n - The typed node.
+ * @returns The variable ids its output rows write.
+ * @internal
+ */
+export declare function typedNodeDeclaredVars(n: Extract<BpmnNode, {
+    kind: 'typed';
+}>): string[];
+/**
+ * Every variable name a node DECLARES by writing to it — the platform counts a
+ * node's output `var` as a declaration, so a downstream `=vars.<name>` resolves
+ * against it without any `uipath:variables` entry. The expression check mirrors
+ * that, or it would reject reads the platform accepts.
+ *
+ * @param n - The node to inspect.
+ * @returns The variable names it declares, if any.
+ *
+ * @internal
+ */
+export declare function nodeDeclaredVars(n: BpmnNode): string[];

package/dist/bpmn/declared-vars.js

@@ -0,0 +1,66 @@
+import { typedNodeOutputVar } from './typed-node.js';
+/**
+ * The variables a connector task's output rows land in.
+ *
+ * Per-node by default, because a `uipath:output`'s `var` IS the variable
+ * declaration as far as the platform is concerned (its canvas model maps every
+ * node output to a variable keyed by `var`). A shared name would therefore mean
+ * two connectors writing one variable, with the second silently clobbering the
+ * first — and it is the reason both the serializer and the expression check need
+ * the same answer, hence one function.
+ *
+ * @param n - The connector node.
+ * @returns The response and error variable names.
+ *
+ * @internal
+ */
+export function connectorOutputVars(n) {
+    return { response: n.outputVar ?? `${n.id}_response`, error: `${n.id}_Error` };
+}
+/**
+ * The variables a typed node writes — the ONE definition of that set.
+ *
+ * It had grown three: this one (what an expression may read), `implicitNodeVars` in
+ * serialize (what gets declared in `uipath:variables`), and `derivedVariableIds` in
+ * decompile (what a decompiled file must NOT re-declare). All three must agree, and
+ * adding `outputRows` proved they do not stay agreed on their own: two were updated,
+ * this one was missed, and a human task's mapped output stopped being visible to the
+ * expression checker — `vars.decision` reported undeclared for a variable the node
+ * plainly writes. So serialize now calls this instead of repeating it, and only
+ * decompile's copy is separate, which its own comment already flags as load-bearing.
+ *
+ * @param n - The typed node.
+ * @returns The variable ids its output rows write.
+ * @internal
+ */
+export function typedNodeDeclaredVars(n) {
+    // Spelled-out rows REPLACE the derived pair, so they are the whole answer.
+    if (n.outputRows)
+        return n.outputRows.map((r) => r.var).filter((v) => v !== undefined);
+    const v = typedNodeOutputVar(n.id, n.type, n.outputVar, n.spec);
+    return [...(v ? [v] : []), ...Object.keys(n.outputs ?? {})];
+}
+/**
+ * Every variable name a node DECLARES by writing to it — the platform counts a
+ * node's output `var` as a declaration, so a downstream `=vars.<name>` resolves
+ * against it without any `uipath:variables` entry. The expression check mirrors
+ * that, or it would reject reads the platform accepts.
+ *
+ * @param n - The node to inspect.
+ * @returns The variable names it declares, if any.
+ *
+ * @internal
+ */
+export function nodeDeclaredVars(n) {
+    if (n.kind === 'connector') {
+        const { response, error } = connectorOutputVars(n);
+        return [response, error];
+    }
+    if (n.kind === 'typed')
+        return typedNodeDeclaredVars(n);
+    if (n.kind === 'scriptTask')
+        return Object.keys(n.outputs);
+    if (n.kind === 'task')
+        return Object.keys(n.set);
+    return [];
+}

package/dist/bpmn/serialize.js

@@ -15,11 +15,10 @@
  */
 import BpmnModdle from 'bpmn-moddle';
 import { createRequire } from 'node:module';
-import { connectorOutputVars, } from './bpmn-sdk.js';
 import { createConnectorTask } from './connector.js';
 import { createConnectorEvent, createExternalTask, intsvcOutputVar } from './intsvc.js';
 import { createExtensionPayload, createTypedNode, rowDeclaration, typedNodeOutputVar, verbatimOutputRows } from './typed-node.js';
-import { typedNodeDeclaredVars } from './bpmn-sdk.js';
+import { connectorOutputVars, typedNodeDeclaredVars } from './declared-vars.js';
 const require = createRequire(import.meta.url);
 const uipathDescriptor = require('./uipath-moddle.v1.json');
 const NS = {

package/dist/case/decompile-cli.js

@@ -17,7 +17,7 @@
  */
 import { reportResult } from '../cli-result.js';
 import { mkdirSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
-import { resolveLibraryDir } from '../registry/cache.js';
+import { resolveLibraryDir } from '../core/library-cache.js';
 import { basename, join, resolve } from 'node:path';
 import { defaultSourceOut, workDirBeside, writeSource } from '../workdir.js';
 import { flagValue, runWhenInvokedDirectly } from '../cli-run.js';

package/dist/check.js

@@ -14,7 +14,8 @@ import { prepareCommand } from './core/cli-spelling.js';
 import { editDistance } from './core/edit-distance.js';
 import { isAnswerField } from './core/hitl-answers.js';
 import { hitlDerivesOutcomeHandles, hitlExitModel, hitlRoutesPerOutcome } from './core/hitl-routing.js';
-import { childStepLists, declaredExits, hasExits, stopsAtEnd } from './core/step-ports.js';
+import { declaredExits, hasExits } from './core/step-ports.js';
+import { childStepLists, stopsAtEnd } from './flow-step-tree.js';
 import { FLOW_SCHEMA_VERSIONS } from './format-profile.js';
 import { compareSchemaVersions, schemaVersionRefusal } from './schema-version.js';
 import { planFlowGlobals, planSharedInputs, sharedInputRoots } from './flow-variables.js';

package/dist/core/cli-library.js

@@ -17,7 +17,7 @@
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { Library } from './library.js';
-import { resolveLibraryDir } from '../registry/cache.js';
+import { resolveLibraryDir } from './library-cache.js';
 import { flagValue } from '../cli-run.js';
 import { defaultOverlayDir } from '../workdir.js';
 import { EQUALS_EXPR_DIALECT } from './connector-checks.js';

package/dist/core/step-ports.d.ts

@@ -1,4 +1,3 @@
-import type { Step } from '../flow-sdk.js';
 /** One author-named exit: the value an arm matches on, and the port it wires. */
 export interface DeclaredExit {
     /** What `.stepSwitch()`'s arm `value` matches — the outcome or branch NAME. */
@@ -35,23 +34,4 @@ type SpecLike = {
 export declare function declaredExits(spec: SpecLike | undefined, pinnedVersion?: string): DeclaredExit[] | NoExits;
 /** Narrowing helper — `declaredExits` returns one or the other. */
 export declare function hasExits(r: DeclaredExit[] | NoExits): r is DeclaredExit[];
-/**
- * Whether a step list that hands on no tail got there by reaching an End — a
- * `.return()`, on some path — rather than by stopping the whole run
- * (`.terminate`) or leaving a loop (`.break`). Only the first leaves a sibling
- * `.parallel` join waiting: a terminate ends the run, join included.
- */
-export declare function stopsAtEnd(steps: readonly Step[]): boolean;
-/**
- * The step lists nested DIRECTLY inside `step` — the bodies a walk over this
- * flow's own tree must descend into. Exhaustive over `Step['kind']`, so a new
- * container kind fails to compile here instead of being silently skipped by
- * every walker. That is how `check`'s return scan came to miss `.stepSwitch`
- * arms and `.stepToList` / `.onError` bodies, and warned NO_RETURN on flows
- * whose every path ends in `.return()` (UV-16855).
- *
- * A subflow's child flow is deliberately NOT a child here: it is another
- * flow's tree, and its returns say nothing about whether THIS flow ends.
- */
-export declare function childStepLists(step: Step): readonly Step[][];
 export {};

package/dist/core/step-ports.js

@@ -94,53 +94,3 @@ export function declaredExits(spec, pinnedVersion) {
 export function hasExits(r) {
     return Array.isArray(r);
 }
-/**
- * Whether a step list that hands on no tail got there by reaching an End — a
- * `.return()`, on some path — rather than by stopping the whole run
- * (`.terminate`) or leaving a loop (`.break`). Only the first leaves a sibling
- * `.parallel` join waiting: a terminate ends the run, join included.
- */
-export function stopsAtEnd(steps) {
-    const has = (list, kinds) => list.some((st) => kinds.has(st.kind)
-        || (st.kind === 'branch' && (has(st.then, kinds) || has(st.otherwise, kinds)))
-        || ((st.kind === 'switch' || st.kind === 'stepSwitch') && st.cases.some((c) => has(c.body, kinds)))
-        || (st.kind === 'switch' && st.default !== undefined && has(st.default, kinds)));
-    return has(steps, new Set(['return'])) && !has(steps, new Set(['terminate', 'break']));
-}
-/**
- * The step lists nested DIRECTLY inside `step` — the bodies a walk over this
- * flow's own tree must descend into. Exhaustive over `Step['kind']`, so a new
- * container kind fails to compile here instead of being silently skipped by
- * every walker. That is how `check`'s return scan came to miss `.stepSwitch`
- * arms and `.stepToList` / `.onError` bodies, and warned NO_RETURN on flows
- * whose every path ends in `.return()` (UV-16855).
- *
- * A subflow's child flow is deliberately NOT a child here: it is another
- * flow's tree, and its returns say nothing about whether THIS flow ends.
- */
-export function childStepLists(step) {
-    switch (step.kind) {
-        case 'branch':
-            return [step.then, step.otherwise];
-        case 'switch':
-            return [...step.cases.map((c) => c.body), ...(step.default ? [step.default] : [])];
-        case 'stepSwitch':
-            return step.cases.map((c) => c.body);
-        case 'loop':
-        case 'doWhile':
-        case 'stepToList':
-            return [step.body];
-        case 'parallel':
-            return step.arms;
-        case 'action':
-        case 'break':
-        case 'terminate':
-        case 'stepToRef':
-        case 'return':
-            return [];
-        default: {
-            const unhandled = step;
-            throw new Error(`childStepLists: unhandled step kind ${JSON.stringify(unhandled.kind)}`);
-        }
-    }
-}

package/dist/emit.js

@@ -30,7 +30,7 @@ import { dirname, join } from 'node:path';
 import { serialize } from './serialize.js';
 import { Library } from './library.js';
 import { Bindings } from './bindings.js';
-import { resolveLibraryDir } from './registry/cache.js';
+import { resolveLibraryDir } from './core/library-cache.js';
 import { defaultBindingsFile } from './workdir.js';
 /**
  * Resolve the connector library the same way `compile-cli` does: only load it

package/dist/flow-step-tree.d.ts

@@ -0,0 +1,25 @@
+/**
+ * flow-step-tree — walkers over a Flow's `Step` tree. They are typed by Flow's
+ * `Step` union (`childStepLists` is exhaustive over `Step['kind']`), so they are
+ * Flow code; the family-neutral exit table stays in `core/step-ports.ts`.
+ */
+import type { Step } from './flow-sdk.js';
+/**
+ * Whether a step list that hands on no tail got there by reaching an End — a
+ * `.return()`, on some path — rather than by stopping the whole run
+ * (`.terminate`) or leaving a loop (`.break`). Only the first leaves a sibling
+ * `.parallel` join waiting: a terminate ends the run, join included.
+ */
+export declare function stopsAtEnd(steps: readonly Step[]): boolean;
+/**
+ * The step lists nested DIRECTLY inside `step` — the bodies a walk over this
+ * flow's own tree must descend into. Exhaustive over `Step['kind']`, so a new
+ * container kind fails to compile here instead of being silently skipped by
+ * every walker. That is how `check`'s return scan came to miss `.stepSwitch`
+ * arms and `.stepToList` / `.onError` bodies, and warned NO_RETURN on flows
+ * whose every path ends in `.return()` (UV-16855).
+ *
+ * A subflow's child flow is deliberately NOT a child here: it is another
+ * flow's tree, and its returns say nothing about whether THIS flow ends.
+ */
+export declare function childStepLists(step: Step): readonly Step[][];

package/dist/flow-step-tree.js

@@ -0,0 +1,50 @@
+/**
+ * Whether a step list that hands on no tail got there by reaching an End — a
+ * `.return()`, on some path — rather than by stopping the whole run
+ * (`.terminate`) or leaving a loop (`.break`). Only the first leaves a sibling
+ * `.parallel` join waiting: a terminate ends the run, join included.
+ */
+export function stopsAtEnd(steps) {
+    const has = (list, kinds) => list.some((st) => kinds.has(st.kind)
+        || (st.kind === 'branch' && (has(st.then, kinds) || has(st.otherwise, kinds)))
+        || ((st.kind === 'switch' || st.kind === 'stepSwitch') && st.cases.some((c) => has(c.body, kinds)))
+        || (st.kind === 'switch' && st.default !== undefined && has(st.default, kinds)));
+    return has(steps, new Set(['return'])) && !has(steps, new Set(['terminate', 'break']));
+}
+/**
+ * The step lists nested DIRECTLY inside `step` — the bodies a walk over this
+ * flow's own tree must descend into. Exhaustive over `Step['kind']`, so a new
+ * container kind fails to compile here instead of being silently skipped by
+ * every walker. That is how `check`'s return scan came to miss `.stepSwitch`
+ * arms and `.stepToList` / `.onError` bodies, and warned NO_RETURN on flows
+ * whose every path ends in `.return()` (UV-16855).
+ *
+ * A subflow's child flow is deliberately NOT a child here: it is another
+ * flow's tree, and its returns say nothing about whether THIS flow ends.
+ */
+export function childStepLists(step) {
+    switch (step.kind) {
+        case 'branch':
+            return [step.then, step.otherwise];
+        case 'switch':
+            return [...step.cases.map((c) => c.body), ...(step.default ? [step.default] : [])];
+        case 'stepSwitch':
+            return step.cases.map((c) => c.body);
+        case 'loop':
+        case 'doWhile':
+        case 'stepToList':
+            return [step.body];
+        case 'parallel':
+            return step.arms;
+        case 'action':
+        case 'break':
+        case 'terminate':
+        case 'stepToRef':
+        case 'return':
+            return [];
+        default: {
+            const unhandled = step;
+            throw new Error(`childStepLists: unhandled step kind ${JSON.stringify(unhandled.kind)}`);
+        }
+    }
+}

package/dist/registry/path-cli.js

@@ -1,6 +1,6 @@
 import { printResult, reportResult } from '../cli-result.js';
 import { join } from "node:path";
-import { CURRENT_LINK, PULL_COMMAND, currentEntrySha, libraryCacheRoot, resolveCachedLibrary, resolveCachedMarkdown, } from "./cache.js";
+import { CURRENT_LINK, PULL_COMMAND, currentEntrySha, libraryCacheRoot, resolveCachedLibrary, resolveCachedMarkdown, } from "../core/library-cache.js";
 /**
  * Say where the connector library is.
  *

package/dist/registry/pull-cli.js

@@ -2,7 +2,7 @@ import { reportResult } from '../cli-result.js';
 import { createHash } from "node:crypto";
 import { mkdir, readFile, rename, rm, stat, symlink, writeFile, } from "node:fs/promises";
 import { join, resolve } from "node:path";
-import { CURRENT_LINK, LIBRARY_JSON_DIR, LIBRARY_MARKDOWN_DIR, cacheEntry, libraryCacheRoot, referencedConnectorKeys, } from "./cache.js";
+import { CURRENT_LINK, LIBRARY_JSON_DIR, LIBRARY_MARKDOWN_DIR, cacheEntry, libraryCacheRoot, referencedConnectorKeys, } from "../core/library-cache.js";
 import { extractLibrary } from "./extractor.js";
 import { materializeRegistry } from "./materializer.js";
 import { curatedOverlayIdentity } from "./curated-overlay.js";

package/dist/registry/search-cli.js

@@ -1,6 +1,6 @@
 import { printResult, reportResult } from '../cli-result.js';
 import { readFile, stat } from "node:fs/promises";
-import { PULL_COMMAND, resolveLibraryDir } from "./cache.js";
+import { PULL_COMMAND, resolveLibraryDir } from "../core/library-cache.js";
 import { dirname, join } from "node:path";
 export const DEFAULT_SEARCH_LIMIT = 20;
 const USAGE = "Usage: flow-sdk registry search [query] [--library <dir>] [--library-md <dir>] [--connector <key>] [--limit <n>]";

package/dist/serialize.js

@@ -19,7 +19,8 @@ import { connectionConnectors } from './bindings-v2.js';
 import { BindingRefusal, GUID_RE, bindingMissingMessage, bindingSelfNameMessage, bindingUndeclaredMessage, missingBindingLabels, undeclaredBinding } from './core/binding-messages.js';
 import { ByoaRefusal, byoaUnverified } from './core/byoa.js';
 import { OUTCOME_HANDLE_NODE_TYPES, assertHitlExitInvariant, hitlExitModel, hitlExitViolation, outcomeSlug } from './core/hitl-routing.js';
-import { declaredExits, hasExits, stopsAtEnd } from './core/step-ports.js';
+import { declaredExits, hasExits } from './core/step-ports.js';
+import { stopsAtEnd } from './flow-step-tree.js';
 import { assertNodeEnvelope } from './core/node-envelope.js';
 import { buildConfiguration } from './config.js';
 import { stableId } from './core/stable-id.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.16.6",
+  "version": "6.16.7",
   "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": "36462ef66bdae191ba107334d402dddaed067b2e"
+  "gitref": "c769835ca295fd52b2f51584b3e21ef9bb226347"
 }