agent-contracts 0.22.7 → 0.22.9

package/dist/index.d.ts

@@ -854,7 +854,9 @@ declare const ReplaceOperatorSchema: z.ZodObject<{
 }, z.core.$strip>;
 type ReplaceOperator = z.infer<typeof ReplaceOperatorSchema>;
 declare const RemoveOperatorSchema: z.ZodObject<{
-    $remove: z.ZodArray<z.ZodString>;
+    $remove: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>]>>;
 }, z.core.$strip>;
 type RemoveOperator = z.infer<typeof RemoveOperatorSchema>;
 type MergeableRecord<T> = Record<string, T> | {
@@ -869,7 +871,9 @@ type MergeableRecord<T> = Record<string, T> | {
 } | {
     $replace: unknown;
 } | {
-    $remove: string[];
+    $remove: (string | {
+        id: string;
+    })[];
 };
 
 declare const PolicyWhenSchema: z.ZodObject<{

package/dist/index.js

@@ -49451,7 +49451,7 @@ var InsertAfterOperatorSchema = z16.object({
 });
 var ReplaceOperatorSchema = z16.object({ $replace: z16.any() });
 var RemoveOperatorSchema = z16.object({
-  $remove: z16.array(z16.string())
+  $remove: z16.array(z16.union([z16.string(), z16.object({ id: z16.string() })]))
 });
 
 // src/loader/loader.ts
@@ -49863,10 +49863,13 @@ function hasOperator(obj) {
   }
   return null;
 }
-function findIndexById(arr, id) {
-  return arr.findIndex(
-    (item) => isRecord2(item) && item["id"] === id
-  );
+function findIndexByIdOrValue(arr, target) {
+  return arr.findIndex((item) => {
+    if (typeof item === "string") {
+      return item === target;
+    }
+    return isRecord2(item) && item["id"] === target;
+  });
 }
 function applyArrayMergeOperator(baseArray, operatorObj, path) {
   const op = hasOperator(operatorObj);
@@ -49884,7 +49887,7 @@ function applyArrayMergeOperator(baseArray, operatorObj, path) {
       const spec = operatorObj["$insert_after"];
       const target = spec["target"];
       const items = spec["items"];
-      const idx = findIndexById(baseArray, target);
+      const idx = findIndexByIdOrValue(baseArray, target);
       if (idx === -1) {
         throw new MergeError(
           `$insert_after target "${target}" not found in base at ${path}`
@@ -49899,7 +49902,28 @@ function applyArrayMergeOperator(baseArray, operatorObj, path) {
     }
     case "$remove": {
       const removeList = operatorObj["$remove"];
-      const idsToRemove = new Set(removeList.map((r3) => r3["id"]));
+      if (removeList.length === 0) {
+        return baseArray;
+      }
+      if (typeof removeList[0] === "string") {
+        const valuesToRemove = new Set(removeList);
+        const result2 = baseArray.filter((item) => {
+          if (typeof item === "string" && valuesToRemove.has(item)) {
+            valuesToRemove.delete(item);
+            return false;
+          }
+          return true;
+        });
+        if (valuesToRemove.size > 0) {
+          throw new MergeError(
+            `$remove values not found in base at ${path}: ${[...valuesToRemove].join(", ")}`
+          );
+        }
+        return result2;
+      }
+      const idsToRemove = new Set(
+        removeList.map((r3) => r3["id"])
+      );
       const result = baseArray.filter((item) => {
         if (isRecord2(item) && typeof item["id"] === "string") {
           const itemId = item["id"];
@@ -50016,7 +50040,9 @@ 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);
     if (op) {
@@ -50025,11 +50051,15 @@ function mergeEntityMaps(baseMap, projectMap, path, hasExtends) {
           `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(