mirror of
https://github.com/penpot/penpot.git
synced 2026-11-21 17:50:38 +00:00
158 Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
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 |
||
|
|
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 |
||
|
|
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
|
||
|
|
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 |
||
|
|
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
|
||
|
|
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 |
||
|
|
b5aa49801f |
🐛 Check and commit plugin component calls as the UI does
- The UI offers swap and reset only on copy heads, and detach only on copies that are not inside another copy. The plugin's swapComponent and resetOverrides accepted any shape inside a copy (F92), and its detach any shape at all (F93), and sent the same events, whose changes expect a head. swapComponent and resetOverrides report "The shape is not a component copy head" for anything else; detach reports a shape that is not a copy, or a copy inside another copy, by ctn/detachable?, which the detach event checks too. swapComponent looked up the target file before checking its argument, so a value that is not a component failed an assert instead of reporting "Component not valid". - The plugin's switchVariant did not check whether the switch would nest a component in itself. The switch event checks that and calls the :on-error of its params' metadata; the plugin passed none, so the default, rx/throw, built an error observable that nothing used, and the call did nothing and reported nothing (F53). The plugin passes an :on-error that reports "The switch would create a component nesting loop", and the event's default does nothing. - Choosing a property value in the design tab with several members selected sent, for each member, an event that set the value and another that cleared its error, each its own commit and undo entry. The plugin's setVariantProperty set the value and left the error as it was (F94). dwv/update-property-value takes the components, and sets the value and clears the error of each in one commit; the design tab passes the selected members, the plugin its component, and the composable interpreter the one member of its edit. shape-bugfixes-test checks each plugin case on the proxy, and workspace-variants-test sets a value on two members with errors. AI-assisted-by: claude-opus-5-5 |
||
|
|
9296c00209 |
✨ Build variant actions and update main changes in common
Several actions built their changes in frontend events, step by step, each step its own commit, so the pure runner could not run them and one undo could revert half an action. - Renaming a variant member in the layers panel sent three events, each in its own undo transaction: update the properties from the typed formula, remove the properties no member gives a value, and set or clear the member's error. One undo reverted only the last. clvp/generate-rename-member builds the three steps in one changes (with generate-update-properties and generate-remove-empty-properties), and dwv/rename-member commits it once with the same analytics events. update-properties-names-and-values goes; remove-empty-properties and update-error stay for the design tab. - Transforming a component into a variant sent about fourteen events, and combining components as variants that transform and eight more. clv/generate-transform-in-variant and clv/generate-combine-as-variants build those steps as one changes, from the generators common already had, and the events commit them once. The flex layout initializer moves to common as cls/layout-initializer. Combine still sizes the board with two frontend dimension updates inside its undo transaction: the frontend applies them through modifiers, which common has no step for. - update-component split the changes of an update main (the copy's, marked :local-change?, from the main's, which may belong to a library) with two transducers; cll/split-local-changes does it. Its undo-group argument, never passed, goes, and the main's library is the copy head's :component-file, which it looked up through the file data only to read its id back. - dwv/valid-variant-switch? read the libraries from the state and repeated the lookup of clv/find-switch-target. clv/valid-switch? takes the libraries and asks find-switch-target; the plugin's switchVariant and the frontend test call it. Behavior changes: - One undo after a rename of a member, a transform or a combine reverts all of it. After a transform, it reverted only the sync of the copies' names (F6 in case AT); its pins go. - The transform no longer sends the "create-board" analytics event of the board it creates around the main. In the composable suites, renaming a member in the layers panel, removing the empty properties and setting a member's error are variant property edits both runners run, and case AW joins the JVM set. Its rename node drives the real layers-panel rename, which removes the empty properties too, so the step that removed them goes. The golden masters are recorded again for AW (the JVM one gains the case, the frontend one loses that step) and for AT (its final states no longer list the F6 undo failures). AI-assisted-by: claude-opus-5-5 |
||
|
|
4c96360d95 |
🐛 Remove the right empty variant properties when there are many
remove-empty-properties, run after a rename in the layers panel, found the position of each property by grouping all the properties of the variant's components by name and numbering the groups. A map of more than eight keys does not keep their order, so with nine or more properties the numbers did not match the positions and the wrong property was removed: with ten properties and the sixth empty in every component, it removed the first (F86). The positions now come from the properties themselves: a property is removed when its value is empty in every component. The work moves to common as clvp/generate-remove-empty-properties, and the event only commits what it builds. workspace-variants-test checks the case with ten properties. AI-assisted-by: claude-opus-5-5 |
||
|
|
c87b6c8ee2 |
📎 Count only a thumbnail test's own RPC calls
The clear-thumbnail-batch tests mock the RPC and count every call recorded while the mock is installed. A thumbnail deletion batch left over by an earlier test of the suite (a component sync clears the thumbnails of the frames it changes) can call it in that window, so the tests failed in the full frontend run from time to time and passed alone. - The batch tests count the calls about their own object ids. - The test that clears an empty queue expected no call at all; a call made by the event under test could only carry no object ids, so it checks that none of the recorded calls is such a call. AI-assisted-by: claude-opus-5-5 |
||
|
|
7b9ddf5b19 |
✨ Give a synced copy text variants of its own font families
Sync and the variant switch can take a copy text's family from one side and its weight from the other. The variant id goes with the weight, so it can name a variant of the other family: the WASM renderer then picks the closest variant, but the SVG renderer falls back to the regular one. The frontend now gives each text content that a sync or a component swap commits variants of its own families: a run whose variant is not one of its family's takes the family's closest to its weight and style (cttx/update-font-variants, fonts/find-closest-variant). The pure runner has no fonts, so case BA leaves variant ids out of its comparison. The merge also leaves alone a run that already shows the placed style, so a main edit no longer rewrites the variant ids of a copy whose family is its own; with a new family, the run still takes the placed variant id. Benchmark (lower quantile, ms; baseline / now / ratio): deepest-edit-through-three-levels 35.2 / 35.7 / 1.01 edit-through-a-chain-of-dependents 68.9 / 65.2 / 0.95 library-update-into-copies 83.1 / 75.1 / 0.90 main-edit-into-10-copies 1.8 / 1.5 / 0.86 main-edit-into-100-copies 15.4 / 15.1 / 0.98 main-edit-into-1000-copies 153.1 / 151.4 / 0.99 variant-switch-into-copies 32.1 / 30.4 / 0.95 AI-assisted-by: claude-opus-5-5 |
||
|
|
6bdb9b6404 |
✨ Reject imported components v1 files that have components
Both binfile importers stored a file without the components/v2 feature as a v2 file, though its component data was never migrated. Such a file is now rejected with :file-in-components-v1, the code that opening a v1 file already raises, when it has components or shapes linked to them (:component-id, :shape-ref or :main-instance). A file without component data takes the feature and imports as before. Since every imported file now has the feature before the pending migrations are registered, the no-op components/v2 migration goes. The import dialog explains the rejection: the entry says that the file uses an old type of components that Penpot no longer supports, with its own text, as errors.deprecated talks about opening a file. AI-assisted-by: claude-opus-5-5 |
||
|
|
62f99e0493 |
✨ Make the component test suites fail when their claims break
A review found tests that would pass with what they test broken. - Runners: both judge one variant at a time, fail a variant with no assertion and a known-failure mark that applies nowhere, and give the asserter the state the operations produced. The pure runner validates the final file and rejects operations of unknown kind. The frontend interpreter fails a step when the store reports an event error (Potok only logs it), reports asserter errors against their case, and stops the watchers that install! starts. - Nodes drive the real code: a main root rename goes through end-rename-shape, and the clipboard's advance of nested copies is one common function, cll/advance-copied-objects, that copy-selected and both test paths call. - Cases N, AH, AI, AK, AD, AE, K, C, H, S, AY, I, Y, AX and F check what they claim; O, R and T get real sizes. - Stricter common unit tests found F60 (a repair detaches healthy copies), F61 (a switch drops a fixed-sizing size), F62 (the ref chain never stops at its target) and F63 (latent); all pinned. - Frontend library tests: the RPC double records on subscribe, the dropped commits check that nothing syncs, and the link and share tests check the events sent. - Plugin suite: OpSwap and OpDetach throw when the API call did nothing, and case AB checks that the reset head is an instance of the original component. - The composable suite memory records the new rules. |
||
|
|
680b08dcaf |
✨ Make composable interpreter steps wait for pending work
The composable interpreter treated a step as done after a 60 ms gap
with no commits, and treated its 2 s timeout as done too. Slow sync or
reflow work could finish after the step, so a case could assert on a
half-synced file.
Each event step now waits, as the plugin waitForLayoutUpdate does,
until every pending work tracked by the reflow registry has drained:
the watcher's sync wait, the sync it starts, and layout and text
reflow. A step that does not drain within 2 s fails the test and names
the work still pending, and the next variant starts with nothing
pending.
The tests cover an edit with a deliberately slow sync, undo and redo
steps that must wait for the watcher's touch-component, translation
and derived commits, a sync that never finishes, and a restart of the
edit watchers, which must keep the undo entries of an edit the same.
Also in this commit:
- Keep page-less changes from adding a nil page. Applying a commit locally
rebuilds the object indices of every page its changes name. Changes that touch
no page, such as :mod-component, name none, and their nil page id was rebuilt
too: the file data in the store gained a page under a nil key holding
{:objects nil}. Every component touch after an edit to a main added it, and
undo never removed it.
- Check undo and redo of every step in the composable cases. The composable
cases tested undo only where a case asked for it, so a change generator with a
wrong inverse, or a step that splits into several undo entries, went
unnoticed.
- Add operations and cases to the composable component suites. The composable
runners could edit, add, remove and move children, swap and switch, but not
run the other component operations.
- Test component validation, repair and library asset sync.
- Add a component sync benchmark with a recorded baseline. The coming refactors
and fixes change sync code, and a slowdown must be seen and explained in the
commit that causes it.
- Tidy the composable suite and make its cases stricter.
- Test the component sync paths no test reached. A coverage run found sync paths
that no test ran.
- Test variant events, token sync and switch overrides. The variant events had
almost no frontend tests, and several switch, paste, token and restore paths
never ran.
- Test the file and container helpers and the library events. The component
helpers of types/file and types/container and the library events of the
workspace had the lowest coverage left.
|
||
|
|
61ec544881 |
🐛 Hold the sync wait for every local commit
The component watcher opened its :sync-file wait only for commits saved to the undo stack. Undo and redo commit without it, so a wait such as the plugin waitForLayoutUpdate returned before the watcher had handled them. Translation and derived commits were filtered out before the wait opened. Open the wait for every local commit of a file and close it once the watcher has decided what to do: sync, only touch the component, or drop the commit. Dropped commits close it right away. Add wrf/pending, a snapshot of the pending work, for tests and diagnostics. |
||
|
|
671ff4a05f | Merge remote-tracking branch 'origin/staging' into develop | ||
|
|
e4fcc663c0 | Merge remote-tracking branch 'origin/staging-2.19.x' into staging | ||
|
|
1db1487c7f
|
🐛 Require thread access when marking threads as read (#12894)
* 🐛 Require thread access when marking threads as read mark-all-threads-as-read took any list of thread ids and wrote the read status of the caller on each of them, without checking that the caller can access the file that owns the thread. It was the only comment mutation that did not check permissions, and it took the ids as an unbounded array, so a single request could keep a database connection and a transaction open for a long time. The rpc now resolves the threads in one query and checks the comment permissions of every distinct file, answering not-found when a thread does not exist or is not accessible. Both cases answer the same error on purpose, so the response cannot be used to tell existing threads apart. The status rows are now written with a single insert, keeping the modified-at date one second in the future that makes the thread count as read. Repeated ids are deduped, the command returns nil again like the sibling commands with no result, and the schema limits the number of threads per call to 500 while the dashboard sends the ids in batches of that size. Tests cover access rejection, unknown threads, mixed batches that write nothing, repeated ids, empty lists, marking twice, and the frontend batch split. Relates to GHSA-j4vc-cmf6-jhr7 AI-assisted-by: minimax-m3.1-flash * 🐛 Refresh the unread list when a batch fails The dashboard sends the thread ids in batches of 500 and each batch commits on the server. A failure in a later batch left the unread list stale: the re-read only ran when every batch succeeded, so the threads already marked as read stayed visible as unread. The re-read now runs in both paths. On failure the event is emitted before the error is propagated, so the error toast still shows and the success toast stays limited to a full success. The backend also answers an empty list without opening a transaction, since there is nothing to check and nothing to write. Relates to GHSA-j4vc-cmf6-jhr7 AI-assisted-by: deepseek-v4.1-flash |
||
|
|
8510daef52
|
🐛 Restrict the team invitation token and list to admins (#12892)
* 🐛 Restrict the team invitation token and list to admins The token of a team invitation is a bearer credential: whoever holds it accepts the invitation with the role of the invitation row. The RPC that mints it only required edition permissions, while the rest of the invitation commands require admin, so a team editor could get the token of any pending invitation, including the ones that grant the owner role. The token now requires admin, and the token of an owner invitation is restricted to the team owner: an admin cannot create nor promote an owner invitation, so it cannot keep its token either. It reuses the error code already used for that rule. Minting the token now leaves an audit event named as an action, carrying the granted role and the id of the invitation, so the extraction does not go unnoticed. The list of pending invitations is admin only as well: it carries the email of the invited person and the role offered, and the dashboard was painting those emails to any member. The frontend catches the permission error and shows the permission notice instead, and the copy action is not offered for an owner invitation, which the backend rejects for an admin. The five invitation commands now answer with the same permission error, so they speak one language. Relates to GHSA-4mmc-j8rh-74pf AI-assisted-by: minimax-m3.1-flash * 🐛 Clear the cached invitations and gate the list on team admin The pending invitations are a team admin only list. The dashboard still offered the entry to every member and keyed the section on the invite policy of the organization, so a team admin blocked by that policy saw the no-permission notice although the backend lets them list. - `fetch-invitations` answers a denied refetch with an `invitations-fetched` event carrying an empty list, so a demoted admin does not keep the cached emails and the header no longer paints the invite button from a stale list. - The header tabs and the team options dropdown hide the invitations entry without `:is-admin`, which already includes the team owner. - `invitations-section-content` keys the section on `:is-admin`, and the invite policy only gates the invite actions: resending keeps the `can-invite?` check, deleting and row selection only need team admin. AI-assisted-by: deepseek-v4.1-flash |
||
|
|
4fb0ea9eee
|
🐛 Give unique values to same-name components combined as variants (#12881)
When components whose name matches the variant container are moved into it, removing the container name leaves an empty value. Combining several components named the same produced "Value 1" for the first variant and empty values for the rest, so variants shared the same combination. Assign the first unused "Value N" to the last property when all computed values are blank, tracking values given within the same batch. Combine moves the remaining mains into the container one at a time, in the combine order, so the generated values follow that order instead of the layer order. Closes #12878 |
||
|
|
cd1ece4beb
|
⚡ Keep the translation flag on undo and redo of a move (#12870)
* ⚡ Keep the translation flag on undo and redo of a move
Previously undos and redos always forced a component sync + thumbnail
rerender for every component touched even if the underlying commits were just
translations. This propagates the translation flag to undos and redos and
propagates it to commit-changes. An entry merged from several undos/redos is
a translation only if all of its undos/redos are translations.
This reduces a UI freeze when undoing a move of a board with 453 components
from 2.42s -> 0.22s.
AI-assisted-by: claude-sonnet-5-5
* :translation? -> :translation
---------
Co-authored-by: Andrey Antukh <niwi@niwi.nz>
|
||
|
|
943e63a99e
|
⚡ Group color updates in selections (#12875) | ||
|
|
1df2941576 | Merge remote-tracking branch 'origin/staging' into develop | ||
|
|
0ea6d166f0
|
✨ Add a session origin model to auth events (#12856)
* 🐛 Return the full profile from the LDAP invitation branch The invitation branch responded with only {:invitation-token token}, so the session start received a map without id or auth-backend. With the new auth-origin vocabulary that map fails validation and the login breaks in development and tests; in production the event would be emitted without a channel. Return the profile plus the token, like the regular branch, and cover both branches with RPC-level tests. Closes #12849 AI-assisted-by: deepseek-v4.1-flash * 🐛 Mint an auth token in the OIDC callback with the invitation inside The callback used the invitation JWE as the session token, so the frontend landed directly on token verification and never ran the regular session start: no signin event, no teams, no host hook. Always mint an :auth token and carry the invitation in its claims. Token verification returns the claims verbatim, so login-from-token attaches the invitation to the profile and logged-in does the rest, the same pattern the verify-email token already uses. Closes #12849 AI-assisted-by: deepseek-v4.1-flash * ✨ Keep the session origin in the telemetry shadow rows The anonymisation filter drops every string unless it is on a short allowlist. Add source and activation next to lang and auth-backend so the shadow copy keeps them; the email and the full name are still dropped and the email domain is still derived from the email. The filter keeps its two bindings: the transducer discards everything that is not a UUID, a boolean or a number, so the allowlist is applied on the filtered map, never on the raw props. Closes #12849 AI-assisted-by: deepseek-v4.1-flash * ✨ Describe the signup outcome with activation, not with action The three success branches of register-profile labelled a new account as "login", "email-verification" or "accept-invitation", so the event contradicted its own name and the value only lived in context, where the analytics consumers never read it. Add activation to the event props and drop action from those branches: the name already says it is a signup, and a constant action would only add noise. The retry branches keep their action in context because there it distinguishes four different outcomes. Closes #12849 AI-assisted-by: deepseek-v4.1-flash * ✨ Describe the session origin in the signin event The event carried the profile but never said why the session started: the only field that tried was frontend metadata that never leaves the browser, and several flows filled it with the wrong value. Add a small closed vocabulary (source, auth-backend, activation, from-invitation) and compose it from the profile when signin is emitted. The assertion fails in development and tests and is elided in the release build, so a bad value cannot break a real login. Closes #12849 AI-assisted-by: deepseek-v4.1-flash * ✨ Emit the session origin from every login entry point The four emitters stamped a free-form string as metadata, so the session event could not rely on it: two flows that were signups wrote the same value as a login. Route them through origin-meta: password and LDAP logins declare source login, register declares source register with activation immediate, and login-from-token derives both from the token issuer: :auth for a login and :verify-email for a signup that needed the email confirmation. Closes #12849 AI-assisted-by: deepseek-v4.1-flash * 🐛 Send the invitation signups through the regular session start Registering from a team invitation link navigated by hand to token verification, so the session start never ran: no signin event, no teams, no host hook. The same navigation was copied in four places. Teach login-from-register to carry an optional invitation token, extract the profile decoration into with-register-origin, and call it from the four sites instead of the hand-written navigation. Closes #12849 AI-assisted-by: deepseek-v4.1-flash * 🐛 Resolve the invitation without waiting for the teams Registering from an invitation link now goes through the session start, and that start only navigates after the teams request completes. fetch-teams has no error handling, so a network failure there would leave the invitation unaccepted and the user on the signup screen with a session already minted. Move the invitation navigation out of the teams path: it emits as soon as the profile carries a token, and the teams path emits nothing for an invited profile so it cannot move the user away from the token verification screen. Closes #12849 AI-assisted-by: deepseek-v4.1-flash * 📚 Document the session origin vocabulary and the invitation flow Add a focused memory with the four fields, where each value comes from, the table of flows, the LDAP exception and the invitation path through logged-in, and link it from the frontend routing. Update the audit-log memory: source and activation are now on the telemetry allowlist, activation lives in props and action only exists on the retry rows. Closes #12849 AI-assisted-by: deepseek-v4.1-flash * 📎 Cover the invitation session start and fix the auth memories The invitation flows and the token decoration in login-from-token were only covered by helper tests, so removing the guard that keeps the teams path from navigating, or the token attach, broke the behaviour silently. Run the events through ptk/watch with a teams-fetched event as input: an invited profile navigates to the token verification screen and never to the dashboard, and the signin keeps from-invitation. Add the login-from-token cases with and without the token, and fix the memory statements about action, the flow table and from-invitation. Closes #12849 AI-assisted-by: deepseek-v4.1-flash |
||
|
|
87fc15b5aa
|
🐛 Open the first page in view mode when the URL has no page id (#12687)
A view URL without a page-id crashed builds with assertions enabled: the viewer passes a nil page-id to `initialize`, whose schema accepted a missing key but not a nil value. Release builds skip that check and draw the first page, but every viewer event reads the page from the route, so zoom to fit and fill, the next-board arrow, Navigate To interactions, and comment pins did not work. `initialize` now accepts a nil page-id, `fetch-bundle` makes it optional, and `bundle-fetched` replaces a route without page-id by one naming the file's first page. The viewer then initializes again on the completed route, as it does when the user changes page. A file with no pages keeps its route. AI-assisted-by: claude-opus-5-5 Signed-off-by: Álvaro Tejero Cantero <alvorithm@teje.ro> |
||
|
|
2df4d10bd5
|
✨ Enforce attribute-based organization permissions (#12868)
* ✨ Enforce attribute-based organization permissions * 📎 Code review |
||
|
|
7eacbec245 |
🐛 Keep comments, focus, thumbnails and text in step with a rollback
A rollback reverts the local data with a rebase, which is not a commit, so the parts of the workspace that follow commits missed it: - Comment pins moved in the reverted action stayed where they were, on screen and on the server, and pins on a board the rollback removed kept pointing to it. They go back to the reverted position, and pins on a removed board move to the page root. - Focus mode stayed on with no shape left when the rollback removed the focused ones, and the next shape drawn turned it on again. It ends when its last shape goes, and the selection drops removed shapes. - Component thumbnails kept the rejected look. The thumbnails of the reverted mains are rendered and uploaded again, and an upload whose shapes changed during the render is skipped. - Under WASM, an open text editor reset to the reverted content but the canvas kept the old layout. It is laid out again. - A library sync whose save failed showed no update notice again once the release undid it. The notice is checked again after that rollback. |
||
|
|
88416d2542 |
✨ Label the copy kept before a repair in the History panel
Before it repairs a damaged file, the backend keeps a copy of it as a system snapshot, and the repair notice points to the version history to find it. The History panel listed that copy among the autosaves, so it could not be told apart. The History panel lists the copies kept before a repair as their own entry per day, "Before automatic repair, <date>", above that day's autosaves, and the preview of such a copy uses the same label. |
||
|
|
61bf66342b |
✨ Tell repairs, damaged data and other files apart in save notices
The notice of a rejected save always said the same thing. It did not name the file when the user had moved to another one, gave no hint when the page held data that was already invalid, and replaced the notice of a backend repair still on screen, since the store holds one toast. The backend flags a rejection whose first commit touches pages or components that failed validation before it (:preexisting-damage). The rejection notice names a file other than the open one, says when the data was damaged before, and folds into a repair notice still on screen; a later repair notice folds a rejection notice in the same way. The notice says that the latest changes were undone, no longer that the rest of the work is saved. |
||
|
|
27c1c38360 |
🐛 Apply the changes stored before a save before acknowledging it
The answer to a save lists the changes other sessions stored before it, such as the backend's repair of a damaged file. When the answer came before the message with such a change, the saved commit was acknowledged first, and the late change was then applied on top of the local edits instead of under them, out of the server's order. A saved commit of the open file now stays pending until this tab has received every change the answer lists from other sessions, so a late change is applied under the local edits. If one does not arrive within 10 seconds, the file reloads. |
||
|
|
302f83f072 |
🐛 Drop the unsaved edits made on a version a peer restored
When a peer restores a version, the file reloads to it. Edits made on the replaced version stayed queued: their save failed for good and locked the workspace, and a rollback or a rebase replayed them on the restored data. Loading another version forgets the queued, buffered and saved commits made on the old one. A save of such a commit, in flight or answered, is dropped instead of failing or being rolled back, and one save carries the edits of one version only. |
||
|
|
1d862c0dd5 |
🐛 Refuse every edit while saves fail
While saves fail the workspace turns read-only, but only some tools checked it. Edits from the asset, color and token panels, and a drag or a drawing in progress when the lock came, still made commits that queued behind the failed save. commit-changes refuses commits while the save-failure lock holds, except those that are not user edits: the undo of rolled-back commits, text position data and component touches. Undo and redo do nothing while locked. When the lock comes, moves, resizes, rotations, drawings and the drags of flex, guide and grid handles in progress are cancelled and commit nothing, and the design panel shows the Inspect view. |
||
|
|
e10ceefb5d |
🐛 Keep a file reload from doubling the workspace streams
Reloading the open file (a peer's restore, the fallback of a rollback) runs initialize-workspace again without leaving the workspace. The streams the first run started kept running next to the new ones, so a commit added one undo entry per reload and each notification was handled twice. The old subscription also sent its unsubscribe after the new subscribe, which ended the new one on the server. A new initialize-workspace, text reflow, shape layout or notification subscription stops the one before it, and a subscription replaced by one to the same file sends no unsubscribe. |
||
|
|
7538d2c187 |
✨ Tell plugins and the MCP agent when changes are rolled back
The backend rejects a save after the call that made the changes has returned, and the workspace then undoes them. A plugin, or the MCP agent, went on working with shapes that were no longer there and never learned why. The rollback event now names the files that lost commits and the pages and page shapes their changes touched, and plugins get it as the new `contentrollback` event (`ContentRollback` type) through a subscription to the store stream, so no rollback is dropped by debouncing. The MCP plugin keeps the rollbacks it is told about and sends them with its next task response, failed or not. The server collects them per tool call and puts a warning first in that tool's response, naming what was affected; the instructions tell the agent to read the pages again and redo what is missing. |
||
|
|
8ef3ba628d |
🐛 Keep the workspace open when closing the v2 text editor
Closing the v2 text editor with Escape could crash the workspace. The text options panel renders once more with the editor it saw last, after closing has disposed it, and reading the style of a disposed editor throws. The panel now takes the values from the shape when the editor is gone. |
||
|
|
6426b17c9c |
🐛 Fix small save bugs found by the rollback test plan
- Ending a drag inside the frame the shapes already belong to sent an empty reparent save and bumped the revision. The move commits only when some shape changes parent. - When a user restored a version, other sessions reloaded the file with no notice. They now see a dialog naming who restored which version (by its name, else its date), saying that later changes are no longer in the file and, when they had changes not saved yet, that those were lost. - Exports drawn in the browser (PDF, SVG, and PNG when the WASM renderer draws it) and duplicating a file from the dashboard started at once, so an export could show changes a pending save then rejected, and a copy could miss queued edits. Both wait for the file's pending saves. A client export warns that it includes unsaved changes; a copy warns that it misses them. |
||
|
|
94c05589cf |
🐛 Keep the UI in step with a rollback
A rollback can remove or change shapes the UI still refers to. - The selection drops shapes that are gone and the color picker that edited them closes. - The undo history is cut at the reverted action; it stays when no entry holds a reverted change. Undo and redo commits carry real undo changes and the history index they moved from, so a reverted Ctrl+Z puts the change and the index back. - An open path edition whose shape the rollback changed closes without saving the editor's stale copy. The v2 text editor loads the reverted text again; the WASM editor already showed it. - The Alt measurements look the hovered shape up in the current data. - Plugin setters, resize() and rotate() on a removed shape throw "Shape not found", whatever the plugin's throwValidationErrors flag. |
||
|
|
cb26e8a39b |
✨ Keep autosave and the workspace alive when saves fail
- A save that failed on a short platform failure (a lost or refused database connection, lack of resources, a server shutting down, a serialization failure or deadlock, a socket or HTTP timeout, a host that did not resolve, an interruption) answered 500, which stops autosave. It now answers 503, which the frontend retries. Other I/O and database errors keep answering 500, timeouts 504. - A save answered not-found no longer replaces the workspace with the access page. It is a terminal save error: the workspace stays open with the failed save notice, report and reload link. When edit rights are lost, the notice says how many changes could not be saved. - A library sync marked the library synced three seconds later, whatever happened to its save. A rejected sync was undone but stayed marked: copies stayed out of date and the "updates available" notice never came back. The mark now waits for the save, a rollback of the sync brings the notice back, and a failed mark (e.g. the user just became a viewer) is logged instead of leaving the workspace. - While saves fail the workspace is read-only. The view-mode banner says editing is disabled because changes can't be saved, with the Inspect banner's size and bold lead and no Done button. Users can still switch pages, pan, zoom and inspect. The lock lifts when a save lands and brings back the mode the user had or picked meanwhile; the WebGL context lock keeps the workspace read-only if it lasts longer. The lock lives in app.main.data.persistence.lock. - A viewer is never locked. A role change that leaves the user a viewer keeps the edits that lost permission, queued and on screen, and shows the count notice again. The role change that brings edit rights back releases them and rolls them back on screen, as a rejected save would. Any other terminal failure is released by the next role change or file opened. The debug faults `io` (socket timeout, 503) and `eof` (500) cover both sides of the I/O rule. |
||
|
|
f4b20ed08f |
🐛 Revert whole user actions in a rollback
A rollback reverts whole undo groups, across files and saves, so that no user action is left half done. Some actions still split: - An action that commits several times inside one undo transaction (e.g. applying a token to several shapes) gave each commit its own group, so a rejection could revert part of it: shapes ended up linked to a token whose value was never applied. An undo transaction now opens with a commit group that every commit made inside it takes. - The commit that undoes saved commits of a rejected action joined an open transaction's group, so a later rejection there reverted the undo too. It gets a group of its own. - Emptying the open transaction during a rollback dropped its group, so its later commits were no longer one unit. It keeps its group. - Waiting for a save ended as soon as the queue emptied, while later commits could still wait in the buffer. Waiters now also wait for an empty buffer. A test covers a token action of three commits in one save whose third commit is rejected. |
||
|
|
4f42ab1d2d |
✨ Keep the valid commits of a save that fails validation
A save whose changes failed validation was rejected as a whole: autosave stopped, the edits made after it piled up unsent, and a reload lost them all, the valid ones included. The frontend now sends each commit of a save as its own group with its commit id (:changes-with-metadata). When applying and validating all of them at once fails, the backend searches by bisection for the first commit that fails, keeps the commits before it and answers with :rejected (that commit and every later one). Only the kept changes are stored, snapshotted and broadcast, so other users never see the rejected ones. Flat :changes and groups without ids stay all-or-nothing; database and network errors still fail the whole request. A rejection without an error type is reported as an internal error. The frontend rolls the file back to what the server holds: it undoes every pending commit of that file, applies again the remote changes that arrived meanwhile, and redoes the kept commits. Undoing only the rejected commits would write stale values over a peer's later change to the same attribute. The rejected and later commits leave the queue, the buffer and the undo history, and a warning that hides after ten seconds tells the user. The pure bookkeeping lives in app.main.data.persistence.commits. The pending notice of a commit the rollback dropped no longer leaves the save status at pending, which made "Pin this version" hang and fail. Debug tools drive these cases by hand: debug.commitInvalidChange() makes a save fail validation, holdSaves() delays the answers, failNextSave() and failNextRollback() fail them on purpose (backend flag debug-save-faults), and persistenceState() shows the queue. |
||
|
|
ef4d66c3aa |
🐛 Apply remote changes under buffered local edits too
A remote commit undoes the pending local commits, applies the remote changes and replays the local ones, so the local file ends like the server will: remote first, local last. Only queued commits took part; the ones still waiting in the persistence buffer (up to ~3s of edits) stayed under the remote change. When both touched the same attribute, the remote value won locally but lost on the server. The buffer now lives in the store ([:persistence :buffer]) instead of an rx buffer, so the rebase can reach it. A flush merges it per file into queue entries that keep the list of commits they carry, and the leave-page guard reads buffer and queue from the store. A buffer left by a previous session is queued when persistence starts. |
||
|
|
97fe51e08b | Merge remote-tracking branch 'origin/staging' into develop | ||
|
|
7666d7d500 | 🐛 Fix Creating or combining a variant set renames the component first | ||
|
|
eeda9c1d18 | 🐛 Fix renaming a variant set saves half-finished steps | ||
|
|
d47f366c70 | 🐛 Fix Creating or combining a variant set saves half-finished steps | ||
|
|
a089f7a5a1
|
🐛 Fix library telemetry counters (#12787)
At some point the code around this changed, I believe this used to reduce over file ids. However today it reduces over entire library maps, so it passes a map instead of an id to `dm/get-in files`. This then hashes the library which forces it to decode all of its shapes, and then it fails to lookup the data. So the component/colors/typography counts were always returning 0. Using reduce-kv fixes this, and we can just get the library data directly with `(:data library)`. On the backstage file in penpot-files this brings the time to the telemetry snapshot down from 3.8s to 1.5s AI-assisted-by: claude-5.5-sonnet Co-authored-by: Andrey Antukh <niwi@niwi.nz> |
||
|
|
be37341f36 | Merge remote-tracking branch 'origin/staging' into develop | ||
|
|
43f3bda8b5
|
✨ Add mcp browser extension (#12627)
* 🐛 Fail MCP tasks at once when their plugin connection closes A response only counts when it comes from the connection the task went to, so a task sent over a connection that then closes can never finish. It used to wait for its full timeout. The plugin bridge now fails such tasks as soon as their connection closes. Connections also log their close code and reason, to tell a page closing its socket from a browser or network failure. * ✨ Announce the MCP session to a browser extension Let a browser extension learn which tab holds an MCP session, so it can keep the browser from discarding that tab. While the MCP plugin runs, the page listens for the extension's hello message, and says it is ready once it listens, so that a content script that said hello too early says it again. After a hello, the page posts its session ID and connection status, and posts them again on every status change. When the plugin stops, it reports the session as disconnected. The plugin also reports "disconnected" while it reconnects on its own, for instance after a page resume, so the page announces "connecting" then and "disconnected" only once the user has stopped the connection. Otherwise the extension would forget the session at every reconnect. The page only accepts messages posted on its own window by its own origin, posts to its own origin only, and sends nothing before the extension asks. It reaches the window through app.util.globals, whose stand-in for the unit tests accepts postMessage. * ✨ Keep Penpot tabs connected to MCP from being frozen Chrome freezes some background tabs, for instance busy ones while Battery Saver is on, and a frozen page cannot run the MCP plugin. Chrome does not freeze a page that holds a Web Lock, so the page holds a lock named penpot-mcp-session from the moment the user asks to connect until the connection stops: on disconnect, logout, MCP being turned off or the MCP runtime starting again. The lock is shared, so several tabs can hold it at once. Browsers without Web Locks skip it, and when the lock request fails, the next connection request tries again. Firefox does not freeze background pages, so the lock changes nothing there. * ✨ Add a browser extension that keeps MCP tabs from being discarded A browser may discard a background tab to save memory. A discarded Penpot tab reloads when the user returns to it and loses its MCP session. Add mcp/packages/browser-extension, a Manifest V3 extension for Chrome and Firefox, built from one source into dist/chrome and dist/firefox. It is written in TypeScript, bundled with esbuild and imports the protocol types from mcp-common. The package joins the mcp workspace, so the build, test and fmt scripts of mcp/ cover it; the server release build skips it. Its content script runs on design.penpot.app, on the test environments under penpot.dev and on local development instances. It asks the page for its MCP session on load, again when the page says it is ready and when the page returns from the back/forward cache, and forwards each valid session announcement to the background. It accepts only messages the page posted on its own window from its own origin, and posts its hello to that origin only. It also tells the background when the page is hidden. The background records which tab holds each MCP session. A tab holds the session it last announced as connected, until its page announces a disconnect, is hidden, or the tab is closed or replaced. The map lives in chrome.storage.session, so it survives restarts of the background and clears when the browser closes. While a tab holds a session, the browser may not discard it automatically. The extension asks only for the storage permission. Chrome runs the background as a service worker; Firefox runs it as an event page and needs the add-on ID, mcp-extension@penpot.app, and Firefox 140. The toolbar popup lists the connected tabs. The icon is the Penpot logo, white on a black rounded square, with the SVG source next to the PNGs. A README explains how the extension works and how to build and load it. * 🐛 Ask MCP plugins for heartbeats so hidden tabs do not look frozen The server refuses to send a task to a plugin whose last heartbeat is older than 30 s, taking its tab for frozen. The plugin sent heartbeats only from a 10 s timer, and Chrome runs the timers of a hidden page as rarely as once a minute: without Energy Saver after about a minute hidden, and at once with it. A Penpot tab hidden for a minute therefore failed that check about half the time, although it could run tasks. Chrome handles socket messages of a hidden page at once, and a frozen page cannot handle them at all. The server now sends each plugin a heartbeat request every 10 s, and the plugin answers it with a heartbeat, so the heartbeat age again tells a frozen tab from a hidden one. The plugin keeps its timer, so it still sends heartbeats to a server that does not ask. A plugin that does not know the request passes it to the plugin code, which ignores it. |
||
|
|
93d36d04d8
|
✨ Stabilize fragmented file data across snapshots and GC (#12420)
* ✨ Stabilize fragmented file data across snapshots and GC Snapshots, automatic and user, now store pointer-based rows that share fragments with the live file instead of duplicating page content. `get-file-snapshot` resolves those pointers on the server so version previews keep rendering plain data, and `restore!` reuses the shared rows. Export still materializes (the package carries no fragments) and import regenerates them. `file-gc` treats the main file and every unpurged snapshot as liveness roots, reads the file unrealized, and reattaches the original pointer wherever the cleaned value is unchanged, so a pass over an untouched file writes no fragments and a pass over an edited file keeps the ids of the pages it did not touch. Snapshot creation and the restore backup take the file row `FOR SHARE`, which serializes them with the pass and closes the race that let a new snapshot reference fragments the pass was about to mark. All backend pointer bindings go through the `fdata/with-pointers`, `with-tracked`, `with-tracked-pointers` and `with-untracked` macros. The loader reads fragments a previous pass marked until `objects-gc` purges them, and the frontend fails loudly with retry instead of dropping an unresolved fragment. Review fixes in this branch: the automatic snapshot attaches before pending migrations, `realize-pointers` is the single verb, `reattach-unchanged` takes the identity fast path, the restore guard takes its revn from the backup read, and `PointerMap.withMeta` generates a fresh id when metadata changes. Tests cover both snapshot writers (red without the lock), snapshot sharing and pin release through the real delete and purge paths, reattach against orphan marking, preview after offload, the pointer binding contracts and the with-meta id change. Closes #12410 AI-assisted-by: muse-spark-1.3-contributor AI-assisted-by: deepseek-v4.1-flash ♻️ Pin no-churn behavior for untouched pages Pin the behavior the churn verification measured: a save keeps the fragment id of every page it does not touch, with a page of eleven keys (PersistentHashMap), a 46-shape objects map and a nine-page index (hash map). Also pin the mixed case: a data-level objects-map flip rewrites the old pointer pages once and the next save keeps the new ids. The memory records the identity rule behind it: re-assoc with the same value returns the same map in array and hash maps alike. Closes #12410 AI-assisted-by: deepseek-v4.1-flash ⚡ Stop loading untouched pages when enabling objects-map `enable-objects-map` wrapped every page on every save, and reading a page's objects forced its PointerMap to load the fragment. A save of one page in a seven-page file therefore made seven fragment reads. Skip unloaded pointers: their fragment was already wrapped by the encode-file that wrote it, so loading it only to wrap it again is a no-op. The save now loads only the pages it edits. A page with a plain fragment (a data-level feature flip) keeps its plain fragment until it is first loaded or edited; a migration that enables the feature must rewrite the data itself. Cover the change with load-count tests for save and restore, update the flip test to the new contract, and drop the stale restore comment. Closes #12410 AI-assisted-by: deepseek-v4.1-flash ⚡ Keep page fragment ids through pending migrations Applying a pending migration on read realized the file, ran the migration and persisted it again; the persist wrapped every plain page in a new PointerMap, so every page got a new fragment id even when the migration did not change it. That leaves the fragment cache cold and rewrites every fragment on the first read after a deploy. Capture the original pointers before realizing, reattach the unchanged positions after migrating (same value comparison file-gc already uses), persist the reattached file and return the realized one: the read contract is plain data. Read-only connections skip the persist and the reattach. A migration that adds objects-map skips the reattach so the pages get wrapped. Move the three helpers to fdata so file-gc and the migration path share them, and cover the path with a real 0031 migration test: the unchanged page keeps its id, the changed page gets a new one, the caller gets realized data and a second read does not migrate again. Closes #12410 AI-assisted-by: deepseek-v4.1-flash * 🐛 Realize library pointers with each library's own loader Fragment rows are keyed by file id, and every caller binds the fragment loader of the file it works on. get-resolved-file-libraries returned libraries with their pages still as pointers, so the first read of a library page under fdata/pointer-map asked the consuming file for the fragment and failed with :fragment-not-found. That broke migrations and file validation for every file using a pointer-mapped library. The weak-map loader now realizes each library's pointers with the library's own id. The test fails without the change. AI-assisted-by: claude-opus-5-5 Signed-off-by: Álvaro Tejero Cantero <alvorithm@teje.ro> * 🐛 Restore the pointer-map require the repair path still needs The branch dropped `app.util.pointer-map` from the namespace while the auto-repair path (added to develop before this branch) still rebinds `pmap/*tracked*` around validation and repair in `repair-preexisting-damage` and `process-changes-and-validate`. The namespace did not compile, so the whole backend failed to load. Those toggles do not fit the fdata macros: `with-untracked` binds nil and `with-tracked` creates a fresh atom, while the repair path has to turn tracking off and restore the existing atom (and read it before the repair starts). Restore the require and keep the bindings explicit. Also pin the feature-off path with a test: with `fdata/pointer-map` off (the default), a save creates no fragments, file-gc writes nothing and the snapshot preview still returns plain data. Drop a stray `\n` char literal left at the end of one deftest. Update the memories with the exception to the macro rule, the snapshot FOR SHARE locking and the pre-migration automatic snapshot. Closes #12410 AI-assisted-by: deepseek-v4.1-flash * 🐛 Validate debug files with their own pointer loader The `/dbg/actions` file validation passed the file id where `get-resolved-file-libraries` expects the file map, so the library map was seeded with a nil key. It also validated a file read without realizing it, so the first page lookup of a pointer-mapped file raised "load is not supported when *load-fn* is not bind" and the endpoint could not validate exactly the files the feature touches. Read the file realized (validation walks every page and component anyway) and build the library map from the file. The library loader already resolves each library's pointers with its own id, so the realized file and its libraries validate as plain data. Covered by a handler-level test that fails before the change. AI-assisted-by: deepseek-v4.1-flash * ♻️ Bind the snapshot loader through the fdata helper `reduce-snapshots` hand-rolled the same `binding` that `fdata/with-pointers` builds (it also loaded the function's own pointer loader before entering the reduction). Use the macro so the rule holds there too and the namespace no longer needs `app.util.pointer-map`; the loader is identical (same cfg and file-id) and snapshot walking behaves the same. AI-assisted-by: deepseek-v4.1-flash * 📚 Note the pointer-binding exceptions and snapshot ordering Record what the feature review settled: - Two direct `binding`s stay on purpose: the fine-grained `*tracked*` toggles of `app.rpc.commands.files-update` (validation/repair turn tracking off and restore the existing atom) and `binfile.common/encode-file` (fresh tracked set inheriting the current one). Atom-scoped macros would only be worth it if the set grows. - The automatic snapshot is taken before the pending migration, and the pre-migration window is narrow: the `get-file` RPC migrates on read and its ETag hashes the available migrations, so a post-deploy read cannot be a 304 from the pre-deploy state. The old-format snapshot only appears when the save is the first request to touch the file after the deploy, and `get-file-snapshot` previews it as stored. AI-assisted-by: deepseek-v4.1-flash * 🐛 Apply pending migrations when previewing a version Automatic snapshots are attached before the save applies pending file migrations, so a version can store the old format. The preview RPC handed that data to the UI as stored, and the viewport renders it with the current code. Realize the snapshot with the live file id (fragments are keyed by file, not by snapshot), normalize its migrations to a set (the decoder keeps the pgarray as a vector, and `set/difference` would compare indexes) and apply the pending migrations with the pure `fmg/migrate-file` and the live libraries. Nothing is persisted: the stored version keeps its data and restoring it re-migrates on the next read. The response now carries the snapshot's migrations. Use `:features` the way `get-file` does for `fdata/objects-map`: a client that does not declare it gets plain objects. The historical feature set is not checked against the enabled one on purpose: a version may predate a feature change. Cover the preview of a snapshot with a pending migration and the objects realization; both pin that the stored row is untouched. Update the file-data memory with the preview contract and the vector/set trap. AI-assisted-by: deepseek-v4.1-flash * 🐛 Decode snapshot migrations as an ordered set `file-snapshots/decode-snapshot` handed the `file_change.migrations` pgarray as a vector. `set/difference` falls back to index lookups when the first collection is shorter than the second, so the pending set was right only by accident: a stored subset happens to work, while a stored set larger than `available-migrations` (a snapshot taken by a newer build) marks every available migration as pending and re-applies it to already migrated data. Decode it as a `d/ordered-set`, the type the rest of the code and `schema:file` expect. This also covers `restore!` and the snapshot list, and it lets `get-file-snapshot` drop the `(into #{} ...)` normalization it was carrying. Re-wrap the union in `fmg/migrate` so the invariant holds even when a caller hands a plain set. A snapshot with NULL `migrations` predates SQL migration 0140 and keeps the format version of its time. Pin that legacy path: the preview regenerates the applied set from that version, migrates in memory and leaves the stored row untouched. Update the file-data memory with the invariant and the legacy path. AI-assisted-by: deepseek-v4.1-flash * 🐛 Fix flaky waiting-gauge assertion in climit test The throwable-while-waiting test asserted the exact list of waiting-gauge publications, but the component sampler republishes the same count when its first tick lands inside the recorded window under load. Assert only the last value, which is the contract the helper documents. AI-assisted-by: muse-spark-1.3 --------- Signed-off-by: Álvaro Tejero Cantero <alvorithm@teje.ro> Co-authored-by: Álvaro Tejero Cantero <alvorithm@teje.ro> |
||
|
|
29373fff9f
|
✨ Rework the progress of the import and export dialogs (#12192)
* ✨ Rework the import dialog The import wizard paints a Check/Upload/Import stepper derived from the dialog status, plus a phase title, a description and a progress bar per phase, and its rows follow the new design: folder icon, file name and a size subtitle. While checking, the dialog shows no rows and no spinner, because the phase header already carries the message. The wizard writes the job milestone once, in the header (`jp/current-milestone-text`), since every file of a container reports the same one. A row keeps its name and its size, says "Ready" once its container finished uploading, and shows the error text when it fails; the button that drops a file only appears while the wizard still offers its import step. The `jobs.queued` label now reads "Waiting job slot". The bar measures the whole import: determinate while the containers are uploaded, weighted by their size (`imp/upload-pct`), and animated otherwise, because the stages of a job are not comparable. The phase title counts the files, and `imp/imported-count` counts them done with the job's own counter, so the number moves while a container rebuilds its files one by one. The analysis reads the entries of a version 3 package in one pass: a file shows what it occupies inside its container, its own entries plus the storage objects its media and thumbnails reference, while what the container weighs stays in `:container-size`, the size the upload bar is weighed on. The ready step waits for the end of the analysis (`imp/ready-to-import?`), not for every known file, so Continue never leaves out the files that arrive later. Tests cover the file sizes, the upload percentage, the done counter, the wizard step and the milestone in course. The change also adds `-XX:NativeMemoryTracking=summary` to the backend devenv so `jcmd` shows native memory, and documents the wizard, the promise call styles (`mem:clojure/promesa`) and two CSS pitfalls: a logical `inline-size` wins over an inline physical `width`, and Rumext leaves a plain `:style` map raw, so inline styles leave CLJS as `#js` objects. AI-assisted-by: glm-5.3-flash AI-assisted-by: deepseek-v4.1-flash * ✨ Rework the export dialog Every exported file is its own job, so each row reports its own state: folder icon, name and a size-plus-`.penpot` subtitle; waiting for a worker; running with the milestone of the job and an animated bar; or exported with a tick. A failed row paints red, takes the close icon and shows the hint of the job, or a generic label, through `files-export-modal.export-error`. Success, failure and cancellation replace each other, so a row never reports two outcomes at once. The ids of the messages are canonicalized to string before they match a row, because they cross serialization boundaries. The export result now carries `:size`, so the subtitle says the format until the job produces the artifact and the size once it exists; a transport failure builds a synthetic error, so a nil `ex-data` no longer leaves the row hanging. The header counts the files and says whether the export runs or ended; since every file has its own job, it paints no global bar. Closing changes too: the Close button is gone. While files are in flight the footer offers Cancel export and the X cancels as well, which marks the loading rows cancelled and leaves them in place, so their outcome can be read; once every row reached a terminal state the footer offers Done, which dismisses the dialog. The retry button of the finished design is left out, because the client has no retry mechanism yet. Styles come along: the rows scroll while the header and the footer stay put, and the new phase header, row and bar follow the tokens of the import wizard. The title key becomes `files-export-modal.title`, and the new keys cover the header, the row states and the buttons. AI-assisted-by: muse-spark-1.3 * ♻️ Inline the binfile job adapters into their task handlers The wrappers in app.binfile.jobs only forwarded to the core, so each task handler now composes its own run: frozen cfg, active check, progress bridge and format dispatch. export-cfg freezes the whole export (file-ids, export-type, output) and v3/export-files! takes it as its single argument; ::bfc/ids becomes ::bfc/file-ids. The bridge keeps one job: bfj/run forwards the cfg to its callback, and check-active answers with it to thread the run. AI-assisted-by: muse-spark-1.3 * 🐛 Migrate binfile tests to the single-arg export-files! The refactor made v3/export-files! take a single cfg carrying ::bfc/file-ids and ::bfc/output, but six calls in binfile_test (added by the tokens handling change) still used the old two-arg form with ::bfc/ids. Move them to the new form, as the rest of the file already does. AI-assisted-by: muse-spark-1.3 * 🐛 Fix export artifact expectations to include file size The export flow now reports the artifact size, but the stale expectations dropped it and failed the frontend suite. Include the size in both assertions so they match the emitted message. AI-assisted-by: muse-spark-1.3-contributor * 🐛 Migrate remaining export-files! test callers to the single-arg form rpc_binfile_test and offload_file_data_test still passed the output apart and used ::bfc/ids; move both into the cfg as ::bfc/file-ids/::bfc/output. * 🐛 Hide the downloads hint when no file was exported After Cancel or when every job failed, the export header said "0 files exported · Check your downloads folder."; drop the hint then. * ♻️ Read the object of a container entry once The index of a container asked twice for the object of the same zip entry: once to test it and once as the key of the update. Resolve it once, in the branch that owns it, so the entries of a file never pay for a question that does not apply to them. Addresses a review note on #12192. AI-assisted-by: deepseek-v4.1-flash * ♻️ Never size an import row with its container's weight A row of a version 3 package took the size of the container whenever the container held no entry for its file, while the comment beside it promised the opposite. An unknown size now stays nil, which the row already understands: it paints no subtitle instead of a number that belongs to the whole package. The test carries a file the manifest lists and the container does not hold, and the memory records what the row does then. Addresses a review note on #12192. AI-assisted-by: deepseek-v4.1-flash * 🐛 Retry pool stats read until snapshot is consistent Hikari exposes each pool counter through a separate MXBean call, so a borrow or return between the reads can leave one snapshot off by one. The test read once and failed in CI with total 2 vs active + idle 3. Read up to 20 times with a 10ms pause until total equals active + idle, then assert on the stable snapshot. The invariant stays strict; only the transient race is tolerated. AI-assisted-by: muse-spark-1.3-contributor --------- Co-authored-by: Elena Torro <elenatorro@gmail.com> |