Repository navigation
Conversation
Review or Edit in CodeSandboxOpen the branch in Web Editor • VS Code • Insiders |
|
|
The latest updates on your projects. Learn more about Vercel for GitHub. |
…output Both diff panel rounds on task t_20f6ff0d found that the paired timing harness judged a candidate's timing even when its rows reported another document than base's, so a broken fix could pass on speed alone. A row may now give an `output`, such as a document hash. Once any row of a cohort gives one, every row of that cohort in every arm must give the same, or measuring and analyzing stop with exit 2. The benchmark rule says so too. This settles task t_5a9fc7f2. Beyond the ask: none Picks: none Not checked: none Session: local_07b9f7e4-a84f-4b59-9714-c5ef6db87f5b Lead: claude-opus-5-5 @xHigh
The final parse of a streamed Markdown answer, `parseSlice` with `previous` and no `partial`, reused the preview's segments, and each segment ran the remark plugins on its own root. A plugin that reads the whole tree, such as one that numbers, joins or splits blocks, then gave the saved answer another document than a fresh parse of the same text. AI chat inserts that result. A parse without `partial` now converts the whole source once. It keeps the preview's block objects in place of that parse's first blocks when the result equals the whole parse up to list ids, so AI chat still publishes only the blocks that changed. Otherwise it returns the whole parse. Previews still reuse segments. On the 10 KB rich answer the final parse used 0.766 times the main-thread CPU of the old final parse plus one fresh parse, and added 10.3 ms over the old final parse alone, against the plan's limits of 1.5 and 20 ms. Introduced-by: a5d0701 Beyond the ask: the every-prefix continuation case no longer checks the strict parse, which now equals a fresh parse by construction; three new cases over whole-tree plugins check it instead Picks: no separate case for kept block objects, because two existing cases check them; "add reuse case" reverses it Not checked: a browser or the AI chat surface; a remark plugin that ships in another package; the Markdown docs say only the text after completed blocks converts again until step 3 lands Session: local_8d5979a3-9f58-4b1a-9856-047d5eae02ac Plan: docs/plans/2026-11-14-conversion-boundary-next-step.md Lead: claude-opus-5-5 @xHigh
This ports two package fixes from main's plate#5120 that next lacked. The Markdown writer wrote a link whose text is its URL as bare text whenever the URL started with http or https. A URL that held markup, such as https://example.com/a<img src=x onerror=alert(1)>, wrote that tag into the Markdown as raw HTML (GHSA-vjm2), and a URL that held a space split its link in two. The writer now writes such a link as bare text only when its URL holds no whitespace, <, > or backslash, and as a Markdown link otherwise. It also writes a bare URL in angle brackets when GFM would not link it in bare text, such as https://[::1]/docs, which next read back as plain text. `plate deps` passed each dependency name to `npm view` with no `--` before it, so a name that starts with `-` read as an npm option (GHSA-q8r4). It now passes `--` first. Introduced-by: da70467 Introduced-by: c8ca821 Beyond the ask: none Picks: none Not checked: no test covers the CLI's npm call; a run of plate deps with a stand-in npm recorded its arguments before and after the fix Plan: docs/plans/2026-11-16-main-sync-backlog.md Session: local_336f62b8-9a8b-4c08-a3de-041794cc08ad Lead: claude-opus-5-5 @xHigh
… landing
Landings waited in line for cores and ran every check their files reached, up to 10 minutes of package tests and formal checks, and a landing that only added a plan reran every formal check.
- check.mjs no longer counts an added Markdown or TSV file as a path an import could newly resolve to, so a plan-only landing runs no formal check.
- land.mjs, proof.mjs and rules/time.md sync from udecode/dotai: a landing and its check never wait in the core pool, whatever the cores and memory, and hold one core so the proofs that queue see their load. The pool counts a nested holder's workers once, and a small proof that fits now enters past a larger waiter younger than 5 minutes.
- pnpm check --affected runs only the steps marked land: typecheck, the fast test files and thirteen checks that take 2 seconds or less. land.mjs still lints the changed files. The new --deep runs every step with the --build --browser steps.
- pnpm test:fast leaves out the test files TEST_SLOW_FILE_PATTERNS names, and the new test-slow step runs only those with pnpm test:slow.
- check.mjs logs each selected step to plate-check-steps.jsonl, which check-steps.mjs summarizes.
- deep-check.mjs runs the deep lane on the newest origin/next from a launchd job, reruns a red step alone, searches for its first bad commit, offers a P1 task and posts to the dev role. The deep-check skill installs it and runs the watcher that starts the plate-fix-red scheduled task.
Team: landings no longer wait in line for cores and run only typecheck, the fast tests and the quickest checks. Slow tests, package tests, formal checks and the whole-repo lint run on one Mac after each landing, which posts here when one breaks, with the commit that broke it. Ask Claude for the deep check status to see whether next is green.
Beyond the ask: the retarget fix in check.mjs, found while this plan's own landing ran 27 minutes
Picks: one landing for the whole build ("full"); only fast checks before landing ("test before landing"); landings never wait, even on low memory ("landings wait on memory"); fix run on Opus 5.5 at xhigh ("fix at high"); old daily task off at install ("keep the daily task")
Not checked: the launchd job, the watcher and the dry fix run start after this lands, because they run the main checkout's copy; the no-wait outcome needs a day of landings
Shipped fast, no review.
Session: local_33292353-57c9-4f45-a26e-6a47953c2b63
Plan: docs/plans/2026-11-16-deep-check-lane.md
Lead: claude-opus-5-5 @high
The Markdown page said a parse with `previous` converts only the text after the blocks it keeps. Since e2533d6 that holds for `partial` parses alone. The Streaming previews section now says a `partial` parse converts only the new text, so a remark plugin that reads the whole tree can make a preview differ from a fresh parse, and that a parse without `partial` converts the whole source once and matches a fresh parse apart from list ids. The Chinese page says the same, and the unreleased platejs changeset's streaming bullet says it too. Beyond the ask: the Chinese paragraph wraps only where the source has a space, which removes a stray space the page showed between two Chinese characters Picks: amend the unreleased markdown-plite-runtime changeset instead of adding one Not checked: lint, whose config ignores MDX and changeset files Session: local_8d5979a3-9f58-4b1a-9856-047d5eae02ac Plan: docs/plans/2026-11-14-conversion-boundary-next-step.md Lead: claude-opus-5-5 @xHigh
… file
A landing ran every fast test file whenever it touched code, 468 seconds on landing 8, and a hand-kept list decided which files were slow.
- pnpm check --affected gives the test step the fast test files whose imports load a changed file, from the clone's stored import graph. A deleted file, or a changed file no import reaches, such as a fixture, still runs every fast test file. A test that loads a file through a computed path is missed, and the deep lane's full run catches it.
- test-suite.mjs records each file's summed test case time from every run in plate-test-times.json in the git common directory. pnpm test:fast leaves out the files last timed at 2 seconds or more and pnpm test:slow runs only those, so TEST_SLOW_FILE_PATTERNS is gone.
Team: a landing now runs only the tests that load the code it changes, and tests that take over 2 seconds run after landing instead.
Beyond the ask: none
Picks: tests by import graph ("run every fast test"); slow at 2 seconds per file from recorded times ("keep a slow list")
Not checked: the time record fills in from the deep lane's first full run; until then only the 20 files from today's profile count as slow
Shipped fast, no review.
Session: local_33292353-57c9-4f45-a26e-6a47953c2b63
Plan: docs/plans/2026-11-16-deep-check-lane.md
Lead: claude-opus-5-5 @high
On next, `pnpm check:undo-redo-history --peer-inserts` compared 119,406 cases against its pin of 119,206. The gate stops a list at its first failure and counts it as no case. History fixes since 92afc5fe took the baseline stopped 156 lists from dropping a step, 5 from throwing and 2 from reporting a failed undo. Those lists and the longer lists that grow from them now run, which adds the 200 cases, so the pin now reads 119,406. The gate still fails 14 lists that its baseline does not hold, because the baseline never grows. Nine follow a lift written as a value diff and a teammate update, also written as a value diff, that adds a paragraph beside the lifted line and edits that line. Their undo or redo carries the paragraph with the line, or throws when the paragraph is a box. Four follow a two-line paste in a quote and a delete or type-over from the second pasted line through the next line, and their undo drops the teammate's paragraph. One undoes a type-over after a teammate value diff that adds a paragraph and deletes the typed letter, and it loses the user's lines. While those 14 are missing from the baseline, the lower option refuses to write, so the 163 entries that next no longer fails stay listed. A fix for the 14 waits on the owner's choice of design. Beyond the ask: none Picks: none Not checked: none Session: local_fb07da71-aed4-4b5c-a9d7-60ffbe0e5e02 Lead: claude-opus-5-5 @xHigh
The note, shape and frame tools now place what you drag. A click places the tool's default size centered on the click, and a drag places the dragged box, over empty board or over another shape, with the picked outline shown while you drag. Shift keeps a square and Alt centers the box on the press point. On a selected shape's corner handles, Shift keeps the shape's proportions and Alt resizes it around its center, and the keyboard resize works as before. The docs pointer tables in English and Chinese and the board's pending release note say the same. Team: On the board demo and the board docs page, the note, shape and frame tools now draw the size you drag and show the picked outline while you drag, even when the drag starts on another shape. Hold Shift for a square or circle, and Alt to grow it from where you pressed. A click still drops the default size, now centered on the click. Beyond the ask: the geo schema default and the preview read one internal default kind; the docs row on Alt-drag copies now says it needs the select tool Picks: the board package draws the preview outline, not the copied UI (word: preview from the board UI); Shift or Alt pressed mid-drag redraws at once (word: keys wait); no design bakeoff, because the frame tool already worked this way (word: architect) Not checked: Alt held during a real mouse drag in a browser, because the hand drive sent Shift and Alt on dispatched pointer events and the www case holds only Shift; touch and pen drags; Safari itself. The docs page toolbar case still fails in Chromium, as it did before this change Plan: docs/plans/2026-11-16-board-drag-size.md Session: local_8df67876-1974-4b77-94b8-5fbc5ae12dfd Lead: claude-opus-5-5 @xHigh
…its its line A word composed with an input method showed part of its line twice, or disappeared in plain text editors, when bold, a collaborator or an app split, joined or removed the line's text pieces before the word was confirmed. The browser owns the composing text's DOM, and the renderer redrew the line's other pieces around it. The composition lease now holds the whole line from a collapsed grant until the word commits. The line keeps the pieces it drew, a held piece whose key left the model keeps its last binding, each text host and text flow root the line drew at the grant waits on the lease, and settle redraws the line when a piece it held left the model. While the line is held, a piece's node key is the only source of its path, so a DOM point or a WebKit commit in a piece another edit removed reads no model point. Every element binds at its key's live path. Four cases still draw as before: a block split inside the composing text, a composition over an expanded selection, a text flow split that moves the line's last piece out, and a join of the composing line onto the block before it. A text flow decoration that changes during a composition still paints only at the line's next draw when the lease releases without a commit. At 200 blocks a typed letter renders the same elements as before. Binding at the key's live path reads 4 to 16 more identity pages per typed letter, against 154 to 2,345 before. Introduced-by: a5d0701 Beyond the ask: the internal node ref hook no longer takes a path from its render; EDIT-IME-LINE-HOLD-001 records the conflict rule; the native subject records the decision; the 2026-10-26 composition commit plan closes, and its manual input method test moves to plate-private#145. Picks: the line keeps drawing what it drew until the word is confirmed (redraw around); the old composition commit plan closes (reopen commit plan); a text flow decoration at a release stays a limit (paint text flow); render and DOM work counts check the speed cost (time it). Not checked: a real macOS or Windows input method; Safari itself, only Playwright WebKit; whether the change slows view-caret-work's 16-view case, which times out under full-suite load here and at the base too (t_ff04fcfa); no bisect pinned the first bad commit, so Introduced-by names the commit that landed the per-host write deferral. Source: t_54e7b1d8 Plan: docs/plans/2026-11-16-native-next-step.md Session: local_407cd3c0-25d2-4bc7-81de-a49fe79c1c88 Lead: claude-opus-5-5 @xHigh
This ports main's fix for GHSA-2q2r from plate#5120, which next lacked. The copied AI command and copilot routes fell back to the server's AI_GATEWAY_API_KEY when a request sent no key, so anyone who could reach a route spent the app's key. They now use only the key the caller sends as apiKey, trimmed, and answer 401 without one. The command route checks the key before it reads the editor content. The docs site calls those routes only when the visitor sends a key, and answers from its canned demo otherwise. The AI and copilot docs, in English and Chinese, stop teaching the server key fallback and say how to use a shared key safely. GHSA-r3c4 needs no port. next's image schema refuses every image URL that main's download check refuses when a document loads, so the preview dialog never gets one. The main sync ledger marks plate#5120 synced. Introduced-by: cee8941 Introduced-by: 791abbf Introduced-by: e77b212 Beyond the ask: none Picks: the docs site AI demo answers a visitor without a key from its canned demo, not the site's server key (site server key); the media preview dialog keeps its download code, because the image schema already refuses the URLs main's check refuses (port media download) Not checked: the docs site AI demo in a browser; the route tests drive both paths with a mocked gateway Plan: docs/plans/2026-11-16-main-sync-backlog.md Session: local_336f62b8-9a8b-4c08-a3de-041794cc08ad Lead: claude-opus-5-5 @xHigh
The Verdict playbook's audit pass skips a due scope whose review topic already holds an open decide task. review-ledger.mjs due did not mark those scopes, so each audit session searched the suggested-task ledger by hand. due now reads that ledger, from the main checkout in trunk delivery, and gives each item a task wait for every offered or started decide task in its topic. On today's ledger, 10 of 57 due scopes wait this way. Source: workflow friction from the run of t_54e7b1d8. Beyond the ask: none Picks: none Not checked: none Session: local_407cd3c0-25d2-4bc7-81de-a49fe79c1c88 Lead: claude-opus-5-5 @xHigh
plate-private#142: in v53, Potion set the block selection area to its page
scroller and marked its cover, so a drag from the cover or from the blank
space around the editor selected blocks. NodeSelectionDrag started a drag
only on the editable itself, so that drag did nothing after the v54 port.
NodeSelectionDrag takes an optional `container` element. A mouse or pen
drag then also starts on the container's own blank space and on each
element inside it that carries `data-node-selection-start`. v53 named that
mark `data-plate-selectable`, and the lint rule for brand names refuses it.
Only the pressed element counts, so a child of a marked element starts
nothing, and the value `false` turns off a mark or the container's own
space. The component holds no list of controls. A button, a link or a page
widget is a different pressed element, so it keeps its own clicks and
drags.
A press on a start area stays with the page until the pointer has moved 4
pixels and one more move or the release has arrived, so a click still
reaches the page, and the page can refuse the drag by canceling the press
or that first 4 pixel move. Escape before the drag starts drops the press.
While a press waits, the component cancels the browser's own drag of a
marked element, such as an image, unless the page refused the press. A touch, a press
on editable content and a press on a scrollbar start nothing. The rectangle of such a drag clips to
the container's visible area and keeps its size under a CSS scale. Without
`container` nothing changes.
Team: A block drag can start from the page around an editor, such as its
cover or margins, once the page hands the editor its scroll area and marks
those areas. Potion needs a follow-up that passes that area through its
copied Editor, renames its two marks and marks its cover image, so
plate-private#142 cannot be retested in Potion yet.
Beyond the ask: a /dev/node-selection-container page and a browser
regression spec that drag from a margin, a cover, a cover image and a page
title on Chromium, Firefox and WebKit; a react topic entry for the prop
and its mark; the drag rectangle keeps its size on a page that a CSS
transform scales.
Picks: the owner chose v53's marked-area rule after two designs that let
any press in the container start a drag failed review; the mark is named
`data-node-selection-start`, not v53's `data-plate-selectable`, which the
brand lint rule refuses ("old name"); the container's own blank
space starts a drag without a mark ("mark only"); the copied Editor gets
no pass-through in this change ("editor prop"); a drag on a marked image
selects blocks ("image drag"); `container` takes an element, not a ref
("ref"); the earlier design's code was changed in place ("revert"); the
run passed its three hour appetite and kept going ("cut"); the owner's
"fast" skipped a second review of the first review's fixes ("full").
Not checked: Safari, a real touch screen, a pen and a classic scrollbar in
Firefox; a marked element inside a shadow root, which starts nothing;
Potion, whose copied Editor does not pass `container` yet.
Shipped fast, no review.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Session: local_7eb8defd-db5e-4ab8-99e1-35b2eab2a43a
Plan: docs/plans/2026-11-16-node-selection-start-areas.md
Lead: claude-opus-5-5 @high
A saved pen mark now knows where to draw after its paragraph changes. placeMark draws the mark over the words its stroke touched when those words still sit on the lines under it. It shows a sign beside the block when the block's text changed, or when the stroke now reaches a word no run of the mark holds, by more than half a pixel. read.place gives each saved block copy its place: the block when it still stands, else the gap the block left. A gone record saves that gap as the ids of the nearest blocks after and before it, in the same update as the delete, so a reload and a Yjs peer read the same place. Plite's transaction change gains changed.removed(root?). It lists each node one step removed, with the gap the node left in the step's result, and builds no index. Ink's change hook reads it at each step, so a block moved and then deleted in one update, a block merged into the one before it and a deleted container's children keep their place. An update hands the blocks it deleted to add's lookback only after it commits, in the order the updates began, so an update that throws hands on nothing and one that a commit listener runs counts as the later one. Plan: docs/plans/2026-11-15-ink-draw-tool.md Plan: docs/plans/2026-11-16-ink-gone-records.md Source: t_9fd8d1e4 Beyond the ask: Plite's public changed.removed(), which the gone-record writer needed and any plugin that tracks blocks can read Picks: changed.removed() is public Plite API (removed internal); a deleted block that no mark names gets no gone record (every gone); a marked block deleted with listeners off, such as Backspace in Editing while a suggestion is pending, keeps its sign at the top of the page (notify recorded); a block that keeps its key under a new id in a step that adds or removes blocks, as replaceChildren with preserveKeys does, keeps its sign at the top of the page (kept keys) Not checked: placeMark against a browser's real line boxes, which step 6's block measurer brings; marks at 5000 per document, which step 8 times Session: local_d1c47c29-4e87-48b6-ac85-77036f26501b Lead: claude-opus-5-5 @xHigh
…ption
Step 11 of the peer undo plan. An undo can keep a teammate's edit only
when every commit says what it did to each node it split, joined or
moved. A paste, a Yjs import of typing and the close a split writes said
nothing a crossing could place. This step makes every command record its
commit behind the internal option `historyFollowsAllFacts`, which stays
off until step 17.
With the option on, a split marks the close it writes with a cut and a
join marks the close it drops with a mend, and composing the commands of
one update keeps both. A lift keeps today's change and holds its cut. A
paste records an heir for each line or element it splits and a merge for
each join, and commits unknown facts when it splits an element into one
of another type, such as a quote that takes the end of a line. A Yjs
import that only types commits recorded facts. A whole value set, a
transfer's landing and a Yjs import that splits, joins, moves or diffs
values commit unknown facts. With the option off, every writer commits
what it commits today.
The gate gains `--all-facts`, which turns the option on in every worker
and faults a raw change or a reshaping import that claims facts. With
the option on, the test oracle and model read the gap rule step 12
builds into `crossRecord` on every row of the close-ownership table,
each element's type and properties included. With the option on, the
default gate's commits that claim facts rise from 23,242 to 49,256 and
its unknown ones fall from 72,311 to 45,733, while every mode's change
digest equals the base's. The history check's coverage record moves its
sync to this commit.
Beyond the ask: none.
Picks: a lift keeps today's change and marks the close its split writes
as a cut ("lift moves" records a move with a carry instead, which
changed today's result in 30 gate lists); phase 2 builds behind an
internal option that stays off until step 17 ("no switch" ships each
step as it lands).
Not checked: no history path reads cuts or mends yet, so whether they
place a teammate's edit waits for steps 12 and 13. The oracle and the
model agree only on the close-ownership rows. Off them, the model
misplaces an heir's lines in two cases that fail the same way on the
base, and the oracle gives two documents for one change and its facts
in three shapes; step 12 replaces the model and fixes the oracle. The
`--peer-inserts` gate exits 1 on its case-count pin, 119,406 against
119,206, as it does on the base. Proofs ran with
BUN_RUNTIME_TRANSPILER_CACHE_PATH=0, because this machine's Bun
transpiler cache served stale modules.
Plan: docs/plans/2026-11-12-history-peer-undo.md
Session: local_bcaed78d-21c4-4725-9b5d-6452dc650428
Lead: claude-opus-5-5 @xHigh
A plugin's transactionChange handler can ask changed.removed() which nodes one step took out of a root, each with the gap it left, and no page said so. The document change pages, Plate's and Plite's, gain a Removed nodes section with a working plugin, what counts as removed, what node and path hold, and where a whole commit's answer lives instead. The Chinese twin gains the same facts in one paragraph, and the transactions subject records the call shape. Beyond the ask: none Picks: the plan that rebuilt ink's gone records stays open and folds into the ink subject with the main ink plan's close, reversed by "fold now" Not checked: none Session: local_d1c47c29-4e87-48b6-ac85-77036f26501b Plan: docs/plans/2026-11-16-ink-gone-records.md Lead: claude-opus-5-5 @xHigh
…ther block Typing, Backspace, Delete or Enter over a selection from the start of a filled required title into a paragraph that another block follows threw, and the keystroke was lost. The range removal leaves the title as a new object, and the join that keeps an empty prefix occupant compared it by object, so it refused and completion failed. The join now matches the occupant by its node key at the start of the update, so the title keeps its place and takes the text after the selection, as ProseMirror does. A selection into the last body block still throws, because that join would leave a body block to build; the required title join build plan owns it. Typing over a selection that ends right before a read-only inline now lands the letter before the inline instead of inside it, and a join out of a quote whose paragraph holds a link or another inline now removes the emptied quote. The range check reached both once a range from the title could, and its baselines drop the 522 findings the three fixes remove. Introduced-by: fc2cb1f Introduced-by: da70467 Introduced-by: a9919f4 Beyond the ask: none Picks: step 1 lands the node-key check alone and the two-block join waits for its own plan (land together); the run goes on to that plan instead of cutting the two-block join (cut two-block join). Not checked: no browser drove a range edit, which step 2's Chromium case covers; the docs schema's platejs cases wait for step 2; the full plitejs suite ran only through land's affected check, beside the 42 join and range files. Plan: docs/plans/2026-11-14-editing-next-step.md Session: local_f4af7fe1-4fdb-4c34-a6ba-69cbbd66de3e Lead: claude-opus-5-5 @xHigh
A tab used to rebase each saved batch over the room's new changes and send it, so a merge that lost a teammate's letter, or left the document with no paragraph, reached the room or stopped the tab. Now the tab judges each saved batch with the effect ledger at the head it installed, before it sends the batch, and keeps on the device every batch it may not send.
- `dispositionOf` turns a verdict into send or keep. Held is sent. Contested is sent when the tab saved the batch while joined and caught up, and kept when it saved the batch offline. When the tab goes offline, or a teammate's entry crosses the batch, while it hashes the batch or saves it as sent, the batch goes back to the judge, so a batch that became contested over an offline stretch is kept. A batch the device saved as sent keeps its origin, so the tab can judge it again, and the tab hands the frame to the room before any listener hears that the batch was sent. A client closed during that save leaves the batch for the next client to judge. Lost, unjudged, a rebase conflict and a rebased batch the editor refuses are kept. The room's gap path refuses through the same function, and `SYNC_RULES` moves to 3, so a room and a tab of different builds refuse each other.
- A saved batch records its origin, the base, change and accepted list it was first rebased from. The tab judges it from there within 8,000 base tokens a change, the room's window, and a batch past that reads unjudged and stays. The judge now finds a new letter's base neighbors in one pass over its line, so eight teammate pastes of 1,999 letters into one line take 0.6 s to judge instead of 6 to 7 s. Its other scans and its pairing tables stay quadratic in the number of letters one change writes into a line until C.14, so a paste of thousands of letters stalls the tab for seconds when an entry crosses it, as it stalls the room.
- A kept batch leaves the live chain through its own inverse, above the confirmed copy, so it never takes back a teammate's write, and each later batch rebases over that inverse and goes to the judge again. A kept batch stays on the device in the `kept` state with the reason `judged` or `invalid`, and the tab keeps syncing.
- When the editor refuses the whole rebase, the tab retries it batch by batch and keeps only the batches the editor refuses.
- A tab opens in its editor only the oldest outbox it claims. When the editor cannot show it, or it stopped as `invalid`, the tab opens a new outbox and adopts every claimed one, so no later tab on the device fails on it and the healthy ones still send.
- The effect ledger reads lost a merge that leaves a root with no block where each side kept one, such as two tabs that each delete another of two empty lines.
Beyond the ask: the check runners and plitejs's `test:bun` turn off Bun's runtime transpiler cache, which reused a plain run's transpile without the test globals and failed with `describe is not defined`. The test client stops waiting for a frame once nothing is left to send. The sync drive takes `--jobs=<n>` and splits its runs across that many processes, so its 3,000 runs fit the hour on a loaded machine.
Picks: a tab judges every batch within the room's window and puts no limit on the letters a change writes, so a teammate's deletion of more than about 8,000 letters keeps the offline batches it crosses, and a big paste stalls the tab until C.14 ("letter cap" reverses it); a kept batch's inverse takes back its review contexts too, because the room never held them ("send kept contexts" reverses it).
Not checked: the stress lane and the three browsers, which C.18 runs; recovery of kept work, which C.7 builds; the effect ledger's full lanes, which suggested task t_6f900662 records.
Plan: docs/plans/2026-11-06-native-sync.md
Session: local_6c06a7e5-a83d-4f25-b4cb-e90a424397cb
Lead: unknown
The board-scale lane gains K3, which times the keys that phase 3 of the board keyboard plan added, in Chromium at 50, 1,000 and 4,000 shapes. It times an arrow key moving a connect's end, an arrow key during an S resize, Tab moving the picking cursor and Space picking a shape, each against its own time at 50 shapes. It also times the selection's Tab, the selection's Mod with an arrow and the connect's Tab against the same keys before phase 3. Each key reads its result and its words back on the page. The lane counts every render of a shape that was mounted when the key started. An end key re-renders at most the old and the new aim, a resize key and Enter's resize write no more shapes than a corner drag does, a picking key at most the shapes whose state it changes, and Enter drawing an arrow to a free point no more than the pointer drawing it. The resize keys act on a note with one bound arrow at every size, so each size redraws one arrow. Each planted slowdown and each planted re-render fails its own line, and every size reaches the log before a line fails. Every K3 render line passes. At 4,000 shapes the end key takes 1.11 times its 50-shape time and the resize key 1.10, against a budget of 1.32. Picking's Tab takes 1.11 times, and Space 1.19 against 1.525. The selection keys and the connect's Tab take at most 1.06 times their time before phase 3, against 1.2. K2 still passes, and so do the checks of the work and time a typed key costs and of a frame drag's preview. This is step 20 of the board keyboard plan, card t_f901520f. Beyond the ask: the lane's readback now checks each page against the arm, build and cohort the driver asked for, instead of against the page's own reading of its address, so a page that drops a parameter fails in every lane instead of timing a default. Picks: none. Not checked: Firefox and WebKit; Space's growth at 1,000 shapes and the first typed key's time at 1,000 shapes stayed undecided, with no slowdown showing, because the host was too noisy for their planted slowdowns to clear their budgets; a slowdown on only some presses, because the lines time the median. Session: local_73bde20e-f8a0-41d8-a2b5-e0584e3ff821 Plan: docs/plans/2026-11-13-board-keyboard-verdict.md Lead: claude-opus-5-5 @xHigh
The board's pen outline and the pressure it simulates for a mouse or finger line move out of the board into one internal module, so pen markup can draw its strokes with the same code. The module takes the pen's size and thinning from its caller, so the board keeps its own width and thinning and pen markup passes its brush size. The board draws as before, and its pen specs pass unchanged. Beyond the ask: none Picks: the shared outline takes the pen's thinning as well as its size, so the board's thinning stays one constant beside its hit radius, reversed by "fixed thinning" Not checked: none Session: local_d1c47c29-4e87-48b6-ac85-77036f26501b Plan: docs/plans/2026-11-15-ink-draw-tool.md Lead: claude-opus-5-5 @xHigh
plate-private#139: `extractLegacyCommentRanges` returned plain ranges that
pointed into the v53 document, so an app had to run one live editor per
document to land them on the migrated one, and a comment across a mention
came back as two groups.
`migrateDocument` now takes a `ranges` record keyed by thread ID and returns
`result.ranges`. Every range maps through each step and the final fit onto
the same words, with no editor. A step that changes the document maps its
ranges through the `mapRanges` it returns; without one every range comes
back `null`, so no range lands on another block's words, and a step that
returns its document unchanged keeps them all. `migrateV54` maps ranges
through its inputs, URL and code block stages, and `migrateListIdentity`
returns each range unchanged. A
range comes back `null` when the text it covered is gone or changed, when it
collapses, or when the saved entry is not a range in the primary root, and
the document still migrates. The migration's fit no longer keeps an inline
spacer for a saved selection, so the document is the same with or without a
selection or ranges.
`extractLegacyCommentRanges` returns `{ document, ranges, report }`. Empty
texts, voids and inline element edges no longer split a thread. A thread
split by visible unmarked text gets no range and a `split-group` row that
lists each part's range. A comment mark in a media caption or in text a void
hides is removed, and every mark removed from a caption gets a report row.
`comments` and `diagnostics` are removed.
Beyond the ask: the migration's fit protects no inline spacer for a saved
selection; the fit's selection mapping aligns text exactly, so a selection
between two far-apart changes keeps its words.
Picks: a saved range that no longer fits its document comes back null and
the document still migrates ("throw on stale ranges"); a thread split by
unmarked text gets a report row with its parts and no range ("join split
marks"); a custom step that changes the document without `mapRanges` gets
null for every range ("infer step ranges").
Not checked: Potion's import script on real v53 data; a custom step that
changes the document without `mapRanges` loses every range; a paste and
other callers of the generic diff keep the whole-span mapping.
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Session: local_d3a4587a-0f87-40af-8d8d-ef9c567870cd
Plan: docs/plans/2026-11-16-comments-persistence-authors.md
Lead: claude-opus-5-5 @high
…nd shared UI
`useEditor()`, `useOptionalEditor()` and shared UI under `EditorController` followed the content the user focused last. A press on a read-only `EditorContent` takes no focus, so a shared toolbar stayed on the writable content beside it and kept its Undo on, while `useRootEditor()` already named the read-only one. When the content used last unmounted, they went to the first mounted content. After an `Activity` hid and showed the content used last, `useEditor()` named another content than `useRootEditor()`.
Plate's target scope now ranks its contents by the store's stamp of each view's use, the record `useRootEditor()` reads. A mounted content tells its scope and the controller each time the store marks its view used. The scope names the content with the latest stamp, or the first content of a `primary` editor when no content has one. It reads only the new content's stamp when one mounts, and ignores a notice older than the stamp of the content it names.
A content registers with its scope and the controller only while its own `Editable` is mounted, and binds its focus listener to its own root. Once a `slots.wrapContent` wrapper removed a content's `Editable`, Plite's `useEditorRootElement` answered with the root element of another view of that root, so the content stayed registered, and `useEditor()` and its Undo kept naming it. After an `Activity` showed a content again, React did not render that subscription again, so its focus listener stayed on another content's element. The effect now reads the root with `getEditorDOMRoot`.
A press or a focus marks a view used and a release marks none, in `Editable` and in a content-root slot. A mark on each release moved `useRootEditor()` to the content where a drag ended, and with the scope above it would have moved `useEditor()` too. Each `Editable` and slot hands its interaction controller its own view, which the release mark used to aim. Each `Editable` on a press's path still marks its own view from a capture handler, outer first, so an editor nested in a content marks its view last. A press that something prevented before the content saw it marks nothing, in an External Text host as in `Editable`, and any other press counts as a use even when the content's own handler prevents it. The interaction controller drops the action a press armed once the next press begins anywhere in its document. Before, a press whose release the root's own handler never saw, such as one released outside the root or on a button portaled into it, or one that ended as a native drag, let the next release over the root focus the view pressed first.
Plate's focus listener keeps the last-focused flag and reports a focus to the store. A focus on an input that a portal from outside a content renders inside it reaches no capture handler of the `Editable`.
Step 7 of 8 of docs/plans/2026-11-15-react-root-control-view.md, with the one step of the press plan below, which this commit closes. Card t_f378804a and design question t_c05ff5b2.
Introduced-by: none
Beyond the ask: when the content used last unmounts, shared UI goes to the content used before it instead of the first mounted one; a release no longer moves `useRootEditor()`, so a drag that ends over another `Editable` leaves it where the drag began; when an app moves focus to a writable content during a press on a read-only one, controls stay on the writable content after the release; a release over an `Editable` no longer runs the action of a press that ended outside it, on a portaled button or as a native drag
Picks: case (e) runs at the depth of a content only ("slot depth" reverses it); a release marks no view ("release wins" reverses it); a press that the content's own handler, or a wrapper around an editor nested in it, prevents still counts as a use of the content ("veto wins" reverses it)
Not checked: the www case and the playtest specs ran in Chromium only; the drag, portal and closed shadow root cases ran in jsdom only; a read-only editor nested in a writable content ran in no real browser; no case covers the content-root slot's own lookup of its view; which commit first let `useRootEditor()` follow a press while `useEditor()` followed focus alone was not bisected, because Plate's scope never followed a press
Plan: docs/plans/2026-11-16-react-control-press.md
Session: local_f04c3d9b-9b5d-4c86-8eb8-b5503a0ea714
Lead: claude-opus-5-5 @xHigh
The board page's general Enter row now leaves out the arrow tool, because with the arrow tool and nothing selected, Enter starts an arrow instead of selecting the first shape. The row for Enter that edits a shape's text now names the tools that take Enter first and says a double click edits only with the select tool, and a new row says that Enter with the arrow tool and several shapes selected says the selection again and draws nothing. The Limits section now says that drawing with the pen needs a pointer, and that a keyboard resize cannot keep proportions or resize around the center, which Shift and Alt do on a corner drag. It also says that no key or pointer gesture moves a bound arrow end off its shape or resizes several shapes at once, and that moving a selected arrow moves its free ends while each bound end stays on its shape. The Chinese page says the same. The copied board's spoken instructions now offer S and connecting only on a shape that is not an arrow, because S does nothing on an arrow and Enter with the arrow tool edits a selected arrow's text instead. The registry output, the registry changelog entry and the Plite dev board carry the new sentences. This is step 21 of the board keyboard plan, card t_f901520f. Beyond the ask: none. Picks: none. Not checked: no screen reader read the new instructions; Safari. Session: local_73bde20e-f8a0-41d8-a2b5-e0584e3ff821 Plan: docs/plans/2026-11-13-board-keyboard-verdict.md Lead: claude-opus-5-5 @xHigh
Board shapes now store their own style, so the coming style panel can restyle a selected shape and every teammate sees the same look. A note stores a fill, opacity and text size. A geo stores a fill, outline color, line style, outline width, opacity and text size. An arrow stores all of those but the fill, and a pen line stores an outline color and opacity. Each style has a default for its kind, so a board saved before this change loads in an editor with every style at its default. defineBoardShape takes a styles map of defaults, always, as it takes properties, and refuses a style key in its properties; each insert takes the styles its kind declares. The board's HTML writes one data attribute per style and drops an invalid value to the default with a report. A shared room, or an API that strict-checks a document passed in, such as read.schema.assertDocument, compare or a serializer given a document, refuses a board saved before this change until an editor loads it.
Beyond the ask: an invalid data-board-geo value now reports a diagnostic instead of dropping silently; an insert stores the default of a style or property passed as undefined; the API reference baseline drops defineBoardShape, which now has a doc comment; the board docs' custom shape example and API rows give styles.
Picks: pen lines get color and opacity but no width yet (word: pen width); notes get no outline (word: note outline); outline width and text size take four named sizes (word: number sizes); the default outline color is the page's text color (word: named outline); a custom shape always passes styles, styles {} for none (word: optional styles).
Not checked: no browser drive, because no React file changed in this step; the slow checks run in the deep lane after landing.
Plan: docs/plans/2026-11-16-board-style-panel.md
Session: local_8df67876-1974-4b77-94b8-5fbc5ae12dfd
Lead: claude-opus-5-5 @xHigh
…ssed last The Plate controller page still gave the rule from before e93e0ef. It said that UI inside an `EditorRoot` and shared UI under `EditorController` follow the view the user focused last, and go to the first mounted view once that view unmounts. They follow the view the user focused or pressed last, and the view used before it once that view unmounts. The page now says so, and says that a press on a read-only view counts, though it takes no focus. A view with `primary={false}` becomes active when the user focuses or presses it. The Chinese twin says the same. Step 8 of 8 of docs/plans/2026-11-15-react-root-control-view.md, which this commit closes. Card t_f378804a. Beyond the ask: none Picks: none Not checked: the page in dark mode and at phone width Plan: docs/plans/2026-11-15-react-root-control-view.md Session: local_f04c3d9b-9b5d-4c86-8eb8-b5503a0ea714 Lead: claude-opus-5-5 @xHigh
…ide it Accepting a struck table or row, or rejecting a suggested one, now removes that grid part with every pending change inside it, as Google Docs does. Before, part of it stayed around another author's pending text, and the kept rows no longer lined up with the grid. A `wholeWhenRemoved` term on `survivalUnder`, read from the compiled schema's grid roles, decides this for a reviewer's decision and a document load alike. A table or row left with none of its rows or cells goes too, so a table goes with its last row, while a cell whose nested table goes keeps its place with an empty paragraph. A line that one author adds in a struck table and another author joins to the line before it also goes with the table. The review ledger's preview follows the same rule, so a preview, a decision and a load agree. A pending property change on a row or cell cannot empty a table, so the table keeps its own preview level. Text outside a grid keeps today's rule. A command whose caret sits on a teammate's live text in a struck table now refuses, typing included, because the command frame maps that caret into the preview, where the table is gone, and would act on a live table next to it. Before, a keystroke there landed after that text, inside the table. A command with an explicit place outside the table still runs. The authored-decision-order gate gains a grid family that runs by default. Applied alone at the base commit, the family fails 39 checks. Beyond the ask: the authored-decision-order skill documents the grid family. Picks: removing a table's last row removes the table (keep empty table); a caret on a teammate's line in a struck table refuses with the existing `unaligned` reason until a later step gives it its own (type after the line). Not checked: the browser, because Suggesting refuses tables until a later step; an Editing author's own removal of a table or row; a load after a rejecting step; a caret on struck text in a struck table; the reload timing over 20,000 struck paragraphs, which stayed inconclusive under host load; and the paired timing after the review fixes. A suggested task reruns both timings on the landed commit. Session: local_c0d87018-f28d-4be2-beb0-3d3365dfafab Plan: docs/plans/2026-11-16-suggestions-table-outer.md Lead: claude-opus-5-5 @xHigh
…ho imported a comparison
A tab's kept batch named only the first record it conflicted on, and none when it also raced a teammate on a named root. A comparison import's change id named no importer and repeated for the same selection, so when two people imported one comparison, the second one's tab threw on the first one's entry, and once a room held that id only in a verdict, it refused every later import of that selection.
- The rebase names every record two changes put unequally, and a conflict on a named root names them too. Each later teammate entry adds the records it puts unequally to a batch that already left the tab's chain, whether kept or still waiting on the wire, so a card lists every record it conflicts on. The room's record or root refusal of a batch the tab withheld reads as a conflict on its records.
- `proposeAuthoredComparison` gives each import the change id `comparison-import:<importer>:<nonce>`, with a fresh nonce from the authored plugin. Two people who import one comparison at once each keep a change of their own, and an import whose old id the room holds only in a verdict goes through.
- The import answers `unchanged`, writing nothing, when accepting the importer's own pending suggestions that the draft no longer marks, directly or through a review context, and leaving every other suggestion pending, already gives the draft. A draft that agrees with a teammate's suggestion imports as the importer's own, so it outlives that suggestion's rejection. A draft whose review marks the check cannot read goes on to the guarded write, which answers `blocked`.
Beyond the ask: none.
Picks: the formal checks whose coverage records name these files run in the deep lane after landing, because every conflict keeps its kind and the ledger only gains a read ("formal before land" reverses it); a kept batch's list grows only from teammates' entries, so the tab's own batch that the room logs never adds to it.
Not checked: a crossing that throws twice, and a batch kept only because an earlier batch of the same tab left, which C.13 owns; a snapshot catch-up, which adds nothing to a kept batch's list and which C.7c's recovery reads past; the cost of reading kept batches per entry, which C.15 measures.
Plan: docs/plans/2026-11-06-native-sync.md
Session: local_6c06a7e5-a83d-4f25-b4cb-e90a424397cb
Lead: unknown
A board toolbar can now restyle the shapes you selected, which the coming style panel needs. setStyle replaces setNextStyle. With the select tool it writes each style to every selected shape that takes it, or to the shape whose text you are editing, as one undo step that keeps the caret, and it sets the next shape's style too. With a drawing tool it sets only the next shape's style. The view's styles gives, for each style a pick would set, the value its targets share or mixed, so a toolbar can show the current fill. Every insert, keyboard placement, arrow and pen line takes the next style, and a draw keeps the style it started with. setStyle skips a value outside the board's values for a style, such as an opacity of 0, and a read-only view or a preview changes nothing. The copied Fill menu shows a selected shape's fill and changes it, and the shape menu switches to the geo tool before it sets the next outline, so a selected geo keeps its kind. Beyond the ask: setStyle reads its targets from the document, so a pick from a commit listener that runs before the view's reaches the shapes selected or edited in that commit; styles refreshes after a schema change alone, such as a runtime plugin reconfigure; a keyboard arrow keeps the style it began with, as a pointer arrow did; the API reference manifest picks up the current useEditor doc line. Picks: a pick while typing in a shape restyles that shape and keeps your caret (word: skip edited shape). Not checked: a plugin that gives a shape kind a narrower style, such as notes whose outline is only red or blue, still makes a pick with another value throw (word: schema-checked picks); no hand drive of the copied board, because its menus changed only where they read and write; the www board spec ran in Chromium only, and the slow checks run in the deep lane after landing. Plan: docs/plans/2026-11-16-board-style-panel.md Session: local_8df67876-1974-4b77-94b8-5fbc5ae12dfd Lead: claude-opus-5-5 @xHigh
The deep lane reported test, test-slow and effect-ledger red on next because its worktree kept the private files of the commit it was first made for. git-private.mjs attach leaves a worktree's private files alone, as a session's own work, so test-suite.mjs there predated --slow and ran the oxlint plugin test under Bun.
- deep-check.mjs resets the deep worktree's private half to its commit after each attach. Nobody works in that worktree.
- A report offers its task as P0 with owns: <step> and writes:, which the ledger requires, and an event names the numbered log proof.mjs wrote.
- install points the launchd job at the deep worktree's copy of deep-check.mjs, which each run moves to the newest next, so a fix to the script reaches the job when it lands.
Team: the deep check's red posts from last night came from stale files, not from next. It checks next again after this lands, and a red step now gets a task.
Beyond the ask: none
Picks: deep-check tasks are P0, because each owns a check failing on next ("deep-check tasks at P1")
Not checked: the next live run on next, which starts once the job is installed again after this lands
Introduced-by: 5c98c8e
Shipped fast, no review.
Session: local_33292353-57c9-4f45-a26e-6a47953c2b63
Lead: claude-opus-5-5 @high
…room cover it An Editing removal of whole tables or rows, at any depth, or of a top-level block that holds them, now records as a plain removal that takes every pending change inside them, as a plain editor does. Before, it recorded claims, so the cell that held another author's pending deletion stayed, and rejecting that change left a one-cell row or table. A table or row another author struck stays for that author to decide, as a struck paragraph does, and a cell removal records as before. The sync room's grant now covers that step. It covers a removed write inside a table or row the step removes whole, also when the step puts a new table or row in its place, and one in a content root the step drops when every owner of that root sits inside such a part. It judges each part by its claims. It counts no part under another author's pending deletion, and no part when a node the step moves out of it, or a node the step writes anywhere, still carries a pending claim that started inside it. So the room still refuses a rewrite that takes one author's pending change and keeps another's. A decision that takes a grid part also takes each content root whose every owner sits inside it, so pending text there no longer blocks accepting a struck table first. A root that an owner outside the part also names stays. Beyond the ask: the suggestions subject file links the plan page's new address. Picks: an Editing removal of a table or row another author struck leaves it struck for that author (take struck rows); accepting a struck table together with another change inside a root only its cells own still waits on pending text there, as before, which only a Plite schema meets (cell roots together); an Editing removal of a block nested in another block, such as one column, still records claims when a table inside it holds another author's pending change (nested table removal). Not checked: the browser; the room's grant on the undo of such a removal, and on removing a table's only row through Plite, both of which it refuses as before until a later step; the recording gate, which builds no grid world; and the 3 sync specs that need a Workers runtime, which do not load in bun. Plan: docs/plans/2026-11-16-suggestions-table-outer.md Session: local_c0d87018-f28d-4be2-beb0-3d3365dfafab Lead: claude-opus-5-5 @xHigh
A board can now dock a panel at its side, which the coming style panel needs. A top-level toolbar element marked data-board-dock="left" or "right" sits beside the board, and every other top-level toolbar element is a row at its top or bottom. fit and Shift+1 fit the shapes into the room the toolbar leaves clear, and use the board's whole width or height where that room cannot hold them at 10 percent. A plain wheel over a toolbar element that can still scroll in the wheel's main direction scrolls that element instead of panning the board, and Ctrl or Meta with the wheel still zooms the board. Shift+Enter moves focus to the toolbar's first control that is shown and enabled, skipping one that is hidden or inert. Beyond the ask: fit used to ignore toolbar rows that left 64 pixels or less and put shapes under them, and now uses the room they leave whenever it holds the shapes at 10 percent; the API reference manifest picks up the doc text of 6bcc71e and ed06fae, which did not regenerate it. Picks: none Not checked: the docked panel itself, with its Chromium wheel, Tab and Shift+Enter cases and a hand drive, comes in step 4; Shift with the wheel in Firefox, whose wheel direction no test here observes, waits for the panel in step 4; the www board spec ran in Chromium only, and the slow checks run in the deep lane after landing. Plan: docs/plans/2026-11-16-board-style-panel.md Session: local_8df67876-1974-4b77-94b8-5fbc5ae12dfd Lead: claude-opus-5-5 @xHigh
This branch was successfully deployed
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Uh oh!
There was an error while loading. Please reload this page.