21 Commits

Author SHA1 Message Date
alonso.torres
17539d9f0e 🐛 Keep as an override the place a copy shape's old constraint gave it
A constraint applies to the resizes after it, so changing the constraint
of a copy shape moves nothing. But a later sync placed the shape from its
main through the new constraint, as if it had applied to the copy's
earlier resize too, so the same copy showed two places depending on the
sync. A copy shape whose constraint changes in a board sized apart from
its main's along that axis now authors its geometry: it keeps its place,
and later resizes of the board move it through the new constraint. The
frontend's shape update runs the check after any update that marks
overrides.

Tests: centring-a-nested-copy-after-its-copy-resized-keeps-its-children-in-place
(the stale gate program of seed 151006440);
a-constraint-a-copy-sets-after-a-resize-moves-nothing-at-sync expects the
override now.

Benchmark (scripts/bench-components, ms, lower 2.5% quantile), measured
with the previous commit's change in the tree as well:
|                             :world | :baseline |   :now |   :mean | :ratio |
|------------------------------------+-----------+--------+---------+--------|
|  deepest-edit-through-three-levels |    35.215 | 21.443 |  22.755 |   0.61 |
| edit-through-a-chain-of-dependents |    68.931 | 40.138 |  42.216 |   0.58 |
|         library-update-into-copies |    83.083 | 51.127 |  55.671 |   0.62 |
|        main-edit-among-many-shapes |     4.837 |  2.516 |   3.029 |   0.52 |
|           main-edit-into-10-copies |      1.79 |   1.11 |   1.148 |   0.62 |
|          main-edit-into-100-copies |    15.415 |  9.991 |  10.514 |   0.65 |
|         main-edit-into-1000-copies |   153.086 | 97.388 | 114.808 |   0.64 |
|         variant-switch-into-copies |    32.052 | 21.907 |  23.988 |   0.68 |

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:48 +01:00
alonso.torres
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
2026-11-18 10:29:46 +01:00
alonso.torres
a9c31f8b5a 🐛 Turn a copy's subtree by its target's axes, not its raw transform
A board below its minimum size keeps the scale of a resize in its
transform: a 0.01 px nested copy in a turned main resized from 140 to
120 high stored a transform scaled by 6/7. A full sync turned that
copy's children by the raw transform of the target, so they came out
scaled by 6/7, while the settled sync left them at their size.

Turning a subtree to match a target takes only the directions of the
target's axes; the lengths are left to constraints.

Benchmark (scripts/bench-components, ms, lower 2.5% quantile):

| world                              | baseline |     now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels  |   35.215 |  19.727 |  0.56 |
| edit-through-a-chain-of-dependents |   68.931 |  38.407 |  0.56 |
| library-update-into-copies         |   83.083 |   48.07 |  0.58 |
| main-edit-among-many-shapes        |    4.837 |   2.187 |  0.45 |
| main-edit-into-10-copies           |     1.79 |   1.058 |  0.59 |
| main-edit-into-100-copies          |   15.415 |  10.201 |  0.66 |
| main-edit-into-1000-copies         |  153.086 |  96.625 |  0.63 |
| variant-switch-into-copies         |   32.052 |   19.74 |  0.62 |

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:46 +01:00
alonso.torres
d7ade70b57 🐛 Store the turn a mirrored shape's transform decomposes into
When sync turns a subtree, it added the head's angle to the rotation of
every shape in it. A shape mirrored relative to the head stores its turn
the other way, so it kept the right transform and corners with a stored
rotation 90 degrees off: 225 for a transform that its vertical flip
decomposes as 315.

Each turned shape now stores its rotation plus the angle, or minus it
when only that one decomposes its transform with its flips. A copy
flipped through a turned nested head now stores 90, the turn its
transform decomposes into, where it stored 270; the test that recorded
270 checks that the oracle still accepts either sign.

Benchmark (scripts/bench-components, ms, lower 2.5% quantile):

| world                              | baseline |     now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels  |   35.215 |  21.321 |  0.61 |
| edit-through-a-chain-of-dependents |   68.931 |  40.817 |  0.59 |
| library-update-into-copies         |   83.083 |  52.024 |  0.63 |
| main-edit-among-many-shapes        |    4.837 |   2.486 |  0.51 |
| main-edit-into-10-copies           |     1.79 |   0.972 |  0.54 |
| main-edit-into-100-copies          |   15.415 |   9.993 |  0.65 |
| main-edit-into-1000-copies         |  153.086 | 102.183 |  0.67 |
| variant-switch-into-copies         |   32.052 |  23.063 |  0.72 |

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:46 +01:00
alonso.torres
05ae99a666 🐛 Keep a copy child's geometry when the copy authors its constraint
A copy resized after its main keeps a child with top constraints at its
size. Setting that child's vertical constraint to scale in the copy
moves nothing, but the next sync resized the child through the new
constraint by the whole earlier resize: a 20 px child of a copy twice
its main's height became 40 px, at whatever later moment a sync came. A
constraint applies to the resizes after it, so a copy child whose copy
authors a constraint that ties one of its dimensions keeps the geometry
it shows, and its children follow it. The test oracle expects the same.

Benchmark (scripts/bench-components, ms, lower 2.5% quantile):

| world                              | baseline |     now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels  |   35.215 |  20.631 |  0.59 |
| edit-through-a-chain-of-dependents |   68.931 |  39.243 |  0.57 |
| library-update-into-copies         |   83.083 |  46.415 |  0.56 |
| main-edit-among-many-shapes        |    4.837 |   2.091 |  0.43 |
| main-edit-into-10-copies           |     1.79 |   1.073 |  0.60 |
| main-edit-into-100-copies          |   15.415 |   9.951 |  0.65 |
| main-edit-into-1000-copies         |  153.086 | 100.057 |  0.65 |
| variant-switch-into-copies         |   32.052 |  20.292 |  0.63 |

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:46 +01:00
alonso.torres
79b909a0bd 🐛 Keep turned copies and swaps at their first corner
A sync lined up a copy with its main by their untransformed top-left.
Once the main is turned or flipped, a width change moves that point, so
every copy that follows the main drifted about 7 px off the corner the
resize keeps, and a child it overrides left its place. A swapped head of
another size than its position did the same when its board turned: it
was lined up by the untransformed boxes and turned about its own centre.

An untouched copy root turned or flipped like its main now lines up
with it at their first corner, and a swapped head turned like its
position takes its place at that corner, so both turn rigidly with
their board. The oracle resizes an expected turned head about its first
corner in the same way.

Benchmark (scripts/bench-components, lower quantile in ms):

| world                              | baseline |    now | ratio |
|------------------------------------+----------+--------+-------|
| deepest-edit-through-three-levels  |   35.215 | 18.808 |  0.53 |
| edit-through-a-chain-of-dependents |   68.931 | 38.155 |  0.55 |
| library-update-into-copies         |   83.083 | 46.798 |  0.56 |
| main-edit-among-many-shapes        |    4.837 |  2.193 |  0.45 |
| main-edit-into-10-copies           |     1.79 |  0.962 |  0.54 |
| main-edit-into-100-copies          |   15.415 |  9.315 |  0.60 |
| main-edit-into-1000-copies         |  153.086 | 93.184 |  0.61 |
| variant-switch-into-copies         |   32.052 |  20.55 |  0.64 |

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:45 +01:00
alonso.torres
b2757fdbb9 🐛 Carry a copy child's own position when sync moves its parent
A copy child with a geometry override keeps its place inside its parent.
When sync turned or flipped the parent, the child followed, but when sync
only moved it, for instance a nested copy that its main's layout shifted
to make room for a new child, the child stayed where it was and came loose
from its parent. A parent that sync moves without resizing now carries its
whole subtree as well.

Benchmark (scripts/bench-components, ms, lower 2.5% quantile):

| world                              | baseline |    now | ratio |
|------------------------------------+----------+--------+-------|
| deepest-edit-through-three-levels  |   35.215 | 18.821 |  0.53 |
| edit-through-a-chain-of-dependents |   68.931 | 37.929 |  0.55 |
| library-update-into-copies         |   83.083 | 48.193 |  0.58 |
| main-edit-among-many-shapes        |    4.837 |   2.06 |  0.43 |
| main-edit-into-10-copies           |     1.79 |  0.959 |  0.54 |
| main-edit-into-100-copies          |   15.415 |   9.24 |   0.6 |
| main-edit-into-1000-copies         |  153.086 | 92.816 |  0.61 |
| variant-switch-into-copies         |   32.052 | 19.519 |  0.61 |

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:45 +01:00
alonso.torres
9056fc9128 🐛 Keep the size a board's constraints give a nested copy on sync
A copy inside a plain board, such as a main, follows the board's resizes
through its constraints. That resize is not an override: the user did not
set the size. The next sync of the copy's own component then gave it the
component's size, undoing the constraint: a copy scaled to 80 px inside an
80 px main went back to 100 px and overflowed it.

When syncing a copy head whose parent is a plain board, keep the dimensions
its constraints tie to that board (scale or left-right horizontally, scale
or top-bottom vertically); its other attributes still sync. The main is
placed at those dimensions first, so the copy's children follow through
their constraints.

A second re-run of the seed-20261101 library property found this; it also
fails on earlier commits. The regression fails before the fix (100 px after
a fill edit of the component) and passes after it: the copy stays 80 px
tall, takes the new fill, keeps the component's width and gets no geometry
override. Full common passes lint, JVM, JavaScript and formatting: JVM 2078
tests / 33886 assertions; JavaScript 2014 / 32497. All six component
properties pass 40 programs each at seed 712 in both runtimes.

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.895     0.50
Main into 100 copies         15.415     9.268     0.60
Main into 1000 copies       153.086    91.733     0.60
Three nesting levels         35.215    18.542     0.53
Dependency chain             68.931    37.663     0.55
Library update               83.083    44.259     0.53
Many plain shapes             4.837     2.206     0.46
Variant switch               32.052    20.658     0.64

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:45 +01:00
alonso.torres
9eda12b819 🐛 Place copy children through the constraints they author
Resizing a copy placed its children through their own constraints, but sync
then placed them again through the constraints of the main children they
pair with. A child that authored a scale, right or left-right constraint
went back to the main's left placement on the next sync, while partial sync
kept the resized result.

When sync places the main subtree like a resized copy, resize the main
children with the constraints their copy children author. The swapped head
placement step takes the head's authored constraints the same way. The
generated oracle predicts copy child geometry with the same rule.

A random common JavaScript structure run found this. Its shrunk program
fails I4 against the old oracle and I6 against the old sync. The direct
regression fails three of 15 assertions before the fix: each authored
constraint places the child on resize, and sync moves it back. Both pass
unchanged after the fix. Goldens are unchanged.

Full common passes lint, JVM, JavaScript and formatting: JVM 2054 tests /
33757 assertions; JavaScript 1990 / 32348. All six component properties pass
40 programs each at seed 712 in both runtimes. Full rebuilt frontend passes
1798 / 15737. Backend passes 1838 / 9293 (a pool-statistics race failed once
and passed on rerun); exporter passes 16 / 40. Consumer lint and formatting
pass. The final nil filter on authored constraints ran in the focused sync,
geometry and golden suites after the full runs.

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.885     0.49
Main into 100 copies         15.415     8.615     0.56
Main into 1000 copies       153.086    87.402     0.57
Three nesting levels         35.215    18.043     0.51
Dependency chain             68.931    35.277     0.51
Library update               83.083    43.810     0.53
Many plain shapes             4.837     2.070     0.43
Variant switch               32.052    19.557     0.61

AI-assisted-by: claude-opus-5-5
2026-11-10 20:21:42 +01:00
alonso.torres
85e829844e 🐛 Settle swapped placement when updating a turned main
Updating a rotated copy also turns its main. A swapped descendant whose
content and position sizes differ needs its placement settled in that new
frame. Append the main-file placement changes to the inverse sync, keeping
source-copy changes local and restoring both files in one undo group.

Portable local/library regressions at 45 and 90 degrees fail eight
assertions before the fix and pass all 20 after it. The original seed712
case4855 and its exact shrink pass, as does the 4855..5000 tail diagnostic.
The diagnostic does not replace the full 5000-program swap gate.

Common JVM1851/30684 and JS1782/29308, frontend1539/9312,
backend1610/8104, exporter14/32 and all 68 plugin cases pass.
Focused suites and unchanged goldens pass; lint and formatting pass.
Live WASM at 45/90 degrees keeps placement stable through undo/redo and a
later main edit. Maximum anchor error is below 0.00001px.

Benchmark ratios against the recorded baseline:
main 10/100/1000: 0.49/0.56/0.54; three levels: 0.49;
chain: 0.49; library: 0.50; many shapes: 0.45; switch: 0.58.

AI-assisted-by: GPT-6
2026-11-10 20:21:33 +01:00
alonso.torres
f755452820 🐛 Place reset replacement children in the main frame
Reset clears the parent's geometry override, but replacing a swapped
child cloned its new children through the parent's old rotation. Drop
that override from the whole sync context so existing and new children
use the main's orientation in the same undo group.

F185: portable checks at 45 and 90 degrees fail six assertions before the
fix and pass all fourteen after it. Original and shrunk programs pass.
The focused suite passes 139 tests / 2590 assertions with unchanged goldens.
Live WASM checks reset placement, exact undo/redo, later sync and no
phantom overrides at both angles. Frontend passes 1538 tests / 9253
assertions; plugin 68 cases, lint/format and isolated Stage 3 checks pass.
Common JVM/JS, backend and exporter suites pass.

Phase 1e benchmark ratios: mains 10/100/1000 .50/.55/.57, levels .50,
chain .50, library .52, many shapes .42, variant switch .60.

AI-assisted-by: GPT-6
2026-11-10 20:21:33 +01:00
alonso.torres
fe2c82f358 🐛 Settle swapped placement when a parent turns
A swapped head can inherit a position frame with a different size from
its content. Turning its parent then leaves the head and child away from
the placement that full sync computes. Settle that derived placement in
the primary transform builder for SVG, WASM and shared test operations.
Preserve authored geometry and keep the correction in the same undo group.

F182: portable regression fails four assertions before the fix and passes
all twelve after it. The original and shrunk library programs pass. The
focused suite passes 137 tests / 2570 assertions with unchanged goldens.
Frontend passes 1535 tests / 9141 assertions; lint and formatting pass.
Live WASM checks at 45 and 90 degrees pass undo, redo and later sync.
Common JVM/JS, backend, exporter and all 68 plugin cases pass.

Phase 1e benchmark ratios: mains 10/100/1000 .49/.57/.61, levels .52,
chain .55, library .58, many shapes .59, variant switch .67.

AI-assisted-by: GPT-6
2026-11-10 20:21:33 +01:00
alonso.torres
82003be1fc 🐛 Carry child geometry through parent rotations received by sync
When sync turns a parent, turn its subtree as derived placement before
walking the children. Geometry overrides keep their size and relative
angle, including swapped children. Read current builder objects throughout
the walk so later syncs do not transform stale records again.

Normalize matrix axis directions for this turn: constraints already handle
resize, and minimum-size matrix scale must not resize children twice.

Portable regression fails for ordinary and swapped geometry overrides.
Expanded controls cover parent turns of 45/135 degrees and authored child
angles of 0/10 degrees, points, flags, retained size, repeat sync and undo.
Broad focused/golden checks: 204 tests, 2314 assertions. Latest controls
and shrunk program: 2 tests, 89 assertions. Goldens remain unchanged.
Initialize the container when direct sync receives an empty builder.
Register the geometry namespace in the JavaScript runner and read record
fields with get in the older flip control. Geometry: 9 tests, 149
assertions on both runtimes. Full common JS: 1768 tests, 29215 assertions.
Full frontend: 1532 tests, 9039 assertions. Lint and formatting pass.
Live WASM verifies both roles, retained placement and later style sync.

Component benchmark ratios: mains 0.51/0.56/0.64; levels 0.62;
chain 0.55; library 0.53; many shapes 0.45; variant switch 0.60.
All worlds pass the unchanged baseline gate.

AI-assisted-by: GPT-6
2026-11-10 20:21:33 +01:00
alonso.torres
1a47d7b9fc 🐛 Compose child flip flags through parent placement
Keep the source and parent-frame flip composition when placing component
content through a rotated parent. A fresh large matrix turn can otherwise
set both child flip flags even though the user only rotated (F170).
Preserve nil/false representation when the parent does not flip an axis.

The portable regression fails two flag assertions before the fix. Eight
geometry tests pass 61 assertions, the original library shrink passes, and
the pure golden master matches all 1149 assertions without recording.
Common and frontend lint and format pass.

Benchmark ratios against Phase 1e: main 10/100/1000 copies 0.58/0.74/0.57,
three levels 0.49, chain 0.49, library 0.52, many shapes 0.47, variant
switch 0.61. No regression flags.

AI-assisted-by: GPT-6
2026-11-10 20:21:33 +01:00
alonso.torres
5d2d5eda23 🐛 Compose child flip flags from the roots during geometry sync
Keep the roots' relative flip state when placing the source subtree.
Several small rotations must give the same child flags after a full sync;
recomputing one large turn could toggle both axes. Fix F139.

The direct regression failed nil/nil to true/true before the fix. Focused
geometry and oracle suites pass 20 tests, 88 assertions.
Benchmark ratios against Phase 1e: main 10/100/1000 0.57/0.64/0.60;
three levels 0.67; chain 0.56; library 0.60; many shapes 0.50;
variant switch 0.64. No regression flag.

AI-assisted-by: GPT-6
2026-11-10 20:21:33 +01:00
alonso.torres
f78a45d5f8 🐛 Queue moved component copies before syncing their new dependents
A copy moved from a rotated parent can need its own component's sync even
when that main did not change. Include the moved heads among the sync
inputs so the new parent's copies receive the settled geometry. Fix F135.

The minimal regression failed before the fix. Geometry suite: 6 tests,
55 assertions, green; the shrunk seed 712 case also passes.
Benchmark ratios against Phase 1e: main 10/100/1000 0.46/0.52/0.53;
three levels 0.47; chain 0.51; library 0.51; many shapes 0.49;
variant switch 0.61. No regression flag.

AI-assisted-by: GPT-6
2026-11-10 20:21:17 +01:00
alonso.torres
5e98b96753 🐛 Keep nested copies in a detached parent's orientation during sync
Express the source subtree in its ordinary parent's orientation before
syncing a surviving nested copy. Detaching a rotated outer instance no
longer makes a later main edit turn the nested copy back. Fix F131.

The focused regression failed on points and rotation before the fix.
Geometry/reset suites: 19 tests, 111 assertions, all green.
Benchmark ratios against Phase 1e: main 10/100/1000 0.46/0.52/0.53;
three levels 0.47; chain 0.51; library 0.51; many shapes 0.49;
variant switch 0.61. No regression flag.

AI-assisted-by: GPT-6
2026-11-10 20:21:17 +01:00
alonso.torres
c4f90eda89 🐛 Match component orientation with its relative transform
Apply the relative orientation matrix directly. Large rotations also
change flip flags, so applying flips before rotation can add 180 degrees.
The text regression fails before this fix at 135 and 225 degrees.

Validation: geometry suite, 4 tests / 50 assertions; existing golden
cases and worlds, 1098 assertions. No existing golden digest changed.

Benchmark lower-quantile ratios against Phase 1e:
main 10/100/1000 copies 0.51/0.59/0.58; three levels 0.53;
chain 0.61; library 0.53; many shapes 0.54; variant switch 0.70.
No regression flag.

AI-assisted-by: GPT-6
2026-11-10 20:21:17 +01:00
alonso.torres
7ff9423355 🐛 Keep intersections accurate for short perpendicular lines
An absolute determinant threshold classified short perpendicular lines
as parallel. Constraint propagation then displaced text in a rotated
nested frame by hundreds of pixels. Compare the determinant relative to
both line lengths, retaining the existing parallel-line fallback.

The component regression failed on points and x/y before the fix. It now
passes, as do direct intersections across sizes and positions, the
geometry tests, and existing composable scenarios.

Sync benchmark ratios against the 1e baseline (lower quantile):
main 10/100/1000 copies 0.47/0.63/0.80; three levels 0.56; chain 0.48;
library 0.50; many shapes 0.45; variant switch 0.56. No regression flags.

AI-assisted-by: GPT-6
2026-11-10 20:21:17 +01:00
alonso.torres
fb1b16fd08 🐛 Preserve scaled content styles through component sync
Store cumulative content scale as an optional shape attribute, default 1.
Sync scales the main's styles by the copy/main ratio separately from
constraint resizing. Keep descendants untouched and allow later main style
edits to propagate (F109). Both renderer modifier paths use this field.

Cover a later sync, repeated scaling, main radius edits, reset and its undo.
The original stroke regression failed before the fix. Common JVM/JS and
frontend suites, backend and exporter tests, lint and format checks pass.
Historical scale gestures cannot be reconstructed from old file data.

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
2026-11-10 20:21:16 +01:00
alonso.torres
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
2026-11-10 20:21:16 +01:00