A variant switch that carries a turn onto a flipped child gives it the
turn before or after its flips, whichever lies nearer the axes the child
had (`unskewed`). For an unflipped 45-degree turn given a horizontal flip
both lie equally far, and the tie went to the order the engines'
rounding favoured: with the WASM engine the switched child stored
`flipX·R45`, the same shape turned the other way, while its rotation and
flips say `R45·flipX`.
A tie within 1e-9 now takes the turn before the flips, as the function
already intends for axes that tell neither apart.
Found by the WASM replay of the pinned generated programs (program 87, a
switch onto a flipped variant), which passes with it.
Test (comp-expected-geometry-test, fails before the fix with the WASM
engine's axes): `an-unskewed-turn-that-tells-no-flip-apart-turns-before-it`.
Benchmark (bench-components, alone):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+---------+---------+--------|
| deepest-edit-through-three-levels | 35.215 | 22.123 | 22.948 | 0.63 |
| edit-through-a-chain-of-dependents | 68.931 | 41.395 | 43.459 | 0.6 |
| library-update-into-copies | 83.083 | 51.144 | 55.732 | 0.62 |
| main-edit-among-many-shapes | 4.837 | 2.373 | 2.539 | 0.49 |
| main-edit-into-10-copies | 1.79 | 1.047 | 1.091 | 0.58 |
| main-edit-into-100-copies | 15.415 | 10.442 | 10.86 | 0.68 |
| main-edit-into-1000-copies | 153.086 | 105.735 | 109.461 | 0.69 |
| variant-switch-into-copies | 32.052 | 21.661 | 23.984 | 0.68 |
AI-assisted-by: claude-opus-5-5
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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