agent-contracts 0.22.8 → 0.23.0

package/dist/index.js

@@ -49856,12 +49856,18 @@ var MergeError = class extends Error {
 function isRecord2(v2) {
   return typeof v2 === "object" && v2 !== null && !Array.isArray(v2);
 }
-function hasOperator(obj) {
+function hasOperator(obj, path) {
   const ops = ["$append", "$prepend", "$insert_after", "$replace", "$remove"];
+  const found = [];
   for (const op of ops) {
-    if (op in obj) return op;
+    if (op in obj) found.push(op);
   }
-  return null;
+  if (found.length > 1) {
+    throw new MergeError(
+      `Multiple merge operators in the same object at ${path ?? "unknown"}: ${found.join(", ")}`
+    );
+  }
+  return found.length === 1 ? found[0] : null;
 }
 function findIndexByIdOrValue(arr, target) {
   return arr.findIndex((item) => {
@@ -49872,7 +49878,7 @@ function findIndexByIdOrValue(arr, target) {
   });
 }
 function applyArrayMergeOperator(baseArray, operatorObj, path) {
-  const op = hasOperator(operatorObj);
+  const op = hasOperator(operatorObj, path);
   if (!op) return baseArray;
   switch (op) {
     case "$append": {
@@ -49946,9 +49952,13 @@ function applyArrayMergeOperator(baseArray, operatorObj, path) {
   }
 }
 function orderedInsertAfter(base, afterKey, entries) {
+  const entryKeys = new Set(Object.keys(entries));
   const result = {};
   let inserted = false;
   for (const key of Object.keys(base)) {
+    if (inserted && entryKeys.has(key)) {
+      continue;
+    }
     result[key] = base[key];
     if (key === afterKey) {
       for (const [ek, ev] of Object.entries(entries)) {
@@ -49957,13 +49967,10 @@ function orderedInsertAfter(base, afterKey, entries) {
       inserted = true;
     }
   }
-  if (!inserted) {
-    return result;
-  }
   return result;
 }
 function applyMapMergeOperator(baseMap, operatorObj, path) {
-  const op = hasOperator(operatorObj);
+  const op = hasOperator(operatorObj, path);
   if (!op) return baseMap;
   switch (op) {
     case "$append": {
@@ -50014,7 +50021,7 @@ function deepMergeEntities(base, project, path, hasExtends) {
   for (const key of Object.keys(project)) {
     const baseVal = result[key];
     const projVal = project[key];
-    if (isRecord2(projVal) && hasOperator(projVal)) {
+    if (isRecord2(projVal) && hasOperator(projVal, `${path}.${key}`)) {
       if (!hasExtends) {
         throw new MergeError(
           `Merge operator used without extends at ${path}.${key}`
@@ -50040,20 +50047,26 @@ function deepMergeEntities(base, project, path, hasExtends) {
   }
   return result;
 }
+var OPERATOR_KEYS = /* @__PURE__ */ new Set(["$append", "$prepend", "$insert_after", "$replace", "$remove"]);
 function mergeEntityMaps(baseMap, projectMap, path, hasExtends) {
+  let result;
   if (isRecord2(projectMap) && !Array.isArray(projectMap)) {
-    const op = hasOperator(projectMap);
+    const op = hasOperator(projectMap, path);
     if (op) {
       if (!hasExtends) {
         throw new MergeError(
           `Merge operator used without extends at ${path}`
         );
       }
-      return applyMapMergeOperator(baseMap, projectMap, path);
+      result = applyMapMergeOperator(baseMap, projectMap, path);
+    } else {
+      result = { ...baseMap };
     }
+  } else {
+    result = { ...baseMap };
   }
-  const result = { ...baseMap };
   for (const [key, projVal] of Object.entries(projectMap)) {
+    if (OPERATOR_KEYS.has(key)) continue;
     const baseVal = result[key];
     if (baseVal !== void 0 && isRecord2(baseVal) && isRecord2(projVal)) {
       result[key] = deepMergeEntities(