Skip to content

Publish develop to main - #784

Merged
b-re-w merged 425 commits into
mainfrom
release
Nov 16, 2026
Merged

b-re-w merged 425 commits into
mainfrom
release

Conversation

@github-actions

Copy link
Copy Markdown
Contributor

Rebuilt from develop by .github/scripts/release/sync-release.sh.

The internal planning documents (PROJECT.md, AGENTS.md, CLAUDE.md, docs/INTENT.md, docs/SPEC.md) and the experiments/ folder are excluded; the source, README.md and docs/guide/ are not.

Merging this leaves main with exactly the tree the script produced.

b-re-w and others added 30 commits November 15, 2026 03:13
…gth (PR-2.1)

The measure request record grew from 72 to 80 bytes when the font features
went into it (#788, FR-83). The smoke host writes its requests by hand in C and
kept 72, so the renderer read the second, third and fourth request of the round
trip eight, sixteen and twenty-four bytes early, and the smoke test failed on
every platform with "the measure round trip did not agree, or never ran"
(develop CI run 43617787436: iOS simulator, GraalVM Linux and macOS, Windows).

MEASURE_RECORD is 80. The records are zeroed before they are filled, so the new
font features slot reads as none. scripts/tests/smoke-host-measure-record.test.sh
holds the C length equal to MEASURE_RECORD_LEN; it fails on the old value.
Develop made ui::Modifier own its values, so it is no longer Copy and
NativeViewScope::compose could not move it out of a borrowed scope. It
now takes it with std::mem::take, the way every other widget scope does.
…p (FR-81)

Runs codegen and stage-android-kotlin.sh over the merged schema:
develop's Presentation 206, MaxWidth 207, Separator 208, the Sticky
modifier and the larger SetOverlayTokens record, together with this
branch's NativeView widget, NativeVisible 190, OnNativeViewFocus 191,
AttachNativeView 37, FocusNativeView 38 and the NativeViewParent and
NativeViewFocus events. The schema hash moves to 0x524d7cce28ecd4cc.

The mutation vector holds 147 records (counted by walking the batch),
which is the recordCount codegen states; events.bin is unchanged, so
the event offsets the tests use stay where they are.
Since 1.11.1-ext.4 (fork #167) the fork's desktop modules (ui-desktop,
foundation-desktop and the rest) name org.thisisthepy.compose.skiko:
skiko-awt at the fork version. skiko-awt is a JVM jar published as a
root alone, with no per-target publications, and publish-skiko-awt.sh
puts it in ~/.m2. fork-dependencies.sh still asked every root sibling
for a publication per served target (skiko-awt-desktop), so
require-fork-artifacts.sh desktop refused a complete repository and
every renderer build script stopped before the toolchain ran.

A root whose metadata has no variant pointing at a target publication
("available-at") is now published when its own files are. A
multiplatform root without the target's publication is still refused.
fork-dependencies.test.sh covers both; the first case failed before
this change with skiko-awt named as missing.
Fix: Write the smoke host's measure requests at the record's real length (PR-2.1)
Generated by .github/scripts/release/sync-release.sh. The internal planning documents
and experiments/ listed below are kept on develop only:
  PROJECT.md
  AGENTS.md
  CLAUDE.md
  experiments
  docs/INTENT.md
  docs/SPEC.md
  docs/platforms.md
…t (FR-81)

The picture checks read the window with CGWindowListCreateImage. For this
window, whose content view is a vibrant NSVisualEffectView, that call
draws the window again when asked instead of returning what the window
server composited. The fork measured it putting a native view a step
ahead of the frame under it in 61 of 96 images while none of 93
ScreenCaptureKit pictures of the same turn had the two apart, so the
scroll test was failing on the capture rather than on the screen.

Every check that judges pixels (the animated scroll, the clip by the
ancestors, the popover's rounded hole, the later view on top) now reads
a ScreenCaptureKit stream of the window's content, the way the fork's
NativeViewSameFrameTest does. The scroll test keeps one column of every
picture the window server composited during the animation and checks
each, as it checked each image before; it now also requires the view to
have been seen at three places or more, so pictures of a page standing
still cannot pass it, and on failure it lists every picture's column.

Without Screen Recording permission, or with no picture of the window,
each picture check prints that nothing on the screen was looked at and
what was not checked, and the checks that do not look at the screen
still run.

The pointer test compared NSCursor.currentCursor with assertSame, which
failed with both references printed at the same address: Kotlin/Native
gave two references to one Objective-C object. It compares the objects'
addresses now.
Every view's onGloballyPositioned worked out the region of every view
in the window again, so with four views a scrolling frame ran the
position, clip and hole computation about ten times (2.5 callbacks a
frame, four views each) to send at most one or two changes. Measured
in the macOS budget test (Kotlin/Native debug, four views, animated
scroll): the coordinator spent 200 to 250 us a frame, of which the
window's own setFrame and setVisibleRegion were 73 to 95 us, so 130 to
155 us was this repository's glue redoing views that had not moved.

A view's callback now places that view only. Compose calls the callback
for every view whose place may have changed, an ancestor's move or
resize included, so each view still hears about its own change in the
same pass. An overlay's callback and a scale change still work out
every view, because they change every view's holes.

After the change the coordinator spends 98 to 117 us a frame including
the probe's own clock reads, of which the window's calls are 57 to 68
us: the glue's share is about 30 to 50 us. The budget test's frame
medians are too noisy run to run to show it alone (before: +0.37,
+0.56, -0.04 ms; after: +0.22, +0.28, +0.15, +0.13 ms over a 1.2 to
1.5 ms frame); the rest of the cost is Compose dispatching
onGloballyPositioned (about 0.07 ms against plain boxes) and the
window's place(), which rebuilds the container frames and mask on
every call.

fr81_view_is_clipped_when_an_ancestor_shrinks_around_it checks the
assumption this rests on: a view that does not move but whose
ancestor shrinks around it is cut to the new clip from its own
callback.
…-layout.test.sh

Since the fork's event record gained the event time (fork #214, in the pin
since 1.11.1-ext.3), its Kotlin gives the record's size as
EVENT_TIME_OFFSET + 8. The test still looked for the old form, the text offset
plus the text length, so its Linux half failed with "fail: event size" on
every run (develop CI run 43617787436, ubuntu). macOS skips that half, which is
why no local gate saw it.

The probe now also prints the time field's offset. The test checks that the
Kotlin names that offset, reads the time there, and that C's size of the record
is the offset plus eight. Run in a Linux container against the pinned fork:
ok.
Test: Check the X11 event's size through its time field in x11-window-layout.test.sh
Generated by .github/scripts/release/sync-release.sh. The internal planning documents
and experiments/ listed below are kept on develop only:
  PROJECT.md
  AGENTS.md
  CLAUDE.md
  experiments
  docs/INTENT.md
  docs/SPEC.md
  docs/platforms.md
The build job built Compose from the fork on every run, about 63 minutes on
macOS. Its output is the local Maven repository the build publishes, which
the step copies to FORK_REPO; every later step (the old build, the
comparison, the renderer build) reads the fork's publication from FORK_REPO
and never from the work directory. FORK_REPO is now restored from a cache
before the build, the build step is skipped on a hit, and it is saved after
a successful build.

Key: compose-fork-<os>-<arch>-<matrix.target>-jdk21-<hash of
renderer/scripts/build-compose.sh>-legacy-<LEGACY_REF>-equivalent-<EQUIVALENT_REVISION>.
build-compose.sh holds every pin that decides the publication as literals
(FORK, REVISION, COMPOSE_AS, MATERIAL3_AS) and reads no .changes file, so
its hash changes whenever the fork pin does. The two env pins only affect
the old build and the comparison but are in the key so a change to them
never trusts an older run.

The save never runs on a pull request, and runs only from develop or main,
since a cache saved on another branch is not visible to develop.
scripts/tests/compose-fork-build-cache.test.sh pins all of this.
…fork test

With the fork's publication cached, a pin-unchanged run still built Compose
twice more: the old patched build and, on Linux, the full Linux set the
renderer resolves. Both are now cached the same way.

The old build publishes into LEGACY_REPO, which is what the comparison
reads. Its script and patches come from the commit LEGACY_REF and nothing
else, so the key is compose-legacy-<os>-<arch>-<target>-jdk21-<LEGACY_REF>.
Putting the fork's publication back into ~/.m2 moves to a step of its own
that always runs, so a restored old build leaves ~/.m2 as a full run does.

The Linux set is published over that put-back repository, and its --clean
wipes only COMPOSE_WORK, which nothing later reads. ~/.m2/repository is
cached as that step leaves it, under
compose-fork-linux-<os>-<arch>-linux-jdk21-<hash of build-compose.sh>, and
restored after the fork's publication is put back, so the result after a
hit matches the result after a full run.

Both saves run only off pull requests, from develop or main, after their
step succeeded. scripts/tests/compose-fork-build-cache.test.sh pins both.
…142)

The menu builds on the fork's 1.11.1-ext.4 window modules, which the merge
of feat/compose-ext4 brings: dxc_native_set_edit_menu and win32EditMenuFlags
at window pin a13a6289029.
Covers the five missing acceptance criteria tests tracked in #29:
- FR-13.1-3 c2: fr13_1_3_highlighted_rust_text_carries_no_literal_colour_on_the_wire
- FR-13.1-3 c4: fr13_1_3_code_roles_leave_widget_property_and_modifier_schemas_unchanged
- FR-26 c1b: fr26_bold_and_link_runs_encode_distinct_styles_and_only_the_link_carries_a_handler and fr26_bold_and_link_runs_draw_differently_and_only_the_link_reports_a_click
- FR-26 c1c: fr26_a_text_with_no_spans_keeps_its_record_size_and_path
- FR-36 c6: fr36_a_worker_notification_sender_queues_requests_a_frame_and_rides_the_next_batch
A dispatch ran every job, about five hours, even to check one branch.
ci.yml now takes a suites input: all (the default, so a release check is
still complete), fast (the Rust, JVM and script tests, the Windows C
compile and the GraalVM renderer smoke), or a comma list of job names. A
plan job runs scripts/ci-suites.sh on the input and every job runs only on
its output; a job that takes the Windows kit brings windows_static_kit
with it, and an unknown name fails the plan rather than checking less.

Test: scripts/tests/ci-suites.test.sh pins the input and its default, that
every job runs on the plan and is named in the script, and the mapping.
test_windows_resize_metrics and test_windows_resize_probe report resize
timings and real drags at two scales; they measure and do not gate a merge,
yet every dispatch spent hours on them. They are now the measure suite:
not in all (still the default and every job that gates), run when asked
for, and all,measure runs everything. Suite names can be mixed with job
names in a comma list.

Test: ci-suites.test.sh pins that all leaves out exactly the measurement
jobs, measure is them, and all,measure is every job.
The fork's X11 window numbers F1 to F12 since fork #219, which the ext.4 pin
brings. a_key_with_no_number_claims_no_meaning used F1 as its example of a key
the window does not number, so on Linux it failed with "Expected <-1>, actual
<122>" (batch CI run 43639736378, Test the linux renderer; the only failed
test of that job).

The example is now Scroll Lock, which the window still leaves unnumbered, and a
new test checks both ends of the function row reach the scene as F1 and F12.
Not compiled here: the Linux module builds only on Linux.
…43.1)

The Renderer reports how many device pixels one dp of a window covers.
The event is tag 53, a 20 byte record with one f32 after the header,
appended to the event table and to the events vector. A scale of zero,
below zero or NaN is a protocol error.

The Host keeps the value in a new density module: density() reads it and
is 1.0 before the first report, subscribe() calls back on a change and
not on a repeat, and a multi-window application has the same per Window
node (density_of, subscribe_window, WindowHandle::density).

Covers FR-43.1 criteria 1 to 3: fr43_density_event_round_trips,
fr43_density_defaults_to_one_before_the_first_event and
fr43_density_change_reaches_readers.

The generated files are not in this commit: Protocol.gen.kt,
schema-hash.txt and tests/vectors are produced by the codegen binary.
The schema hash moves and events.bin grows from 1755 to 1775 bytes.

Needed by DarkPyonix/dioxus-compose#240.
The content tells the Host the display's scale once before the first
frame and again when it changes, under the window's node like the zoom.
The value is the screen's own scale with the zoom left out: whoever
makes the zoomed Density provides the number it was made from
(LocalDisplayScale), so a zoom step is never reported as a density.

Covers FR-43.1 criterion 4 (fr43_density_reported_at_start) and an
automated stand-in for criterion 5
(fr43_density_reported_when_window_changes_screen); the move between
two real monitors stays a check by hand.

The Kotlin here needs HostEvent.DensityChanged from a codegen run, and
compose-rust/android-kotlin needs restaging.
Feat: Report the window's density to the Host (DensityChanged, FR-43.1)
Generated by .github/scripts/release/sync-release.sh. The internal planning documents
and experiments/ listed below are kept on develop only:
  PROJECT.md
  AGENTS.md
  CLAUDE.md
  experiments
  docs/INTENT.md
  docs/SPEC.md
  docs/platforms.md
…r (FR-24.1)

FR-24.1 put the handler on the containers and TextField. The other builders
could carry Modifier::motion and had no way to hear it settle, though the
rsx path and the Renderer take OnMotionFinished on any node (#707).

A motion_handler! macro adds the method to a builder with an
on_motion_finished field, the way click_handler! adds on_click, and each
compose hands the handler to the existing motion_input. LazyList writes the
method by hand, as TextField does, because the macro is not in scope there.

Tests cover FR-24.1 per builder family: the handler property is sent for the
node, and a MotionFinished report reaches that builder's closure once with
the size it carries.
… criteria (#310)

Leader-approved, provisional (2026-11-15).
…(FR-56) (#789)

Leader-approved, provisional (2026-11-15).
b-re-w and others added 29 commits November 16, 2026 08:14
Chore: Build the Windows renderer kit in release mode
Generated by .github/scripts/release/sync-release.sh. The internal planning documents
and experiments/ listed below are kept on develop only:
  PROJECT.md
  AGENTS.md
  CLAUDE.md
  experiments
  docs/INTENT.md
  docs/SPEC.md
  docs/platforms.md
Fix: Run the Windows UI on a thread the Host makes with a 64 MB stack (PR-3)
Generated by .github/scripts/release/sync-release.sh. The internal planning documents
and experiments/ listed below are kept on develop only:
  PROJECT.md
  AGENTS.md
  CLAUDE.md
  experiments
  docs/INTENT.md
  docs/SPEC.md
  docs/platforms.md
The Compose, window and Windows pins all move to 96ae925f7fb6a730d7af31c2c29c856f35778d25,
the tip of the fork's extended branch and the commit its v1.11.1-ext.5 tag goes on. It
publishes every line as 1.11.1-ext.5, so COMPOSE_AS, MATERIAL3_AS and SKIKO_AWT_AS move with
it, and every live coordinate follows: the renderer module.yaml files, COMPOSE_VERSION in
Transform3DLayers.kt and its staged Android copy (stage-android-kotlin.sh), the
troubleshooting guides in English and Korean, the scripts, the test comments and the
workflow comment.

ext.5 is the first tag since the ext.2 build that changes Compose itself, in foundation
(fork #240). The Kotlin/Native Windows and Linux scroll configs answer the wheel with the
sign and the line desktop Compose uses on the same system; before, the wheel scrolled the
wrong way there, and on Windows three times too far. The macOS config works out a scroll
with no NSEvent from its travel, 10 dp a line, where it came to zero. The scene sends a
scroll where the pointer last was (ScenePointer) instead of the top left corner, and the
macOS window places the pointer before a scroll that came before any move. Together they
make the wheel and the trackpad scroll on the Kotlin/Native macOS window, where nothing
scrolled. The tag also holds what the window pin carried past ext.4 (fork #232, #235, #239,
#236, #234, #237) and the AT-SPI readback tool matching roles by number (fork #241).

No glue changes: the renderer calls none of the scene's input functions (its Linux and
Windows windows go through its own WindowEvents.kt, which already scrolls at the last
pointer place, and the macOS renderer goes through the fork's scene), and the C symbols the
desktops link are unchanged (desktop-c-symbols.test.sh).

compose-fork.changes and compose-fork-mingw.changes are regenerated from 73ac849 to the new
pin. No path is dropped; the new paths are the foundation scroll configs and their tests,
the fork's wheel and native view tests, two fork workflows and its AGENTS.md. The historical
CHANGELOG entry for ext.4 keeps its version and ext.5 gets its own.

The tag and the Maven Central artifacts do not exist yet; this was built and checked against
1.11.1-ext.5 published into ~/.m2 from the same commit.
…trackpad

WheelScrollWindowTest opens a Kotlin/Native macOS window the way the renderer does
(MacosWindow with ComposeRustContent over a scripted Host), with a box that does not scroll
at the top left corner and a ScrollColumn and a LazyColumn beside it, each started in the
middle of its content. It moves the pointer over one container and hands the view under it
AppKit scroll events made with CGEventCreateScrollWheelEvent2: -3 and +3 lines, and -40 and
+40 pixels. It reads where each container is from its ScrollChanged reports and asserts that
-3 lines moves the one under the pointer 3 lines of 10 points toward its end, +3 brings it
back, 40 trackpad points move it 40 points, and the other container does not move.

It would have caught the bug ext.5 fixes (fork #240): against the 1.11.1-ext.4 pins all three
tests fail with the container moved by 0.0 pixels, because every scroll reached the scene at
the window's corner and its distance came to zero. Covers FR-13.6 (scroll containers) for
pointer input on the macOS window.
LinuxWheelScrollTest opens a window through the Linux backend with the same page as the
macOS wheel test: a box at the corner, a ScrollColumn and a LazyColumn started in the middle
of their content. Another display client sends the window a MotionNotify over a container,
then a button 5 press and release (a notch toward the reader) and a button 4 one, with
XSendEvent. The container under the pointer must move toward its end by three lines of the
square root of its height in pixels and then come back, and the other one must stay.

Against 1.11.1-ext.4 the notch down would move the container toward the top, by 64 dp a
line, which is the wrong-way wheel fork #240 fixes. Runs under Xvfb in the Kotlin/Native
desktop renderer test (linux); it cannot run or compile on a Mac. Covers FR-13.6.
The Windows renderer carries its real-window checks itself (Fr53WindowsCheck.kt), because a
Kotlin/Native test executable for mingwX64 cannot link the MSVC-built window.
fr13_windows_a_wheel_turned_forward_scrolls_toward_the_top joins them: a window with a box at
the corner and a ScrollColumn and a LazyColumn started in their middle, the real pointer moved
over a container and a WM_MOUSEMOVE posted, then a WM_MOUSEWHEEL of +120 (forward, away from
the reader) and one of -120. The container must move toward the top by the system's wheel
lines of a twentieth of its height and come back; the other must stay.

Against 1.11.1-ext.4 the forward notch moves the container toward its end, three times as far,
which is what fork #240 fixes. check-windows-consumer.sh and fr53-windows-backend.test.sh read
every `fr<N>_windows_*` name from the Kotlin instead of only `fr53_windows_*`, so the new check
is required to print its ok line. It runs in the consumer job of the Windows static renderer
workflow (windows_static_consumer in ci.yml). Covers FR-13.6.
…t it on a CI runner (FR-81)

On the shared macOS runner the test stopped at its own precondition, "frames
drawn: 19": three passes of an animated scroll give thirty frames on a
developer's display and not on a runner that draws a few frames a second
(batch run 43755840225, Test the macos renderer). The other eleven
NativeViewWindowTest tests pass there.

The test now scrolls back and forth until it has thirty frames, up to twenty-four passes, and measures each page three times in turn, taking the lowest of the three medians: other processes only add time, and on a busy developer machine a single median missed the budget two runs in five. On a CI runner (the CI environment variable is "true") it prints both figures with the words "budget not judged on CI" and does not judge them, because a shared runner's frame times swing by more than the tenth the budget allows; too few frames still fails there. The budget itself is unchanged.
Test: Give the native view frame budget frames enough, and only report it on a CI runner (FR-81)
Generated by .github/scripts/release/sync-release.sh. The internal planning documents
and experiments/ listed below are kept on develop only:
  PROJECT.md
  AGENTS.md
  CLAUDE.md
  experiments
  docs/INTENT.md
  docs/SPEC.md
  docs/platforms.md
Criterion 15 says the measured numbers go beside it. Five runs on macOS arm64
at the window pin a187dd1e: 1.34 to 1.43 ms a frame without views, 1.47 to
1.51 ms with four, so 0.08 to 0.14 ms for the four, and 0.04 ms to spare
against the allowance in the closest run. The margin is thin, so a later
failure is to be read as cost, not noise.

Also written down, as the leader accepted them on 2026-11-16: the lowest of
three interleaved medians as the method, and that a CI runner prints the two
figures without judging them while too few frames still fails there.
Docs: Record the measured cost of four native views beside FR-81
Feat: One right-click text menu on the Windows windows, the system's (FR-33.1)
Generated by .github/scripts/release/sync-release.sh. The internal planning documents
and experiments/ listed below are kept on develop only:
  PROJECT.md
  AGENTS.md
  CLAUDE.md
  experiments
  docs/INTENT.md
  docs/SPEC.md
  docs/platforms.md
…ences, and prove the method catches a cost (FR-81)

The budget test took the lowest of three medians for each page and
compared the two. On a busy machine it failed at random: one run had
medians without views [1.37, 2.03, 2.06] ms and with four [1.85, 2.04,
2.13] ms, and the lowest-of-three paired a lucky fast baseline with no
equally fast partner.

What the data says (macOS arm64, this machine's usual load):
- No order effect. Measuring both halves on the same page (A/A, 20
  pairs) put the second half slower in 10 and faster in 10.
- No regression since 4a3b31c: 30 pairs over both commits give a cost
  of 0.166 ms a frame at a 1.92 ms baseline, against an allowance of
  0.242 ms. A single pair's difference swings by about 0.3 ms.
- A bootstrap of those pairs: the best single pair (with a median
  baseline guard) fails a fine run 24% of the time over five pairs and
  misses a +0.20 ms regression 54% of the time; the mean of the paired
  differences misses it 8% of the time over twelve pairs.

The rule now: twelve interleaved pairs; the cost is the mean of the
paired differences, the allowance is a tenth of the mean baseline plus
0.05 ms, and the test fails when the cost minus two standard errors is
above the allowance. Its resolution is stated: two standard errors are
about 0.17 ms at the measured spread, so it reliably catches a cost of
about 0.3 ms a frame over the allowance; smaller overruns would need
about 65 pairs. Each pair, the frame count and the cost, standard
error, allowance and margin are printed; on CI the budget is printed
and not judged, as before.

fr81_the_frame_budget_method_catches_an_added_cost proves the method
fails on a real cost, everywhere including CI: the Host busy-waits on
each scroll report, which the renderer sends from the frame clock
inside the measured frame time, for as long as the page without views
takes (at least 0.5 ms). Five pairs are enough for it.

Four runs of NativeViewWindowTest (two under three extra busy loops):
cost 0.120/0.092/0.188/0.097 ms, standard error 0.013/0.013/0.067/0.010,
allowance 0.217/0.211/0.260/0.186 ms, all inside; the added-cost check
over in all four (cost 1.73 to 2.21 ms). Wall time: 102 s for the
budget test, 43 s for the method check.
…erences (FR-81)

FR-81 criterion 15: the method line now states twelve interleaved pairs, the mean of the paired differences judged with two standard errors, its resolution of about 0.3 ms a frame and the test that proves it fails on a cost. The measured values gain the figures under this machine's usual load (0.166 ms at a 1.92 ms baseline over 30 pairs, allowance 0.242 ms); the quiet-machine figures stay. Leader decision, 2026-11-16.
Test: Judge the native view frame budget by the mean of paired differences (FR-81)
Generated by .github/scripts/release/sync-release.sh. The internal planning documents
and experiments/ listed below are kept on develop only:
  PROJECT.md
  AGENTS.md
  CLAUDE.md
  experiments
  docs/INTENT.md
  docs/SPEC.md
  docs/platforms.md
Both sides added checks to the Windows real-window harness: develop the two
text edit menu checks, this branch the wheel check. Both are kept, and the
consumer script and its script test now read every fr<N>_windows and
fr<N>_<M>_windows name.
Chore: Move the Compose fork to 1.11.1-ext.5, with wheel tests through the real window
Generated by .github/scripts/release/sync-release.sh. The internal planning documents
and experiments/ listed below are kept on develop only:
  PROJECT.md
  AGENTS.md
  CLAUDE.md
  experiments
  docs/INTENT.md
  docs/SPEC.md
  docs/platforms.md
Test: Drag the current Windows window pin on every edge, judged by edge markers (#17, #353)
Generated by .github/scripts/release/sync-release.sh. The internal planning documents
and experiments/ listed below are kept on develop only:
  PROJECT.md
  AGENTS.md
  CLAUDE.md
  experiments
  docs/INTENT.md
  docs/SPEC.md
  docs/platforms.md
compose-rust and compose-rust-macros 0.0.11 in the manifests and Cargo.lock, the
install lines in the README, its Korean translation and both getting-started
pages, and the changelog's Unreleased section becomes v0.0.11.

The section opens with the known issues: the gap at the moving edge during a
drag resize on Windows 10 and Server 2022 (the fork's window,
compose-multiplatform-core-extended#245; found by the resize probe in run
43812830794, the same window code as v0.0.10), and the window size after a live
change of display scale, fixed in the fork after this release's pin.

develop bb9cddb was checked by run 43812830794: 76 jobs green, the two resize
probe jobs red for the gate's own bug and for #245.
Chore: Bump the version to 0.0.11
Generated by .github/scripts/release/sync-release.sh. The internal planning documents
and experiments/ listed below are kept on develop only:
  PROJECT.md
  AGENTS.md
  CLAUDE.md
  experiments
  docs/INTENT.md
  docs/SPEC.md
  docs/platforms.md
@b-re-w
b-re-w merged commit 732f69a into main Nov 16, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant