@revisium/schema-toolkit 0.14.3 → 0.15.0

package/dist/chunk-A4E524UU.cjs

@@ -0,0 +1,2179 @@
+'use strict';
+
+var formula = require('@revisium/formula');
+
+// src/core/schema-node/types.ts
+var EMPTY_METADATA = Object.freeze({});
+
+// src/core/schema-node/NullNode.ts
+var NullNodeImpl = class {
+  id() {
+    return "";
+  }
+  name() {
+    return "";
+  }
+  nodeType() {
+    return "null";
+  }
+  metadata() {
+    return EMPTY_METADATA;
+  }
+  isObject() {
+    return false;
+  }
+  isArray() {
+    return false;
+  }
+  isPrimitive() {
+    return false;
+  }
+  isRef() {
+    return false;
+  }
+  isNull() {
+    return true;
+  }
+  property() {
+    return this;
+  }
+  properties() {
+    return [];
+  }
+  items() {
+    return this;
+  }
+  ref() {
+    return void 0;
+  }
+  formula() {
+    return void 0;
+  }
+  hasFormula() {
+    return false;
+  }
+  defaultValue() {
+    return void 0;
+  }
+  foreignKey() {
+    return void 0;
+  }
+  clone() {
+    return this;
+  }
+  setName(_name) {
+  }
+  setMetadata(_metadata) {
+  }
+  addChild(_node) {
+  }
+  removeChild(_name) {
+    return false;
+  }
+  setItems(_node) {
+  }
+  setDefaultValue(_value) {
+  }
+  setFormula(_formula) {
+  }
+  setForeignKey(_key) {
+  }
+};
+var NULL_NODE = new NullNodeImpl();
+
+// src/core/schema-node/BaseNode.ts
+var BaseNode = class {
+  constructor(_id, name, metadata = EMPTY_METADATA) {
+    this._id = _id;
+    this._name = name;
+    this._metadata = metadata;
+  }
+  _name;
+  _metadata;
+  id() {
+    return this._id;
+  }
+  name() {
+    return this._name;
+  }
+  metadata() {
+    return this._metadata;
+  }
+  isObject() {
+    return false;
+  }
+  isArray() {
+    return false;
+  }
+  isPrimitive() {
+    return false;
+  }
+  isRef() {
+    return false;
+  }
+  isNull() {
+    return false;
+  }
+  property(_name) {
+    return NULL_NODE;
+  }
+  properties() {
+    return [];
+  }
+  items() {
+    return NULL_NODE;
+  }
+  ref() {
+    return void 0;
+  }
+  formula() {
+    return void 0;
+  }
+  hasFormula() {
+    return false;
+  }
+  defaultValue() {
+    return void 0;
+  }
+  foreignKey() {
+    return void 0;
+  }
+  setName(name) {
+    this._name = name;
+  }
+  setMetadata(metadata) {
+    this._metadata = metadata;
+  }
+  addChild(_node) {
+  }
+  removeChild(_name) {
+    return false;
+  }
+  setItems(_node) {
+  }
+  setDefaultValue(_value) {
+  }
+  setFormula(_formula) {
+  }
+  setForeignKey(_key) {
+  }
+};
+
+// src/core/schema-node/ObjectNode.ts
+var ObjectNode = class _ObjectNode extends BaseNode {
+  _children;
+  constructor(id, name, children = [], metadata = EMPTY_METADATA) {
+    super(id, name, metadata);
+    this._children = [...children];
+  }
+  nodeType() {
+    return "object";
+  }
+  isObject() {
+    return true;
+  }
+  property(name) {
+    return this._children.find((child) => child.name() === name) ?? NULL_NODE;
+  }
+  properties() {
+    return this._children;
+  }
+  clone() {
+    return new _ObjectNode(
+      this.id(),
+      this.name(),
+      this._children.map((child) => child.clone()),
+      this.metadata()
+    );
+  }
+  addChild(node) {
+    this._children.push(node);
+  }
+  removeChild(name) {
+    const index = this._children.findIndex((child) => child.name() === name);
+    if (index === -1) {
+      return false;
+    }
+    this._children.splice(index, 1);
+    return true;
+  }
+};
+function createObjectNode(id, name, children = [], metadata = EMPTY_METADATA) {
+  return new ObjectNode(id, name, children, metadata);
+}
+
+// src/core/schema-node/ArrayNode.ts
+var ArrayNode = class _ArrayNode extends BaseNode {
+  _items;
+  constructor(id, name, items, metadata = EMPTY_METADATA) {
+    super(id, name, metadata);
+    this._items = items;
+  }
+  nodeType() {
+    return "array";
+  }
+  isArray() {
+    return true;
+  }
+  properties() {
+    return [this._items];
+  }
+  items() {
+    return this._items;
+  }
+  clone() {
+    return new _ArrayNode(
+      this.id(),
+      this.name(),
+      this._items.clone(),
+      this.metadata()
+    );
+  }
+  setItems(node) {
+    this._items = node;
+  }
+};
+function createArrayNode(id, name, items, metadata = EMPTY_METADATA) {
+  return new ArrayNode(id, name, items, metadata);
+}
+
+// src/core/schema-node/PrimitiveNode.ts
+var PrimitiveNode = class extends BaseNode {
+  _defaultValue;
+  _foreignKey;
+  _formula;
+  constructor(id, name, options = {}) {
+    super(id, name, options.metadata ?? EMPTY_METADATA);
+    this._defaultValue = options.defaultValue;
+    this._foreignKey = options.foreignKey;
+    this._formula = options.formula;
+  }
+  isPrimitive() {
+    return true;
+  }
+  formula() {
+    return this._formula;
+  }
+  hasFormula() {
+    return this._formula !== void 0;
+  }
+  defaultValue() {
+    return this._defaultValue;
+  }
+  foreignKey() {
+    return this._foreignKey;
+  }
+  setDefaultValue(value) {
+    this._defaultValue = value;
+  }
+  setFormula(formula) {
+    this._formula = formula;
+  }
+  setForeignKey(key) {
+    this._foreignKey = key;
+  }
+};
+
+// src/core/schema-node/StringNode.ts
+var StringNode = class _StringNode extends PrimitiveNode {
+  constructor(id, name, options = {}) {
+    super(id, name, options);
+  }
+  nodeType() {
+    return "string";
+  }
+  clone() {
+    return new _StringNode(this.id(), this.name(), this.cloneOptions());
+  }
+  cloneOptions() {
+    return {
+      defaultValue: this._defaultValue,
+      foreignKey: this._foreignKey,
+      formula: this._formula,
+      metadata: this._metadata
+    };
+  }
+};
+function createStringNode(id, name, options = {}) {
+  return new StringNode(id, name, options);
+}
+
+// src/core/schema-node/NumberNode.ts
+var NumberNode = class _NumberNode extends PrimitiveNode {
+  constructor(id, name, options = {}) {
+    super(id, name, options);
+  }
+  nodeType() {
+    return "number";
+  }
+  clone() {
+    return new _NumberNode(this.id(), this.name(), this.cloneOptions());
+  }
+  cloneOptions() {
+    return {
+      defaultValue: this._defaultValue,
+      formula: this._formula,
+      metadata: this._metadata
+    };
+  }
+};
+function createNumberNode(id, name, options = {}) {
+  return new NumberNode(id, name, options);
+}
+
+// src/core/schema-node/BooleanNode.ts
+var BooleanNode = class _BooleanNode extends PrimitiveNode {
+  constructor(id, name, options = {}) {
+    super(id, name, options);
+  }
+  nodeType() {
+    return "boolean";
+  }
+  clone() {
+    return new _BooleanNode(this.id(), this.name(), this.cloneOptions());
+  }
+  cloneOptions() {
+    return {
+      defaultValue: this._defaultValue,
+      formula: this._formula,
+      metadata: this._metadata
+    };
+  }
+};
+function createBooleanNode(id, name, options = {}) {
+  return new BooleanNode(id, name, options);
+}
+
+// src/core/schema-node/RefNode.ts
+var RefNode = class _RefNode extends BaseNode {
+  _ref;
+  constructor(id, name, ref, metadata = EMPTY_METADATA) {
+    super(id, name, metadata);
+    if (!ref) {
+      throw new Error("RefNode requires a non-empty ref");
+    }
+    this._ref = ref;
+  }
+  nodeType() {
+    return "ref";
+  }
+  isRef() {
+    return true;
+  }
+  ref() {
+    return this._ref;
+  }
+  clone() {
+    return new _RefNode(this.id(), this.name(), this._ref, this.metadata());
+  }
+};
+function createRefNode(id, name, ref, metadata = EMPTY_METADATA) {
+  return new RefNode(id, name, ref, metadata);
+}
+
+// src/core/path/PathSegment.ts
+var PropertySegment = class {
+  constructor(name) {
+    this.name = name;
+  }
+  isProperty() {
+    return true;
+  }
+  isItems() {
+    return false;
+  }
+  propertyName() {
+    return this.name;
+  }
+  equals(other) {
+    return other.isProperty() && other.propertyName() === this.name;
+  }
+};
+var ItemsSegment = class {
+  isProperty() {
+    return false;
+  }
+  isItems() {
+    return true;
+  }
+  propertyName() {
+    throw new Error("Items segment has no property name");
+  }
+  equals(other) {
+    return other.isItems();
+  }
+};
+
+// src/core/base-path/AbstractBasePath.ts
+var AbstractBasePath = class {
+  constructor(segs) {
+    this.segs = segs;
+  }
+  segments() {
+    return this.segs;
+  }
+  equals(other) {
+    const otherSegs = other.segments();
+    if (this.segs.length !== otherSegs.length) {
+      return false;
+    }
+    for (let i = 0; i < this.segs.length; i++) {
+      const a = this.segs[i];
+      const b = otherSegs[i];
+      if (!a || !b || !a.equals(b)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isEmpty() {
+    return this.segs.length === 0;
+  }
+  length() {
+    return this.segs.length;
+  }
+  isChildOf(parent) {
+    const parentSegs = parent.segments();
+    if (this.segs.length <= parentSegs.length) {
+      return false;
+    }
+    for (let i = 0; i < parentSegs.length; i++) {
+      const a = this.segs[i];
+      const b = parentSegs[i];
+      if (!a || !b || !a.equals(b)) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
+
+// src/core/path/Path.ts
+var PathImpl = class _PathImpl extends AbstractBasePath {
+  asJsonPointer() {
+    return this.segs.map(
+      (seg) => seg.isProperty() ? `/properties/${seg.propertyName()}` : "/items"
+    ).join("");
+  }
+  asSimple() {
+    const parts = [];
+    for (const seg of this.segs) {
+      if (seg.isProperty()) {
+        parts.push(seg.propertyName());
+      } else if (seg.isItems()) {
+        if (parts.length > 0) {
+          const lastIndex = parts.length - 1;
+          const lastPart = parts[lastIndex];
+          if (lastPart !== void 0) {
+            parts[lastIndex] = lastPart + "[*]";
+          }
+        } else {
+          parts.push("[*]");
+        }
+      }
+    }
+    return parts.join(".");
+  }
+  parent() {
+    if (this.segs.length <= 1) {
+      return EMPTY_PATH;
+    }
+    return new _PathImpl(this.segs.slice(0, -1));
+  }
+  child(name) {
+    return new _PathImpl([...this.segs, new PropertySegment(name)]);
+  }
+  childItems() {
+    return new _PathImpl([...this.segs, new ItemsSegment()]);
+  }
+};
+var EMPTY_PATH = new PathImpl([]);
+function createPath(segments) {
+  return segments.length === 0 ? EMPTY_PATH : new PathImpl(segments);
+}
+
+// src/core/path/PathParser.ts
+function jsonPointerToSegments(pointer) {
+  if (pointer === "" || pointer === "/") {
+    return [];
+  }
+  const parts = pointer.split("/").filter(Boolean);
+  const segments = [];
+  let i = 0;
+  while (i < parts.length) {
+    const part = parts[i];
+    if (part === "properties") {
+      const name = parts[i + 1];
+      if (name === void 0 || name === "") {
+        throw new Error(
+          `Invalid path: 'properties' segment requires a name in path ${pointer}`
+        );
+      }
+      segments.push(new PropertySegment(name));
+      i += 2;
+    } else if (part === "items") {
+      segments.push(new ItemsSegment());
+      i += 1;
+    } else {
+      throw new Error(`Invalid path segment: ${part} in path ${pointer}`);
+    }
+  }
+  return segments;
+}
+function jsonPointerToPath(pointer) {
+  return createPath(jsonPointerToSegments(pointer));
+}
+function jsonPointerToSimplePath(pointer) {
+  return jsonPointerToPath(pointer).asSimple();
+}
+
+// src/core/schema-tree/TreeNodeIndex.ts
+var TreeNodeIndex = class {
+  nodeIndex = /* @__PURE__ */ new Map();
+  pathIndex = /* @__PURE__ */ new Map();
+  rebuild(rootNode) {
+    this.nodeIndex.clear();
+    this.pathIndex.clear();
+    this.collectNodes(rootNode, EMPTY_PATH);
+  }
+  getNode(id) {
+    return this.nodeIndex.get(id) ?? NULL_NODE;
+  }
+  getPath(id) {
+    return this.pathIndex.get(id) ?? EMPTY_PATH;
+  }
+  countNodes() {
+    return this.nodeIndex.size;
+  }
+  nodeIds() {
+    return this.nodeIndex.keys();
+  }
+  collectNodes(node, path) {
+    this.nodeIndex.set(node.id(), node);
+    this.pathIndex.set(node.id(), path);
+    if (node.isObject()) {
+      for (const child of node.properties()) {
+        this.collectNodes(child, path.child(child.name()));
+      }
+    } else if (node.isArray()) {
+      this.collectNodes(node.items(), path.childItems());
+    }
+  }
+};
+
+// src/core/schema-tree/SchemaTreeImpl.ts
+var SchemaTreeImpl = class _SchemaTreeImpl {
+  constructor(rootNode) {
+    this.rootNode = rootNode;
+    this.index.rebuild(rootNode);
+  }
+  index = new TreeNodeIndex();
+  _replacements = /* @__PURE__ */ new Map();
+  root() {
+    return this.rootNode;
+  }
+  nodeById(id) {
+    return this.index.getNode(id);
+  }
+  pathOf(id) {
+    return this.index.getPath(id);
+  }
+  nodeAt(path) {
+    if (path.isEmpty()) {
+      return this.rootNode;
+    }
+    let current = this.rootNode;
+    for (const segment of path.segments()) {
+      if (current.isNull()) {
+        return NULL_NODE;
+      }
+      if (segment.isItems()) {
+        current = current.items();
+      } else {
+        current = current.property(segment.propertyName());
+      }
+    }
+    return current;
+  }
+  nodeIds() {
+    return this.index.nodeIds();
+  }
+  countNodes() {
+    return this.index.countNodes();
+  }
+  clone() {
+    const cloned = new _SchemaTreeImpl(this.rootNode.clone());
+    for (const [oldId, newId] of this._replacements) {
+      cloned._replacements.set(oldId, newId);
+    }
+    return cloned;
+  }
+  trackReplacement(oldNodeId, newNodeId) {
+    this._replacements.set(oldNodeId, newNodeId);
+  }
+  replacements() {
+    return this._replacements.entries();
+  }
+  addChildTo(parentId, node) {
+    const parent = this.nodeById(parentId);
+    if (parent.isNull()) {
+      return;
+    }
+    if (parent.isArray()) {
+      throw new Error("Cannot add child to array node. Use setItems instead.");
+    }
+    parent.addChild(node);
+    this.rebuildIndex();
+  }
+  removeNodeAt(path) {
+    if (path.isEmpty()) {
+      return false;
+    }
+    const parentPath = path.parent();
+    const parent = this.nodeAt(parentPath);
+    if (parent.isNull()) {
+      return false;
+    }
+    const lastSegment = path.segments().at(-1);
+    if (!lastSegment || lastSegment.isItems()) {
+      return false;
+    }
+    const removed = parent.removeChild(lastSegment.propertyName());
+    if (removed) {
+      this.rebuildIndex();
+    }
+    return removed;
+  }
+  renameNode(nodeId, newName) {
+    const node = this.nodeById(nodeId);
+    if (node.isNull()) {
+      return;
+    }
+    node.setName(newName);
+    this.rebuildIndex();
+  }
+  moveNode(nodeId, newParentId) {
+    const node = this.nodeById(nodeId);
+    if (node.isNull()) {
+      return;
+    }
+    const currentPath = this.pathOf(nodeId);
+    if (currentPath.isEmpty()) {
+      return;
+    }
+    const currentParentPath = currentPath.parent();
+    const currentParent = this.nodeAt(currentParentPath);
+    if (currentParent.isNull()) {
+      return;
+    }
+    if (currentParent.isArray()) {
+      throw new Error("Cannot move node from array. Array items cannot be moved.");
+    }
+    const newParent = this.nodeById(newParentId);
+    if (newParent.isNull()) {
+      return;
+    }
+    if (newParent.isArray()) {
+      throw new Error("Cannot move node into array. Use setItems instead.");
+    }
+    const newParentPath = this.pathOf(newParentId);
+    if (newParentPath.equals(currentPath) || newParentPath.isChildOf(currentPath)) {
+      return;
+    }
+    currentParent.removeChild(node.name());
+    newParent.addChild(node);
+    this.rebuildIndex();
+  }
+  setNodeAt(path, node) {
+    if (path.isEmpty()) {
+      return;
+    }
+    const parentPath = path.parent();
+    const parent = this.nodeAt(parentPath);
+    if (parent.isNull()) {
+      return;
+    }
+    const lastSegment = path.segments().at(-1);
+    if (!lastSegment) {
+      return;
+    }
+    if (lastSegment.isItems()) {
+      parent.setItems(node);
+    } else {
+      parent.removeChild(lastSegment.propertyName());
+      node.setName(lastSegment.propertyName());
+      parent.addChild(node);
+    }
+    this.rebuildIndex();
+  }
+  rebuildIndex() {
+    this.index.rebuild(this.rootNode);
+  }
+};
+function createSchemaTree(root) {
+  return new SchemaTreeImpl(root);
+}
+
+// src/core/schema-diff/NodePathIndex.ts
+var NodePathIndex = class {
+  _basePaths = /* @__PURE__ */ new Map();
+  _replacements = /* @__PURE__ */ new Map();
+  constructor(baseTree) {
+    for (const nodeId of baseTree.nodeIds()) {
+      this._basePaths.set(nodeId, baseTree.pathOf(nodeId));
+    }
+  }
+  hasBasePath(nodeId) {
+    return this._basePaths.has(nodeId);
+  }
+  getBasePath(nodeId) {
+    return this._basePaths.get(nodeId);
+  }
+  trackReplacement(oldNodeId, newNodeId) {
+    this._replacements.set(oldNodeId, newNodeId);
+  }
+  getReplacementNodeId(oldNodeId) {
+    return this._replacements.get(oldNodeId);
+  }
+  getOriginalNodeId(newNodeId) {
+    for (const [oldId, newId] of this._replacements) {
+      if (newId === newNodeId) {
+        return oldId;
+      }
+    }
+    return void 0;
+  }
+  isReplacement(nodeId) {
+    for (const newId of this._replacements.values()) {
+      if (newId === nodeId) {
+        return true;
+      }
+    }
+    return false;
+  }
+  get replacements() {
+    return this._replacements;
+  }
+};
+
+// src/model/schema-formula/core/FormulaError.ts
+var FormulaError = class extends Error {
+  constructor(message, nodeId, details) {
+    super(message);
+    this.nodeId = nodeId;
+    this.details = details;
+    this.name = "FormulaError";
+  }
+};
+
+// src/model/schema-formula/serialization/FormulaPathBuilder.ts
+var FormulaPathBuilder = class {
+  buildWithArrayNotation(fromPath, toPath) {
+    const fromSegments = fromPath.parent().segments();
+    const toSegments = toPath.segments();
+    const commonLength = this.findCommonPrefixLength(fromSegments, toSegments);
+    const upCount = fromSegments.length - commonLength;
+    const parts = this.buildPartsWithArrayNotation(
+      upCount,
+      toSegments,
+      commonLength
+    );
+    return this.formatPartsWithArrayNotation(parts, toSegments);
+  }
+  findCommonPrefixLength(fromSegments, toSegments) {
+    const minLen = Math.min(fromSegments.length, toSegments.length);
+    let commonPrefixLen = 0;
+    for (let i = 0; i < minLen; i++) {
+      const fromSeg = fromSegments[i];
+      const toSeg = toSegments[i];
+      if (!fromSeg || !toSeg) {
+        break;
+      }
+      if (fromSeg.isItems() && toSeg.isItems()) {
+        commonPrefixLen++;
+      } else if (fromSeg.isProperty() && toSeg.isProperty() && fromSeg.propertyName() === toSeg.propertyName()) {
+        commonPrefixLen++;
+      } else {
+        break;
+      }
+    }
+    return commonPrefixLen;
+  }
+  buildPartsWithArrayNotation(upCount, toSegments, startIndex) {
+    const parts = [];
+    for (let i = 0; i < upCount; i++) {
+      parts.push("..");
+    }
+    for (let i = startIndex; i < toSegments.length; i++) {
+      const seg = toSegments[i];
+      if (seg) {
+        if (seg.isProperty()) {
+          parts.push(seg.propertyName());
+        } else if (seg.isItems() && parts.length > 0) {
+          const lastPart = parts.at(-1);
+          if (lastPart && lastPart !== "..") {
+            parts[parts.length - 1] = lastPart + "[*]";
+          }
+        }
+      }
+    }
+    return parts;
+  }
+  formatPartsWithArrayNotation(parts, toSegments) {
+    if (parts.length === 0) {
+      const lastSeg = toSegments.at(-1);
+      if (lastSeg?.isProperty()) {
+        return lastSeg.propertyName();
+      }
+      return "";
+    }
+    if (parts[0] === "..") {
+      return parts.join("/");
+    }
+    return parts.join(".");
+  }
+};
+
+// src/model/schema-formula/serialization/FormulaSerializer.ts
+var FormulaSerializer = class _FormulaSerializer {
+  constructor(tree, formulaNodeId, formula) {
+    this.tree = tree;
+    this.formulaNodeId = formulaNodeId;
+    this.formula = formula;
+  }
+  pathBuilder = new FormulaPathBuilder();
+  static toXFormula(tree, formulaNodeId, formula) {
+    const serializer = new _FormulaSerializer(tree, formulaNodeId, formula);
+    return {
+      version: 1,
+      expression: serializer.serialize()
+    };
+  }
+  static serializeExpression(tree, formulaNodeId, formula, options = {}) {
+    const serializer = new _FormulaSerializer(tree, formulaNodeId, formula);
+    return serializer.serialize(options);
+  }
+  serialize(options = {}) {
+    const replacements = this.buildPathReplacements(options);
+    const updatedAst = formula.replaceDependencies(this.formula.ast(), replacements);
+    return formula.serializeAst(updatedAst);
+  }
+  buildPathReplacements(options) {
+    const replacements = {};
+    const formulaPath = this.tree.pathOf(this.formulaNodeId);
+    const strict = options.strict ?? true;
+    for (const astPath of this.formula.astPaths()) {
+      const nodeId = this.formula.getNodeIdForAstPath(astPath);
+      if (!nodeId) {
+        continue;
+      }
+      const targetNode = this.tree.nodeById(nodeId);
+      if (targetNode.isNull()) {
+        if (strict) {
+          throw new FormulaError(
+            `Cannot serialize formula: target node not found`,
+            this.formulaNodeId,
+            `Target nodeId: ${nodeId}`
+          );
+        }
+        continue;
+      }
+      const targetPath = this.tree.pathOf(nodeId);
+      const newPath = this.pathBuilder.buildWithArrayNotation(
+        formulaPath,
+        targetPath
+      );
+      if (this.needsReplacement(astPath, newPath)) {
+        replacements[astPath] = newPath;
+      }
+    }
+    return replacements;
+  }
+  needsReplacement(astPath, newPath) {
+    if (astPath === newPath) {
+      return false;
+    }
+    const normalizedAstPath = this.normalizeArrayNotation(astPath);
+    const normalizedNewPath = this.normalizeArrayNotation(newPath);
+    return normalizedAstPath !== normalizedNewPath;
+  }
+  normalizeArrayNotation(path) {
+    return path.replaceAll(/\[\d+\]/g, "[*]");
+  }
+};
+
+// src/core/schema-diff/SchemaComparator.ts
+function areNodesEqual(current, base, context) {
+  if (current.nodeType() !== base.nodeType()) {
+    return false;
+  }
+  if (current.name() !== base.name()) {
+    return false;
+  }
+  if (!areMetadataEqual(current, base)) {
+    return false;
+  }
+  if (current.isPrimitive()) {
+    return arePrimitivesEqual(current, base, context);
+  }
+  if (current.isObject()) {
+    return areObjectsEqual(current, base, context);
+  }
+  if (current.isArray()) {
+    return areArraysEqual(current, base, context);
+  }
+  if (current.isRef()) {
+    return current.ref() === base.ref();
+  }
+  return current.isNull() && base.isNull();
+}
+function areNodesContentEqual(current, base, context) {
+  if (current.nodeType() !== base.nodeType()) {
+    return false;
+  }
+  if (!areMetadataEqual(current, base)) {
+    return false;
+  }
+  if (current.isPrimitive()) {
+    return arePrimitivesEqual(current, base, context);
+  }
+  if (current.isObject()) {
+    return areObjectsEqual(current, base, context);
+  }
+  if (current.isArray()) {
+    return areArraysEqual(current, base, context);
+  }
+  if (current.isRef()) {
+    return current.ref() === base.ref();
+  }
+  return current.isNull() && base.isNull();
+}
+function areMetadataEqual(current, base) {
+  const metaCurrent = current.metadata();
+  const metaBase = base.metadata();
+  return metaCurrent.title === metaBase.title && metaCurrent.description === metaBase.description && metaCurrent.deprecated === metaBase.deprecated;
+}
+function arePrimitivesEqual(current, base, context) {
+  if (current.defaultValue() !== base.defaultValue()) {
+    return false;
+  }
+  if (current.foreignKey() !== base.foreignKey()) {
+    return false;
+  }
+  const currentFormula = current.formula();
+  const baseFormula = base.formula();
+  if (currentFormula === void 0 && baseFormula === void 0) {
+    return true;
+  }
+  if (currentFormula === void 0 || baseFormula === void 0) {
+    return false;
+  }
+  return areFormulasEqual(
+    currentFormula,
+    baseFormula,
+    current.id(),
+    base.id(),
+    context
+  );
+}
+function areFormulasEqual(currentFormula, baseFormula, currentNodeId, baseNodeId, context) {
+  if (currentFormula.version() !== baseFormula.version()) {
+    return false;
+  }
+  const currentExpr = getSerializedExpression(
+    currentFormula,
+    context.currentTree,
+    currentNodeId
+  );
+  const baseExpr = getSerializedExpression(
+    baseFormula,
+    context.baseTree,
+    baseNodeId
+  );
+  return currentExpr === baseExpr;
+}
+function getSerializedExpression(formula, tree, nodeId) {
+  return FormulaSerializer.serializeExpression(tree, nodeId, formula, { strict: false });
+}
+function areObjectsEqual(current, base, context) {
+  const propsCurrent = current.properties();
+  const propsBase = base.properties();
+  if (propsCurrent.length !== propsBase.length) {
+    return false;
+  }
+  for (const propCurrent of propsCurrent) {
+    const propBase = propsBase.find((p) => p.name() === propCurrent.name());
+    if (!propBase || !areNodesEqual(propCurrent, propBase, context)) {
+      return false;
+    }
+  }
+  return true;
+}
+function areArraysEqual(current, base, context) {
+  if (current.defaultValue() !== base.defaultValue()) {
+    return false;
+  }
+  return areNodesEqual(current.items(), base.items(), context);
+}
+
+// src/core/schema-diff/ChangeCollector.ts
+var ChangeCollector = class {
+  constructor(baseTree, currentTree, index) {
+    this.baseTree = baseTree;
+    this.currentTree = currentTree;
+    this.index = index;
+    this.context = { currentTree, baseTree };
+  }
+  context;
+  collect() {
+    const changes = [];
+    this.collectFromCurrentTree(changes);
+    this.collectRemovedNodes(changes);
+    return changes;
+  }
+  collectFromCurrentTree(changes) {
+    for (const nodeId of this.currentTree.nodeIds()) {
+      const currentNode = this.currentTree.nodeById(nodeId);
+      if (this.index.isReplacement(nodeId)) {
+        const originalId = this.index.getOriginalNodeId(nodeId);
+        if (originalId) {
+          const baseNode2 = this.baseTree.nodeById(originalId);
+          changes.push({
+            type: "modified",
+            baseNode: baseNode2,
+            currentNode
+          });
+        }
+        continue;
+      }
+      const basePath = this.index.getBasePath(nodeId);
+      if (!basePath) {
+        changes.push({
+          type: "added",
+          baseNode: null,
+          currentNode
+        });
+        continue;
+      }
+      const currentPath = this.currentTree.pathOf(nodeId);
+      const baseNode = this.baseTree.nodeById(nodeId);
+      if (!basePath.equals(currentPath)) {
+        changes.push({
+          type: "moved",
+          baseNode,
+          currentNode
+        });
+        if (!areNodesContentEqual(currentNode, baseNode, this.context)) {
+          changes.push({
+            type: "modified",
+            baseNode,
+            currentNode
+          });
+        }
+      } else if (!areNodesEqual(currentNode, baseNode, this.context)) {
+        changes.push({
+          type: "modified",
+          baseNode,
+          currentNode
+        });
+      }
+    }
+  }
+  collectRemovedNodes(changes) {
+    for (const nodeId of this.baseTree.nodeIds()) {
+      if (this.index.getReplacementNodeId(nodeId)) {
+        continue;
+      }
+      const currentNode = this.currentTree.nodeById(nodeId);
+      if (currentNode.isNull()) {
+        const baseNode = this.baseTree.nodeById(nodeId);
+        changes.push({
+          type: "removed",
+          baseNode,
+          currentNode: null
+        });
+      }
+    }
+  }
+};
+function collectChanges(baseTree, currentTree, index) {
+  return new ChangeCollector(baseTree, currentTree, index).collect();
+}
+
+// src/core/schema-diff/ChangeCoalescer.ts
+var ChangeCoalescer = class {
+  constructor(currentTree, index) {
+    this.currentTree = currentTree;
+    this.index = index;
+  }
+  coalesce(changes) {
+    const moved = [];
+    const added = [];
+    const removed = [];
+    const modified = [];
+    const movedPaths = this.getMovedPaths(changes);
+    for (const change of changes) {
+      if (this.isNestedChange(change, changes, movedPaths)) {
+        continue;
+      }
+      switch (change.type) {
+        case "moved":
+          moved.push(change);
+          break;
+        case "added":
+          added.push(change);
+          break;
+        case "removed":
+          removed.push(change);
+          break;
+        case "modified":
+          modified.push(change);
+          break;
+      }
+    }
+    return { moved, added, removed, modified };
+  }
+  getMovedPaths(changes) {
+    const paths = /* @__PURE__ */ new Set();
+    for (const change of changes) {
+      if (change.type === "moved") {
+        const basePath = this.index.getBasePath(change.baseNode.id());
+        if (basePath) {
+          paths.add(basePath.asJsonPointer());
+        }
+      }
+    }
+    return paths;
+  }
+  isNestedChange(change, allChanges, movedPaths) {
+    const path = this.getChangePath(change);
+    if (this.hasParentChange(change, allChanges, path)) {
+      return true;
+    }
+    if (this.isAffectedByMove(change, movedPaths)) {
+      return true;
+    }
+    return false;
+  }
+  getChangePath(change) {
+    if (change.type === "removed") {
+      const basePath = this.index.getBasePath(change.baseNode.id());
+      if (!basePath) {
+        throw new Error(
+          `Base path not found for removed node: ${change.baseNode.id()}`
+        );
+      }
+      return basePath;
+    }
+    return this.currentTree.pathOf(change.currentNode.id());
+  }
+  hasParentChange(change, allChanges, path) {
+    for (const other of allChanges) {
+      if (other === change) continue;
+      if (other.type === "modified") {
+        if (!this.isTypeChangeReplacement(other)) {
+          continue;
+        }
+      }
+      const otherPath = this.getChangePath(other);
+      if (path.isChildOf(otherPath)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  isTypeChangeReplacement(change) {
+    return change.baseNode.nodeType() !== change.currentNode.nodeType();
+  }
+  isAffectedByMove(change, movedPaths) {
+    if (change.type !== "modified") {
+      return false;
+    }
+    const basePath = this.index.getBasePath(change.baseNode.id());
+    if (!basePath) {
+      return false;
+    }
+    for (const movedPath of movedPaths) {
+      if (basePath.asJsonPointer().startsWith(movedPath + "/") && basePath.asJsonPointer() !== movedPath) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+function coalesceChanges(changes, currentTree, index) {
+  return new ChangeCoalescer(currentTree, index).coalesce(changes);
+}
+
+// src/core/schema-diff/SchemaDiff.ts
+var SchemaDiff = class {
+  _baseTree;
+  _currentTree;
+  _index;
+  constructor(currentTree) {
+    this._currentTree = currentTree;
+    this._baseTree = currentTree.clone();
+    this._index = new NodePathIndex(this._baseTree);
+  }
+  get baseTree() {
+    return this._baseTree;
+  }
+  get currentTree() {
+    return this._currentTree;
+  }
+  get index() {
+    return this._index;
+  }
+  isDirty() {
+    const changes = this.collectChanges();
+    return changes.length > 0;
+  }
+  collectChanges() {
+    return collectChanges(this._baseTree, this._currentTree, this._index);
+  }
+  coalesceChanges(changes) {
+    const rawChanges = changes ?? this.collectChanges();
+    return coalesceChanges(rawChanges, this._currentTree, this._index);
+  }
+  trackReplacement(oldNodeId, newNodeId) {
+    this._index.trackReplacement(oldNodeId, newNodeId);
+  }
+  markAsSaved() {
+    this._baseTree = this._currentTree.clone();
+    this._index = new NodePathIndex(this._baseTree);
+  }
+};
+
+// src/model/schema-formula/core/FormulaDependency.ts
+var ResolvedDependency = class {
+  constructor(nodeId) {
+    this.nodeId = nodeId;
+    if (!nodeId) {
+      throw new Error("ResolvedDependency requires a non-empty nodeId");
+    }
+  }
+  targetNodeId() {
+    return this.nodeId;
+  }
+};
+var ARRAY_NOTATION_REGEX = /^([^[]+)\[(?:\d+|\*)?\]$/;
+var FormulaPath = class {
+  constructor(basePath, relativePath) {
+    this.basePath = basePath;
+    this.relativePath = relativePath;
+  }
+  resolve() {
+    let ast;
+    try {
+      const parseResult = formula.parseFormula(this.relativePath);
+      ast = parseResult.ast;
+    } catch {
+      return null;
+    }
+    return this.astToPath(ast, this.basePath);
+  }
+  astToPath(ast, base) {
+    switch (ast.type) {
+      case "Identifier":
+        return base.child(ast.name);
+      case "MemberExpression": {
+        const objectPath = this.astToPath(ast.object, base);
+        if (!objectPath) {
+          return null;
+        }
+        return objectPath.child(ast.property);
+      }
+      case "IndexExpression":
+      case "WildcardExpression": {
+        const objectPath = this.astToPath(ast.object, base);
+        if (!objectPath) {
+          return null;
+        }
+        return objectPath.childItems();
+      }
+      case "RelativePath":
+        return this.resolveRelativePathString(base, ast.path);
+      case "RootPath":
+        return this.resolveRootPath(ast.path);
+      default:
+        return null;
+    }
+  }
+  resolveRelativePathString(base, path) {
+    const parts = path.split("/");
+    let result = base;
+    for (const part of parts) {
+      if (part === "..") {
+        if (result.isEmpty()) {
+          return null;
+        }
+        result = result.parent();
+      } else if (part === ".") {
+        continue;
+      } else if (part) {
+        result = result.child(part);
+      }
+    }
+    return result;
+  }
+  resolveRootPath(rootPath) {
+    const path = rootPath.startsWith("/") ? rootPath.slice(1) : rootPath;
+    if (!path) {
+      return EMPTY_PATH;
+    }
+    try {
+      return this.parseFormulaPath(path);
+    } catch {
+      return null;
+    }
+  }
+  parseFormulaPath(formulaPath) {
+    const parts = formulaPath.split(".");
+    let result = EMPTY_PATH;
+    for (const part of parts) {
+      if (!part) {
+        throw new Error(`Invalid path: empty segment`);
+      }
+      const match = ARRAY_NOTATION_REGEX.exec(part);
+      if (match?.[1]) {
+        result = result.child(match[1]).childItems();
+      } else {
+        result = result.child(part);
+      }
+    }
+    return result;
+  }
+};
+
+// src/model/schema-formula/parsing/ParsedFormula.ts
+var ParsedFormula = class {
+  _expression;
+  astNode;
+  deps;
+  astPathToNodeId;
+  constructor(tree, formulaNodeId, expression) {
+    this._expression = expression;
+    const parseResult = formula.parseFormula(expression);
+    this.astNode = parseResult.ast;
+    const formulaPath = tree.pathOf(formulaNodeId);
+    if (formulaPath.isEmpty() && tree.root().id() !== formulaNodeId) {
+      throw new FormulaError("Formula node not found in tree", formulaNodeId);
+    }
+    const deps = [];
+    const astPathToNodeId = /* @__PURE__ */ new Map();
+    for (const depPath of parseResult.dependencies) {
+      const targetNodeId = this.resolveDependencyPath(
+        tree,
+        formulaPath,
+        depPath
+      );
+      if (!targetNodeId) {
+        throw new FormulaError(
+          `Cannot resolve formula dependency: ${depPath}`,
+          formulaNodeId,
+          "Path not found in schema"
+        );
+      }
+      if (targetNodeId === formulaNodeId) {
+        throw new FormulaError(
+          "Formula cannot reference itself",
+          formulaNodeId,
+          "Self-reference detected"
+        );
+      }
+      deps.push(new ResolvedDependency(targetNodeId));
+      astPathToNodeId.set(depPath, targetNodeId);
+    }
+    this.deps = deps;
+    this.astPathToNodeId = astPathToNodeId;
+  }
+  version() {
+    return 1;
+  }
+  expression() {
+    return this._expression;
+  }
+  ast() {
+    return this.astNode;
+  }
+  dependencies() {
+    return this.deps;
+  }
+  getNodeIdForAstPath(astPath) {
+    return this.astPathToNodeId.get(astPath) ?? null;
+  }
+  astPaths() {
+    return Array.from(this.astPathToNodeId.keys());
+  }
+  resolveDependencyPath(tree, formulaNodePath, depPath) {
+    const basePath = this.getFormulaBasePath(formulaNodePath);
+    const depFormulaPath = new FormulaPath(basePath, depPath);
+    const targetPath = depFormulaPath.resolve();
+    if (!targetPath) {
+      return null;
+    }
+    const targetNode = tree.nodeAt(targetPath);
+    if (targetNode.isNull()) {
+      return null;
+    }
+    return targetNode.id();
+  }
+  getFormulaBasePath(formulaPath) {
+    let basePath = formulaPath;
+    while (!basePath.isEmpty()) {
+      const segs = basePath.segments();
+      const lastSeg = segs[segs.length - 1];
+      basePath = basePath.parent();
+      if (!lastSeg?.isItems()) {
+        break;
+      }
+    }
+    return basePath;
+  }
+};
+
+// src/model/schema-formula/store/FormulaDependencyIndex.ts
+var FormulaDependencyIndex = class {
+  dependentsMap = /* @__PURE__ */ new Map();
+  formulasByNodeId = /* @__PURE__ */ new Map();
+  registerFormula(formulaNodeId, formula) {
+    this.unregisterFormula(formulaNodeId);
+    this.formulasByNodeId.set(formulaNodeId, formula);
+    for (const dep of formula.dependencies()) {
+      const targetId = dep.targetNodeId();
+      let dependents = this.dependentsMap.get(targetId);
+      if (!dependents) {
+        dependents = /* @__PURE__ */ new Set();
+        this.dependentsMap.set(targetId, dependents);
+      }
+      dependents.add(formulaNodeId);
+    }
+  }
+  unregisterFormula(formulaNodeId) {
+    this.formulasByNodeId.delete(formulaNodeId);
+    for (const [targetId, dependents] of this.dependentsMap) {
+      dependents.delete(formulaNodeId);
+      if (dependents.size === 0) {
+        this.dependentsMap.delete(targetId);
+      }
+    }
+  }
+  getDependents(nodeId) {
+    const dependents = this.dependentsMap.get(nodeId);
+    return dependents ? Array.from(dependents) : [];
+  }
+  hasDependents(nodeId) {
+    const dependents = this.dependentsMap.get(nodeId);
+    return dependents !== void 0 && dependents.size > 0;
+  }
+  getFormula(nodeId) {
+    return this.formulasByNodeId.get(nodeId) ?? null;
+  }
+  hasFormula(nodeId) {
+    return this.formulasByNodeId.has(nodeId);
+  }
+  clear() {
+    this.dependentsMap.clear();
+    this.formulasByNodeId.clear();
+  }
+  forEachFormula(callback) {
+    for (const [nodeId, formula] of this.formulasByNodeId) {
+      callback(nodeId, formula);
+    }
+  }
+  size() {
+    return this.formulasByNodeId.size;
+  }
+};
+
+// src/core/schema-serializer/SchemaSerializer.ts
+var SchemaSerializer = class {
+  tree = null;
+  excludeNodeIds = /* @__PURE__ */ new Set();
+  serializeNode(node, tree, options) {
+    this.tree = tree;
+    this.excludeNodeIds = options?.excludeNodeIds ?? /* @__PURE__ */ new Set();
+    try {
+      return this.serialize(node);
+    } finally {
+      this.tree = null;
+      this.excludeNodeIds = /* @__PURE__ */ new Set();
+    }
+  }
+  serializeTree(tree) {
+    return this.serializeNode(tree.root(), tree);
+  }
+  serialize(node) {
+    if (node.isNull()) {
+      throw new Error("Cannot serialize null node");
+    }
+    if (node.isObject()) {
+      return this.serializeObject(node);
+    }
+    if (node.isArray()) {
+      return this.serializeArray(node);
+    }
+    if (node.isRef()) {
+      return this.serializeRef(node);
+    }
+    return this.serializePrimitive(node);
+  }
+  serializeObject(node) {
+    const properties = {};
+    const required = [];
+    for (const child of node.properties()) {
+      if (this.shouldExclude(child)) {
+        continue;
+      }
+      properties[child.name()] = this.serialize(child);
+      required.push(child.name());
+    }
+    const result = {
+      type: "object" /* Object */,
+      properties,
+      additionalProperties: false,
+      required
+    };
+    return this.addMetadata(result, node);
+  }
+  serializeArray(node) {
+    const items = node.items();
+    if (items.isNull()) {
+      throw new Error("Array node must have items");
+    }
+    const result = {
+      type: "array" /* Array */,
+      items: this.serialize(items)
+    };
+    return this.addMetadata(result, node);
+  }
+  serializeRef(node) {
+    const ref = node.ref();
+    if (!ref) {
+      throw new Error("Ref node must have a ref value");
+    }
+    const result = {
+      $ref: ref
+    };
+    return this.addMetadata(result, node);
+  }
+  serializePrimitive(node) {
+    const nodeType = node.nodeType();
+    switch (nodeType) {
+      case "string":
+        return this.serializeString(node);
+      case "number":
+        return this.serializeNumber(node);
+      case "boolean":
+        return this.serializeBoolean(node);
+      default:
+        throw new Error(`Unknown primitive type: ${nodeType}`);
+    }
+  }
+  serializeString(node) {
+    const result = {
+      type: "string" /* String */,
+      default: node.defaultValue() ?? ""
+    };
+    const foreignKey = node.foreignKey();
+    if (foreignKey) {
+      result.foreignKey = foreignKey;
+    }
+    const formula = node.formula();
+    if (formula) {
+      result.readOnly = true;
+      result["x-formula"] = this.serializeFormula(node, formula);
+    }
+    return this.addMetadata(result, node);
+  }
+  serializeNumber(node) {
+    const result = {
+      type: "number" /* Number */,
+      default: node.defaultValue() ?? 0
+    };
+    const formula = node.formula();
+    if (formula) {
+      result.readOnly = true;
+      result["x-formula"] = this.serializeFormula(node, formula);
+    }
+    return this.addMetadata(result, node);
+  }
+  serializeBoolean(node) {
+    const result = {
+      type: "boolean" /* Boolean */,
+      default: node.defaultValue() ?? false
+    };
+    const formula = node.formula();
+    if (formula) {
+      result.readOnly = true;
+      result["x-formula"] = this.serializeFormula(node, formula);
+    }
+    return this.addMetadata(result, node);
+  }
+  serializeFormula(node, formula) {
+    if (!this.tree) {
+      throw new Error(
+        "Cannot serialize formula without tree context. Use serializeNode with tree."
+      );
+    }
+    return FormulaSerializer.toXFormula(this.tree, node.id(), formula);
+  }
+  addMetadata(schema, node) {
+    const meta = node.metadata();
+    if (meta.title) {
+      schema.title = meta.title;
+    }
+    if (meta.description) {
+      schema.description = meta.description;
+    }
+    if (meta.deprecated) {
+      schema.deprecated = meta.deprecated;
+    }
+    return schema;
+  }
+  shouldExclude(node) {
+    return this.excludeNodeIds.has(node.id());
+  }
+};
+
+// src/core/schema-patch/PatchGenerator.ts
+var PatchGenerator = class {
+  constructor(currentTree, baseTree) {
+    this.currentTree = currentTree;
+    this.baseTree = baseTree;
+    this.context = { currentTree, baseTree };
+  }
+  serializer = new SchemaSerializer();
+  context;
+  generate(coalesced) {
+    const movedNodeIds = this.collectMovedNodeIds(coalesced.moved);
+    const movePatches = this.generateMovePatches(coalesced.moved);
+    const addPatches = this.generateAddPatches(coalesced.added, movedNodeIds);
+    const removePatches = this.generateRemovePatches(coalesced.removed);
+    const { prerequisiteAdds, regularAdds } = this.partitionAddPatches(
+      addPatches,
+      movePatches
+    );
+    const childChangePaths = /* @__PURE__ */ new Set([
+      ...addPatches.map((p) => p.path),
+      ...removePatches.map((p) => p.path),
+      ...movePatches.flatMap((p) => [p.path, p.from ?? ""]).filter(Boolean)
+    ]);
+    const replacePatches = this.generateReplacePatches(
+      coalesced.modified,
+      childChangePaths,
+      movedNodeIds
+    );
+    return [
+      ...prerequisiteAdds,
+      ...movePatches,
+      ...replacePatches,
+      ...regularAdds,
+      ...removePatches
+    ];
+  }
+  collectMovedNodeIds(moved) {
+    const nodeIds = /* @__PURE__ */ new Set();
+    for (const change of moved) {
+      nodeIds.add(change.currentNode.id());
+    }
+    return nodeIds;
+  }
+  partitionAddPatches(addPatches, movePatches) {
+    const moveDestinations = movePatches.map((p) => jsonPointerToPath(p.path));
+    const prerequisiteAdds = [];
+    const regularAdds = [];
+    for (const addPatch of addPatches) {
+      const addPath = jsonPointerToPath(addPatch.path);
+      const isPrerequisite = moveDestinations.some(
+        (moveDest) => moveDest.isChildOf(addPath)
+      );
+      if (isPrerequisite) {
+        prerequisiteAdds.push(addPatch);
+      } else {
+        regularAdds.push(addPatch);
+      }
+    }
+    return { prerequisiteAdds, regularAdds };
+  }
+  generateMovePatches(moved) {
+    const patches = [];
+    for (const change of moved) {
+      const basePath = this.baseTree.pathOf(change.baseNode.id());
+      const currentPath = this.currentTree.pathOf(change.currentNode.id());
+      patches.push({
+        op: "move",
+        from: basePath.asJsonPointer(),
+        path: currentPath.asJsonPointer()
+      });
+      const modifyPatch = this.generateModifyAfterMove(
+        change.baseNode,
+        change.currentNode,
+        currentPath.asJsonPointer()
+      );
+      if (modifyPatch) {
+        patches.push(modifyPatch);
+      }
+    }
+    return patches;
+  }
+  generateModifyAfterMove(baseNode, currentNode, currentPath) {
+    if (areNodesContentEqual(currentNode, baseNode, this.context)) {
+      return null;
+    }
+    const currentSchema = this.serializer.serializeNode(
+      currentNode,
+      this.currentTree
+    );
+    return {
+      op: "replace",
+      path: currentPath,
+      value: currentSchema
+    };
+  }
+  generateAddPatches(added, movedNodeIds) {
+    const patches = [];
+    for (const change of added) {
+      const currentPath = this.currentTree.pathOf(change.currentNode.id());
+      const schema = this.serializer.serializeNode(
+        change.currentNode,
+        this.currentTree,
+        { excludeNodeIds: movedNodeIds }
+      );
+      patches.push({
+        op: "add",
+        path: currentPath.asJsonPointer(),
+        value: schema
+      });
+    }
+    return patches;
+  }
+  generateRemovePatches(removed) {
+    const patches = [];
+    for (const change of removed) {
+      const basePath = this.baseTree.pathOf(change.baseNode.id());
+      patches.push({
+        op: "remove",
+        path: basePath.asJsonPointer()
+      });
+    }
+    return patches;
+  }
+  generateReplacePatches(modified, childChangePaths, movedNodeIds) {
+    const patches = [];
+    const replacedPaths = [];
+    const childChangePathObjects = [...childChangePaths].map(jsonPointerToPath);
+    for (const change of modified) {
+      if (movedNodeIds.has(change.currentNode.id())) {
+        continue;
+      }
+      const currentPath = this.currentTree.pathOf(change.currentNode.id());
+      if (this.isChildOfAny(currentPath, replacedPaths)) {
+        continue;
+      }
+      if (this.hasChildIn(currentPath, childChangePathObjects)) {
+        continue;
+      }
+      if (!this.isActuallyModified(change)) {
+        continue;
+      }
+      if (change.currentNode.isArray()) {
+        const arrayPatches = this.generateArrayReplacePatches(
+          change.currentNode,
+          change.baseNode,
+          currentPath
+        );
+        patches.push(...arrayPatches);
+        replacedPaths.push(currentPath);
+        continue;
+      }
+      const schema = this.serializer.serializeNode(
+        change.currentNode,
+        this.currentTree
+      );
+      patches.push({
+        op: "replace",
+        path: currentPath.asJsonPointer(),
+        value: schema
+      });
+      replacedPaths.push(currentPath);
+    }
+    return patches;
+  }
+  generateArrayReplacePatches(currentNode, baseNode, currentPath) {
+    if (!baseNode.isArray()) {
+      const schema = this.serializer.serializeNode(
+        currentNode,
+        this.currentTree
+      );
+      return [
+        {
+          op: "replace",
+          path: currentPath.asJsonPointer(),
+          value: schema
+        }
+      ];
+    }
+    const patches = [];
+    const metadataChanged = this.hasMetadataChanged(currentNode, baseNode);
+    const itemsChanged = this.hasItemsChanged(currentNode, baseNode);
+    if (metadataChanged) {
+      const schema = this.serializer.serializeNode(
+        currentNode,
+        this.currentTree
+      );
+      patches.push({
+        op: "replace",
+        path: currentPath.asJsonPointer(),
+        value: schema
+      });
+    }
+    if (itemsChanged) {
+      const items = currentNode.items();
+      const itemsPath = currentPath.childItems();
+      const itemsSchema = this.serializer.serializeNode(
+        items,
+        this.currentTree
+      );
+      patches.push({
+        op: "replace",
+        path: itemsPath.asJsonPointer(),
+        value: itemsSchema
+      });
+    }
+    return patches;
+  }
+  hasItemsChanged(currentNode, baseNode) {
+    const items = currentNode.items();
+    const baseItems = baseNode.items();
+    const currentItemsSchema = this.serializer.serializeNode(
+      items,
+      this.currentTree
+    );
+    const baseItemsSchema = this.serializer.serializeNode(
+      baseItems,
+      this.baseTree
+    );
+    return JSON.stringify(currentItemsSchema) !== JSON.stringify(baseItemsSchema);
+  }
+  isChildOfAny(path, parents) {
+    return parents.some((parent) => path.isChildOf(parent));
+  }
+  hasChildIn(path, candidates) {
+    return candidates.some((candidate) => candidate.isChildOf(path));
+  }
+  isActuallyModified(change) {
+    const currentSchema = this.serializer.serializeNode(
+      change.currentNode,
+      this.currentTree
+    );
+    const baseSchema = this.serializer.serializeNode(
+      change.baseNode,
+      this.baseTree
+    );
+    if (JSON.stringify(currentSchema) === JSON.stringify(baseSchema)) {
+      return false;
+    }
+    if (change.currentNode.isObject() && this.hasOnlyChildChanges(change.currentNode, change.baseNode)) {
+      return false;
+    }
+    if (change.currentNode.isArray() && this.hasOnlyItemsChanges(change.currentNode, change.baseNode)) {
+      return false;
+    }
+    return true;
+  }
+  hasOnlyChildChanges(currentNode, baseNode) {
+    if (!baseNode.isObject()) {
+      return false;
+    }
+    if (this.hasMetadataChanged(currentNode, baseNode)) {
+      return false;
+    }
+    return true;
+  }
+  hasMetadataChanged(currentNode, baseNode) {
+    const currentMeta = currentNode.metadata();
+    const baseMeta = baseNode.metadata();
+    return currentMeta.title !== baseMeta.title || currentMeta.description !== baseMeta.description || currentMeta.deprecated !== baseMeta.deprecated;
+  }
+  hasOnlyItemsChanges(currentNode, baseNode) {
+    if (!baseNode.isArray()) {
+      return false;
+    }
+    if (this.hasMetadataChanged(currentNode, baseNode)) {
+      return false;
+    }
+    const items = currentNode.items();
+    const baseItems = baseNode.items();
+    return items.id() === baseItems.id();
+  }
+};
+
+// src/core/schema-patch/PatchEnricher.ts
+function isPrimitiveDefault(value) {
+  const type = typeof value;
+  return type === "string" || type === "number" || type === "boolean";
+}
+var PatchEnricher = class {
+  constructor(currentTree, baseTree) {
+    this.currentTree = currentTree;
+    this.baseTree = baseTree;
+  }
+  enrich(patch) {
+    const fieldName = this.getFieldNameFromPath(patch.path);
+    if (patch.op === "add") {
+      return this.enrichAddPatch(patch, fieldName);
+    }
+    if (patch.op === "remove") {
+      return this.enrichRemovePatch(patch, fieldName);
+    }
+    if (patch.op === "move") {
+      return this.enrichMovePatch(patch, fieldName);
+    }
+    return this.enrichReplacePatch(patch, fieldName);
+  }
+  enrichAddPatch(patch, fieldName) {
+    const currentNode = this.getNodeAtPath(this.currentTree, patch.path);
+    if (!currentNode) {
+      return { patch, fieldName };
+    }
+    return {
+      patch,
+      fieldName,
+      ...this.computeAddMetadata(currentNode)
+    };
+  }
+  enrichRemovePatch(patch, fieldName) {
+    return { patch, fieldName };
+  }
+  enrichMovePatch(patch, fieldName) {
+    const fromPath = patch.from || "";
+    const isRename = this.isRenameMove(fromPath, patch.path);
+    const baseNode = this.getNodeAtPath(this.baseTree, fromPath);
+    const currentNode = this.getNodeAtPath(this.currentTree, patch.path);
+    const formulaChange = this.computeFormulaChange(baseNode, currentNode);
+    return {
+      patch,
+      fieldName,
+      isRename: isRename || void 0,
+      formulaChange
+    };
+  }
+  enrichReplacePatch(patch, fieldName) {
+    const baseNode = this.getNodeAtPath(this.baseTree, patch.path);
+    const currentNode = this.getNodeAtPath(this.currentTree, patch.path);
+    const isArrayMetadataPatch = baseNode?.isArray() && currentNode?.isArray();
+    return {
+      patch,
+      fieldName,
+      typeChange: this.computeTypeChange(baseNode, currentNode, isArrayMetadataPatch),
+      formulaChange: this.computeFormulaChange(baseNode, currentNode),
+      defaultChange: isArrayMetadataPatch ? void 0 : this.computeDefaultChange(baseNode, currentNode),
+      descriptionChange: this.computeDescriptionChange(baseNode, currentNode),
+      deprecatedChange: this.computeDeprecatedChange(baseNode, currentNode),
+      foreignKeyChange: this.computeForeignKeyChange(baseNode, currentNode)
+    };
+  }
+  computeAddMetadata(node) {
+    const result = {};
+    const formula = node.formula();
+    if (formula) {
+      result.formulaChange = {
+        fromFormula: void 0,
+        toFormula: this.getFormulaExpression(formula, this.currentTree, node.id()),
+        fromVersion: void 0,
+        toVersion: formula.version()
+      };
+    }
+    const defaultValue = node.defaultValue();
+    if (defaultValue !== void 0 && isPrimitiveDefault(defaultValue)) {
+      result.defaultChange = {
+        fromDefault: void 0,
+        toDefault: defaultValue
+      };
+    }
+    const meta = node.metadata();
+    if (meta.description) {
+      result.descriptionChange = {
+        fromDescription: void 0,
+        toDescription: meta.description
+      };
+    }
+    if (meta.deprecated) {
+      result.deprecatedChange = {
+        fromDeprecated: void 0,
+        toDeprecated: meta.deprecated
+      };
+    }
+    const foreignKey = node.foreignKey();
+    if (foreignKey) {
+      result.foreignKeyChange = {
+        fromForeignKey: void 0,
+        toForeignKey: foreignKey
+      };
+    }
+    return result;
+  }
+  computeTypeChange(baseNode, currentNode, ignoreItems) {
+    if (!baseNode || !currentNode) {
+      return void 0;
+    }
+    const baseType = this.getNodeType(baseNode);
+    const currentType = this.getNodeType(currentNode);
+    if (ignoreItems) {
+      const baseBaseType = baseNode.nodeType();
+      const currentBaseType = currentNode.nodeType();
+      if (baseBaseType === currentBaseType) {
+        return void 0;
+      }
+    }
+    if (baseType !== currentType) {
+      return { fromType: baseType, toType: currentType };
+    }
+    return void 0;
+  }
+  computeFormulaChange(baseNode, currentNode) {
+    const baseFormula = baseNode?.formula();
+    const currentFormula = currentNode?.formula();
+    const baseExpr = baseFormula && baseNode ? this.getFormulaExpression(baseFormula, this.baseTree, baseNode.id()) : void 0;
+    const currentExpr = currentFormula && currentNode ? this.getFormulaExpression(currentFormula, this.currentTree, currentNode.id()) : void 0;
+    const baseVersion = baseFormula?.version();
+    const currentVersion = currentFormula?.version();
+    if (baseExpr !== currentExpr || baseVersion !== currentVersion) {
+      return {
+        fromFormula: baseExpr,
+        toFormula: currentExpr,
+        fromVersion: baseVersion,
+        toVersion: currentVersion
+      };
+    }
+    return void 0;
+  }
+  getFormulaExpression(formula, tree, nodeId) {
+    return FormulaSerializer.serializeExpression(tree, nodeId, formula, { strict: false });
+  }
+  computeDefaultChange(baseNode, currentNode) {
+    const baseDefault = baseNode?.defaultValue();
+    const currentDefault = currentNode?.defaultValue();
+    const safeBaseDefault = isPrimitiveDefault(baseDefault) ? baseDefault : void 0;
+    const safeCurrentDefault = isPrimitiveDefault(
+      currentDefault
+    ) ? currentDefault : void 0;
+    if (safeBaseDefault !== safeCurrentDefault) {
+      return {
+        fromDefault: safeBaseDefault,
+        toDefault: safeCurrentDefault
+      };
+    }
+    return void 0;
+  }
+  computeDescriptionChange(baseNode, currentNode) {
+    const baseDesc = baseNode?.metadata().description;
+    const currentDesc = currentNode?.metadata().description;
+    if (baseDesc !== currentDesc) {
+      return { fromDescription: baseDesc, toDescription: currentDesc };
+    }
+    return void 0;
+  }
+  computeDeprecatedChange(baseNode, currentNode) {
+    const baseDeprecated = baseNode?.metadata().deprecated;
+    const currentDeprecated = currentNode?.metadata().deprecated;
+    if (baseDeprecated !== currentDeprecated) {
+      return { fromDeprecated: baseDeprecated, toDeprecated: currentDeprecated };
+    }
+    return void 0;
+  }
+  computeForeignKeyChange(baseNode, currentNode) {
+    const baseFk = baseNode?.foreignKey();
+    const currentFk = currentNode?.foreignKey();
+    if (baseFk !== currentFk) {
+      return { fromForeignKey: baseFk, toForeignKey: currentFk };
+    }
+    return void 0;
+  }
+  getNodeType(node) {
+    if (node.isArray()) {
+      const items = node.items();
+      return `array<${this.getNodeType(items)}>`;
+    }
+    return node.nodeType();
+  }
+  getFieldNameFromPath(jsonPointer) {
+    try {
+      return jsonPointerToPath(jsonPointer).asSimple();
+    } catch {
+      return "";
+    }
+  }
+  isRenameMove(fromPointer, toPointer) {
+    try {
+      const fromParent = jsonPointerToPath(fromPointer).parent();
+      const toParent = jsonPointerToPath(toPointer).parent();
+      return fromParent.equals(toParent);
+    } catch {
+      return false;
+    }
+  }
+  getNodeAtPath(tree, jsonPointer) {
+    try {
+      const path = jsonPointerToPath(jsonPointer);
+      const node = tree.nodeAt(path);
+      return node.isNull() ? null : node;
+    } catch {
+      return null;
+    }
+  }
+};
+
+// src/core/schema-patch/PatchBuilder.ts
+var PatchBuilder = class {
+  build(currentTree, baseTree) {
+    const index = new NodePathIndex(baseTree);
+    this.syncReplacements(currentTree, index);
+    const rawChanges = collectChanges(baseTree, currentTree, index);
+    const coalesced = coalesceChanges(rawChanges, currentTree, index);
+    const generator = new PatchGenerator(currentTree, baseTree);
+    const patches = generator.generate(coalesced);
+    const enricher = new PatchEnricher(currentTree, baseTree);
+    return patches.map((patch) => enricher.enrich(patch));
+  }
+  syncReplacements(tree, index) {
+    for (const [oldId, newId] of tree.replacements()) {
+      index.trackReplacement(oldId, newId);
+    }
+  }
+};
+
+exports.AbstractBasePath = AbstractBasePath;
+exports.ChangeCoalescer = ChangeCoalescer;
+exports.ChangeCollector = ChangeCollector;
+exports.EMPTY_METADATA = EMPTY_METADATA;
+exports.EMPTY_PATH = EMPTY_PATH;
+exports.FormulaDependencyIndex = FormulaDependencyIndex;
+exports.ItemsSegment = ItemsSegment;
+exports.NULL_NODE = NULL_NODE;
+exports.NodePathIndex = NodePathIndex;
+exports.ParsedFormula = ParsedFormula;
+exports.PatchBuilder = PatchBuilder;
+exports.PatchEnricher = PatchEnricher;
+exports.PatchGenerator = PatchGenerator;
+exports.PropertySegment = PropertySegment;
+exports.SchemaDiff = SchemaDiff;
+exports.SchemaSerializer = SchemaSerializer;
+exports.areNodesContentEqual = areNodesContentEqual;
+exports.areNodesEqual = areNodesEqual;
+exports.coalesceChanges = coalesceChanges;
+exports.collectChanges = collectChanges;
+exports.createArrayNode = createArrayNode;
+exports.createBooleanNode = createBooleanNode;
+exports.createNumberNode = createNumberNode;
+exports.createObjectNode = createObjectNode;
+exports.createPath = createPath;
+exports.createRefNode = createRefNode;
+exports.createSchemaTree = createSchemaTree;
+exports.createStringNode = createStringNode;
+exports.jsonPointerToPath = jsonPointerToPath;
+exports.jsonPointerToSegments = jsonPointerToSegments;
+exports.jsonPointerToSimplePath = jsonPointerToSimplePath;
+//# sourceMappingURL=chunk-A4E524UU.cjs.map
+//# sourceMappingURL=chunk-A4E524UU.cjs.map