feat: array semantics — identity diffing, displacement, restore, cascade (v0.15.0) by maxjay · Pull Request #32 · maxjay/patchwork

maxjay · 2026-06-14T22:24:24Z

Summary

Identity-keyed array diffing redesigned: matched elements now emit element-level replace ops with a grouped changes array (absolute paths), rather than flat field-level ops. Displaced elements emit move ops carrying identity.
Ordered arrays + displacement: x-ordered: true on a schema array surfaces position changes as move ops. displacement field on replace ops when an element is both modified and displaced.
New diff() options: includeUnchanged returns all elements including unmodified ones (for UI rendering without a separate zip); cascade (default true) controls whether nested identity-array changes bubble up to mark the parent as modified.
New restore(op): inverts any DiffOp and pushes to the undo stack. Move restore uses splice semantics (removeAt + insertAt) not overwrite.
OpType.Unchanged: new op kind emitted only when includeUnchanged: true.
ArrayMeta: replaces bare string in keyMap to carry both key and ordered flag; extractKeyMap reads x-ordered from schema.
Full spec in docs/array-semantics.md and implementation notes in docs/implementation.md.

Test plan

247 tests passing (npm test)
src/engine.array-semantics.test.ts covers: identity matching, ordered displacement, includeUnchanged, cascade (true and false), $self arrays, restore (all op kinds + undo), identity stability, edge cases
Existing engine.test.ts keyed-array tests updated to reflect new element-level grouping behavior

🤖 Generated with Claude Code

Reset point at 0.12.0. Reference for redesigning array diff/revert after the 0.13-0.16 filter-string/segment approach was judged overweight. Captures: key = diff-time addressing; edits belong to the element not the array; identity must be stable (declared, not inferred); order = a hidden position attribute. Defines diff + revert for the three array kinds and the implementation stance (drop segment paths, express revert via the existing functional undo/redo closures).

…acement Captures the converged model: in an ordered array an element whose index shifts because of a nearby add/remove HAS changed (order matters, so it's surfaced) but is NOT revertible on its own — a new 'effect' entry kind that carries a reason pointing at the causing entries. Genuine reorders (crossing a surviving element) are 'move' (revertible). Adds the full entry-kind table, the one-API-both-views note, prior art (RFC 6902 / Myers / CRDTs), and the worked [A,B,C]->[A,B,D,C] example. Replaces the earlier (wrong) 'removal cascades as modifications' framing.

OpType.Move, the {from,to} DiffOp variant, engine.move(), and import/export all exist in 0.12.0; a move op is created inside engine.move() for exportChanges. The gap is diff() never emitting one (diffNode does only add/remove/replace, never detects a reorder). So 'effect' is the only net-new concept; move just needs diff to emit the existing op.

… cases Full redesign of array diff semantics: identity containment, ordered/unordered distinction, displacement as move ops, restore operation, and cascade flag. Adds implementation spec with pseudo-code and a test suite defining the contract. Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

…tore, cascade - DiffOp extended: element-level replace with grouped changes (absolute paths), move op carries identity for displacement, new unchanged op for includeUnchanged - diffArrayByKey rewritten: matched elements emit replace+changes, move, or unchanged based on field changes and displacement - diff() gains includeUnchanged and cascade options; cascade:false stops nested identity array changes from bubbling up to the parent element - restore(op) inverts any DiffOp and pushes to the undo stack; move restore uses splice semantics (removeAt + insertAt) not overwrite - ArrayMeta replaces bare string in keyMap to carry both key and ordered flag - extractKeyMap reads x-ordered from schema - All 247 tests passing Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay · 2026-06-14T22:24:24Z

Summary

Identity-keyed array diffing redesigned: matched elements now emit element-level replace ops with a grouped changes array (absolute paths), rather than flat field-level ops. Displaced elements emit move ops carrying identity.
Ordered arrays + displacement: x-ordered: true on a schema array surfaces position changes as move ops. displacement field on replace ops when an element is both modified and displaced.
New diff() options: includeUnchanged returns all elements including unmodified ones (for UI rendering without a separate zip); cascade (default true) controls whether nested identity-array changes bubble up to mark the parent as modified.
New restore(op): inverts any DiffOp and pushes to the undo stack. Move restore uses splice semantics (removeAt + insertAt) not overwrite.
OpType.Unchanged: new op kind emitted only when includeUnchanged: true.
ArrayMeta: replaces bare string in keyMap to carry both key and ordered flag; extractKeyMap reads x-ordered from schema.
Full spec in docs/array-semantics.md and implementation notes in docs/implementation.md.

Test plan

247 tests passing (npm test)
src/engine.array-semantics.test.ts covers: identity matching, ordered displacement, includeUnchanged, cascade (true and false), $self arrays, restore (all op kinds + undo), identity stability, edge cases
Existing engine.test.ts keyed-array tests updated to reflect new element-level grouping behavior

🤖 Generated with Claude Code

Reset point at 0.12.0. Reference for redesigning array diff/revert after the 0.13-0.16 filter-string/segment approach was judged overweight. Captures: key = diff-time addressing; edits belong to the element not the array; identity must be stable (declared, not inferred); order = a hidden position attribute. Defines diff + revert for the three array kinds and the implementation stance (drop segment paths, express revert via the existing functional undo/redo closures).

…acement Captures the converged model: in an ordered array an element whose index shifts because of a nearby add/remove HAS changed (order matters, so it's surfaced) but is NOT revertible on its own — a new 'effect' entry kind that carries a reason pointing at the causing entries. Genuine reorders (crossing a surviving element) are 'move' (revertible). Adds the full entry-kind table, the one-API-both-views note, prior art (RFC 6902 / Myers / CRDTs), and the worked [A,B,C]->[A,B,D,C] example. Replaces the earlier (wrong) 'removal cascades as modifications' framing.

OpType.Move, the {from,to} DiffOp variant, engine.move(), and import/export all exist in 0.12.0; a move op is created inside engine.move() for exportChanges. The gap is diff() never emitting one (diffNode does only add/remove/replace, never detects a reorder). So 'effect' is the only net-new concept; move just needs diff to emit the existing op.

… cases Full redesign of array diff semantics: identity containment, ordered/unordered distinction, displacement as move ops, restore operation, and cascade flag. Adds implementation spec with pseudo-code and a test suite defining the contract. Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

…tore, cascade - DiffOp extended: element-level replace with grouped changes (absolute paths), move op carries identity for displacement, new unchanged op for includeUnchanged - diffArrayByKey rewritten: matched elements emit replace+changes, move, or unchanged based on field changes and displacement - diff() gains includeUnchanged and cascade options; cascade:false stops nested identity array changes from bubbling up to the parent element - restore(op) inverts any DiffOp and pushes to the undo stack; move restore uses splice semantics (removeAt + insertAt) not overwrite - ArrayMeta replaces bare string in keyMap to carry both key and ordered flag - extractKeyMap reads x-ordered from schema - All 247 tests passing Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay · 2026-06-14T22:24:24Z

Summary

Identity-keyed array diffing redesigned: matched elements now emit element-level replace ops with a grouped changes array (absolute paths), rather than flat field-level ops. Displaced elements emit move ops carrying identity.
Ordered arrays + displacement: x-ordered: true on a schema array surfaces position changes as move ops. displacement field on replace ops when an element is both modified and displaced.
New diff() options: includeUnchanged returns all elements including unmodified ones (for UI rendering without a separate zip); cascade (default true) controls whether nested identity-array changes bubble up to mark the parent as modified.
New restore(op): inverts any DiffOp and pushes to the undo stack. Move restore uses splice semantics (removeAt + insertAt) not overwrite.
OpType.Unchanged: new op kind emitted only when includeUnchanged: true.
ArrayMeta: replaces bare string in keyMap to carry both key and ordered flag; extractKeyMap reads x-ordered from schema.
Full spec in docs/array-semantics.md and implementation notes in docs/implementation.md.

Test plan

247 tests passing (npm test)
src/engine.array-semantics.test.ts covers: identity matching, ordered displacement, includeUnchanged, cascade (true and false), $self arrays, restore (all op kinds + undo), identity stability, edge cases
Existing engine.test.ts keyed-array tests updated to reflect new element-level grouping behavior

🤖 Generated with Claude Code

Reset point at 0.12.0. Reference for redesigning array diff/revert after the 0.13-0.16 filter-string/segment approach was judged overweight. Captures: key = diff-time addressing; edits belong to the element not the array; identity must be stable (declared, not inferred); order = a hidden position attribute. Defines diff + revert for the three array kinds and the implementation stance (drop segment paths, express revert via the existing functional undo/redo closures).

…acement Captures the converged model: in an ordered array an element whose index shifts because of a nearby add/remove HAS changed (order matters, so it's surfaced) but is NOT revertible on its own — a new 'effect' entry kind that carries a reason pointing at the causing entries. Genuine reorders (crossing a surviving element) are 'move' (revertible). Adds the full entry-kind table, the one-API-both-views note, prior art (RFC 6902 / Myers / CRDTs), and the worked [A,B,C]->[A,B,D,C] example. Replaces the earlier (wrong) 'removal cascades as modifications' framing.

OpType.Move, the {from,to} DiffOp variant, engine.move(), and import/export all exist in 0.12.0; a move op is created inside engine.move() for exportChanges. The gap is diff() never emitting one (diffNode does only add/remove/replace, never detects a reorder). So 'effect' is the only net-new concept; move just needs diff to emit the existing op.

… cases Full redesign of array diff semantics: identity containment, ordered/unordered distinction, displacement as move ops, restore operation, and cascade flag. Adds implementation spec with pseudo-code and a test suite defining the contract. Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

…tore, cascade - DiffOp extended: element-level replace with grouped changes (absolute paths), move op carries identity for displacement, new unchanged op for includeUnchanged - diffArrayByKey rewritten: matched elements emit replace+changes, move, or unchanged based on field changes and displacement - diff() gains includeUnchanged and cascade options; cascade:false stops nested identity array changes from bubbling up to the parent element - restore(op) inverts any DiffOp and pushes to the undo stack; move restore uses splice semantics (removeAt + insertAt) not overwrite - ArrayMeta replaces bare string in keyMap to carry both key and ordered flag - extractKeyMap reads x-ordered from schema - All 247 tests passing Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay · 2026-06-14T22:24:24Z

Summary

Identity-keyed array diffing redesigned: matched elements now emit element-level replace ops with a grouped changes array (absolute paths), rather than flat field-level ops. Displaced elements emit move ops carrying identity.
Ordered arrays + displacement: x-ordered: true on a schema array surfaces position changes as move ops. displacement field on replace ops when an element is both modified and displaced.
New diff() options: includeUnchanged returns all elements including unmodified ones (for UI rendering without a separate zip); cascade (default true) controls whether nested identity-array changes bubble up to mark the parent as modified.
New restore(op): inverts any DiffOp and pushes to the undo stack. Move restore uses splice semantics (removeAt + insertAt) not overwrite.
OpType.Unchanged: new op kind emitted only when includeUnchanged: true.
ArrayMeta: replaces bare string in keyMap to carry both key and ordered flag; extractKeyMap reads x-ordered from schema.
Full spec in docs/array-semantics.md and implementation notes in docs/implementation.md.

Test plan

247 tests passing (npm test)
src/engine.array-semantics.test.ts covers: identity matching, ordered displacement, includeUnchanged, cascade (true and false), $self arrays, restore (all op kinds + undo), identity stability, edge cases
Existing engine.test.ts keyed-array tests updated to reflect new element-level grouping behavior

🤖 Generated with Claude Code

Reset point at 0.12.0. Reference for redesigning array diff/revert after the 0.13-0.16 filter-string/segment approach was judged overweight. Captures: key = diff-time addressing; edits belong to the element not the array; identity must be stable (declared, not inferred); order = a hidden position attribute. Defines diff + revert for the three array kinds and the implementation stance (drop segment paths, express revert via the existing functional undo/redo closures).

…acement Captures the converged model: in an ordered array an element whose index shifts because of a nearby add/remove HAS changed (order matters, so it's surfaced) but is NOT revertible on its own — a new 'effect' entry kind that carries a reason pointing at the causing entries. Genuine reorders (crossing a surviving element) are 'move' (revertible). Adds the full entry-kind table, the one-API-both-views note, prior art (RFC 6902 / Myers / CRDTs), and the worked [A,B,C]->[A,B,D,C] example. Replaces the earlier (wrong) 'removal cascades as modifications' framing.

OpType.Move, the {from,to} DiffOp variant, engine.move(), and import/export all exist in 0.12.0; a move op is created inside engine.move() for exportChanges. The gap is diff() never emitting one (diffNode does only add/remove/replace, never detects a reorder). So 'effect' is the only net-new concept; move just needs diff to emit the existing op.

… cases Full redesign of array diff semantics: identity containment, ordered/unordered distinction, displacement as move ops, restore operation, and cascade flag. Adds implementation spec with pseudo-code and a test suite defining the contract. Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

…tore, cascade - DiffOp extended: element-level replace with grouped changes (absolute paths), move op carries identity for displacement, new unchanged op for includeUnchanged - diffArrayByKey rewritten: matched elements emit replace+changes, move, or unchanged based on field changes and displacement - diff() gains includeUnchanged and cascade options; cascade:false stops nested identity array changes from bubbling up to the parent element - restore(op) inverts any DiffOp and pushes to the undo stack; move restore uses splice semantics (removeAt + insertAt) not overwrite - ArrayMeta replaces bare string in keyMap to carry both key and ordered flag - extractKeyMap reads x-ordered from schema - All 247 tests passing Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay · 2026-06-14T22:24:24Z

Summary

Identity-keyed array diffing redesigned: matched elements now emit element-level replace ops with a grouped changes array (absolute paths), rather than flat field-level ops. Displaced elements emit move ops carrying identity.
Ordered arrays + displacement: x-ordered: true on a schema array surfaces position changes as move ops. displacement field on replace ops when an element is both modified and displaced.
New diff() options: includeUnchanged returns all elements including unmodified ones (for UI rendering without a separate zip); cascade (default true) controls whether nested identity-array changes bubble up to mark the parent as modified.
New restore(op): inverts any DiffOp and pushes to the undo stack. Move restore uses splice semantics (removeAt + insertAt) not overwrite.
OpType.Unchanged: new op kind emitted only when includeUnchanged: true.
ArrayMeta: replaces bare string in keyMap to carry both key and ordered flag; extractKeyMap reads x-ordered from schema.
Full spec in docs/array-semantics.md and implementation notes in docs/implementation.md.

Test plan

247 tests passing (npm test)
src/engine.array-semantics.test.ts covers: identity matching, ordered displacement, includeUnchanged, cascade (true and false), $self arrays, restore (all op kinds + undo), identity stability, edge cases
Existing engine.test.ts keyed-array tests updated to reflect new element-level grouping behavior

🤖 Generated with Claude Code

Reset point at 0.12.0. Reference for redesigning array diff/revert after the 0.13-0.16 filter-string/segment approach was judged overweight. Captures: key = diff-time addressing; edits belong to the element not the array; identity must be stable (declared, not inferred); order = a hidden position attribute. Defines diff + revert for the three array kinds and the implementation stance (drop segment paths, express revert via the existing functional undo/redo closures).

…acement Captures the converged model: in an ordered array an element whose index shifts because of a nearby add/remove HAS changed (order matters, so it's surfaced) but is NOT revertible on its own — a new 'effect' entry kind that carries a reason pointing at the causing entries. Genuine reorders (crossing a surviving element) are 'move' (revertible). Adds the full entry-kind table, the one-API-both-views note, prior art (RFC 6902 / Myers / CRDTs), and the worked [A,B,C]->[A,B,D,C] example. Replaces the earlier (wrong) 'removal cascades as modifications' framing.

OpType.Move, the {from,to} DiffOp variant, engine.move(), and import/export all exist in 0.12.0; a move op is created inside engine.move() for exportChanges. The gap is diff() never emitting one (diffNode does only add/remove/replace, never detects a reorder). So 'effect' is the only net-new concept; move just needs diff to emit the existing op.

… cases Full redesign of array diff semantics: identity containment, ordered/unordered distinction, displacement as move ops, restore operation, and cascade flag. Adds implementation spec with pseudo-code and a test suite defining the contract. Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

…tore, cascade - DiffOp extended: element-level replace with grouped changes (absolute paths), move op carries identity for displacement, new unchanged op for includeUnchanged - diffArrayByKey rewritten: matched elements emit replace+changes, move, or unchanged based on field changes and displacement - diff() gains includeUnchanged and cascade options; cascade:false stops nested identity array changes from bubbling up to the parent element - restore(op) inverts any DiffOp and pushes to the undo stack; move restore uses splice semantics (removeAt + insertAt) not overwrite - ArrayMeta replaces bare string in keyMap to carry both key and ordered flag - extractKeyMap reads x-ordered from schema - All 247 tests passing Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay · 2026-06-14T22:24:24Z

Summary

Identity-keyed array diffing redesigned: matched elements now emit element-level replace ops with a grouped changes array (absolute paths), rather than flat field-level ops. Displaced elements emit move ops carrying identity.
Ordered arrays + displacement: x-ordered: true on a schema array surfaces position changes as move ops. displacement field on replace ops when an element is both modified and displaced.
New diff() options: includeUnchanged returns all elements including unmodified ones (for UI rendering without a separate zip); cascade (default true) controls whether nested identity-array changes bubble up to mark the parent as modified.
New restore(op): inverts any DiffOp and pushes to the undo stack. Move restore uses splice semantics (removeAt + insertAt) not overwrite.
OpType.Unchanged: new op kind emitted only when includeUnchanged: true.
ArrayMeta: replaces bare string in keyMap to carry both key and ordered flag; extractKeyMap reads x-ordered from schema.
Full spec in docs/array-semantics.md and implementation notes in docs/implementation.md.

Test plan

247 tests passing (npm test)
src/engine.array-semantics.test.ts covers: identity matching, ordered displacement, includeUnchanged, cascade (true and false), $self arrays, restore (all op kinds + undo), identity stability, edge cases
Existing engine.test.ts keyed-array tests updated to reflect new element-level grouping behavior

🤖 Generated with Claude Code

Reset point at 0.12.0. Reference for redesigning array diff/revert after the 0.13-0.16 filter-string/segment approach was judged overweight. Captures: key = diff-time addressing; edits belong to the element not the array; identity must be stable (declared, not inferred); order = a hidden position attribute. Defines diff + revert for the three array kinds and the implementation stance (drop segment paths, express revert via the existing functional undo/redo closures).

…acement Captures the converged model: in an ordered array an element whose index shifts because of a nearby add/remove HAS changed (order matters, so it's surfaced) but is NOT revertible on its own — a new 'effect' entry kind that carries a reason pointing at the causing entries. Genuine reorders (crossing a surviving element) are 'move' (revertible). Adds the full entry-kind table, the one-API-both-views note, prior art (RFC 6902 / Myers / CRDTs), and the worked [A,B,C]->[A,B,D,C] example. Replaces the earlier (wrong) 'removal cascades as modifications' framing.

OpType.Move, the {from,to} DiffOp variant, engine.move(), and import/export all exist in 0.12.0; a move op is created inside engine.move() for exportChanges. The gap is diff() never emitting one (diffNode does only add/remove/replace, never detects a reorder). So 'effect' is the only net-new concept; move just needs diff to emit the existing op.

… cases Full redesign of array diff semantics: identity containment, ordered/unordered distinction, displacement as move ops, restore operation, and cascade flag. Adds implementation spec with pseudo-code and a test suite defining the contract. Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

…tore, cascade - DiffOp extended: element-level replace with grouped changes (absolute paths), move op carries identity for displacement, new unchanged op for includeUnchanged - diffArrayByKey rewritten: matched elements emit replace+changes, move, or unchanged based on field changes and displacement - diff() gains includeUnchanged and cascade options; cascade:false stops nested identity array changes from bubbling up to the parent element - restore(op) inverts any DiffOp and pushes to the undo stack; move restore uses splice semantics (removeAt + insertAt) not overwrite - ArrayMeta replaces bare string in keyMap to carry both key and ordered flag - extractKeyMap reads x-ordered from schema - All 247 tests passing Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay · 2026-06-14T22:24:24Z

Summary

Identity-keyed array diffing redesigned: matched elements now emit element-level replace ops with a grouped changes array (absolute paths), rather than flat field-level ops. Displaced elements emit move ops carrying identity.
Ordered arrays + displacement: x-ordered: true on a schema array surfaces position changes as move ops. displacement field on replace ops when an element is both modified and displaced.
New diff() options: includeUnchanged returns all elements including unmodified ones (for UI rendering without a separate zip); cascade (default true) controls whether nested identity-array changes bubble up to mark the parent as modified.
New restore(op): inverts any DiffOp and pushes to the undo stack. Move restore uses splice semantics (removeAt + insertAt) not overwrite.
OpType.Unchanged: new op kind emitted only when includeUnchanged: true.
ArrayMeta: replaces bare string in keyMap to carry both key and ordered flag; extractKeyMap reads x-ordered from schema.
Full spec in docs/array-semantics.md and implementation notes in docs/implementation.md.

Test plan

247 tests passing (npm test)
src/engine.array-semantics.test.ts covers: identity matching, ordered displacement, includeUnchanged, cascade (true and false), $self arrays, restore (all op kinds + undo), identity stability, edge cases
Existing engine.test.ts keyed-array tests updated to reflect new element-level grouping behavior

🤖 Generated with Claude Code

Reset point at 0.12.0. Reference for redesigning array diff/revert after the 0.13-0.16 filter-string/segment approach was judged overweight. Captures: key = diff-time addressing; edits belong to the element not the array; identity must be stable (declared, not inferred); order = a hidden position attribute. Defines diff + revert for the three array kinds and the implementation stance (drop segment paths, express revert via the existing functional undo/redo closures).

…acement Captures the converged model: in an ordered array an element whose index shifts because of a nearby add/remove HAS changed (order matters, so it's surfaced) but is NOT revertible on its own — a new 'effect' entry kind that carries a reason pointing at the causing entries. Genuine reorders (crossing a surviving element) are 'move' (revertible). Adds the full entry-kind table, the one-API-both-views note, prior art (RFC 6902 / Myers / CRDTs), and the worked [A,B,C]->[A,B,D,C] example. Replaces the earlier (wrong) 'removal cascades as modifications' framing.

OpType.Move, the {from,to} DiffOp variant, engine.move(), and import/export all exist in 0.12.0; a move op is created inside engine.move() for exportChanges. The gap is diff() never emitting one (diffNode does only add/remove/replace, never detects a reorder). So 'effect' is the only net-new concept; move just needs diff to emit the existing op.

… cases Full redesign of array diff semantics: identity containment, ordered/unordered distinction, displacement as move ops, restore operation, and cascade flag. Adds implementation spec with pseudo-code and a test suite defining the contract. Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

…tore, cascade - DiffOp extended: element-level replace with grouped changes (absolute paths), move op carries identity for displacement, new unchanged op for includeUnchanged - diffArrayByKey rewritten: matched elements emit replace+changes, move, or unchanged based on field changes and displacement - diff() gains includeUnchanged and cascade options; cascade:false stops nested identity array changes from bubbling up to the parent element - restore(op) inverts any DiffOp and pushes to the undo stack; move restore uses splice semantics (removeAt + insertAt) not overwrite - ArrayMeta replaces bare string in keyMap to carry both key and ordered flag - extractKeyMap reads x-ordered from schema - All 247 tests passing Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay · 2026-06-14T22:24:24Z

Summary

Identity-keyed array diffing redesigned: matched elements now emit element-level replace ops with a grouped changes array (absolute paths), rather than flat field-level ops. Displaced elements emit move ops carrying identity.
Ordered arrays + displacement: x-ordered: true on a schema array surfaces position changes as move ops. displacement field on replace ops when an element is both modified and displaced.
New diff() options: includeUnchanged returns all elements including unmodified ones (for UI rendering without a separate zip); cascade (default true) controls whether nested identity-array changes bubble up to mark the parent as modified.
New restore(op): inverts any DiffOp and pushes to the undo stack. Move restore uses splice semantics (removeAt + insertAt) not overwrite.
OpType.Unchanged: new op kind emitted only when includeUnchanged: true.
ArrayMeta: replaces bare string in keyMap to carry both key and ordered flag; extractKeyMap reads x-ordered from schema.
Full spec in docs/array-semantics.md and implementation notes in docs/implementation.md.

Test plan

247 tests passing (npm test)
src/engine.array-semantics.test.ts covers: identity matching, ordered displacement, includeUnchanged, cascade (true and false), $self arrays, restore (all op kinds + undo), identity stability, edge cases
Existing engine.test.ts keyed-array tests updated to reflect new element-level grouping behavior

🤖 Generated with Claude Code

Reset point at 0.12.0. Reference for redesigning array diff/revert after the 0.13-0.16 filter-string/segment approach was judged overweight. Captures: key = diff-time addressing; edits belong to the element not the array; identity must be stable (declared, not inferred); order = a hidden position attribute. Defines diff + revert for the three array kinds and the implementation stance (drop segment paths, express revert via the existing functional undo/redo closures).

…acement Captures the converged model: in an ordered array an element whose index shifts because of a nearby add/remove HAS changed (order matters, so it's surfaced) but is NOT revertible on its own — a new 'effect' entry kind that carries a reason pointing at the causing entries. Genuine reorders (crossing a surviving element) are 'move' (revertible). Adds the full entry-kind table, the one-API-both-views note, prior art (RFC 6902 / Myers / CRDTs), and the worked [A,B,C]->[A,B,D,C] example. Replaces the earlier (wrong) 'removal cascades as modifications' framing.

OpType.Move, the {from,to} DiffOp variant, engine.move(), and import/export all exist in 0.12.0; a move op is created inside engine.move() for exportChanges. The gap is diff() never emitting one (diffNode does only add/remove/replace, never detects a reorder). So 'effect' is the only net-new concept; move just needs diff to emit the existing op.

… cases Full redesign of array diff semantics: identity containment, ordered/unordered distinction, displacement as move ops, restore operation, and cascade flag. Adds implementation spec with pseudo-code and a test suite defining the contract. Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

…tore, cascade - DiffOp extended: element-level replace with grouped changes (absolute paths), move op carries identity for displacement, new unchanged op for includeUnchanged - diffArrayByKey rewritten: matched elements emit replace+changes, move, or unchanged based on field changes and displacement - diff() gains includeUnchanged and cascade options; cascade:false stops nested identity array changes from bubbling up to the parent element - restore(op) inverts any DiffOp and pushes to the undo stack; move restore uses splice semantics (removeAt + insertAt) not overwrite - ArrayMeta replaces bare string in keyMap to carry both key and ordered flag - extractKeyMap reads x-ordered from schema - All 247 tests passing Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjayand others added 9 commits June 13, 2026 23:45

docs: strip move from array-semantics; keep focus on effect
204a052

chore: bump version to 0.15.0
0ddc444
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Merge branch 'main' into claude/array-semantics-redesign
4c1fd3c

docs: update README for array semantics, restore, and new diff options
b56420e
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay force-pushed the claude/array-semantics-redesign branch from 1070f6e to b56420eCompare June 14, 2026 22:34

maxjay merged commit be848a2 into mainJun 14, 2026
1 check passed

maxjayand others added 9 commits June 13, 2026 23:45

docs: strip move from array-semantics; keep focus on effect
204a052

chore: bump version to 0.15.0
0ddc444
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Merge branch 'main' into claude/array-semantics-redesign
4c1fd3c

docs: update README for array semantics, restore, and new diff options
b56420e
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay force-pushed the claude/array-semantics-redesign branch from 1070f6e to b56420eCompare June 14, 2026 22:34

maxjay merged commit be848a2 into mainJun 14, 2026
1 check passed

maxjayand others added 9 commits June 13, 2026 23:45

docs: strip move from array-semantics; keep focus on effect
204a052

chore: bump version to 0.15.0
0ddc444
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Merge branch 'main' into claude/array-semantics-redesign
4c1fd3c

docs: update README for array semantics, restore, and new diff options
b56420e
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay force-pushed the claude/array-semantics-redesign branch from 1070f6e to b56420eCompare June 14, 2026 22:34

maxjay merged commit be848a2 into mainJun 14, 2026
1 check passed

maxjayand others added 9 commits June 13, 2026 23:45

docs: strip move from array-semantics; keep focus on effect
204a052

chore: bump version to 0.15.0
0ddc444
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Merge branch 'main' into claude/array-semantics-redesign
4c1fd3c

docs: update README for array semantics, restore, and new diff options
b56420e
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay force-pushed the claude/array-semantics-redesign branch from 1070f6e to b56420eCompare June 14, 2026 22:34

maxjay merged commit be848a2 into mainJun 14, 2026
1 check passed

maxjayand others added 9 commits June 13, 2026 23:45

docs: strip move from array-semantics; keep focus on effect
204a052

chore: bump version to 0.15.0
0ddc444
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Merge branch 'main' into claude/array-semantics-redesign
4c1fd3c

docs: update README for array semantics, restore, and new diff options
b56420e
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay force-pushed the claude/array-semantics-redesign branch from 1070f6e to b56420eCompare June 14, 2026 22:34

maxjay merged commit be848a2 into mainJun 14, 2026
1 check passed

maxjayand others added 9 commits June 13, 2026 23:45

docs: strip move from array-semantics; keep focus on effect
204a052

chore: bump version to 0.15.0
0ddc444
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Merge branch 'main' into claude/array-semantics-redesign
4c1fd3c

docs: update README for array semantics, restore, and new diff options
b56420e
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay force-pushed the claude/array-semantics-redesign branch from 1070f6e to b56420eCompare June 14, 2026 22:34

maxjay merged commit be848a2 into mainJun 14, 2026
1 check passed

maxjayand others added 9 commits June 13, 2026 23:45

docs: strip move from array-semantics; keep focus on effect
204a052

chore: bump version to 0.15.0
0ddc444
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Merge branch 'main' into claude/array-semantics-redesign
4c1fd3c

docs: update README for array semantics, restore, and new diff options
b56420e
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay force-pushed the claude/array-semantics-redesign branch from 1070f6e to b56420eCompare June 14, 2026 22:34

maxjay merged commit be848a2 into mainJun 14, 2026
1 check passed

maxjayand others added 9 commits June 13, 2026 23:45

docs: strip move from array-semantics; keep focus on effect
204a052

chore: bump version to 0.15.0
0ddc444
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

Merge branch 'main' into claude/array-semantics-redesign
4c1fd3c

docs: update README for array semantics, restore, and new diff options
b56420e
Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

maxjay force-pushed the claude/array-semantics-redesign branch from 1070f6e to b56420eCompare June 14, 2026 22:34

maxjay merged commit be848a2 into mainJun 14, 2026
1 check passed

Conversation

maxjay commented Jun 14, 2026

Summary

Test plan

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Conversation

maxjay commented Jun 14, 2026

Summary

Test plan

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Conversation

maxjay commented Jun 14, 2026

Summary

Test plan

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Conversation

maxjay commented Jun 14, 2026

Summary

Test plan

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Conversation

maxjay commented Jun 14, 2026

Summary

Test plan

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

1 participant

Conversation

maxjay commented Jun 14, 2026

Summary

Test plan

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects