mirror of
https://github.com/penpot/penpot.git
synced 2026-11-21 17:50:38 +00:00
43 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
65f548e437 |
♻️ Reindent the harness undo check and transform op
Whitespace only, as the formatter wants it after the last changes to same-state? and the transform op of the generator. Harness only; the benchmark is not run. Also in this commit: - Record the frontend golden master of case AY again. The undo and redo checks compare the tokens library by its exported content, so the golden master writes it key by key; the JVM golden master of case AY was recorded again for that, and the frontend one is now too. Same values, written differently. - The harness changes that check the next commit, "Grow a track for a grid copy's new child and keep it at sync". AI-assisted-by: claude-opus-5-5 |
||
|
|
47603c4aa9 |
✨ Transform shapes in the groups and bools of copies
The random histories never transformed a copy shape inside a group or a bool. They now do, where the board around the group has no layout. Inside a layout, a move of a group's shape makes the layout move the group back, and its siblings with it, with nothing authored; that stays out until it is decided. The oracle learns: - the shapes of a group or bool take their place from the board around it, or from the nearest group or bool on the way that authors its geometry; - the geometry check leaves groups and bools out, as their bounds come from their children, which it checks. The frontend replay realises the token value edit as the token form commits it, with its propagation. Test: the-shapes-of-a-moved-copy-group-follow-it; shape structure programs pass (seeds 8101 at 150, 8102 at 300). Harness only; the benchmark is not run. AI-assisted-by: claude-opus-5-5 |
||
|
|
488ee13f08 |
📎 Use this branch's compositions alias in develop's combine tests
The same-name combine tests that develop added build their file with the `tho` alias, which this branch's variant workspace tests name `ctho`, so the frontend test run stopped with a ReferenceError there. Harness only; the benchmark is not run. Also in this commit: - Re-record the combine golden master for unique variant values. Combining two components whose names leave no value gives the second variant "Value 2" where it had an empty value, since develop's fix for same-name combines (#12881). Case au records that combine, so its two variants are recorded again on purpose; no other case changes. AI-assisted-by: claude-opus-5-5 |
||
|
|
e1decc4812 |
✨ Generate variant sets made from components and library set edits
The variant programs now also make sets: transform a component into a variant set (kind make-variant) and combine two components as variants (kind combine), each paired with a switch. The pure runner runs both actions through their common generators with what the frontend events do after them: the reflow of the new board's layout, and a combined board sized 30 px past its mains on each side. Each must leave the components it names as members of one new set in the board, with the same property names; a transform adds a member with a value of its own. The library editor of the stale library programs edits its variant sets too: property edits, added variants, transforms and combines, followed by a library sync and a switch in the consuming file. Their requested results are checked on the library, and an added member takes on the model of the main it duplicates. The test of undoing a library variant a consumer switched to belongs to the previous commit's fix. The stale library programs must cover only the library steps and the operations they are tested with, as the variant programs do; the structure and swap programs cover the rest. A frontend step also waits briefly for an undo transaction its events close on a later tick, as combining variants does, and the golden master transcripts record the components a variant action makes. Harness only; the benchmark is not run. AI-assisted-by: claude-opus-5-5 |
||
|
|
3e6c98c01a |
✨ Generate and check random component histories
The Phase 4 bug hunt: random component programs, an independent model of what they should leave, and the regression programs of what they found. The production fixes they found are the commits before this one, each with its regression programs; this commit holds the test harness, the rest of the tests and the memories they grew with. A regression program that needs the harness runs once this commit is in. - Generation (composable gen): worlds of components, nested copies, variants, libraries (stale and dependent), flex and grid layouts and texts; operations for structure, geometry, styles, texts, layout items, grid tracks and cells, swaps, variant switches, update main, reset, detach, library edits and syncs, undo and redo; shrinking, coverage accounting per operation kind, and PENPOT_GEN_SEED, PENPOT_GEN_NUM and PENPOT_GEN_HISTORIES to choose the seed, the number of programs and their length. - The oracle: invariants on touched groups, overrides, refs, settled versus full sync, design snapshots and the model values, with its own model of authored intent (shadow, geometry, grid and variant rules) instead of production's results. - The frontend replays generated programs through the workspace events and the completion contract, with undo and redo checks. - The oracle unit tests, the test runners' registrations, the golden masters recorded again where a fix changed them, and the memories of the component sync contract and its tests. Harness only; the benchmark is not run. Also in this commit: - Adapt develop's variant set and reload tests to this branch. Develop's tests of transforming a component into a variant set call the event with the set's id and expect the defining commit to hold only the main. Here the transform builds the whole set, its second member included, in one commit: transform-in-variant takes an optional variant id, and the tests expect both members in that commit. - Restore the requires and test wiring the rebase merges dropped. - Generate variant property edits and added variants. The random programs switched between the members of a variant set but never changed the set. AI-assisted-by: claude-opus-5-5 |
||
|
|
05c08b9e9a |
🐛 Read a missing grid direction as row everywhere
A grid without a direction assigned children column-first and grew rows, while grid creation, the direction event, the WASM renderer and CSS export read it as a row grid. The library file builder decodes the direction as optional, so imported files can lack it. Picking "column" on such a grid then swapped auto-placed children. Add grid-direction, which defaults to row, and use it for cell order, track growth, track fitting and the direction event. The generated oracle predicts the same flow order. The builder regressions fail three of six assertions before the fix; the real-event component regression fails six of 293, with main and copies grown to 3x2 instead of 2x3. Both pass unchanged after the fix, including exact undo and redo. The fitting flow-order control's missing-direction case now expects row order. Full frontend passes 1798 tests / 15737 assertions; common JVM passes 2052 / 33613. Backend passes 1838 / 9293; exporter passes 16 / 40. Lint and formatting pass for common, backend and exporter; frontend lint and changed-file formatting pass. Common JavaScript fails only in two random-seed component properties. Both shrunk programs fail the same way without this change and are fixed separately. Compare lower-quantile milliseconds with the saved baseline; keep that baseline unchanged. The machine/JVM warning makes ratios rough. No world is flagged. World Baseline Now Ratio Main into 10 copies 1.790 0.961 0.54 Main into 100 copies 15.415 8.816 0.57 Main into 1000 copies 153.086 94.309 0.62 Three nesting levels 35.215 19.435 0.55 Dependency chain 68.931 37.850 0.55 Library update 83.083 45.747 0.55 Many plain shapes 4.837 2.153 0.45 Variant switch 32.052 20.254 0.63 AI-assisted-by: claude-opus-5-5 |
||
|
|
93df1d680a |
🐛 Fit overridden grid cells when inherited tracks shrink
Removing a main grid track left overridden copy cells beyond their inherited track lists. Follow the main's untouched track count, move or shorten affected cells, and retain cell identity, alignment and other metadata. Explicit copy track overrides keep their own lists. Record the agreed ownership rule in the component sync contract. Fit occupied cells before empty defaults, preserve placements that fit and retain empty authored areas when space remains. Resolve collisions without overlap. If no distinct slot remains, combine children in the retained cell using its properties and a manual position so assignment keeps every child. Reconcile before assignment, then fit overflow back into inherited tracks. Keep the existing minimum track rule for participating children and leave the normal non-shrinking path in place. The portable regression fails eight of 60 assertions before the fix; the real-event frontend regression fails one of 18. Both pass unchanged after the fix, including exact undo and redo. Additional controls cover spans, explicit track overrides, collisions, empty areas/grids, repeated sync and existing row/column/absent-direction ordering. Goldens are unchanged. Browser data checks pass 32 assertions across maps, records and actual ShapeProxy values with WASM initialized. They preserve app state and check data/proxy behavior, not pointer events or visual rendering. Full frontend passes 1797 tests / 15707 assertions; common JVM passes 2050 / 33660. Backend passes 1838 / 9293; exporter passes 16 / 40. Consumer lint and formatting pass. All targeted layout/sync checks pass, including the final 99-test / 725-assertion flow-order run. Full common JavaScript passes 1986 tests / 32311 assertions. Common lint and formatting pass. All six component properties pass 40 programs each at seed 712 in both runtimes. No fresh 5000-program gate ran. Frontend lint and changed-file format pass. Full frontend format retains two existing alignment errors in the unchanged plugin library test. The isolated component benchmark passes all eight worlds with no regression flags. Compare lower-quantile milliseconds with the saved baseline; keep that baseline unchanged. The machine/JVM warning makes ratios rough. World Baseline Now Ratio Main into 10 copies 1.790 0.919 0.51 Main into 100 copies 15.415 9.640 0.63 Main into 1000 copies 153.086 97.121 0.63 Three nesting levels 35.215 19.225 0.55 Dependency chain 68.931 36.700 0.53 Library update 83.083 44.976 0.54 Many plain shapes 4.837 3.433 0.71 Variant switch 32.052 20.612 0.64 AI-assisted-by: gpt-6 |
||
|
|
31f9350d08 |
🐛 Keep grid cell overrides within newly inherited tracks
Create default cells in newly inherited grid tracks before assigning added copy children. A cell override previously made sync append an extra track; a later full sync shrank the tracks beneath the retained cells. Keep existing authored cells and skip positions covered by existing spans. Add common and real frontend row/column growth histories, including an opposite copy direction, retained overrides, exact undo/redo and stable full sync. The original common test failed 12 of 100 assertions and the frontend test failed 4 of 100. Keep those assertions and add checks that each child has exactly one cell. Sync benchmark lower quantiles (ms), baseline -> now (ratio): deepest three levels: 35.215 -> 18.770 (0.53) chain of dependents: 68.931 -> 37.764 (0.55) library update: 83.083 -> 49.418 (0.59) main among many shapes: 4.837 -> 3.008 (0.62) main into 10 copies: 1.790 -> 0.968 (0.54) main into 100 copies: 15.415 -> 9.474 (0.61) main into 1000 copies: 153.086 -> 97.063 (0.63) variant switch: 32.052 -> 22.157 (0.69) All worlds pass the recorded 10% regression limit. The baseline used another machine/JVM, so ratios are rough comparisons. Validation: common JVM 2,016 tests / 33,356 assertions; common JS 1,952 / 32,015; frontend 1,752 / 14,088; backend 1,793 / 9,007; exporter 16 / 40. Six properties pass 40 programs at seed 712 in both common runtimes. Lint and format checks pass for all four modules. Golden-master data is unchanged. AI-assisted-by: gpt-6 |
||
|
|
d883a68d65 |
🐛 Keep layout child grid assignment derived
Changing a grid copy child to absolute touched its parent's grid cells and blocked later main cell updates. Separate parent sizing writes from derived grid assignment in the same undo transaction. Skip generic grid reassignment until the derived write, so it cannot touch the parent first. Add a real-event regression for clean parent cells, later main-cell propagation and exact undo/redo. It fails two of sixteen assertions before the fix and passes afterward. A live WASM check passes 27 checks, including exact page-object snapshots through undo and redo for both edits. Validate the final continuation on common JVM (2004 tests / 32919 assertions), common JS (1940 / 31522), frontend (1745 / 13569), backend (1793 / 9007) and exporter (16 / 40). All four modules pass lint and format. All six generated properties pass 40 programs at seed 712 in both runtimes. Golden data is unchanged. The final continuation benchmark passes with no regression flags. Lower quantile ratios against Phase 1e: main 10/100/1000 0.51/0.58/0.57, three levels 0.57, chain 0.53, library 0.57, many shapes 0.45, variant switch 0.66. Machine/JVM differences make these rough comparisons; baseline unchanged. AI-assisted-by: gpt-6 |
||
|
|
6f7d32d0ae |
🐛 Keep flex deletion and reflow in one undo group
Use the deletion's undo group for its delayed layout update, reusing an enclosing transaction when present. Store that group on the primary changes so deleting a child and moving its siblings undo together. Add real-event regressions for standalone deletion, an explicit group and an outer transaction. Verify exact snapshots after one undo and redo. AI-assisted-by: GPT-6 |
||
|
|
a4eea62bdc |
🐛 Take nested swap constraints from their position source
Settle a nested swap's untouched constraint group from the replaced position, including fixed-scroll. Carry compatible switch overrides first so an inherited position cannot discard an authored constraint override. Cover F224's reduced history in common and the async frontend, both constraint axes, absent position fields, compatible carry and exact undo. The complete original history and browser ShapeProxy replay also pass. Validation: focused swap/variant/golden tests (123 tests, 1,764 assertions), full common JVM/JS, frontend, backend and exporter suites; lint and format. Golden data is unchanged. Benchmark ratios against the unchanged baseline, with no regression flags: mains 10/100/1,000: 0.53/0.58/0.63; three levels: 0.56; chain: 0.55; library: 0.56; many shapes: 0.48; variant switch: 0.65. The baseline uses another machine/JVM, so ratios are rough comparisons. AI-assisted-by: GPT-6 |
||
|
|
a88f53874d |
🐛 Keep pending library edits out of transform settlement
Use the component sync result only as a geometry proposal when settling reflections and swapped placement. Correct existing shapes without pulling pending library content, styles or structure into a transformed copy. Keep path geometry and the primary action's exact undo/redo group. Generate source transforms, letters and all twelve text style units with separate source histories and explicit consumer acceptance. Add dropped source-edit controls and portable/frontend regressions for the accidental pull. Register the new portable namespace in the JavaScript runner. The complete original program and both reductions pass unchanged. Common JVM passes 1,919 tests/31,313 assertions. Full JS passes 1,845/29,770; the newly registered source namespace adds 5/135 passing checks. Frontend passes 1,566/11,119, backend 1,610/8,104 and exporter 14/32. Lint and formatting pass; browser ShapeProxy replay passes. No golden data changes. Benchmark ratios against the unchanged baseline: mains 10/100/1000 0.57/0.65/0.61, levels 0.52, chain 0.51, library 0.52, many shapes 0.47, variant switch 0.60. No regression flag. AI-assisted-by: gpt-6 |
||
|
|
f54d1a288e |
🐛 Skip numerically equal component sync writes
Compare integer and floating forms exactly for scalar values, points and selection rectangles. A library update that only changes their numeric representation must not create changes or an undo entry. Preserve every nonzero difference, including real subpixel moves. Add the reduced resize/library-sync regression and a subpixel control, plus async frontend undo/redo replay. Review and update eight golden states in case N: only equal integer/float representations changed. The recreated seed-712 audit leaves all 61 syncs and undo depths unchanged. Common JVM 1,914 tests/31,146 assertions and JS 1,845/29,810 pass. Frontend 1,563/10,880, its added replay, backend 1,610/8,104 and exporter 14/32 pass. Lint and formatting pass. Exporter needs its test-only secret. Benchmark ratios against the unchanged baseline: mains 10/100/1000 0.54/0.61/0.61, levels 0.53, chain 0.55, library 0.55, many shapes 0.62, variant switch 0.65. No regression flag. AI-assisted-by: gpt-6 |
||
|
|
e5dc24ed83 |
🐛 Keep delayed copy measurements with their undo group
Route non-stacked derived commits to their applied group when a later edit or transaction intervenes. Copy remeasurement must undo with the font action rather than becoming a separate step after an unrelated edit. Keep adjacent non-stacked entries and exclude the redo tail from routing. Extend the font-boundary regression to component mains and copies, and cover both stacking modes during a later transaction. The regression fails before the fix; all 1,563 frontend tests and 10,880 assertions pass. Live WASM history passes exact undo/redo and full-sync consistency. The sync core is unchanged by this undo fix. Its preceding benchmark ratios remain 0.48-0.76 of the unchanged baseline, with no regression flag. AI-assisted-by: gpt-6 |
||
|
|
503330d178 |
🐛 Keep delayed font resizes in their undo group
Stack a delayed derived change into its applied undo group when that group exists, instead of an unrelated later entry or transaction. Preserve an older entry's selection and exclude the redo tail. The delayed-font regression fails before the fix and passes afterward. Async transaction controls pass 18 assertions; the completion suite passes 17 tests / 646 assertions. Full frontend passes 1,563 tests / 10,860 assertions, including unchanged goldens. Lint and formatting pass. A standalone-text WASM history passes 9 checks, with exact undo/redo, full-sync consistency, the original page restored and no pending work. Benchmark ratios against the unchanged Phase 1e baseline: main 10/100/1,000 copies 0.62/0.59/0.62; three levels 0.68; dependency chain 0.54; library update 0.54; many shapes 0.48; variant switch 0.76. All worlds pass without regression flags. The separate late copy-measurement path remains tracked as F222. AI-assisted-by: gpt-6 |
||
|
|
48a627e042 |
🚧 Save component stabilization follow-up
Expand generated component coverage with independent library histories, meaningful mutation counts, varied geometry and variants, all text style units, oracle corruption controls and pending-sync frontend replays. Fix reflected descendants, partial size carry, WASM shape defaults, deferred swap and sidebar text undo, grid visibility, explicit typography ownership, metadata filtering and swapped placement through sync/detach. Recorded validation after F219: - Common JVM: 1,909 tests / 31,088 assertions; JS: 1,840 / 29,688. - Frontend: 1,560 tests / 10,821 assertions. - Backend: 1,610 tests / 8,104 assertions; exporter: 14 / 32. - Applicable lint and formatting pass; golden data stays unchanged. Benchmark ratios against the unchanged Phase 1e baseline: - Main edits into 10/100/1,000 copies: 0.52/0.57/0.58. - Three levels: 0.51; dependency chain: 0.52; library update: 0.58. - Many shapes: 0.42; variant switch: 0.62. No regression flags. This is a checkpoint. The fresh legacy-library gate at seed 712 fails at program 351 (F221); its cause remains unclassified. The other four large gates did not run. F220, F187, F214 and wider coverage remain open. AI-assisted-by: gpt-6 |
||
|
|
2b50fda318 |
✨ Generate component programs across library files
Build a shared library world and route edits, updates and settlement across working and library files. Check the independent override model, geometry, propagation and exact undo for both files. Replay shrunk library failures through the async frontend with the same target choices and barriers. Keep common generation/shrinking and CLJS replay as the main regression suite. Use the plugin for public API, WASM and measured-text smoke checks; retain its existing fixed cases until equivalent coverage replaces them. All four properties pass 5000 programs each with seed712, each in a full run. Fresh swaps: 5009 assertions; library: 5008. Isolated Stage3: 55/379. Live WASM, fonts, undo/redo and later propagation checks pass. Full frontend: 1539 tests, 9312 assertions, including 39 generated replays. Common JVM: 1851 tests, 30684 assertions; JS: 1782 tests, 29308 assertions. Backend: 1610 tests, 8104 assertions; exporter: 14 tests, 32 assertions. Plugin: 68 cases. Lint, formatting and unchanged goldens pass. AI-assisted-by: GPT-6 |
||
|
|
88dd41f065 |
🐛 Record user undo changes before starting derived component sync
Hand applied transitions to the component watcher only after the workspace records their undo entry. Keep the handoff synchronous with the captured prior file data. This preserves transaction order when nesting triggers several component syncs. Fix F137. The minimal replay failed both undo and redo before the fix; its 4 checks now pass. Existing sync scenarios pass their behavior and undo checks; 60 golden digests need review for the accumulated Phase 4 fixes. Common benchmark ratios against Phase 1e: main 10/100/1000 0.46/0.52/0.53; levels 0.47; chain 0.51; library 0.51; many 0.49; switch 0.61. This handoff changes no common benchmark code. AI-assisted-by: GPT-6 |
||
|
|
a25afbe2d6 |
🚧 Save Phase 4 random harness and grid fixes in progress
Save Stage 2 structure, text, geometry and layout generation, independent oracle checks, frontend seeded replay and plugin visible-value checks. Include pending grid sync and deletion fixes with focused regressions. WIP validation: component sync 21 tests / 106 assertions; move shapes 6 tests / 33 assertions. Earlier plugin checks passed 68 full cases, 11 unit tests and types. The final generated replay, golden check, 5000-case gate, full suites and live WASM check remain unfinished. Stages 3 (swaps/variants) and 4 (library files) have not started. F124 benchmark ratios against Phase 1e: main 10/100/1000 copies 0.48/0.52/0.54; three levels 0.53; chain 0.56; library 0.52; many shapes 0.42; variant switch 0.64. No regression flag. The F125 deletion change still needs its final benchmark. Save the detailed resume checklist and logs in the local stabilization plan. Keep that workflow document out of the commit. AI-assisted-by: GPT-6 |
||
|
|
d077a5ec8e |
🐛 Preserve file destinations through undo and redo
Keep a namespaced file destination on each history change. Replay changes in order in their target files, including stacked entries and transactions. Keep payload fields named file-id intact, such as set-tokens-source (F111). Snapshot the current file and every library in both composable runners. Name the file in failure signatures; normalize the server synced-at status stamp alongside modified-at. Update golden cases H and AP for this exclusion. The library update regression checks both files through undo and redo and failed against the old code. Common JVM: 1705 tests; JS: 1633; frontend: 1495; backend: 1610; exporter: 14. All pass, with lint and formatting checks for both changed modules. Benchmark vs Phase 1e (lower quantile, ms): world baseline now ratio main-10 1.790 0.993 0.55 main-100 15.415 9.038 0.59 main-1000 153.086 90.145 0.59 three-levels 35.215 18.989 0.54 chain 68.931 35.045 0.51 library-500 83.083 85.830 1.03 many-shapes 4.837 3.344 0.69 variant-100 32.052 33.586 1.05 All worlds pass the 10% regression threshold. AI-assisted-by: GPT-6 |
||
|
|
5b4049b5da |
🐛 Keep component sync with each user state transition
Emit changes-applied with the commit's prior file data. Sync each commit before a later edit can replace its state or separate its undo group. Allow later commits through while completion barriers finish (F110). Process layout batches after their buffer closes, so reentrant component sync cannot lose a pending layout task. Cover three user edits without an intermediate wait, then every undo and redo. Token and tiny-layout cases also pass. Re-record golden cases X and AJ for the settled timing. Frontend: 1495 tests, 7255 assertions pass; lint and format checks pass. The three-edit regression failed before the fix. Benchmark vs Phase 1e (lower quantile, ms): world baseline now ratio main-10 1.790 0.993 0.55 main-100 15.415 9.038 0.59 main-1000 153.086 90.145 0.59 three-levels 35.215 18.989 0.54 chain 68.931 35.045 0.51 library-500 83.083 85.830 1.03 many-shapes 4.837 3.344 0.69 variant-100 32.052 33.586 1.05 All worlds pass the 10% regression threshold. AI-assisted-by: GPT-6 |
||
|
|
ed29bb4289 |
♻️ Write the touched groups with the :set-touched operation
Two operations set the touched groups of a shape: a :set of :touched, which assigns the value as given, and :set-touched, which keeps them only on a copy and drops an empty set. update-shapes and the undo of add-component wrote the first while their own undo and sync wrote the second. The contract prefers :set-touched; both builders now write it, and an update with only its touched groups changed still records their undo. A :set of :touched is still applied, for changes already stored. Case AE leaves no empty touched set on the shape a detach turned plain; both golden masters record the state again for it. comp-touched-test: an update that sets the touched groups of a copy shape writes one :set-touched operation, and its undo restores them. Benchmark (lower quantile, ms; baseline / now / ratio): deepest-edit-through-three-levels 35.2 / 16.6 / 0.47 edit-through-a-chain-of-dependents 68.9 / 32.8 / 0.48 library-update-into-copies 83.1 / 42.8 / 0.51 main-edit-among-many-shapes 4.8 / 2.3 / 0.48 main-edit-into-10-copies 1.8 / 1.0 / 0.54 main-edit-into-100-copies 15.4 / 8.9 / 0.58 main-edit-into-1000-copies 153.1 / 82.0 / 0.54 variant-switch-into-copies 32.1 / 17.7 / 0.55 AI-assisted-by: claude-opus-5-5 |
||
|
|
fc8dff9fe1 |
✨ Keep the children of a transformed copy shape derived
Decision (f) of the component contract, with a fix it needed and a check of decision (g) (Phase 3c). - Return empty modifiers for a scale constraint axis. The constraint of each axis of a child gives the modifiers that the parent's resize adds to the child; :scale has no method of its own and took the default, which returned an empty vector. Adding a vector to modifiers reads its :last-order as nil: JavaScript adds nil as 0, the JVM throws, so a child scaled on one axis and constrained on the other (scale and top, say) could not be resized on the JVM. The default now returns empty modifiers. geom-shapes-constraints-test checks the default is empty and adds to modifiers. - Keep the children of a transformed copy shape derived. Decision (f) of the component contract: transforming a copy shape touches that shape only; its children change as a consequence and stay untouched, and sync gives them their expected geometry, their main's placed against their parent and resized through their constraints. Touch. The placement step decided per shape whether a transform touched it by comparing it with its copy root, so the children of a resized root that stretched (scale, left and right) were touched (F10), a derived width or height always touched (F22), and a resize that scales the content touched the strokes, radii and the like of every child (F39). The editor now tells the placement step which shapes the user transformed (the keys of the modifiers given, or those the stored modifiers were set for); any other shape of the transform changes only as a consequence of theirs (a child through its constraints, a board that hugs them) and touches nothing. Sync. Sync placed every main shape by the offset between the roots only, so the children of a resized copy root that a resize leaves untouched (center) went back to their main's place at the next sync of the main (F10). Now, before it walks the children of a copy shape that keeps its own geometry, sync resizes, turns and moves the main shape's subtree to match it, its children following through their constraints and layouts, and walks those: each child gets that geometry unless it has its own. comp-expected-geometry-test: a copy root resized as the editor does places a child constrained left, right, center, scale and left-right, leaves it untouched and keeps it there through a sync; a resize that scales the content scales the child's stroke and touches only the root. The frontend golden master records, in cases AI and the touched child under a main rotation, the children the resize or rotation of a root no longer touches. - Check a copy child resize leaves its hug board untouched. Decision (g) of the component contract: the size of a board that hugs its content is the layout's, never an override. The layout reflow writes it as derived, and a transform touches only the shapes the user transformed (decision (f)), so a resize of a copy child that grows the board it sits in touches the child only. workspace-layout-owned-sizes-test pins it. Benchmark (lower quantile, ms; baseline / now / ratio); the machine was loaded, and the code before this change, run in between, gave the same spread (0.44 to 0.59): deepest-edit-through-three-levels 35.2 / 16.7 / 0.47 edit-through-a-chain-of-dependents 68.9 / 33.4 / 0.48 library-update-into-copies 83.1 / 40.3 / 0.49 main-edit-among-many-shapes 4.8 / 2.4 / 0.49 main-edit-into-10-copies 1.8 / 1.0 / 0.54 main-edit-into-100-copies 15.4 / 8.8 / 0.57 main-edit-into-1000-copies 153.1 / 92.7 / 0.61 variant-switch-into-copies 32.1 / 19.6 / 0.61 AI-assisted-by: claude-opus-5-5 |
||
|
|
070fcd44a4 |
🐛 Keep text names and measured sizes derived
The name a text takes from its content and the size it is measured to are
derived: they never touch a copy (decisions (d) and (g), Phase 3c).
- Let a copy text's automatic name follow its own letters.
The editors name a text after its letters on every edit. In a copy that
rename went through the same write as the content, so it touched
:name-group (F27), against decision (d) of the component contract: only an
explicit rename is an override.
- update-shapes takes :ignore-touched as a set of attributes too, and the
editors' commits (v1 and v3, finalize and keystrokes) and the replace of
text pass #{:name}: the name follows the content, so its write is
derived. Token unapply still runs for such an update.
- Sync gives an untouched copy text the name generated from the letters it
shows after the sync when its main's name is the one generated from the
main's letters (decision (d), refined), and the main's name otherwise.
So a copy that retyped its text keeps that name, and one that did not
follows the main's.
The pure runner's text edit makes the same commit. Case Y no longer pins
F27 and checks the copy's name follows its letters; both golden masters
record the copy without :name-group.
text-sync-test: an untouched copy takes the main's letters and name, a
copy that typed its letters keeps the name they give, and a main named by
hand passes its name on.
- Name a text with several paragraphs without line breaks.
The editors name a text after its letters, with the line breaks of its
paragraphs included, so a text "Hello world" + Enter + "Ends Sunday" was
named "Hello world\nEnds Sunday"; the layers panel showed a space there
(F82). generate-shape-name now turns each line break, with the spaces
around it, into one space.
text-test: the name of a two-paragraph text joins them with a space.
- Keep the size a WASM text grows to from touching the copy.
A text that grows with its content (auto width, auto height) gets its size
from the WASM renderer after a font loads, a style changes, a paste or an
edit ends. That size is derived from the content, yet the resize applied
it as a user change, so a copy's text took :geometry-group each time and
kept that size against its main (F1). The resize and the debounced resize,
the size an edit ends with and its geometry undo now pass ignore-touched.
These paths measure the text in WASM, so no headless test reaches them.
Checked in the browser with the WASM renderer: an edit of a copy's text
touches :content-group only, and a resize after a font size change of 24
grows the text with no :geometry-group.
- Keep the finalize resize of a text out of the undo stack.
When an edit of an existing text ends, the WASM renderer gives the size it
grows to, and the finalize commit stores that size along with its undo.
The resize that shows it on the canvas recorded an undo of its own with no
undo group: a release build kept a second undo entry for one edit, and a
dev build failed the undo entry check (F36). It now records none; a new
text still joins the undo group of its creation.
Checked in the browser with the WASM renderer: an edit of an existing text
adds one undo entry.
- Keep the size a text edit ends with from touching the copy.
When an edit of a text ends, the editor stores its content together with
the size measured for it (the SVG renderer's text modifier, or the WASM
measure in the v1 editor). Only the name was written as derived, so an
edit of a copy's text touched :geometry-group besides :content-group, and
the text kept its size against its main (F1, in the SVG renderer). These
writes now take the size, the position data and the name as derived; the
content still touches.
workspace-text-modifier-test: an edit that ends with a measured width
touches the copy text's content only. Checked in the browser with the SVG
renderer: an edit of a copy's text touches :content-group and
:text-content-text only.
- Measure again on WASM the texts a sync writes.
The size of a text that grows with its content is derived (decision (g) of
the component contract): sync writes the main's, and the renderer measures
the text again. The SVG renderer does so when it draws the text; the WASM
renderer did not, so a copy text with content of its own kept its main's
width and height after a sync (F35). Now, with the WASM renderer, a sync
of the current file measures again the auto-grow texts of the current page
it writes, without a component sync of its own, in the undo group of the
sync; a sync with no undo group gets one for both.
Texts on other pages keep the size sync wrote until they are measured
again.
workspace-sync-wasm-text-test: a sync that writes a copy text with content
of its own measures it again, in the undo group of the sync. Checked in
the browser with the WASM renderer: after the main text grows or shrinks,
two copy texts with content of their own get their own widths and no
:geometry-group.
Benchmark (lower quantile, ms; baseline / now / ratio):
deepest-edit-through-three-levels 35.2 / 18.1 / 0.51
edit-through-a-chain-of-dependents 68.9 / 34.0 / 0.49
library-update-into-copies 83.1 / 40.2 / 0.48
main-edit-among-many-shapes 4.8 / 2.5 / 0.51
main-edit-into-10-copies 1.8 / 0.8 / 0.44
main-edit-into-100-copies 15.4 / 8.5 / 0.55
main-edit-into-1000-copies 153.1 / 83.5 / 0.55
variant-switch-into-copies 32.1 / 18.1 / 0.56
AI-assisted-by: claude-opus-5-5
|
||
|
|
524161cacf |
🐛 Fix the component watcher and library updates
Fixes in when the workspace syncs copies and propagates tokens, and in what a layout wait covers (Phase 3c). - Sync the copies when a shape is dragged inside a main. The component watcher dropped every commit flagged :translation? (the WASM drag commits only moves) so dragging whole mains around the canvas stays fast. A drag of a shape inside a main is flagged the same, so its copies never followed until some other edit of that main made them jump (F70). The watcher now drops a translation commit only when it moves shapes outside mains or whole mains: every shape it moves inside a main moves with the main's root (decision (q)). Otherwise the commit goes through component sync like any edit. workspace-sync-barrier-test: a translation of a whole main is dropped; one of a main's child syncs the copy. fill-commit in the interpreter takes several labels. - Propagate the file's tokens after any library update. Updating a library from the notification synced the file and then propagated its tokens, so the copies take the token values of the file's token status, not the library's. The update button of the libraries dialog's Updates tab only synced the file (F83). dwl/update-libraries syncs the file from the given libraries and then propagates its tokens; the notification and the Updates tab both use it. workspace-library-updates-test: updating a library syncs it and then propagates the tokens. - Sync copies whether or not component thumbnails are on. The component watcher's whole pipeline, the sync of the copies included, ran only when the :component-thumbnails flag was on or the WASM renderer was active. The flag is on by default, but an install that turned it off never synced copies on the SVG renderer: editing a main left its copies as they were (F8). The flag now gates only the thumbnail streams. workspace-sync-barrier-test: with the flag off, a main edit reaches the copy. - Hold a token's shapes pending until the token is applied. A plugin's waitForLayoutUpdate waits until no shape has layout work pending. Applying a token resolves the tokens first, asynchronously, and opened no pending work meanwhile, so the wait found nothing pending and returned before the token reached the shapes or their copies (F54). The shapes are now pending, as a :token task, from the start of the resolution until the update is emitted, and the layout, text and sync work it starts takes over from there. The composable interpreter no longer waits on the token itself: case AY applies a token and checks its copies after the same wait a plugin uses, and fails without this change. AI-assisted-by: claude-opus-5-5 |
||
|
|
1e44a136aa |
🐛 Keep guides and reflows in the undo group of their step
Two derived commits that left the copies' sync in an undo entry of its own
(Phase 3c).
- Move frame guides in the undo group of their transform.
A transform of a board sends the move of its guides before the shapes'
update. The guide move committed every guide of the board, moved or not,
each in a commit with an undo group of its own, so when the board was a
main with a guide, its transform and the copies' sync landed in different
undo entries: one undo reverted only the copies (F6).
Both transform paths now give the shapes' update an undo group up front
and pass it to the guide move, which commits only the guides that move,
all in one commit in that group.
workspace-frame-guides-undo-test: one undo reverts a rotation of a main
with a guide, its copy included, and a move of a main together with its
guide.
- Reflow layouts in the undo group of the step that asked for it.
A layout reflow runs a moment after the commit that needs it: the
:layout/update events are buffered for 100 ms and reflowed per page. The
reflow lost the undo group of the step (F43):
- the buffer passed no undo group to the reflow;
- update-shapes asked for a reflow without the group of its commit;
- the reflow's transform opened an undo transaction, so it made an entry
of its own instead of stacking on the latest one, and the sync that a
reflow of a main starts took that entry's fresh group.
So one undo after a sync that reflows (a flex main's margin edit, a nested
sync with minimal frames, a swap) reverted only the reflow, or only part
of the step.
update-shapes now gives a commit that needs a reflow an undo group up
front and passes it on; the buffer reflows each page in the group an
update of that buffer names (those that name none come from the same step,
like update-layout-child's); the reflow stacks on the latest entry with no
transaction of its own.
Cases AJ and AN no longer pin F43: one undo after a nested sync reverts
the remote change and the float noise of the reflow, and one undo after a
flex main's margin edit reverts the margin, the sync and the reflow. The
frontend golden master records that.
AI-assisted-by: claude-opus-5-5
|
||
|
|
c7a8f1afae |
🐛 Fix the variant events and the plugin component calls
Fixes in the variant events of the workspace and in the component calls of the plugin API (Phase 3c). - Rename a variant in one commit. Renaming a variant renamed its board, then each of its components and mains, as separate commits inside an undo transaction. The transaction kept the undo group of its first commit, the board's, while the sync that the renamed mains started took the group of their commits and made an entry of its own: one undo reverted only the copies' names (F6, case AV). clv/generate-rename-variant builds the board, component and main renames in common, and the event commits them once, so the rename and its sync are one undo entry, like transform into a variant. Case AV no longer marks its round trip as a known failure; the frontend golden master records it without failures. - Keep overrides in a plugin swap only within a variant set. The plugin's swapComponent swapped with keep-touched for any component, while the UI keeps a copy's overrides only on a variant switch: the same swap kept different overrides by route (F33). It now keeps them only when the copy's component and the target are variants of one set (decision (p)), as swap-keeps-touched? says. shape-bugfixes-test: two variants of one set keep the overrides; of different sets, or plain components, do not. - Look up a plugin variant head's component in its own file. The plugin's isVariantHead looked the shape's component up in the file of the shape, so it was false for copies of a library's variants; and it looked it up before checking the shape is a head, so on a shape with no component it failed the lookup's assert (F91). It now checks the head first and looks in the shape's :component-file. shape-bugfixes-test: a copy of a library variant is a variant head, and a plain rect is not. - Add a variant with the shortcut when a variant set is selected. The context menu of a variant container offers "Add variant" and shows the create-component shortcut for it, but the shortcut's event did not know containers: with one selected it fell through to creating a component, which the container's own rules refuse (F95). With a single variant container selected, the shortcut now adds a variant to it, as the menu entry does. workspace-variants-test: the shortcut on a variant container gives the set a third member. - Refuse plugin variant edits whose variant is on another page. The variant events the plugin API calls (add a variant, add, remove or rename a property, set a property value) build their changes on the objects of the page the workspace shows. For a variant whose mains sit on another page, they updated the components but not their mains, so the mains kept their old :variant-name and the file failed validation (F94). The plugin now refuses these edits, as it refuses edits of shapes on another page, unless the variant is in the current file and on the current page. library-test: each edit goes through with the variant on the current page and is refused, with nothing emitted, with it elsewhere. - Check every component of an assets group before combining it. The assets panel offers to combine a group of components as variants when they can be: more than one, none a variant, all with their main on one page. It counted every component of the group, subgroups included, but checked the other two rules only on the components directly in it, while the combine takes them all; with none directly in it, those rules always held (F98). can-combine-group? now checks every component of the group. assets-components-test: a group whose only components are in a subgroup can be combined; a variant or a main on another page in a subgroup blocks it; one component cannot. AI-assisted-by: claude-opus-5-5 |
||
|
|
3643d6fb7b |
🐛 Fix component sync, reset and update main
Fixes in the sync of copies from their mains, in reset and in update main
(Phase 3c).
- Undo a token sync to the tokens a copy shape had.
The token sync of a copy shape wrote, as its undo, the shape's tokens read
with an empty map as default, so undoing the sync of a main's token gave a
copy shape that had none an empty :applied-tokens map instead of no map
(F55). The undo now writes the value the shape had.
Case AY no longer marks its round trip as a known failure; both golden
masters record the round trip without failures in the two variants that
hit it.
- Reorder a copy's children with the fewest moves and exact undo.
When a main reordered its children, sync wrote a move for every copy child
the walk found out of place, from its position in the copy's original list
to its main's index:
- once one child was out of place, every following pair was too, so a main
with 1,000 children that moved its first one to the end wrote 999 moves
per copy, quadratic in the children (F85);
- :mov-objects inserts before the index of the list that still holds the
shape, so a move to a later place landed one short, and the undo, which
used the original position, did not put the child back: undoing a
reorder in a main left its copies reordered (F41).
The walk now syncs the pairs, removals and additions first, and then moves
the copy's children, as those changes left them, into their main shapes'
order: the longest run already in order stays, and each other child moves
right after the one before it in the main's order. Each move is computed
on the order the moves before it left, so its index is exact, and its undo
puts the child back after its old neighbour.
The update main walk keeps its moves: the copy's order differs from the
main's only after F41's undo, as the UI never reorders a copy.
comp-sync-test: a reorder in a six-child main moves each displaced copy
child once, gives the main's order, and undoes exactly. Cases F, AG and AO
no longer mark their round trip as a known failure; both golden masters
record it without failures.
- Remap a main's grid cells after the update main pairs children.
An update main from a copy of a grid main pushes the copy's cells into the
main, with each copy child mapped to its main shape. The cells were
remapped before the children walk, when a swapped copy child still
referred to the main child it replaces; the walk then removed that child
and added a new main child for the swapped one. The main's cell kept the
removed child's id and the new child was in no cell (F49); the next sync
of the copy took that broken cell back.
The cells are now remapped after the walk: each copy child goes with the
main shape the walk added for it, or else with the one it refers to.
Case AK no longer pins F49: with a swap, the main's third cell holds the
new main child, the main takes the copy's cells as they are (the swap had
made the first one manual), and the copy keeps its child in the third
cell. Both golden masters record that.
- Add update main's new main shapes and their undo in the main.
When update main pushes a copy child the main lacks (a swapped child), it
adds a copy of it to the main (F102):
- the refit of the groups around it was a :reg-objects that named the
component, which reaches only a deleted component's stored shapes, so a
group in the main kept its old bounds;
- the undo deleted the new shapes from the copy's page, so when the main
sat on another page the undo left them in the main.
The new shapes, the refit of their parents and the undo of both now go to
the main's container; undoing deletes the new shapes and refits the
parents again.
The case AM setup and the new test fit their groups to their children, as
the editor does; an unfitted group's size is one the refit cannot give
back on undo. Both golden masters record case AM with the fitted groups.
comp-sync-test: an update main from a copy on one page into a main on
another fits the group around the pushed copy, and undo gives the main
back.
- Sync flips with the rest of the geometry.
A flip changes a shape's transform, points and selrect, which sync and
touch as geometry, and toggles :flip-x or :flip-y, which were not in
sync-attrs: when a main flipped a child, its copies took the flipped
transform but kept their old flip flags, which the renderers and the
placement of swapped shapes read (F38). A flip on a copy touched geometry
through the transform all the same.
:flip-x and :flip-y now sync and touch as :geometry-group.
comp-sync-test: a copy follows its main's flip, flags and transform,
untouched.
- Reset a nested copy of a flex board keeping its children.
Sync gives each child of a copy of a flex board the flex child attributes
(margins, sizing, z-index, ...) of the main child it refers to. It looked
that child up in the copy head's own component; for a nested copy that is
not where its children's mains are (they are the children of the nested
copy in the outer main), so the lookup gave nil, and a reset, which copies
every attribute, wrote nil into all of them (F103). A child with no main
was written nil the same way.
The lookup now uses the container the walk reads the main shapes from,
where every child's :shape-ref points, and a child with no main shape is
left as it is.
comp-reset-test: resetting a nested copy of a flex board keeps its child's
margin (with a grid board too, whose children F15 leaves).
- Sync layout child attributes of the children of grid mains.
Sync and update main copy the layout child attributes of a board's
children (margins, sizing limits, z-index, absolute position, align-self)
from the shapes they pair with, but only when the main was a flex board:
the children of a grid main never got them, so a margin set on a grid
main's child never reached its copies (F15). Grid boards now go through
the same step, renamed update-layout-children.
comp-sync-test: a copy follows the margin its grid main gives a child.
comp-reset-test checks the reset of a nested grid copy keeps it too.
- Clear remote-synced when a nested copy is reset.
A reset makes a copy equal to its near main, but the reset of a nested
head marked every shape below the copy root :remote-synced, the mark of a
shape last synced from a remote main. Update main reads that mark: it
gives the main the copy's overrides only for shapes without it, and
otherwise clears the main's touched groups. So after resetting a nested
copy, an update main from the top copy cleared the overrides of the nested
copy in the main, which the next sync from its own component then
overwrote (F13).
A reset now clears the mark, as the shapes follow their near main.
comp-reset-test: after a reset of a nested copy, an update main from the
top copy keeps the fill override of the nested copy in the main. Both
golden masters record case AB without the marks.
- Check that a nested copy keeps its constraints.
A copy of one component dropped into another's main, whose constraints the
outer main then sets, keeps them, in that main and in its copies, when the
inner component's main is edited: the setting is an override of the nested
copy. The test guards it; the reset of the constraints a drop writes,
which looked like a loss (F45), changes nothing a user sees, as nil means
the same left/top.
- Undo a library typography sync to the text's measured layout.
The library color and typography syncs rewrite a text's content and clear
its :position-data, so the text is measured again. Their undo put back the
old content but cleared the position data too, so an undone sync left the
text unmeasured (F90). The undo now writes back the position data the text
had.
library-asset-sync-test: undoing a typography sync gives back the font
size and the position data.
- File the copy's relinks of an update main with the copy's file.
Update main from a copy of a library component writes some changes in the
library (the main) and some in the copy's file; the frontend commits each
part to its file, telling them apart by the changes of the copy shapes the
walk visited (F9). A swapped copy child is not visited: update main adds a
main shape for it and relinks the copy shapes to it, and those relinks,
changes of the copy, went with the library's changes. The shapes it
relinks now count as the copy's.
comp-sync-test: pushing a swap from a copy of a library component keeps
every change of the copy's shapes in the local part.
Benchmark (lower quantile, ms; baseline / now / ratio):
deepest-edit-through-three-levels 35.2 / 16.9 / 0.48
edit-through-a-chain-of-dependents 68.9 / 33.0 / 0.48
library-update-into-copies 83.1 / 40.9 / 0.49
main-edit-among-many-shapes 4.8 / 2.3 / 0.48
main-edit-into-10-copies 1.8 / 0.8 / 0.45
main-edit-into-100-copies 15.4 / 7.8 / 0.51
main-edit-into-1000-copies 153.1 / 82.2 / 0.54
variant-switch-into-copies 32.1 / 18.2 / 0.57
AI-assisted-by: claude-opus-5-5
|
||
|
|
b5aa49801f |
🐛 Check and commit plugin component calls as the UI does
- The UI offers swap and reset only on copy heads, and detach only on copies that are not inside another copy. The plugin's swapComponent and resetOverrides accepted any shape inside a copy (F92), and its detach any shape at all (F93), and sent the same events, whose changes expect a head. swapComponent and resetOverrides report "The shape is not a component copy head" for anything else; detach reports a shape that is not a copy, or a copy inside another copy, by ctn/detachable?, which the detach event checks too. swapComponent looked up the target file before checking its argument, so a value that is not a component failed an assert instead of reporting "Component not valid". - The plugin's switchVariant did not check whether the switch would nest a component in itself. The switch event checks that and calls the :on-error of its params' metadata; the plugin passed none, so the default, rx/throw, built an error observable that nothing used, and the call did nothing and reported nothing (F53). The plugin passes an :on-error that reports "The switch would create a component nesting loop", and the event's default does nothing. - Choosing a property value in the design tab with several members selected sent, for each member, an event that set the value and another that cleared its error, each its own commit and undo entry. The plugin's setVariantProperty set the value and left the error as it was (F94). dwv/update-property-value takes the components, and sets the value and clears the error of each in one commit; the design tab passes the selected members, the plugin its component, and the composable interpreter the one member of its edit. shape-bugfixes-test checks each plugin case on the proxy, and workspace-variants-test sets a value on two members with errors. AI-assisted-by: claude-opus-5-5 |
||
|
|
9296c00209 |
✨ Build variant actions and update main changes in common
Several actions built their changes in frontend events, step by step, each step its own commit, so the pure runner could not run them and one undo could revert half an action. - Renaming a variant member in the layers panel sent three events, each in its own undo transaction: update the properties from the typed formula, remove the properties no member gives a value, and set or clear the member's error. One undo reverted only the last. clvp/generate-rename-member builds the three steps in one changes (with generate-update-properties and generate-remove-empty-properties), and dwv/rename-member commits it once with the same analytics events. update-properties-names-and-values goes; remove-empty-properties and update-error stay for the design tab. - Transforming a component into a variant sent about fourteen events, and combining components as variants that transform and eight more. clv/generate-transform-in-variant and clv/generate-combine-as-variants build those steps as one changes, from the generators common already had, and the events commit them once. The flex layout initializer moves to common as cls/layout-initializer. Combine still sizes the board with two frontend dimension updates inside its undo transaction: the frontend applies them through modifiers, which common has no step for. - update-component split the changes of an update main (the copy's, marked :local-change?, from the main's, which may belong to a library) with two transducers; cll/split-local-changes does it. Its undo-group argument, never passed, goes, and the main's library is the copy head's :component-file, which it looked up through the file data only to read its id back. - dwv/valid-variant-switch? read the libraries from the state and repeated the lookup of clv/find-switch-target. clv/valid-switch? takes the libraries and asks find-switch-target; the plugin's switchVariant and the frontend test call it. Behavior changes: - One undo after a rename of a member, a transform or a combine reverts all of it. After a transform, it reverted only the sync of the copies' names (F6 in case AT); its pins go. - The transform no longer sends the "create-board" analytics event of the board it creates around the main. In the composable suites, renaming a member in the layers panel, removing the empty properties and setting a member's error are variant property edits both runners run, and case AW joins the JVM set. Its rename node drives the real layers-panel rename, which removes the empty properties too, so the step that removed them goes. The golden masters are recorded again for AW (the JVM one gains the case, the frontend one loses that step) and for AT (its final states no longer list the F6 undo failures). AI-assisted-by: claude-opus-5-5 |
||
|
|
1fa27f0299 |
♻️ Build the changes of the variant property events once
- Removing, reordering and setting the value of a variant property each wrote the component's new properties and then the variant name of its main, built from them. set-variant-properties does both. - ctv had two functions that find the position of a property by name; the private find-index-by-name goes. - generate-reorder-variant-poperties and the frontend event reorder-variant-poperties are spelled reorder-variant-properties. - Nine events of workspace/variants (set the value, the name, the error, the variant id, add, remove, remove the empty ones, reorder, and update after a rename in the layers) each looked up the page, its objects and the file data, built the same empty changes, and committed them inside an undo transaction. variant-changes builds those changes, and the transactions go: each one held a single commit, which already makes one undo entry on its own, or joins the transaction a caller has open. No behavior change: the golden masters and the suites are unchanged. AI-assisted-by: claude-opus-5-5 |
||
|
|
9dd1b356ca |
✨ Record a golden master of the component code
Before refactoring the component sync code, record the exact files the component tests produce, so a refactor that changes any of them fails. The JVM test common-tests.logic.golden-master-test runs every variant of the composable cases the pure runner runs and every benchmark world. It records the file after each user, undo and redo step (the runner's new :observe option), the final files with the signatures of the undo/redo round trip failures, and each world's file after its timed work. The frontend interpreter records the store's files of every variant of its cases and of the completion contract the same way. app.common.test-helpers.golden-master writes a state as the normalized files in sorted "path value" lines: ids become test labels, or numbers in tree order when unlabelled; grid cells are named after their shape and position; timestamps are left out. So a state is the same in every run whatever ids it draws. Only a digest per state is committed; the full lines go to tmp/golden-master/ and tmp/golden-master-frontend/ (recorded/, and actual/ for a state that differs), so diff -r shows a change. PENPOT_GOLDEN_MASTER=record records them again. Both sides repeat exactly across runs. Dropping :opacity from the attributes sync copies fails the case C variants that edit it. The interpreter's fixture also turns cts/wasm-enabled? off for each composable test and restores it after, as it already restores the store. A test that starts the WASM renderer left the flag on, so in a full frontend run the cases ran on WASM shape proxies, which leave out the attributes that are nil or false, and the frontend golden master differed from a run of the cases alone (:flip-x and :flip-y). AI-assisted-by: claude-opus-5-5 |
||
|
|
256d6001a0 |
✨ Test what copy texts keep through sync and switches
Add a battery of tests for text overrides in copies. - A short notation for text content in tests (thtx): paragraphs of runs with short style names, read back with equal runs joined, edits in the notation, set-text and set-content through the change path, and the override rule for texts (override-units), which says which overrides a copy must hold against its main. - Sync matrix: every whole-text copy edit against every main edit, plus the cards of the worked examples, the "Hello world" table, a token on a copy, typographies and a library color sync. Where the code differs from decisions (k) to (o), the result is pinned against F72 to F80. - Switch matrix: copy edits against variants that differ in letters, size, color, a new line or a bolded word; F76, F77, F79 and F81 pinned. - Composable case BA: EditText also edits fills, font family and a whole text; the copy and the main change different styles, then reset or update main, in both runners; F72 pinned. - Editor output: the content the WASM and v1 editors commit when a copy text is typed into, retyped, split with Enter and has a word bolded, recorded in the workspace and replayed on a copy. Typing sets only the text groups and a style change no text override; F79 pinned on both editors' content. |
||
|
|
62f99e0493 |
✨ Make the component test suites fail when their claims break
A review found tests that would pass with what they test broken. - Runners: both judge one variant at a time, fail a variant with no assertion and a known-failure mark that applies nowhere, and give the asserter the state the operations produced. The pure runner validates the final file and rejects operations of unknown kind. The frontend interpreter fails a step when the store reports an event error (Potok only logs it), reports asserter errors against their case, and stops the watchers that install! starts. - Nodes drive the real code: a main root rename goes through end-rename-shape, and the clipboard's advance of nested copies is one common function, cll/advance-copied-objects, that copy-selected and both test paths call. - Cases N, AH, AI, AK, AD, AE, K, C, H, S, AY, I, Y, AX and F check what they claim; O, R and T get real sizes. - Stricter common unit tests found F60 (a repair detaches healthy copies), F61 (a switch drops a fixed-sizing size), F62 (the ref chain never stops at its target) and F63 (latent); all pinned. - Frontend library tests: the RPC double records on subscribe, the dropped commits check that nothing syncs, and the link and share tests check the events sent. - Plugin suite: OpSwap and OpDetach throw when the API call did nothing, and case AB checks that the reset head is an instance of the original component. - The composable suite memory records the new rules. |
||
|
|
680b08dcaf |
✨ Make composable interpreter steps wait for pending work
The composable interpreter treated a step as done after a 60 ms gap
with no commits, and treated its 2 s timeout as done too. Slow sync or
reflow work could finish after the step, so a case could assert on a
half-synced file.
Each event step now waits, as the plugin waitForLayoutUpdate does,
until every pending work tracked by the reflow registry has drained:
the watcher's sync wait, the sync it starts, and layout and text
reflow. A step that does not drain within 2 s fails the test and names
the work still pending, and the next variant starts with nothing
pending.
The tests cover an edit with a deliberately slow sync, undo and redo
steps that must wait for the watcher's touch-component, translation
and derived commits, a sync that never finishes, and a restart of the
edit watchers, which must keep the undo entries of an edit the same.
Also in this commit:
- Keep page-less changes from adding a nil page. Applying a commit locally
rebuilds the object indices of every page its changes name. Changes that touch
no page, such as :mod-component, name none, and their nil page id was rebuilt
too: the file data in the store gained a page under a nil key holding
{:objects nil}. Every component touch after an edit to a main added it, and
undo never removed it.
- Check undo and redo of every step in the composable cases. The composable
cases tested undo only where a case asked for it, so a change generator with a
wrong inverse, or a step that splits into several undo entries, went
unnoticed.
- Add operations and cases to the composable component suites. The composable
runners could edit, add, remove and move children, swap and switch, but not
run the other component operations.
- Test component validation, repair and library asset sync.
- Add a component sync benchmark with a recorded baseline. The coming refactors
and fixes change sync code, and a slowdown must be seen and explained in the
commit that causes it.
- Tidy the composable suite and make its cases stricter.
- Test the component sync paths no test reached. A coverage run found sync paths
that no test ran.
- Test variant events, token sync and switch overrides. The variant events had
almost no frontend tests, and several switch, paste, token and restore paths
never ran.
- Test the file and container helpers and the library events. The component
helpers of types/file and types/container and the library events of the
workspace had the lowest coverage left.
|
||
|
|
61ec544881 |
🐛 Hold the sync wait for every local commit
The component watcher opened its :sync-file wait only for commits saved to the undo stack. Undo and redo commit without it, so a wait such as the plugin waitForLayoutUpdate returned before the watcher had handled them. Translation and derived commits were filtered out before the wait opened. Open the wait for every local commit of a file and close it once the watcher has decided what to do: sync, only touch the component, or drop the commit. Dropped commits close it right away. Add wrf/pending, a snapshot of the pending work, for tests and diagnostics. |
||
|
|
7d0b9e0b59 |
♻️ Share the workspace edit watchers with the test harness
The composable test interpreter wired its own copy of the undo stack subscription and started only the component watcher, so it reacted to edits differently from the app, and a missing subscription failed silently. Gather the subscriptions that react to edits while a file is open (undo stack, layout updates, text reflow, WASM text measurement) in initialize-edit-watchers, stopped by finalize-edit-watchers, and the per-page component and token watchers in watch-library-changes. The workspace and the interpreter both start them. Starting the edit watchers again replaces the running ones. A file reload starts the workspace again without finalizing it, which left two undo stack watchers running, so an edit added an extra undo entry. |
||
|
|
106572a2d6 |
✨ Run the composable component cases on the JVM
The composable test engine, nodes, setups and cases lived in the frontend test tree, so only the frontend interpreter could run them. Move them to CLJC test helpers under app.common.test-helpers.composable and add a pure runner (comp.runner) that does what the workspace does around each operation, without the frontend store: - after a user operation it syncs the changed components until none is left, as the frontend watcher does with one pass per sync commit; - the operation and its syncs form one undo group, and the undo node reverts the latest one; - it validates the file once the sync or the undo has settled. Each node declares its kind: assembly, user, undo or frontend-only. User nodes record the production changes they apply, and the runner throws when a node breaks that. The swap and switch nodes build their changes with the production clv/generate-component-swap-in-place. Rotate and ChangeHeight need the frontend placement step, so the pure runner rejects them. The cases are zero-arg functions in comp.cases, shared by the frontend interpreter and common-tests.logic.composable-sync-test. The latter runs cases B to M and the new case O, a switch of an overridden copy, on the JVM and in JS. Case N and the rotation case stay frontend-only. |
||
|
|
cd1ece4beb
|
⚡ Keep the translation flag on undo and redo of a move (#12870)
* ⚡ Keep the translation flag on undo and redo of a move
Previously undos and redos always forced a component sync + thumbnail
rerender for every component touched even if the underlying commits were just
translations. This propagates the translation flag to undos and redos and
propagates it to commit-changes. An entry merged from several undos/redos is
a translation only if all of its undos/redos are translations.
This reduces a UI freeze when undoing a move of a board with 453 components
from 2.42s -> 0.22s.
AI-assisted-by: claude-sonnet-5-5
* :translation? -> :translation
---------
Co-authored-by: Andrey Antukh <niwi@niwi.nz>
|
||
|
|
81c3b3cd56
|
📎 Update copyright name on file header (#11346) | ||
|
|
83a3d099f6 |
🐛 Mock RPC and timer in composable test interpreter to fix network errors
The `SyncFromLibrary` op dispatches a real `sync-file` event that schedules `rx/timer 3000` + an RPC call to `update-file-library-sync-status`. In the headless test runner (no backend), this produces a network error that leaks into test output. Wrap the `check` function in `mock/with-mocks` to mock `rp/cmd!` (returning success) and `rx/timer` (firing instantly). This eliminates the 3200ms grace period in `op-grace-ms` and prevents the network error from appearing in test output. AI-assisted-by: mimo-v2.5 |
||
|
|
4ea56e0b89
|
🐛 Fix propagation of geometric changes to rotated component copies (#10574)
* 🐛 Fix geometry sync between mains and rotated component copies Rotating a copy instance as a whole marked every shape inside it as touched for geometry, so later geometric changes in the main (e.g. a resize) were no longer propagated to that copy, while non-geometric ones (e.g. fills) still were. And on paths where geometry did get written to a rotated copy (e.g. resetting overrides), the sync engine compensated only the roots' position delta, so the written values wiped the copy's rotation back to 0. Model the instance root's transformation as inherited, overridable content, asymmetric to position (which remains free per-instance placement): - An untouched copy follows the main's transformation verbatim, including rotation and flips (preserving the BUG #13267 semantics that rotating a main propagates to its copies). - Transforming a copy as a whole overrides only its ROOT: check-delta compares the root's rotation/flips absolutely, but the descendants relative to their root, so they merely follow and stay untouched. - When a copy root's geometry is overridden, update-attrs expresses the main's geometry in the copy's own frame: reposition-shape applies the roots' relative transformation (rotation/flips) around the dest root center in addition to the position delta. Geometric changes from the main then keep propagating to the rotated copy, landing correctly in its rotated frame instead of destroying its placement. Covered by the new composable test case case-n-geometry-sync-with-rotated-instances: an 8-variant sweep over optional copy rotation, optional main rotation, and one of a fills or height edit on the main child, asserting the whole model through the real workspace events (the new rotate operation dispatches dwt/increase-rotation, whose apply-modifiers step runs the check-delta classification under test; change-height dispatches dwt/update-dimensions and implements IPropertyCheck so one-of sweeps can mix property and geometry edits). Verified by temporarily reverting the fix: the case then fails with 6 assertion failures and passes again with the fix restored. Fixes #10109 AI-assisted-by: claude-fable-5 * 🐛 Fix synchronization problems --------- Co-authored-by: alonso.torres <alonso.torres@kaleidos.net> |
||
|
|
2c15dcdb84
|
✨ Add systematic component tests via a composable test model (#10529)
* ✨ Add systematic component tests via a composable test model Introduce a framework for systematically testing Penpot component behaviour (synchronisation/propagation, swaps, variant switches, nesting), plus a first suite of cases built on it. A test is expressed as a COMPOSITION OF OPERATIONS over a "situation" (an in-memory file value plus named role bindings). Operations are reified as data and composed by two combinators — `in-sequence` (threads the situation) and `one-of`/`optional` (alternatives, enumerated into concrete variants). So one written case stands for a whole matrix of variants, and coverage grows by composition rather than by copying tests. Operations drive the REAL production change pipeline, and event-operations dispatch the REAL workspace events and await settlement, so the production watcher's automatic propagation is what is exercised — the tests reflect genuine app behaviour, not a reimplementation. Structure (frontend/test/frontend_tests/composable_tests/): - core — the domain-agnostic engine: situation, the operation and enumeration protocols, the combinators, and the runners. - comp/nodes — the component operations (create/instantiate/reset, nesting, swap, the variant ops, child add/remove/move, change, undo, library sync). - comp/setups — component-shaped starting configurations. - interpreter — runs a case against the real frontend store: sync-ops apply directly, event-ops dispatch real events and await settlement (absorbing sync-file's delayed status RPC, which would otherwise leak an error into subsequent tests). - comp/sync-test — the cases (B-F, H, I, K, L, M). This is test-only code with a single consumer — the frontend test suite (the layer that runs the real app) — so it lives entirely under the frontend test tree as .cljs, not under app/common. The framework and its cases are documented in the project memory frontend/composable-component-tests, added alongside. Co-authored-by: Claude <noreply@anthropic.com> * 🐛 Guard WASM mock teardown against an empty snapshot `teardown-wasm-mocks!` unconditionally restored from the `originals` atom. When run without a matching setup (double teardown, or `with-wasm-mocks*` misused around an async test body), the snapshot is empty and every WASM API function was `set!` to nil — permanently, for the remainder of the test run. Any later code calling one of them (e.g. a leaked debounced resize-wasm-text event firing during a subsequent test namespace) then crashed with "initialized? is not a function". Make the restore a no-op when there is nothing to restore. Co-authored-by: Claude <noreply@anthropic.com> --------- Co-authored-by: Claude <noreply@anthropic.com> |