fix: don't duplicate field-level ops when filtering by child array path (v0.17.2) (#36)

* fix: don't duplicate field-level ops when filtering by child array path

flattenOpsForFilter recursed into Replace.changes even when the Replace
op itself already matched the prefix, causing field-level ops to appear
alongside their parent element op in the results (e.g. changing one
field on a child item produced both a Replace for the child AND a loose
Replace for the field).

Replace with filterOpsForPrefixes: include a matching op as-is (its
.changes are already attached), and only recurse into Replace.changes
when the Replace itself does NOT match the prefix.

https://claude.ai/code/session_017H6NzxYAwbmKxHH6QusCdh

* chore: bump version to 0.17.2

https://claude.ai/code/session_017H6NzxYAwbmKxHH6QusCdh

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: maxjay

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@maxjay/patchwork",
-  "version": "0.17.1",
+  "version": "0.17.2",
   "description": "A JSON editing engine with base/draft, diff, undo, and scoped lenses.",
   "type": "module",
   "main": "dist/index.js",

package.json

@@ -573,4 +573,17 @@ describe('diff — includeUnchanged propagation into nested keyed arrays', () =>
 		expect(ops).toHaveLength(1);
 		expect(ops[0]).toMatchObject({ op: OpType.Unchanged, identity: 'DELTA' });
 	});
+
+	it('field change on one child: returns one Replace op for that child — not a duplicate field-level op', () => {
+		const e = makeOrdersEngine();
+		e.replace('$.items[0].children[1].qty', 99); // change BETA's qty
+		const ops = e.diff("$.items[0].children", { includeUnchanged: true });
+		// Expect exactly one op per child — no field-level replace leaking out alongside the element Replace
+		expect(ops).toHaveLength(3);
+		const betaOp = ops.find((o: any) => o.identity === 'BETA');
+		expect(betaOp).toBeDefined();
+		expect(betaOp!.op).toBe(OpType.Replace);
+		expect((betaOp as any).changes).toHaveLength(1); // field-level replace lives inside .changes
+		expect(ops.filter(o => o.op === OpType.Replace)).toHaveLength(1); // not duplicated at top level
+	});
 });

src/engine.array-semantics.test.ts

@@ -447,19 +447,24 @@ export class Engine<T extends JsonValue = JsonValue> {
 		this.diffNode(this.base, this.draft, '$', ops, includeUnchanged, cascade, false);
 		if (!path) return ops;
 		const prefixes = [...new Set([...paths(this.draft, path), ...paths(this.base, path)])];
-		// Flatten Replace.changes recursively so path filters can reach ops nested inside
-		// changed parent elements (e.g. querying a child keyed array when its parent changed).
-		return this.flattenOpsForFilter(ops).filter(op => prefixes.some(p => isUnderPrefix(opPath(op), p)));
+		return this.filterOpsForPrefixes(ops, prefixes);
 	}
 
-	private flattenOpsForFilter(ops: DiffOp[]): DiffOp[] {
-		const flat: DiffOp[] = [];
+	// Filters ops to those at-or-under any prefix. When a Replace op itself does NOT
+	// match but its changes might (e.g. querying a child keyed array inside a changed
+	// parent element), recurse into Replace.changes rather than skipping the whole subtree.
+	// When a Replace op DOES match, include it without recursing — its .changes are
+	// already attached and recursing would duplicate the field-level ops in the result.
+	private filterOpsForPrefixes(ops: DiffOp[], prefixes: string[]): DiffOp[] {
+		const result: DiffOp[] = [];
 		for (const op of ops) {
-			flat.push(op);
-			if (op.op === OpType.Replace && op.changes?.length)
-				flat.push(...this.flattenOpsForFilter(op.changes));
+			if (prefixes.some(p => isUnderPrefix(opPath(op), p))) {
+				result.push(op);
+			} else if (op.op === OpType.Replace && op.changes?.length) {
+				result.push(...this.filterOpsForPrefixes(op.changes, prefixes));
+			}
 		}
-		return flat;
+		return result;
 	}
 
 	private moveOrCopy(from: string, to: string, isMove: boolean): void {