@uipath/packager-tool-flow 1.204.0-preview.255 → 1.205.0-preview.256

package/dist/agents.d.ts

@@ -1,4 +1,5 @@
 import type { IFileSystem, IToolLogger } from "@uipath/solutionpackager-tool-core";
+import type { BindingsResource } from "./bindings.js";
 export interface InlineAgentContract {
     agentJson: Record<string, unknown>;
     bindingsJson: {
@@ -19,8 +20,13 @@ export declare function buildInlineAgentContract(config: {
     outputPath: string;
 }): Promise<InlineAgentContract>;
 /**
- * Build every root-level agent directory into the content folder and merge
- * their binding resources. Returns each built agent.json keyed by its
- * directory name (the source UUID).
+ * Build every root-level agent directory into the content folder. Return the
+ * agents and their bindings separately so Flow artifact generation cannot
+ * overwrite the agent resources before the host merges them.
  */
-export declare const processAgents: (fileSystem: IFileSystem, logger: IToolLogger, projectPath: string, contentFolder: string) => Promise<Map<string, Record<string, unknown>>>;
+export declare const processAgents: (fileSystem: IFileSystem, logger: IToolLogger, projectPath: string, contentFolder: string, context?: {
+    sharesSolutionDirectory?: boolean;
+}) => Promise<{
+    agents: Map<string, Record<string, unknown>>;
+    bindings: BindingsResource[];
+}>;

package/dist/bindings.d.ts

@@ -1,10 +1,7 @@
+import { type BindingResource } from "@uipath/flow-schema";
 import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
 import type { AgentBuildResult } from "@uipath/tool-agent/build";
-export interface BindingsResource {
-    resource: string;
-    key: string;
-    [other: string]: unknown;
-}
+export type BindingsResource = BindingResource;
 export interface Bindings {
     version: string;
     resources: BindingsResource[];
@@ -12,6 +9,10 @@ export interface Bindings {
 export declare const toBindingsResources: (result: AgentBuildResult) => BindingsResource[];
 /**
  * Merge agent binding resources into the flow's bindings_v2.json.
- * Deduplicates by (resource, key) tuple, keeping the first occurrence.
+ * Deduplicates by (resource, key) tuple, keeping the first occurrence. The
+ * resource kind is compared case-insensitively, the same rule as
+ * `mergeBindingResources` in `@uipath/flow-schema`: a Flow writes
+ * `Connection` where an agent build writes `connection`, and both name the
+ * same binding.
  */
 export declare const mergeAgentBindings: (fileSystem: IFileSystem, contentFolder: string, agentBindingResources: BindingsResource[]) => Promise<void>;

package/dist/entry-point-triggers.d.ts

@@ -0,0 +1,17 @@
+type TriggerNode = Record<string, unknown> & {
+    id: string;
+};
+/**
+ * The flow's entry-point triggers, in `nodes[]` order. `isStartEventNode` is
+ * the predicate packaging uses to find entry points, so it covers connector
+ * triggers, not just `core.trigger.*`. Pass top-level nodes only: a subflow's
+ * trigger is not an entry point of the flow.
+ */
+export declare function entryPointTriggers(nodes: readonly unknown[]): TriggerNode[];
+/**
+ * The trigger a run starts from when none is chosen: the one marked
+ * `isDefaultEntryPoint`, else the first. Studio Web writes `operate.json`
+ * `main` by the same rule. Undefined only when the flow has no trigger.
+ */
+export declare function defaultEntryPointNodeId(nodes: readonly unknown[]): string | undefined;
+export {};

package/dist/entry-point-triggers.js

@@ -0,0 +1,25 @@
+// src/entry-point-triggers.ts
+import { isStartEventNode } from "@uipath/flow-schema";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function entryPointTriggers(nodes) {
+  return nodes.filter((node) => isRecord(node) && typeof node.id === "string" && typeof node.type === "string" && isStartEventNode({
+    id: node.id,
+    type: node.type,
+    typeVersion: typeof node.typeVersion === "string" ? node.typeVersion : "1.0"
+  }));
+}
+function isDefaultEntryPoint(node) {
+  return isRecord(node.inputs) && node.inputs.isDefaultEntryPoint === true || isRecord(node.model) && node.model.isDefaultEntryPoint === true;
+}
+function defaultEntryPointNodeId(nodes) {
+  const triggers = entryPointTriggers(nodes);
+  return (triggers.find(isDefaultEntryPoint) ?? triggers[0])?.id;
+}
+export {
+  defaultEntryPointNodeId,
+  entryPointTriggers
+};
+
+//# debugId=BF641D6B3631253B64756E2164756E21

package/dist/flow-binding-resources.d.ts

@@ -0,0 +1,22 @@
+import { getBindingResources, type PackagingNode, type Workflow } from "@uipath/flow-schema";
+import type { IToolLogger } from "@uipath/solutionpackager-tool-core";
+/** The flat node shape `getEntryPoints` and `getBindingResources` read. */
+export declare function toPackagingNodes(workflow: Workflow): PackagingNode[];
+/**
+ * The binding resources a Flow's package carries in `content/bindings_v2.json`.
+ * It runs `ensureProcessBindings` on a copy first, as pack does on the `.flow`
+ * before it generates the file, and never touches the workflow it is given.
+ * Pack and the solution's resource sync both read this, so they agree.
+ *
+ * Inline-agent bindings are added by `FlowToolFactory.describeResourcesAsync`
+ * after each agent is built, using the same merge order as pack.
+ *
+ * `ensureProcessBindings` is the same safety net pack runs, with the same
+ * reach: it walks `workflow.nodes`, not `workflow.subflows[*].nodes`. A
+ * subflow node authored outside the CLI whose `<bindings.*>` placeholder was
+ * never resolved therefore gets no binding generated — here or in a package.
+ * Subflow bindings that already exist in `workflow.bindings` are read, which
+ * is what `subflows` below is for. Widening the generator would change what
+ * every package carries, so it is its own change, not this one.
+ */
+export declare function flowBindingResources(workflow: Workflow, logger: IToolLogger): ReturnType<typeof getBindingResources>;

package/dist/flow-io.d.ts

@@ -30,9 +30,12 @@ export declare function migrateRawWorkflow(raw: unknown, logger?: FlowIoLogger):
  * Build the standard `$ref` resolver for `.flow` chunk files: resolves the
  * ref path against the referencing file's directory and reads it as UTF-8
  * JSON. A missing target logs a warning (fail-soft) and resolves to `null`;
- * the resulting workflow may be partial.
+ * the resulting workflow may be partial. When staging project-owned content,
+ * pass `projectRoot` to reject references whose canonical targets escape it.
  */
-export declare function createFlowRefResolver(fs: IFileSystem, logger?: FlowIoLogger): ResolveRefCallback;
+export declare function createFlowRefResolver(fs: IFileSystem, logger?: FlowIoLogger, projectRoot?: string): ResolveRefCallback;
+/** Check source files and reference chunks before reading project-owned content. */
+export declare function resolveProjectOwnedFlowPath(fs: IFileSystem, projectRoot: string, filePath: string): Promise<string>;
 /**
  * Resolve all `$ref` chunk references in a parsed `.flow` document. Throws
  * when resolution itself errors (cycles, resolver throws); a missing target
@@ -50,7 +53,7 @@ export declare function resolveWorkflowRefs(parsed: unknown, resolver: ResolveRe
  * was, and so does text that is not JSON, for the validator to report.
  * Throws as {@link resolveWorkflowRefs} does.
  */
-export declare function inlineFlowRefs(fs: IFileSystem, content: string, filePath: string, logger?: FlowIoLogger): Promise<string>;
+export declare function inlineFlowRefs(fs: IFileSystem, content: string, filePath: string, logger?: FlowIoLogger, projectRoot?: string): Promise<string>;
 /**
  * The full read pipeline for a parsed `.flow` document: resolve `$ref`
  * chunks, project to the fleet write floor, convert to the in-memory
@@ -67,6 +70,8 @@ export interface ReadFlowWorkflowOptions {
     fs?: IFileSystem;
     /** Logger for non-fatal `$ref` resolution failures. */
     logger?: FlowIoLogger;
+    /** Bound project-owned source and chunk reads; other callers keep their existing semantics. */
+    projectRoot?: string;
 }
 /**
  * Read a `.flow` file, resolve any `$ref` chunk references, and convert
@@ -103,12 +108,13 @@ export declare function resolveProjectFlowFile(fs: IFileSystem, projectPath: str
 export declare function tryResolveProjectFlowFile(fs: IFileSystem, projectPath: string): Promise<string | undefined>;
 /**
  * Locate a flow project's `.flow` source file. Prefers the `project.uiproj`
- * `MainFile` when it names a `.flow` inside the project, then the first
- * `.flow` found in the project root, `content/`, or `flow_files/`.
+ * `MainFile` when it names a `.flow` inside the project, then a file matching
+ * `preferredBaseName` anywhere in the root, `content/`, or `flow_files/`,
+ * then the first `.flow` in that directory order.
  *
  * Studio Web-exported solutions ship the flow as `new.flow` (not
  * `<ProjectName>.flow`) with `MainFile: null`, so callers must NOT assume the
- * file is named after the project. When a directory holds multiple `.flow`s,
+ * file is named after the project. When the project holds multiple `.flow`s,
  * pass `preferredBaseName` (the project name) to disambiguate to
  * `<preferredBaseName>.flow` deterministically. Throws when no `.flow` is found.
  */
@@ -117,6 +123,11 @@ export declare function findProjectFlowFile(fs: IFileSystem, projectPath: string
  * {@link findProjectFlowFile}, except that a project with no `.flow` answers
  * `undefined` rather than throwing.
  *
+ * Select MainFile first, then the project-named file across root, content/
+ * and flow_files/, then the first fallback in that directory order. Pack,
+ * resource refresh, debug, validate and local eval preparation share this
+ * selection through the project resolvers.
+ *
  * For a caller to whom "this project has none" is an ordinary outcome — a
  * Lite or Maestro Automate project packs fine without one. Reading the
  * directory can still throw (EACCES, EIO); that is not the same answer and

package/dist/flow-tool-factory.d.ts

@@ -1,8 +1,18 @@
-import { type IFileSystem, type IProjectToolFactory, type IToolLogger, type ProjectTool, type ProjectType } from "@uipath/solutionpackager-tool-core";
+import { type IFileSystem, type IProjectToolFactory, type IToolLogger, type ProjectOperationContext, type ProjectResourceContribution, type ProjectTool, type ProjectType } from "@uipath/solutionpackager-tool-core";
 /**
  * Factory for creating Flow project tools
  */
 export declare class FlowToolFactory implements IProjectToolFactory {
     readonly supportedTypes: readonly ProjectType[];
-    createAsync(logger: IToolLogger, fileSystem: IFileSystem): Promise<ProjectTool>;
+    createAsync(logger: IToolLogger, fileSystem: IFileSystem, context?: ProjectOperationContext): Promise<ProjectTool>;
+    /**
+     * A Flow keeps its bindings in the `.flow`; node edits also maintain a
+     * derived `bindings_v2.json` beside it. Contribute the source bindings
+     * pack writes, ignoring that derived file even after a hand edit. A
+     * project with no `.flow` may use its sidecar as the authored source;
+     * pack preserves it, so the solution must read it too.
+     */
+    describeResourcesAsync(projectDir: string, fs: IFileSystem, context?: {
+        sharesSolutionDirectory: boolean;
+    }): Promise<ProjectResourceContribution>;
 }

package/dist/flow-tool.d.ts

@@ -4,8 +4,9 @@ import { type IFileSystem, type IToolLogger, ProjectTool, ToolResult } from "@ui
  * Flow project tool implementation
  */
 export declare class FlowTool extends ProjectTool {
+    private readonly solutionRoot?;
     private readonly _temporaryStorage;
-    constructor(fileSystem: IFileSystem, logger: IToolLogger);
+    constructor(fileSystem: IFileSystem, logger: IToolLogger, solutionRoot?: string | undefined);
     restoreAsync(_options: IProjectRestoreOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
     validateAsync(options: IProjectValidateOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
     /**
@@ -40,6 +41,8 @@ export declare class FlowTool extends ProjectTool {
     buildAsync(options: IProjectBuildOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
     packAsync(options: IProjectPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     dispose(): Promise<void>;
+    /** Stage the selected source last, resolving chunks before its layout changes. */
+    private stageFlowSource;
     /**
      * Read the .flow file from the content folder, resolve any unresolved
      * process bindings, and write the updated workflow back.

package/dist/flow-validation.d.ts

@@ -18,6 +18,7 @@
 import { type ParsedWorkflow, type ValidationRule, type WorkflowValidationContext, type WorkflowVariables } from "@uipath/flow-schema";
 import type { FlowValidationIssue } from "./flow-validation-hook.js";
 import { type ReadAgentJson } from "./inline-agent-utils.js";
+import { type InlineEntityCheck } from "./inline-entity-bindings.js";
 /** Graph shape shared by root workflow and each subflow entry; avoids `as ParsedWorkflow` over `unknown[]`. */
 export interface FlowGraph {
     nodes: Array<{
@@ -130,6 +131,7 @@ export declare function runDesignerRules(graph: FlowGraph, options?: DesignerRul
  * {@link parseFlowSource}, then {@link runDesignerRules} over the root graph
  * and every subflow — with each inline agent first hydrated from its
  * `agent.json` through `readAgentJson`, as the designer shows it. This is the
- * pack verdict: any `error` fails the pack.
+ * pack verdict: any `error` fails the pack. With `inlineEntities`, it also runs
+ * the unbound-entity rule ({@link inlineEntityBindingIssues}).
  */
-export declare function validateFlowSource(content: string, readAgentJson?: ReadAgentJson): Promise<FlowValidationIssue[]>;
+export declare function validateFlowSource(content: string, readAgentJson?: ReadAgentJson, inlineEntities?: InlineEntityCheck): Promise<FlowValidationIssue[]>;

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export { type AgentInputLeaf, canonicalAgentInputPath, collectAgentInputLeaves, leafToBinding, SCHEMA_CONTAINER_MARKER, } from "./agent-input-encoding-utils.js";
 export { buildInlineAgentContract, type InlineAgentContract, } from "./agents.js";
 export { createProcessBindings, ensureProcessBindings, extractProcessGuid, } from "./ensure-process-bindings.js";
+export { defaultEntryPointNodeId, entryPointTriggers, } from "./entry-point-triggers.js";
 export { replaceExporterVersion } from "./exporter-version.js";
 export { createFlowRefResolver, type FlowIoLogger, findProjectFlowFile, inlineFlowRefs, migrateRawWorkflow, readFlowWorkflow, resolveAndMigrateWorkflow, resolveProjectFlowFile, resolveWorkflowRefs, tryFindProjectFlowFile, tryResolveProjectFlowFile, } from "./flow-io.js";
 export { FlowTool } from "./flow-tool.js";
@@ -8,6 +9,8 @@ export { FlowToolFactory } from "./flow-tool-factory.js";
 export { type DesignerRuleOptions, type FlowGraph, hydrateAgentNodeInputs, type ParsedFlowSource, parseFlowSource, runDesignerRules, validateFlowSource, } from "./flow-validation.js";
 export type { FlowValidationIssue, FlowValidationSeverity, } from "./flow-validation-hook.js";
 export { type AgentInputVariable, agentJsonReader, hydrateInlineAgentInputVariables, isInlineAgentNodeType, type ReadAgentJson, readInlineAgentSource, reconcileInlineAgentInputVariables, setPublishIntentOnInlineAgents, } from "./inline-agent-utils.js";
+export { describeUnboundInlineEntity, type EntityConfig, entityScopeKey, findInlineEntity, findUnboundInlineEntityNodes, INLINE_ENTITY_UNBOUND, type InlineEntity, type InlineEntityCheck, inlineEntityBindingIssues, isEntityNodeType, type ReadInlineEntities, registeredInlineEntityReader, registerInlineEntityReader, type ScannedWorkflow, type UnboundInlineEntityNode, } from "./inline-entity-bindings.js";
 export { applyRuntimeProfile, isMaestroAutomateSentinel, RuntimeProfile, resolveRuntimeProfile, resolveRuntimeProfileForFlowFile, withRuntimeProfile, } from "./maestro-automate.js";
 export { operateRuntimeOptions } from "./operate-runtime-options.js";
+export { allNodesOf, bindingNodesOf, type FlowWithSubflows, } from "./trigger-node-types.js";
 export { assertVoiceAgentDefinitionsEmbedded, type VoiceAgentFlowNode, voiceConvertOptions, } from "./voice-agent-definitions.js";

package/dist/index.js

@@ -3,100 +3,11 @@ import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
 
 // src/flow-tool-factory.ts
 import {
-  ProjectTypes as ProjectTypes2
-} from "@uipath/solutionpackager-tool-core";
-
-// src/flow-tool.ts
-import { convertFlowToBpmn } from "@uipath/flow-converter";
-import {
-  generateBindingsJson,
-  generateEntryPointsJson,
-  generateOperateJson,
-  getBindingResources,
-  getEntryPoints,
-  inMemoryWorkflowToFileFormat,
-  ProjectType
+  mergeBindingResources as mergeBindingResources2
 } from "@uipath/flow-schema";
 import {
-  ensureProjectId,
-  NugetConstants,
-  NugetPackager,
-  Path as Path4,
-  ProjectTool,
-  ProjectTypes,
-  TemporaryStorageService,
-  ToolErrorCodes,
-  ToolResult,
-  writeContentOperateFile
+  ProjectTypes as ProjectTypes2
 } from "@uipath/solutionpackager-tool-core";
-// package.json
-var package_default = {
-  name: "@uipath/packager-tool-flow",
-  version: "1.204.0-preview.255",
-  description: "UiPath Flow tool implementation",
-  type: "module",
-  exports: {
-    ".": "./dist/index.js",
-    "./maestro-automate": "./dist/maestro-automate-entry.js"
-  },
-  repository: {
-    type: "git",
-    url: "https://github.com/UiPath/cli.git",
-    directory: "packages/packager/packager-tool-flow"
-  },
-  publishConfig: {
-    registry: "https://npm.pkg.github.com/"
-  },
-  types: "./dist/index.d.ts",
-  scripts: {
-    build: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-core --external @uipath/flow-converter --external @uipath/flow-migrations --external @uipath/flow-schema --external i18next --sourcemap=linked && bun build ./src/maestro-automate-entry.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --sourcemap=linked && tsc -p tsconfig.build.json --emitDeclarationOnly --noCheck --outDir dist",
-    typecheck: "tsc --noEmit",
-    dev: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-core --external @uipath/flow-converter --external @uipath/flow-migrations --external @uipath/flow-schema --external i18next --watch",
-    test: "vitest run",
-    "test:browser": "vitest run --config=vitest.browser.config.ts",
-    "test:coverage": "vitest run --coverage",
-    "test:browser:coverage": "vitest run --config=vitest.browser.config.ts --coverage",
-    "test:all": "bun run test && bun run test:browser",
-    "test:all:coverage": "bun run test:coverage && bun run test:browser:coverage",
-    prepack: "bun run build",
-    "publish:dry": "bun publish --dry-run",
-    "publish:gh": "bun publish",
-    "version:patch": "bun version patch --no-git-tag-version",
-    "version:minor": "bun version minor --no-git-tag-version",
-    "version:major": "bun version major --no-git-tag-version",
-    lint: "biome check ."
-  },
-  files: [
-    "dist"
-  ],
-  author: "UiPath",
-  license: "SEE LICENSE IN LICENSE.txt",
-  peerDependencies: {
-    "@uipath/filesystem": "workspace:*",
-    "@uipath/flow-converter": "0.69.3",
-    "@uipath/flow-core": "0.115.4-develop",
-    "@uipath/flow-migrations": "0.56.2",
-    "@uipath/flow-schema": "0.68.0",
-    "@uipath/solutionpackager-tool-core": "workspace:*",
-    "@uipath/tool-agent": "^2.0.0",
-    i18next: "^23.16.8"
-  },
-  devDependencies: {
-    "@types/node": "^25.5.2",
-    "@uipath/filesystem": "workspace:*",
-    "@uipath/flow-converter": "0.69.3",
-    "@uipath/flow-core": "0.115.4-develop",
-    "@uipath/solutionpackager-tool-core": "workspace:*",
-    "@uipath/tool-agent": "^2.0.0",
-    "@vitest/browser": "^4.1.11",
-    "@vitest/browser-playwright": "^4.1.11",
-    "@vitest/coverage-v8": "^4.1.11",
-    i18next: "^23.16.8",
-    playwright: "^1.57.0",
-    typescript: "^7.0.2",
-    vitest: "^4.1.11"
-  }
-};
 
 // src/agents.ts
 import {
@@ -107,6 +18,9 @@ import { Path as Path2 } from "@uipath/solutionpackager-tool-core";
 import { buildAgent } from "@uipath/tool-agent/build";
 
 // src/bindings.ts
+import {
+  mergeBindingResources
+} from "@uipath/flow-schema";
 import { Path } from "@uipath/solutionpackager-tool-core";
 var BINDINGS_V2_FILE_NAME = "bindings_v2.json";
 var toBindingsResources = (result) => result.bindings.resources.map((r) => ({ ...r }));
@@ -125,15 +39,10 @@ var mergeAgentBindings = async (fileSystem, contentFolder, agentBindingResources
       } catch {}
     }
   }
-  const dedupKey = (b) => JSON.stringify([b.resource, b.key]);
-  const seen = new Set(existing.resources.map(dedupKey));
-  for (const binding of agentBindingResources) {
-    const key = dedupKey(binding);
-    if (!seen.has(key)) {
-      seen.add(key);
-      existing.resources.push(binding);
-    }
-  }
+  existing.resources = mergeBindingResources([
+    ...existing.resources,
+    ...agentBindingResources
+  ]);
   await fileSystem.writeFile(bindingsPath, JSON.stringify(existing, null, 2));
 };
 
@@ -157,7 +66,7 @@ function healAgentInputEncoding(agent) {
   const resources = Array.isArray(rawResources) ? rawResources.map((resource) => resource && typeof resource === "object" && !Array.isArray(resource) ? healResourceInputEncoding(resource) : resource) : rawResources;
   return { ...normalized, resources };
 }
-var processAgents = async (fileSystem, logger, projectPath, contentFolder) => {
+var processAgents = async (fileSystem, logger, projectPath, contentFolder, context) => {
   const agentResults = [];
   const builtAgents = new Map;
   const entries = await fileSystem.readdir(projectPath);
@@ -167,6 +76,9 @@ var processAgents = async (fileSystem, logger, projectPath, contentFolder) => {
     if (!stat?.isDirectory()) {
       continue;
     }
+    if (context?.sharesSolutionDirectory && (await fileSystem.exists(Path2.join(sourceDir, "project.uiproj")) || await fileSystem.exists(Path2.join(sourceDir, "project.json")))) {
+      continue;
+    }
     const agentJsonPath = Path2.join(sourceDir, "agent.json");
     if (!await fileSystem.exists(agentJsonPath)) {
       continue;
@@ -187,13 +99,17 @@ var processAgents = async (fileSystem, logger, projectPath, contentFolder) => {
     agentResults.push(result);
     builtAgents.set(entry, agentJson);
   }
-  const agentBindingResources = agentResults.flatMap(toBindingsResources);
-  if (agentBindingResources.length > 0) {
-    await mergeAgentBindings(fileSystem, contentFolder, agentBindingResources);
-  }
-  return builtAgents;
+  return {
+    agents: builtAgents,
+    bindings: agentResults.flatMap(toBindingsResources)
+  };
 };
 
+// src/flow-binding-resources.ts
+import {
+  getBindingResources
+} from "@uipath/flow-schema";
+
 // src/ensure-process-bindings.ts
 import { addBinding, createBinding } from "@uipath/flow-core";
 var PROCESS_NODE_PREFIXES = [
@@ -374,8 +290,43 @@ function ensureProcessBindings(workflow, logger) {
   return bindingsCreated;
 }
 
-// src/exporter-version.ts
-var replaceExporterVersion = (bpmnXml, version) => bpmnXml.replace(/exporterVersion="development"/g, () => `exporterVersion="${version}"`);
+// src/trigger-node-types.ts
+import { collectWorkflowNodesDeep } from "@uipath/flow-schema";
+function isTriggerLikeNodeType(type) {
+  return typeof type === "string" && (type.startsWith("uipath.connector.trigger.") || type === "core.trigger.scheduled");
+}
+function bindingNodesOf(workflow) {
+  const root = new Set(workflow?.nodes ?? []);
+  return allNodesOf(workflow).filter((node) => root.has(node) || !isTriggerLikeNodeType(node.type));
+}
+function allNodesOf(workflow) {
+  const subflows = {};
+  for (const [id, subflow] of Object.entries(workflow?.subflows ?? {})) {
+    if (subflow)
+      subflows[id] = { nodes: [...subflow.nodes ?? []] };
+  }
+  return collectWorkflowNodesDeep({
+    nodes: [...workflow?.nodes ?? []],
+    subflows
+  });
+}
+
+// src/flow-binding-resources.ts
+function toPackagingNodes(workflow) {
+  return (workflow.nodes ?? []).map((node) => ({
+    id: node.id,
+    type: node.type,
+    typeVersion: node.typeVersion ?? "1.0",
+    display: node.display,
+    inputs: node.inputs,
+    outputs: node.outputs
+  }));
+}
+function flowBindingResources(workflow, logger) {
+  const copy = structuredClone(workflow);
+  ensureProcessBindings(copy, logger);
+  return getBindingResources(toPackagingNodes({ ...copy, nodes: bindingNodesOf(copy) }), copy.bindings ?? [], copy.definitions ?? [], copy.subflows);
+}
 
 // src/flow-io.ts
 import { getFileSystem } from "@uipath/filesystem";
@@ -410,9 +361,12 @@ function migrateRawWorkflow(raw, logger) {
     return raw;
   }
 }
-function createFlowRefResolver(fs, logger) {
+function createFlowRefResolver(fs, logger, projectRoot) {
   return async (refPath, baseUri) => {
-    const resolvedPath = fs.path.resolve(fs.path.dirname(baseUri), refPath);
+    let resolvedPath = fs.path.resolve(fs.path.dirname(baseUri), refPath);
+    if (projectRoot !== undefined) {
+      resolvedPath = await resolveProjectOwnedFlowPath(fs, projectRoot, resolvedPath);
+    }
     const refContent = await readUtf8OrNull(fs, resolvedPath);
     if (refContent === null) {
       logger?.warn(`Failed to resolve $ref "${refPath}": file not found at ${resolvedPath}`);
@@ -421,6 +375,17 @@ function createFlowRefResolver(fs, logger) {
     return JSON.parse(refContent);
   };
 }
+async function resolveProjectOwnedFlowPath(fs, projectRoot, filePath) {
+  const [root, target] = await Promise.all([
+    fs.realpath(fs.path.resolve(projectRoot)),
+    fs.realpath(fs.path.resolve(filePath))
+  ]);
+  const relative = fs.path.relative(root, target);
+  if (relative === ".." || relative.startsWith("../") || relative.startsWith("..\\") || fs.path.isAbsolute(relative)) {
+    throw new Error(`File resolves outside the Flow project: ${target}`);
+  }
+  return target;
+}
 async function resolveWorkflowRefs(parsed, resolver, baseUri) {
   const { resolved, refMap, errors } = await resolveRefs(parsed, resolver, {
     baseUri
@@ -431,7 +396,7 @@ async function resolveWorkflowRefs(parsed, resolver, baseUri) {
   }
   return { resolved, refMap };
 }
-async function inlineFlowRefs(fs, content, filePath, logger) {
+async function inlineFlowRefs(fs, content, filePath, logger, projectRoot) {
   if (!content.includes('"$ref"'))
     return content;
   let parsed;
@@ -440,7 +405,7 @@ async function inlineFlowRefs(fs, content, filePath, logger) {
   } catch {
     return content;
   }
-  const { resolved } = await resolveWorkflowRefs(parsed, createFlowRefResolver(fs, logger), filePath);
+  const { resolved } = await resolveWorkflowRefs(parsed, createFlowRefResolver(fs, logger, projectRoot), filePath);
   return JSON.stringify(resolved);
 }
 async function resolveAndMigrateWorkflow(parsed, resolver, baseUri, logger) {
@@ -454,8 +419,9 @@ async function resolveAndMigrateWorkflow(parsed, resolver, baseUri, logger) {
 async function readFlowWorkflow(filePath, options = {}) {
   const fs = options.fs ?? getFileSystem();
   const logger = options.logger;
-  const parsed = JSON.parse(await readUtf8(fs, filePath));
-  const { workflow } = await resolveAndMigrateWorkflow(parsed, createFlowRefResolver(fs, logger), filePath, logger);
+  const sourcePath = options.projectRoot === undefined ? filePath : await resolveProjectOwnedFlowPath(fs, options.projectRoot, filePath);
+  const parsed = JSON.parse(await readUtf8(fs, sourcePath));
+  const { workflow } = await resolveAndMigrateWorkflow(parsed, createFlowRefResolver(fs, logger, options.projectRoot), sourcePath, logger);
   return workflow;
 }
 async function readUtf8(fs, filePath) {
@@ -509,6 +475,7 @@ async function tryFindProjectFlowFile(fs, projectPath, mainFile, preferredBaseNa
     fs.path.join(projectPath, "content"),
     fs.path.join(projectPath, "flow_files")
   ];
+  let fallback;
   for (const dir of candidateDirs) {
     if (!await fs.exists(dir)) {
       continue;
@@ -521,16 +488,135 @@ async function tryFindProjectFlowFile(fs, projectPath, mainFile, preferredBaseNa
     if (flowFiles.length === 0) {
       continue;
     }
-    const chosen = (preferred && flowFiles.find((f) => f.toLowerCase() === preferred)) ?? flowFiles[0];
-    return fs.path.join(dir, chosen);
-  }
-  return;
+    const chosen = preferred && flowFiles.find((f) => f.toLowerCase() === preferred);
+    if (chosen)
+      return fs.path.join(dir, chosen);
+    fallback ??= fs.path.join(dir, flowFiles[0]);
+    if (!preferred)
+      return fallback;
+  }
+  return fallback;
 }
 function isInsideDirectory(fs, directory, candidate) {
   const relative = fs.path.relative(directory, candidate);
   return relative !== "" && !/^\.\.(?:[\\/]|$)/.test(relative) && !fs.path.isAbsolute(relative);
 }
 
+// src/flow-tool.ts
+import { convertFlowToBpmn } from "@uipath/flow-converter";
+import {
+  generateBindingsJson,
+  generateEntryPointsJson,
+  generateOperateJson,
+  getEntryPoints,
+  inMemoryWorkflowToFileFormat,
+  ProjectType
+} from "@uipath/flow-schema";
+import {
+  ensureProjectId,
+  NugetConstants,
+  NugetPackager,
+  Path as Path4,
+  ProjectTool,
+  ProjectTypes,
+  TemporaryStorageService,
+  ToolErrorCodes,
+  ToolResult,
+  writeContentOperateFile
+} from "@uipath/solutionpackager-tool-core";
+// package.json
+var package_default = {
+  name: "@uipath/packager-tool-flow",
+  version: "1.205.0-preview.256",
+  description: "UiPath Flow tool implementation",
+  type: "module",
+  exports: {
+    ".": "./dist/index.js",
+    "./maestro-automate": "./dist/maestro-automate-entry.js",
+    "./entry-point-triggers": "./dist/entry-point-triggers.js"
+  },
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/packager/packager-tool-flow"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/"
+  },
+  types: "./dist/index.d.ts",
+  scripts: {
+    build: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-core --external @uipath/flow-converter --external @uipath/flow-migrations --external @uipath/flow-schema --external i18next --sourcemap=linked && bun build ./src/maestro-automate-entry.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --sourcemap=linked && bun build ./src/entry-point-triggers.ts --outdir dist --format esm --target browser --external @uipath/flow-schema --sourcemap=linked && tsc -p tsconfig.build.json --emitDeclarationOnly --noCheck --outDir dist",
+    typecheck: "tsc --noEmit",
+    dev: "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/filesystem --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-core --external @uipath/flow-converter --external @uipath/flow-migrations --external @uipath/flow-schema --external i18next --watch",
+    test: "vitest run",
+    "test:browser": "vitest run --config=vitest.browser.config.ts",
+    "test:coverage": "vitest run --coverage",
+    "test:browser:coverage": "vitest run --config=vitest.browser.config.ts --coverage",
+    "test:all": "bun run test && bun run test:browser",
+    "test:all:coverage": "bun run test:coverage && bun run test:browser:coverage",
+    prepack: "bun run build",
+    "publish:dry": "bun publish --dry-run",
+    "publish:gh": "bun publish",
+    "version:patch": "bun version patch --no-git-tag-version",
+    "version:minor": "bun version minor --no-git-tag-version",
+    "version:major": "bun version major --no-git-tag-version",
+    lint: "biome check ."
+  },
+  files: [
+    "dist"
+  ],
+  author: "UiPath",
+  license: "SEE LICENSE IN LICENSE.txt",
+  peerDependencies: {
+    "@uipath/filesystem": "workspace:*",
+    "@uipath/flow-converter": "0.69.3",
+    "@uipath/flow-core": "^0.129.1",
+    "@uipath/flow-migrations": "^0.71.1",
+    "@uipath/flow-schema": "0.68.0",
+    "@uipath/solutionpackager-tool-core": "workspace:*",
+    "@uipath/tool-agent": "^2.0.0",
+    i18next: "^23.16.8"
+  },
+  devDependencies: {
+    "@types/node": "^25.5.2",
+    "@uipath/filesystem": "workspace:*",
+    "@uipath/flow-converter": "0.69.3",
+    "@uipath/flow-core": "^0.129.1",
+    "@uipath/solutionpackager-tool-core": "workspace:*",
+    "@uipath/tool-agent": "^2.0.0",
+    "@vitest/browser": "^4.1.11",
+    "@vitest/browser-playwright": "^4.1.11",
+    "@vitest/coverage-v8": "^4.1.11",
+    i18next: "^23.16.8",
+    playwright: "^1.57.0",
+    typescript: "^7.0.2",
+    vitest: "^4.1.11"
+  }
+};
+
+// src/entry-point-triggers.ts
+import { isStartEventNode } from "@uipath/flow-schema";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function entryPointTriggers(nodes) {
+  return nodes.filter((node) => isRecord(node) && typeof node.id === "string" && typeof node.type === "string" && isStartEventNode({
+    id: node.id,
+    type: node.type,
+    typeVersion: typeof node.typeVersion === "string" ? node.typeVersion : "1.0"
+  }));
+}
+function isDefaultEntryPoint(node) {
+  return isRecord(node.inputs) && node.inputs.isDefaultEntryPoint === true || isRecord(node.model) && node.model.isDefaultEntryPoint === true;
+}
+function defaultEntryPointNodeId(nodes) {
+  const triggers = entryPointTriggers(nodes);
+  return (triggers.find(isDefaultEntryPoint) ?? triggers[0])?.id;
+}
+
+// src/exporter-version.ts
+var replaceExporterVersion = (bpmnXml, version) => bpmnXml.replace(/exporterVersion="development"/g, () => `exporterVersion="${version}"`);
+
 // src/flow-validation.ts
 import {
   AGENT_NODE_TYPES,
@@ -550,21 +636,21 @@ import { isAgentNodeType, isVoiceAgentNodeType } from "@uipath/flow-schema";
 
 // src/agent-input-encoding-utils.ts
 var SCHEMA_CONTAINER_MARKER = "x-uipath-container";
-var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 function containerChildren(prop) {
-  if (!isRecord(prop))
+  if (!isRecord2(prop))
     return;
   if (prop[SCHEMA_CONTAINER_MARKER] !== true)
     return;
   const children = prop.properties;
-  return isRecord(children) ? children : undefined;
+  return isRecord2(children) ? children : undefined;
 }
 function canonicalAgentInputPath(name) {
   return name.split("__").join(".");
 }
 function collectAgentInputLeaves(inputSchema) {
-  const properties = isRecord(inputSchema) ? inputSchema.properties : undefined;
-  if (!isRecord(properties))
+  const properties = isRecord2(inputSchema) ? inputSchema.properties : undefined;
+  if (!isRecord2(properties))
     return [];
   const leaves = [];
   const walk = (prop, segments) => {
@@ -574,7 +660,7 @@ function collectAgentInputLeaves(inputSchema) {
       leaves.push({
         flatKey,
         path: canonicalAgentInputPath(segments.join(".")),
-        type: isRecord(prop) && typeof prop.type === "string" ? prop.type : undefined
+        type: isRecord2(prop) && typeof prop.type === "string" ? prop.type : undefined
       });
       return;
     }
@@ -688,6 +774,75 @@ function setPublishIntentOnInlineAgents(fileFormat) {
   }
 }
 
+// src/inline-entity-bindings.ts
+var READER_KEY = Symbol.for("@uipath/packager-tool-flow/readInlineEntities");
+var readerSlot = globalThis;
+function registerInlineEntityReader(reader) {
+  readerSlot[READER_KEY] = reader;
+}
+function registeredInlineEntityReader() {
+  return readerSlot[READER_KEY];
+}
+function findInlineEntity(entities, entityName) {
+  return entities.get(entityName.toLowerCase());
+}
+var ENTITY_NODE_PREFIX = "core.datafabric.";
+function isEntityNodeType(nodeType) {
+  return nodeType?.startsWith(ENTITY_NODE_PREFIX) ?? false;
+}
+function entityScopeKey(config) {
+  return typeof config?._resourceKey === "string" && config._resourceKey || typeof config?._entityKey === "string" && config._entityKey || "";
+}
+function findUnboundInlineEntityNodes(workflow, inlineEntities) {
+  if (inlineEntities.size === 0) {
+    return [];
+  }
+  const bindings = workflow.bindings ?? [];
+  const scoped = [
+    ...(workflow.nodes ?? []).map((node) => ({ node, scope: "" })),
+    ...Object.entries(workflow.subflows ?? {}).flatMap(([subflowId, sub]) => (sub.nodes ?? []).map((node) => ({
+      node,
+      scope: `subflows[${subflowId}].`
+    })))
+  ];
+  const found = [];
+  for (const { node, scope } of scoped) {
+    if (!isEntityNodeType(node.type)) {
+      continue;
+    }
+    const config = node.inputs?.entityConfig;
+    const entityName = config?.entityName;
+    if (typeof entityName !== "string" || entityName === "") {
+      continue;
+    }
+    if (findInlineEntity(inlineEntities, entityName) === undefined) {
+      continue;
+    }
+    const scopeKey = entityScopeKey(config);
+    const bound = scopeKey !== "" && bindings.some((binding) => binding.resource === "Entity" && binding.resourceKey === scopeKey && binding.propertyAttribute === "name");
+    if (!bound) {
+      found.push({ nodeId: node.id, entityName, scope });
+    }
+  }
+  return found;
+}
+var INLINE_ENTITY_UNBOUND = "INLINE_ENTITY_UNBOUND";
+function describeUnboundInlineEntity(node, flowFilePath) {
+  const problem = `Node "${node.nodeId}" names "${node.entityName}", an entity this solution authors locally, but carries no Entity binding. `;
+  const consequence = `Otherwise the entity resolves at tenant scope and the run fails as "Entity ${node.entityName} does not exist".`;
+  if (node.scope !== "") {
+    return problem + `It sits inside ${node.scope.replace(/\.$/, "")}, which 'uip maestro flow nodes configure' cannot target yet — it only resolves top-level nodes. ` + "Either move the node to the top-level graph and configure it there, or open the flow in Studio Web and re-pick the entity so the picker writes the keys. " + consequence;
+  }
+  return problem + `Run: uip maestro flow nodes configure ${flowFilePath} ${node.nodeId} --detail '{"entityName":"${node.entityName}"}' — ` + consequence;
+}
+function inlineEntityBindingIssues(workflow, inlineEntities, flowFilePath) {
+  return findUnboundInlineEntityNodes(workflow, inlineEntities).map((node) => ({
+    path: `${node.scope}nodes[${node.nodeId}].inputs.entityConfig`,
+    message: `[${INLINE_ENTITY_UNBOUND}] ${describeUnboundInlineEntity(node, flowFilePath)}`,
+    severity: "error"
+  }));
+}
+
 // src/flow-validation.ts
 var validationMessagesRegistered = false;
 function ensureValidationMessages() {
@@ -711,8 +866,8 @@ function hydrateAgentNodeInputs(node, agent) {
   const inputs = node.inputs;
   const settings = agent.settings;
   if (isVoiceAgentNodeType2(node.type)) {
-    const voiceSettings = isRecord2(settings) ? settings.voice : undefined;
-    if (isRecord2(voiceSettings) && inputs.voice === undefined) {
+    const voiceSettings = isRecord3(settings) ? settings.voice : undefined;
+    if (isRecord3(voiceSettings) && inputs.voice === undefined) {
       inputs.voice = voiceSettings;
     }
   }
@@ -756,7 +911,7 @@ async function hydrateInlineAgents(nodes, readAgentJson) {
       hydrateAgentNodeInputs(node, agent);
   }
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function parseFlowSource(content) {
@@ -803,7 +958,7 @@ function runDesignerRules(graph, options = {}) {
   const ruleErrors = runRules([...rules, conditionExpressionRule, ...options.extraRules ?? []], ctx);
   return ruleErrors.map(validationErrorToIssue);
 }
-async function validateFlowSource(content, readAgentJson) {
+async function validateFlowSource(content, readAgentJson, inlineEntities) {
   const parsed = parseFlowSource(content);
   if (!parsed.ok) {
     return parsed.issues;
@@ -830,6 +985,9 @@ async function validateFlowSource(content, readAgentJson) {
       path: `${prefix}${issue.path}`
     })));
   }
+  if (inlineEntities) {
+    issues.push(...inlineEntityBindingIssues(workflow, await inlineEntities.read(), inlineEntities.flowFilePath));
+  }
   return issues;
 }
 function extractSupportsErrorHandling(content) {
@@ -1073,9 +1231,11 @@ var FLOW_VALIDATION_SOURCE = "Validator";
 var SUBFLOW_PATH_SEGMENT = "subflows[";
 
 class FlowTool extends ProjectTool {
+  solutionRoot;
   _temporaryStorage;
-  constructor(fileSystem, logger) {
+  constructor(fileSystem, logger, solutionRoot) {
     super(fileSystem, logger);
+    this.solutionRoot = solutionRoot;
     this._temporaryStorage = new TemporaryStorageService(fileSystem);
   }
   async restoreAsync(_options, _cancellationToken) {
@@ -1094,13 +1254,19 @@ class FlowTool extends ProjectTool {
         this.logger.info("Flow project has no .flow file; skipping Flow validation");
         return ToolResult.success();
       }
-      const content = await this.fileSystem.readFile(flowFile, "utf-8");
+      const canonicalFlowFile = await resolveProjectOwnedFlowPath(this.fileSystem, projectPath, flowFile);
+      const content = await this.fileSystem.readFile(canonicalFlowFile, "utf-8");
       if (content === null) {
-        throw new Error(`Could not read ${flowFile}`);
+        throw new Error(`Could not read ${canonicalFlowFile}`);
       }
       this.logger.progress("Validating Flow project...");
-      const source = await inlineFlowRefs(this.fileSystem, content, flowFile, this.logger);
-      issues = await validateFlowSource(source, agentJsonReader(this.fileSystem, projectPath));
+      const source = await inlineFlowRefs(this.fileSystem, content, canonicalFlowFile, this.logger, projectPath);
+      const readInlineEntities = registeredInlineEntityReader();
+      const resolvedFlowFile = canonicalFlowFile;
+      issues = await validateFlowSource(source, agentJsonReader(this.fileSystem, projectPath), readInlineEntities ? {
+        flowFilePath: resolvedFlowFile,
+        read: () => readInlineEntities(this.fileSystem, resolvedFlowFile)
+      } : undefined);
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       this.logger.warn(`Could not validate the Flow project, continuing without validation: ${message}`);
@@ -1139,16 +1305,26 @@ class FlowTool extends ProjectTool {
     const localBuildFolder = Path4.join(tempFolder, NugetConstants.OutputFolderName);
     const contentFolder = Path4.join(localBuildFolder, NugetConstants.ContentFolderName);
     try {
+      const sharesSolutionDirectory = this.solutionRoot !== undefined && this.fileSystem.path.resolve(options.projectPath) === this.fileSystem.path.resolve(this.solutionRoot);
+      const sourceFlow = await tryResolveProjectFlowFile(this.fileSystem, options.projectPath);
+      const canonicalSource = sourceFlow ? await resolveProjectOwnedFlowPath(this.fileSystem, options.projectPath, sourceFlow) : undefined;
+      const flowPath = sourceFlow ? Path4.join(contentFolder, this.fileSystem.path.relative(options.projectPath, sourceFlow).replace(/^content[\\/]/, "")) : undefined;
       this.logger.progress("Copying files...");
-      await this.copyProjectFiles(options.projectPath, contentFolder);
+      await this.copyProjectFiles(options.projectPath, contentFolder, sharesSolutionDirectory);
+      if (canonicalSource && flowPath) {
+        await this.stageFlowSource(canonicalSource, flowPath, options.projectPath);
+      }
       this.logger.progress("Processing agents...");
-      const builtAgents = await processAgents(this.fileSystem, this.logger, options.projectPath, contentFolder);
+      const { agents: builtAgents, bindings: agentBindings } = await processAgents(this.fileSystem, this.logger, options.projectPath, contentFolder, { sharesSolutionDirectory });
       this.logger.progress("Resolving process bindings...");
-      await this.resolveProcessBindings(contentFolder);
+      await this.resolveProcessBindings(flowPath);
       const projectId = options.projectStorageId ?? await ensureProjectId(options.projectPath, this.fileSystem);
       const profile = await resolveRuntimeProfile(this.fileSystem, options.projectPath);
       this.logger.progress("Generating packaging artifacts from .flow...");
-      await this.generateFlowPackagingArtifacts(contentFolder, projectId, builtAgents);
+      await this.generateFlowPackagingArtifacts(contentFolder, projectId, builtAgents, flowPath);
+      if (agentBindings.length > 0) {
+        await mergeAgentBindings(this.fileSystem, contentFolder, agentBindings);
+      }
       this.logger.progress("Creating operate.json file...");
       await this.createOperateFile(contentFolder, projectId, profile);
       this.logger.progress("Creating package-descriptor.json file...");
@@ -1190,12 +1366,17 @@ class FlowTool extends ProjectTool {
       await this._temporaryStorage.cleanup();
     } catch {}
   }
-  async resolveProcessBindings(contentFolder) {
-    const entries = await this.fileSystem.readdir(contentFolder);
-    const flowFile = entries.find((e) => e.endsWith(".flow"));
-    if (!flowFile)
+  async stageFlowSource(sourcePath, targetPath, projectRoot) {
+    const source = await this.fileSystem.readFile(sourcePath, "utf-8");
+    if (source === null)
+      throw new Error(`Could not read ${sourcePath}`);
+    const inlined = await inlineFlowRefs(this.fileSystem, source, sourcePath, this.logger, projectRoot);
+    await this.fileSystem.mkdir(this.fileSystem.path.dirname(targetPath));
+    await this.fileSystem.writeFile(targetPath, inlined);
+  }
+  async resolveProcessBindings(flowPath) {
+    if (!flowPath)
       return;
-    const flowPath = Path4.join(contentFolder, flowFile);
     const flowBuffer = await this.fileSystem.readFile(flowPath);
     if (!flowBuffer)
       return;
@@ -1211,19 +1392,18 @@ class FlowTool extends ProjectTool {
       await this.fileSystem.writeFile(flowPath, JSON.stringify(workflow, null, 4));
     }
   }
-  async generateFlowPackagingArtifacts(contentFolder, projectId, builtAgents) {
-    const entries = await this.fileSystem.readdir(contentFolder);
-    const flowFile = entries.find((e) => e.endsWith(".flow"));
-    if (!flowFile) {
+  async generateFlowPackagingArtifacts(contentFolder, projectId, builtAgents, flowFilePath) {
+    if (!flowFilePath) {
       this.logger.warn("No .flow file found in content folder — skipping artifact generation");
       return;
     }
-    const flowFilePath = Path4.join(contentFolder, flowFile);
+    const flowFile = this.fileSystem.path.basename(flowFilePath);
     let workflow;
     try {
       workflow = await readFlowWorkflow(flowFilePath, {
         fs: this.fileSystem,
-        logger: this.logger
+        logger: this.logger,
+        projectRoot: contentFolder
       });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -1246,16 +1426,8 @@ class FlowTool extends ProjectTool {
     const bpmn = replaceExporterVersion(rawBpmn, package_default.version);
     assertVoiceAgentDefinitionsEmbedded(bpmn, flowNodes);
     await this.fileSystem.writeFile(bpmnPath, bpmn);
-    const packagingNodes = (workflow.nodes ?? []).map((node) => ({
-      id: node.id,
-      type: node.type,
-      typeVersion: node.typeVersion ?? "1.0",
-      display: node.display,
-      inputs: node.inputs,
-      outputs: node.outputs
-    }));
+    const packagingNodes = toPackagingNodes(workflow);
     const variables = workflow.variables ?? {};
-    const bindings = workflow.bindings ?? [];
     const definitions = workflow.definitions ?? [];
     const entryPointsPath = Path4.join(contentFolder, FlowConstants.EntryPointsFileName);
     const entryPoints = getEntryPoints(bpmnFileName, packagingNodes, variables, definitions, ProjectType.Flow);
@@ -1299,12 +1471,12 @@ class FlowTool extends ProjectTool {
     await this.fileSystem.writeFile(entryPointsPath, `${JSON.stringify(generateEntryPointsJson(allEntryPoints), null, 2)}
 `);
     const bindingsPath = Path4.join(contentFolder, FlowConstants.BindingsV2FileName);
-    const bindingResources = getBindingResources(packagingNodes, bindings, definitions);
+    const bindingResources = flowBindingResources(workflow, this.logger);
     await this.fileSystem.writeFile(bindingsPath, `${JSON.stringify(generateBindingsJson(bindingResources), null, 2)}
 `);
     const operatePath = Path4.join(contentFolder, NugetConstants.OperateFileName);
     const startEventMatch = bpmn.match(/<bpmn:startEvent\s+id="([^"]+)"/);
-    const startEventId = startEventMatch?.[1] ?? "start";
+    const startEventId = defaultEntryPointNodeId(workflow.nodes ?? []) ?? startEventMatch?.[1] ?? "start";
     const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
     const operateJson = generateOperateJson(projectId || workflow.id || "", mainEntryPoint, operateRuntimeOptions(flowNodes));
     await this.fileSystem.writeFile(operatePath, `${JSON.stringify(operateJson, null, 2)}
@@ -1346,7 +1518,7 @@ class FlowTool extends ProjectTool {
       return;
     }
   }
-  async copyProjectFiles(projectPath, contentFolder) {
+  async copyProjectFiles(projectPath, contentFolder, sharesSolutionDirectory = false) {
     await this.fileSystem.mkdir(contentFolder);
     const entries = await this.fileSystem.readdir(projectPath);
     for (const entry of entries) {
@@ -1357,7 +1529,7 @@ class FlowTool extends ProjectTool {
           await this.copyDirectoryContents(sourceEntry, contentFolder);
         }
       } else if (stat?.isFile()) {
-        if (entry === "project.uiproj" || isMaestroAutomateSentinel(entry)) {
+        if (entry === "project.uiproj" || sharesSolutionDirectory && entry === "bindings_v2.json" || isMaestroAutomateSentinel(entry)) {
           continue;
         }
         const content = await this.fileSystem.readFile(sourceEntry);
@@ -1443,10 +1615,114 @@ function toFlowFinding(issue, flowFilePath) {
 }
 
 // src/flow-tool-factory.ts
+var quietLogger = {
+  debug: () => {},
+  info: () => {},
+  warn: () => {},
+  error: () => {},
+  progress: () => {},
+  log: () => {},
+  logMessage: () => {}
+};
+async function readAuthoredSidecarBindings(fs, sidecarPath) {
+  const raw = await fs.readFile(sidecarPath, "utf-8");
+  if (raw === null)
+    throw new Error("Sidecar file is missing");
+  const parsed = JSON.parse(typeof raw === "string" ? raw : new TextDecoder().decode(raw));
+  if (typeof parsed !== "object" || parsed === null || !("resources" in parsed) || !Array.isArray(parsed.resources)) {
+    throw new Error("Expected a resources array");
+  }
+  return parsed.resources;
+}
+
 class FlowToolFactory {
   supportedTypes = [ProjectTypes2.Flow];
-  async createAsync(logger, fileSystem) {
-    return new FlowTool(fileSystem, logger);
+  async createAsync(logger, fileSystem, context) {
+    return new FlowTool(fileSystem, logger, context?.solutionRoot);
+  }
+  async describeResourcesAsync(projectDir, fs, context) {
+    let flowFile;
+    let stage = "flow";
+    try {
+      flowFile = await tryResolveProjectFlowFile(fs, projectDir);
+      const workflow = flowFile ? await readFlowWorkflow(flowFile, {
+        fs,
+        projectRoot: projectDir
+      }) : undefined;
+      stage = "agents";
+      const contentFolder = await fs.getTempDir();
+      try {
+        const { bindings: agentBindings } = await processAgents(fs, quietLogger, projectDir, contentFolder, {
+          sharesSolutionDirectory: context?.sharesSolutionDirectory
+        });
+        if (!workflow) {
+          if (context?.sharesSolutionDirectory) {
+            return { bindings: agentBindings };
+          }
+          const sidecarPath = fs.path.join(projectDir, "bindings_v2.json");
+          const hasSidecar = await fs.exists(sidecarPath);
+          if (agentBindings.length === 0) {
+            return hasSidecar ? {} : { bindings: [] };
+          }
+          stage = "sidecar";
+          const authoredBindings = hasSidecar ? await readAuthoredSidecarBindings(fs, sidecarPath) : [];
+          return {
+            bindings: mergeBindingResources2([
+              ...authoredBindings,
+              ...agentBindings
+            ])
+          };
+        }
+        return {
+          bindings: mergeBindingResources2([
+            ...flowBindingResources(workflow, quietLogger),
+            ...agentBindings
+          ])
+        };
+      } finally {
+        try {
+          await fs.rm(contentFolder);
+        } catch {}
+      }
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      if (stage === "sidecar") {
+        const sidecarPath = fs.path.join(projectDir, "bindings_v2.json");
+        return {
+          bindings: [],
+          errors: [
+            {
+              code: "sidecar_unreadable",
+              message: `${sidecarPath} could not be read: ${detail}.`,
+              instructions: `Fix ${sidecarPath}, then re-run the command.`
+            }
+          ]
+        };
+      }
+      if (stage === "agents") {
+        return {
+          bindings: [],
+          errors: [
+            {
+              code: "agent_build_failed",
+              message: `Inline agents in ${projectDir} could not be built: ${detail}.`,
+              instructions: `Fix the inline agent files in ${projectDir}, then re-run the command.`
+            }
+          ]
+        };
+      }
+      const source = flowFile ?? projectDir;
+      return {
+        bindings: [],
+        errors: [
+          {
+            code: "flow_unreadable",
+            message: `${source} could not be read as a workflow: ${detail}.`,
+            instructions: `Fix ${source} (or open it in the designer), then re-run the command.`
+          }
+        ]
+      };
+    }
   }
 }
 
@@ -1455,22 +1731,33 @@ toolsFactoryRepository.registerProjectToolFactory(new FlowToolFactory);
 export {
   FlowTool,
   FlowToolFactory,
+  INLINE_ENTITY_UNBOUND,
   RuntimeProfile,
   SCHEMA_CONTAINER_MARKER,
   agentJsonReader,
+  allNodesOf,
   applyRuntimeProfile,
   assertVoiceAgentDefinitionsEmbedded,
+  bindingNodesOf,
   buildInlineAgentContract,
   canonicalAgentInputPath,
   collectAgentInputLeaves,
   createFlowRefResolver,
   createProcessBindings,
+  defaultEntryPointNodeId,
+  describeUnboundInlineEntity,
   ensureProcessBindings,
+  entityScopeKey,
+  entryPointTriggers,
   extractProcessGuid,
+  findInlineEntity,
   findProjectFlowFile,
+  findUnboundInlineEntityNodes,
   hydrateAgentNodeInputs,
   hydrateInlineAgentInputVariables,
+  inlineEntityBindingIssues,
   inlineFlowRefs,
+  isEntityNodeType,
   isInlineAgentNodeType,
   isMaestroAutomateSentinel,
   leafToBinding,
@@ -1480,6 +1767,8 @@ export {
   readFlowWorkflow,
   readInlineAgentSource,
   reconcileInlineAgentInputVariables,
+  registerInlineEntityReader,
+  registeredInlineEntityReader,
   replaceExporterVersion,
   resolveAndMigrateWorkflow,
   resolveProjectFlowFile,
@@ -1495,4 +1784,4 @@ export {
   withRuntimeProfile
 };
 
-//# debugId=A9432E844F5B873564756E2164756E21
+//# debugId=2428956CE060A14A64756E2164756E21

package/dist/inline-entity-bindings.d.ts

@@ -0,0 +1,87 @@
+/**
+ * The unbound-entity rule: a Data Fabric node naming an entity this solution
+ * authors must carry its `bindings[]` rows, or it resolves at tenant scope and
+ * fails as `Entity <Name> does not exist`. Lives beside the designer's rules so
+ * `uip solution pack` enforces it too.
+ *
+ * The entity layout belongs to packager-tool-datafabric, which this package
+ * does not import, so flow-tool registers a reader at runtime (Hard Rule 19).
+ * No reader (Studio Web's publish) means the rule does not run.
+ */
+import type { IFileSystem, LocalEntityRef } from "@uipath/solutionpackager-tool-core";
+import type { FlowValidationIssue } from "./flow-validation-hook.js";
+/** An entity the enclosing solution authors locally. The same shape the Data
+ *  Fabric packager reads them into — shared through the packager core, since
+ *  this package does not import that one. */
+export type InlineEntity = LocalEntityRef;
+/**
+ * The solution's locally authored entities, keyed by lower-cased name (read
+ * through {@link findInlineEntity}). Referenced platform entities are absent.
+ */
+export type ReadInlineEntities = (fs: IFileSystem, flowFilePath: string) => Promise<Map<string, InlineEntity>>;
+/** Register (or, with `undefined`, clear) the entity reader. */
+export declare function registerInlineEntityReader(reader: ReadInlineEntities | undefined): void;
+/** The registered entity reader, if any tool supplied one. */
+export declare function registeredInlineEntityReader(): ReadInlineEntities | undefined;
+/**
+ * Case-insensitive lookup — entity names are solution-wide unique that way, as
+ * `findProjectsOwningEntity` assumes.
+ */
+export declare function findInlineEntity(entities: Map<string, InlineEntity>, entityName: string): InlineEntity | undefined;
+/** Whether a node type is a native Data Fabric node. The one copy of this test. */
+export declare function isEntityNodeType(nodeType: string | undefined): boolean;
+/** A node's `inputs.entityConfig` as read off a `.flow` — hence `unknown`. */
+export interface EntityConfig {
+    entityName?: unknown;
+    _resourceKey?: unknown;
+    _entityKey?: unknown;
+    _folderKey?: unknown;
+    [extra: string]: unknown;
+}
+/** The key packaging matches on — `_resourceKey`, else `_entityKey` — or `""`. */
+export declare function entityScopeKey(config: EntityConfig | null | undefined): string;
+/** A Data Fabric node that names a locally authored entity but carries no row. */
+export interface UnboundInlineEntityNode {
+    nodeId: string;
+    entityName: string;
+    /** `""` for the root graph, `subflows[<id>].` for a subflow node. */
+    scope: string;
+}
+interface ScannedNode {
+    id: string;
+    type?: string;
+    inputs?: Record<string, unknown>;
+}
+/** The slice of a workflow the rule reads. `bindings[]` is flow-wide. */
+export interface ScannedWorkflow {
+    nodes?: ScannedNode[];
+    bindings?: Array<{
+        resource?: string;
+        resourceKey?: string;
+        propertyAttribute?: string;
+    }>;
+    subflows?: Record<string, {
+        nodes?: ScannedNode[];
+    }>;
+}
+/**
+ * Nodes naming a locally authored entity with no `Entity` name row. Whole
+ * workflow, not per graph: a subflow node's rows live in the root `bindings[]`.
+ * Silent on tenant/referenced entities and on nodes with no `entityName`.
+ *
+ * Not `entityNodeIsTenantScoped` (flow-schema): it reads `_folderKey`, which an
+ * unbound local node lacks too.
+ */
+export declare function findUnboundInlineEntityNodes(workflow: ScannedWorkflow, inlineEntities: Map<string, InlineEntity>): UnboundInlineEntityNode[];
+/** The rule code `splitIssueMessage` lifts into a finding's `ErrorCode`. */
+export declare const INLINE_ENTITY_UNBOUND = "INLINE_ENTITY_UNBOUND";
+/** One line per unbound node, naming the fix that works for it. */
+export declare function describeUnboundInlineEntity(node: UnboundInlineEntityNode, flowFilePath: string): string;
+/** The rule's findings as `error` issues — an undeclared key fails at runtime. */
+export declare function inlineEntityBindingIssues(workflow: ScannedWorkflow, inlineEntities: Map<string, InlineEntity>, flowFilePath: string): FlowValidationIssue[];
+/** What `validateFlowSource` needs to run the rule, bound by its caller. */
+export interface InlineEntityCheck {
+    flowFilePath: string;
+    read: () => Promise<Map<string, InlineEntity>>;
+}
+export {};

package/dist/trigger-node-types.d.ts

@@ -0,0 +1,30 @@
+/** The only shape {@link bindingNodesOf} reads. Nullable throughout: it runs
+ *  on a `.flow` as parsed, before anything has vouched for it. */
+export interface FlowWithSubflows<N> {
+    nodes?: readonly N[] | null;
+    subflows?: Record<string, {
+        nodes?: readonly N[] | null;
+    } | undefined>;
+}
+/**
+ * The nodes `getBindingResources` needs: top-level plus every subflow's, minus
+ * subflow triggers (a subflow is invoked, not triggered). Both packaging paths
+ * call this, so they cannot disagree on the list.
+ *
+ * The walk is flow-schema's `collectWorkflowNodesDeep`, the one `flow-tool`
+ * uses too. It expects well-formed scopes, so a null scope a hand-edited
+ * `.flow` can carry is dropped first; root nodes are told apart by identity,
+ * because only a SUBFLOW's trigger is excluded.
+ */
+export declare function bindingNodesOf<N extends {
+    type?: unknown;
+}>(workflow: FlowWithSubflows<N> | null | undefined): N[];
+/**
+ * Every node in the flow, top-level then each subflow's, from a `.flow` as
+ * parsed. flow-schema's `collectWorkflowNodesDeep` does the walk but expects
+ * well-formed scopes; a hand-edited file can carry a null subflow entry or
+ * null `nodes`, and those are dropped here instead of crashing the caller.
+ * The one walk both packages use, so the guard cannot exist in one and not
+ * the other.
+ */
+export declare function allNodesOf<N>(workflow: FlowWithSubflows<N> | null | undefined): N[];

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "@uipath/packager-tool-flow",
-    "version": "1.204.0-preview.255",
+    "version": "1.205.0-preview.256",
     "description": "UiPath Flow tool implementation",
     "type": "module",
     "exports": {
         ".": "./dist/index.js",
-        "./maestro-automate": "./dist/maestro-automate-entry.js"
+        "./maestro-automate": "./dist/maestro-automate-entry.js",
+        "./entry-point-triggers": "./dist/entry-point-triggers.js"
     },
     "repository": {
         "type": "git",
@@ -22,14 +23,14 @@
     "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
     "peerDependencies": {
-        "@uipath/filesystem": "1.204.0",
+        "@uipath/filesystem": "1.205.0",
         "@uipath/flow-converter": "0.69.3",
-        "@uipath/flow-core": "0.115.4-develop",
-        "@uipath/flow-migrations": "0.56.2",
+        "@uipath/flow-core": "^0.129.1",
+        "@uipath/flow-migrations": "^0.71.1",
         "@uipath/flow-schema": "0.68.0",
-        "@uipath/solutionpackager-tool-core": "1.204.0",
+        "@uipath/solutionpackager-tool-core": "1.205.0",
         "@uipath/tool-agent": "^2.0.0",
         "i18next": "^23.16.8"
     },
-    "gitHead": "699c58dabb59414557755a8933bcbe40aa420df3"
+    "gitHead": "63740c6cbb7ff282fa9118cc16a148eb030b245f"
 }