@uipath/flow-tool 1.200.0-preview.120 → 1.201.0-preview.121

package/dist/{packager-tool-wm273rrd.js → packager-tool-9x76z587.js}

@@ -1,9 +1,9 @@
 import {
   registerPackagerFactories
-} from "./packager-tool-231njxzf.js";
+} from "./packager-tool-neavt1k3.js";
 import {
   flowInitAsync
-} from "./packager-tool-25z1hdbm.js";
+} from "./packager-tool-1g6958de.js";
 import {
   ERROR_SOURCE_PORT,
   FlowEvalFileStore,
@@ -35,100 +35,104 @@ import {
   stageInlineAgentPackageFiles,
   writePackagingArtifacts,
   writePackagingArtifactsDetailed
-} from "./packager-tool-2q2qddqr.js";
+} from "./packager-tool-qfp49pq4.js";
 import {
   ensureProjectId
 } from "./packager-tool-7yjpwj92.js";
 import {
-  ATTACHMENT_INSTRUCTIONS,
-  ATTACHMENT_UPLOAD_INSTRUCTIONS,
-  ErrorDecision,
   FilterNotSupportedError,
-  JobsApi,
   MANAGED_HTTP_CONNECTOR_KEY,
-  MIN_INTERVAL_MS,
   MaestroHttpError,
-  OutputFormatter,
-  PackageFeedsApi,
-  PollOutcome,
-  ProcessesApi,
-  RESULTS,
-  ReleasesApi,
-  ScreenLogger,
   VALID_PACKAGE_NAME_REGEX,
-  addSdkUserAgentHeader,
   allDefinitions,
-  appendOption,
   applySavedFilterTree,
   assertActivityMetadataResolved,
   buildInputMetadata,
   buildManagedHttpEssentialConfiguration,
   buildSolutionPackageFromDir,
-  catchError,
-  createApiClient,
   createConfiguredActivityClient,
-  createHiddenDeprecatedTenantOption,
-  createOrchestratorConfig,
   createZipFromDir,
   debugPimsGet,
-  ensureToolModule,
-  extractErrorMessage,
-  extractErrorMessageSync,
   extractMultipartParameters,
   extractStartEventId,
   fetchConnectionInfo,
   fetchConnectorMetadata,
-  findNearestParentUipxFile,
   findProjectFlowFile,
-  findSolutionFile,
   formatTraceLine,
-  getAuthContext,
   getFolderInfoById,
-  getLoginStatusAsync,
   getPersonalFolderInfo,
   getPersonalFolderKey,
-  getSdkUserAgentToken,
   getStudioWebSolutionProjects,
   inlineMultipartFileValues,
-  installSdkUserAgentHeader,
-  instructionsFor,
-  isFailureStatus,
-  isProjectRegisteredInSolution,
   isSuccessfulDebugStatus,
-  isTerminalStatus,
-  logger,
-  mapPackageMetadataOptions,
-  msToDuration,
   nodeModuleRegistry,
   normalizeHttpMethod,
-  parseAttachmentSpec,
   parseJsonInputOrFile,
   patchConnectionOverwrites,
-  pollUntil,
   prepareForCustomDebug,
-  processContext,
   readFlowWorkflow,
-  readStdin,
-  readUipxFile,
-  registerPackageMetadataOptions,
   registerRegistryCommand,
   registerSharedDebugInstanceCommands,
   registerSharedIncidentCommands,
   registerSharedInstanceCommands,
   registerSharedProcessCommands,
   registerSharedProcessesCommands,
-  resolveAttachmentInputs,
-  resolveFolder,
   substituteFilterVariables,
-  updateSolutionFile,
   uploadAndDebugSolution,
-  uploadJobAttachment,
   uploadOrOverwriteSolution,
   writeFlowWorkflow
-} from "./packager-tool-95ht91a8.js";
+} from "./packager-tool-xa2xwzrq.js";
+import {
+  JobsApi,
+  PackageFeedsApi,
+  ProcessesApi,
+  ReleasesApi,
+  createApiClient,
+  createOrchestratorConfig,
+  findNearestParentUipxFile,
+  findSolutionFile,
+  getAuthContext,
+  getLoginStatusAsync,
+  isProjectRegisteredInSolution,
+  readUipxFile,
+  resolveFolder,
+  updateSolutionFile,
+  uploadJobAttachment
+} from "./packager-tool-b0s5d4ek.js";
+import {
+  ATTACHMENT_INSTRUCTIONS,
+  ATTACHMENT_UPLOAD_INSTRUCTIONS,
+  ErrorDecision,
+  MIN_INTERVAL_MS,
+  OutputFormatter,
+  PollOutcome,
+  RESULTS,
+  ScreenLogger,
+  addSdkUserAgentHeader,
+  appendOption,
+  catchError,
+  createHiddenDeprecatedTenantOption,
+  extractErrorMessage,
+  extractErrorMessageSync,
+  getSdkUserAgentToken,
+  installSdkUserAgentHeader,
+  instructionsFor,
+  isFailureStatus,
+  isPreviewBuild,
+  isTerminalStatus,
+  logger,
+  mapPackageMetadataOptions,
+  msToDuration,
+  parseAttachmentSpec,
+  pollUntil,
+  processContext,
+  readStdin,
+  registerPackageMetadataOptions,
+  resolveAttachmentInputs
+} from "./packager-tool-ny53xmsd.js";
 import {
   getFileSystem
-} from "./packager-tool-4f38v0ry.js";
+} from "./packager-tool-1cb0d5e0.js";
 import {
   DEFAULT_LAYOUT_OPTIONS,
   addBinding,
@@ -139,22 +143,32 @@ import {
   checkNodeMigrations,
   convertFlowToBpmn,
   createBinding,
+  createFlowRefResolver,
   createWorkflowVariable,
-  currentVersion,
   generateNodeIdAndName,
   generateNodeVariables,
-  generatePackageDescriptor,
-  generateRandomId,
-  inMemoryWorkflowToFileFormat,
-  migrateWorkflow,
-  migrations,
+  migrateWorkflowToFloor,
+  minimumSupportedVersion,
   replaceExporterVersion,
   resolveHeight,
   resolveWidth,
+  resolveWorkflowRefs,
+  runtimeMigrations,
+  runtimeVersion,
   setPublishIntentOnInlineAgents,
   snapToGrid,
   validateIdentifier
-} from "./packager-tool-q94g73f7.js";
+} from "./packager-tool-6a7wdv5z.js";
+import {
+  compareVersions,
+  executeWritePlan,
+  generatePackageDescriptor,
+  generateRandomId,
+  inMemoryWorkflowToFileFormat,
+  isExpressionValue,
+  isStartEventNode,
+  planWriteThrough
+} from "./packager-tool-ef2aypt3.js";
 import {
   __require,
   __toESM
@@ -163,7 +177,7 @@ import {
 var package_default = {
   name: "@uipath/flow-tool",
   license: "MIT",
-  version: "1.200.0-preview.120",
+  version: "1.201.0-preview.121",
   description: "Create, debug, and run UiPath Flow projects and jobs.",
   private: false,
   repository: {
@@ -209,13 +223,14 @@ var package_default = {
   devDependencies: {
     "@uipath/agent-sdk": "workspace:*",
     "@uipath/auth": "workspace:*",
+    "@uipath/builder-sdk": "workspace:*",
     "@uipath/common": "workspace:*",
     "@uipath/filesystem": "workspace:*",
-    "@uipath/flow-core": "^0.34.1",
+    "@uipath/flow-core": "^0.68.0",
     elkjs: "^0.11.1",
-    "@uipath/flow-converter": "0.25.0",
-    "@uipath/flow-migrations": "^0.15.1",
-    "@uipath/flow-schema": "^0.22.1",
+    "@uipath/flow-converter": "^0.42.1",
+    "@uipath/flow-migrations": "^0.33.0",
+    "@uipath/flow-schema": "^0.42.0",
     "@uipath/integrationservice-sdk": "workspace:*",
     i18next: "^23.16.8",
     "@uipath/maestro-sdk": "workspace:*",
@@ -1294,7 +1309,7 @@ class FlowDebugService {
       ];
       const startNodeId = entryPoints[0]?.filePath.split("#")[1] ?? startEventId;
       entryPoint = `/${bpmnFileName}#${startNodeId}`;
-      const [refreshError, refreshResult] = await catchError(ensureToolModule("solution", "@uipath/solution-tool", "resource").then((mod) => mod.resourceRefreshAsync(stagingDir)));
+      const [refreshError, refreshResult] = await catchError(import("./index-6hp3p3eq.js").then((mod) => mod.resourceRefreshAsync(stagingDir)));
       if (refreshError) {
         logger.warn(`Resource refresh threw before debug: ${refreshError.message}. Continuing without generated overwrites.`);
       } else if (refreshResult.ok) {
@@ -6090,18 +6105,25 @@ var buildNodeMigrationRegistry = () => {
   }
   return registry2;
 };
+var netWorkflowSteps = (fromVersion, steps) => {
+  const cmp = compareVersions(fromVersion, minimumSupportedVersion);
+  const net = cmp < 0 ? steps.filter((s) => compareVersions(s.to, s.from) > 0 && compareVersions(s.to, minimumSupportedVersion) <= 0) : steps.filter((s) => compareVersions(s.to, s.from) < 0);
+  return net.map((s) => `${s.from} -> ${s.to}`);
+};
 var migrateFlow = async (filePath, options = {}) => {
   const fs = getFileSystem();
   const raw = await fs.readFile(filePath, "utf-8");
-  const workflow = JSON.parse(raw);
-  const fromVersion = String(workflow.version ?? "");
+  const parsed = JSON.parse(raw);
+  const fromVersion = String(parsed.version ?? "");
+  const { resolved, refMap } = await resolveWorkflowRefs(parsed, createFlowRefResolver(fs, logger), filePath);
+  const workflow = resolved;
   const { tracker, fieldPaths } = captureMigrationIssues();
-  const wfResult = migrateWorkflow(migrations, workflow, currentVersion, tracker);
+  const wfResult = migrateWorkflowToFloor(runtimeMigrations, workflow, runtimeVersion, minimumSupportedVersion, tracker);
   if (wfResult.error) {
     throw new Error(formatMigrationFailureMessage(wfResult.error.step, wfResult.error.message, fieldPaths()));
   }
   const migrated = wfResult.migrated ? wfResult.workflow : workflow;
-  const workflowSteps = wfResult.steps.map((s) => `${s.from} -> ${s.to}`);
+  const workflowSteps = wfResult.migrated ? netWorkflowSteps(fromVersion, wfResult.steps) : [];
   const registry2 = buildNodeMigrationRegistry();
   const allNodes = [
     ...migrated.nodes ?? [],
@@ -6113,15 +6135,23 @@ var migrateFlow = async (filePath, options = {}) => {
   const nodeResult = applyNodeMigrations(migrated, toApply);
   const anyChange = wfResult.migrated || nodeResult.migratedCount > 0;
   if (anyChange && !options.dryRun) {
-    await fs.writeFile(filePath, `${JSON.stringify(migrated, null, 2)}
-`);
+    const plan = planWriteThrough(migrated, refMap);
+    await executeWritePlan(plan, {
+      writeMainFile: async (content) => {
+        await fs.writeFile(filePath, content);
+      },
+      writeRefFile: async (refPath, content) => {
+        const resolvedPath = fs.path.resolve(fs.path.dirname(filePath), refPath);
+        await fs.writeFile(resolvedPath, content);
+      }
+    });
     logger.debug(`migrateFlow: wrote migrated workflow to ${filePath}`);
   }
   const optionalApplied = includeOptional ? Math.max(0, check.optional.length - nodeResult.failedCount) : 0;
   return {
     file: filePath,
     fromVersion,
-    toVersion: String(migrated.version ?? currentVersion),
+    toVersion: String(migrated.version ?? minimumSupportedVersion),
     migrated: anyChange,
     workflowSteps,
     forcedNodeMigrations: check.forced.length,
@@ -6314,32 +6344,51 @@ function extractInstanceParameters(definitions, nodeType) {
   }
 }
 function ensureConnectionBindings(workflow, connectorKey, connectionId, folderKey) {
+  const liveConnectionKeys = collectConfiguredConnectionKeys(workflow);
   upsertConnectionResourceBinding(workflow, {
     name: `${connectorKey} connection`,
     propertyAttribute: "ConnectionId",
     resourceKey: connectionId,
     default: connectionId
-  });
+  }, liveConnectionKeys);
   upsertConnectionResourceBinding(workflow, {
     name: "FolderKey",
     propertyAttribute: "FolderKey",
     resourceKey: connectionId,
     default: folderKey
-  });
+  }, liveConnectionKeys);
 }
-function upsertConnectionResourceBinding(workflow, spec) {
+function collectConfiguredConnectionKeys(workflow) {
+  const keys = new Set;
+  const collect = (nodes) => {
+    for (const node of nodes ?? []) {
+      const detail = node.inputs?.detail;
+      const key = detail?.connectionResourceId;
+      if (typeof key === "string" && key.length > 0)
+        keys.add(key);
+    }
+  };
+  collect(workflow.nodes);
+  const subflows = workflow.subflows;
+  for (const entry of Object.values(subflows ?? {})) {
+    collect(entry?.nodes);
+  }
+  return keys;
+}
+function upsertConnectionResourceBinding(workflow, spec, liveConnectionKeys) {
   const bindings = workflow.bindings ?? [];
-  const exact = bindings.find((b) => b.name === spec.name && b.resource?.toLowerCase() === "connection" && b.resourceKey === spec.resourceKey && b.propertyAttribute === spec.propertyAttribute);
+  const sameSlot = bindings.filter((b) => b.name === spec.name && b.resource?.toLowerCase() === "connection" && b.propertyAttribute === spec.propertyAttribute);
+  const exact = sameSlot.find((b) => b.resourceKey === spec.resourceKey);
   if (exact) {
     exact.resource = "connection";
     exact.default = spec.default;
     return;
   }
-  const existing = bindings.find((b) => b.name === spec.name && b.resource?.toLowerCase() === "connection" && b.propertyAttribute === spec.propertyAttribute);
-  if (existing) {
-    existing.resource = "connection";
-    existing.resourceKey = spec.resourceKey;
-    existing.default = spec.default;
+  const claimable = sameSlot.find((b) => !b.resourceKey) ?? sameSlot.find((b) => !liveConnectionKeys.has(b.resourceKey));
+  if (claimable) {
+    claimable.resource = "connection";
+    claimable.resourceKey = spec.resourceKey;
+    claimable.default = spec.default;
     return;
   }
   const fresh = {
@@ -6725,10 +6774,32 @@ function buildAgentToolParamsFromMetadata(metadata, method) {
 }
 var UNRESOLVABLE_FILTER_MARKER = "${=js:";
 var MANGLED_FILTER_FRAGMENT = "${";
-function assertCompiledFilterResolvable(compiled, filterParamName) {
+var DANGLING_TRAILING_OPERATOR = /(?:^|\s)(?:AND|OR)\s*$/i;
+var DANGLING_LEADING_OPERATOR = /^\s*(?:AND|OR)(?:\s|$)/i;
+var DOUBLED_OPERATOR = /(?:^|\s)(?:AND|OR)\s+(?:AND|OR)(?:\s|$)/i;
+function collectFilterFieldIds(tree) {
+  const ids = (tree.filters ?? []).map((condition) => condition.id);
+  for (const group of tree.groups ?? []) {
+    ids.push(...collectFilterFieldIds(group));
+  }
+  return ids;
+}
+function assertCompiledFilterResolvable(compiled, filterParamName, authoredTree) {
   if (compiled.includes(MANGLED_FILTER_FRAGMENT)) {
     throw new Error(`Refusing to persist the compiled filter for '${filterParamName}': it embeds a '\${…}' fragment, which the runtime never resolves — the fragment reaches the connector as literal text and the filter silently matches nothing. Cause: either a dynamic operand escaped placeholder substitution, or the design-time client mis-marked a literal value as an expression (widget-metadata defect ENGCE-60123). Workaround: author the whole filter as one '=js:' template under --detail.queryParameters.${filterParamName} (activities), or re-author the filter with values the connector's picker supports (triggers).`);
   }
+  if (!authoredTree)
+    return;
+  const fieldIds = collectFilterFieldIds(authoredTree);
+  if (fieldIds.length === 0)
+    return;
+  const isEmpty = compiled.trim() === "";
+  const isMalformed = DANGLING_TRAILING_OPERATOR.test(compiled) || DANGLING_LEADING_OPERATOR.test(compiled) || DOUBLED_OPERATOR.test(compiled);
+  if (!isEmpty && !isMalformed)
+    return;
+  const outcome = isEmpty ? "The compiled expression is empty, so the filter disappears and the query returns every record." : `The compiled expression is broken: '${compiled}'. It holds a stray logical operator, so the connector faults at run time.`;
+  const names = [...new Set(fieldIds)].map((id) => `'${id}'`).join(", ");
+  throw new InvalidDetailError(`Refusing to persist the compiled filter for '${filterParamName}': the connector dropped at least one condition of --detail.filter. ${outcome} The filter tree names these fields: ${names}. Cause: a field id does not match the entity schema, or a condition has no operator. Field id matching is case-sensitive. Fix: read the supported field ids, then re-send --detail.filter with the exact ids. Run 'uip df entities get <ENTITY_ID> --output json' for a Data Service entity, or 'uip maestro flow registry get <NODE_TYPE> --connection-id <CONNECTION_ID> --output json' and read filterFields for a connector.`);
 }
 function assertLiteralEventParameters(eventParameters, nodeType) {
   const dynamic = Object.entries(eventParameters).filter(([, value]) => typeof value === "string" && value.startsWith("=js:")).map(([name]) => `'${name}'`);
@@ -6837,7 +6908,7 @@ async function configureActivity(workflow, node, config) {
     assertActivityMetadataResolved(activityClient.getEssentialConfiguration().essentialConfiguration, config.connectionId);
     if (filterInputName && authoredFilterTree) {
       const compiledFilter = activityClient.getCompiledFilter(filterInputName);
-      assertCompiledFilterResolvable(compiledFilter, filterInputName);
+      assertCompiledFilterResolvable(compiledFilter, filterInputName, authoredFilterTree);
       detail.queryParameters = {
         ...detail.queryParameters ?? {},
         [filterInputName]: compiledFilter
@@ -6927,7 +6998,7 @@ async function configureTrigger(workflow, node, config) {
   });
   assertActivityMetadataResolved(triggerClient.getEssentialConfiguration().essentialConfiguration, config.connectionId);
   const compiledTriggerFilter = triggerClient.getCompiledFilter("filter");
-  assertCompiledFilterResolvable(compiledTriggerFilter, "filter");
+  assertCompiledFilterResolvable(compiledTriggerFilter, "filter", filterTree);
   detail.filterExpression = compiledTriggerFilter;
   if (filterTree && Object.keys(filterVariables).length > 0) {
     detail.filterVariables = filterVariables;
@@ -7436,7 +7507,7 @@ Packing flow project...
       const packageId = `${packageName}.flow.Flow`;
       const version = options.version || "1.0.0";
       registerPackagerFactories();
-      const { createNodeProjectPackager, ProjectPackOptions } = await import("./node-8d0q6ch7.js");
+      const { createNodeProjectPackager, ProjectPackOptions } = await import("./node-f062h75p.js");
       const packager = await createNodeProjectPackager({
         logHandler: logger.handleLog
       });
@@ -8512,9 +8583,10 @@ var ElkLayoutEngine = class {
     const elk = await this.getElk();
     const layouted = await elk.layout(graph);
     const updatedNodes = this.extractNodePositions(nodes, layouted);
+    const edgeWaypoints = this.extractEdgeWaypoints(layouted, new Set(edges.map((e) => e.id)));
     const endTime = performance.now();
     const metrics = this.calculateMetrics(layouted, endTime - startTime);
-    return { nodes: updatedNodes, metrics };
+    return { nodes: updatedNodes, edgeWaypoints, metrics };
   }
   collectPorts(nodes, options, resolveNodePorts) {
     const nodePortsMap = /* @__PURE__ */ new Map;
@@ -8749,6 +8821,17 @@ var ElkLayoutEngine = class {
       return { ...node, position: { x: pos.x, y: pos.y } };
     });
   }
+  extractEdgeWaypoints(root, realEdgeIds) {
+    const result = /* @__PURE__ */ new Map;
+    for (const edge of root.edges ?? []) {
+      if (!realEdgeIds.has(edge.id))
+        continue;
+      const points = (edge.sections ?? []).flatMap((s) => s.bendPoints ?? []).map((p) => ({ x: p.x, y: p.y }));
+      if (points.length > 0)
+        result.set(edge.id, points);
+    }
+    return result;
+  }
   getLayoutOptions(options) {
     const opts = {
       "elk.algorithm": options.algorithm,
@@ -8766,6 +8849,7 @@ var ElkLayoutEngine = class {
         }
         opts["elk.spacing.edgeNode"] = options.nodeSpacing.toString();
         opts["elk.spacing.edgeEdge"] = "16";
+        opts["elk.edgeRouting"] = "ORTHOGONAL";
         break;
       case "mrtree":
         opts["elk.spacing.nodeNode"] = options.nodeSpacing.toString();
@@ -9378,7 +9462,7 @@ function querystringSingleKey(key, value, keyPrefix = "") {
 var package_default2 = {
   name: "@uipath/agent-sdk",
   license: "MIT",
-  version: "1.200.0-preview.120",
+  version: "1.201.0-preview.121",
   description: "SDK for the UiPath Agent Runtime API — evaluation execution and debug sessions.",
   repository: {
     type: "git",
@@ -9587,6 +9671,13 @@ var registerValidateCommand = (program) => {
 };
 
 // src/services/variable-service.ts
+var expressionText = (expression) => {
+  if (typeof expression === "string")
+    return expression;
+  if (isExpressionValue(expression))
+    return expression.expression;
+  return "";
+};
 var listVariablesInFlow = async (filePath) => {
   const { workflow } = await readFlowWorkflow(filePath);
   const globals = (workflow.variables?.globals ?? []).map((v) => ({
@@ -9594,7 +9685,10 @@ var listVariablesInFlow = async (filePath) => {
     type: v.type,
     direction: v.direction,
     ...v.defaultValue !== undefined && { defaultValue: v.defaultValue },
-    ...v.description !== undefined && { description: v.description }
+    ...v.description !== undefined && { description: v.description },
+    ...v.triggerNodeId !== undefined && {
+      triggerNodeId: v.triggerNodeId
+    }
   }));
   const nodes = (workflow.variables?.nodes ?? []).map((v) => ({
     id: v.id,
@@ -9606,14 +9700,44 @@ var listVariablesInFlow = async (filePath) => {
   const variables = [...globals, ...nodes];
   return { variables, count: variables.length };
 };
+var resolveTriggerNodeId = (nodes, explicitTriggerNodeId) => {
+  const triggerNodes = nodes.filter((node) => isStartEventNode({
+    id: node.id,
+    type: node.type,
+    typeVersion: node.typeVersion ?? "1.0"
+  }));
+  if (explicitTriggerNodeId !== undefined) {
+    if (!nodes.some((node) => node.id === explicitTriggerNodeId)) {
+      const available = nodes.map((node) => node.id).join(", ");
+      throw new Error(available ? `Node '${explicitTriggerNodeId}' not found in the flow. Available nodes: ${available}` : `Node '${explicitTriggerNodeId}' not found. The flow has no nodes`);
+    }
+    if (!triggerNodes.some((node) => node.id === explicitTriggerNodeId)) {
+      const triggerIds = triggerNodes.map((node) => node.id).join(", ");
+      throw new Error(triggerIds ? `Node '${explicitTriggerNodeId}' is not a trigger node. Trigger nodes in this flow: ${triggerIds}` : `Node '${explicitTriggerNodeId}' is not a trigger node. The flow has no trigger nodes`);
+    }
+    return explicitTriggerNodeId;
+  }
+  if (triggerNodes.length === 0) {
+    return;
+  }
+  if (triggerNodes.length > 1) {
+    const triggerIds = triggerNodes.map((node) => node.id).join(", ");
+    throw new Error(`Flow has multiple trigger nodes (${triggerIds}); each is a separate entry point. Pass --trigger-node-id <nodeId> to choose which one this input belongs to`);
+  }
+  return triggerNodes[0].id;
+};
 var addVariableToFlow = async (filePath, options) => {
+  if (options.triggerNodeId !== undefined && options.direction !== "in") {
+    throw new Error(`--trigger-node-id applies only to input variables (--direction in), but --direction is '${options.direction}'`);
+  }
   const { workflow, refMap } = await readFlowWorkflow(filePath);
   const globals = workflow.variables?.globals ?? [];
   const duplicate = globals.find((v) => v.id === options.id);
   if (duplicate) {
     throw new Error(`Variable '${options.id}' already exists in the flow file`);
   }
-  const variable = createWorkflowVariable({
+  const triggerNodeId = options.direction === "in" ? resolveTriggerNodeId(workflow.nodes ?? [], options.triggerNodeId) : undefined;
+  const created = createWorkflowVariable({
     id: options.id,
     direction: options.direction,
     type: options.type,
@@ -9622,6 +9746,7 @@ var addVariableToFlow = async (filePath, options) => {
     description: options.description,
     schema: options.schema
   });
+  const variable = triggerNodeId === undefined ? created : { ...created, triggerNodeId };
   addVariable(workflow, variable);
   await writeFlowWorkflow(filePath, workflow, refMap);
   return variable;
@@ -9640,7 +9765,7 @@ var deleteVariableFromFlow = async (filePath, variableId) => {
     const cleaned = {};
     for (const [nodeId, updates] of Object.entries(updatedVariableUpdates)) {
       const varRefPattern = new RegExp(`\\$vars\\.${variableId}\\b`);
-      const filtered = updates.filter((u) => u.variableId !== variableId && !varRefPattern.test(u.expression));
+      const filtered = updates.filter((u) => u.variableId !== variableId && !varRefPattern.test(expressionText(u.expression)));
       if (filtered.length > 0) {
         cleaned[nodeId] = filtered;
       }
@@ -9659,7 +9784,7 @@ var deleteVariableFromFlow = async (filePath, variableId) => {
 // src/commands/variable.ts
 var VARIABLE_ADD_EXAMPLES = [
   {
-    Description: "Add a string input variable to a flow",
+    Description: "Add a string input variable to a flow (auto-bound to the flow's trigger node, making it an entry-point input)",
     Command: "uip maestro flow variable add flow.json myInput --direction in --type string",
     Output: {
       Code: "VariableAddSuccess",
@@ -9667,7 +9792,23 @@ var VARIABLE_ADD_EXAMPLES = [
         Variable: {
           id: "myInput",
           direction: "in",
-          type: "string"
+          type: "string",
+          triggerNodeId: "manualTrigger1"
+        }
+      }
+    }
+  },
+  {
+    Description: "Bind an input to a specific trigger when the flow has several entry points",
+    Command: "uip maestro flow variable add flow.json myInput --direction in --type string --trigger-node-id timerTrigger1",
+    Output: {
+      Code: "VariableAddSuccess",
+      Data: {
+        Variable: {
+          id: "myInput",
+          direction: "in",
+          type: "string",
+          triggerNodeId: "timerTrigger1"
         }
       }
     }
@@ -9754,7 +9895,7 @@ function parseDefaultValue(value, type) {
 }
 var registerVariableCommand = (program) => {
   const variable = program.command("variable").description("Manage variables in a Flow file");
-  variable.command("add").description("Add a variable to a Flow file").argument("<file>", "Path to the .flow file").argument("<variable-id>", "Variable identifier (e.g. myInputVar)").requiredOption("-d, --direction <direction>", `Variable direction (${VALID_DIRECTIONS.join(", ")})`).option("-t, --type <type>", `Data type (${VALID_TYPES.join(", ")})`, "string").option("--default-value <value>", "Default value (parsed based on --type)").option("--description <text>", "Human-readable description").option("--schema <json>", "JSON schema for object/array types").option("--sub-type <subType>", "Sub-type for complex types").examples(VARIABLE_ADD_EXAMPLES).trackedAction(processContext, async (file, variableId, options) => {
+  variable.command("add").description("Add a variable to a Flow file").argument("<file>", "Path to the .flow file").argument("<variable-id>", "Variable identifier (e.g. myInputVar)").requiredOption("-d, --direction <direction>", `Variable direction (${VALID_DIRECTIONS.join(", ")})`).option("-t, --type <type>", `Data type (${VALID_TYPES.join(", ")})`, "string").option("--default-value <value>", "Default value (parsed based on --type)").option("--description <text>", "Human-readable description").option("--schema <json>", "JSON schema for object/array types").option("--sub-type <subType>", "Sub-type for complex types").option("--trigger-node-id <nodeId>", "Trigger node an input variable belongs to (defaults to the flow's only trigger node; required when the flow has several)").examples(VARIABLE_ADD_EXAMPLES).trackedAction(processContext, async (file, variableId, options) => {
     const identifierError = validateIdentifier(variableId, []);
     if (identifierError) {
       OutputFormatter.error({
@@ -9827,7 +9968,8 @@ var registerVariableCommand = (program) => {
       subType: options.subType,
       defaultValue,
       description: options.description,
-      schema
+      schema,
+      triggerNodeId: options.triggerNodeId
     }));
     if (error) {
       OutputFormatter.error({
@@ -9897,200 +10039,6 @@ var registerVariableCommand = (program) => {
   });
 };
 
-// src/services/variable-update-service.ts
-var addVariableUpdateToFlow = async (filePath, options) => {
-  const { workflow, refMap } = await readFlowWorkflow(filePath);
-  const nodeExists = (workflow.nodes ?? []).some((n) => n.id === options.nodeId);
-  if (!nodeExists) {
-    throw new Error(`Node '${options.nodeId}' not found in the workflow`);
-  }
-  const globals = workflow.variables?.globals ?? [];
-  const variable = globals.find((v) => v.id === options.variableId);
-  if (!variable) {
-    throw new Error(`Variable '${options.variableId}' not found in workflow globals`);
-  }
-  if (variable.direction === "in") {
-    throw new Error(`Variable '${options.variableId}' has direction 'in' and cannot be assigned to. Only 'out' or 'inout' variables can be updated`);
-  }
-  const variableUpdates = workflow.variables?.variableUpdates ?? {};
-  const nodeUpdates = variableUpdates[options.nodeId] ?? [];
-  const duplicate = nodeUpdates.find((u) => u.variableId === options.variableId);
-  if (duplicate) {
-    throw new Error(`Variable update for variable '${options.variableId}' on node '${options.nodeId}' already exists. Use 'variable-update set' to replace it`);
-  }
-  const expression = options.expression.startsWith("=js:") ? options.expression : `=js:${options.expression}`;
-  const update = { variableId: options.variableId, expression };
-  nodeUpdates.push(update);
-  variableUpdates[options.nodeId] = nodeUpdates;
-  if (!workflow.variables) {
-    workflow.variables = {};
-  }
-  workflow.variables.variableUpdates = variableUpdates;
-  await writeFlowWorkflow(filePath, workflow, refMap);
-  return {
-    nodeId: options.nodeId,
-    variableId: options.variableId,
-    expression
-  };
-};
-var deleteVariableUpdateFromFlow = async (filePath, nodeId, variableId) => {
-  const { workflow, refMap } = await readFlowWorkflow(filePath);
-  const updatesMap = workflow.variables?.variableUpdates;
-  const nodeUpdates = updatesMap?.[nodeId];
-  if (!nodeUpdates || nodeUpdates.length === 0) {
-    throw new Error(`No variable updates found for node "${nodeId}". Use 'uip maestro flow variable-update list' to see existing updates.`);
-  }
-  const entryIndex = nodeUpdates.findIndex((e) => e.variableId === variableId);
-  if (entryIndex === -1) {
-    throw new Error(`No update for variable "${variableId}" on node "${nodeId}". Use 'uip maestro flow variable-update list' to see existing updates.`);
-  }
-  const [deleted] = nodeUpdates.splice(entryIndex, 1);
-  if (nodeUpdates.length === 0 && updatesMap) {
-    delete updatesMap[nodeId];
-  }
-  await writeFlowWorkflow(filePath, workflow, refMap);
-  return {
-    deletedUpdate: {
-      nodeId,
-      variableId: deleted.variableId,
-      expression: deleted.expression
-    }
-  };
-};
-var listVariableUpdatesInFlow = async (filePath, options) => {
-  const { workflow } = await readFlowWorkflow(filePath);
-  const updatesRecord = workflow.variables?.variableUpdates ?? {};
-  let variableUpdates = Object.entries(updatesRecord).flatMap(([nodeId, updates]) => (Array.isArray(updates) ? updates : []).filter((u) => typeof u?.variableId === "string" && typeof u?.expression === "string").map((u) => ({
-    nodeId,
-    variableId: u.variableId,
-    expression: u.expression
-  })));
-  if (options?.nodeId) {
-    variableUpdates = variableUpdates.filter((u) => u.nodeId === options.nodeId);
-  }
-  return { variableUpdates, count: variableUpdates.length };
-};
-
-// src/commands/variable-update.ts
-var VARIABLE_UPDATE_ADD_EXAMPLES = [
-  {
-    Description: "Add a variable update expression to a node",
-    Command: 'uip maestro flow variable-update add flow.json --node-id node_a1b2c3d4 --variable-id var_1 --expression "=js:ctx.output"',
-    Output: {
-      Code: "VariableUpdateAddSuccess",
-      Data: {
-        VariableUpdate: {
-          nodeId: "node_a1b2c3d4",
-          variableId: "var_1",
-          expression: "=js:ctx.output"
-        }
-      }
-    }
-  }
-];
-var VARIABLE_UPDATE_DELETE_EXAMPLES = [
-  {
-    Description: "Remove a variable update from a node",
-    Command: "uip maestro flow variable-update remove flow.json node_a1b2c3d4 var_1",
-    Output: {
-      Code: "VariableUpdateRemoveSuccess",
-      Data: {
-        DeletedUpdate: {
-          nodeId: "node_a1b2c3d4",
-          variableId: "var_1"
-        }
-      }
-    }
-  }
-];
-var VARIABLE_UPDATE_LIST_EXAMPLES = [
-  {
-    Description: "List all variable updates in a flow",
-    Command: "uip maestro flow variable-update list flow.json",
-    Output: {
-      Code: "VariableUpdateListSuccess",
-      Data: {
-        VariableUpdates: [
-          {
-            nodeId: "node_a1b2c3d4",
-            variableId: "var_1",
-            expression: "=js:ctx.output"
-          }
-        ],
-        Count: 1
-      }
-    }
-  }
-];
-var registerVariableUpdateCommand = (program) => {
-  const variableUpdate = program.command("variable-update").description("Manage variable updates in a Flow file");
-  variableUpdate.command("add").description("Add a variable update expression to a node").argument("<file>", "Path to the .flow file").requiredOption("--node-id <id>", "Node that triggers the update on completion").requiredOption("--variable-id <id>", "Global variable to assign to (must be out or inout)").requiredOption("--expression <expr>", "JS expression to evaluate (auto-prefixed with =js: if missing)").examples(VARIABLE_UPDATE_ADD_EXAMPLES).trackedAction(processContext, async (file, options) => {
-    const [error, result] = await catchError(addVariableUpdateToFlow(file, {
-      nodeId: options.nodeId,
-      variableId: options.variableId,
-      expression: options.expression
-    }));
-    if (error) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "Error adding variable update",
-        Instructions: error.message
-      });
-      processContext.exit(1);
-      return;
-    }
-    OutputFormatter.success({
-      Result: RESULTS.Success,
-      Code: "VariableUpdateAddSuccess",
-      Data: {
-        VariableUpdate: result
-      }
-    });
-  });
-  variableUpdate.command("remove").description(`Remove a variable update from a node in a Flow file.
-` + "Use 'uip maestro flow variable-update list' to find node and variable IDs.").argument("<file>", "Path to the .flow file").argument("<node-id>", "ID of the node").argument("<variable-id>", "ID of the variable").examples(VARIABLE_UPDATE_DELETE_EXAMPLES).trackedAction(processContext, async (file, nodeId, variableId) => {
-    const [error, result] = await catchError(deleteVariableUpdateFromFlow(file, nodeId, variableId));
-    if (error) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "Error deleting variable update",
-        Instructions: error.message
-      });
-      processContext.exit(1);
-      return;
-    }
-    OutputFormatter.success({
-      Result: RESULTS.Success,
-      Code: "VariableUpdateRemoveSuccess",
-      Data: {
-        DeletedUpdate: result.deletedUpdate
-      }
-    });
-  });
-  variableUpdate.command("list").description("List all variable updates in a Flow file").argument("<file>", "Path to the .flow file").option("--node-id <id>", "Filter to updates on a specific node").examples(VARIABLE_UPDATE_LIST_EXAMPLES).trackedAction(processContext, async (file, options) => {
-    const [error, result] = await catchError(listVariableUpdatesInFlow(file, {
-      nodeId: options.nodeId
-    }));
-    if (error) {
-      OutputFormatter.error({
-        Result: RESULTS.Failure,
-        Message: "Error listing variable updates",
-        Instructions: error.message
-      });
-      processContext.exit(1);
-      return;
-    }
-    OutputFormatter.success({
-      Result: RESULTS.Success,
-      Code: "VariableUpdateListSuccess",
-      Data: {
-        VariableUpdates: result.variableUpdates,
-        Count: result.count
-      }
-    });
-  });
-};
-
 // src/tool.ts
 var metadata = {
   name: "flow-tool",
@@ -10099,6 +10047,10 @@ var metadata = {
   commandPrefix: "flow"
 };
 var registerCommands = async (program) => {
+  if (isPreviewBuild()) {
+    const { registerFlowAuthoringCommands } = await import("./authoring-rezk32bm.js");
+    registerFlowAuthoringCommands(program);
+  }
   registerInitCommand(program);
   registerPackCommand(program);
   registerPublishCommand(program);
@@ -10119,9 +10071,8 @@ var registerCommands = async (program) => {
   registerIncidentsCommand(program);
   registerTidyCommand(program);
   registerVariableCommand(program);
-  registerVariableUpdateCommand(program);
 };
 
 export { metadata, registerCommands };
 
-//# debugId=E2D51F83F5DCA73564756E2164756E21
+//# debugId=8FD717C3B3B7EC5B64756E2164756E21