@uipath/flow-tool 1.197.0 → 1.198.0-preview.81

package/dist/init.js

@@ -165937,6 +165937,7 @@ function getLogFilePath() {
 // ../common/src/output-format-context.ts
 var formatSlot = singleton("OutputFormat");
 var formatExplicitSlot = singleton("OutputFormatExplicit");
+var helpRequestedSlot = singleton("HelpRequested");
 var filterSlot = singleton("OutputFilter");
 function getOutputFormat() {
   return formatSlot.get("json");
@@ -167004,6 +167005,9 @@ var OutputFormatter;
     if (opts?.warning) {
       data.Warning = opts.warning;
     }
+    if (opts?.pagination) {
+      data.Pagination = opts.pagination;
+    }
     success(data);
   }
   OutputFormatter.emitList = emitList;
@@ -167443,6 +167447,7 @@ var savedOriginalsSlot = singleton("ConsoleGuardOriginals");
 var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
 // ../common/src/interactivity-context.ts
 var modeSlot = singleton("InteractivityMode");
+var interactiveFlagSlot = singleton("InteractiveFlag");
 // ../common/src/polling/types.ts
 var PollOutcome = {
   Completed: "completed",
@@ -194611,6 +194616,10 @@ var KNOWN_ERROR_CODES = new Set([
   "ENOTDIR",
   "EUNKNOWN"
 ]);
+
+// ../auth/src/index.ts
+init_constants();
+
 // ../auth/src/interactive.ts
 init_src();
 
@@ -195197,7 +195206,7 @@ class TextApiResponse {
 var package_default = {
   name: "@uipath/integrationservice-sdk",
   license: "MIT",
-  version: "1.197.0",
+  version: "1.198.0-preview.81",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -200937,6 +200946,17 @@ var API_DOMAIN_MAP = new Map([
   [SessionsApi, "connections"],
   [ElementsApi, "elements"]
 ]);
+function baseApiClassName(name) {
+  let end = name.length;
+  while (end > 0 && name[end - 1] >= "0" && name[end - 1] <= "9") {
+    end--;
+  }
+  return name.slice(0, end);
+}
+var API_DOMAIN_BY_NAME = new Map([...API_DOMAIN_MAP].map(([ApiClass, domain3]) => [
+  baseApiClassName(ApiClass.name),
+  domain3
+]));
 // ../integrationservice-sdk/src/dap/essential-config.ts
 var JIT_INPUT_OPERATIONS = new Set(["create", "update", "replace"]);
 // ../integrationservice-sdk/src/dap/filter-builder/workflow-value.ts
@@ -201460,7 +201480,9 @@ var ENABLED_MANIFEST_FLAGS = new Set([
   MANIFEST_FEATURE_FLAGS.CONNECTOR_NODES,
   MANIFEST_FEATURE_FLAGS.EXTRACT_DOCUMENT,
   MANIFEST_FEATURE_FLAGS.HITL,
-  MANIFEST_FEATURE_FLAGS.LOOP_CONTAINER
+  MANIFEST_FEATURE_FLAGS.LOOP_CONTAINER,
+  MANIFEST_FEATURE_FLAGS.BATCH_TRANSFORM,
+  MANIFEST_FEATURE_FLAGS.SUMMARIZE
 ]);
 // ../orchestrator-sdk/generated/src/runtime.ts
 var BASE_PATH3 = "https://alpha.uipath.com/uipattycyrhx/abizon_1/orchestrator_".replace(/\/+$/, "");
@@ -201685,7 +201707,7 @@ function querystringSingleKey3(key, value, keyPrefix = "") {
 var package_default2 = {
   name: "@uipath/orchestrator-sdk",
   license: "MIT",
-  version: "1.197.0",
+  version: "1.198.0",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -201978,7 +202000,7 @@ function querystringSingleKey4(key, value, keyPrefix = "") {
 var package_default3 = {
   name: "@uipath/solution-sdk",
   license: "MIT",
-  version: "1.197.0",
+  version: "1.198.0-preview.81",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -204431,6 +204453,10 @@ class ProjectTool {
     this.logger.info("Pack operation is a noop");
     return ToolResult.success();
   }
+  async cleanupAsync(_options, _cancellationToken) {
+    this.logger.info("Cleanup operation is a noop");
+    return ToolResult.success();
+  }
   async getUiProjectAsync(projectPath) {
     const filePath = Path.join(projectPath, ProjectTool.ProjectFileName);
     if (!await this.fileSystem.exists(filePath)) {
@@ -204510,7 +204536,7 @@ init_dist2();
 // ../packager/packager-tool-flow/package.json
 var package_default4 = {
   name: "@uipath/packager-tool-flow",
-  version: "1.197.0",
+  version: "1.198.0-preview.81",
   description: "UiPath Flow tool implementation",
   type: "module",
   exports: {
@@ -216392,10 +216418,14 @@ var PROCESS_NODE_PREFIXES = [
   "uipath.core.agent.",
   "uipath.core.api-workflow."
 ];
-var UNRESOLVED_BINDING_PATTERN = /^<bindings\.\w+>$/;
+var CONNECTOR_TOOL_PREFIX = "uipath.agent.resource.tool.connector.";
+var UNRESOLVED_BINDING_PATTERN = /^<bindings\.[^>]+>$/;
 function isProcessNode(nodeType) {
   return PROCESS_NODE_PREFIXES.some((prefix2) => nodeType?.startsWith(prefix2));
 }
+function isConnectorToolNode(nodeType) {
+  return nodeType?.startsWith(CONNECTOR_TOOL_PREFIX) ?? false;
+}
 function extractProcessGuid(nodeType) {
   const match = nodeType.match(/^(?:uipath\.core\.rpa-workflow|uipath\.agent\.resource\.tool\.process|uipath\.core\.agent|uipath\.core\.api-workflow)\.([0-9a-f-]+)$/i);
   if (!match) {
@@ -216447,13 +216477,50 @@ function resolveContextPlaceholders(context, storedName, storedFolder) {
     }
   }
 }
+function createConnectorToolBindings(node2, definition97) {
+  const model = definition97.model;
+  const detail = node2.inputs?.detail;
+  const connectionId = detail?.connectionId ?? "";
+  const connectionFolderKey = detail?.connectionFolderKey ?? "";
+  const values = model?.bindings?.values ?? [];
+  const connValue = values.find((v2) => v2.propertyAttribute === "ConnectionId");
+  const folderValue = values.find((v2) => v2.propertyAttribute === "FolderKey");
+  const connectionBinding = createBinding({
+    name: connValue?.name ?? "connection",
+    value: connectionId,
+    resource: "Connection",
+    resourceKey: connectionId,
+    propertyAttribute: "ConnectionId"
+  });
+  const folderKeyBinding = createBinding({
+    name: folderValue?.name ?? "FolderKey",
+    value: connectionFolderKey,
+    resource: "Connection",
+    resourceKey: connectionId,
+    propertyAttribute: "FolderKey"
+  });
+  return { connectionBinding, folderKeyBinding };
+}
+function resolveConnectorContextPlaceholders(context, storedConnection, storedFolderKey) {
+  if (!context)
+    return;
+  for (const entry of context) {
+    if (typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)) {
+      if (entry.name === "connection") {
+        entry.default = storedConnection.default;
+        entry.value = `=bindings.${storedConnection.id}`;
+      } else if (entry.name === "folderKey") {
+        entry.default = storedFolderKey.default;
+        entry.value = `=bindings.${storedFolderKey.id}`;
+      }
+    }
+  }
+}
 function ensureProcessBindings(workflow, logger3) {
   const nodes = workflow.nodes ?? [];
   const definitions = workflow.definitions ?? [];
   let bindingsCreated = 0;
   for (const node2 of nodes) {
-    if (!isProcessNode(node2.type))
-      continue;
     const nodeModel = node2.model;
     const defModel = definitions.find((d2) => d2.nodeType === node2.type)?.model;
     const hasUnresolved = [nodeModel, defModel].some((m2) => m2?.context?.some((entry) => typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)));
@@ -216462,25 +216529,49 @@ function ensureProcessBindings(workflow, logger3) {
     const definition97 = definitions.find((d2) => d2.nodeType === node2.type);
     if (!definition97)
       continue;
-    let nameBinding;
-    let folderBinding;
-    try {
-      ({ nameBinding, folderBinding } = createProcessBindings(definition97));
-    } catch (err2) {
-      logger3.warn(`Skipping binding resolution for node "${node2.id}": ${err2 instanceof Error ? err2.message : String(err2)}`);
+    if (isProcessNode(node2.type)) {
+      let nameBinding;
+      let folderBinding;
+      try {
+        ({ nameBinding, folderBinding } = createProcessBindings(definition97));
+      } catch (err2) {
+        logger3.warn(`Skipping binding resolution for node "${node2.id}": ${err2 instanceof Error ? err2.message : String(err2)}`);
+        continue;
+      }
+      const beforeCount = workflow.bindings?.length ?? 0;
+      addBinding(workflow, nameBinding);
+      addBinding(workflow, folderBinding);
+      const storedBindings = workflow.bindings;
+      const storedName = storedBindings.find((b2) => b2.resourceKey === nameBinding.resourceKey && b2.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
+      const storedFolder = storedBindings.find((b2) => b2.resourceKey === folderBinding.resourceKey && b2.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
+      resolveContextPlaceholders(nodeModel?.context, storedName, storedFolder);
+      resolveContextPlaceholders(defModel?.context, storedName, storedFolder);
+      const added = (workflow.bindings?.length ?? 0) - beforeCount;
+      bindingsCreated += added;
+      logger3.info(`Resolved process bindings for node "${node2.id}" (${node2.type})`);
       continue;
     }
-    const beforeCount = workflow.bindings?.length ?? 0;
-    addBinding(workflow, nameBinding);
-    addBinding(workflow, folderBinding);
-    const storedBindings = workflow.bindings;
-    const storedName = storedBindings.find((b2) => b2.resourceKey === nameBinding.resourceKey && b2.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
-    const storedFolder = storedBindings.find((b2) => b2.resourceKey === folderBinding.resourceKey && b2.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
-    resolveContextPlaceholders(nodeModel?.context, storedName, storedFolder);
-    resolveContextPlaceholders(defModel?.context, storedName, storedFolder);
-    const added = (workflow.bindings?.length ?? 0) - beforeCount;
-    bindingsCreated += added;
-    logger3.info(`Resolved process bindings for node "${node2.id}" (${node2.type})`);
+    if (isConnectorToolNode(node2.type)) {
+      let connectionBinding;
+      let folderKeyBinding;
+      try {
+        ({ connectionBinding, folderKeyBinding } = createConnectorToolBindings(node2, definition97));
+      } catch (err2) {
+        logger3.warn(`Skipping connector binding resolution for node "${node2.id}": ${err2 instanceof Error ? err2.message : String(err2)}`);
+        continue;
+      }
+      const beforeCount = workflow.bindings?.length ?? 0;
+      addBinding(workflow, connectionBinding);
+      addBinding(workflow, folderKeyBinding);
+      const storedBindings = workflow.bindings;
+      const storedConn = storedBindings.find((b2) => b2.resourceKey === connectionBinding.resourceKey && b2.propertyAttribute === connectionBinding.propertyAttribute) ?? connectionBinding;
+      const storedFk = storedBindings.find((b2) => b2.resourceKey === folderKeyBinding.resourceKey && b2.propertyAttribute === folderKeyBinding.propertyAttribute) ?? folderKeyBinding;
+      resolveConnectorContextPlaceholders(nodeModel?.context, storedConn, storedFk);
+      resolveConnectorContextPlaceholders(defModel?.context, storedConn, storedFk);
+      const added = (workflow.bindings?.length ?? 0) - beforeCount;
+      bindingsCreated += added;
+      logger3.info(`Resolved connector bindings for node "${node2.id}" (${node2.type})`);
+    }
   }
   if (bindingsCreated > 0) {
     logger3.info(`ensureProcessBindings: created ${bindingsCreated} binding(s) for directly-authored nodes`);
@@ -218308,4 +218399,4 @@ export {
   flowInitAsync
 };
 
-//# debugId=84876202DD3CE52664756E2164756E21
+//# debugId=DA627481A33D1D5564756E2164756E21

package/dist/packager-tool.js

@@ -159757,6 +159757,10 @@ class ProjectTool {
     this.logger.info("Pack operation is a noop");
     return ToolResult.success();
   }
+  async cleanupAsync(_options, _cancellationToken) {
+    this.logger.info("Cleanup operation is a noop");
+    return ToolResult.success();
+  }
   async getUiProjectAsync(projectPath) {
     const filePath = Path.join(projectPath, ProjectTool.ProjectFileName);
     if (!await this.fileSystem.exists(filePath)) {
@@ -159836,7 +159840,7 @@ init_dist6();
 // ../packager/packager-tool-flow/package.json
 var package_default = {
   name: "@uipath/packager-tool-flow",
-  version: "1.197.0",
+  version: "1.198.0-preview.81",
   description: "UiPath Flow tool implementation",
   type: "module",
   exports: {
@@ -171779,10 +171783,14 @@ var PROCESS_NODE_PREFIXES = [
   "uipath.core.agent.",
   "uipath.core.api-workflow."
 ];
-var UNRESOLVED_BINDING_PATTERN = /^<bindings\.\w+>$/;
+var CONNECTOR_TOOL_PREFIX = "uipath.agent.resource.tool.connector.";
+var UNRESOLVED_BINDING_PATTERN = /^<bindings\.[^>]+>$/;
 function isProcessNode(nodeType) {
   return PROCESS_NODE_PREFIXES.some((prefix2) => nodeType?.startsWith(prefix2));
 }
+function isConnectorToolNode(nodeType) {
+  return nodeType?.startsWith(CONNECTOR_TOOL_PREFIX) ?? false;
+}
 function extractProcessGuid(nodeType) {
   const match = nodeType.match(/^(?:uipath\.core\.rpa-workflow|uipath\.agent\.resource\.tool\.process|uipath\.core\.agent|uipath\.core\.api-workflow)\.([0-9a-f-]+)$/i);
   if (!match) {
@@ -171834,13 +171842,50 @@ function resolveContextPlaceholders(context, storedName, storedFolder) {
     }
   }
 }
+function createConnectorToolBindings(node, definition95) {
+  const model = definition95.model;
+  const detail = node.inputs?.detail;
+  const connectionId = detail?.connectionId ?? "";
+  const connectionFolderKey = detail?.connectionFolderKey ?? "";
+  const values = model?.bindings?.values ?? [];
+  const connValue = values.find((v2) => v2.propertyAttribute === "ConnectionId");
+  const folderValue = values.find((v2) => v2.propertyAttribute === "FolderKey");
+  const connectionBinding = createBinding2({
+    name: connValue?.name ?? "connection",
+    value: connectionId,
+    resource: "Connection",
+    resourceKey: connectionId,
+    propertyAttribute: "ConnectionId"
+  });
+  const folderKeyBinding = createBinding2({
+    name: folderValue?.name ?? "FolderKey",
+    value: connectionFolderKey,
+    resource: "Connection",
+    resourceKey: connectionId,
+    propertyAttribute: "FolderKey"
+  });
+  return { connectionBinding, folderKeyBinding };
+}
+function resolveConnectorContextPlaceholders(context, storedConnection, storedFolderKey) {
+  if (!context)
+    return;
+  for (const entry of context) {
+    if (typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)) {
+      if (entry.name === "connection") {
+        entry.default = storedConnection.default;
+        entry.value = `=bindings.${storedConnection.id}`;
+      } else if (entry.name === "folderKey") {
+        entry.default = storedFolderKey.default;
+        entry.value = `=bindings.${storedFolderKey.id}`;
+      }
+    }
+  }
+}
 function ensureProcessBindings(workflow, logger) {
   const nodes = workflow.nodes ?? [];
   const definitions = workflow.definitions ?? [];
   let bindingsCreated = 0;
   for (const node of nodes) {
-    if (!isProcessNode(node.type))
-      continue;
     const nodeModel = node.model;
     const defModel = definitions.find((d2) => d2.nodeType === node.type)?.model;
     const hasUnresolved = [nodeModel, defModel].some((m2) => m2?.context?.some((entry) => typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)));
@@ -171849,25 +171894,49 @@ function ensureProcessBindings(workflow, logger) {
     const definition95 = definitions.find((d2) => d2.nodeType === node.type);
     if (!definition95)
       continue;
-    let nameBinding;
-    let folderBinding;
-    try {
-      ({ nameBinding, folderBinding } = createProcessBindings(definition95));
-    } catch (err2) {
-      logger.warn(`Skipping binding resolution for node "${node.id}": ${err2 instanceof Error ? err2.message : String(err2)}`);
+    if (isProcessNode(node.type)) {
+      let nameBinding;
+      let folderBinding;
+      try {
+        ({ nameBinding, folderBinding } = createProcessBindings(definition95));
+      } catch (err2) {
+        logger.warn(`Skipping binding resolution for node "${node.id}": ${err2 instanceof Error ? err2.message : String(err2)}`);
+        continue;
+      }
+      const beforeCount = workflow.bindings?.length ?? 0;
+      addBinding(workflow, nameBinding);
+      addBinding(workflow, folderBinding);
+      const storedBindings = workflow.bindings;
+      const storedName = storedBindings.find((b2) => b2.resourceKey === nameBinding.resourceKey && b2.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
+      const storedFolder = storedBindings.find((b2) => b2.resourceKey === folderBinding.resourceKey && b2.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
+      resolveContextPlaceholders(nodeModel?.context, storedName, storedFolder);
+      resolveContextPlaceholders(defModel?.context, storedName, storedFolder);
+      const added = (workflow.bindings?.length ?? 0) - beforeCount;
+      bindingsCreated += added;
+      logger.info(`Resolved process bindings for node "${node.id}" (${node.type})`);
       continue;
     }
-    const beforeCount = workflow.bindings?.length ?? 0;
-    addBinding(workflow, nameBinding);
-    addBinding(workflow, folderBinding);
-    const storedBindings = workflow.bindings;
-    const storedName = storedBindings.find((b2) => b2.resourceKey === nameBinding.resourceKey && b2.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
-    const storedFolder = storedBindings.find((b2) => b2.resourceKey === folderBinding.resourceKey && b2.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
-    resolveContextPlaceholders(nodeModel?.context, storedName, storedFolder);
-    resolveContextPlaceholders(defModel?.context, storedName, storedFolder);
-    const added = (workflow.bindings?.length ?? 0) - beforeCount;
-    bindingsCreated += added;
-    logger.info(`Resolved process bindings for node "${node.id}" (${node.type})`);
+    if (isConnectorToolNode(node.type)) {
+      let connectionBinding;
+      let folderKeyBinding;
+      try {
+        ({ connectionBinding, folderKeyBinding } = createConnectorToolBindings(node, definition95));
+      } catch (err2) {
+        logger.warn(`Skipping connector binding resolution for node "${node.id}": ${err2 instanceof Error ? err2.message : String(err2)}`);
+        continue;
+      }
+      const beforeCount = workflow.bindings?.length ?? 0;
+      addBinding(workflow, connectionBinding);
+      addBinding(workflow, folderKeyBinding);
+      const storedBindings = workflow.bindings;
+      const storedConn = storedBindings.find((b2) => b2.resourceKey === connectionBinding.resourceKey && b2.propertyAttribute === connectionBinding.propertyAttribute) ?? connectionBinding;
+      const storedFk = storedBindings.find((b2) => b2.resourceKey === folderKeyBinding.resourceKey && b2.propertyAttribute === folderKeyBinding.propertyAttribute) ?? folderKeyBinding;
+      resolveConnectorContextPlaceholders(nodeModel?.context, storedConn, storedFk);
+      resolveConnectorContextPlaceholders(defModel?.context, storedConn, storedFk);
+      const added = (workflow.bindings?.length ?? 0) - beforeCount;
+      bindingsCreated += added;
+      logger.info(`Resolved connector bindings for node "${node.id}" (${node.type})`);
+    }
   }
   if (bindingsCreated > 0) {
     logger.info(`ensureProcessBindings: created ${bindingsCreated} binding(s) for directly-authored nodes`);
@@ -174488,4 +174557,4 @@ var toolsFactoryRepository2 = _global2[REGISTRY_KEY2];
 // src/packager-tool.ts
 toolsFactoryRepository2.registerProjectToolFactory(new FlowToolFactory);
 
-//# debugId=7BFF9F271C5C8D6564756E2164756E21
+//# debugId=BEFF1E140161CD1464756E2164756E21

package/dist/services/flow-eval-file-store.d.ts

@@ -0,0 +1,11 @@
+import type { IFileSystem } from "@uipath/filesystem";
+export declare function ensureDirectory(fs: IFileSystem, path: string): Promise<void>;
+export declare class FlowEvalFileStore {
+    private readonly fs;
+    constructor(fs: IFileSystem);
+    readJsonFiles<T extends {
+        fileName?: string;
+    }>(dir: string): Promise<T[]>;
+    writeJsonFile(path: string, value: unknown): Promise<void>;
+    remove(path: string): Promise<void>;
+}

package/dist/services/flow-migration-check.d.ts

@@ -0,0 +1,51 @@
+import { type MigrationErrorTracker, type MigrationWorkflow } from "@uipath/flow-migrations";
+/**
+ * Studio Web runs the workflow migration chain when it opens a `.flow`, and
+ * rejects the flow if any step fails (e.g. "Workflow migration failed at
+ * 1.3->1.4: Invalid input for migration 1.3 -> 1.4"). The CLI bundles the same
+ * `@uipath/flow-migrations` engine, so it can reproduce that failure locally —
+ * this module is the shared plumbing that both `flow migrate` and `flow
+ * validate` use to do so (UV-15030).
+ *
+ * `migrateWorkflow` does NOT throw on a failed step; it returns the ORIGINAL
+ * workflow with `migrated: false` and a populated `error: { step, message }`.
+ * The offending field paths are only reachable through the optional
+ * `errorTracker`, not the returned `error`. `captureMigrationIssues` wires that
+ * tracker up so callers can enrich the bare "Invalid input" message with the
+ * exact nodes/fields that failed.
+ */
+export declare function captureMigrationIssues(): {
+    tracker: MigrationErrorTracker;
+    fieldPaths: () => string[];
+};
+/**
+ * Human-facing explanation for a failed workflow migration step, shared by
+ * `flow migrate` (as a thrown error message) and `flow validate` (as a
+ * validation issue). `step` and `rawMessage` come straight from
+ * `migrateWorkflow`'s returned `error`; `fieldPaths` come from
+ * `captureMigrationIssues`.
+ */
+export declare function formatMigrationFailureMessage(step: string, rawMessage: string, fieldPaths: string[]): string;
+export type ForwardMigrationCheck = {
+    ok: true;
+} | {
+    ok: false;
+    step: string;
+    rawMessage: string;
+    message: string;
+    fieldPaths: string[];
+};
+/**
+ * Run the forward migration Studio Web would run when opening this flow, in
+ * memory — no write, no network. Returns `{ ok: false, ... }` only when a
+ * migration STEP fails (the flow is at a known version but its shape is
+ * invalid for the next step); that flow will not open in Studio Web until
+ * fixed.
+ *
+ * Returns `{ ok: true }` when the flow migrates cleanly, is already current,
+ * OR when the chain can't be built at all — a missing/unknown/newer-than-
+ * bundled `version` makes `migrateWorkflow` throw before running any step.
+ * That last case means the CLI's bundled migrations are out of step with the
+ * flow (version skew), which is not a flow defect we should hard-fail on.
+ */
+export declare function checkForwardMigration(rawWorkflow: MigrationWorkflow): ForwardMigrationCheck;

package/dist/services/flow-validate-service.d.ts

@@ -82,6 +82,18 @@ export declare class FlowValidateService {
     private loadCurrentManifestMap;
     private loadCurrentManifestMapUncached;
     validateFile(flowFilePath: string): Promise<FlowValidateResult>;
+    /**
+     * Forward-migration preflight (UV-15030).
+     *
+     * Studio Web runs the `@uipath/flow-migrations` chain when it opens a
+     * `.flow`; a flow that fails a migration step (e.g. 1.3->1.4) passes every
+     * structural/semantic check here yet never opens in the browser. The CLI
+     * bundles the same engine, so we run it in-memory (no write, no network)
+     * and turn a failed step into a blocking error naming the offending
+     * fields. A flow that migrates cleanly, is already current, or carries an
+     * unknown/skewed version yields no issue — see `checkForwardMigration`.
+     */
+    private validateForwardMigration;
     /**
      * For agent nodes that reference an external agent definition via a
      * `projectId` UUID, read the sibling `<uuid>/agent.json` file and

package/dist/services/packaging-utils.d.ts

@@ -55,7 +55,24 @@ export interface InlineAgentPackage {
     entryPoint: EntryPoint;
     /** The raw agent.json content (for .agent-builder/agent.json). */
     agentJson: Record<string, unknown>;
+    bindingsJson?: PackagingBindingsJson;
 }
+export interface PackagingBindingsJson extends Record<string, unknown> {
+    version: string;
+    resources: Record<string, unknown>[];
+}
+export interface PackagingArtifacts {
+    entryPoints: EntryPoint[];
+    bindingsJson: PackagingBindingsJson;
+}
+export interface PackagingArtifactOptions {
+    additionalEntryPoints?: EntryPoint[];
+    additionalBindingsJsons?: Array<PackagingBindingsJson | undefined>;
+    packageDescriptorJson?: Record<string, unknown>;
+}
+export declare function normalizePackagingBindingsJson(value: unknown): PackagingBindingsJson | undefined;
+export declare function emptyPackagingBindingsJson(): PackagingBindingsJson;
+export declare function mergePackagingBindingsJson(bindingsJsons: Array<PackagingBindingsJson | undefined>): PackagingBindingsJson;
 /**
  * Scan workflow nodes for inline agents, read their agent.json,
  * and build entry points + metadata for packaging.
@@ -71,6 +88,12 @@ export declare function packageInlineAgents(fs: IFileSystem, projectDir: string,
     inputs?: Record<string, unknown>;
     model?: Record<string, unknown>;
 }>): Promise<InlineAgentPackage[]>;
+/**
+ * Copy each referenced inline agent's directory into the staging project and
+ * write its `.agent-builder` files (agent.json + bindings.json) — the agent's
+ * runtime execution contract the runtime loads when it runs the agent.
+ */
+export declare function stageInlineAgentPackageFiles(fs: IFileSystem, sourceProjectPath: string, stagingProjectDir: string, inlineAgents: InlineAgentPackage[], formatLogMessage: (source: string) => string): Promise<void>;
 /**
  * Build inline-agent descriptors for a debug session's FpsProperties
  * injection. Mirrors flow-workbench's `extractInlineAgents` shape:
@@ -101,7 +124,8 @@ export declare function buildInlineAgentDescriptors(nodes: Array<{
  * Returns the computed entry points so callers can derive PIMS entry point paths
  * without calling getEntryPoints again.
  */
-export declare function writePackagingArtifacts(fs: IFileSystem, projectDir: string, projectId: string, packagingNodes: PackagingNode[], bindings: PackagingBinding[], variables: PackagingWorkflowVariables, bpmnFileName: string, startEventId: string, flowFileName?: string, definitions?: PackagingNodeManifest[]): Promise<EntryPoint[]>;
+export declare function writePackagingArtifacts(fs: IFileSystem, projectDir: string, projectId: string, packagingNodes: PackagingNode[], bindings: PackagingBinding[], variables: PackagingWorkflowVariables, bpmnFileName: string, startEventId: string, flowFileName?: string, definitions?: PackagingNodeManifest[], options?: PackagingArtifactOptions): Promise<EntryPoint[]>;
+export declare function writePackagingArtifactsDetailed(fs: IFileSystem, projectDir: string, projectId: string, packagingNodes: PackagingNode[], bindings: PackagingBinding[], variables: PackagingWorkflowVariables, bpmnFileName: string, startEventId: string, flowFileName?: string, definitions?: PackagingNodeManifest[], options?: PackagingArtifactOptions): Promise<PackagingArtifacts>;
 /**
  * Re-read a .flow file and regenerate bindings_v2.json in the same project directory.
  * Called after `node add` (process nodes), `node delete`, and `node configure` to