648 Commits

Author SHA1 Message Date
alonso.torres
4b404af324 🐛 Reflow the layouts an update main changes
Pushing a grid copy's column direction to its main left the main's
children in their row order, and pushing a copy's grid cells left the
main's children where they were before, outside the cells they took. A
sync reflows the layouts of the copies it changes, but `update-component`
reflowed none, so the main never laid out again.

It now emits a layout update for the frames its changes touch in the
current file, the main's among them when its component is local, in the
undo group of the update.

Test: frontend generated
`generated-an-update-main-of-a-grid-direction-orders-the-main-by-it`.
The frontend golden master of `case-ak-update-main-pushes-grid-cells` is
recorded again: its main and copy children now sit at their cells, where
they were left stacked outside their boards.

ClojureScript only; the benchmark covers JVM code and is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
57c2cff1e1 🐛 Undo a sync with the change its group was stacked into
Ungrouping a board in a grid main whose copies are ungrouped alike took
two Ctrl+Z to undo: the first only moved the copies' children back. The
layout update after the ungroup stacks onto its history entry with an
undo group of its own, which the entry records among the groups stacked
into it. The component sync that update causes commits later under that
group without stacking, and `append-undo` gave it a new entry when the
matching entry was the latest. Undo walks entries by their own undo
group, so the new entry was undone alone.

Such a commit now joins the entry that holds its group among the stacked
ones. Commits of one group in a row still keep their entries, which undo
walks together.

Tests: `workspace-undo-test/a-delayed-commit-joins-the-entry-its-group-
was-stacked-into` (fails before the fix), `adjacent-commits-of-one-group-
keep-their-entries`, and the frontend generated `generated-an-ungroup-in-
a-grid-main-undoes-in-one-step`.

ClojureScript only; the benchmark covers JVM code and is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
fb271c00e5 📎 Keep the frontend replay's library bookkeeping as the model's
The frontend interpreter recorded three library steps unlike the pure
runner, so three replayed programs differed from the model with no
difference in production:

- A detach leaves a nested copy's child plain when the loaded library no
  longer has its main; the interpreter now records those children, as the
  detach node does, and the oracle reads each as its main's child.
- A duplicate takes the reference inputs of the shapes it copies, so a
  duplicate of a copy back on an older library holds that version.
- A library sync remembers its copies against the synced library as
  loaded and the other libraries as accepted.

The detach node and the interpreter share `n/record-unlinked-children`.
Frontend generated tests replay the three programs.

Harness only; the benchmark is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
5314093548 📎 Replay the programs of a file through the frontend in node
With `PENPOT_REPLAY_PROGRAMS` naming an EDN file of programs, a frontend
generated test replays each of them and logs its own results, which
compares the frontend with the model on many programs without a browser.
Without it the test does nothing.

Harness only; the benchmark is not run.

Also in this commit:

- Give the generated text component a measurable size. The generated worlds'
  text component had a board and a text of a hundredth of a pixel, where turning
  or moving them left the transform to float noise and the checks reported
  differences no design shows. The board is 100 by 100 and the text 100 by 20;
  `add-frame-with-text` sets up its text with the size its child params give.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
06f5abdce3 🐛 Undo a token edit and its propagation in one step
Saving a token from its form committed the edit, then propagated the new
value to the shapes in an undo transaction of its own, opened only once
the tokens resolved. One undo reverted the shapes and left the token with
its new value.

The propagation opens its transaction before the tokens resolve, and the
form commits the edit and the propagation in one transaction, which the
propagation's nests in. The frontend replay commits a token edit as the
form does.

The benchmark covers JVM code; this change is ClojureScript only, so it
is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
8c57e7b3a9 🐛 Lay out the parent of a new bool again
A bool takes the bounds of its result, smaller than those of the shapes
it combines for an intersection, but creating it did not update the
layout it is in, so in a grid board it kept a place the layout does not
give it. It now updates the layout of its parent, as grouping does.

The benchmark covers JVM code; this change is ClojureScript only, so it
is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
d659ab3b9e 🐛 Lay out the parents of an unmasked group again
Unmasking a group gives it the bounds of all its children instead of its
mask's, but the event did not update the layout the group is in, so in a
flex or grid board it kept the place of its old bounds and overlapped its
neighbours. It now updates the layouts of the groups' parents, as group,
mask and ungroup do.

The benchmark covers JVM code; this change is ClojureScript only, so it
is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
468aaea5ca 📎 Compare each key within its shape when naming a difference
`oracle/inequivalence` compared a shape's values on their own, so the
geometry tolerance of `equivalent?` did not apply and float noise was
named as the first difference. Each key is compared within the shape it
belongs to.

Harness only; the benchmark is not run.

Also in this commit:

- Replay layout, structure and grid track edits as the UI does. The frontend
  interpreter set a layout's gap, padding and item alignment and a layout
  child's margin with a plain shape update, where the sidebar goes through the
  layout events that reflow the layout; a copy then kept its children where the
  old gap put them. It dispatches those events now.
- Watch the targets of a replayed program in the browser. With `watch`, the
  browser replay logs the events the store handles and each move of the shapes
  the program's operations target.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
abc64f0243 📎 Log targets and final shapes in both engines of the replay
With `debug`, the browser replay logs each target and the shapes every
program ends with whether the WASM engine is on or off, so a WASM failure
can be compared with the same program on the plain engine.

Harness only; the benchmark is not run.

Also in this commit:

- Apply the generated typography only where the file holds it. A text style edit
  picks the generated typography for one of its values, but only worlds with
  text styles add that typography to the file. In the others the model applied
  the edit's styles while the frontend applied a missing typography, which sets
  no style, so the two diverged. The edit names the typography only when the
  file holds it.
- Replay programs in the browser as the frontend tests do. The browser replay
  mocks the backend and the timers as the frontend generated tests do, turns the
  WASM engine off for the plain engine even when the page's configuration turns
  it on, and in debug logs the content a text edit commits and each text's
  characters and font weights.
- Name the boards a deleted component's main was held by. The canonical design
  data names shapes and components by their place in the tree, so the model and
  the frontend compare although each allocates its own ids. A deleted component
  keeps the ids of the board that held its main, as a variant's component keeps
  its container's once the variant is undone; with that board gone the ids
  stayed raw and differed between the two runs. They are named after the
  component when no live shape is.
- Report where the model and the frontend first differ. A backend mismatch in
  the frontend replay printed the whole diff of the two canonical designs, which
  lists float noise the comparison accepts next to the difference it rejects.
  `oracle/inequivalence` walks the two designs as `equivalent?` compares them
  and returns the path of the first rejected value with both sides; the mismatch
  message leads with it.
- Keep text sizes and take inline programs in the browser replay. With the WASM
  engine on, the replay keeps each text's stored size in place of the engine's
  text resizes: the model keeps stored sizes, and the generated texts are too
  narrow to measure, so a new copy's measured text differed from its main's
  unmeasured one. The page also takes the programs inline in an `edn` query
  parameter, which a shrink loop drives.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
ac31d67366 🐛 Sync copies when a copy nested in a main is moved
The component watcher drops a translation commit that moves only shapes
outside mains or whole mains. It found the main of each moved shape with
`get-component-shape`, which stops at the nearest copy head, so a copy
placed in a main, or a shape inside one, looked like a shape outside any
main: moving it with the WASM engine on, whose drags commit as
translations, left the main's copies where they were.

The watcher now walks up through nested copies to the main instance the
shape lies in.

The benchmark covers JVM code; this change is ClojureScript only, so it
is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
700245059b 📎 Resume, debug and compare the browser replay of programs
The replay page takes a `start` index to resume a long run, an `engine`
of `plain` to replay the same programs with the WASM engine off, and a
`debug` flag that logs each target, each WASM layout with its result and
the shapes of a failing program.

Harness only; the benchmark is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
1c339ddcca 🐛 Send the WASM engine the paddings and margins the layout uses
A `:simple` padding or margin type repeats the top and right values on
the bottom and left, as `ctl/paddings` and `ctl/child-margins` read them,
but the WASM engine received the four stored values. A board whose type
was switched to simple after editing its sides laid out its children with
the stale bottom and left values in the WASM engine only, so moving one
child shifted all of them and marked copies as touched.

Both the shape payload and the per-attribute calls now send the values
the layout functions return.

The benchmark covers JVM code; this change is ClojureScript only, so it
is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
5d84e9a449 ✨ Replay generated programs in the browser with the WASM engine
The frontend replay of generated component programs runs in node, where
the WASM render engine is not available. A `test-wasm` build runs the same
replay in a browser page: it loads the engine on a canvas, turns on
render-wasm/v1 and loads the shapes of the replayed page into the engine
whenever they change, so every layout goes through it. Text edits commit
through the SVG editor, as the WASM editor needs its own editing session.
The page reads the programs the common tests pin, which a script writes
out, and reports each one to the console.

Build with `pnpm run build:test-wasm`, then open
`/test-wasm.html?programs=programs.js`.

Test tooling only; the benchmark is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
bca17d5dac ✨ Generate moves, renames and annotations of components
Three kinds join the structure programs, and the programs built on them:

- move: a shape a main holds, or a nested copy head, moves to the page,
  into a board or group of its own main or of another. The model gives
  an override of its constraints the defaults of its new parent, as the
  move resets them.
- rename: the assets panel's rename, with names that carry a path. The
  component must take the normalized path and name, and its main root
  the whole name.
- annotate: a component's annotation is set or removed. Only that edit,
  or its undo or redo, may change an annotation.

The frontend interpreter realises the rename and the annotation through
their workspace events.

Harness only; the benchmark is not run.

Also in this commit:

- Ignore the layout-given size of a hidden layout child in the oracle. A hidden
  shape leaves its layout's flow, so it keeps the size the layout last gave it
  along its fill or auto axes, while a sync from its main can give it the
  main's. The layout gives it its size again once it is shown. The oracle
  expected the main's size, and the design snapshots of a settled and a fully
  synced world differed by it. Those sizes are now nobody's to keep, as the
  place of a hidden layout child already is.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:49 +01:00
alonso.torres
65f548e437 ♻️ Reindent the harness undo check and transform op
Whitespace only, as the formatter wants it after the last changes to
same-state? and the transform op of the generator.

Harness only; the benchmark is not run.

Also in this commit:

- Record the frontend golden master of case AY again. The undo and redo checks
  compare the tokens library by its exported content, so the golden master
  writes it key by key; the JVM golden master of case AY was recorded again for
  that, and the frontend one is now too. Same values, written differently.
- The harness changes that check the next commit, "Grow a track for a grid
  copy's new child and keep it at sync".

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:48 +01:00
alonso.torres
47603c4aa9 ✨ Transform shapes in the groups and bools of copies
The random histories never transformed a copy shape inside a group or a
bool. They now do, where the board around the group has no layout.
Inside a layout, a move of a group's shape makes the layout move the
group back, and its siblings with it, with nothing authored; that stays
out until it is decided.

The oracle learns:
- the shapes of a group or bool take their place from the board around
  it, or from the nearest group or bool on the way that authors its
  geometry;
- the geometry check leaves groups and bools out, as their bounds come
  from their children, which it checks.

The frontend replay realises the token value edit as the token form
commits it, with its propagation.

Test: the-shapes-of-a-moved-copy-group-follow-it; shape structure
programs pass (seeds 8101 at 150, 8102 at 300).

Harness only; the benchmark is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:48 +01:00
alonso.torres
a9357626ac ♻️ Move the group, mask and bool actions to common
The changes of grouping, ungrouping, masking, unmasking and creating
bools were built in the workspace events, which the JVM tests and the
component gates cannot run. They move to app.common.logic.groups and
app.common.logic.bool with the same behavior: the events keep their
selection and stream handling and call the common builders, and the
other callers of shapes-for-grouping and prepare-create-group use the
common namespace.

Tests: groups-test (grouping, ungrouping, copy heads left whole, mask and
unmask, bools without boards). Frontend suite: 2080 tests, 2 failures,
both the intermittent persistence-rollback-test timeout.

Benchmark (scripts/bench-components, ms, lower 2.5% quantile), measured
with the other production changes of this series in the tree; none of
them is on a measured path:
|                             :world | :baseline |    :now |   :mean | :ratio |
|------------------------------------+-----------+---------+---------+--------|
|  deepest-edit-through-three-levels |    35.215 |  22.167 |  22.682 |   0.63 |
| edit-through-a-chain-of-dependents |    68.931 |  43.218 |  44.696 |   0.63 |
|         library-update-into-copies |    83.083 |  47.824 |  50.506 |   0.58 |
|        main-edit-among-many-shapes |     4.837 |   2.216 |    2.34 |   0.46 |
|           main-edit-into-10-copies |      1.79 |   1.067 |   1.133 |    0.6 |
|          main-edit-into-100-copies |    15.415 |  10.604 |  10.813 |   0.69 |
|         main-edit-into-1000-copies |   153.086 | 106.085 | 108.631 |   0.69 |
|         variant-switch-into-copies |    32.052 |  22.556 |  23.137 |    0.7 |

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:48 +01:00
alonso.torres
a871ea42a0 ✨ Generate component histories in deeper and wider worlds
The random histories ran in worlds of two or three components nested at
most two levels, each with two copies, where ordering and propagation
bugs that need deeper nesting or many copies of one main cannot show.
The scale programs build three or four components nested three or four
levels, with three to six copies of each, a larger shape budget, and
every variant operation. A world takes its number of copies per main
(two by default). Scale programs run several times longer than the
others, so the suite draws twelve; the gates draw more.

Test: random-scale-compositions.
Common suite: 2444 tests, 0 failures.

Harness only; the benchmark is not run.

Also in this commit:

- Model a head size as authored only when a sync resizes its copy. The model
  took any resized copy parent of an untouched swapped head as a sync resize and
  expected the head to author the size it was given. A user resize of a nested
  copy authors that copy's geometry and scales a swapped head under it through
  constraints, which production leaves untouched. The model now finds the
  topmost ancestor the step resized and authors the head's size only when that
  ancestor is a copy shape without authored geometry, the only shape a sync
  resizes.
- Keep the layout item overrides of a swapped head in the model. A swap restores
  the swap-keep-attrs of the old head on the new one with the touched groups
  they belong to, on every swap. The model kept the old head's layout item
  groups only on a variant switch, so after a plain swap of a head that authors
  a margin it expected the new head without that override. It now keeps them on
  every swap.
- Align the arguments of the combine test fixtures. The same-name combine
  fixtures in the variant workspace tests call their helper through the `ctho`
  alias, one character longer than develop's `tho`, so their continuation lines
  sat one column left of the first argument and the frontend format check
  failed.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:48 +01:00
alonso.torres
488ee13f08 📎 Use this branch's compositions alias in develop's combine tests
The same-name combine tests that develop added build their file with the
`tho` alias, which this branch's variant workspace tests name `ctho`, so
the frontend test run stopped with a ReferenceError there.

Harness only; the benchmark is not run.

Also in this commit:

- Re-record the combine golden master for unique variant values. Combining two
  components whose names leave no value gives the second variant "Value 2" where
  it had an empty value, since develop's fix for same-name combines (#12881).
  Case au records that combine, so its two variants are recorded again on
  purpose; no other case changes.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:47 +01:00
alonso.torres
e1decc4812 ✨ Generate variant sets made from components and library set edits
The variant programs now also make sets: transform a component into a
variant set (kind make-variant) and combine two components as variants
(kind combine), each paired with a switch. The pure runner runs both
actions through their common generators with what the frontend events
do after them: the reflow of the new board's layout, and a combined
board sized 30 px past its mains on each side. Each must leave the
components it names as members of one new set in the board, with the
same property names; a transform adds a member with a value of its own.

The library editor of the stale library programs edits its variant sets
too: property edits, added variants, transforms and combines, followed
by a library sync and a switch in the consuming file. Their requested
results are checked on the library, and an added member takes on the
model of the main it duplicates. The test of undoing a library variant
a consumer switched to belongs to the previous commit's fix.

The stale library programs must cover only the library steps and the
operations they are tested with, as the variant programs do; the
structure and swap programs cover the rest. A frontend step also waits
briefly for an undo transaction its events close on a later tick, as
combining variants does, and the golden master transcripts record the
components a variant action makes.

Harness only; the benchmark is not run.

AI-assisted-by: claude-opus-5-5
2026-11-18 10:29:46 +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
05c08b9e9a 🐛 Read a missing grid direction as row everywhere
A grid without a direction assigned children column-first and grew rows,
while grid creation, the direction event, the WASM renderer and CSS export
read it as a row grid. The library file builder decodes the direction as
optional, so imported files can lack it. Picking "column" on such a grid
then swapped auto-placed children.

Add grid-direction, which defaults to row, and use it for cell order, track
growth, track fitting and the direction event. The generated oracle predicts
the same flow order.

The builder regressions fail three of six assertions before the fix; the
real-event component regression fails six of 293, with main and copies
grown to 3x2 instead of 2x3. Both pass unchanged after the fix, including
exact undo and redo. The fitting flow-order control's missing-direction case
now expects row order.

Full frontend passes 1798 tests / 15737 assertions; common JVM passes
2052 / 33613. Backend passes 1838 / 9293; exporter passes 16 / 40. Lint
and formatting pass for common, backend and exporter; frontend lint and
changed-file formatting pass. Common JavaScript fails only in two random-seed
component properties. Both shrunk programs fail the same way without this
change and are fixed separately.

Compare lower-quantile milliseconds with the saved baseline; keep that
baseline unchanged. The machine/JVM warning makes ratios rough. No world
is flagged.

World                      Baseline       Now    Ratio
Main into 10 copies           1.790     0.961     0.54
Main into 100 copies         15.415     8.816     0.57
Main into 1000 copies       153.086    94.309     0.62
Three nesting levels         35.215    19.435     0.55
Dependency chain             68.931    37.850     0.55
Library update               83.083    45.747     0.55
Many plain shapes             4.837     2.153     0.45
Variant switch               32.052    20.254     0.63

AI-assisted-by: claude-opus-5-5
2026-11-10 20:21:42 +01:00
alonso.torres
93df1d680a 🐛 Fit overridden grid cells when inherited tracks shrink
Removing a main grid track left overridden copy cells beyond their inherited
track lists. Follow the main's untouched track count, move or shorten
affected cells, and retain cell identity, alignment and other metadata.
Explicit copy track overrides keep their own lists.
Record the agreed ownership rule in the component sync contract.

Fit occupied cells before empty defaults, preserve placements that fit and
retain empty authored areas when space remains. Resolve collisions without
overlap. If no distinct slot remains, combine children in the retained cell
using its properties and a manual position so assignment keeps every child.
Reconcile before assignment, then fit overflow back into inherited tracks.
Keep the existing minimum track rule for participating children and leave
the normal non-shrinking path in place.

The portable regression fails eight of 60 assertions before the fix; the
real-event frontend regression fails one of 18. Both pass unchanged after
the fix, including exact undo and redo. Additional controls cover spans,
explicit track overrides, collisions, empty areas/grids, repeated sync and
existing row/column/absent-direction ordering. Goldens are unchanged.

Browser data checks pass 32 assertions across maps, records and actual
ShapeProxy values with WASM initialized. They preserve app state and check
data/proxy behavior, not pointer events or visual rendering.

Full frontend passes 1797 tests / 15707 assertions; common JVM passes
2050 / 33660. Backend passes 1838 / 9293; exporter passes 16 / 40. Consumer
lint and formatting pass. All targeted layout/sync checks pass, including
the final 99-test / 725-assertion flow-order run.

Full common JavaScript passes 1986 tests / 32311 assertions. Common lint
and formatting pass. All six component properties pass 40 programs each
at seed 712 in both runtimes. No fresh 5000-program gate ran.

Frontend lint and changed-file format pass. Full frontend format retains
two existing alignment errors in the unchanged plugin library test.

The isolated component benchmark passes all eight worlds with no regression
flags. Compare lower-quantile milliseconds with the saved baseline; keep
that baseline unchanged. The machine/JVM warning makes ratios rough.

World                      Baseline       Now    Ratio
Main into 10 copies           1.790     0.919     0.51
Main into 100 copies         15.415     9.640     0.63
Main into 1000 copies       153.086    97.121     0.63
Three nesting levels        35.215    19.225     0.55
Dependency chain            68.931    36.700     0.53
Library update              83.083    44.976     0.54
Many plain shapes            4.837     3.433     0.71
Variant switch              32.052    20.612     0.64

AI-assisted-by: gpt-6
2026-11-10 20:21:42 +01:00
alonso.torres
31f9350d08 🐛 Keep grid cell overrides within newly inherited tracks
Create default cells in newly inherited grid tracks before assigning
added copy children. A cell override previously made sync append an extra
track; a later full sync shrank the tracks beneath the retained cells.
Keep existing authored cells and skip positions covered by existing spans.

Add common and real frontend row/column growth histories, including an
opposite copy direction, retained overrides, exact undo/redo and stable
full sync. The original common test failed 12 of 100 assertions and the
frontend test failed 4 of 100. Keep those assertions and add checks that
each child has exactly one cell.

Sync benchmark lower quantiles (ms), baseline -> now (ratio):
  deepest three levels:      35.215 -> 18.770 (0.53)
  chain of dependents:       68.931 -> 37.764 (0.55)
  library update:            83.083 -> 49.418 (0.59)
  main among many shapes:     4.837 ->  3.008 (0.62)
  main into 10 copies:        1.790 ->  0.968 (0.54)
  main into 100 copies:      15.415 ->  9.474 (0.61)
  main into 1000 copies:    153.086 -> 97.063 (0.63)
  variant switch:            32.052 -> 22.157 (0.69)
All worlds pass the recorded 10% regression limit. The baseline used
another machine/JVM, so ratios are rough comparisons.

Validation: common JVM 2,016 tests / 33,356 assertions; common JS
1,952 / 32,015; frontend 1,752 / 14,088; backend 1,793 / 9,007;
exporter 16 / 40. Six properties pass 40 programs at seed 712 in
both common runtimes. Lint and format checks pass for all four modules.
Golden-master data is unchanged.

AI-assisted-by: gpt-6
2026-11-10 20:21:42 +01:00
alonso.torres
d883a68d65 🐛 Keep layout child grid assignment derived
Changing a grid copy child to absolute touched its parent's grid cells
and blocked later main cell updates. Separate parent sizing writes from
derived grid assignment in the same undo transaction. Skip generic grid
reassignment until the derived write, so it cannot touch the parent first.

Add a real-event regression for clean parent cells, later main-cell
propagation and exact undo/redo. It fails two of sixteen assertions before
the fix and passes afterward. A live WASM check passes 27 checks, including
exact page-object snapshots through undo and redo for both edits.

Validate the final continuation on common JVM (2004 tests / 32919
assertions), common JS (1940 / 31522), frontend (1745 / 13569), backend
(1793 / 9007) and exporter (16 / 40). All four modules pass lint and format.
All six generated properties pass 40 programs at seed 712 in both runtimes.
Golden data is unchanged.

The final continuation benchmark passes with no regression flags. Lower
quantile ratios against Phase 1e: main 10/100/1000 0.51/0.58/0.57, three
levels 0.57, chain 0.53, library 0.57, many shapes 0.45, variant switch 0.66.
Machine/JVM differences make these rough comparisons; baseline unchanged.

AI-assisted-by: gpt-6
2026-11-10 20:21:42 +01:00
alonso.torres
4719ababe8 📎 Restore merged imports and multipart test setup
Keep the string helper required by the variant rename predicate after
removing the old swap-slot helpers. Sort the merged test imports.

Send import-audit fixtures through the existing multipart RPC helper so
they exercise auditing through the required upload path. Start the edit
watcher in the isolated component test so it forwards recorded transitions.

AI-assisted-by: GPT-6
2026-11-10 20:21:42 +01:00
alonso.torres
6f7d32d0ae 🐛 Keep flex deletion and reflow in one undo group
Use the deletion's undo group for its delayed layout update, reusing an
enclosing transaction when present. Store that group on the primary
changes so deleting a child and moving its siblings undo together.

Add real-event regressions for standalone deletion, an explicit group and
an outer transaction. Verify exact snapshots after one undo and redo.

AI-assisted-by: GPT-6
2026-11-10 20:21:41 +01:00
alonso.torres
a4eea62bdc 🐛 Take nested swap constraints from their position source
Settle a nested swap's untouched constraint group from the replaced
position, including fixed-scroll. Carry compatible switch overrides first
so an inherited position cannot discard an authored constraint override.

Cover F224's reduced history in common and the async frontend, both
constraint axes, absent position fields, compatible carry and exact undo.
The complete original history and browser ShapeProxy replay also pass.

Validation: focused swap/variant/golden tests (123 tests, 1,764 assertions),
full common JVM/JS, frontend, backend and exporter suites; lint and format.
Golden data is unchanged.

Benchmark ratios against the unchanged baseline, with no regression flags:
mains 10/100/1,000: 0.53/0.58/0.63; three levels: 0.56; chain: 0.55;
library: 0.56; many shapes: 0.48; variant switch: 0.65.
The baseline uses another machine/JVM, so ratios are rough comparisons.

AI-assisted-by: GPT-6
2026-11-10 20:21:41 +01:00
alonso.torres
c7e8ff8d47 📎 Restore migration and test compatibility after rebase
Keep the container root helper used by the main-instance name migration.
Adapt imported-file ids and component swap tests to the current APIs, and
check copied swaps through their position refs and swap groups.

AI-assisted-by: gpt-6
2026-11-10 20:21:41 +01:00
alonso.torres
a88f53874d 🐛 Keep pending library edits out of transform settlement
Use the component sync result only as a geometry proposal when settling
reflections and swapped placement. Correct existing shapes without pulling
pending library content, styles or structure into a transformed copy.
Keep path geometry and the primary action's exact undo/redo group.

Generate source transforms, letters and all twelve text style units with
separate source histories and explicit consumer acceptance. Add dropped
source-edit controls and portable/frontend regressions for the accidental
pull. Register the new portable namespace in the JavaScript runner.
The complete original program and both reductions pass unchanged.

Common JVM passes 1,919 tests/31,313 assertions. Full JS passes
1,845/29,770; the newly registered source namespace adds 5/135 passing
checks. Frontend passes 1,566/11,119, backend 1,610/8,104 and exporter
14/32. Lint and formatting pass; browser ShapeProxy replay passes.
No golden data changes.

Benchmark ratios against the unchanged baseline: mains 10/100/1000
0.57/0.65/0.61, levels 0.52, chain 0.51, library 0.52, many shapes 0.47,
variant switch 0.60. No regression flag.

AI-assisted-by: gpt-6
2026-11-10 20:21:41 +01:00
alonso.torres
f54d1a288e 🐛 Skip numerically equal component sync writes
Compare integer and floating forms exactly for scalar values, points and
selection rectangles. A library update that only changes their numeric
representation must not create changes or an undo entry. Preserve every
nonzero difference, including real subpixel moves.

Add the reduced resize/library-sync regression and a subpixel control,
plus async frontend undo/redo replay. Review and update eight golden
states in case N: only equal integer/float representations changed.
The recreated seed-712 audit leaves all 61 syncs and undo depths unchanged.

Common JVM 1,914 tests/31,146 assertions and JS 1,845/29,810 pass.
Frontend 1,563/10,880, its added replay, backend 1,610/8,104 and exporter
14/32 pass. Lint and formatting pass. Exporter needs its test-only secret.

Benchmark ratios against the unchanged baseline: mains 10/100/1000
0.54/0.61/0.61, levels 0.53, chain 0.55, library 0.55, many shapes 0.62,
variant switch 0.65. No regression flag.

AI-assisted-by: gpt-6
2026-11-10 20:21:41 +01:00
alonso.torres
e5dc24ed83 🐛 Keep delayed copy measurements with their undo group
Route non-stacked derived commits to their applied group when a later
edit or transaction intervenes. Copy remeasurement must undo with the
font action rather than becoming a separate step after an unrelated edit.
Keep adjacent non-stacked entries and exclude the redo tail from routing.

Extend the font-boundary regression to component mains and copies, and
cover both stacking modes during a later transaction. The regression
fails before the fix; all 1,563 frontend tests and 10,880 assertions pass.
Live WASM history passes exact undo/redo and full-sync consistency.

The sync core is unchanged by this undo fix. Its preceding benchmark
ratios remain 0.48-0.76 of the unchanged baseline, with no regression flag.

AI-assisted-by: gpt-6
2026-11-10 20:21:41 +01:00
alonso.torres
503330d178 🐛 Keep delayed font resizes in their undo group
Stack a delayed derived change into its applied undo group when that
group exists, instead of an unrelated later entry or transaction.
Preserve an older entry's selection and exclude the redo tail.

The delayed-font regression fails before the fix and passes afterward.
Async transaction controls pass 18 assertions; the completion suite
passes 17 tests / 646 assertions. Full frontend passes 1,563 tests /
10,860 assertions, including unchanged goldens. Lint and formatting pass.
A standalone-text WASM history passes 9 checks, with exact undo/redo,
full-sync consistency, the original page restored and no pending work.

Benchmark ratios against the unchanged Phase 1e baseline:
main 10/100/1,000 copies 0.62/0.59/0.62; three levels 0.68;
dependency chain 0.54; library update 0.54; many shapes 0.48;
variant switch 0.76. All worlds pass without regression flags.

The separate late copy-measurement path remains tracked as F222.

AI-assisted-by: gpt-6
2026-11-10 20:21:41 +01:00
alonso.torres
48a627e042 🚧 Save component stabilization follow-up
Expand generated component coverage with independent library histories,
meaningful mutation counts, varied geometry and variants, all text style
units, oracle corruption controls and pending-sync frontend replays.

Fix reflected descendants, partial size carry, WASM shape defaults,
deferred swap and sidebar text undo, grid visibility, explicit typography
ownership, metadata filtering and swapped placement through sync/detach.

Recorded validation after F219:
- Common JVM: 1,909 tests / 31,088 assertions; JS: 1,840 / 29,688.
- Frontend: 1,560 tests / 10,821 assertions.
- Backend: 1,610 tests / 8,104 assertions; exporter: 14 / 32.
- Applicable lint and formatting pass; golden data stays unchanged.

Benchmark ratios against the unchanged Phase 1e baseline:
- Main edits into 10/100/1,000 copies: 0.52/0.57/0.58.
- Three levels: 0.51; dependency chain: 0.52; library update: 0.58.
- Many shapes: 0.42; variant switch: 0.62. No regression flags.

This is a checkpoint. The fresh legacy-library gate at seed 712 fails
at program 351 (F221); its cause remains unclassified. The other four
large gates did not run. F220, F187, F214 and wider coverage remain open.

AI-assisted-by: gpt-6
2026-11-10 20:21:33 +01:00
alonso.torres
2b50fda318 ✨ Generate component programs across library files
Build a shared library world and route edits, updates and settlement across
working and library files. Check the independent override model, geometry,
propagation and exact undo for both files. Replay shrunk library failures
through the async frontend with the same target choices and barriers.

Keep common generation/shrinking and CLJS replay as the main regression
suite. Use the plugin for public API, WASM and measured-text smoke checks;
retain its existing fixed cases until equivalent coverage replaces them.

All four properties pass 5000 programs each with seed712, each in a full
run. Fresh swaps: 5009 assertions; library: 5008. Isolated Stage3: 55/379.
Live WASM, fonts, undo/redo and later propagation checks pass.
Full frontend: 1539 tests, 9312 assertions, including 39 generated replays.
Common JVM: 1851 tests, 30684 assertions; JS: 1782 tests, 29308 assertions.
Backend: 1610 tests, 8104 assertions; exporter: 14 tests, 32 assertions.
Plugin: 68 cases. Lint, formatting and unchanged goldens pass.

AI-assisted-by: GPT-6
2026-11-10 20:21:33 +01:00
alonso.torres
88dd41f065 🐛 Record user undo changes before starting derived component sync
Hand applied transitions to the component watcher only after the workspace
records their undo entry. Keep the handoff synchronous with the captured
prior file data. This preserves transaction order when nesting triggers
several component syncs. Fix F137.

The minimal replay failed both undo and redo before the fix; its 4 checks
now pass. Existing sync scenarios pass their behavior and undo checks;
60 golden digests need review for the accumulated Phase 4 fixes.
Common benchmark ratios against Phase 1e: main 10/100/1000
0.46/0.52/0.53; levels 0.47; chain 0.51; library 0.51; many 0.49;
switch 0.61. This handoff changes no common benchmark code.

AI-assisted-by: GPT-6
2026-11-10 20:21:33 +01:00
alonso.torres
a25afbe2d6 🚧 Save Phase 4 random harness and grid fixes in progress
Save Stage 2 structure, text, geometry and layout generation, independent
oracle checks, frontend seeded replay and plugin visible-value checks.
Include pending grid sync and deletion fixes with focused regressions.

WIP validation: component sync 21 tests / 106 assertions; move shapes
6 tests / 33 assertions. Earlier plugin checks passed 68 full cases,
11 unit tests and types. The final generated replay, golden check,
5000-case gate, full suites and live WASM check remain unfinished.
Stages 3 (swaps/variants) and 4 (library files) have not started.

F124 benchmark ratios against Phase 1e: main 10/100/1000 copies
0.48/0.52/0.54; three levels 0.53; chain 0.56; library 0.52;
many shapes 0.42; variant switch 0.64. No regression flag.
The F125 deletion change still needs its final benchmark.

Save the detailed resume checklist and logs in the local stabilization
plan. Keep that workflow document out of the commit.

AI-assisted-by: GPT-6
2026-11-10 20:21:17 +01:00
alonso.torres
a76888cb5d 🐛 Cancel WASM thumbnails when leaving the workspace
Cancel the full thumbnail upload/render stream on page or workspace
teardown and on matching thumbnail clearing. Deferred library thumbnails
can otherwise query a main missing from the next WASM scene and abort
the renderer (F112).

Complete the upload observable after its callback so successful requests
also release their subscriptions.

Add async regressions for pending current and library frames, late upload
callbacks, clearing, and successful rendering. They fail before the fix.
Document the thumbnail lifecycle in the frontend memory.

Frontend CI passes lint, 1499 tests / 7272 assertions, and formatting.
Live WASM update-main followed by navigation no longer crashes; an
uninterrupted library request refreshes its PNG thumbnail too.

AI-assisted-by: GPT-6
2026-11-10 20:21:17 +01:00
alonso.torres
d077a5ec8e 🐛 Preserve file destinations through undo and redo
Keep a namespaced file destination on each history change. Replay changes
in order in their target files, including stacked entries and transactions.
Keep payload fields named file-id intact, such as set-tokens-source (F111).

Snapshot the current file and every library in both composable runners.
Name the file in failure signatures; normalize the server synced-at status
stamp alongside modified-at. Update golden cases H and AP for this exclusion.
The library update regression checks both files through undo and redo and
failed against the old code.

Common JVM: 1705 tests; JS: 1633; frontend: 1495; backend: 1610; exporter: 14.
All pass, with lint and formatting checks for both changed modules.

Benchmark vs Phase 1e (lower quantile, ms):
world                 baseline     now   ratio
main-10                  1.790   0.993    0.55
main-100                15.415   9.038    0.59
main-1000              153.086  90.145    0.59
three-levels            35.215  18.989    0.54
chain                   68.931  35.045    0.51
library-500             83.083  85.830    1.03
many-shapes              4.837   3.344    0.69
variant-100             32.052  33.586    1.05
All worlds pass the 10% regression threshold.

AI-assisted-by: GPT-6
2026-11-10 20:21:16 +01:00
alonso.torres
5b4049b5da 🐛 Keep component sync with each user state transition
Emit changes-applied with the commit's prior file data. Sync each commit
before a later edit can replace its state or separate its undo group.
Allow later commits through while completion barriers finish (F110).

Process layout batches after their buffer closes, so reentrant component
sync cannot lose a pending layout task. Cover three user edits without an
intermediate wait, then every undo and redo. Token and tiny-layout cases
also pass. Re-record golden cases X and AJ for the settled timing.

Frontend: 1495 tests, 7255 assertions pass; lint and format checks pass.
The three-edit regression failed before the fix.

Benchmark vs Phase 1e (lower quantile, ms):
world                 baseline     now   ratio
main-10                  1.790   0.993    0.55
main-100                15.415   9.038    0.59
main-1000              153.086  90.145    0.59
three-levels            35.215  18.989    0.54
chain                   68.931  35.045    0.51
library-500             83.083  85.830    1.03
many-shapes              4.837   3.344    0.69
variant-100             32.052  33.586    1.05
All worlds pass the 10% regression threshold.

AI-assisted-by: GPT-6
2026-11-10 20:21:16 +01:00
alonso.torres
4ad93f1033 🐛 Keep a committed property name from being sent again
When the variant property panel went away (selecting another layer),
input-with-meta* sent a blur from the last input it had rendered, to
commit an edit still open. After an edit was already committed that
input is gone and keeps the text it had: reordering the properties
and then selecting a variant renamed the property now in that row
after the old one, "Property 1" becoming "Property 2 (1)"
(PENPOT-2588). The input is forgotten once its edit is committed, so
the blur is sent only for an edit still open.

ds-input-with-meta-test mounts the component in a jsdom document: a
committed edit is not sent again when the value changes and the input
goes away; an edit still open is committed.

AI-assisted-by: claude-opus-5-5
2026-11-10 20:21:16 +01:00
alonso.torres
a059a32d5a 📎 Count only the plugin calls in the plugin registry tests
The registry tests mock the RPC and check every call recorded while the
mock is installed. A component sync deletes the thumbnails of the
frames it changes 200 ms later, so a sync at the end of an earlier test
of the suite can call the mock in that window: under the coverage run,
the frontend suite failed in register-test, a different test each time,
with an extra :delete-file-object-thumbnails call. The mock now records
and answers only the plugin profile commands; any other call gets an
empty answer.

Also in this commit:

- Update the component memories for the audit and fix phase. The contract memory
  says how the code now holds it: the eager cascade and where it lives, the
  automatic text name, the children of a transformed copy shape, measured text
  sizes on both renderers, repairs as derived writes, the tolerance of "differs"
  and the :set-touched operation. The debugging recipes add the override
  scanner; the data model and the composable test notes follow the changes.

AI-assisted-by: claude-opus-5-5
2026-11-10 20:21:16 +01:00
alonso.torres
ed29bb4289 ♻️ Write the touched groups with the :set-touched operation
Two operations set the touched groups of a shape: a :set of :touched,
which assigns the value as given, and :set-touched, which keeps them
only on a copy and drops an empty set. update-shapes and the undo of
add-component wrote the first while their own undo and sync wrote the
second. The contract prefers :set-touched; both builders now write it,
and an update with only its touched groups changed still records their
undo. A :set of :touched is still applied, for changes already stored.

Case AE leaves no empty touched set on the shape a detach turned plain;
both golden masters record the state again for it.

comp-touched-test: an update that sets the touched groups of a copy
shape writes one :set-touched operation, and its undo restores them.

Benchmark (lower quantile, ms; baseline / now / ratio):
  deepest-edit-through-three-levels    35.2 /  16.6 / 0.47
  edit-through-a-chain-of-dependents   68.9 /  32.8 / 0.48
  library-update-into-copies           83.1 /  42.8 / 0.51
  main-edit-among-many-shapes           4.8 /   2.3 / 0.48
  main-edit-into-10-copies              1.8 /   1.0 / 0.54
  main-edit-into-100-copies            15.4 /   8.9 / 0.58
  main-edit-into-1000-copies          153.1 /  82.0 / 0.54
  variant-switch-into-copies           32.1 /  17.7 / 0.55

AI-assisted-by: claude-opus-5-5
2026-11-10 20:21:16 +01:00
alonso.torres
45776a119f ✨ Sync the components a sync changes in the same commit
Decision (c) of the component contract, after a fix that made the sync of a
library file reach that file at all (Phase 3c).

- Commit the sync of a library file to that file.

  An update of the main of a library component, made from a copy in the
  file, syncs the copies of the component in the file and in the library.
  The changes of a sync carry no file id, so the commit took the current
  file's: the library's copies, among them those its other mains nest, were
  written to pages the current file does not have, and never changed (F19).
  A sync now commits to the file it syncs.

  workspace-remote-cascade-test: an update of the main of a library
  component reaches the copy of it that another library main nests.

- Sync the components a sync changes in the same commit.

  Decision (c) of the component contract: a sync reaches the copies of the
  components it changes, until none is left, in one commit. A sync of a file
  changed the mains of the components that nest the synced copies, and the
  component watcher synced those in a commit of its own, one level per pass,
  so the file stayed partly synced in between; the watcher only watches the
  current file, so a sync of a library file stopped at its first level
  (F19).

  common: generate-sync-file-cascade syncs a file as
  generate-sync-file-changes does, then the copies of each component of the
  file that the sync changed, one per pass, applying each pass to the file
  data, until none is left (generate-sync-components-cascade). The
  composable runner, the benchmark and the golden master use it.

  frontend: sync-file commits the whole cascade at once. When it syncs a
  library file, it then syncs the copies in the current file of the library
  components the cascade changed.

  workspace-remote-cascade-test: an update of the main of a library
  component, made from a copy in the file, reaches the file's copy of a
  library component whose main nests it. The common golden master records
  fewer changes undone in case W: a cascade is one change set.

Benchmark (lower quantile, ms; baseline / now / ratio):
  deepest-edit-through-three-levels    35.2 /  17.0 / 0.48
  edit-through-a-chain-of-dependents   68.9 /  33.2 / 0.48
  library-update-into-copies           83.1 /  43.6 / 0.52
  main-edit-among-many-shapes           4.8 /   3.5 / 0.73
  main-edit-into-10-copies              1.8 /   0.9 / 0.49
  main-edit-into-100-copies            15.4 /   8.1 / 0.52
  main-edit-into-1000-copies          153.1 /  83.9 / 0.55
  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
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
alonso.torres
070fcd44a4 🐛 Keep text names and measured sizes derived
The name a text takes from its content and the size it is measured to are
derived: they never touch a copy (decisions (d) and (g), Phase 3c).

- Let a copy text's automatic name follow its own letters.

  The editors name a text after its letters on every edit. In a copy that
  rename went through the same write as the content, so it touched
  :name-group (F27), against decision (d) of the component contract: only an
  explicit rename is an override.

  - update-shapes takes :ignore-touched as a set of attributes too, and the
    editors' commits (v1 and v3, finalize and keystrokes) and the replace of
    text pass #{:name}: the name follows the content, so its write is
    derived. Token unapply still runs for such an update.
  - Sync gives an untouched copy text the name generated from the letters it
    shows after the sync when its main's name is the one generated from the
    main's letters (decision (d), refined), and the main's name otherwise.
    So a copy that retyped its text keeps that name, and one that did not
    follows the main's.

  The pure runner's text edit makes the same commit. Case Y no longer pins
  F27 and checks the copy's name follows its letters; both golden masters
  record the copy without :name-group.

  text-sync-test: an untouched copy takes the main's letters and name, a
  copy that typed its letters keeps the name they give, and a main named by
  hand passes its name on.

- Name a text with several paragraphs without line breaks.

  The editors name a text after its letters, with the line breaks of its
  paragraphs included, so a text "Hello world" + Enter + "Ends Sunday" was
  named "Hello world\nEnds Sunday"; the layers panel showed a space there
  (F82). generate-shape-name now turns each line break, with the spaces
  around it, into one space.

  text-test: the name of a two-paragraph text joins them with a space.

- Keep the size a WASM text grows to from touching the copy.

  A text that grows with its content (auto width, auto height) gets its size
  from the WASM renderer after a font loads, a style changes, a paste or an
  edit ends. That size is derived from the content, yet the resize applied
  it as a user change, so a copy's text took :geometry-group each time and
  kept that size against its main (F1). The resize and the debounced resize,
  the size an edit ends with and its geometry undo now pass ignore-touched.

  These paths measure the text in WASM, so no headless test reaches them.
  Checked in the browser with the WASM renderer: an edit of a copy's text
  touches :content-group only, and a resize after a font size change of 24
  grows the text with no :geometry-group.

- Keep the finalize resize of a text out of the undo stack.

  When an edit of an existing text ends, the WASM renderer gives the size it
  grows to, and the finalize commit stores that size along with its undo.
  The resize that shows it on the canvas recorded an undo of its own with no
  undo group: a release build kept a second undo entry for one edit, and a
  dev build failed the undo entry check (F36). It now records none; a new
  text still joins the undo group of its creation.

  Checked in the browser with the WASM renderer: an edit of an existing text
  adds one undo entry.

- Keep the size a text edit ends with from touching the copy.

  When an edit of a text ends, the editor stores its content together with
  the size measured for it (the SVG renderer's text modifier, or the WASM
  measure in the v1 editor). Only the name was written as derived, so an
  edit of a copy's text touched :geometry-group besides :content-group, and
  the text kept its size against its main (F1, in the SVG renderer). These
  writes now take the size, the position data and the name as derived; the
  content still touches.

  workspace-text-modifier-test: an edit that ends with a measured width
  touches the copy text's content only. Checked in the browser with the SVG
  renderer: an edit of a copy's text touches :content-group and
  :text-content-text only.

- Measure again on WASM the texts a sync writes.

  The size of a text that grows with its content is derived (decision (g) of
  the component contract): sync writes the main's, and the renderer measures
  the text again. The SVG renderer does so when it draws the text; the WASM
  renderer did not, so a copy text with content of its own kept its main's
  width and height after a sync (F35). Now, with the WASM renderer, a sync
  of the current file measures again the auto-grow texts of the current page
  it writes, without a component sync of its own, in the undo group of the
  sync; a sync with no undo group gets one for both.

  Texts on other pages keep the size sync wrote until they are measured
  again.

  workspace-sync-wasm-text-test: a sync that writes a copy text with content
  of its own measures it again, in the undo group of the sync. Checked in
  the browser with the WASM renderer: after the main text grows or shrinks,
  two copy texts with content of their own get their own widths and no
  :geometry-group.

Benchmark (lower quantile, ms; baseline / now / ratio):
  deepest-edit-through-three-levels    35.2 /  18.1 / 0.51
  edit-through-a-chain-of-dependents   68.9 /  34.0 / 0.49
  library-update-into-copies           83.1 /  40.2 / 0.48
  main-edit-among-many-shapes           4.8 /   2.5 / 0.51
  main-edit-into-10-copies              1.8 /   0.8 / 0.44
  main-edit-into-100-copies            15.4 /   8.5 / 0.55
  main-edit-into-1000-copies          153.1 /  83.5 / 0.55
  variant-switch-into-copies           32.1 /  18.1 / 0.56

AI-assisted-by: claude-opus-5-5
2026-11-10 20:21:16 +01:00
alonso.torres
524161cacf 🐛 Fix the component watcher and library updates
Fixes in when the workspace syncs copies and propagates tokens, and in what
a layout wait covers (Phase 3c).

- Sync the copies when a shape is dragged inside a main.

  The component watcher dropped every commit flagged :translation? (the WASM
  drag commits only moves) so dragging whole mains around the canvas stays
  fast. A drag of a shape inside a main is flagged the same, so its copies
  never followed until some other edit of that main made them jump (F70).

  The watcher now drops a translation commit only when it moves shapes
  outside mains or whole mains: every shape it moves inside a main moves
  with the main's root (decision (q)). Otherwise the commit goes through
  component sync like any edit.

  workspace-sync-barrier-test: a translation of a whole main is dropped; one
  of a main's child syncs the copy. fill-commit in the interpreter takes
  several labels.

- Propagate the file's tokens after any library update.

  Updating a library from the notification synced the file and then
  propagated its tokens, so the copies take the token values of the file's
  token status, not the library's. The update button of the libraries
  dialog's Updates tab only synced the file (F83).

  dwl/update-libraries syncs the file from the given libraries and then
  propagates its tokens; the notification and the Updates tab both use it.

  workspace-library-updates-test: updating a library syncs it and then
  propagates the tokens.

- Sync copies whether or not component thumbnails are on.

  The component watcher's whole pipeline, the sync of the copies included,
  ran only when the :component-thumbnails flag was on or the WASM renderer
  was active. The flag is on by default, but an install that turned it off
  never synced copies on the SVG renderer: editing a main left its copies as
  they were (F8). The flag now gates only the thumbnail streams.

  workspace-sync-barrier-test: with the flag off, a main edit reaches the
  copy.

- Hold a token's shapes pending until the token is applied.

  A plugin's waitForLayoutUpdate waits until no shape has layout work
  pending. Applying a token resolves the tokens first, asynchronously, and
  opened no pending work meanwhile, so the wait found nothing pending and
  returned before the token reached the shapes or their copies (F54). The
  shapes are now pending, as a :token task, from the start of the resolution
  until the update is emitted, and the layout, text and sync work it starts
  takes over from there.

  The composable interpreter no longer waits on the token itself: case AY
  applies a token and checks its copies after the same wait a plugin uses,
  and fails without this change.

AI-assisted-by: claude-opus-5-5
2026-11-10 20:21:16 +01:00
alonso.torres
1e44a136aa 🐛 Keep guides and reflows in the undo group of their step
Two derived commits that left the copies' sync in an undo entry of its own
(Phase 3c).

- Move frame guides in the undo group of their transform.

  A transform of a board sends the move of its guides before the shapes'
  update. The guide move committed every guide of the board, moved or not,
  each in a commit with an undo group of its own, so when the board was a
  main with a guide, its transform and the copies' sync landed in different
  undo entries: one undo reverted only the copies (F6).

  Both transform paths now give the shapes' update an undo group up front
  and pass it to the guide move, which commits only the guides that move,
  all in one commit in that group.

  workspace-frame-guides-undo-test: one undo reverts a rotation of a main
  with a guide, its copy included, and a move of a main together with its
  guide.

- Reflow layouts in the undo group of the step that asked for it.

  A layout reflow runs a moment after the commit that needs it: the
  :layout/update events are buffered for 100 ms and reflowed per page. The
  reflow lost the undo group of the step (F43):
  - the buffer passed no undo group to the reflow;
  - update-shapes asked for a reflow without the group of its commit;
  - the reflow's transform opened an undo transaction, so it made an entry
    of its own instead of stacking on the latest one, and the sync that a
    reflow of a main starts took that entry's fresh group.

  So one undo after a sync that reflows (a flex main's margin edit, a nested
  sync with minimal frames, a swap) reverted only the reflow, or only part
  of the step.

  update-shapes now gives a commit that needs a reflow an undo group up
  front and passes it on; the buffer reflows each page in the group an
  update of that buffer names (those that name none come from the same step,
  like update-layout-child's); the reflow stacks on the latest entry with no
  transaction of its own.

  Cases AJ and AN no longer pin F43: one undo after a nested sync reverts
  the remote change and the float noise of the reflow, and one undo after a
  flex main's margin edit reverts the margin, the sync and the reflow. The
  frontend golden master records that.

AI-assisted-by: claude-opus-5-5
2026-11-10 20:21:16 +01:00
alonso.torres
c7a8f1afae 🐛 Fix the variant events and the plugin component calls
Fixes in the variant events of the workspace and in the component calls of
the plugin API (Phase 3c).

- Rename a variant in one commit.

  Renaming a variant renamed its board, then each of its components and
  mains, as separate commits inside an undo transaction. The transaction
  kept the undo group of its first commit, the board's, while the sync that
  the renamed mains started took the group of their commits and made an
  entry of its own: one undo reverted only the copies' names (F6, case AV).

  clv/generate-rename-variant builds the board, component and main renames
  in common, and the event commits them once, so the rename and its sync are
  one undo entry, like transform into a variant.

  Case AV no longer marks its round trip as a known failure; the frontend
  golden master records it without failures.

- Keep overrides in a plugin swap only within a variant set.

  The plugin's swapComponent swapped with keep-touched for any component,
  while the UI keeps a copy's overrides only on a variant switch: the same
  swap kept different overrides by route (F33). It now keeps them only when
  the copy's component and the target are variants of one set (decision
  (p)), as swap-keeps-touched? says.

  shape-bugfixes-test: two variants of one set keep the overrides; of
  different sets, or plain components, do not.

- Look up a plugin variant head's component in its own file.

  The plugin's isVariantHead looked the shape's component up in the file of
  the shape, so it was false for copies of a library's variants; and it
  looked it up before checking the shape is a head, so on a shape with no
  component it failed the lookup's assert (F91). It now checks the head
  first and looks in the shape's :component-file.

  shape-bugfixes-test: a copy of a library variant is a variant head, and a
  plain rect is not.

- Add a variant with the shortcut when a variant set is selected.

  The context menu of a variant container offers "Add variant" and shows the
  create-component shortcut for it, but the shortcut's event did not know
  containers: with one selected it fell through to creating a component,
  which the container's own rules refuse (F95). With a single variant
  container selected, the shortcut now adds a variant to it, as the menu
  entry does.

  workspace-variants-test: the shortcut on a variant container gives the set
  a third member.

- Refuse plugin variant edits whose variant is on another page.

  The variant events the plugin API calls (add a variant, add, remove or
  rename a property, set a property value) build their changes on the
  objects of the page the workspace shows. For a variant whose mains sit on
  another page, they updated the components but not their mains, so the
  mains kept their old :variant-name and the file failed validation (F94).
  The plugin now refuses these edits, as it refuses edits of shapes on
  another page, unless the variant is in the current file and on the current
  page.

  library-test: each edit goes through with the variant on the current page
  and is refused, with nothing emitted, with it elsewhere.

- Check every component of an assets group before combining it.

  The assets panel offers to combine a group of components as variants when
  they can be: more than one, none a variant, all with their main on one
  page. It counted every component of the group, subgroups included, but
  checked the other two rules only on the components directly in it, while
  the combine takes them all; with none directly in it, those rules always
  held (F98). can-combine-group? now checks every component of the group.

  assets-components-test: a group whose only components are in a subgroup
  can be combined; a variant or a main on another page in a subgroup blocks
  it; one component cannot.

AI-assisted-by: claude-opus-5-5
2026-11-10 20:21:16 +01:00
alonso.torres
3643d6fb7b 🐛 Fix component sync, reset and update main
Fixes in the sync of copies from their mains, in reset and in update main
(Phase 3c).

- Undo a token sync to the tokens a copy shape had.

  The token sync of a copy shape wrote, as its undo, the shape's tokens read
  with an empty map as default, so undoing the sync of a main's token gave a
  copy shape that had none an empty :applied-tokens map instead of no map
  (F55). The undo now writes the value the shape had.

  Case AY no longer marks its round trip as a known failure; both golden
  masters record the round trip without failures in the two variants that
  hit it.

- Reorder a copy's children with the fewest moves and exact undo.

  When a main reordered its children, sync wrote a move for every copy child
  the walk found out of place, from its position in the copy's original list
  to its main's index:
  - once one child was out of place, every following pair was too, so a main
    with 1,000 children that moved its first one to the end wrote 999 moves
    per copy, quadratic in the children (F85);
  - :mov-objects inserts before the index of the list that still holds the
    shape, so a move to a later place landed one short, and the undo, which
    used the original position, did not put the child back: undoing a
    reorder in a main left its copies reordered (F41).

  The walk now syncs the pairs, removals and additions first, and then moves
  the copy's children, as those changes left them, into their main shapes'
  order: the longest run already in order stays, and each other child moves
  right after the one before it in the main's order. Each move is computed
  on the order the moves before it left, so its index is exact, and its undo
  puts the child back after its old neighbour.

  The update main walk keeps its moves: the copy's order differs from the
  main's only after F41's undo, as the UI never reorders a copy.

  comp-sync-test: a reorder in a six-child main moves each displaced copy
  child once, gives the main's order, and undoes exactly. Cases F, AG and AO
  no longer mark their round trip as a known failure; both golden masters
  record it without failures.

- Remap a main's grid cells after the update main pairs children.

  An update main from a copy of a grid main pushes the copy's cells into the
  main, with each copy child mapped to its main shape. The cells were
  remapped before the children walk, when a swapped copy child still
  referred to the main child it replaces; the walk then removed that child
  and added a new main child for the swapped one. The main's cell kept the
  removed child's id and the new child was in no cell (F49); the next sync
  of the copy took that broken cell back.

  The cells are now remapped after the walk: each copy child goes with the
  main shape the walk added for it, or else with the one it refers to.

  Case AK no longer pins F49: with a swap, the main's third cell holds the
  new main child, the main takes the copy's cells as they are (the swap had
  made the first one manual), and the copy keeps its child in the third
  cell. Both golden masters record that.

- Add update main's new main shapes and their undo in the main.

  When update main pushes a copy child the main lacks (a swapped child), it
  adds a copy of it to the main (F102):
  - the refit of the groups around it was a :reg-objects that named the
    component, which reaches only a deleted component's stored shapes, so a
    group in the main kept its old bounds;
  - the undo deleted the new shapes from the copy's page, so when the main
    sat on another page the undo left them in the main.

  The new shapes, the refit of their parents and the undo of both now go to
  the main's container; undoing deletes the new shapes and refits the
  parents again.

  The case AM setup and the new test fit their groups to their children, as
  the editor does; an unfitted group's size is one the refit cannot give
  back on undo. Both golden masters record case AM with the fitted groups.

  comp-sync-test: an update main from a copy on one page into a main on
  another fits the group around the pushed copy, and undo gives the main
  back.

- Sync flips with the rest of the geometry.

  A flip changes a shape's transform, points and selrect, which sync and
  touch as geometry, and toggles :flip-x or :flip-y, which were not in
  sync-attrs: when a main flipped a child, its copies took the flipped
  transform but kept their old flip flags, which the renderers and the
  placement of swapped shapes read (F38). A flip on a copy touched geometry
  through the transform all the same.

  :flip-x and :flip-y now sync and touch as :geometry-group.

  comp-sync-test: a copy follows its main's flip, flags and transform,
  untouched.

- Reset a nested copy of a flex board keeping its children.

  Sync gives each child of a copy of a flex board the flex child attributes
  (margins, sizing, z-index, ...) of the main child it refers to. It looked
  that child up in the copy head's own component; for a nested copy that is
  not where its children's mains are (they are the children of the nested
  copy in the outer main), so the lookup gave nil, and a reset, which copies
  every attribute, wrote nil into all of them (F103). A child with no main
  was written nil the same way.

  The lookup now uses the container the walk reads the main shapes from,
  where every child's :shape-ref points, and a child with no main shape is
  left as it is.

  comp-reset-test: resetting a nested copy of a flex board keeps its child's
  margin (with a grid board too, whose children F15 leaves).

- Sync layout child attributes of the children of grid mains.

  Sync and update main copy the layout child attributes of a board's
  children (margins, sizing limits, z-index, absolute position, align-self)
  from the shapes they pair with, but only when the main was a flex board:
  the children of a grid main never got them, so a margin set on a grid
  main's child never reached its copies (F15). Grid boards now go through
  the same step, renamed update-layout-children.

  comp-sync-test: a copy follows the margin its grid main gives a child.
  comp-reset-test checks the reset of a nested grid copy keeps it too.

- Clear remote-synced when a nested copy is reset.

  A reset makes a copy equal to its near main, but the reset of a nested
  head marked every shape below the copy root :remote-synced, the mark of a
  shape last synced from a remote main. Update main reads that mark: it
  gives the main the copy's overrides only for shapes without it, and
  otherwise clears the main's touched groups. So after resetting a nested
  copy, an update main from the top copy cleared the overrides of the nested
  copy in the main, which the next sync from its own component then
  overwrote (F13).

  A reset now clears the mark, as the shapes follow their near main.

  comp-reset-test: after a reset of a nested copy, an update main from the
  top copy keeps the fill override of the nested copy in the main. Both
  golden masters record case AB without the marks.

- Check that a nested copy keeps its constraints.

  A copy of one component dropped into another's main, whose constraints the
  outer main then sets, keeps them, in that main and in its copies, when the
  inner component's main is edited: the setting is an override of the nested
  copy. The test guards it; the reset of the constraints a drop writes,
  which looked like a loss (F45), changes nothing a user sees, as nil means
  the same left/top.

- Undo a library typography sync to the text's measured layout.

  The library color and typography syncs rewrite a text's content and clear
  its :position-data, so the text is measured again. Their undo put back the
  old content but cleared the position data too, so an undone sync left the
  text unmeasured (F90). The undo now writes back the position data the text
  had.

  library-asset-sync-test: undoing a typography sync gives back the font
  size and the position data.

- File the copy's relinks of an update main with the copy's file.

  Update main from a copy of a library component writes some changes in the
  library (the main) and some in the copy's file; the frontend commits each
  part to its file, telling them apart by the changes of the copy shapes the
  walk visited (F9). A swapped copy child is not visited: update main adds a
  main shape for it and relinks the copy shapes to it, and those relinks,
  changes of the copy, went with the library's changes. The shapes it
  relinks now count as the copy's.

  comp-sync-test: pushing a swap from a copy of a library component keeps
  every change of the copy's shapes in the local part.

Benchmark (lower quantile, ms; baseline / now / ratio):
  deepest-edit-through-three-levels    35.2 /  16.9 / 0.48
  edit-through-a-chain-of-dependents   68.9 /  33.0 / 0.48
  library-update-into-copies           83.1 /  40.9 / 0.49
  main-edit-among-many-shapes           4.8 /   2.3 / 0.48
  main-edit-into-10-copies              1.8 /   0.8 / 0.45
  main-edit-into-100-copies            15.4 /   7.8 / 0.51
  main-edit-into-1000-copies          153.1 /  82.2 / 0.54
  variant-switch-into-copies           32.1 /  18.2 / 0.57

AI-assisted-by: claude-opus-5-5
2026-11-10 20:21:16 +01:00