A nested grid copy with its own cells, switched to a variant with an
identical grid, carries those cells onto the new copy. Its children
kept the new main's order, so they no longer followed the flow of the
carried cells, as the children of a grid copy with its own cells do.
After carrying the cells, the switch reorders the new copy's children
by them, as the sync does for a copy with its own cells.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+---------+--------|
| deepest-edit-through-three-levels | 35.215 | 20.163 | 20.973 | 0.57 |
| edit-through-a-chain-of-dependents | 68.931 | 39.635 | 41.769 | 0.57 |
| library-update-into-copies | 83.083 | 49.886 | 50.993 | 0.6 |
| main-edit-among-many-shapes | 4.837 | 2.05 | 2.334 | 0.42 |
| main-edit-into-10-copies | 1.79 | 0.95 | 1.003 | 0.53 |
| main-edit-into-100-copies | 15.415 | 9.468 | 10.043 | 0.61 |
| main-edit-into-1000-copies | 153.086 | 98.029 | 103.338 | 0.64 |
| variant-switch-into-copies | 32.052 | 21.263 | 22.422 | 0.66 |
AI-assisted-by: claude-opus-5-5
A layout skews a turned child that fills along its parent's axes. A
swapped copy head keeps the lengths of its own component and turned them
to the skewed axes of the main shape it replaces, so the layout squashed
it into another shape than that main; each later sync started from the
squashed head and moved it again. A 100px square turned 45 degrees in a
100px high row gave a 141x100 rhombus for the main and an ordinary copy,
and 163x100, then 156x100, for the swapped copy.
A swapped head that its layout skews now takes the turn its rotation and
flips give, without the skew: its content main is oriented with that
turn, and its placement resets it from its own component and turns it
like the replaced shape's unskewed turn. The layout then skews it as it
skews the main.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+---------+--------|
| deepest-edit-through-three-levels | 35.215 | 21.39 | 22.34 | 0.61 |
| edit-through-a-chain-of-dependents | 68.931 | 42.155 | 43.846 | 0.61 |
| library-update-into-copies | 83.083 | 47.467 | 51.34 | 0.57 |
| main-edit-among-many-shapes | 4.837 | 2.026 | 2.265 | 0.42 |
| main-edit-into-10-copies | 1.79 | 1.025 | 1.065 | 0.57 |
| main-edit-into-100-copies | 15.415 | 9.538 | 10.051 | 0.62 |
| main-edit-into-1000-copies | 153.086 | 96.813 | 102.667 | 0.63 |
| variant-switch-into-copies | 32.052 | 21.011 | 22.247 | 0.66 |
AI-assisted-by: claude-opus-5-5
A switch keeps a copy's swapped child: it moves the swap into the new
copy in place of the new child at its path and deletes that child. In a
grid copy whose cells were its main's, nothing carries the cells, so the
deleted child's cell stayed empty and the swap had no cell; the next
layout of the grid failed on the uncelled child.
`keep-swapped-item` gives the swap the cell of the child it replaces.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+---------+--------|
| deepest-edit-through-three-levels | 35.215 | 22.929 | 23.421 | 0.65 |
| edit-through-a-chain-of-dependents | 68.931 | 41.595 | 45.427 | 0.6 |
| library-update-into-copies | 83.083 | 47.657 | 49.963 | 0.57 |
| main-edit-among-many-shapes | 4.837 | 2.118 | 2.33 | 0.44 |
| main-edit-into-10-copies | 1.79 | 1.126 | 1.158 | 0.63 |
| main-edit-into-100-copies | 15.415 | 10.291 | 11.027 | 0.67 |
| main-edit-into-1000-copies | 153.086 | 101.89 | 104.528 | 0.67 |
| variant-switch-into-copies | 32.052 | 21.203 | 22.033 | 0.66 |
AI-assisted-by: claude-opus-5-5
A copy that turns a nested copy turns the children of that nested copy
with it. When a resize deeper in a child's chain marks it with the
geometry group, the variant switch compares the old child with its ref
to tell whether the copy authored its geometry. It turned the ref only
into the frame of the copy root, so the turn the child inherits from its
nested parent looked authored: the switch placed the child at its main's
unturned offset and marked it touched.
`generate-keep-touched` also turns the ref into the frame of the old
child's parent, so only a turn the child authors itself carries.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+--------+--------|
| deepest-edit-through-three-levels | 35.215 | 20.988 | 21.212 | 0.6 |
| edit-through-a-chain-of-dependents | 68.931 | 41.108 | 42.793 | 0.6 |
| library-update-into-copies | 83.083 | 45.86 | 47.865 | 0.55 |
| main-edit-among-many-shapes | 4.837 | 2.114 | 2.268 | 0.44 |
| main-edit-into-10-copies | 1.79 | 1.004 | 1.024 | 0.56 |
| main-edit-into-100-copies | 15.415 | 9.828 | 9.983 | 0.64 |
| main-edit-into-1000-copies | 153.086 | 98.452 | 99.954 | 0.64 |
| variant-switch-into-copies | 32.052 | 20.156 | 21.317 | 0.63 |
AI-assisted-by: claude-opus-5-5
A child of a turned parent first scales with the parent's resize, and
its constraints then scale it back. The scale back divided by the
child's scaled width with a 0.01 minimum, so a child that the resize
scaled below 0.01 came back too narrow: a 70px text with a left
constraint in a board turned 45 degrees and narrowed to 0.01 kept
40.83px. An axis-aligned parent skips this path, so the layout of an
unturned copy kept 70px while the sync of that copy, which resizes its
turned main, gave 40.83px.
The scale back now divides by the child's real edge lengths, and only a
collapsed child takes no scale.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+---------+--------|
| deepest-edit-through-three-levels | 35.215 | 21.281 | 21.79 | 0.6 |
| edit-through-a-chain-of-dependents | 68.931 | 41.715 | 42.166 | 0.61 |
| library-update-into-copies | 83.083 | 50.352 | 52.632 | 0.61 |
| main-edit-among-many-shapes | 4.837 | 2.29 | 2.413 | 0.47 |
| main-edit-into-10-copies | 1.79 | 0.932 | 0.983 | 0.52 |
| main-edit-into-100-copies | 15.415 | 8.968 | 9.361 | 0.58 |
| main-edit-into-1000-copies | 153.086 | 99.524 | 107.384 | 0.65 |
| variant-switch-into-copies | 32.052 | 21.503 | 21.923 | 0.67 |
AI-assisted-by: claude-opus-5-5
A copy's child authored a swap, and a later swap in the main gave the
child's near main the same component. Update-main clones the copy's
swapped parent into the main, and the clone of the child keeps its swap
against the same near main, as an authored swap stays when its near
main converges. The model dropped the swap from every pushed main shape
whose component equals its ref's; it now keeps it on a main shape that
refers to the same shape as the copy shape.
Harness only; the benchmark is not run.
Also in this commit:
- Turn an authored child by the sign of its own mirror decomposition. A mirrored
shape can store its turn either way: rotation 45 with the flip after the turn,
or 315 with the turn after the flip, for one transform. When a flipped copy
turned, the model turned a child's authored rotation with the sign of the
decomposition the shape stores, while the model may hold the other one, and
expected 270 where production gives 0.
AI-assisted-by: claude-opus-5-5
A switch between identical grids carries a copy's cell overrides, with
each child mapped to the new copy's child at its path. A kept swap takes
that place with its own id, so the cells named the child the switch
removes and the swap had no cell. The kept swap now keeps its own id in
the cells.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+---------+--------|
| deepest-edit-through-three-levels | 35.215 | 21.301 | 21.507 | 0.6 |
| edit-through-a-chain-of-dependents | 68.931 | 38.218 | 42.273 | 0.55 |
| library-update-into-copies | 83.083 | 46.586 | 48.732 | 0.56 |
| main-edit-among-many-shapes | 4.837 | 1.842 | 2.032 | 0.38 |
| main-edit-into-10-copies | 1.79 | 0.924 | 0.968 | 0.52 |
| main-edit-into-100-copies | 15.415 | 9.135 | 9.733 | 0.59 |
| main-edit-into-1000-copies | 153.086 | 99.654 | 101.131 | 0.65 |
| variant-switch-into-copies | 32.052 | 20.939 | 22.049 | 0.65 |
Common suite: 2379 tests, 1 failure, the known insufficient-random-coverage
of random-stale-library-compositions (detach attempted once in 20
programs).
AI-assisted-by: claude-opus-5-5
The switch model carries an authored geometry value only where both
variants agree on it. It compared the new main's child turned into the
new copy parent's orientation with the old main's child unturned, so
under a turned copy the variants seemed to disagree on rotation and the
model dropped the turn the copy's child authors. Both are now turned into
their copy parent's orientation.
Harness only; the benchmark is not run.
AI-assisted-by: claude-opus-5-5
A switch kept a swap whose subtree holds a copy of a nested copy's
component of the new variant, the copy the swap goes into. The move of
the kept swap was refused and it stayed at the page root. A switch now
keeps a swap only when it holds no copy of a component of the shapes it
would be inside: the ancestors of its place in the new variant, and
those of the copy.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+---------+--------|
| deepest-edit-through-three-levels | 35.215 | 19.637 | 20.776 | 0.56 |
| edit-through-a-chain-of-dependents | 68.931 | 40.27 | 42.936 | 0.58 |
| library-update-into-copies | 83.083 | 52.234 | 53.028 | 0.63 |
| main-edit-among-many-shapes | 4.837 | 2.105 | 2.231 | 0.44 |
| main-edit-into-10-copies | 1.79 | 1.079 | 1.11 | 0.6 |
| main-edit-into-100-copies | 15.415 | 10.333 | 10.617 | 0.67 |
| main-edit-into-1000-copies | 153.086 | 97.413 | 103.833 | 0.64 |
| variant-switch-into-copies | 32.052 | 22.451 | 23.0 | 0.7 |
Common suite: 2379 tests, 1 failure, the known insufficient-random-coverage
of random-stale-library-compositions (detach attempted once in 20
programs).
AI-assisted-by: claude-opus-5-5
A copy shape's authored geometry is checked where it sits in the parent
it was authored in, resized through its constraints as that parent
resizes. A constraint edit after a resize of that parent replayed the
resize through the new constraint, though the edit moves nothing and
applies only to later resizes. A constraint edit now anchors the
authored position where the shape sits.
Harness only; the benchmark is not run.
AI-assisted-by: claude-opus-5-5
A copy's child swapped for another component and set to fill takes the
size the layout gives it. When a sync of its main set it back to fix, the
swapped head only took its placement attributes and kept the filled size,
where a full sync gives it its own component's size. A head with
untouched geometry that stops filling in a direction is now synced with
its own component; the sync context carries the file and the libraries
for it.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+---------+--------|
| deepest-edit-through-three-levels | 35.215 | 19.042 | 21.954 | 0.54 |
| edit-through-a-chain-of-dependents | 68.931 | 39.697 | 41.13 | 0.58 |
| library-update-into-copies | 83.083 | 49.796 | 50.704 | 0.6 |
| main-edit-among-many-shapes | 4.837 | 2.3 | 2.482 | 0.48 |
| main-edit-into-10-copies | 1.79 | 1.061 | 1.101 | 0.59 |
| main-edit-into-100-copies | 15.415 | 10.157 | 10.441 | 0.66 |
| main-edit-into-1000-copies | 153.086 | 96.248 | 101.459 | 0.63 |
| variant-switch-into-copies | 32.052 | 21.72 | 22.289 | 0.68 |
Common suite: 2373 tests, 0 failures.
AI-assisted-by: claude-opus-5-5
A copy whose child was swapped to a variant, switched to that variant,
kept the swap. That put a copy of the new component inside a copy of
itself, so the move of the kept child was refused and the child stayed
at the page root, leaving an invalid file. A switch now keeps a swap only
when its subtree holds no copy of the new component, nor of a component
the copy is inside; the new variant's own child takes its place.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+--------+--------|
| deepest-edit-through-three-levels | 35.215 | 19.0 | 20.802 | 0.54 |
| edit-through-a-chain-of-dependents | 68.931 | 36.673 | 38.166 | 0.53 |
| library-update-into-copies | 83.083 | 44.204 | 46.142 | 0.53 |
| main-edit-among-many-shapes | 4.837 | 2.106 | 2.224 | 0.44 |
| main-edit-into-10-copies | 1.79 | 0.917 | 0.981 | 0.51 |
| main-edit-into-100-copies | 15.415 | 8.858 | 9.458 | 0.57 |
| main-edit-into-1000-copies | 153.086 | 89.013 | 93.164 | 0.58 |
| variant-switch-into-copies | 32.052 | 19.844 | 20.613 | 0.62 |
Common suite: 2371 tests, 1 failure, the known insufficient-random-coverage
of random-stale-library-compositions (swap and library-add-variant
attempted too few times in 20 programs).
AI-assisted-by: claude-opus-5-5
A switch carried every text override both variants agree on, also those
whose value the new variant already shows. A copy text whose letters
equal the new variant's kept a content override, because the new
variant's paragraph names a typography the copy's does not; a copy sized
like the new variant's typography kept the size and so dropped that
typography. The switch now carries only the overrides both variants agree
on and where the copy differs from the new variant, and a carried
typography takes every unit it sets along.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+--------+--------|
| deepest-edit-through-three-levels | 35.215 | 19.068 | 20.738 | 0.54 |
| edit-through-a-chain-of-dependents | 68.931 | 42.028 | 42.803 | 0.61 |
| library-update-into-copies | 83.083 | 46.312 | 49.715 | 0.56 |
| main-edit-among-many-shapes | 4.837 | 2.149 | 2.298 | 0.44 |
| main-edit-into-10-copies | 1.79 | 1.002 | 1.023 | 0.56 |
| main-edit-into-100-copies | 15.415 | 9.234 | 9.643 | 0.6 |
| main-edit-into-1000-copies | 153.086 | 92.417 | 97.463 | 0.6 |
| variant-switch-into-copies | 32.052 | 21.472 | 21.958 | 0.67 |
Common suite: 2367 tests, 0 failures.
AI-assisted-by: claude-opus-5-5
The generator built its variant containers at 0.01 by 0.01. Adding a
variant grows the container by a member's width, as the app does, and
a member constrained to scale grew with it by about twelve thousand
times, until its coordinates left the valid range. Both generated
worlds now size the container to 200 by 200, room for its members.
Harness only; the benchmark is not run.
Also in this commit:
- Keep the model of shapes an undo stores in a deleted component. Undoing an
operation that created a component deletes it, and the deleted component keeps
its shapes with their overrides. The model went back to its state before the
operation, which never knew those shapes, so restoring the component expected
none of their overrides. An undo now keeps the model of the shapes it leaves
only in a deleted component.
AI-assisted-by: claude-opus-5-5
A main that nests a variant copy can swap a child of it for another
component and override that component's fill. A copy of the main that
switched its nested copy took the touched groups of the child's whole ref
chain and compared them with the variant's slot, so it carried the fill
authored over the swapped component onto the new variant's board. A child
whose ref chain passes through a swap made by a main now has no
counterpart in the new variant, and nothing carries into it.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+---------+--------+--------|
| deepest-edit-through-three-levels | 35.215 | 19.723 | 20.106 | 0.56 |
| edit-through-a-chain-of-dependents | 68.931 | 36.982 | 39.628 | 0.54 |
| library-update-into-copies | 83.083 | 44.331 | 46.283 | 0.53 |
| main-edit-among-many-shapes | 4.837 | 1.969 | 2.159 | 0.41 |
| main-edit-into-10-copies | 1.79 | 1.05 | 1.078 | 0.59 |
| main-edit-into-100-copies | 15.415 | 10.02 | 10.27 | 0.65 |
| main-edit-into-1000-copies | 153.086 | 100.392 | 102.54 | 0.66 |
| variant-switch-into-copies | 32.052 | 19.796 | 20.354 | 0.62 |
AI-assisted-by: claude-opus-5-5
A copy text marked as owning its typography, though neither it nor its
main applies one, kept its size over a switch to a variant whose text
applies a typography. The size drops that typography, but the switch
asked whether the copy's styles drop it of the copy's whole touched set,
which holds the typography mark, and so marked the dropped reference as a
typography override. The switch now asks of the text overrides it
carries.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+--------+--------|
| deepest-edit-through-three-levels | 35.215 | 19.698 | 20.154 | 0.56 |
| edit-through-a-chain-of-dependents | 68.931 | 37.739 | 39.432 | 0.55 |
| library-update-into-copies | 83.083 | 45.988 | 48.369 | 0.55 |
| main-edit-among-many-shapes | 4.837 | 1.93 | 2.101 | 0.4 |
| main-edit-into-10-copies | 1.79 | 0.971 | 0.987 | 0.54 |
| main-edit-into-100-copies | 15.415 | 9.163 | 9.653 | 0.59 |
| main-edit-into-1000-copies | 153.086 | 91.955 | 96.317 | 0.6 |
| variant-switch-into-copies | 32.052 | 20.339 | 23.274 | 0.63 |
AI-assisted-by: claude-opus-5-5
A switch kept a swapped child of the copy wherever the new variant had a
shape of the same name and ancestor kinds, even a plain board a main had
detached. The kept swap then referred to a shape that is no copy head and
the file failed validation. The switch now keeps a swap only where the
new main holds a copy, and the other swaps go with the old head.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+---------+--------|
| deepest-edit-through-three-levels | 35.215 | 20.978 | 21.326 | 0.6 |
| edit-through-a-chain-of-dependents | 68.931 | 40.47 | 41.523 | 0.59 |
| library-update-into-copies | 83.083 | 47.521 | 50.404 | 0.57 |
| main-edit-among-many-shapes | 4.837 | 2.175 | 2.476 | 0.45 |
| main-edit-into-10-copies | 1.79 | 0.982 | 1.003 | 0.55 |
| main-edit-into-100-copies | 15.415 | 9.423 | 9.949 | 0.61 |
| main-edit-into-1000-copies | 153.086 | 99.435 | 101.227 | 0.65 |
| variant-switch-into-copies | 32.052 | 21.14 | 21.923 | 0.66 |
AI-assisted-by: claude-opus-5-5
A switch carried a child's :x or :y when the old main's child and the new
copy's child shared the coordinate, though one lies in main space and the
other in copy space. A turned copy whose child inherits a resize could
then switch to a child whose :y disagreed with its selrect and points,
touched for a place it never authored. The switch now keeps the new
variant's position and carries only a size.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+--------+--------|
| deepest-edit-through-three-levels | 35.215 | 19.545 | 20.219 | 0.56 |
| edit-through-a-chain-of-dependents | 68.931 | 37.535 | 39.465 | 0.54 |
| library-update-into-copies | 83.083 | 52.071 | 53.432 | 0.63 |
| main-edit-among-many-shapes | 4.837 | 2.116 | 2.202 | 0.44 |
| main-edit-into-10-copies | 1.79 | 1.055 | 1.079 | 0.59 |
| main-edit-into-100-copies | 15.415 | 9.013 | 9.777 | 0.58 |
| main-edit-into-1000-copies | 153.086 | 94.616 | 97.597 | 0.62 |
| variant-switch-into-copies | 32.052 | 23.127 | 23.774 | 0.72 |
AI-assisted-by: claude-opus-5-5
A copy text that cleared a library typography in the generated histories
kept the run's typography file reference with no typography, which the
design panel never writes. The oracle then saw a reference the copy could
not own. Restyling the typography of a test text now replaces the file
reference too.
Harness only; the benchmark is not run.
AI-assisted-by: claude-opus-5-5
A turned copy holds a nested variant copy whose child is flipped. When
the nested copy switches to a variant whose child agrees with the old
one, the switch compared the old main's child with the new copy's child
as they stand, and the copy's turn made their transforms disagree while
their flips agreed. It carried the flip flag without the flipped
transform and points, so the child stored a flip it did not show.
Before carrying, the switch turns the old main's shapes as the copy
turns its new main, so both variants are compared in one frame.
Tests: test-switch-of-a-turned-copy-carries-the-flip-of-its-child and the
regression program
switching-a-turned-copy-keeps-the-flip-its-child-inherits.
Full common suite: 2353 tests, 0 failures.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+---------+--------|
| deepest-edit-through-three-levels | 35.215 | 19.783 | 20.636 | 0.56 |
| edit-through-a-chain-of-dependents | 68.931 | 42.981 | 44.139 | 0.62 |
| library-update-into-copies | 83.083 | 49.497 | 51.013 | 0.6 |
| main-edit-among-many-shapes | 4.837 | 2.119 | 2.197 | 0.44 |
| main-edit-into-10-copies | 1.79 | 0.976 | 1.056 | 0.55 |
| main-edit-into-100-copies | 15.415 | 9.563 | 9.784 | 0.62 |
| main-edit-into-1000-copies | 153.086 | 95.722 | 103.356 | 0.63 |
| variant-switch-into-copies | 32.052 | 21.712 | 22.187 | 0.68 |
AI-assisted-by: claude-opus-5-5
A copy text that overrides its size, and switches to a variant whose
text applies a typography, keeps its size when both variants show the
same one; the typography, whose size is not the copy's, is dropped. The
switch then authored the missing reference as a typography override the
copy never made. txt/drops-typography? tells when a copy's text
overrides hold a unit a typography sets but not the typography; the
switch then leaves out the typography group, and the update-main push
uses the same helper.
Tests: copy-that-resizes-its-text-holds-no-typography-of-the-new-variant
and the regression program
switching-a-resized-copy-text-to-a-typography-variant-holds-no-typography.
Full common suite: 2351 tests, 0 failures.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+--------+--------|
| deepest-edit-through-three-levels | 35.215 | 21.282 | 21.706 | 0.6 |
| edit-through-a-chain-of-dependents | 68.931 | 41.59 | 43.639 | 0.6 |
| library-update-into-copies | 83.083 | 46.407 | 49.512 | 0.56 |
| main-edit-among-many-shapes | 4.837 | 2.075 | 2.227 | 0.43 |
| main-edit-into-10-copies | 1.79 | 0.96 | 1.042 | 0.54 |
| main-edit-into-100-copies | 15.415 | 9.576 | 10.099 | 0.62 |
| main-edit-into-1000-copies | 153.086 | 94.283 | 98.829 | 0.62 |
| variant-switch-into-copies | 32.052 | 22.495 | 22.945 | 0.7 |
AI-assisted-by: claude-opus-5-5
The requested update-main check compared the absolute points of the copy
that pushes its overrides. When that copy sits in a variant and the push
changes the bounds of a sibling variant, the set's layout moves the
copy's variant, and the copy with it, though the copy keeps its place in
its parent. When the copy's parent keeps its size, the check now moves
the expected geometry by the parent's displacement.
Test: the regression program
updating-a-main-from-a-copy-in-a-variant-it-moves-keeps-the-copy-in-place.
Full common suite: the 20-program coverage flakes, and a swap property
failure in a text switch that the next commit fixes.
Harness only; the benchmark is not run.
AI-assisted-by: claude-opus-5-5
A copy text that overrides a typography unit, such as its font family,
drops a typography its main applies, without a typography override.
When update main pushes that text into the main, it keeps the same
reference, yet the push authored the missing reference as a typography
override. The pushed text now leaves out the typography group when its
own text overrides drop the reference; a typography that differs on its
own is still authored.
Tests: pushing-a-text-authors-no-typography-its-own-styles-drop and the
regression program
updating-a-main-from-a-switched-copy-keeps-the-text-overrides-it-pushes.
Full common suite: 2348 tests, 1 failure, the known 20-program coverage
flake (library-redo reached by one program; the property passes).
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+---------+--------|
| deepest-edit-through-three-levels | 35.215 | 19.02 | 19.838 | 0.54 |
| edit-through-a-chain-of-dependents | 68.931 | 37.452 | 39.34 | 0.54 |
| library-update-into-copies | 83.083 | 45.852 | 48.286 | 0.55 |
| main-edit-among-many-shapes | 4.837 | 1.893 | 2.076 | 0.39 |
| main-edit-into-10-copies | 1.79 | 1.068 | 1.092 | 0.6 |
| main-edit-into-100-copies | 15.415 | 10.287 | 10.57 | 0.67 |
| main-edit-into-1000-copies | 153.086 | 97.173 | 105.333 | 0.63 |
| variant-switch-into-copies | 32.052 | 20.618 | 21.363 | 0.64 |
AI-assisted-by: claude-opus-5-5
A variant switch carries the copy's override of a group with the copy's
values, an attribute the copy leaves unset included, as constraints the
copy leaves to their default. The component model took the carried
values with select-keys, which leaves out the attributes a shape does
not store, so the new main's values showed through in the prediction.
The carried attributes now take the copy's value, unset or not.
Harness only; the benchmark is not run.
AI-assisted-by: claude-opus-5-5
Updating a main from a copy with a name override renamed the component
and its main to the copy's name. A variant takes its name from its
set, though, and every member carries it, so a renamed copy of a
variant left the file failing validation (a variant main and component
with a name other than their set's). Updating the main of a variant
copy now pushes everything but the name, and the copy keeps its name as
an override. The component model and its update-main check expect the
same.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 20.618 | 0.59 |
| edit-through-a-chain-of-dependents | 68.931 | 40.714 | 0.59 |
| library-update-into-copies | 83.083 | 49.993 | 0.60 |
| main-edit-among-many-shapes | 4.837 | 2.112 | 0.44 |
| main-edit-into-10-copies | 1.790 | 1.105 | 0.62 |
| main-edit-into-100-copies | 15.415 | 9.427 | 0.61 |
| main-edit-into-1000-copies | 153.086 | 101.540 | 0.66 |
| variant-switch-into-copies | 32.052 | 21.918 | 0.68 |
AI-assisted-by: claude-opus-5-5
A switch keeps a child the copy swapped for another component, and when
the new variant holds that same component at the child's place the swap
ends: the child becomes a plain copy of its new position. It kept the
values it had, though, untouched, so it showed its old size or opacity
where its new main authored others, until some later sync. When a switch
ends a kept child's swap, the switched copy now syncs as an ordinary
copy, as it already did when it carries a size.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 20.516 | 0.58 |
| edit-through-a-chain-of-dependents | 68.931 | 40.411 | 0.59 |
| library-update-into-copies | 83.083 | 52.359 | 0.63 |
| main-edit-among-many-shapes | 4.837 | 2.024 | 0.42 |
| main-edit-into-10-copies | 1.790 | 0.954 | 0.53 |
| main-edit-into-100-copies | 15.415 | 9.210 | 0.60 |
| main-edit-into-1000-copies | 153.086 | 91.498 | 0.60 |
| variant-switch-into-copies | 32.052 | 19.466 | 0.61 |
AI-assisted-by: claude-opus-5-5
A switch between variants with identical grids carried the copy's cells
and marked them as an override whenever its cells were touched along its
reference chain, also when they were the cells the new copy shows. When
both variant mains hold the same cell override, a copy that showed it
without one of its own ended with a redundant cell override after the
switch. The cells now carry only when they differ from the new copy's,
as every other attribute does; the component model predicts the same.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 19.449 | 0.55 |
| edit-through-a-chain-of-dependents | 68.931 | 40.962 | 0.59 |
| library-update-into-copies | 83.083 | 45.075 | 0.54 |
| main-edit-among-many-shapes | 4.837 | 1.959 | 0.41 |
| main-edit-into-10-copies | 1.790 | 0.933 | 0.52 |
| main-edit-into-100-copies | 15.415 | 9.038 | 0.59 |
| main-edit-into-1000-copies | 153.086 | 91.626 | 0.60 |
| variant-switch-into-copies | 32.052 | 21.183 | 0.66 |
AI-assisted-by: claude-opus-5-5
A variant switch keeps a copy's grid cell overrides when the old and the
new variant mains have identical grids: the same tracks and the same
cells holding corresponding children. The component model never
predicted it, since it compared the old main's cells, kept by id, with
the new main's list of cells, so a kept override showed as a phantom.
The model now carries the copy's cells whole in that case, with each
child replaced by the new child at its path.
Harness only; the benchmark is not run.
Also in this commit:
- Predict the end of a swap kept by a switch onto the same component. A variant
switch keeps a child the copy swapped for another component, and when the new
variant holds that same component at the child's place, the child becomes a
plain copy of it: the swap ends, as the swap-group tests of a switch to a
variant with the same component expect. The component model kept the swap
override there. It now drops it for a kept swapped child whose new position
has the same component.
- The harness changes that check the next commit, "Carry no grid cells a
switched copy already shows".
AI-assisted-by: claude-opus-5-5
Adding a flex or grid layout derives its direction, gaps and paddings
from the board's children, leaving out the hidden ones, but it checked
for children before leaving them out. A board whose children were all
hidden then failed: flex reduced an empty list of points and grid read
the bounds of no shapes. Making a variant of a hidden main reaches it,
since the new variant board gets a flex layout around the main. Hidden
children are now left out first; with none left, the layout gets the
parameters of a board with no children.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 20.267 | 0.58 |
| edit-through-a-chain-of-dependents | 68.931 | 39.871 | 0.58 |
| library-update-into-copies | 83.083 | 45.985 | 0.55 |
| main-edit-among-many-shapes | 4.837 | 1.943 | 0.40 |
| main-edit-into-10-copies | 1.790 | 1.036 | 0.58 |
| main-edit-into-100-copies | 15.415 | 9.998 | 0.65 |
| main-edit-into-1000-copies | 153.086 | 97.836 | 0.64 |
| variant-switch-into-copies | 32.052 | 19.658 | 0.61 |
AI-assisted-by: claude-opus-5-5
The pure runner's delete and restore of a component left the layouts
around the main untouched, while the frontend lays out the parents of
the deleted main and the frames the restored shapes go into. In a
variant set, a flex board, a restored member then kept a place the
layout would not give it, and the next edit's layout pass moved it, so a
move of a shape inside it landed off the requested offset. Both
operations now reflow those layouts.
Harness only; the benchmark is not run.
AI-assisted-by: claude-opus-5-5
A switch carries the overrides of a copy's children into the new
variant where both variants agree on the attribute, but it never carried
their layout item attributes: margins, sizing, limits, absolute position,
z-index and alignment. The switch walked the attributes a sync updates,
which leave those out, and its list of attributes a switch may keep did
not have them either, so a copy child lost its own margin or its
absolute position, and the override with it. A switched child now
carries them under the same rule; the switched head keeps its own
placement as before.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 21.753 | 0.62 |
| edit-through-a-chain-of-dependents | 68.931 | 42.985 | 0.62 |
| library-update-into-copies | 83.083 | 51.623 | 0.62 |
| main-edit-among-many-shapes | 4.837 | 1.988 | 0.41 |
| main-edit-into-10-copies | 1.790 | 0.971 | 0.54 |
| main-edit-into-100-copies | 15.415 | 9.418 | 0.61 |
| main-edit-into-1000-copies | 153.086 | 102.474 | 0.67 |
| variant-switch-into-copies | 32.052 | 19.863 | 0.62 |
AI-assisted-by: claude-opus-5-5
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
Undoing the creation of a component removed it from the file. A copy
another file had made of it in the meantime, as a consumer of a library
can after a variant is added there, then pointed at a component that
did not exist: the file failed validation, and the copy could not find
its main shapes or be restored. Undoing the creation now marks the
component deleted and keeps its main's shapes in it, as deleting it
does; redoing it adds it again.
The undo and redo checks of the component tests compare files without
their deleted components, since an undone creation leaves one where
there was none.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 19.745 | 0.56 |
| edit-through-a-chain-of-dependents | 68.931 | 37.914 | 0.55 |
| library-update-into-copies | 83.083 | 48.026 | 0.58 |
| main-edit-among-many-shapes | 4.837 | 1.944 | 0.40 |
| main-edit-into-10-copies | 1.790 | 1.047 | 0.58 |
| main-edit-into-100-copies | 15.415 | 10.179 | 0.66 |
| main-edit-into-1000-copies | 153.086 | 91.854 | 0.60 |
| variant-switch-into-copies | 32.052 | 21.546 | 0.67 |
AI-assisted-by: claude-opus-5-5
Applying a typography to a copy text overrides all six styles it sets,
equal values too, so the typography stays the copy's own. A switch that
carried that text set its overrides from what differs from the new main
only: a family equal to the new main's lost its override while the text
kept the typography, a reference whose styles were split between the
copy and its main, which a later sync could not describe.
When the text a switch carries holds a typography that differs from
the new main's, it overrides all six styles, as applying it does. The
component model predicts the same, and also when the typography came
from a copy level the switched copy refers to.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 20.947 | 0.59 |
| edit-through-a-chain-of-dependents | 68.931 | 40.747 | 0.59 |
| library-update-into-copies | 83.083 | 47.063 | 0.57 |
| main-edit-among-many-shapes | 4.837 | 2.363 | 0.49 |
| main-edit-into-10-copies | 1.790 | 0.964 | 0.54 |
| main-edit-into-100-copies | 15.415 | 9.223 | 0.60 |
| main-edit-into-1000-copies | 153.086 | 95.751 | 0.63 |
| variant-switch-into-copies | 32.052 | 21.325 | 0.67 |
AI-assisted-by: claude-opus-5-5
Adding a variant, or duplicating a variant main into its set, gives the
new member a "Value n" in its last property. The values came from the
last entry of the properties grouped by name, which is a hash map once
a set has nine properties, so the count could come from another
property: with eight empty properties before "Property 9", the new
member took "Value 2", its source's value, and duplicated it.
Both actions now take, through one function, the first "Value n" no
member has at the position the value goes to, n counting up from one
more than the values there. Duplicating a variant main into its set
could also repeat a value in use after a member was deleted, as adding
a variant did.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 20.529 | 0.58 |
| edit-through-a-chain-of-dependents | 68.931 | 40.136 | 0.58 |
| library-update-into-copies | 83.083 | 45.708 | 0.55 |
| main-edit-among-many-shapes | 4.837 | 1.972 | 0.41 |
| main-edit-into-10-copies | 1.790 | 0.920 | 0.51 |
| main-edit-into-100-copies | 15.415 | 9.714 | 0.63 |
| main-edit-into-1000-copies | 153.086 | 96.513 | 0.63 |
| variant-switch-into-copies | 32.052 | 21.386 | 0.67 |
AI-assisted-by: claude-opus-5-5
When a switch carries a copy text's typography override, the model
dropped it unless every other typographic style carried with it, since
a typography reference cannot describe styles split between the copy
and its main. That holds for a typography the copy applied. A copy text
that lacks its main's typography and overrides only its size has no
reference to split: production keeps the typography override, the same
state a sync leaves, and the model now keeps it too.
Harness only; the benchmark is not run.
AI-assisted-by: claude-opus-5-5
Adding a variant names the new member's last value "Value n", n one
more than the number of values that property has. Once a member is
deleted, that count can repeat a value still in use: after adding
"Value 3" and "Value 4" and deleting "Value 3", the next member added
from "Value 4" got "Value 4" again, the same properties as its source.
The new member takes the first "Value n" from that number up that no
member has.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 21.352 | 0.61 |
| edit-through-a-chain-of-dependents | 68.931 | 39.364 | 0.57 |
| library-update-into-copies | 83.083 | 46.730 | 0.56 |
| main-edit-among-many-shapes | 4.837 | 1.943 | 0.40 |
| main-edit-into-10-copies | 1.790 | 1.051 | 0.59 |
| main-edit-into-100-copies | 15.415 | 9.726 | 0.63 |
| main-edit-into-1000-copies | 153.086 | 101.415 | 0.66 |
| variant-switch-into-copies | 32.052 | 20.744 | 0.65 |
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 swap restores the swap-keep-attrs (layout item attributes and
interactions) of the old head on the new one, but dropped the touched
groups they belong to, so a variant switch left those overrides
unprotected and the next sync overwrote them (#12851). The new head now
takes the touched groups of the restored attributes the old head had.
Develop's layout item switch tests count the touched groups exactly;
making a copy child absolute also authors its geometry here, so they
leave :geometry-group out of the count.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 19.816 | 0.56 |
| edit-through-a-chain-of-dependents | 68.931 | 41.189 | 0.60 |
| library-update-into-copies | 83.083 | 48.819 | 0.59 |
| main-edit-among-many-shapes | 4.837 | 2.146 | 0.44 |
| main-edit-into-10-copies | 1.79 | 0.962 | 0.54 |
| main-edit-into-100-copies | 15.415 | 9.577 | 0.62 |
| main-edit-into-1000-copies | 153.086 | 104.859 | 0.68 |
| variant-switch-into-copies | 32.052 | 21.305 | 0.66 |
AI-assisted-by: claude-opus-5-5
A direction change in a grid copy makes its cells an override when the
reflow moves items, and the copy's main has a grid. For a copy that
keeps another component than its main's slot, the main was looked up by
its reference, the slot's board, which has no grid: the reflow moved its
items without making the cells an override, and the next sync of its
own component's main gave it the main's cells back.
The main of a swapped head is the root of its own component, the one its
content and its cells follow.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 19.155 | 0.54 |
| edit-through-a-chain-of-dependents | 68.931 | 43.042 | 0.62 |
| library-update-into-copies | 83.083 | 50.796 | 0.61 |
| main-edit-among-many-shapes | 4.837 | 2.12 | 0.44 |
| main-edit-into-10-copies | 1.79 | 0.958 | 0.54 |
| main-edit-into-100-copies | 15.415 | 9.406 | 0.61 |
| main-edit-into-1000-copies | 153.086 | 93.765 | 0.61 |
| variant-switch-into-copies | 32.052 | 22.183 | 0.69 |
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
A grid fills a child turned in it along the grid's axes, which skews the
child. In a column a fixed sibling left without width, the fill squeezed
the child down to a line: its axes became parallel and its transform
singular, and its stored rotation stopped describing it.
The fill no longer narrows a turned child below 1px of thickness in its
own axes; the child overflows its column instead. The grid passes each
child's own corners with its bounds in the grid's axes to know its size
and turn.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 19.605 | 0.56 |
| edit-through-a-chain-of-dependents | 68.931 | 41.613 | 0.60 |
| library-update-into-copies | 83.083 | 47.375 | 0.57 |
| main-edit-among-many-shapes | 4.837 | 2.321 | 0.48 |
| main-edit-into-10-copies | 1.79 | 0.949 | 0.53 |
| main-edit-into-100-copies | 15.415 | 10.086 | 0.65 |
| main-edit-into-1000-copies | 153.086 | 92.412 | 0.60 |
| variant-switch-into-copies | 32.052 | 20.051 | 0.63 |
AI-assisted-by: claude-opus-5-5
Sync places the content main of a swapped head in the head's orientation
by turning the main's subtree with the head's transform against the
main's. A head shrunk to a fraction of a pixel stores a transform that
carries its rounding, not a pure turn: a child nested into its content
main came out of a full sync slightly scaled and skewed, unlike the
settled copy.
The turn uses only the directions of both transforms' axes.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 22.709 | 0.64 |
| edit-through-a-chain-of-dependents | 68.931 | 43.034 | 0.62 |
| library-update-into-copies | 83.083 | 53.487 | 0.64 |
| main-edit-among-many-shapes | 4.837 | 2.794 | 0.58 |
| main-edit-into-10-copies | 1.79 | 1.068 | 0.60 |
| main-edit-into-100-copies | 15.415 | 10.244 | 0.66 |
| main-edit-into-1000-copies | 153.086 | 105.368 | 0.69 |
| variant-switch-into-copies | 32.052 | 23.65 | 0.74 |
AI-assisted-by: claude-opus-5-5
Changing the direction of a grid copy without cell overrides reflowed its
auto cells and left the layout to pin those after a gap in the new order,
without making them an override. Changing the direction back kept the
pins, so the copy differed from its main with no override, and the next
sync of its main silently changed it.
A direction change that moves no item of such a copy gives it the cells
its main gives it, laid out as sync lays them out in the new direction,
so changing the direction back restores its main's grid; one that moves
items makes the cells an override, as before. The frontend and the test
operation set the cells first and then the direction, the only override
the change makes otherwise.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 21.653 | 0.61 |
| edit-through-a-chain-of-dependents | 68.931 | 40.646 | 0.59 |
| library-update-into-copies | 83.083 | 49.282 | 0.59 |
| main-edit-among-many-shapes | 4.837 | 2.415 | 0.50 |
| main-edit-into-10-copies | 1.79 | 1.072 | 0.60 |
| main-edit-into-100-copies | 15.415 | 9.683 | 0.63 |
| main-edit-into-1000-copies | 153.086 | 103.559 | 0.68 |
| variant-switch-into-copies | 32.052 | 21.623 | 0.67 |
AI-assisted-by: claude-opus-5-5
Turning a subtree to match another orientation stores, for each shape,
its old rotation plus the turn, or minus it when only that one fits its
flips. A turn that also drops or adds a flip leaves neither fitting: a
switch from an unflipped variant to a flipped one kept the copy's
unflipped turn in the transform but stored the flipped main's rotation.
When neither fits, the shape stores the rotation its transform
decomposes into with its flips.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 19.641 | 0.56 |
| edit-through-a-chain-of-dependents | 68.931 | 38.794 | 0.56 |
| library-update-into-copies | 83.083 | 46.743 | 0.56 |
| main-edit-among-many-shapes | 4.837 | 2.355 | 0.49 |
| main-edit-into-10-copies | 1.79 | 0.997 | 0.56 |
| main-edit-into-100-copies | 15.415 | 9.669 | 0.63 |
| main-edit-into-1000-copies | 153.086 | 97.248 | 0.64 |
| variant-switch-into-copies | 32.052 | 21.73 | 0.68 |
AI-assisted-by: claude-opus-5-5
A switch deletes the old head without its swapped children, which it
moves into the new head. A swapped child whose place the new variant
lacks found no counterpart and was never moved: it went with the old
head's subtree without changes of its own, so undo left it out.
The switch keeps out of the deletion only the swapped children whose
place, by name and ancestor kinds in their main, the new variant has;
the others are deleted with the old head and restored by undo.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 21.011 | 0.60 |
| edit-through-a-chain-of-dependents | 68.931 | 40.794 | 0.59 |
| library-update-into-copies | 83.083 | 45.598 | 0.55 |
| main-edit-among-many-shapes | 4.837 | 2.087 | 0.43 |
| main-edit-into-10-copies | 1.79 | 1.001 | 0.56 |
| main-edit-into-100-copies | 15.415 | 10.11 | 0.66 |
| main-edit-into-1000-copies | 153.086 | 98.638 | 0.64 |
| variant-switch-into-copies | 32.052 | 19.844 | 0.62 |
AI-assisted-by: claude-opus-5-5
Generated component programs have up to 40 chunks of operations. Runs
that look for bugs needing longer histories can raise that bound with
PENPOT_GEN_HISTORIES, read like PENPOT_GEN_NUM and PENPOT_GEN_SEED; the
default is unchanged.
Harness only; the benchmark is not run.
AI-assisted-by: claude-opus-5-5
A switch that carries an authored orientation marks a geometry override
when the head's turn differs from its new main's placement. Inside a copy
the placement left out the turn of the head's parent: a head whose near
main's half turn cancelled its turned copy parent's showed the main's own
turn, looked unchanged and lost its override.
The placement includes the parent's turn and flips inside a copy too.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 19.589 | 0.56 |
| edit-through-a-chain-of-dependents | 68.931 | 39.264 | 0.57 |
| library-update-into-copies | 83.083 | 48.997 | 0.59 |
| main-edit-among-many-shapes | 4.837 | 2.377 | 0.49 |
| main-edit-into-10-copies | 1.79 | 1.031 | 0.58 |
| main-edit-into-100-copies | 15.415 | 9.145 | 0.59 |
| main-edit-into-1000-copies | 153.086 | 97.525 | 0.64 |
| variant-switch-into-copies | 32.052 | 21.316 | 0.67 |
AI-assisted-by: claude-opus-5-5
A switch carries the touched attributes of the old copy into the new
one, skipping those whose values are already equal. Geometry was compared
exactly: a turn the new copy already showed, up to float noise in its
transform, was carried and marked as a geometry override the old copy
did not author.
Geometry attributes compare within their precision, as the check that
both variants share a value already does.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 18.972 | 0.54 |
| edit-through-a-chain-of-dependents | 68.931 | 37.79 | 0.55 |
| library-update-into-copies | 83.083 | 46.453 | 0.56 |
| main-edit-among-many-shapes | 4.837 | 2.175 | 0.45 |
| main-edit-into-10-copies | 1.79 | 0.927 | 0.52 |
| main-edit-into-100-copies | 15.415 | 8.87 | 0.58 |
| main-edit-into-1000-copies | 153.086 | 89.777 | 0.59 |
| variant-switch-into-copies | 32.052 | 20.379 | 0.64 |
AI-assisted-by: claude-opus-5-5
A sync that turns and resizes a copy lays out the copy's main subtree at
the copy's size. That layout climbed to the main's parent: in a grid
whose duplicated child had no cell yet, laying out the grid crashed.
The subtree is laid out under the root, so only its own layouts run and
no layout of the main's parent owns the copy's size.
Benchmark (scripts/bench-components, ms, lower 2.5% quantile):
| world | baseline | now | ratio |
|------------------------------------+----------+---------+-------|
| deepest-edit-through-three-levels | 35.215 | 19.675 | 0.56 |
| edit-through-a-chain-of-dependents | 68.931 | 43.856 | 0.64 |
| library-update-into-copies | 83.083 | 45.859 | 0.55 |
| main-edit-among-many-shapes | 4.837 | 2.118 | 0.44 |
| main-edit-into-10-copies | 1.79 | 1.051 | 0.59 |
| main-edit-into-100-copies | 15.415 | 9.265 | 0.60 |
| main-edit-into-1000-copies | 153.086 | 92.142 | 0.60 |
| variant-switch-into-copies | 32.052 | 21.434 | 0.67 |
AI-assisted-by: claude-opus-5-5