@syntax-syllogism/flow-delta 0.0.1

package/dist/cli.js

@@ -0,0 +1,1353 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { parseArgs } from "node:util";
+
+// src/parser/flow_parser.ts
+import { Parser } from "xml2js";
+var FAULT = "Fault";
+var END = "End";
+var START = "FLOW_START";
+var END_NODE = {
+  name: "END",
+  label: END,
+  locationX: 0,
+  locationY: 0,
+  elementSubtype: END,
+  description: END
+};
+var ERROR_MESSAGES = {
+  couldNotFindConnectedNode: (node) => `Could not find connected node for ${node}`,
+  flowStartNotDefined: "Flow start is not defined"
+};
+var FlowParser = class {
+  constructor(flowXml) {
+    this.flowXml = flowXml;
+    this.beingParsed = {
+      nameToNode: /* @__PURE__ */ new Map()
+    };
+  }
+  flowXml;
+  beingParsed;
+  async generateFlowDefinition() {
+    const flowFromXml = await this.parseXmlFile();
+    return this.generateParsedFlow(flowFromXml.Flow);
+  }
+  parseXmlFile() {
+    return new Promise((resolve2, reject) => {
+      new Parser({ explicitArray: false }).parseString(
+        this.flowXml,
+        (err, result) => {
+          if (err) {
+            reject(err);
+          } else {
+            resolve2(result);
+          }
+        }
+      );
+    });
+  }
+  generateParsedFlow(flow) {
+    this.populateFlowNodes(flow);
+    this.beingParsed.nameToNode = this.generateNameToNodeMap();
+    this.beingParsed.transitions = this.populateTransitions();
+    return this.beingParsed;
+  }
+  populateFlowNodes(flow) {
+    this.beingParsed.label = flow.label;
+    this.beingParsed.fullName = flow.fullName;
+    this.beingParsed.processType = flow.processType;
+    this.beingParsed.start = flow.start;
+    this.validateFlowStart();
+    setFlowStart(this.beingParsed.start);
+    this.beingParsed.apexPluginCalls = ensureArray(flow.apexPluginCalls);
+    this.beingParsed.assignments = ensureArray(flow.assignments);
+    setAssignments(this.beingParsed.assignments);
+    this.beingParsed.collectionProcessors = ensureArray(
+      flow.collectionProcessors
+    );
+    this.beingParsed.customErrors = ensureArray(flow.customErrors);
+    setCustomErrorMessages(this.beingParsed.customErrors);
+    this.beingParsed.decisions = ensureArray(flow.decisions);
+    setDecisionRules(this.beingParsed.decisions);
+    this.beingParsed.loops = ensureArray(flow.loops);
+    this.beingParsed.orchestratedStages = ensureArray(flow.orchestratedStages);
+    setOrchestratedStageSteps(this.beingParsed.orchestratedStages);
+    this.beingParsed.recordCreates = ensureArray(flow.recordCreates);
+    this.beingParsed.recordDeletes = ensureArray(flow.recordDeletes);
+    this.beingParsed.recordLookups = ensureArray(flow.recordLookups);
+    setRecordLookups(this.beingParsed.recordLookups);
+    this.beingParsed.recordRollbacks = ensureArray(flow.recordRollbacks);
+    this.beingParsed.recordUpdates = ensureArray(flow.recordUpdates);
+    setRecordUpdates(this.beingParsed.recordUpdates);
+    this.beingParsed.screens = ensureArray(flow.screens);
+    this.beingParsed.steps = ensureArray(flow.steps);
+    this.beingParsed.subflows = ensureArray(flow.subflows);
+    this.beingParsed.transforms = ensureArray(flow.transforms);
+    this.beingParsed.waits = ensureArray(flow.waits);
+    this.beingParsed.actionCalls = ensureArray(flow.actionCalls);
+  }
+  /**
+   * Generates a map of node names to node objects.
+   *
+   * Node name contains the API name of a flow node and is unique across
+   * all elements within the flow.
+   * Here we make a special case for the END node, which is not defined in the
+   * XML.
+   */
+  generateNameToNodeMap() {
+    const nameToNode = /* @__PURE__ */ new Map();
+    nameToNode.set(END_NODE.name, END_NODE);
+    nameToNode.set(START, this.beingParsed.start);
+    const toProcess = [
+      this.beingParsed.apexPluginCalls,
+      this.beingParsed.assignments,
+      this.beingParsed.collectionProcessors,
+      this.beingParsed.customErrors,
+      this.beingParsed.decisions,
+      this.beingParsed.loops,
+      this.beingParsed.orchestratedStages,
+      this.beingParsed.recordCreates,
+      this.beingParsed.recordDeletes,
+      this.beingParsed.recordLookups,
+      this.beingParsed.recordRollbacks,
+      this.beingParsed.recordUpdates,
+      this.beingParsed.screens,
+      this.beingParsed.steps,
+      this.beingParsed.subflows,
+      this.beingParsed.transforms,
+      this.beingParsed.waits,
+      this.beingParsed.actionCalls
+    ];
+    for (const nodeArray of toProcess) {
+      if (!nodeArray) {
+        continue;
+      }
+      for (const node of nodeArray) {
+        nameToNode.set(node.name, node);
+      }
+    }
+    return nameToNode;
+  }
+  validateFlowStart() {
+    if (!this.beingParsed.start) {
+      throw new Error(ERROR_MESSAGES.flowStartNotDefined);
+    }
+    this.beingParsed.start.name = START;
+  }
+  /**
+   * Populate Transitions
+   *
+   * This populates the transitions represented in the Flow by performing a
+   * breadth first search from the start node.
+   * Cycles are detected and skipped by referencing the visited node names.
+   */
+  populateTransitions() {
+    const result = [];
+    const start = this.beingParsed.start;
+    if (!start) {
+      return result;
+    }
+    const queue = [start];
+    const visitedNodes = /* @__PURE__ */ new Set();
+    while (queue.length > 0) {
+      const node = queue.shift();
+      if (!node || visitedNodes.has(node.name)) {
+        continue;
+      }
+      visitedNodes.add(node.name);
+      const transitions = this.getTransitionsForNode(node);
+      for (const transition of transitions) {
+        const toNode2 = this.beingParsed.nameToNode?.get(transition.to);
+        if (toNode2) {
+          queue.push(toNode2);
+        }
+      }
+      result.push(...transitions);
+    }
+    return result;
+  }
+  /**
+   * Get the collection of transitions for a given node
+   *
+   * Unfortunately, there are multiple different properties which reference a
+   * `flowTypes.FlowConnector` and it is not possible to determine which
+   * property is being referenced without inspecting the XML.
+   *
+   * This method inspects all possible properties based on the type of the node
+   * and returns the transitions for the node.
+   */
+  getTransitionsForNode(node) {
+    const transitions = [];
+    if (isFlowStart(node)) {
+      transitions.push(...this.getTransitionsFromFlowStart(node));
+    } else if (isRecordCreate(node) || isRecordDelete(node) || isRecordLookup(node) || isRecordUpdate(node) || isApexPluginCall(node) || isFlowActionCall(node)) {
+      transitions.push(...this.getTransitionsFromConnectorOrFault(node));
+    } else if (isStep(node)) {
+      transitions.push(...this.getTransitionsFromStep(node));
+    } else if (isDecision(node)) {
+      transitions.push(...this.getTransitionsFromDecision(node));
+    } else if (isWait(node)) {
+      transitions.push(...this.getTransitionsFromWait(node));
+    } else if (isLoop(node)) {
+      transitions.push(...this.getTransitionsFromLoop(node));
+    } else if (isAssignment(node) || isCollectionProcessor(node) || isScreen(node) || isSubflow(node) || isTransform(node) || isRecordRollback(node) || isCustomError(node)) {
+      transitions.push(...this.getTransitionsFromConnector(node));
+    }
+    return transitions;
+  }
+  createTransition(from, connection, isFault, transitionLabel) {
+    const connectedNode = this.beingParsed.nameToNode?.get(
+      connection.targetReference
+    );
+    if (!connectedNode) {
+      throw new Error(
+        ERROR_MESSAGES.couldNotFindConnectedNode(connection.targetReference)
+      );
+    }
+    return {
+      from: from.name,
+      to: connectedNode.name,
+      fault: isFault,
+      label: transitionLabel
+    };
+  }
+  getTransitionsFromDecision(node) {
+    const result = [];
+    if (node.defaultConnector) {
+      result.push(
+        this.createTransition(
+          node,
+          node.defaultConnector,
+          false,
+          node.defaultConnectorLabel
+        )
+      );
+    }
+    if (node.rules) {
+      for (const rule of node.rules) {
+        if (rule && rule.connector) {
+          result.push(
+            this.createTransition(node, rule.connector, false, rule.label)
+          );
+        }
+      }
+    }
+    return result;
+  }
+  getTransitionsFromStep(node) {
+    const result = [];
+    if (node.connectors) {
+      for (const connector of node.connectors) {
+        result.push(this.createTransition(node, connector, false, void 0));
+      }
+    }
+    return result;
+  }
+  getTransitionsFromConnectorOrFault(node) {
+    const result = [];
+    if (node.connector) {
+      result.push(
+        this.createTransition(node, node.connector, false, void 0)
+      );
+    }
+    if (node.faultConnector) {
+      result.push(
+        this.createTransition(node, node.faultConnector, true, FAULT)
+      );
+    }
+    return result;
+  }
+  getTransitionsFromLoop(node) {
+    const result = [];
+    if (node.nextValueConnector) {
+      result.push(
+        this.createTransition(node, node.nextValueConnector, false, "for each")
+      );
+    }
+    if (node.noMoreValuesConnector) {
+      result.push(
+        this.createTransition(
+          node,
+          node.noMoreValuesConnector,
+          false,
+          "after all"
+        )
+      );
+    }
+    return result;
+  }
+  getTransitionsFromConnector(node) {
+    const result = [];
+    if (node.connector) {
+      for (const connector of Array.isArray(node.connector) ? node.connector : [node.connector]) {
+        result.push(this.createTransition(node, connector, false, void 0));
+      }
+    }
+    return result;
+  }
+  getTransitionsFromWait(node) {
+    const result = [];
+    if (node.defaultConnector) {
+      result.push(
+        this.createTransition(
+          node,
+          node.defaultConnector,
+          false,
+          node.defaultConnectorLabel
+        )
+      );
+    }
+    if (node.faultConnector) {
+      result.push(
+        this.createTransition(node, node.faultConnector, true, FAULT)
+      );
+    }
+    return result;
+  }
+  getTransitionsFromFlowStart(node) {
+    const result = [];
+    if (node.connector) {
+      result.push(
+        this.createTransition(node, node.connector, false, void 0)
+      );
+    }
+    if (node.scheduledPaths && node.scheduledPaths.length > 0) {
+      for (const scheduledPath of node.scheduledPaths) {
+        if (scheduledPath.connector) {
+          const label = scheduledPath.pathType;
+          result.push(
+            this.createTransition(node, scheduledPath.connector, false, label)
+          );
+        }
+      }
+    }
+    return result;
+  }
+};
+function ensureArray(input) {
+  return input ? Array.isArray(input) ? input : [input] : input;
+}
+function setAssignments(assignments) {
+  assignments?.forEach((assignment) => {
+    assignment.assignmentItems = ensureArray(
+      assignment.assignmentItems
+    );
+  });
+}
+function setOrchestratedStageSteps(orchestratedStages) {
+  orchestratedStages?.forEach((stage) => {
+    if (!stage.stageSteps) {
+      return;
+    }
+    stage.stageSteps = ensureArray(
+      stage.stageSteps
+    );
+  });
+}
+function setDecisionRules(decisions) {
+  decisions?.forEach((decision) => {
+    if (!decision.rules) {
+      return;
+    }
+    decision.rules = ensureArray(decision.rules);
+    setRuleConditions(decision.rules);
+  });
+}
+function setRuleConditions(rules) {
+  rules?.forEach((rule) => {
+    if (!rule.conditions) {
+      return;
+    }
+    rule.conditions = ensureArray(rule.conditions);
+  });
+}
+function setRecordLookups(recordLookups) {
+  recordLookups?.forEach((recordLookup) => {
+    if (recordLookup.filters) {
+      recordLookup.filters = ensureArray(
+        recordLookup.filters
+      );
+    }
+    if (recordLookup.queriedFields) {
+      recordLookup.queriedFields = ensureArray(
+        recordLookup.queriedFields
+      );
+    }
+  });
+}
+function setRecordUpdates(recordUpdates) {
+  if (!recordUpdates) {
+    return;
+  }
+  for (const recordUpdate of recordUpdates) {
+    recordUpdate.filters = ensureArray(
+      recordUpdate.filters ?? []
+    );
+    recordUpdate.inputAssignments = ensureArray(
+      recordUpdate.inputAssignments ?? []
+    );
+  }
+}
+function setCustomErrorMessages(customErrors) {
+  if (!customErrors) {
+    return;
+  }
+  for (const customError of customErrors) {
+    customError.customErrorMessages = ensureArray(
+      customError.customErrorMessages
+    );
+  }
+}
+function setFlowStart(start) {
+  if (!start) {
+    return;
+  }
+  if (start.filters) {
+    start.filters = ensureArray(start.filters);
+  }
+  if (start.scheduledPaths) {
+    start.scheduledPaths = ensureArray(
+      start.scheduledPaths
+    );
+  }
+  if (start.capabilityTypes) {
+    start.capabilityTypes = ensureArray(
+      start.capabilityTypes
+    );
+  }
+}
+function isAssignment(node) {
+  return node.assignmentItems !== void 0;
+}
+function isCollectionProcessor(node) {
+  return node.collectionProcessorType !== void 0;
+}
+function isScreen(node) {
+  return node.fields !== void 0;
+}
+function isSubflow(node) {
+  return node.flowName !== void 0;
+}
+function isTransform(node) {
+  return node.dataType !== void 0;
+}
+function isStep(node) {
+  return node.connectors !== void 0;
+}
+function isDecision(node) {
+  return node.rules !== void 0;
+}
+function isWait(node) {
+  return node.waitEvents !== void 0;
+}
+function isLoop(node) {
+  return node.nextValueConnector !== void 0;
+}
+function isRecordCreate(node) {
+  const recordCreate = node;
+  const hasInputAssignments = recordCreate.inputAssignments !== void 0 && Array.isArray(recordCreate.inputAssignments);
+  const hasObject = recordCreate.object !== void 0;
+  const recordUpdate = node;
+  const hasNoFilters = recordUpdate.filters === void 0;
+  return hasInputAssignments && hasObject && hasNoFilters;
+}
+function isRecordDelete(node) {
+  return node.inputReference !== void 0;
+}
+function isRecordLookup(node) {
+  return node.filters !== void 0;
+}
+function isRecordUpdate(node) {
+  const recordUpdate = node;
+  return recordUpdate.inputAssignments !== void 0 && recordUpdate.filters !== void 0 && recordUpdate.object !== void 0;
+}
+function isRecordRollback(node) {
+  return node.connector !== void 0;
+}
+function isApexPluginCall(node) {
+  return node.apexClass !== void 0;
+}
+function isFlowActionCall(node) {
+  return node.actionName !== void 0;
+}
+function isCustomError(node) {
+  return node.customErrorMessages !== void 0;
+}
+function isFlowStart(node) {
+  return node.name === START && node.label === void 0;
+}
+
+// src/model/build-model.ts
+var EDGE_KEYS = /* @__PURE__ */ new Set([
+  "connector",
+  "faultConnector",
+  "defaultConnector",
+  "nextValueConnector",
+  "noMoreValuesConnector"
+]);
+var TOP_LEVEL_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "label",
+  "locationX",
+  "locationY",
+  "elementSubtype",
+  "diffStatus"
+]);
+var UNORDERED_ARRAY_KEYS = /* @__PURE__ */ new Set([
+  "capabilityTypes",
+  "choiceReferences",
+  "dataTypeMappings",
+  "filters",
+  "inputParameters",
+  "outputParameters",
+  "processMetadataValues"
+]);
+var NODE_TYPE_BY_COLLECTION = {
+  apexPluginCalls: "apexPluginCall",
+  assignments: "assignment",
+  collectionProcessors: "collectionProcessor",
+  customErrors: "customError",
+  decisions: "decision",
+  loops: "loop",
+  orchestratedStages: "orchestratedStage",
+  recordCreates: "recordCreate",
+  recordDeletes: "recordDelete",
+  recordLookups: "recordLookup",
+  recordRollbacks: "recordRollback",
+  recordUpdates: "recordUpdate",
+  screens: "screen",
+  steps: "step",
+  subflows: "subflow",
+  transforms: "transform",
+  waits: "wait",
+  actionCalls: "actionCall"
+};
+function buildModel(parsed) {
+  const nodes = [
+    toNode(parsed.start, "start"),
+    toNode({ name: "END", label: "End", description: "End", elementSubtype: "End", locationX: 0, locationY: 0 }, "end"),
+    ...collectNodes(parsed)
+  ].filter((node) => Boolean(node)).sort((a, b) => a.id.localeCompare(b.id));
+  const edges = addImplicitEndTransitions(parsed.transitions ?? [], parsed.start?.name).map(toEdge).sort((a, b) => a.id.localeCompare(b.id));
+  return {
+    flowName: parsed.fullName ?? parsed.label ?? "(unknown)",
+    label: parsed.label ?? parsed.fullName ?? "(unknown)",
+    processType: parsed.processType,
+    nodes,
+    edges
+  };
+}
+function addImplicitEndTransitions(transitions, startNodeId) {
+  const reachableNodeIds = /* @__PURE__ */ new Set([
+    ...startNodeId ? [startNodeId] : [],
+    ...transitions.flatMap((transition) => [transition.from, transition.to])
+  ]);
+  const nodesWithNormalExit = new Set(
+    transitions.filter((transition) => !transition.fault).map((transition) => transition.from)
+  );
+  const implicitEndTransitions = [...reachableNodeIds].filter((nodeId) => nodeId !== "END" && !nodesWithNormalExit.has(nodeId)).map((nodeId) => ({ from: nodeId, to: "END", fault: false }));
+  return [...transitions, ...implicitEndTransitions];
+}
+function collectNodes(parsed) {
+  const result = [];
+  for (const [collectionName, type] of Object.entries(NODE_TYPE_BY_COLLECTION)) {
+    const nodes = parsed[collectionName];
+    if (!nodes) {
+      continue;
+    }
+    for (const node of nodes) {
+      result.push(toNode(node, type));
+    }
+  }
+  return result;
+}
+function toNode(node, type) {
+  if (!node) {
+    return void 0;
+  }
+  const label = "label" in node && typeof node.label === "string" ? node.label : node.name;
+  return {
+    id: node.name,
+    type,
+    label,
+    properties: stripNodeProperties(structuredClone(node), true)
+  };
+}
+function toEdge(transition) {
+  const label = transition.label;
+  return {
+    id: `${transition.from}->${transition.to}#${transition.fault ? "fault" : "normal"}#${label ?? ""}`,
+    source: transition.from,
+    target: transition.to,
+    kind: transition.fault ? "fault" : "normal",
+    label
+  };
+}
+function stripNodeProperties(value, topLevel = false) {
+  if (Array.isArray(value)) {
+    return value.map((item) => stripNodeProperties(item));
+  }
+  if (!isPlainObject(value)) {
+    return value;
+  }
+  const result = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (topLevel && TOP_LEVEL_KEYS.has(key)) {
+      continue;
+    }
+    if (EDGE_KEYS.has(key)) {
+      continue;
+    }
+    if (Array.isArray(entry) && UNORDERED_ARRAY_KEYS.has(key)) {
+      result[key] = normalizeUnorderedArray(entry);
+      continue;
+    }
+    result[key] = stripNodeProperties(entry);
+  }
+  return result;
+}
+function normalizeUnorderedArray(items) {
+  return items.map((item) => stripNodeProperties(item)).sort((left, right) => stableStringify(left).localeCompare(stableStringify(right)));
+}
+function stableStringify(value) {
+  return JSON.stringify(value, (_, entry) => {
+    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+      return Object.keys(entry).sort().reduce((acc, key) => {
+        acc[key] = entry[key];
+        return acc;
+      }, {});
+    }
+    return entry;
+  }) ?? "";
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// src/diff/deep-diff.ts
+function deepDiff(before, after, path = "") {
+  if (Object.is(before, after)) {
+    return [];
+  }
+  if (Array.isArray(before) && Array.isArray(after)) {
+    const changes = [];
+    const shared = Math.min(before.length, after.length);
+    for (let index = 0; index < shared; index += 1) {
+      changes.push(...deepDiff(before[index], after[index], joinPath(path, `[${index}]`)));
+    }
+    for (let index = shared; index < before.length; index += 1) {
+      changes.push({ path: joinPath(path, `[${index}]`), before: before[index], after: void 0 });
+    }
+    for (let index = shared; index < after.length; index += 1) {
+      changes.push({ path: joinPath(path, `[${index}]`), before: void 0, after: after[index] });
+    }
+    return changes;
+  }
+  if (isPlainObject2(before) && isPlainObject2(after)) {
+    const changes = [];
+    const keys = /* @__PURE__ */ new Set([...Object.keys(before), ...Object.keys(after)]);
+    for (const key of [...keys].sort()) {
+      if (!(key in before)) {
+        changes.push({ path: joinPath(path, key), before: void 0, after: after[key] });
+        continue;
+      }
+      if (!(key in after)) {
+        changes.push({ path: joinPath(path, key), before: before[key], after: void 0 });
+        continue;
+      }
+      changes.push(...deepDiff(before[key], after[key], joinPath(path, key)));
+    }
+    return changes;
+  }
+  return [{ path, before, after }];
+}
+function isPlainObject2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function joinPath(base, segment) {
+  if (!base) {
+    return segment;
+  }
+  return segment.startsWith("[") ? `${base}${segment}` : `${base}.${segment}`;
+}
+
+// src/diff/diff-model.ts
+function diffModel(oldModel, newModel) {
+  const oldNodes = indexById(oldModel.nodes);
+  const newNodes = indexById(newModel.nodes);
+  const oldEdges = indexById(oldModel.edges);
+  const newEdges = indexById(newModel.edges);
+  const nodeIds = [.../* @__PURE__ */ new Set([...oldNodes.keys(), ...newNodes.keys()])].sort();
+  const edgeIds = [.../* @__PURE__ */ new Set([...oldEdges.keys(), ...newEdges.keys()])].sort();
+  const nodes = nodeIds.map((id) => classifyNode(oldNodes.get(id), newNodes.get(id)));
+  const edges = edgeIds.map((id) => classifyEdge(oldEdges.get(id), newEdges.get(id)));
+  const summary = {
+    addedNodes: nodes.filter((node) => node.status === "added").length,
+    removedNodes: nodes.filter((node) => node.status === "deleted").length,
+    modifiedNodes: nodes.filter((node) => node.status === "modified").length,
+    unchangedNodes: nodes.filter((node) => node.status === "unchanged").length,
+    addedEdges: edges.filter((edge) => edge.status === "added").length,
+    removedEdges: edges.filter((edge) => edge.status === "deleted").length
+  };
+  return {
+    flowName: selectFlowName(oldModel, newModel),
+    summary,
+    nodes,
+    edges
+  };
+}
+function selectFlowName(oldModel, newModel) {
+  if (newModel.nodes.length > 0 || newModel.edges.length > 0) {
+    return newModel.flowName;
+  }
+  return oldModel.flowName;
+}
+function indexById(items) {
+  return new Map(items.map((item) => [item.id, item]));
+}
+function classifyNode(oldNode, newNode) {
+  if (!oldNode && !newNode) {
+    throw new Error("Cannot classify absent node");
+  }
+  if (!oldNode) {
+    return { id: newNode.id, type: newNode.type, label: newNode.label, status: "added" };
+  }
+  if (!newNode) {
+    return { id: oldNode.id, type: oldNode.type, label: oldNode.label, status: "deleted" };
+  }
+  const changes = [
+    ...deepDiff(oldNode.label, newNode.label, "label"),
+    ...deepDiff(oldNode.type, newNode.type, "type"),
+    ...deepDiff(oldNode.properties, newNode.properties)
+  ];
+  if (changes.length === 0) {
+    return {
+      id: newNode.id,
+      type: newNode.type,
+      label: newNode.label,
+      status: "unchanged"
+    };
+  }
+  return {
+    id: newNode.id,
+    type: newNode.type,
+    label: newNode.label,
+    status: "modified",
+    changes
+  };
+}
+function classifyEdge(oldEdge, newEdge) {
+  if (!oldEdge && !newEdge) {
+    throw new Error("Cannot classify absent edge");
+  }
+  if (!oldEdge) {
+    return toEdgeDiff(newEdge, "added");
+  }
+  if (!newEdge) {
+    return toEdgeDiff(oldEdge, "deleted");
+  }
+  return toEdgeDiff(newEdge, "unchanged");
+}
+function toEdgeDiff(edge, status) {
+  return {
+    id: edge.id,
+    source: edge.source,
+    target: edge.target,
+    label: edge.label,
+    kind: edge.kind,
+    status
+  };
+}
+
+// src/render/layout.ts
+import ELK from "elkjs/lib/elk.bundled.js";
+async function layoutDiff(diff) {
+  const elk = new ELK();
+  const graph = {
+    id: "root",
+    layoutOptions: {
+      "elk.algorithm": "layered",
+      "elk.direction": "DOWN",
+      "elk.layered.spacing.nodeNodeBetweenLayers": 60,
+      "elk.spacing.nodeNode": 40
+    },
+    children: diff.nodes.map((node) => ({
+      id: node.id,
+      width: estimateWidth(node.label),
+      height: 48
+    })),
+    edges: diff.edges.map((edge) => ({
+      id: edge.id,
+      sources: [edge.source],
+      targets: [edge.target]
+    }))
+  };
+  const laidOut = await elk.layout(graph);
+  const children = laidOut.children ?? [];
+  const edges = laidOut.edges ?? [];
+  const nodeMap = new Map(children.map((node) => [node.id, node]));
+  const edgeMap = new Map(edges.map((edge) => [edge.id, edge]));
+  const nodes = diff.nodes.map((node) => {
+    const positioned = nodeMap.get(node.id);
+    return {
+      ...node,
+      x: positioned?.x ?? 0,
+      y: positioned?.y ?? 0,
+      width: positioned?.width ?? estimateWidth(node.label),
+      height: positioned?.height ?? 48
+    };
+  });
+  const positionedEdges = diff.edges.map((edge) => ({
+    ...edge,
+    sections: normalizeSections(edgeMap.get(edge.id)?.sections)
+  }));
+  const bounds = measureBounds(nodes);
+  return {
+    diff,
+    nodes,
+    edges: positionedEdges,
+    width: bounds.width,
+    height: bounds.height
+  };
+}
+function estimateWidth(label) {
+  return Math.max(120, Math.min(320, label.length * 8 + 32));
+}
+function normalizeSections(sections) {
+  if (!sections || sections.length === 0) {
+    return [];
+  }
+  return sections.map((section) => ({
+    startPoint: { x: section.startPoint.x, y: section.startPoint.y },
+    endPoint: { x: section.endPoint.x, y: section.endPoint.y },
+    bendPoints: section.bendPoints?.map((point) => ({ x: point.x, y: point.y }))
+  }));
+}
+function measureBounds(nodes) {
+  const maxX = nodes.reduce((acc, node) => Math.max(acc, node.x + node.width), 0);
+  const maxY = nodes.reduce((acc, node) => Math.max(acc, node.y + node.height), 0);
+  return { width: maxX + 40, height: maxY + 40 };
+}
+
+// src/render/render-html.ts
+function renderHtml(layout) {
+  const data = {
+    diff: layout.diff,
+    nodes: layout.nodes,
+    edges: layout.edges,
+    width: layout.width,
+    height: layout.height
+  };
+  const json = JSON.stringify(data).replace(/</g, "\\u003c");
+  const s = layout.diff.summary;
+  const stat = (n, kind, word) => `<span class="stat ${kind}${n === 0 ? " zero" : ""}">${n} ${word}</span>`;
+  const edgeStat = s.addedEdges + s.removedEdges > 0 ? `<span class="sep">\xB7</span><span class="stat edges">+${s.addedEdges}/\u2212${s.removedEdges} edges</span>` : "";
+  const metaHtml = `${stat(s.addedNodes, "added", "added")}<span class="sep">\xB7</span>${stat(s.removedNodes, "deleted", "deleted")}<span class="sep">\xB7</span>${stat(s.modifiedNodes, "modified", "modified")}${edgeStat}`;
+  const viewBox = fitViewBox(layout.width, layout.height);
+  return `<!doctype html>
+<html lang="en">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml(layout.diff.flowName)}</title>
+  <style>
+    :root {
+      color-scheme: light;
+      font-family: system-ui, -apple-system, "Segoe UI", sans-serif;
+      --bg: #f5f7fb; --surface: #ffffff; --border: #e3e8ef;
+      --text: #1f2937; --muted: #64748b; --faint: #94a3b8;
+      --added: #16a34a; --added-fill: #dcfce7;
+      --deleted: #dc2626; --deleted-fill: #fee2e2;
+      --modified: #d97706; --modified-fill: #fef3c7;
+      --unchanged: #94a3b8; --unchanged-fill: #e9edf3;
+      --edge: #64748b; --fault: #7c3aed;
+    }
+    * { box-sizing: border-box; }
+    body { margin: 0; height: 100vh; display: grid; grid-template-rows: auto 1fr; background: var(--bg); color: var(--text); font-size: 14px; line-height: 1.45; }
+    header { display: flex; justify-content: space-between; gap: 16px; align-items: center; padding: 12px 20px; border-bottom: 1px solid var(--border); background: var(--surface); }
+    header h1 { margin: 0 0 2px; font-size: 15px; font-weight: 650; letter-spacing: -0.01em; }
+    header .meta { font-size: 12.5px; color: var(--muted); display: flex; align-items: center; gap: 8px; }
+    header .meta .stat { font-variant-numeric: tabular-nums; }
+    header .meta .stat.zero { color: var(--faint); }
+    header .meta .added:not(.zero) { color: var(--added); }
+    header .meta .deleted:not(.zero) { color: var(--deleted); }
+    header .meta .modified:not(.zero) { color: var(--modified); }
+    header .meta .sep { color: var(--border); }
+    .legend { display: flex; gap: 14px; font-size: 12px; flex-wrap: wrap; color: var(--muted); }
+    .legend span::before { content: ""; display: inline-block; width: 9px; height: 9px; border-radius: 2px; margin-right: 6px; vertical-align: 0; }
+    .legend .added::before { background: var(--added); }
+    .legend .deleted::before { background: var(--deleted); }
+    .legend .modified::before { background: var(--modified); }
+    .legend .unchanged::before { background: var(--unchanged); }
+    main { display: grid; grid-template-columns: minmax(0, 1fr) clamp(360px, 32vw, 520px); min-height: 0; }
+    .canvas { position: relative; overflow: hidden; }
+    svg {
+      width: 100%; height: 100%; display: block;
+      background:
+        radial-gradient(circle, #dfe5ee 1px, transparent 1.4px) -11px -11px / 22px 22px,
+        linear-gradient(#ffffff, #f7f9fc);
+    }
+    .panel { min-width: 0; border-left: 1px solid var(--border); background: var(--surface); padding: 20px; overflow-y: auto; overflow-x: hidden; }
+    .panel h2 { margin: 0 0 8px; font-size: 15px; font-weight: 650; letter-spacing: -0.01em; }
+    .panel .badge { display: inline-block; padding: 3px 9px; border-radius: 999px; font-size: 11px; font-weight: 600; letter-spacing: 0.03em; background: #eef1f6; color: var(--muted); margin-bottom: 16px; }
+    .panel.added .badge { background: var(--added-fill); color: var(--added); }
+    .panel.deleted .badge { background: var(--deleted-fill); color: var(--deleted); }
+    .panel.modified .badge { background: var(--modified-fill); color: var(--modified); }
+    .panel .empty { color: var(--muted); font-size: 13px; }
+    .changes { list-style: none; padding: 0; margin: 4px 0 0; }
+    .changes li { min-width: 0; margin-bottom: 12px; padding: 13px 14px; border: 1px solid var(--border); border-radius: 8px; background: #fbfcfe; }
+    .change-title { font-weight: 600; margin-bottom: 5px; }
+    .change-path { margin-bottom: 12px; color: var(--muted); font-size: 11px; overflow-wrap: anywhere; }
+    .change-values { display: grid; gap: 10px; min-width: 0; }
+    .change-value { min-width: 0; }
+    .change-value-label { margin-bottom: 4px; color: #475569; font-size: 10.5px; font-weight: 600; letter-spacing: 0.04em; text-transform: uppercase; }
+    .changes code { font-size: 12px; font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace; background: #eef1f6; padding: 2px 5px; border-radius: 4px; overflow-wrap: anywhere; }
+    .changes pre { max-width: 100%; margin: 0; padding: 11px 12px; background: var(--surface); border: 1px solid var(--border); border-radius: 6px; white-space: pre-wrap; overflow-wrap: anywhere; font-family: ui-monospace, "SF Mono", Menlo, Consolas, monospace; font-size: 12px; line-height: 1.5; }
+    .edge { fill: none; stroke-width: 1.75; }
+    .edge.normal { stroke: var(--edge); marker-end: url(#arrow-normal); }
+    .edge.fault { stroke: var(--fault); stroke-dasharray: 6 4; marker-end: url(#arrow-fault); }
+    #arrow-normal path { fill: var(--edge); }
+    #arrow-fault path { fill: var(--fault); }
+    .node rect { rx: 11; ry: 11; stroke-width: 1.75; filter: drop-shadow(0 1px 2px rgba(15, 23, 42, 0.08)); }
+    .node { cursor: pointer; }
+    .node text { font-size: 12px; fill: #111827; pointer-events: none; }
+    .node.added rect { fill: var(--added-fill); stroke: var(--added); }
+    .node.deleted rect { fill: var(--deleted-fill); stroke: var(--deleted); }
+    .node.modified rect { fill: var(--modified-fill); stroke: var(--modified); }
+    .node.unchanged rect { fill: var(--unchanged-fill); stroke: var(--unchanged); }
+    .node.selected rect { stroke-width: 3; filter: drop-shadow(0 2px 6px rgba(15, 23, 42, 0.18)); }
+    .node-label { white-space: pre; }
+    @media (max-width: 1000px) {
+      main { grid-template-columns: minmax(0, 1fr) minmax(320px, 42vw); }
+      .panel { padding: 16px; }
+    }
+  </style>
+</head>
+<body>
+  <header>
+    <div>
+      <h1>${escapeHtml(layout.diff.flowName)}</h1>
+      <div class="meta">${metaHtml}</div>
+    </div>
+    <div class="legend">
+      <span class="added">Added</span>
+      <span class="deleted">Deleted</span>
+      <span class="modified">Modified</span>
+      <span class="unchanged">Unchanged</span>
+    </div>
+  </header>
+  <main>
+    <div class="canvas">
+      <svg id="flow-svg" viewBox="${viewBox}" preserveAspectRatio="xMidYMid meet" role="img" aria-label="Flow diff">
+        <defs>
+          <marker id="arrow-normal" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto" markerUnits="userSpaceOnUse">
+            <path d="M0,0 L8,4 L0,8 Z"></path>
+          </marker>
+          <marker id="arrow-fault" markerWidth="8" markerHeight="8" refX="7" refY="4" orient="auto" markerUnits="userSpaceOnUse">
+            <path d="M0,0 L8,4 L0,8 Z"></path>
+          </marker>
+        </defs>
+        <g id="viewport">
+          ${layout.edges.map(renderEdge).join("")}
+          ${layout.nodes.map(renderNode).join("")}
+        </g>
+      </svg>
+    </div>
+    <aside class="panel">
+      <h2 id="panel-title">Select a node</h2>
+      <div id="panel-badge" class="badge">No selection</div>
+      <div id="panel-body">Click a node to inspect its properties.</div>
+    </aside>
+  </main>
+  <script>
+    const DATA = ${json};
+    const svg = document.getElementById("flow-svg");
+    const viewport = document.getElementById("viewport");
+    const panel = document.querySelector(".panel");
+    const panelTitle = document.getElementById("panel-title");
+    const panelBadge = document.getElementById("panel-badge");
+    const panelBody = document.getElementById("panel-body");
+    const nodesById = new Map(DATA.nodes.map((node) => [node.id, node]));
+    let viewBox = svg.viewBox.baseVal;
+    let dragStart = null;
+
+    function escapeHtml(value) {
+      return String(value)
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+    }
+
+    function selectNode(id) {
+      document.querySelectorAll(".node").forEach((el) => el.classList.remove("selected"));
+      const selected = document.querySelector(\`.node[data-node-id="\${CSS.escape(id)}"]\`);
+      if (selected) selected.classList.add("selected");
+      const node = nodesById.get(id);
+      if (!node) return;
+      panel.className = "panel " + node.status;
+      panelTitle.textContent = node.label;
+      panelBadge.textContent = node.status.toUpperCase();
+      const changes = node.changes || [];
+      panelBody.innerHTML = changes.length
+        ? "<ul class='changes'>" + changes.map(formatChange).join("") + "</ul>"
+        : node.status === "added"
+          ? "<div class='empty'>This node was added in the new version.</div>"
+          : node.status === "deleted"
+            ? "<div class='empty'>This node was removed in the new version.</div>"
+            : "<div class='empty'>No property changes.</div>";
+    }
+
+    function formatChange(change) {
+      const beforeMissing = change.before === undefined;
+      const afterMissing = change.after === undefined;
+      const action = beforeMissing ? "Added" : afterMissing ? "Removed" : "Changed";
+      const values = beforeMissing
+        ? formatLabeledValue("New value", change.after)
+        : afterMissing
+          ? formatLabeledValue("Previous value", change.before)
+          : formatLabeledValue("Before", change.before) + formatLabeledValue("After", change.after);
+      return "<li><div class='change-title'>" + action + ": " + escapeHtml(humanizePath(change.path)) + "</div>"
+        + "<div class='change-path'>Metadata path: <code>" + escapeHtml(change.path) + "</code></div>"
+        + "<div class='change-values'>" + values + "</div></li>";
+    }
+
+    function formatLabeledValue(label, value) {
+      return "<div class='change-value'><div class='change-value-label'>" + label + "</div>" + formatValue(value) + "</div>";
+    }
+
+    function humanizePath(path) {
+      const names = {
+        assignmentItems: "Assignment item",
+        conditions: "Condition",
+        rules: "Rule",
+      };
+      return path.split(".").map((segment) => {
+        const match = segment.match(/^([^[]+)(?:\\[(\\d+)\\])?$/);
+        if (!match) return segment;
+        const name = names[match[1]] || match[1].replace(/([a-z])([A-Z])/g, "$1 $2").replace(/^./, (char) => char.toUpperCase());
+        return match[2] === undefined ? name : name + " " + (Number(match[2]) + 1);
+      }).join(" \u203A ");
+    }
+
+    function formatValue(value) {
+      if (value === undefined) return "<em>Not present</em>";
+      if (value === null) return "<em>Empty value</em>";
+      if (typeof value === "object") return "<pre>" + escapeHtml(JSON.stringify(value, null, 2)) + "</pre>";
+      return "<code>" + escapeHtml(String(value)) + "</code>";
+    }
+
+    document.querySelectorAll(".node").forEach((node) => {
+      node.addEventListener("click", (event) => {
+        event.stopPropagation();
+        selectNode(node.dataset.nodeId);
+      });
+    });
+
+    svg.addEventListener("wheel", (event) => {
+      event.preventDefault();
+      const scale = event.deltaY < 0 ? 0.9 : 1.1;
+      const rect = svg.getBoundingClientRect();
+      const mx = viewBox.x + (event.clientX - rect.left) * (viewBox.width / rect.width);
+      const my = viewBox.y + (event.clientY - rect.top) * (viewBox.height / rect.height);
+      viewBox.x = mx - (mx - viewBox.x) * scale;
+      viewBox.y = my - (my - viewBox.y) * scale;
+      viewBox.width *= scale;
+      viewBox.height *= scale;
+    }, { passive: false });
+
+    svg.addEventListener("pointerdown", (event) => {
+      if (event.target.closest(".node")) return;
+      dragStart = { x: event.clientX, y: event.clientY, viewBox: { x: viewBox.x, y: viewBox.y } };
+      svg.setPointerCapture(event.pointerId);
+    });
+    svg.addEventListener("pointermove", (event) => {
+      if (!dragStart) return;
+      const rect = svg.getBoundingClientRect();
+      const dx = (event.clientX - dragStart.x) * (viewBox.width / rect.width);
+      const dy = (event.clientY - dragStart.y) * (viewBox.height / rect.height);
+      viewBox.x = dragStart.viewBox.x - dx;
+      viewBox.y = dragStart.viewBox.y - dy;
+    });
+    svg.addEventListener("pointerup", () => { dragStart = null; });
+    svg.addEventListener("pointercancel", () => { dragStart = null; });
+
+    const initialNode = DATA.nodes.find((node) => node.status === "modified")
+      || DATA.nodes.find((node) => node.status !== "unchanged")
+      || DATA.nodes[0];
+    selectNode(initialNode?.id);
+  </script>
+</body>
+</html>`;
+}
+function fitViewBox(contentWidth, contentHeight) {
+  const minWidth = 720;
+  const minHeight = 540;
+  const width = Math.max(contentWidth, minWidth);
+  const height = Math.max(contentHeight, minHeight);
+  const x = (contentWidth - width) / 2;
+  const y = (contentHeight - height) / 2;
+  return `${round(x)} ${round(y)} ${round(width)} ${round(height)}`;
+}
+function round(value) {
+  return Math.round(value * 100) / 100;
+}
+function renderEdge(edge) {
+  const points = edge.sections.flatMap((section, index) => {
+    const start = index === 0 ? [section.startPoint] : [];
+    const bends = section.bendPoints ?? [];
+    const end = [section.endPoint];
+    return [...start, ...bends, ...end];
+  });
+  if (points.length === 0) {
+    return "";
+  }
+  const d = points.map((point, index) => `${index === 0 ? "M" : "L"} ${point.x} ${point.y}`).join(" ");
+  return `<path class="edge ${edge.kind}" d="${d}" data-edge-id="${escapeHtml(edge.id)}"></path>`;
+}
+function renderNode(node) {
+  const lines = wrapLabel(node.label, 22);
+  const lineHeight = 14;
+  const textY = node.height / 2 - (lines.length - 1) * lineHeight / 2 + 5;
+  return `<g class="node ${node.status}" data-node-id="${escapeHtml(node.id)}" transform="translate(${node.x},${node.y})">
+    <rect width="${node.width}" height="${node.height}"></rect>
+    <text x="${node.width / 2}" y="${textY}" text-anchor="middle" class="node-label">
+      ${lines.map((line, index) => `<tspan x="${node.width / 2}" dy="${index === 0 ? 0 : lineHeight}">${escapeHtml(line)}</tspan>`).join("")}
+    </text>
+  </g>`;
+}
+function wrapLabel(label, maxChars) {
+  const words = label.split(/\s+/);
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    const candidate = current ? `${current} ${word}` : word;
+    if (candidate.length > maxChars && current) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = candidate;
+    }
+  }
+  if (current) {
+    lines.push(current);
+  }
+  return lines.length ? lines.slice(0, 3) : [label];
+}
+function escapeHtml(value) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// src/io/read-flow.ts
+import { existsSync, readFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+function readFlowFromFile(path) {
+  if (!path.endsWith(".xml")) {
+    throw new Error(`Expected an XML file, got ${path}`);
+  }
+  if (!existsSync(path)) {
+    throw new Error(`File not found: ${path}`);
+  }
+  return readFileSync(path, "utf8");
+}
+function readFlowFromGit(repo, ref, filePath) {
+  try {
+    return execFileSync("git", ["-C", repo, "show", `${ref}:${filePath}`], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+  } catch (error) {
+    const message = String(error.stderr ?? error.message ?? "");
+    if (message.includes("does not exist in") || message.includes("exists on disk, but not in") || message.includes("pathspec") || message.includes("fatal: path")) {
+      return null;
+    }
+    throw error;
+  }
+}
+
+// src/util/file-name.ts
+function safeFileName(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+
+// src/cli.ts
+var CLI_USAGE = `Usage:
+  flow-delta --old <old.flow-meta.xml> --new <new.flow-meta.xml> [--out dir] [--json]
+  flow-delta --from <ref> --to <ref> --repo <path> --path <glob> [--changed-only] [--out dir] [--json]
+`;
+async function main(argv = process.argv.slice(2)) {
+  const parsed = parseArgs({
+    args: argv,
+    options: {
+      old: { type: "string" },
+      new: { type: "string" },
+      from: { type: "string" },
+      to: { type: "string" },
+      repo: { type: "string" },
+      path: { type: "string" },
+      out: { type: "string" },
+      json: { type: "boolean" },
+      "changed-only": { type: "boolean" },
+      help: { type: "boolean", short: "h" }
+    },
+    allowPositionals: false
+  });
+  const options = parsed.values;
+  if (options.help) {
+    console.log(CLI_USAGE.trimEnd());
+    return;
+  }
+  const outDir = resolve(options.out ?? "./flow-delta-out");
+  mkdirSync(outDir, { recursive: true });
+  try {
+    if (options.old || options.new) {
+      if (!options.old || !options.new) {
+        throw new Error("File mode requires both --old and --new");
+      }
+      await runFileMode(options.old, options.new, outDir, Boolean(options.json));
+      return;
+    }
+    if (options.from || options.to || options.repo || options.path) {
+      if (!options.from || !options.to || !options.repo || !options.path) {
+        throw new Error("Git mode requires --from, --to, --repo, and --path");
+      }
+      await runGitMode(
+        options.repo,
+        options.from,
+        options.to,
+        options.path,
+        outDir,
+        Boolean(options.json),
+        Boolean(options["changed-only"])
+      );
+      return;
+    }
+    throw new Error("Specify either --old/--new or --from/--to/--repo/--path");
+  } catch (error) {
+    console.error(error.message);
+    process.exitCode = 1;
+  }
+}
+async function runFileMode(oldPath, newPath, outDir, writeJson) {
+  const oldModel = buildModel(await parseXml(readFlowFromFile(oldPath)));
+  const newModel = buildModel(await parseXml(readFlowFromFile(newPath)));
+  await writeArtifacts(oldModel, newModel, outDir, writeJson);
+}
+async function runGitMode(repo, from, to, pattern, outDir, writeJson, changedOnly) {
+  const files = discoverGitFiles(repo, from, to, pattern, changedOnly);
+  let hadFailure = false;
+  for (const filePath of files) {
+    try {
+      const oldXml = readFlowFromGit(repo, from, filePath);
+      const newXml = readFlowFromGit(repo, to, filePath);
+      const oldModel = oldXml ? buildModel(await parseXml(oldXml)) : buildEmptyModel();
+      const newModel = newXml ? buildModel(await parseXml(newXml)) : buildEmptyModel();
+      await writeArtifacts(oldModel, newModel, outDir, writeJson, filePath);
+    } catch (error) {
+      hadFailure = true;
+      console.error(`${filePath}: ${error.message}`);
+    }
+  }
+  if (hadFailure) {
+    process.exitCode = 1;
+  }
+}
+async function parseXml(xml) {
+  const parser = new FlowParser(xml);
+  return parser.generateFlowDefinition();
+}
+function buildEmptyModel() {
+  return {
+    flowName: "(unknown)",
+    label: "(unknown)",
+    nodes: [],
+    edges: []
+  };
+}
+async function writeArtifacts(oldModel, newModel, outDir, writeJson, sourcePath) {
+  const diff = diffModel(oldModel, newModel);
+  const layout = await layoutDiff(diff);
+  const html = renderHtml(layout);
+  const fileStem = safeFileName(diff.flowName || sourcePath || "flow");
+  writeFileSync(join(outDir, `${fileStem}.html`), html, "utf8");
+  if (writeJson) {
+    writeFileSync(join(outDir, `${fileStem}.diff.json`), JSON.stringify(diff, null, 2), "utf8");
+  }
+  console.log(
+    `${diff.flowName}: nodes ${diff.summary.addedNodes} added, ${diff.summary.removedNodes} deleted, ${diff.summary.modifiedNodes} modified; edges ${diff.summary.addedEdges} added, ${diff.summary.removedEdges} deleted`
+  );
+}
+function discoverGitFiles(repo, from, to, pattern, changedOnly) {
+  const matcher = createPathMatcher(pattern);
+  if (!changedOnly) {
+    const fromFiles = listGitTree(repo, from);
+    const toFiles = listGitTree(repo, to);
+    const files = [.../* @__PURE__ */ new Set([...fromFiles, ...toFiles])];
+    return files.filter((file) => matcher(file)).sort();
+  }
+  return listChangedGitFiles(repo, from, to, pattern).filter((file) => matcher(file)).sort();
+}
+function listGitTree(repo, ref) {
+  return listGitFiles(repo, ["ls-tree", "-r", "--name-only", ref]);
+}
+function listChangedGitFiles(repo, from, to, pattern) {
+  return listGitFiles(repo, ["diff", "--name-only", "--diff-filter=ACMRD", from, to, "--", pattern]);
+}
+function listGitFiles(repo, args) {
+  return splitLines(
+    execFileSync2("git", ["-C", repo, ...args], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"]
+    })
+  );
+}
+function splitLines(output) {
+  return output.split("\n").map((line) => line.trim()).filter(Boolean);
+}
+function createPathMatcher(pattern) {
+  if (!hasGlob(pattern)) {
+    const normalized = pattern.replaceAll("\\", "/");
+    return (path) => path === normalized;
+  }
+  const regex = globToRegExp(pattern.replaceAll("\\", "/"));
+  return (path) => regex.test(path);
+}
+function hasGlob(value) {
+  return /[*?[\]]/.test(value);
+}
+function globToRegExp(pattern) {
+  let source = "^";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === "*") {
+      if (pattern[index + 1] === "*") {
+        source += ".*";
+        index += 1;
+      } else {
+        source += "[^/]*";
+      }
+      continue;
+    }
+    if (char === "?") {
+      source += "[^/]";
+      continue;
+    }
+    if ("\\^$+?.()|{}[]".includes(char)) {
+      source += `\\${char}`;
+      continue;
+    }
+    source += char;
+  }
+  source += "$";
+  return new RegExp(source);
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  void main();
+}
+export {
+  main
+};