@uipath/flow-tool 1.205.0-preview.276 → 1.206.0-preview.279

package/dist/packager-tool-5dgpfh5e.js

@@ -0,0 +1,1274 @@
+import {
+  getFileSystem
+} from "./packager-tool-vgrswa8p.js";
+import {
+  catchError2
+} from "./packager-tool-pxq0bwp0.js";
+import {
+  logger
+} from "./packager-tool-8ed52y5r.js";
+import {
+  isConversationalOrVoiceAgentNodeType2,
+  isVoiceAgentNodeType2,
+  DYNAMIC_EXTRACT_NODE_TYPE2,
+  EntryPointType2,
+  ProjectType2,
+  getBindingResources2,
+  getEntryPoints2,
+  generateOperateJson2,
+  generateBindingsJson2,
+  generateEntryPointsJson2,
+  mergeBindingResources2
+} from "./packager-tool-fzgfb0jt.js";
+import {
+  createBinding2,
+  generateNodeIdAndName2,
+  addNode2,
+  addBinding2
+} from "./packager-tool-2b0tn4p4.js";
+import {
+  buildExtractDocumentBuilderNode
+} from "./packager-tool-gdpw0daf.js";
+import {
+  isConnectorNode2,
+  getConnectorInfo2,
+  isTenantManifestInvalidError2,
+  isTenantManifestUnavailableError2,
+  getNode2
+} from "./packager-tool-kz3t4raw.js";
+import {
+  isKnownSdkNodeType2
+} from "./packager-tool-d07g2kpn.js";
+import {
+  explainNodeTypeWithoutProcessResource2
+} from "./packager-tool-a1h0q79w.js";
+import {
+  buildInlineAgentContract,
+  extractProcessGuid,
+  createProcessBindings,
+  bindingNodesOf,
+  allNodesOf,
+  readInlineAgentSource,
+  isBareProjectIdSource,
+  agentJsonReader,
+  isInlineAgentNodeType,
+  INLINE_AGENT_STRUCTURAL_INPUT_KEYS,
+  agentOutputVariablesFromSchema,
+  reconcileInlineAgentInputVariables,
+  isEntityNodeType,
+  entityScopeKey,
+  operateRuntimeOptions
+} from "./packager-tool-mdf7bws6.js";
+import {
+  readFlowWorkflow2,
+  writeFlowWorkflow2
+} from "./packager-tool-6jpvvxyb.js";
+import {
+  resolveInlineEntity2
+} from "./packager-tool-8n4bdvke.js";
+import {
+  findNodeDefinition,
+  ensureDirectory,
+  findMatchingDefinition
+} from "./packager-tool-ac6rvny7.js";
+import {
+  findFlowProjectRoot,
+  withRuntimeProfile2
+} from "./packager-tool-14rdgz3c.js";
+import {
+  defaultEntryPointNodeId
+} from "./packager-tool-jd3v0bh1.js";
+
+// src/services/connector-request-buckets.ts
+var REQUEST_BUCKETS = [
+  "bodyParameters",
+  "queryParameters",
+  "pathParameters",
+  "eventParameters"
+];
+
+// src/services/extract-schema/default-schema-document.ts
+var DEFAULT_FIELD_TYPE_DEFINITIONS = {
+  "ft-exact-text": {
+    title: "Exact Text",
+    type: ["string", "null"],
+    format: "verbatim"
+  },
+  "ft-inferred-text": {
+    title: "Inferred Text",
+    type: ["string", "null"]
+  },
+  "ft-date": {
+    title: "Date",
+    type: ["string", "null"],
+    format: "date"
+  },
+  "ft-number": {
+    title: "Number",
+    type: ["string", "null"],
+    format: "decimal"
+  },
+  "ft-monetary-quantity": {
+    title: "Monetary Quantity",
+    type: ["string", "null"],
+    format: "monetary"
+  },
+  "ft-boolean": {
+    title: "Boolean",
+    type: ["boolean", "null"]
+  }
+};
+function buildDefaultSchemaDocument() {
+  return {
+    prompt: "",
+    outputSchema: {
+      type: "object",
+      additionalProperties: false,
+      required: [],
+      properties: {},
+      $defs: structuredClone(DEFAULT_FIELD_TYPE_DEFINITIONS)
+    }
+  };
+}
+
+// src/services/inline-activity-service.ts
+import { randomUUID } from "node:crypto";
+var INLINE_ACTIVITY_TYPE_PREFIX = "uipath.connector.custom.";
+var INLINE_ACTIVITY_SOURCE = "inline";
+var INLINE_ACTIVITY_VERSION = "4.0.0";
+
+class InlineActivityError2 extends Error {
+  code = "InlineActivityInvalid";
+  instructions;
+  constructor(message, instructions) {
+    super(message);
+    this.name = "InlineActivityError";
+    this.instructions = instructions;
+  }
+}
+var asBag = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+var text = (v) => typeof v === "string" ? v : "";
+function parseInlineActivityNodeType(nodeType) {
+  if (!nodeType.startsWith(INLINE_ACTIVITY_TYPE_PREFIX)) {
+    throw new InlineActivityError2(`Node type "${nodeType}" is not a non-catalog activity type.`, `A non-catalog activity node type is "${INLINE_ACTIVITY_TYPE_PREFIX}<connector-key>.<activity-slug>", e.g. "${INLINE_ACTIVITY_TYPE_PREFIX}uipath-salesforce-slack.add-users-to-user-group".`);
+  }
+  const rest = nodeType.slice(INLINE_ACTIVITY_TYPE_PREFIX.length);
+  const dot = rest.indexOf(".");
+  const connectorKey = dot === -1 ? rest : rest.slice(0, dot);
+  const slug = dot === -1 ? "" : rest.slice(dot + 1);
+  if (!connectorKey || !slug) {
+    throw new InlineActivityError2(`Node type "${nodeType}" is missing the connector key or the activity slug.`, `Use "${INLINE_ACTIVITY_TYPE_PREFIX}<connector-key>.<activity-slug>" — both parts are required.`);
+  }
+  return { connectorKey, slug };
+}
+async function readInlineActivityMetadata(metadataFile) {
+  const fs = getFileSystem();
+  const raw = await fs.readFile(metadataFile, "utf-8");
+  if (raw === null || raw === undefined) {
+    throw new InlineActivityError2(`Activity metadata file not found: ${metadataFile}`, "Pass the <Name>.json that `uip is activities metadata generate` wrote.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(String(raw));
+  } catch (err) {
+    throw new InlineActivityError2(`Activity metadata is not valid JSON (${metadataFile}): ${err instanceof Error ? err.message : String(err)}`, "Regenerate it with `uip is activities metadata generate <min-file>` — never hand-edit generated metadata.");
+  }
+  return assertInlineActivityMetadata(parsed, metadataFile);
+}
+function assertInlineActivityMetadata(value, where) {
+  const m = asBag(value);
+  const problems = [];
+  for (const key of ["name", "elementKey", "path"]) {
+    if (!text(m[key])) {
+      problems.push(`missing top-level "${key}"`);
+    }
+  }
+  const slots = asBag(asBag(m.metadata).method);
+  const verbs = Object.keys(slots);
+  if (verbs.length !== 1) {
+    problems.push(`metadata.method must have exactly one verb slot (got ${verbs.length})`);
+  } else {
+    const slot = asBag(slots[verbs[0]]);
+    for (const key of ["operation", "method", "path", "scriptRef"]) {
+      if (!text(slot[key])) {
+        problems.push(`method ${verbs[0]}: missing "${key}"`);
+      }
+    }
+  }
+  if (problems.length > 0) {
+    throw new InlineActivityError2(`Activity metadata is not a v4 activity (${where}):
+  - ${problems.join(`
+  - `)}`, "Regenerate it with `uip is activities metadata generate <min-file>`; this command reads the file that writes.");
+  }
+  return m;
+}
+function verbSlotOf(metadata) {
+  const verb = Object.keys(metadata.metadata.method)[0];
+  return { verb, slot: metadata.metadata.method[verb] };
+}
+function collectScriptRefs(metadata) {
+  const { slot } = verbSlotOf(metadata);
+  const lookups = [];
+  const add = (ref) => {
+    const r = text(ref);
+    if (r && r !== slot.scriptRef && !lookups.includes(r)) {
+      lookups.push(r);
+    }
+  };
+  for (const p of slot.parameters ?? []) {
+    add(asBag(p.reference).scriptRef);
+  }
+  for (const f of Object.values(metadata.fields ?? {})) {
+    add(asBag(asBag(f).reference).scriptRef);
+  }
+  return { main: slot.scriptRef, lookups };
+}
+async function readInlineScripts(scriptsDir, refs) {
+  const fs = getFileSystem();
+  const scripts = {};
+  const missing = [];
+  for (const ref of refs) {
+    const file = fs.path.join(scriptsDir, `${ref}.js`);
+    const source = await fs.readFile(file, "utf-8");
+    if (source === null || source === undefined) {
+      missing.push(file);
+      continue;
+    }
+    scripts[ref] = String(source);
+  }
+  if (missing.length > 0) {
+    throw new InlineActivityError2(`Action script(s) not found:
+  - ${missing.join(`
+  - `)}`, "Every scriptRef in the metadata — the main action and each lookup reference — needs a <scriptRef>.js in --scripts. Generate the missing script, or fix the scriptRef in the min-file and regenerate.");
+  }
+  return scripts;
+}
+function buildInlineActivityDefinition(args) {
+  const { nodeType, connectorKey, metadata, activityTypeId } = args;
+  const { slot } = verbSlotOf(metadata);
+  const label = metadata.displayName ?? metadata.name;
+  const description = metadata.description ?? "";
+  const configuration = {
+    connectorKey,
+    objectName: metadata.name,
+    httpMethod: slot.method,
+    activityType: "Curated",
+    activitySource: INLINE_ACTIVITY_SOURCE,
+    version: INLINE_ACTIVITY_VERSION,
+    operation: slot.operation,
+    supportsStreaming: false,
+    subType: "standard"
+  };
+  const manifest = {
+    nodeType,
+    version: INLINE_ACTIVITY_VERSION,
+    category: `connector.${connectorKey}`,
+    tags: ["connector", "activity", INLINE_ACTIVITY_SOURCE],
+    sortOrder: 1,
+    supportsErrorHandling: true,
+    description,
+    display: {
+      label,
+      description,
+      sourceDisplayName: connectorKey
+    },
+    handleConfiguration: [
+      {
+        position: "left",
+        handles: [
+          {
+            id: "input",
+            type: "target",
+            handleType: "input",
+            label: ""
+          }
+        ]
+      },
+      {
+        position: "right",
+        handles: [
+          {
+            id: "output",
+            type: "source",
+            handleType: "output",
+            label: ""
+          }
+        ]
+      }
+    ],
+    model: {
+      type: "bpmn:SendTask",
+      serviceType: "Intsvc.ActivityExecution",
+      bindings: {
+        resource: "Connection",
+        resourceKey: "",
+        values: [
+          {
+            name: `${connectorKey} connection`,
+            propertyAttribute: "ConnectionId"
+          },
+          { name: "FolderKey", propertyAttribute: "FolderKey" }
+        ]
+      },
+      context: [
+        { name: "connectorKey", type: "string", value: connectorKey },
+        { name: "operation", type: "string", value: slot.operation },
+        { name: "objectName", type: "string", value: metadata.name },
+        { name: "method", type: "string", value: slot.method },
+        {
+          name: "connection",
+          type: "string",
+          value: `<bindings.${connectorKey} connection>`
+        },
+        {
+          name: "folderKey",
+          type: "string",
+          value: "<bindings.FolderKey>"
+        },
+        {
+          name: "activityConfigurationVersion",
+          type: "string",
+          value: "v1"
+        },
+        {
+          name: "metadata",
+          type: "json",
+          body: {
+            telemetryData: {
+              connectorKey,
+              connectorName: label
+            },
+            inputMetadata: {},
+            errorState: { hasError: true }
+          }
+        }
+      ]
+    },
+    form: {
+      id: "connector-properties",
+      title: "Connector configuration",
+      sections: [
+        {
+          id: "connector",
+          title: "Connector",
+          collapsible: true,
+          defaultExpanded: true,
+          fields: [
+            {
+              label: "",
+              name: "inputs.detail",
+              type: "custom",
+              component: "dap-config",
+              componentProps: {
+                connectorDetail: {
+                  uiPathActivityTypeId: activityTypeId,
+                  displayName: label,
+                  description,
+                  configuration: JSON.stringify(configuration)
+                }
+              }
+            }
+          ]
+        }
+      ]
+    },
+    inputDefinition: {},
+    inputDefaults: {},
+    outputDefinition: {
+      output: {
+        type: "object",
+        description: "The return value of the connector.",
+        source: "=result.response",
+        var: "output"
+      }
+    },
+    debug: { runtime: "bpmnEngine" }
+  };
+  return manifest;
+}
+async function prepareInlineActivity(nodeType, input) {
+  const { connectorKey } = parseInlineActivityNodeType(nodeType);
+  const metadata = await readInlineActivityMetadata(input.metadataFile);
+  if (metadata.elementKey !== connectorKey) {
+    throw new InlineActivityError2(`Node type names connector "${connectorKey}" but the metadata was generated for "${metadata.elementKey}".`, `Use "${INLINE_ACTIVITY_TYPE_PREFIX}${metadata.elementKey}.<activity-slug>", or regenerate the metadata for "${connectorKey}".`);
+  }
+  const { main, lookups } = collectScriptRefs(metadata);
+  const scripts = await readInlineScripts(input.scriptsDir, [
+    main,
+    ...lookups
+  ]);
+  const manifest = buildInlineActivityDefinition({
+    nodeType,
+    connectorKey,
+    metadata,
+    activityTypeId: randomUUID()
+  });
+  return {
+    manifest,
+    connectorKey,
+    configuration: { metadata, scriptRef: main, scripts }
+  };
+}
+function getInlineActivityConfiguration(node) {
+  const raw = node.inputs?.inlineActivityConfiguration;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    return;
+  }
+  return raw;
+}
+function definitionConfigurationOf(definition) {
+  const form = asBag(definition.form);
+  for (const section of form.sections ?? []) {
+    for (const field of asBag(section).fields ?? []) {
+      const detail = asBag(asBag(asBag(field).componentProps).connectorDetail);
+      if (typeof detail.configuration === "string") {
+        return detail.configuration;
+      }
+    }
+  }
+  return;
+}
+
+// src/services/orchestrator-connection-field.ts
+var ORCHESTRATOR_CONNECTION_PICKER = "orchestrator-connection-picker";
+function findOrchestratorConnectionField(definitions, node) {
+  const definition = findNodeDefinition(definitions, node);
+  const form = definition?.form;
+  for (const section of form?.sections ?? []) {
+    for (const field of section.fields ?? []) {
+      if (field.name !== "inputs.connectionId" || field.component !== ORCHESTRATOR_CONNECTION_PICKER) {
+        continue;
+      }
+      const props = field.componentProps ?? {};
+      if (typeof props.connectorKey === "string" && typeof props.bindingConnectorKey === "string") {
+        return {
+          connectorKey: props.connectorKey,
+          bindingConnectorKey: props.bindingConnectorKey
+        };
+      }
+    }
+  }
+  return;
+}
+function orchestratorConnectionKey(definitions, node) {
+  if (!findOrchestratorConnectionField(definitions, node))
+    return;
+  const id = node.inputs?.connectionId;
+  return typeof id === "string" && id.length > 0 ? id : undefined;
+}
+
+// src/services/packaging-utils.ts
+function fileNodesToPackagingNodes(nodes) {
+  return nodes.map((node) => ({
+    id: node.id,
+    type: node.type,
+    typeVersion: node.typeVersion ?? "1.0",
+    display: node.display,
+    inputs: node.inputs,
+    outputs: node.outputs,
+    ...node.model ? { model: node.model } : {}
+  }));
+}
+function flowToPackagingNodes(workflow) {
+  return fileNodesToPackagingNodes(bindingNodesOf(workflow));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toResourceList(value) {
+  if (!Array.isArray(value))
+    return;
+  const resources = value.filter(isRecord);
+  return resources.length === value.length ? resources : undefined;
+}
+function normalizePackagingBindingsJson(value) {
+  if (!isRecord(value))
+    return;
+  const resources = toResourceList(value.resources);
+  if (!resources)
+    return;
+  return {
+    ...value,
+    version: typeof value.version === "string" ? value.version : "2.0",
+    resources
+  };
+}
+function emptyPackagingBindingsJson() {
+  return { version: "2.0", resources: [] };
+}
+function mergePackagingBindingsJson(bindingsJsons) {
+  const first = bindingsJsons.find((bindingsJson) => bindingsJson !== undefined);
+  return {
+    ...first ?? emptyPackagingBindingsJson(),
+    resources: mergeBindingResources2(bindingsJsons.flatMap((bindingsJson) => bindingsJson?.resources ?? []))
+  };
+}
+var inlineAgentPackagerLogger = {
+  debug: (message) => logger.debug(message),
+  info: (message) => logger.info(message),
+  warn: (message) => logger.warn(message),
+  error: (message) => logger.error(message),
+  progress: (message) => logger.info(message),
+  log: (message, level) => {
+    if (level === "Error" /* Error */)
+      logger.error(message);
+    else if (level === "Warning" /* Warn */)
+      logger.warn(message);
+    else if (level === "Debug" /* Debug */)
+      logger.debug(message);
+    else
+      logger.info(message);
+  },
+  logMessage: (message) => inlineAgentPackagerLogger.log(message.message, message.logLevel)
+};
+async function createInlineAgentContract(fs, agentDir) {
+  const outputPath = fs.path.join(fs.env.tmpdir(), `.inline-agent-contract-${crypto.randomUUID()}`);
+  await fs.mkdir(outputPath);
+  try {
+    const built = await buildInlineAgentContract({
+      fileSystem: fs,
+      logger: inlineAgentPackagerLogger,
+      projectPath: agentDir,
+      outputPath
+    });
+    const bindingsJson = normalizePackagingBindingsJson(built.bindingsJson);
+    if (!bindingsJson) {
+      throw new Error("Agent packager returned an invalid binding contract");
+    }
+    return { agentJson: built.agentJson, bindingsJson };
+  } finally {
+    const [cleanupError] = await catchError2(fs.rm(outputPath));
+    if (cleanupError) {
+      logger.debug(`Could not remove inline-agent contract directory ${outputPath}: ${cleanupError.message}`);
+    }
+  }
+}
+async function inlineAgentExists(fs, projectDir, source) {
+  const agentJsonPath = fs.path.join(projectDir, source, "agent.json");
+  return fs.exists(agentJsonPath);
+}
+async function packageInlineAgents(fs, projectDir, nodes) {
+  const result = [];
+  const seen = new Set;
+  for (const node of nodes) {
+    if (!isInlineAgentNodeType(node.type))
+      continue;
+    const source = readInlineAgentSource(node);
+    if (!source)
+      continue;
+    if (!isBareProjectIdSource(source))
+      continue;
+    if (seen.has(source))
+      continue;
+    seen.add(source);
+    if (!await inlineAgentExists(fs, projectDir, source))
+      continue;
+    const contract = await createInlineAgentContract(fs, fs.path.join(projectDir, source));
+    const inputSchema = contract.agentJson.inputSchema ?? {
+      type: "object",
+      properties: {}
+    };
+    const outputSchema = contract.agentJson.outputSchema ?? {
+      type: "object",
+      properties: {}
+    };
+    result.push({
+      source,
+      entryPoint: {
+        filePath: `content/${source}/agent.json`,
+        uniqueId: contract.agentJson.projectId ?? source,
+        type: EntryPointType2.Agent,
+        input: inputSchema,
+        output: outputSchema,
+        displayName: contract.agentJson.name ?? "Agent"
+      },
+      agentJson: contract.agentJson,
+      bindingsJson: contract.bindingsJson
+    });
+    logger.info(`Packaged inline agent "${source}" for entry-points`);
+  }
+  return result;
+}
+async function stageInlineAgentPackageFiles(fs, sourceProjectPath, stagingProjectDir, inlineAgents, formatLogMessage) {
+  for (const agent of inlineAgents) {
+    const srcDir = fs.path.join(sourceProjectPath, agent.source);
+    const destDir = fs.path.join(stagingProjectDir, agent.source);
+    if (fs.path.resolve(srcDir) !== fs.path.resolve(destDir) && await fs.exists(srcDir)) {
+      await fs.copyDirectory(srcDir, destDir);
+    }
+    const agentBuilderDir = fs.path.join(destDir, ".agent-builder");
+    await ensureDirectory(fs, agentBuilderDir);
+    await fs.writeFile(fs.path.join(agentBuilderDir, "agent.json"), JSON.stringify({
+      ...agent.agentJson,
+      resources: agent.agentJson.resources ?? [],
+      features: agent.agentJson.features ?? []
+    }, null, 2));
+    await fs.writeFile(fs.path.join(agentBuilderDir, "bindings.json"), `${JSON.stringify(agent.bindingsJson ?? emptyPackagingBindingsJson(), null, 2)}
+`);
+    logger.info(formatLogMessage(agent.source));
+  }
+}
+function buildInlineAgentDescriptors(nodes) {
+  const out = [];
+  const seen = new Set;
+  for (const node of nodes) {
+    if (!isInlineAgentNodeType(node.type))
+      continue;
+    const source = readInlineAgentSource(node);
+    if (!source)
+      continue;
+    if (seen.has(source))
+      continue;
+    seen.add(source);
+    const label = node.display?.label ?? "Agent";
+    out.push({
+      name: label,
+      agentProjectId: source,
+      isConversational: isConversationalOrVoiceAgentNodeType2(node.type),
+      entryPointPath: `${source}/agent.json`
+    });
+  }
+  return out;
+}
+async function writePackagingArtifacts(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions = [], options = {}) {
+  const { entryPoints } = await writePackagingArtifactsDetailed(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions, options);
+  return entryPoints;
+}
+async function writePackagingArtifactsDetailed(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions = [], options = {}) {
+  const startNodes = options.entryPointNodes ?? packagingNodes;
+  const flowEntryPoints = getEntryPoints2(bpmnFileName, startNodes, variables, definitions, ProjectType2.Flow);
+  const entryPoints = [
+    ...flowEntryPoints,
+    ...options.additionalEntryPoints ?? []
+  ];
+  await fs.writeFile(fs.path.join(projectDir, "entry-points.json"), `${JSON.stringify(generateEntryPointsJson2(entryPoints), null, 2)}
+`);
+  const bindingResources = getBindingResources2(packagingNodes, bindings, definitions);
+  const bindingsJson = normalizePackagingBindingsJson(generateBindingsJson2(bindingResources)) ?? emptyPackagingBindingsJson();
+  const stagedBindingsJson = mergePackagingBindingsJson([
+    bindingsJson,
+    ...options.additionalBindingsJsons ?? []
+  ]);
+  await fs.writeFile(fs.path.join(projectDir, "bindings_v2.json"), `${JSON.stringify(stagedBindingsJson, null, 2)}
+`);
+  const mainEntryPoint = `/${bpmnFileName}#${defaultEntryPointNodeId(startNodes) ?? startEventId}`;
+  const operateJson = withRuntimeProfile2(generateOperateJson2(projectId, mainEntryPoint, operateRuntimeOptions(startNodes)), options.profile ?? "Standard" /* Standard */);
+  await fs.writeFile(fs.path.join(projectDir, "operate.json"), `${JSON.stringify(operateJson, null, 2)}
+`);
+  const packageDescriptorJson = options.packageDescriptorJson ?? {
+    $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+    files: {
+      "operate.json": "operate.json",
+      "entry-points.json": "entry-points.json",
+      "bindings.json": "bindings_v2.json",
+      [bpmnFileName]: bpmnFileName,
+      ...flowFileName ? { [flowFileName]: flowFileName } : {}
+    }
+  };
+  await fs.writeFile(fs.path.join(projectDir, "package-descriptor.json"), `${JSON.stringify(packageDescriptorJson, null, 2)}
+`);
+  return { entryPoints, bindingsJson: stagedBindingsJson };
+}
+function backfillNodeModelsFromDefinitions(nodes, definitions) {
+  if (definitions.length === 0)
+    return nodes;
+  const definitionByType = new Map;
+  for (const def of definitions) {
+    if (def?.nodeType)
+      definitionByType.set(def.nodeType, def);
+  }
+  return nodes.map((n) => {
+    if (n.model)
+      return n;
+    const def = definitionByType.get(n.type);
+    if (!def?.model)
+      return n;
+    return { ...n, model: def.model };
+  });
+}
+async function regenerateBindingsFile(fs, flowFilePath) {
+  const absolutePath = fs.path.resolve(flowFilePath);
+  const projectDir = fs.path.dirname(absolutePath);
+  const [readErr, read] = await catchError2(readFlowWorkflow2(absolutePath, fs));
+  if (readErr) {
+    throw new Error(`Failed to read .flow file at ${absolutePath}: ${readErr.message}`);
+  }
+  const flowData = read.workflow;
+  const packagingNodes = backfillNodeModelsFromDefinitions(flowToPackagingNodes(flowData), flowData.definitions ?? []);
+  const bindingResources = getBindingResources2(packagingNodes, flowData.bindings ?? [], flowData.definitions ?? []);
+  const flowBindingsJson = normalizePackagingBindingsJson(generateBindingsJson2(bindingResources)) ?? emptyPackagingBindingsJson();
+  const [agentErr, inlineAgents] = await catchError2(packageInlineAgents(fs, projectDir, allNodesOf(flowData)));
+  if (agentErr) {
+    logger.warn(`Wrote bindings_v2.json without inline agent tool bindings: ${agentErr.message}`);
+  }
+  await fs.writeFile(fs.path.join(projectDir, "bindings_v2.json"), `${JSON.stringify(mergePackagingBindingsJson([
+    flowBindingsJson,
+    ...(inlineAgents ?? []).map((agent) => agent.bindingsJson)
+  ]), null, 2)}
+`);
+}
+// src/services/node-service.ts
+class NodeTypeNotFoundError2 extends Error {
+  code = "NodeTypeNotFound";
+  instructions;
+  constructor(message, instructions) {
+    super(message);
+    this.name = "NodeTypeNotFoundError";
+    this.instructions = instructions;
+  }
+}
+
+class NodeTypeNotEnabledError2 extends Error {
+  code = "NodeTypeNotEnabled";
+  instructions;
+  constructor(message, instructions) {
+    super(message);
+    this.name = "NodeTypeNotEnabledError";
+    this.instructions = instructions;
+  }
+}
+
+class SourceRequiredError2 extends Error {
+  code = "SourceRequired";
+  instructions;
+  constructor(message, instructions) {
+    super(message);
+    this.name = "SourceRequiredError";
+    this.instructions = instructions;
+  }
+}
+var listNodesInFlow2 = async (filePath) => {
+  const { workflow } = await readFlowWorkflow2(filePath);
+  const nodes = workflow.nodes.map((n) => ({
+    id: n.id,
+    type: n.type,
+    label: n.display.label ?? "",
+    position: n.ui.position
+  }));
+  return { nodes, count: nodes.length };
+};
+var PROCESS_NODE_PREFIXES = [
+  "uipath.core.rpa-workflow.",
+  "uipath.agent.resource.tool.process.",
+  "uipath.core.agent.",
+  "uipath.core.api-workflow."
+];
+function isProcessNode2(manifest) {
+  return PROCESS_NODE_PREFIXES.some((prefix) => manifest.nodeType?.startsWith(prefix));
+}
+function isEntityNode2(manifest) {
+  return isEntityNodeType(manifest.nodeType);
+}
+function createEntityBindings2(node) {
+  const entityConfig = node.inputs?.entityConfig;
+  const entityName = entityConfig?.entityName;
+  if (typeof entityName !== "string" || entityName === "")
+    return [];
+  const scopeKey = entityScopeKey(entityConfig);
+  if (!scopeKey)
+    return [];
+  const bindings = [
+    createBinding2({
+      name: entityName,
+      value: entityName,
+      resource: "Entity",
+      resourceKey: scopeKey,
+      propertyAttribute: "name"
+    })
+  ];
+  const folderKey = entityConfig?._folderKey;
+  if (typeof folderKey === "string" && folderKey !== "") {
+    bindings.push(createBinding2({
+      name: `${entityName}Folder`,
+      value: folderKey,
+      resource: "Entity",
+      resourceKey: scopeKey,
+      propertyAttribute: "folderKey"
+    }));
+  }
+  return bindings;
+}
+async function resolveEntityIdentity2(filePath, node) {
+  const entityConfig = node.inputs?.entityConfig;
+  const entityName = entityConfig?.entityName;
+  if (entityConfig == null || typeof entityName !== "string" || entityName === "") {
+    return;
+  }
+  const entity = await resolveInlineEntity2(getFileSystem(), filePath, entityName);
+  if (entity === undefined) {
+    return;
+  }
+  const current = entityScopeKey(entityConfig);
+  if (current !== "" && current !== entity.resourceKey) {
+    return;
+  }
+  entityConfig.entityName = entity.name;
+  if (current === "") {
+    entityConfig._resourceKey = entity.resourceKey;
+    entityConfig._folderKey = entity.folderId;
+  }
+}
+function resolveProcessTarget2(node, definitions) {
+  if (!isProcessNode2({ nodeType: node.type }))
+    return;
+  let subType = "Process";
+  if (definitions) {
+    const def = findMatchingDefinition(node.type, node.typeVersion, definitions);
+    const model = def?.model;
+    const defBindings = model?.bindings;
+    if (defBindings?.resourceSubType)
+      subType = defBindings.resourceSubType;
+    if (defBindings?.resourceKey) {
+      return { key: defBindings.resourceKey, subType };
+    }
+  }
+  return { key: extractProcessGuid(node.type), subType };
+}
+function resolveProcessTargetKey(node, definitions) {
+  return resolveProcessTarget2(node, definitions)?.key;
+}
+async function writeInlineAgentStepFromAgent(node, filePath, outputsFromInput) {
+  const inputs = node.inputs;
+  for (const key of Object.keys(inputs)) {
+    if (!INLINE_AGENT_STRUCTURAL_INPUT_KEYS.has(key) && !(key === "callContext" && isVoiceAgentNodeType2(node.type))) {
+      delete inputs[key];
+    }
+  }
+  const source = inputs.source;
+  if (typeof source !== "string" || /[/\\.]/.test(source)) {
+    return;
+  }
+  const fs = getFileSystem();
+  const projectRoot = await findFlowProjectRoot(fs, filePath);
+  const agent = await agentJsonReader(fs, projectRoot)(source);
+  if (agent) {
+    const existing = Array.isArray(inputs.agentInputVariables) ? inputs.agentInputVariables : [];
+    inputs.agentInputVariables = reconcileInlineAgentInputVariables(existing, agent.inputSchema).variables;
+    const metadata = agent.metadata;
+    if (!outputsFromInput && inputs.agentOutputVariables !== undefined) {
+      inputs.agentOutputVariables = agentOutputVariablesFromSchema(agent.outputSchema, metadata?.isConversational === true);
+    }
+  }
+}
+function resolveProcessBindingsInContext(node, nameBinding, folderBinding) {
+  const model = node.model;
+  if (!model?.context)
+    return;
+  for (const entry of model.context) {
+    if (entry.name === "name" && typeof entry.value === "string") {
+      entry.default = nameBinding.default;
+      entry.value = `=bindings.${nameBinding.id}`;
+    } else if (entry.name === "folderPath" && typeof entry.value === "string") {
+      entry.default = folderBinding.default;
+      entry.value = `=bindings.${folderBinding.id}`;
+    }
+  }
+}
+var UNRESOLVED_BINDING_PATTERN = /^<bindings\.\w+>$/;
+function ensureProcessBindings2(workflow) {
+  const nodes = workflow.nodes;
+  const definitions = workflow.definitions ?? [];
+  let bindingsCreated = 0;
+  for (const node of nodes) {
+    if (!isProcessNode2({ nodeType: node.type }))
+      continue;
+    const nodeModel = node.model;
+    const defModel = definitions.find((d) => d.nodeType === node.type)?.model;
+    const hasUnresolved = [nodeModel, defModel].some((m) => m?.context?.some((entry) => typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)));
+    if (!hasUnresolved)
+      continue;
+    const definition = definitions.find((d) => d.nodeType === node.type);
+    if (!definition)
+      continue;
+    const [err, bindings] = catchError2(() => createProcessBindings({
+      nodeType: node.type,
+      model: definition.model
+    }));
+    if (err) {
+      logger.warn(`Skipping binding resolution for node "${node.id}": ${err.message}`);
+      continue;
+    }
+    const { nameBinding, folderBinding } = bindings;
+    const beforeCount = workflow.bindings?.length ?? 0;
+    addBinding2(workflow, nameBinding);
+    addBinding2(workflow, folderBinding);
+    const storedBindings = workflow.bindings;
+    const storedName = storedBindings.find((b) => b.resourceKey === nameBinding.resourceKey && b.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
+    const storedFolder = storedBindings.find((b) => b.resourceKey === folderBinding.resourceKey && b.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
+    resolveProcessBindingsInContext(node, storedName, storedFolder);
+    if (defModel?.context) {
+      for (const entry of defModel.context) {
+        if (entry.name === "name" && typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)) {
+          entry.default = storedName.default;
+          entry.value = `=bindings.${storedName.id}`;
+        } else if (entry.name === "folderPath" && typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)) {
+          entry.default = storedFolder.default;
+          entry.value = `=bindings.${storedFolder.id}`;
+        }
+      }
+    }
+    const added = (workflow.bindings?.length ?? 0) - beforeCount;
+    bindingsCreated += added;
+    logger.info(`Resolved process bindings for node "${node.id}" (${node.type})`);
+  }
+  if (bindingsCreated > 0) {
+    logger.info(`ensureProcessBindings: created ${bindingsCreated} binding(s) for directly-authored nodes`);
+  }
+  return bindingsCreated;
+}
+var BINDING_REF_PATTERN = /^=bindings\.(.+)$/;
+function collectNodeBindingRefs(node) {
+  const refs = new Set;
+  const addRef = (value) => {
+    if (typeof value !== "string")
+      return;
+    const match = value.match(BINDING_REF_PATTERN);
+    if (match)
+      refs.add(match[1]);
+  };
+  if (node.inputs) {
+    const inputs = node.inputs;
+    for (const value of Object.values(inputs))
+      addRef(value);
+    const detail = inputs.detail;
+    for (const bucket of REQUEST_BUCKETS) {
+      const values = detail?.[bucket];
+      if (values !== null && typeof values === "object") {
+        for (const value of Object.values(values))
+          addRef(value);
+      }
+    }
+  }
+  return refs;
+}
+function collectNodeBindingResourceKeys2(node, bindings, definitions) {
+  const keys = new Set;
+  const processKey = resolveProcessTargetKey(node, definitions);
+  if (processKey) {
+    keys.add(processKey);
+  }
+  const inputs = node.inputs;
+  if (typeof inputs?.detail?.connectionResourceId === "string") {
+    keys.add(inputs.detail.connectionResourceId);
+  }
+  const fileNodeConnection = orchestratorConnectionKey(definitions, node);
+  if (fileNodeConnection) {
+    keys.add(fileNodeConnection);
+  }
+  const entityKey = entityScopeKey(inputs?.entityConfig);
+  if (entityKey !== "") {
+    keys.add(entityKey);
+  }
+  const refs = collectNodeBindingRefs(node);
+  for (const binding of bindings) {
+    if (refs.has(binding.id)) {
+      keys.add(binding.resourceKey);
+    }
+  }
+  return keys;
+}
+var addNodeToFlow2 = async (filePath, nodeType, options = {}) => {
+  let inline;
+  if (options.inlineActivity) {
+    inline = await prepareInlineActivity(nodeType, options.inlineActivity);
+  } else if (nodeType.startsWith("uipath.connector.custom.")) {
+    throw new InlineActivityError2(`Node type "${nodeType}" is a non-catalog activity, which the registry does not carry.`, "Pass --metadata <Name>.json and --scripts <dir> (the files `uip is activities metadata generate` and `script update` produced) so the definition is built locally.");
+  }
+  let manifest = inline?.manifest ?? null;
+  let registryErr;
+  if (!manifest) {
+    const [err, registryManifest] = await catchError2(getNode2(nodeType));
+    manifest = registryManifest ?? null;
+    registryErr = err;
+    if (err) {
+      logger.debug(`Registry node lookup failed for ${nodeType}: ${err.message}`);
+    }
+  }
+  let localErr = null;
+  if (!manifest) {
+    const [err, localManifest] = await catchError2(getNode2(nodeType, { local: true }));
+    manifest = localManifest ?? null;
+    if (err) {
+      localErr = err;
+      logger.warn(`In-solution node lookup failed for ${nodeType}: ${err.message}`);
+    }
+  }
+  if (!manifest && nodeType === DYNAMIC_EXTRACT_NODE_TYPE2) {
+    manifest = buildExtractDocumentBuilderNode();
+  }
+  if (!manifest && (isTenantManifestInvalidError2(registryErr) || isTenantManifestUnavailableError2(registryErr))) {
+    throw registryErr;
+  }
+  if (!manifest) {
+    if (isKnownSdkNodeType2(nodeType)) {
+      throw new NodeTypeNotEnabledError2(`Node type '${nodeType}' is not enabled for this tenant.`, "Ask an admin to enable the feature flag for this node type, " + "or run `uip maestro flow registry list` to see every " + "known type with its `AvailableOnTenant` flag.");
+    }
+    const [, withoutProcessResource] = await catchError2(explainNodeTypeWithoutProcessResource2(nodeType));
+    if (withoutProcessResource) {
+      throw new NodeTypeNotFoundError2(`Node type not found: ${nodeType}. ${withoutProcessResource.message}`, withoutProcessResource.instructions);
+    }
+    const details = [
+      registryErr && `Registry lookup failed: ${registryErr.message}`,
+      localErr && `In-solution lookup failed: ${localErr.message}`
+    ].filter(Boolean).join(". ");
+    const hint = details || "If this is an in-solution node, make sure you are running " + "from inside a solution directory (with a .uipx file in CWD, parent, or grandparent).";
+    throw new NodeTypeNotFoundError2(`Node type not found: ${nodeType}. ${hint}`, "Run `uip maestro flow registry search <keyword>` to find the " + "correct node type, or `uip maestro flow registry list` " + "to see every known type (including ones not enabled on this tenant).");
+  }
+  if (manifest.model?.source === true && nodeType !== DYNAMIC_EXTRACT_NODE_TYPE2) {
+    const fromFlag = typeof options.source === "string" && options.source.length > 0;
+    const inputsSourceCandidate = options.inputs?.source;
+    const fromInputs = typeof inputsSourceCandidate === "string" && inputsSourceCandidate.length > 0;
+    if (!fromFlag && !fromInputs) {
+      throw new SourceRequiredError2(`Node type "${nodeType}" requires a source UUID at inputs.source. Pass --source <uuid>.`, "Use the agent's ProjectId (returned by " + '`uip agent init "<flow-dir>" --inline-in-flow`) for inline ' + "agent nodes, or the resource id declared in the parent " + "inline agent's `resources[]` for agent-tool resource nodes. " + '`--input \'{"source":"<uuid>"}\'` is also accepted.');
+    }
+  }
+  const { workflow, refMap } = await readFlowWorkflow2(filePath);
+  if (inline) {
+    const existing = workflow.definitions.find((d) => d.nodeType === manifest.nodeType && d.version === manifest.version);
+    if (existing && definitionConfigurationOf(existing) !== definitionConfigurationOf(manifest)) {
+      throw new InlineActivityError2(`"${nodeType}" is already defined in this flow with different activity metadata.`, "Use a different activity slug for this node type, or remove the existing nodes of this type first so the definition is rebuilt from the new metadata.");
+    }
+  }
+  const existingIds = new Set(workflow.nodes.map((n) => n.id));
+  const existingDefCount = workflow.definitions.length;
+  const { id, displayName } = generateNodeIdAndName2(options.label ?? manifest.display.label, existingIds);
+  const bindingsBefore = workflow.bindings?.length ?? 0;
+  const node = addNode2(workflow, manifest, id, options.position ?? { x: 0, y: 0 }, options.label ?? displayName);
+  const schema = manifest.inputDefinition;
+  if (node.inputs && manifest.inputDefaults === undefined && schema?.type === "object") {
+    for (const schemaKey of Object.keys(schema)) {
+      delete node.inputs[schemaKey];
+    }
+  }
+  let bindingsCreated = 0;
+  if (isProcessNode2(manifest)) {
+    const { nameBinding, folderBinding } = createProcessBindings(manifest);
+    addBinding2(workflow, nameBinding);
+    addBinding2(workflow, folderBinding);
+    const storedBindings = workflow.bindings;
+    const storedName = storedBindings.find((b) => b.resourceKey === nameBinding.resourceKey && b.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
+    const storedFolder = storedBindings.find((b) => b.resourceKey === folderBinding.resourceKey && b.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
+    if (folderBinding.default === "" && storedFolder.default === undefined) {
+      storedFolder.default = "";
+    }
+    resolveProcessBindingsInContext(node, storedName, storedFolder);
+    bindingsCreated = (workflow.bindings?.length ?? 0) - bindingsBefore;
+  }
+  if (options.inputs && Object.keys(options.inputs).length > 0) {
+    node.inputs = { ...node.inputs ?? {}, ...options.inputs };
+  }
+  if (inline) {
+    node.inputs = {
+      ...node.inputs ?? {},
+      inlineActivityConfiguration: inline.configuration
+    };
+  }
+  if (isEntityNode2(manifest)) {
+    await resolveEntityIdentity2(filePath, node);
+    for (const entityBinding of createEntityBindings2(node)) {
+      addBinding2(workflow, entityBinding);
+    }
+    bindingsCreated = (workflow.bindings?.length ?? 0) - bindingsBefore;
+  }
+  const manifestModel = manifest.model;
+  if (manifestModel?.source === true) {
+    if (typeof options.source === "string" && options.source.length > 0) {
+      const inputs = node.inputs ?? {};
+      inputs.source = options.source;
+      node.inputs = inputs;
+    }
+    if (nodeType === DYNAMIC_EXTRACT_NODE_TYPE2) {
+      const inputs = node.inputs ?? {};
+      const existingSource = inputs.source;
+      if (typeof existingSource !== "string" || existingSource.length === 0) {
+        inputs.source = crypto.randomUUID();
+        node.inputs = inputs;
+      }
+    }
+    if (node.model) {
+      delete node.model;
+    }
+    if (isInlineAgentNodeType(node.type)) {
+      await writeInlineAgentStepFromAgent(node, filePath, options.inputs?.agentOutputVariables !== undefined);
+    }
+  }
+  if (nodeType === DYNAMIC_EXTRACT_NODE_TYPE2) {
+    const inputs = node.inputs ?? {};
+    if (inputs.schemaDocument === undefined) {
+      inputs.schemaDocument = buildDefaultSchemaDocument();
+      node.inputs = inputs;
+    }
+  }
+  if (nodeType === DYNAMIC_EXTRACT_NODE_TYPE2) {
+    const outputDefinition = manifest.outputDefinition;
+    if (outputDefinition) {
+      const outputs = {};
+      for (const [port, definition] of Object.entries(outputDefinition)) {
+        outputs[port] = {
+          type: definition.type,
+          source: definition.source,
+          var: definition.var ?? port
+        };
+      }
+      node.outputs = outputs;
+    }
+  }
+  if (typeof options.parent === "string" && options.parent.length > 0) {
+    const allNodes = workflow.nodes;
+    if (!allNodes.some((n) => n.id === options.parent)) {
+      throw new Error(`--parent value "${options.parent}" is not an existing node id in this flow. ` + "Run 'uip maestro flow nodes list <file>' to see valid ids.");
+    }
+    node.parentId = options.parent;
+  }
+  await writeFlowWorkflow2(filePath, workflow, refMap);
+  if (isProcessNode2(manifest) || isEntityNode2(manifest)) {
+    const fs = getFileSystem();
+    const [regenErr] = await catchError2(regenerateBindingsFile(fs, filePath));
+    if (regenErr) {
+      logger.warn(`Failed to regenerate bindings_v2.json after adding ${manifest.nodeType}: ${regenErr.message}`);
+    }
+  }
+  const definitionAdded = workflow.definitions.length > existingDefCount;
+  const variableCount = workflow.variables?.nodes?.length ?? 0;
+  const inlineActivity = inline ? {
+    scriptRef: inline.configuration.scriptRef,
+    scripts: Object.keys(inline.configuration.scripts)
+  } : undefined;
+  if (isConnectorNode2(manifest)) {
+    const connInfo = getConnectorInfo2(manifest);
+    return {
+      node,
+      definitionAdded,
+      bindingsCreated,
+      variableCount,
+      connectorInfo: connInfo ?? undefined,
+      ...inlineActivity && { inlineActivity }
+    };
+  } else {
+    return {
+      node,
+      definitionAdded,
+      bindingsCreated,
+      variableCount,
+      ...inlineActivity && { inlineActivity }
+    };
+  }
+};
+function removeConnectedEdges(workflow, nodeId) {
+  const edges = workflow.edges ?? [];
+  const before = edges.length;
+  workflow.edges = edges.filter((e) => e.sourceNodeId !== nodeId && e.targetNodeId !== nodeId);
+  return before - workflow.edges.length;
+}
+function subflowNodes(workflow) {
+  return Object.values(workflow.subflows ?? {}).flatMap((entry) => entry?.nodes ?? []);
+}
+function removeOrphanedBindings(workflow, deletedNodeKeys, remainingNodes, bindings) {
+  if (deletedNodeKeys.size === 0 || bindings.length === 0)
+    return 0;
+  const defs = workflow.definitions ?? [];
+  const remainingKeys = new Set;
+  for (const node of remainingNodes) {
+    for (const key of collectNodeBindingResourceKeys2(node, bindings, defs)) {
+      remainingKeys.add(key);
+    }
+  }
+  const before = bindings.length;
+  workflow.bindings = bindings.filter((b) => !deletedNodeKeys.has(b.resourceKey) || remainingKeys.has(b.resourceKey));
+  return before - workflow.bindings.length;
+}
+function connectorConnectionBindingName(node, definitions) {
+  if (!node.type.startsWith("uipath.connector"))
+    return "";
+  const def = definitions.find((d) => d.nodeType === node.type);
+  const context = def?.model?.context;
+  const connectorKey = context?.find((c) => c.name === "connectorKey")?.value;
+  return typeof connectorKey === "string" && connectorKey.length > 0 ? `${connectorKey} connection` : "";
+}
+function removeOrphanedConnectorStub(workflow, deletedNode, remainingNodes, definitions) {
+  const stubName = connectorConnectionBindingName(deletedNode, definitions);
+  if (!stubName)
+    return 0;
+  const stillOwned = remainingNodes.some((n) => connectorConnectionBindingName(n, definitions) === stubName);
+  if (stillOwned)
+    return 0;
+  const bindings = workflow.bindings ?? [];
+  if (bindings.length === 0)
+    return 0;
+  const before = bindings.length;
+  workflow.bindings = bindings.filter((b) => !(b.resource?.toLowerCase() === "connection" && b.propertyAttribute === "ConnectionId" && !b.resourceKey && !b.default && b.name === stubName));
+  return before - workflow.bindings.length;
+}
+function removeOrphanedDefinitions(workflow, remainingNodes) {
+  const definitions = workflow.definitions ?? [];
+  const usedKeys = new Set(remainingNodes.map((n) => `${n.type}:${n.typeVersion}`));
+  const before = definitions.length;
+  workflow.definitions = definitions.filter((d) => usedKeys.has(`${d.nodeType}:${d.version}`));
+  return before - workflow.definitions.length;
+}
+function removeVariableUpdates(workflow, nodeId) {
+  const variables = workflow.variables;
+  if (!variables?.variableUpdates)
+    return 0;
+  const updates = variables.variableUpdates[nodeId];
+  if (!updates)
+    return 0;
+  const count = updates.length;
+  delete variables.variableUpdates[nodeId];
+  return count;
+}
+function removeNodeVariables(workflow, nodeId) {
+  const variables = workflow.variables;
+  if (!variables?.nodes)
+    return 0;
+  const before = variables.nodes.length;
+  variables.nodes = variables.nodes.filter((v) => v.binding.nodeId !== nodeId);
+  return before - variables.nodes.length;
+}
+var deleteNodeFromFlow2 = async (filePath, nodeId) => {
+  const { workflow, refMap } = await readFlowWorkflow2(filePath);
+  const nodes = workflow.nodes;
+  const nodeIndex = nodes.findIndex((n) => n.id === nodeId);
+  if (nodeIndex === -1) {
+    const available = nodes.map((n) => n.id).join(", ") || "(none)";
+    throw new Error(`Node not found: "${nodeId}". Available node IDs: ${available}`);
+  }
+  const targetNode = nodes[nodeIndex];
+  const deletedWasProcessNode = isProcessNode2({ nodeType: targetNode.type });
+  const deletedNode = {
+    id: targetNode.id,
+    type: targetNode.type,
+    label: targetNode.display.label ?? "",
+    position: targetNode.ui.position
+  };
+  const bindings = workflow.bindings ?? [];
+  const definitions = workflow.definitions ?? [];
+  const deletedNodeResourceKeys = collectNodeBindingResourceKeys2(targetNode, bindings, definitions);
+  nodes.splice(nodeIndex, 1);
+  const edgesRemoved = removeConnectedEdges(workflow, nodeId);
+  const remainingNodes = [...nodes, ...subflowNodes(workflow)];
+  const bindingsRemoved = removeOrphanedBindings(workflow, deletedNodeResourceKeys, remainingNodes, bindings) + removeOrphanedConnectorStub(workflow, targetNode, remainingNodes, definitions);
+  const definitionsRemoved = removeOrphanedDefinitions(workflow, remainingNodes);
+  const variablesRemoved = removeNodeVariables(workflow, nodeId);
+  const variableUpdatesRemoved = removeVariableUpdates(workflow, nodeId);
+  await writeFlowWorkflow2(filePath, workflow, refMap);
+  if (deletedWasProcessNode || bindingsRemoved > 0) {
+    const fs = getFileSystem();
+    const [regenErr] = await catchError2(regenerateBindingsFile(fs, filePath));
+    if (regenErr) {
+      logger.warn(`Failed to regenerate bindings_v2.json after deleting ${targetNode.type}: ${regenErr.message}`);
+    }
+  }
+  return {
+    deletedNode,
+    edgesRemoved,
+    bindingsRemoved,
+    definitionsRemoved,
+    variablesRemoved,
+    variableUpdatesRemoved
+  };
+};
+
+export { REQUEST_BUCKETS, INLINE_ACTIVITY_TYPE_PREFIX, INLINE_ACTIVITY_SOURCE, InlineActivityError2, collectScriptRefs, getInlineActivityConfiguration, findOrchestratorConnectionField, orchestratorConnectionKey, fileNodesToPackagingNodes, flowToPackagingNodes, packageInlineAgents, stageInlineAgentPackageFiles, buildInlineAgentDescriptors, writePackagingArtifacts, writePackagingArtifactsDetailed, regenerateBindingsFile, NodeTypeNotFoundError2, NodeTypeNotEnabledError2, SourceRequiredError2, listNodesInFlow2, isProcessNode2, isEntityNode2, createEntityBindings2, resolveEntityIdentity2, resolveProcessTarget2, ensureProcessBindings2, collectNodeBindingResourceKeys2, addNodeToFlow2, deleteNodeFromFlow2 };
+
+//# debugId=BEA93E4CFE39CB1C64756E2164756E21