@uipath/flow-tool 1.201.0 → 1.202.0-preview.136

package/dist/packager-tool-r0xpcqwg.js

@@ -0,0 +1,188 @@
+import {
+  getEvaluatorRef,
+  isRecord,
+  stripJsonExt
+} from "./packager-tool-8j92afwp.js";
+import {
+  ensureDirectory
+} from "./packager-tool-jc34wvrw.js";
+import {
+  readUipxFile
+} from "./packager-tool-eebq62fq.js";
+import {
+  catchError
+} from "./packager-tool-5qaxht3k.js";
+
+// src/services/flow-eval-paths.ts
+function readWorkflowId(flowContent) {
+  const [parseError, parsed] = catchError(() => JSON.parse(flowContent));
+  if (parseError) {
+    return;
+  }
+  if (!isRecord(parsed) || typeof parsed.id !== "string") {
+    return;
+  }
+  if (parsed.id === "" || parsed.id.includes("/") || parsed.id.includes("\\") || parsed.id.includes("..")) {
+    return;
+  }
+  return parsed.id;
+}
+
+class FlowEvalPathResolver {
+  fs;
+  constructor(fs) {
+    this.fs = fs;
+  }
+  async resolveEvalRoot(projectPath, create) {
+    const absoluteProjectPath = await this.resolveFlowProjectPath(projectPath);
+    const scopedRoot = await this.resolveWorkflowScopedEvalRoot(absoluteProjectPath);
+    const candidates = [
+      ...scopedRoot ? [scopedRoot] : [],
+      this.fs.path.join(absoluteProjectPath, "evals", "default"),
+      this.fs.path.join(absoluteProjectPath, "evals")
+    ];
+    for (const candidate of candidates) {
+      const evalSets = this.fs.path.join(candidate, "eval-sets");
+      const evaluators = this.fs.path.join(candidate, "evaluators");
+      if (await this.fs.exists(evalSets) || await this.fs.exists(evaluators)) {
+        return candidate;
+      }
+    }
+    if (!create) {
+      return null;
+    }
+    const root = scopedRoot ?? this.fs.path.join(absoluteProjectPath, "evals", "default");
+    await ensureDirectory(this.fs, this.fs.path.join(root, "eval-sets"));
+    await ensureDirectory(this.fs, this.fs.path.join(root, "evaluators"));
+    return root;
+  }
+  async resolveFlowProjectPath(projectPath) {
+    const absolutePath = this.fs.path.resolve(projectPath);
+    if (!await this.fs.exists(absolutePath)) {
+      throw new Error(`Path ${absolutePath} does not exist. Provide --path pointing to a Flow project directory or solution directory.`);
+    }
+    const [statError, stat] = await catchError(this.fs.stat(absolutePath));
+    if (statError || !stat?.isDirectory()) {
+      throw new Error(`Path ${absolutePath} is not a directory. Provide --path pointing to a Flow project directory or solution directory.`);
+    }
+    const [flowFileError] = await catchError(this.findFlowFile(absolutePath));
+    if (!flowFileError) {
+      return absolutePath;
+    }
+    const [uipxError, uipxResult] = await catchError(readUipxFile(this.fs, absolutePath));
+    if (uipxError || !uipxResult) {
+      return absolutePath;
+    }
+    const flowProjects = uipxResult.uipx.Projects.filter((project) => project.Type === "Flow");
+    if (flowProjects.length === 0) {
+      throw new Error(`No Flow project found in solution directory ${absolutePath}. Provide --path pointing to a Flow project directory.`);
+    }
+    const flowProjectPaths = flowProjects.map((project) => this.fs.path.join(absolutePath, this.fs.path.dirname(project.ProjectRelativePath)));
+    if (flowProjects.length > 1) {
+      throw new Error(`Multiple Flow projects found in solution directory ${absolutePath}. Provide --path pointing to one of: ${flowProjectPaths.join(", ")}`);
+    }
+    return flowProjectPaths[0];
+  }
+  async resolveWorkflowScopedEvalRoot(projectPath) {
+    const [flowFileError, flowFilePath] = await catchError(this.findFlowFile(projectPath));
+    if (flowFileError) {
+      return;
+    }
+    const [readError, flowContent] = await catchError(this.fs.readFile(flowFilePath, "utf-8"));
+    if (readError) {
+      return;
+    }
+    const workflowId = readWorkflowId(String(flowContent));
+    return workflowId ? this.fs.path.join(projectPath, "evals", workflowId) : undefined;
+  }
+  async findFlowFile(projectPath) {
+    const candidates = [
+      projectPath,
+      this.fs.path.join(projectPath, "content"),
+      this.fs.path.join(projectPath, "flow_files")
+    ];
+    for (const dir of candidates) {
+      if (!await this.fs.exists(dir)) {
+        continue;
+      }
+      const stat = await this.fs.stat(dir);
+      if (!stat?.isDirectory()) {
+        continue;
+      }
+      const entries = await this.fs.readdir(dir);
+      const flowFile = entries.find((entry) => entry.endsWith(".flow"));
+      if (flowFile) {
+        return this.fs.path.join(dir, flowFile);
+      }
+    }
+    throw new Error(`No .flow file found in ${projectPath}.`);
+  }
+  async readDefaultEntryPointNodeId(projectPath) {
+    const [findError, flowFilePath] = await catchError(this.findFlowFile(projectPath));
+    if (findError || !flowFilePath) {
+      return;
+    }
+    const [readError, content] = await catchError(this.fs.readFile(flowFilePath, "utf-8"));
+    if (readError) {
+      return;
+    }
+    const [parseError, nodeId] = catchError(() => readStartNodeId(String(content)));
+    if (parseError) {
+      return;
+    }
+    return nodeId;
+  }
+}
+function readStartNodeId(flowContent) {
+  const parsed = JSON.parse(flowContent);
+  if (!isRecord(parsed) || !Array.isArray(parsed.nodes)) {
+    return;
+  }
+  const nodes = parsed.nodes.filter(isRecord);
+  const defaultEntry = nodes.find((node) => {
+    const inputs = isRecord(node.inputs) ? node.inputs : undefined;
+    if (inputs?.isDefaultEntryPoint === true) {
+      return true;
+    }
+    const model = isRecord(node.model) ? node.model : undefined;
+    return model?.isDefaultEntryPoint === true;
+  });
+  const startNode = defaultEntry ?? nodes.find((node) => {
+    const model = isRecord(node.model) ? node.model : undefined;
+    return model?.type === "bpmn:StartEvent" || node.type === "core.trigger.manual";
+  }) ?? nodes[0];
+  return typeof startNode?.id === "string" ? startNode.id : undefined;
+}
+
+// src/services/flow-eval-selectors.ts
+function findEvaluator(evaluators, idOrName) {
+  return evaluators.find((ev) => ev.id === idOrName || ev.name === idOrName || getEvaluatorRef(ev) === idOrName) ?? null;
+}
+function findEvalSet(sets, idOrName) {
+  return sets.find((set) => set.id === idOrName || set.name === idOrName || stripJsonExt(set.fileName ?? "") === idOrName) ?? null;
+}
+function getLinkedEvaluators(allEvaluators, evalSet) {
+  const refs = new Set(evalSet.evaluatorRefs.map(stripJsonExt));
+  return allEvaluators.filter((evaluator) => {
+    const candidates = [
+      evaluator.id,
+      evaluator.fileName,
+      getEvaluatorRef(evaluator)
+    ].filter((value) => value !== undefined);
+    return candidates.some((candidate) => refs.has(stripJsonExt(candidate)));
+  });
+}
+function removeEvaluatorRefFromSet(evalSet, evaluator) {
+  const removedRefs = new Set([
+    evaluator.id,
+    getEvaluatorRef(evaluator),
+    evaluator.fileName
+  ]);
+  const before = evalSet.evaluatorRefs.length;
+  evalSet.evaluatorRefs = evalSet.evaluatorRefs.filter((ref) => !removedRefs.has(ref));
+  return evalSet.evaluatorRefs.length !== before;
+}
+
+export { readWorkflowId, FlowEvalPathResolver, readStartNodeId, findEvaluator, findEvalSet, getLinkedEvaluators, removeEvaluatorRefFromSet };
+
+//# debugId=8C8FD74CA22CF5FB64756E2164756E21

package/dist/packager-tool-raq2wbwp.js

@@ -0,0 +1,18 @@
+import {
+  logger
+} from "./packager-tool-5qaxht3k.js";
+import {
+  inMemoryWorkflowToFileFormat
+} from "./packager-tool-m5qfverj.js";
+
+// src/utils/write-resolved-flow.ts
+async function writeResolvedFlow(fs, dir, name, workflow) {
+  const resolvedFileFormat = inMemoryWorkflowToFileFormat(workflow);
+  const resolvedPath = fs.path.join(dir, `${name}.flow.resolved`);
+  await fs.writeFile(resolvedPath, JSON.stringify(resolvedFileFormat, null, 2));
+  logger.info(`Resolved flow written to ${resolvedPath}`);
+}
+
+export { writeResolvedFlow };
+
+//# debugId=AE0D61ABCE2DA4C364756E2164756E21

package/dist/{packager-tool-y3dezh8k.js → packager-tool-rs6jm14d.js}

@@ -1,4 +1,4 @@
-// ../../node_modules/@uipath/flow-migrations/dist/chunk-PF22ZHE3.js
+// ../../node_modules/@uipath/flow-migrations/dist/chunk-PLXZTKXD.js
 var createMigration_invalidDownInput_message = "Invalid input for down-migration {{fromVersion}} → {{toVersion}}";
 var createMigration_invalidDownOutput_message = "Invalid output for down-migration {{fromVersion}} → {{toVersion}}";
 var createMigration_invalidInput_message = "Invalid input for migration {{fromVersion}} → {{toVersion}}";
@@ -6,6 +6,7 @@ var createMigration_invalidOutput_message = "Invalid output for migration {{from
 var downgradeWorkflow_missingDown_message = "Downgrade path is missing {{fromVersion}} → {{toVersion}}";
 var downgradeWorkflow_noPath_message = "No downgrade path from {{fromVersion}} to {{toVersion}}";
 var migrate_chain_noMigrationFound_message = "No migration found from version {{current}}. Cannot reach {{toVersion}}.";
+var migrationValidation_deprecatedNode_message = "{{label}} is on version {{currentVersion}}, which is no longer supported. Upgrade to {{latestVersion}} before running this process.";
 var en_default = {
   createMigration_invalidDownInput_message,
   createMigration_invalidDownOutput_message,
@@ -13,9 +14,10 @@ var en_default = {
   createMigration_invalidOutput_message,
   downgradeWorkflow_missingDown_message,
   downgradeWorkflow_noPath_message,
-  migrate_chain_noMigrationFound_message
+  migrate_chain_noMigrationFound_message,
+  migrationValidation_deprecatedNode_message
 };
 
-export { createMigration_invalidDownInput_message, createMigration_invalidDownOutput_message, createMigration_invalidInput_message, createMigration_invalidOutput_message, downgradeWorkflow_missingDown_message, downgradeWorkflow_noPath_message, migrate_chain_noMigrationFound_message, en_default };
+export { createMigration_invalidDownInput_message, createMigration_invalidDownOutput_message, createMigration_invalidInput_message, createMigration_invalidOutput_message, downgradeWorkflow_missingDown_message, downgradeWorkflow_noPath_message, migrate_chain_noMigrationFound_message, migrationValidation_deprecatedNode_message, en_default };
 
-//# debugId=F2DA66301ADBA78364756E2164756E21
+//# debugId=BC7DD8AD7874F44864756E2164756E21

package/dist/packager-tool-s9ff3kk4.js

@@ -0,0 +1,6 @@
+// ../../node_modules/@uipath/flow-expression-model/dist/chunk-EYTLLV4Z.js
+var EXPRESSION_MODEL_NAMESPACE = "expressionModel";
+
+export { EXPRESSION_MODEL_NAMESPACE };
+
+//# debugId=84A1129EBE7188B564756E2164756E21

package/dist/{packager-tool-pbsghbmj.js → packager-tool-sykgshez.js}

@@ -1,9 +1,9 @@
 import {
   toolsFactoryRepository
-} from "./packager-tool-7yjpwj92.js";
+} from "./packager-tool-4hx14snw.js";
 import {
   FlowToolFactory
-} from "./packager-tool-17cn3xb7.js";
+} from "./packager-tool-6m078z5s.js";
 
 // src/packager-tool.ts
 function registerPackagerFactories() {

package/dist/packager-tool-tf3d2y8z.js

@@ -0,0 +1,31 @@
+// src/utils/pending-stall.ts
+var PENDING_NORMAL_SECONDS = 60;
+var PENDING_STALLED_SECONDS = 600;
+function pendingSecondsFor(state, creationTime, now = Date.now()) {
+  if (state !== "Pending" || !creationTime) {
+    return;
+  }
+  const created = creationTime instanceof Date ? creationTime : new Date(creationTime);
+  const elapsedMs = now - created.getTime();
+  if (Number.isNaN(elapsedMs) || elapsedMs < 0) {
+    return;
+  }
+  return Math.round(elapsedMs / 1000);
+}
+function pendingStallInstructions(pendingSeconds) {
+  if (pendingSeconds >= PENDING_STALLED_SECONDS) {
+    return `Pending for ${pendingSeconds}s, past the ${PENDING_STALLED_SECONDS}s mark where the Flow runtime counts ` + `as stalled rather than slow. Stop polling this job — more polling will not start it. Check that the ` + `tenant can run Flow processes ('uip or machines list', 'uip maestro flow job list --state Pending' for ` + `a backlog), then escalate with this job key.`;
+  }
+  if (pendingSeconds >= PENDING_NORMAL_SECONDS) {
+    return `Pending for ${pendingSeconds}s. A Flow job normally starts within ${PENDING_NORMAL_SECONDS}s. Keep ` + `polling until ${PENDING_STALLED_SECONDS}s, then treat the runtime as stalled and stop.`;
+  }
+  return `Pending for ${pendingSeconds}s — normal. A Flow job usually starts within ${PENDING_NORMAL_SECONDS}s; ` + `treat it as stalled once it has been Pending for ${PENDING_STALLED_SECONDS}s.`;
+}
+
+// src/utils/wait-for-flow-job-defaults.ts
+var DEFAULT_TIMEOUT_MS = 1800000;
+var DEFAULT_INTERVAL_MS = 5000;
+
+export { PENDING_NORMAL_SECONDS, PENDING_STALLED_SECONDS, pendingSecondsFor, pendingStallInstructions, DEFAULT_TIMEOUT_MS, DEFAULT_INTERVAL_MS };
+
+//# debugId=D37FC2A9077F372264756E2164756E21

package/dist/packager-tool-tn5e7wnb.js

@@ -0,0 +1,384 @@
+import {
+  generateNodeVariables
+} from "./packager-tool-vpqyvh4c.js";
+import {
+  MINIMUM_SUPPORTED_SCHEMA_VERSION,
+  RESERVED_WORDS,
+  VALID_IDENTIFIER_PATTERN,
+  coerceInputsViaSchema,
+  createRefResolver,
+  executeWritePlan,
+  fileFormatToInMemoryWorkflow,
+  generateNextId,
+  inMemoryWorkflowToFileFormat,
+  planWriteThrough,
+  resolveAndConvertWorkflow,
+  workflowFileSchema,
+  workflowSchema
+} from "./packager-tool-m5qfverj.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// ../../node_modules/@uipath/flow-core/dist/chunk-PYGLRILU.js
+function needsBinding(manifest) {
+  const model = manifest.model;
+  if (!model)
+    return false;
+  if (model.bindings !== undefined)
+    return true;
+  const context = model.context;
+  if (!context || typeof context !== "object")
+    return false;
+  const connectionKeys = ["connection", "folderKey", "connectionId"];
+  return Object.keys(context).some((k) => connectionKeys.includes(k));
+}
+function createBinding(options) {
+  return {
+    id: generateNextId("b", 8),
+    name: options.name,
+    type: "string",
+    resource: options.resource,
+    resourceKey: options.resourceKey ?? options.resource,
+    ...options.value && { default: options.value },
+    ...options.propertyAttribute && { propertyAttribute: options.propertyAttribute },
+    ...options.resourceSubType && { resourceSubType: options.resourceSubType }
+  };
+}
+function createConnectionBinding(connectionId, connectorName) {
+  return createBinding({
+    name: connectorName,
+    value: connectorName,
+    resource: "connection",
+    resourceKey: connectionId,
+    propertyAttribute: "connection"
+  });
+}
+function createFolderKeyBinding(connectionId, folderKey) {
+  return createBinding({
+    name: folderKey,
+    value: folderKey,
+    resource: "folderKey",
+    resourceKey: connectionId,
+    propertyAttribute: "folderKey"
+  });
+}
+function addBindingIfMissing(bindings, binding) {
+  const exists = bindings.some((b) => b.name === binding.name && b.resource === binding.resource && b.resourceKey === binding.resourceKey && b.propertyAttribute === binding.propertyAttribute);
+  if (exists)
+    return bindings;
+  return [...bindings, binding];
+}
+function createBindingsFromManifest(manifest) {
+  const model = manifest.model;
+  const bindingsTemplate = model?.bindings;
+  if (!bindingsTemplate?.values)
+    return [];
+  return bindingsTemplate.values.map((v) => createBinding({
+    name: v.name,
+    value: v.default ?? "",
+    resource: bindingsTemplate.resource,
+    resourceKey: bindingsTemplate.resourceKey,
+    propertyAttribute: v.propertyAttribute,
+    resourceSubType: bindingsTemplate.resourceSubType
+  }));
+}
+
+// ../../node_modules/@uipath/flow-core/dist/chunk-GCUQRSSY.js
+var DEFAULT_TRIGGER_POSITION = { x: 256, y: 144 };
+var DEFAULT_LAYOUT_OPTIONS = {
+  algorithm: "layered",
+  direction: "RIGHT",
+  nodeSpacing: 96,
+  layerSpacing: 96,
+  minimizeCrossings: true,
+  straightenEdges: true,
+  compact: false,
+  animate: true,
+  animationDuration: 500
+};
+function resolveWidth(node) {
+  return node.measured?.width ?? node.width ?? 96;
+}
+function resolveHeight(node) {
+  return node.measured?.height ?? node.height ?? 96;
+}
+var GRID_SPACING = 16;
+function snapToGrid(value, gridSize = GRID_SPACING) {
+  return Math.round(value / gridSize) * gridSize;
+}
+
+// ../../node_modules/@uipath/flow-core/dist/index.js
+function sanitizeNodeLabel(label) {
+  const words = label.split(/[^a-zA-Z0-9]+/).filter(Boolean);
+  if (words.length === 0)
+    return "node";
+  return words.map((word, index) => {
+    const lower = word.toLowerCase();
+    if (index === 0)
+      return lower;
+    return lower.charAt(0).toUpperCase() + lower.slice(1);
+  }).join("");
+}
+function lowerCaseFirstLetter(str) {
+  if (!str)
+    return str;
+  return str.charAt(0).toLowerCase() + str.slice(1);
+}
+function generateNodeId(label, existingIds) {
+  return generateNodeIdAndName(label, existingIds).id;
+}
+function generateNodeIdAndName(label, existingIds) {
+  const idSet = existingIds instanceof Set ? existingIds : new Set(existingIds);
+  const baseId = lowerCaseFirstLetter(sanitizeNodeLabel(label).replace("createNew", ""));
+  let index = 1;
+  let candidateId = `${baseId}${index}`;
+  while (idSet.has(candidateId)) {
+    index++;
+    candidateId = `${baseId}${index}`;
+  }
+  return {
+    id: candidateId,
+    displayName: label ? index > 1 ? `${label} ${index}` : label : `Node${index > 1 ? ` ${index}` : ""}`
+  };
+}
+function validateIdFormat(id) {
+  if (!id || !id.trim()) {
+    return "ID is required";
+  }
+  const trimmed = id.trim();
+  if (!VALID_IDENTIFIER_PATTERN.test(trimmed)) {
+    if (/^\d/.test(trimmed))
+      return "ID cannot start with a number";
+    if (/\s/.test(trimmed))
+      return "ID cannot contain spaces";
+    if (/[^a-zA-Z0-9_]/.test(trimmed))
+      return "ID can only contain letters, numbers, and underscores";
+    return "ID must start with a letter or underscore";
+  }
+  if (RESERVED_WORDS.includes(trimmed)) {
+    return `"${trimmed}" is a reserved word`;
+  }
+  return;
+}
+function validateIdentifier(id, existingIds, currentNodeId) {
+  const formatError = validateIdFormat(id);
+  if (formatError)
+    return formatError;
+  const idSet = existingIds instanceof Set ? existingIds : new Set(existingIds);
+  if (currentNodeId && id === currentNodeId) {
+    return;
+  }
+  if (idSet.has(id) && id !== currentNodeId) {
+    return `ID "${id}" is already in use by a node or variable`;
+  }
+  return;
+}
+function generateEdgeId(source, sourceHandle, target, targetHandle, existingIds) {
+  const baseId = `${source}-${sourceHandle ?? "default"}-${target}-${targetHandle ?? "default"}`;
+  if (!existingIds || !existingIds.has(baseId)) {
+    return baseId;
+  }
+  let index = 2;
+  let candidateId = `${baseId}-${index}`;
+  while (existingIds.has(candidateId)) {
+    index++;
+    candidateId = `${baseId}-${index}`;
+  }
+  return candidateId;
+}
+function getInputDefaults(manifest) {
+  const raw = manifest.inputDefaults ? structuredClone(manifest.inputDefaults) : manifest.inputDefinition ? structuredClone(manifest.inputDefinition) : {};
+  const inputDefinition = manifest.inputDefinition;
+  const inputProps = inputDefinition?.properties ?? {};
+  for (const [key, value] of Object.entries(raw)) {
+    raw[key] = coerceInputsViaSchema(value, inputProps[key]);
+  }
+  return raw;
+}
+function createNodeFromManifest(manifest, id, position = { x: 0, y: 0 }, label) {
+  const manifestModel = manifest.model;
+  const inputs = getInputDefaults(manifest);
+  if (manifestModel?.entryPointId) {
+    inputs.entryPointId = crypto.randomUUID();
+  }
+  if (manifestModel?.source) {
+    inputs.source = crypto.randomUUID();
+  }
+  return {
+    id,
+    type: manifest.nodeType,
+    typeVersion: manifest.version,
+    ui: { position },
+    display: { label: label ?? manifest.display?.label ?? id },
+    inputs
+  };
+}
+function createNode(options) {
+  if (!options.typeVersion) {
+    throw new Error("createNode requires an explicit typeVersion");
+  }
+  return {
+    id: options.id,
+    type: options.type,
+    typeVersion: options.typeVersion,
+    ui: { position: options.position ?? { x: 0, y: 0 } },
+    display: { label: options.label ?? options.id },
+    inputs: options.inputs ?? {}
+  };
+}
+function createEdge(options) {
+  const sourcePort = options.sourcePort ?? "default";
+  const targetPort = options.targetPort ?? "default";
+  const id = options.id ?? generateEdgeId(options.source, sourcePort, options.target, targetPort, options.existingIds);
+  return {
+    id,
+    sourceNodeId: options.source,
+    sourcePort,
+    targetNodeId: options.target,
+    targetPort
+  };
+}
+function addDefinition(workflow, manifest) {
+  const defs = workflow.definitions;
+  const already = defs.some((d) => d.nodeType === manifest.nodeType && d.version === manifest.version);
+  if (!already) {
+    defs.push(manifest);
+  }
+}
+function addNode(workflow, manifest, id, position, label) {
+  const node = createNodeFromManifest(manifest, id, position, label);
+  if (node.inputs?.entryPointId) {
+    const hasDefault = workflow.nodes.some((n) => n.inputs?.isDefaultEntryPoint === true);
+    if (!hasDefault) {
+      node.inputs.isDefaultEntryPoint = true;
+    }
+  }
+  workflow.nodes.push(node);
+  addDefinition(workflow, manifest);
+  const manifestBindings = createBindingsFromManifest(manifest);
+  if (manifestBindings.length > 0) {
+    let bindings = workflow.bindings ?? [];
+    for (const b of manifestBindings)
+      bindings = addBindingIfMissing(bindings, b);
+    workflow.bindings = bindings;
+  }
+  workflow.variables = {
+    ...workflow.variables,
+    nodes: generateNodeVariables(workflow.nodes, workflow.definitions)
+  };
+  return node;
+}
+function createWorkflow(options) {
+  const id = options?.id ?? crypto.randomUUID();
+  const name = options?.name ?? "Untitled Workflow";
+  const nodes = [];
+  const definitions = [];
+  if (options?.triggerManifest) {
+    const triggerNode = createNodeFromManifest(options.triggerManifest, "start", { ...DEFAULT_TRIGGER_POSITION });
+    if (triggerNode.inputs?.entryPointId) {
+      triggerNode.inputs.isDefaultEntryPoint = true;
+    }
+    nodes.push(triggerNode);
+    definitions.push(options.triggerManifest);
+  }
+  return {
+    id,
+    version: MINIMUM_SUPPORTED_SCHEMA_VERSION,
+    name,
+    nodes,
+    edges: [],
+    definitions
+  };
+}
+function addEdge(workflow, options) {
+  const existingIds = new Set(workflow.edges.map((e) => e.id));
+  const edge = createEdge({ ...options, existingIds });
+  workflow.edges.push(edge);
+  return edge;
+}
+function addBinding(workflow, binding) {
+  const current = workflow.bindings ?? [];
+  const updated = addBindingIfMissing(current, binding);
+  workflow.bindings = updated;
+}
+function addVariable(workflow, variable) {
+  if (!workflow.variables) {
+    workflow.variables = { globals: [], nodes: [] };
+  }
+  if (!workflow.variables.globals) {
+    workflow.variables.globals = [];
+  }
+  workflow.variables.globals.push(variable);
+}
+var cachedNodeFs;
+async function getNodeFs() {
+  if (cachedNodeFs)
+    return cachedNodeFs;
+  const nodeFs = await import("fs");
+  cachedNodeFs = {
+    readFile: (p, enc) => nodeFs.promises.readFile(p, enc),
+    writeFile: (p, c, enc) => nodeFs.promises.writeFile(p, c, enc)
+  };
+  return cachedNodeFs;
+}
+async function readWorkflow(filePath, fs) {
+  const filesystem = fs ?? await getNodeFs();
+  const refResolver = createRefResolver((resolvedPath) => filesystem.readFile(resolvedPath, "utf-8"));
+  const content = await filesystem.readFile(filePath, "utf-8");
+  const raw = JSON.parse(content);
+  const { workflow } = await resolveAndConvertWorkflow(raw, refResolver, { baseUri: filePath });
+  return workflowSchema.parse(workflow);
+}
+async function writeWorkflow(filePath, workflow, fs) {
+  const filesystem = fs ?? await getNodeFs();
+  const fileFormat = inMemoryWorkflowToFileFormat(workflow);
+  await filesystem.writeFile(filePath, JSON.stringify(fileFormat, null, 2), "utf-8");
+}
+async function writeWorkflowWithRefs(filePath, workflow, refMap, fs) {
+  const filesystem = fs ?? await getNodeFs();
+  const fileFormat = inMemoryWorkflowToFileFormat(workflow);
+  const plan = planWriteThrough(fileFormat, refMap);
+  await executeWritePlan(plan, {
+    writeMainFile: async (content) => {
+      await filesystem.writeFile(filePath, content, "utf-8");
+    },
+    writeRefFile: async (refPath, content) => {
+      const path = await import("path");
+      const absPath = path.resolve(path.dirname(filePath), refPath);
+      await filesystem.writeFile(absPath, content, "utf-8");
+    }
+  });
+}
+function validateWorkflow(workflow) {
+  const file = workflowFileSchema.parse(workflow);
+  return fileFormatToInMemoryWorkflow(file);
+}
+function summarizeWorkflow(workflow) {
+  const nodes = workflow.nodes;
+  const edges = workflow.edges;
+  return {
+    id: workflow.id,
+    name: workflow.name,
+    version: workflow.version,
+    nodeCount: nodes.length,
+    edgeCount: edges.length,
+    nodes: nodes.map((n) => ({
+      id: n.id,
+      type: n.type,
+      label: n.display?.label
+    })),
+    edges: edges.map((e) => ({
+      source: e.sourceNodeId,
+      target: e.targetNodeId
+    })),
+    variableCount: {
+      globals: workflow.variables?.globals?.length ?? 0,
+      nodes: workflow.variables?.nodes?.length ?? 0
+    },
+    hasBindings: (workflow.bindings?.length ?? 0) > 0
+  };
+}
+export { needsBinding, createBinding, createConnectionBinding, createFolderKeyBinding, addBindingIfMissing, createBindingsFromManifest, DEFAULT_LAYOUT_OPTIONS, resolveWidth, resolveHeight, GRID_SPACING, snapToGrid, generateNodeId, generateNodeIdAndName, validateIdentifier, generateEdgeId, createNodeFromManifest, createNode, createEdge, addDefinition, addNode, createWorkflow, addEdge, addBinding, addVariable, readWorkflow, writeWorkflow, writeWorkflowWithRefs, validateWorkflow, summarizeWorkflow };
+
+//# debugId=B91CF0AAF9DF6B2D64756E2164756E21