An update main that pushes a transformed fill child into the nested copy
its main holds fixes that copy's layout sizing, as a resize does, so the
layout keeps the pushed size. It did not mark the sizing as the nested
copy's own override: the copy differed from its reference without an
override, and the next sync would give it the fill back and undo the
pushed size (F588, reachable since moves are generated).
A main that is itself a copy now touches the sizing groups the push
fixes. The composable model expects it to author them.
Test: generated
`generated-an-update-main-into-a-nested-copy-authors-the-sizing-it-fixes`
(JVM and frontend replay).
Benchmark (bench-components, alone):
| :world | :baseline | :now | :mean | :ratio |
|------------------------------------+-----------+--------+---------+--------|
| deepest-edit-through-three-levels | 35.215 | 21.333 | 22.41 | 0.61 |
| edit-through-a-chain-of-dependents | 68.931 | 42.992 | 44.734 | 0.62 |
| library-update-into-copies | 83.083 | 55.577 | 58.064 | 0.67 |
| main-edit-among-many-shapes | 4.837 | 2.625 | 3.164 | 0.54 |
| main-edit-into-10-copies | 1.79 | 1.131 | 1.216 | 0.63 |
| main-edit-into-100-copies | 15.415 | 11.226 | 12.849 | 0.73 |
| main-edit-into-1000-copies | 153.086 | 103.22 | 108.455 | 0.67 |
| variant-switch-into-copies | 32.052 | 23.27 | 24.267 | 0.73 |
AI-assisted-by: claude-opus-5-5
A layout update applied its modifiers and then settled the placement of
the copy shapes they moved, as a transform does. For a swapped head
turned with its main and filling a row, the settle gave back the
unskewed turn of its main and undid the skew the layout gives it, which
its main keeps (F441: a swapped head turned to fill takes the skew of
its main).
A layout update no longer settles placement (`apply-modifiers` and
`apply-wasm-modifiers` take `:settle-component-placement? false`); a
transform still does. The composable model's reflow, which settled
placement since `bac1443729` to match the old update, no longer does:
with it, layout and settle undid each other and never settled.
Test: frontend generated
`generated-a-turned-fill-swap-keeps-the-skew-its-row-gives`.
ClojureScript only; the benchmark covers JVM code and is not run.
AI-assisted-by: claude-opus-5-5
Two turned-shape programs of the frontend replay differed from the
composable model:
- Setting a turned variant to fill in its hugging variant board: the
sidebar fixes the board's width first, the model's property edit did
not, and a layout pass of a fill child in a hugging row collapses a
turned child before growing it, which left it a singular transform.
The model's edit of a layout child now applies the same sizing fixes
(`cls/fix-child-sizing`, `cls/fix-parent-sizing`).
- A swapped head turned with its main, filling a row: the frontend's
layout update settles the placement of the copy shapes it moves, which
gives the head its main's unskewed turn; the model's reflow did not,
and kept the layout's skew. The model's reflow settles them too
(`cll/generate-sync-transformed-placement`).
Both programs now pass in the frontend replay with WASM off (frontend
generated tests).
Harness only; the benchmark is not run.
Also in this commit:
- Log each shape's parent id in the WASM replay's debug output. The debug log
named each shape's parent, which copies and their mains share; it now gives
the parent's id too, so a subtree can be told apart from its copies'.
AI-assisted-by: claude-opus-5-5
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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