diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5be910324..2bb1797ce 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -114,8 +114,8 @@ jobs:
           echo "code=$code" >> "$GITHUB_OUTPUT"
           echo "sdl=$sdl" >> "$GITHUB_OUTPUT"
 
-  # Every tracked .zig and .zon file as `zig fmt` writes it. Needs Zig and nothing else: no
-  # dependencies, no cache, a few seconds.
+  # Formatting, lint and script regression checks. Needs Zig, Python and shell tools,
+  # but no app dependencies or build cache.
   format:
     name: Format
     needs: changes
@@ -132,6 +132,8 @@ jobs:
       - name: lint
         # Not `zig build lint`: the root build fetches the app's URL dependencies.
         run: zig run scripts/lint.zig
+      - name: ci-ok result policy
+        run: python3 scripts/test-ci-ok.py
       - name: scripts/zb (build lock)
         run: sh scripts/test-zb.sh
       - name: scripts/check-kickoff
diff --git a/AGENTS.md b/AGENTS.md
index da935bd50..e55708e6f 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -40,7 +40,6 @@ Fizzy (Editor) ←── Host registries + EditorAPI ──→ Plugin (register(
 - **`archive`** — opens a `.zip` as a mounted folder (the web's "open a vault" path, too).
 - **`devtools`** — the dashboard: where the app's time goes, from `core.profile`, for a person and an agent alike.
 - **`guides`** — every demo the app can play, on the rail: fizzy's tour and each plugin's own, by chapter, through the `demos` service.
-- **`chat`** — a conversation and its composer over the `chat.provider` service; owns no conversation (a small in-memory demo provider when none is offered). Not in fizzy's own bundle: an app lists it.
 - `shared` — build helpers used across plugins' `static/integration.zig` (not a plugin itself).
 
 **Pixi (pixel-art editor) and Drive (Google Drive as a mount) live outside this repo** as third-party-style plugins ([`fizzyedit/pixi`](https://github.com/fizzyedit/pixi), [`fizzyedit/drive`](https://github.com/fizzyedit/drive)) — they ship and update purely through the plugin store (`docs/PLUGINS.md` §6), with no special treatment in Fizzy itself. **Trust `ls plugins/` and `jj log` over any doc's plugin list.**
@@ -104,14 +103,6 @@ both against each pull request's own tree (`scripts/check-examples.sh`, which yo
 locally): a change here that breaks either fails here. A change that needs them changed too
 lands its PR in that repo alongside.
 
-An app that wants fizzy's own shape with a different frame sets the **`Chrome`** build options
-(`src/editor/Chrome.zig`): `-Dchrome-sidebar-edge=right` puts the rail and Sidebar on the right
-(the width stays the Sidebar's `extent`), `-Dchrome-panel=false` leaves out the Panel and fizzy's
-Output view, `-Dchrome-menu-bar=false` and `-Dchrome-infobar=false` leave out those bars
-(macOS keeps its native menu). The defaults are fizzy's own frame. An app-supplied layout
-(`-Dapp-layout=`) draws its own frame. The phone shape reads only `sidebar_edge` (landscape
-sheets) and `panel`.
-
 ## Plugin store: built, not forward-looking
 
 The plugin registry/install flow (author repo → release CI → `fizzyedit/plugins` registry →
diff --git a/app/AGENTS.md b/app/AGENTS.md
index fc425ce73..d80947e77 100644
--- a/app/AGENTS.md
+++ b/app/AGENTS.md
@@ -47,5 +47,5 @@ each directory is.
   ReleaseFast). Check against `control.Server.max_path`, the real size, before `init`.
 - **On Windows, a socket test must not read to EOF when it need not.** Its AF_UNIX sometimes never
   tells a reader that the other side closed, so a test client reading "until the end" hangs about
-  one run in twenty. Read `Content-Length` bytes, as HTTP clients do, or stop after the expected
-  complete SSE message for an event stream (`control/Server.zig`'s `TestClient`).
+  one run in twenty. Read `Content-Length` bytes, as HTTP clients do (`control/Server.zig`'s
+  `TestClient`). It sent a day after server bugs that were not there.
diff --git a/app/HistoryFrames.zig b/app/HistoryFrames.zig
index 1b1e4beff..def842c89 100644
--- a/app/HistoryFrames.zig
+++ b/app/HistoryFrames.zig
@@ -39,8 +39,9 @@ unread: ?Unread = null,
 /// while the history moves frame after frame (a held undo, a scrub), so each step is a copy into
 /// it rather than a new pane-sized target; let go of the first frame no picture is asked for.
 whole: ?dvui.TextureTarget = null,
-/// The size of the pane's part a picture is taken from as the pane stands (`take`, each frame).
-/// Kept pictures retain their original size even when the pane resizes.
+/// The size of the pane's part a picture is taken from as the pane stands (`take`, each frame): a
+/// step's picture from another size (the window resized since) is of another view of it, and a
+/// visit takes it again.
 pane_source: [2]u32 = .{ 0, 0 },
 
 const Unread = struct {
@@ -112,8 +113,8 @@ pub const max_w: u32 = 384;
 /// document drew) are seen the frame after, which draws them.
 pub fn moved(self: *HistoryFrames, gpa: std.mem.Allocator, top: u64, below: ?u64, change: Change) void {
     if (change == .restarted) self.forget(gpa);
-    // A visit keeps the original pixels and change box, even after the pane resizes.
-    if (change == .visited and self.frames.contains(top)) return;
+    // Only visited, and it has its picture of the pane as it stands: kept as it was taken.
+    if (change == .visited) if (self.frames.get(top)) |pic| if (std.mem.eql(u32, &pic.source, &self.pane_source)) return;
     self.due = .{ .top = top, .below = below, .made = change != .visited };
     // Keep the frame in a texture to read from, on a backend that would draw it straight to the
     // window (the web).
@@ -190,11 +191,12 @@ fn land(self: *HistoryFrames, gpa: std.mem.Allocator) void {
         } else |_| {}
     } else |_| {}
     const top = u.step.top;
-    // A picture may have landed since this visit was requested: keep that original.
-    if (!u.step.made and self.frames.contains(top)) {
+    // A visit's picture of a step that has one of this view by now (made since it was asked for)
+    // is not the step's: it keeps its own.
+    if (!u.step.made) if (self.frames.get(top)) |old| if (std.mem.eql(u32, &old.source, &pic.source)) {
         gpa.free(pic.prints);
         return;
-    }
+    };
     // Round what the step changed; one that changed nothing visible, round the document's content,
     // or the pane's middle.
     const round = pic.change orelse content orelse rules.Frac{};
@@ -378,9 +380,7 @@ test "scrubbing across the steps leaves each step's picture as it was taken" {
     }
     // Back to the start and forward again, then to and fro: undo, redo, a scrub's jumps.
     const stops = [_]u64{ 4, 3, 2, 1, 0, 1, 2, 3, 4, 0, 4, 2 };
-    for (stops, 0..) |top, visit| {
-        // Opening the strip or resizing the pane must not retake a kept picture.
-        hf.pane_source = if (visit % 2 == 0) .{ 800, 500 } else .{ 800, 430 };
+    for (stops) |top| {
         hf.moved(gpa, top, if (top == 0) null else top - 1, changeOf(&.{}, top));
         try std.testing.expectEqual(@as(?Step, null), hf.due);
     }
diff --git a/app/Tracks.zig b/app/Tracks.zig
index 7338fa745..997dfe5f9 100644
--- a/app/Tracks.zig
+++ b/app/Tracks.zig
@@ -1177,7 +1177,7 @@ pub fn exportTape(self: *Tracks, host: *sdk.Host, doc: sdk.DocHandle, gpa: std.m
     const files = try arena.alloc(tape.Tape.File, 1);
     files[0] = .{ .path = name, .text = bytes, .owner = doc.owner.id, .format = t.format };
     const keyframes = try arena.alloc(tape.Tape.Keyframe, 1);
-    keyframes[0] = .{ .root = "demo://share", .files = files, .open = try arena.dupe([]const u8, &.{name}) };
+    keyframes[0] = .{ .root = "demo://share", .files = files, .open = try arena.dupe([]const u8, &.{name}), .layout = .focused };
     const ops = try arena.alloc(tape.Tape.Op, to - first + 2);
     ops[0] = .{ .at = 0, .do = .{ .keyframe = 0 } };
     ops[1] = .{ .at = 0, .do = .{ .wait = .{ .until = .idle } } };
@@ -1288,7 +1288,7 @@ pub fn exportLine(self: *Tracks, host: *sdk.Host, doc: sdk.DocHandle, gpa: std.m
     const files = try arena.alloc(tape.Tape.File, 1);
     files[0] = .{ .path = name, .text = bytes, .owner = doc.owner.id, .format = t.format };
     const keyframes = try arena.alloc(tape.Tape.Keyframe, 1);
-    keyframes[0] = .{ .root = "demo://share", .files = files, .open = try arena.dupe([]const u8, &.{name}) };
+    keyframes[0] = .{ .root = "demo://share", .files = files, .open = try arena.dupe([]const u8, &.{name}), .layout = .focused };
     const ops = try arena.alloc(tape.Tape.Op, recs.len + 2);
     ops[0] = .{ .at = 0, .do = .{ .keyframe = 0 } };
     ops[1] = .{ .at = 0, .do = .{ .wait = .{ .until = .idle } } };
diff --git a/app/control/Server.zig b/app/control/Server.zig
index 82c748aec..f0bb42c21 100644
--- a/app/control/Server.zig
+++ b/app/control/Server.zig
@@ -721,8 +721,6 @@ const TestClient = struct {
     io: Io,
     path: []const u8,
     request: []const u8,
-    /// A complete final SSE message: streams have no Content-Length or reliable EOF.
-    event_end: ?[]const u8 = null,
     reply: [8192]u8 = undefined,
     reply_len: usize = 0,
 
@@ -737,13 +735,11 @@ const TestClient = struct {
         w.interface.flush() catch return;
         var rbuf: [1024]u8 = undefined;
         var r = stream.reader(self.io, &rbuf);
-        self.readReply(&r.interface);
-    }
-
-    fn readReply(self: *TestClient, reader: *Io.Reader) void {
-        // Read only a framed response: EOF is not reliable on Windows AF_UNIX.
+        // As an HTTP client does: the head, then `Content-Length` bytes when it says, else to the
+        // end (a stream). Never to the end when it need not: whether Windows' AF_UNIX tells a
+        // reader the other side closed is not something to test here.
         while (self.reply_len < self.reply.len) {
-            const n = reader.readSliceShort(self.reply[self.reply_len..][0..1]) catch return;
+            const n = r.interface.readSliceShort(self.reply[self.reply_len..][0..1]) catch return;
             if (n == 0) return;
             self.reply_len += 1;
             if (std.mem.endsWith(u8, self.reply[0..self.reply_len], "\r\n\r\n")) break;
@@ -754,37 +750,14 @@ const TestClient = struct {
             const end = std.mem.findPos(u8, head, i, "\r\n") orelse return;
             const len = std.fmt.parseInt(usize, head[i + key.len .. end], 10) catch return;
             const want = @min(len, self.reply.len - self.reply_len);
-            reader.readSliceAll(self.reply[self.reply_len..][0..want]) catch return;
+            r.interface.readSliceAll(self.reply[self.reply_len..][0..want]) catch return;
             self.reply_len += want;
-        } else if (self.event_end) |end| {
-            while (self.reply_len < self.reply.len) {
-                const n = reader.readSliceShort(self.reply[self.reply_len..][0..1]) catch return;
-                if (n == 0) return;
-                self.reply_len += 1;
-                if (std.mem.endsWith(u8, self.reply[0..self.reply_len], end)) return;
-            }
+        } else {
+            self.reply_len += r.interface.readSliceShort(self.reply[self.reply_len..]) catch 0;
         }
     }
 };
 
-test "the HTTP test client stops at the response boundary without waiting for EOF" {
-    const cases = [_]struct { response: []const u8, event_end: ?[]const u8 = null }{
-        .{ .response = "HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nhi" },
-        .{ .response = "HTTP/1.1 204 No Content\r\n\r\n" },
-        .{ .response = "HTTP/1.1 200 OK\r\ncontent-type: text/event-stream\r\n\r\nevent: end\ndata: {}\n\n", .event_end = "event: end\ndata: {}\n\n" },
-    };
-    for (cases) |case| {
-        // Bytes after the response stand in for an open connection: none may be consumed.
-        const bytes = try std.mem.concat(std.testing.allocator, u8, &.{ case.response, "still open" });
-        defer std.testing.allocator.free(bytes);
-        var reader: Io.Reader = .fixed(bytes);
-        var client: TestClient = .{ .io = std.testing.io, .path = "", .request = "", .event_end = case.event_end };
-        client.readReply(&reader);
-        try std.testing.expectEqualStrings(case.response, client.reply[0..client.reply_len]);
-        try std.testing.expectEqualStrings("still open", reader.buffered());
-    }
-}
-
 test "a request reaches the UI thread and its answer goes back" {
     if (!Io.net.has_unix_sockets) return error.SkipZigTest;
     const gpa = std.testing.allocator;
@@ -994,7 +967,7 @@ test "a server that took over the path keeps it when the old one stops" {
     try std.testing.expect(std.mem.endsWith(u8, client.reply[0..client.reply_len], "\r\n\r\nnew"));
 }
 
-test "a stream gets only the events it asked for, once each" {
+test "a stream gets the events it asked for, once each, until the server stops" {
     if (!Io.net.has_unix_sockets) return error.SkipZigTest;
     const gpa = std.testing.allocator;
     const io = std.testing.io;
@@ -1009,12 +982,7 @@ test "a stream gets only the events it asked for, once each" {
     var server: Server = .{ .gpa = gpa, .io = io, .socket_path = path, .wake = noWake };
     try server.start();
     errdefer server.stop();
-    var client: TestClient = .{
-        .io = io,
-        .path = path,
-        .request = "GET /events?topics=fizzy.document.*,chat.turn_ended HTTP/1.1\r\nHost: x\r\n\r\n",
-        .event_end = "event: chat.turn_ended\ndata: {}\n\n",
-    };
+    var client: TestClient = .{ .io = io, .path = path, .request = "GET /events?topics=fizzy.document.*,chat.turn_ended HTTP/1.1\r\nHost: x\r\n\r\n" };
     const thread = try std.Thread.spawn(.{}, TestClient.run, .{&client});
 
     var taken: std.ArrayList(*Request) = .empty;
@@ -1031,9 +999,10 @@ test "a stream gets only the events it asked for, once each" {
     server.publish("fizzy.document.saved", "{\"path\":\"/a\"}");
     server.publish("fizzy.folder.opened", "{\"path\":\"/p\"}");
     server.publish("chat.turn_ended", "{}");
-    // Wait for the final expected message before stopping can cancel the writer.
-    thread.join();
+    // Let the stream write before the stop ends it.
+    io.sleep(.fromMilliseconds(50), .awake) catch {};
     server.stop();
+    thread.join();
 
     const reply = client.reply[0..client.reply_len];
     try std.testing.expect(std.mem.startsWith(u8, reply, "HTTP/1.1 200 OK\r\n"));
@@ -1174,7 +1143,7 @@ test "a stopped server ends a stream whose client stopped reading" {
     server.stop();
 }
 
-test "an event published as the stream is answered arrives while the stream stays open" {
+test "an event published as the stream is answered is not lost" {
     if (!Io.net.has_unix_sockets) return error.SkipZigTest;
     const gpa = std.testing.allocator;
     const io = std.testing.io;
@@ -1188,12 +1157,7 @@ test "an event published as the stream is answered arrives while the stream stay
 
     var server: Server = .{ .gpa = gpa, .io = io, .socket_path = path, .wake = noWake };
     try server.start();
-    var client: TestClient = .{
-        .io = io,
-        .path = path,
-        .request = "GET /events HTTP/1.1\r\nHost: x\r\n\r\n",
-        .event_end = "event: first\ndata: 1\n\n",
-    };
+    var client: TestClient = .{ .io = io, .path = path, .request = "GET /events HTTP/1.1\r\nHost: x\r\n\r\n" };
     const thread = try std.Thread.spawn(.{}, TestClient.run, .{&client});
     var taken: std.ArrayList(*Request) = .empty;
     defer taken.deinit(gpa);
@@ -1206,9 +1170,9 @@ test "an event published as the stream is answered arrives while the stream stay
     // though its connection has not written the headers yet.
     taken.items[0].answerStream(&server);
     server.publish("first", "1");
-    // The client must finish on the message, while the server still holds the stream open.
-    thread.join();
+    io.sleep(.fromMilliseconds(50), .awake) catch {};
     server.stop();
+    thread.join();
     try std.testing.expect(std.mem.endsWith(u8, client.reply[0..client.reply_len], "\r\n\r\nevent: first\ndata: 1\n\n"));
 }
 
@@ -1399,23 +1363,3 @@ test "a client that leaves an upgraded connection finishes its link" {
 test {
     _ = Link;
 }
-
-test "a thousand listeners stop without a client waking accept" {
-    if (!Io.net.has_unix_sockets) return error.SkipZigTest;
-    const gpa = std.testing.allocator;
-    const io = std.testing.io;
-    const dog = try Watchdog.start(gpa, io, @src().fn_name);
-    defer dog.stop();
-    var tmp = std.testing.tmpDir(.{});
-    defer tmp.cleanup();
-    const path = try testSocket(gpa, &tmp);
-    defer gpa.free(path);
-    defer removeTestSocket(path);
-
-    // Reuse the path, as repeated launches in one profile do.
-    for (0..1000) |_| {
-        var server: Server = .{ .gpa = gpa, .io = io, .socket_path = path, .wake = noWake };
-        try server.start();
-        server.stop();
-    }
-}
diff --git a/app/history_transport.zig b/app/history_transport.zig
index c0c0463a1..77d875665 100644
--- a/app/history_transport.zig
+++ b/app/history_transport.zig
@@ -184,9 +184,9 @@ pub fn stopAt(x: f32, x0: f32, x1: f32, n: usize) usize {
 }
 
 /// Where stop `i` of `n` sits on the line from `x0` to `x1`: evenly spaced, stop 0 at `x0` and
-/// stop `n` at `x1`, so the knob reaches both ends. With no history, the one stop is at `x0`.
+/// stop `n` at `x1`, so the knob reaches both ends. With no history, the one stop is in the middle.
 pub fn stopX(i: usize, x0: f32, x1: f32, n: usize) f32 {
-    if (n == 0) return x0;
+    if (n == 0) return (x0 + x1) / 2;
     return x0 + (x1 - x0) * @as(f32, @floatFromInt(i)) / @as(f32, @floatFromInt(n));
 }
 
@@ -344,7 +344,7 @@ test "stop 0 is at the left end, stop n at the right, and stopAt inverts stopX"
         try testing.expectApproxEqAbs(@as(f32, 220), stopX(n, 20, 220, n), 1e-3);
         for (0..n + 1) |i| try testing.expectEqual(i, stopAt(stopX(i, 20, 220, n), 20, 220, n));
     }
-    try testing.expectEqual(@as(f32, 20), stopX(0, 20, 220, 0));
+    try testing.expectEqual(@as(f32, 120), stopX(0, 20, 220, 0));
 }
 
 test "a bar told to go goes from where it is, and one left goes soon" {
diff --git a/app/layout/Floats.zig b/app/layout/Floats.zig
index 91ce807ef..30b2475af 100644
--- a/app/layout/Floats.zig
+++ b/app/layout/Floats.zig
@@ -209,11 +209,6 @@ const ghost_blur: f32 = 0.55;
 /// Where `Float.aside` goes for a ghost closing — its last view landed elsewhere: past the ghost,
 /// to nothing.
 const gone: f32 = 2;
-/// The leading traffic light of a titled macOS window, points: its diameter, and how far its left
-/// edge sits in from the window's. A tape presses the same spot in the frame, since the OS draws
-/// the button outside it.
-const traffic_light_diameter: f32 = 12;
-const traffic_light_inset: f32 = 7;
 
 /// How a float looks `v` of the way aside (`Float.aside`): itself at 0, its ghost at 1, nothing
 /// at `gone` — how much of it shows, and how far out of focus.
@@ -684,8 +679,8 @@ fn drawOne(l: *Layout, i: usize) bool {
     // click there never reaches it. A tape aims at the same spot in the frame (the leading
     // traffic light), and a press there closes the float as the OS button does.
     if (header_close == null and osButtons(first) and core.anchor.wanted()) {
-        const side = traffic_light_diameter * scale;
-        const spot: dvui.Rect.Physical = .{ .x = header.x + traffic_light_inset * scale, .y = header.y + (header.h - side) / 2, .w = side, .h = side };
+        const side = 12 * scale;
+        const spot: dvui.Rect.Physical = .{ .x = header.x + 7 * scale, .y = header.y + (header.h - side) / 2, .w = side, .h = side };
         core.anchor.markRect(win_id, spot, true, "float-close:{s}", .{first.name});
         for (dvui.events()) |*e| {
             if (e.evt != .mouse or e.handled) continue;
diff --git a/app/layout/Region.zig b/app/layout/Region.zig
index 01c54b483..bbe5bf638 100644
--- a/app/layout/Region.zig
+++ b/app/layout/Region.zig
@@ -1437,9 +1437,7 @@ fn initTree(
 /// A turn is the new half sliding shut along the old axis (`_fold`, which its place reads as a
 /// target of zero), then easing open along the new one. Its share of the box is kept through the
 /// turn (`_share`, taken from the extent when that was last chosen, not from a box that has since
-/// changed shape), and follows a drag while turned. That drag is shown and nothing more: turning
-/// back takes the share from the saved one again (`_seen` is unread while turned, so dvui drops it
-/// and the first frame back reads the saved share anew).
+/// changed shape), and follows a drag while turned.
 fn orientBranch(self: *Layout, saved: SplitTree.Branch, id: dvui.Id) SplitTree.Branch {
     if (!saved.adaptive) return saved;
     const dims = dvui.dataGet(null, id, "_dims", dvui.Size) orelse return saved;
@@ -1464,10 +1462,10 @@ fn orientBranch(self: *Layout, saved: SplitTree.Branch, id: dvui.Id) SplitTree.B
             }
         }
     } else if (chosen) |extent| {
-        // Dragged since the branch set it: the drag is the share drawn, and is not saved.
+        // Dragged since the branch set it: the drag is the new share.
         const set = dvui.dataGet(null, id, "_set", f32) orelse extent;
         const room = alongSize(drawn.dir, dims);
-        if (set != extent and room > 0) dvui.dataSet(null, id, "_share", std.math.clamp(extent / room, 0, 1));
+        if (set != extent and room > 0) setShare(self, saved.created, id, std.math.clamp(extent / room, 0, 1));
     }
     const share = dvui.dataGet(null, id, "_share", f32) orelse return drawn;
 
diff --git a/app/layout/SplitTree.zig b/app/layout/SplitTree.zig
index 78fa33e27..bcb8b86f6 100644
--- a/app/layout/SplitTree.zig
+++ b/app/layout/SplitTree.zig
@@ -6,10 +6,8 @@
 //! picker fills them. Closing an empty leaf collapses the branch.
 const std = @import("std");
 const dvui = @import("dvui");
-const core = @import("core");
 
-/// The docking widget's side: a pane tree and a place tree name an edge the same way.
-pub const Side = core.widgets.DockLayout.Side;
+pub const Side = enum { left, right, top, bottom };
 
 pub fn axisOf(side: Side) dvui.enums.Direction {
     return switch (side) {
diff --git a/app/layout/State.zig b/app/layout/State.zig
index 243029465..46aa109cf 100644
--- a/app/layout/State.zig
+++ b/app/layout/State.zig
@@ -38,14 +38,6 @@ pub const StoreOffer = struct {
     title: []const u8,
 };
 
-/// An app's answer to where an open beside splits a place (`beside`).
-pub const Beside = struct {
-    ctx: *anyopaque,
-    /// The edge of place `name` an open beside splits, or null where it joins a place, becomes a
-    /// card, or `name` holds no documents.
-    edge: *const fn (ctx: *anyopaque, name: []const u8) ?SplitTree.Side,
-};
-
 /// How an application gives a document a home outside the slots its plugins made: a view of its
 /// own that holds documents (fizzy's workspaces). With one, a document carried in the view drag
 /// lands in any place as a view would, inside a new such view (`ViewDrag.place`).
@@ -177,11 +169,10 @@ tree_cleared: bool = false,
 slide_open: []const u8 = "",
 /// A place's view being dragged to another place. Empty `name` when idle.
 view_drag: ViewDrag = .{},
-/// Set each frame by the app while a demo plays: asked for each place a drag may land in, it
-/// names the edge an open beside splits that place on. That edge's drop zone is also published as
-/// the anchor `drop:beside`, so a tape aims at the target place's own answer, not at an edge it
-/// chose when it was written.
-beside: ?Beside = null,
+/// The edge an open beside splits the documents' place on right now, set each frame by the app
+/// while a demo plays: that edge's drop zone is also published as the anchor `drop:beside`, so a
+/// tape aims at the place's answer, not at an edge it chose when it was written.
+beside: ?SplitTree.Side = null,
 /// Floats are OS windows of their own (the application says so each frame, where it has them): a
 /// view let go over no window of the app's opens one there (`ViewDrag.apply`).
 floats_windowed: bool = false,
diff --git a/app/layout/ViewDrag.zig b/app/layout/ViewDrag.zig
index 73e449dc8..ce83ef85d 100644
--- a/app/layout/ViewDrag.zig
+++ b/app/layout/ViewDrag.zig
@@ -1323,21 +1323,18 @@ pub fn drawZones(l: *Layout, name: []const u8, key: dvui.Id) void {
     // is the target, so a demo aims at the bubble rather than an offset from the place's middle.
     // Marked only while a tape asks for anchors, and ahead of the offer queue's limit (which has
     // nothing to do with the bubble being there).
-    if (target and !covered and core.anchor.wanted()) {
-        const beside = if (l.state.beside) |aim_at| aim_at.edge(aim_at.ctx, name) else null;
-        for (DropZones.all) |z| {
-            if (z == .remove and !zones.remove) continue;
-            const b = zones.bubble(z);
-            const r: dvui.Rect.Physical = .{ .x = b.c.x - b.r, .y = b.c.y - b.r, .w = 2 * b.r, .h = 2 * b.r };
-            switch (z) {
-                .edge => |side| {
-                    core.anchor.markRect(key, r, true, "drop:{t}", .{side});
-                    if (beside == side) core.anchor.markRect(key, r, true, "drop:beside", .{});
-                },
-                else => core.anchor.markRect(key, r, true, "drop:{t}", .{z}),
-            }
+    if (target and !covered and core.anchor.wanted()) for (DropZones.all) |z| {
+        if (z == .remove and !zones.remove) continue;
+        const b = zones.bubble(z);
+        const r: dvui.Rect.Physical = .{ .x = b.c.x - b.r, .y = b.c.y - b.r, .w = 2 * b.r, .h = 2 * b.r };
+        switch (z) {
+            .edge => |side| {
+                core.anchor.markRect(key, r, true, "drop:{t}", .{side});
+                if (l.state.beside) |aimed_side| if (std.mem.eql(u8, @tagName(aimed_side), @tagName(side))) core.anchor.markRect(key, r, true, "drop:beside", .{});
+            },
+            else => core.anchor.markRect(key, r, true, "drop:{t}", .{z}),
         }
-    }
+    };
     // Queued, not drawn: over everything, once every place has drawn (`drawOverlay`).
     const now = dvui.currentWindow().frame_time_ns;
     if (d.pending_frame != now) {
diff --git a/app/update/bounded_join.zig b/app/update/bounded_join.zig
index cebac162c..eeb91e5df 100644
--- a/app/update/bounded_join.zig
+++ b/app/update/bounded_join.zig
@@ -6,9 +6,9 @@ const std = @import("std");
 /// instead and returns false. The caller owns what the thread still touches: it must outlive
 /// the process or the thread must touch nothing torn down meanwhile.
 pub fn joinWithin(io: std.Io, thread: std.Thread, done: *const std.atomic.Value(bool), bound_ms: u32) bool {
-    const start = std.Io.Clock.awake.now(io);
-    while (!done.load(.acquire)) {
-        if (start.durationTo(std.Io.Clock.awake.now(io)).toMilliseconds() >= bound_ms) {
+    var waited_ms: u32 = 0;
+    while (!done.load(.acquire)) : (waited_ms += poll_ms) {
+        if (waited_ms >= bound_ms) {
             thread.detach();
             return false;
         }
@@ -22,28 +22,21 @@ const poll_ms = 5;
 
 test "a stalled thread is detached once the bound passes" {
     const Stall = struct {
-        // The test thread releases the check; the worker publishes entry and completion.
-        var entered: std.atomic.Value(bool) = .init(false);
         var release: std.atomic.Value(bool) = .init(false);
         var done: std.atomic.Value(bool) = .init(false);
         fn run(io: std.Io) void {
-            entered.store(true, .release);
             while (!release.load(.acquire)) io.sleep(.fromMilliseconds(1), .awake) catch {};
             done.store(true, .release);
         }
     };
     const io = std.testing.io;
     const thread = try std.Thread.spawn(.{}, Stall.run, .{io});
-    defer {
-        Stall.release.store(true, .release);
-        while (!Stall.done.load(.acquire)) io.sleep(.fromMilliseconds(1), .awake) catch {};
-    }
-    while (!Stall.entered.load(.acquire)) io.sleep(.fromMilliseconds(1), .awake) catch {};
     const start = std.Io.Clock.awake.now(io);
     try std.testing.expect(!joinWithin(io, thread, &Stall.done, 50));
     const elapsed = start.durationTo(std.Io.Clock.awake.now(io));
     try std.testing.expect(elapsed.toMilliseconds() < 1000);
-    try std.testing.expect(!Stall.done.load(.acquire));
+    Stall.release.store(true, .release);
+    while (!Stall.done.load(.acquire)) io.sleep(.fromMilliseconds(1), .awake) catch {};
 }
 
 test "a finished thread is joined" {
diff --git a/app/update/update_notify.zig b/app/update/update_notify.zig
index dec9a5a49..ec1fe1656 100644
--- a/app/update/update_notify.zig
+++ b/app/update/update_notify.zig
@@ -96,7 +96,7 @@ fn startCheck() void {
     }
 
     // The worker may outlive `deinit` (see there), so it cannot borrow the app's allocator.
-    check_thread = std.Thread.spawn(.{}, worker, .{}) catch {
+    check_thread = std.Thread.spawn(.{}, worker, .{ io, std.heap.page_allocator }) catch {
         phase.store(@backingInt(Phase.done_no), .release);
         return;
     };
@@ -121,13 +121,8 @@ pub fn deinit(io: std.Io) void {
     check_thread = null;
 }
 
-fn worker() void {
+fn worker(io: std.Io, gpa: std.mem.Allocator) void {
     defer check_done.store(true, .release);
-    // A detached check must also outlive teardown of the application's Io.
-    const gpa = std.heap.page_allocator;
-    var threaded: std.Io.Threaded = .init(gpa, .{});
-    defer threaded.deinit();
-    const io = threaded.io();
     var ver_buf: [128]u8 = undefined;
     const summary = auto_update.checkRemoteVersionSummary(io, gpa, &ver_buf) catch {
         phase.store(@backingInt(Phase.done_no), .release);
diff --git a/backend/src/SDLBackend.zig b/backend/src/SDLBackend.zig
index 51b148979..9df175e70 100644
--- a/backend/src/SDLBackend.zig
+++ b/backend/src/SDLBackend.zig
@@ -216,9 +216,6 @@ pub const Viewport = struct {
     /// pointer is read against it, and it is kept above every window by its level, not ordered over
     /// the main one.
     passive: bool = false,
-    /// Windows: whether a carry window is topmost, as last applied
-    /// (`win32_titlebar.viewportCarryTopmost`): while the app is active, not after it is left.
-    carry_topmost: bool = true,
     /// A held pointer over it is read as over what is beneath it — the main window — this frame
     /// (`viewportSeeThrough`): a float's window gone to its ghost while a view is carried out of it.
     see_through: bool = false,
@@ -1527,7 +1524,7 @@ pub fn viewportOpenMenu(self: *SDLBackend, at: viewport_map.Rect, radius: f32, r
         .macos => {
             _ = fizzy_macos_viewport_menu(cocoaWindow(vp.window), cocoaWindow(self.window), platform.window.ns_visual_effect_material, radius, @intFromBool(dialog));
             // Gone while the app is left (a quiet run is never active: its menus stay).
-            if (platform.window_layout.hidesWhenAppLeft(if (dialog) .dialog else .menu, quiet)) fizzy_macos_viewport_menu_hides(cocoaWindow(vp.window));
+            if (!dialog and !quiet) fizzy_macos_viewport_menu_hides(cocoaWindow(vp.window));
             vp.ride = switch (ride) {
                 .none => null,
                 .main => self.window,
@@ -1780,19 +1777,12 @@ fn openViewport(self: *SDLBackend, at: viewport_map.Rect, title_text: [:0]const
     // Dressed by `viewportOpenMenu`, and no hit test: nothing in it moves or resizes it.
     if (menu) return vp;
     if (role == .overlay) {
-        if (comptime builtin.target.os.tag == .macos) {
-            fizzy_macos_viewport_overlay(cocoaWindow(window), cocoaWindow(self.window));
-            // Its bubbles and zones stood over other apps' windows while fizzy was in the background.
-            if (platform.window_layout.hidesWhenAppLeft(.overlay, quiet)) fizzy_macos_viewport_menu_hides(cocoaWindow(window));
-        }
+        if (comptime builtin.target.os.tag == .macos) fizzy_macos_viewport_overlay(cocoaWindow(window), cocoaWindow(self.window));
         return vp;
     }
     if (carry) {
         switch (comptime builtin.target.os.tag) {
-            .macos => {
-                fizzy_macos_viewport_carry(cocoaWindow(window), cocoaWindow(self.window), platform.window.ns_visual_effect_material);
-                if (platform.window_layout.hidesWhenAppLeft(.carry, quiet)) fizzy_macos_viewport_menu_hides(cocoaWindow(window));
-            },
+            .macos => fizzy_macos_viewport_carry(cocoaWindow(window), cocoaWindow(self.window), platform.window.ns_visual_effect_material),
             .windows => if (c.SDL_GetPointerProperty(c.SDL_GetWindowProperties(window), c.SDL_PROP_WINDOW_WIN32_HWND_POINTER, null)) |hwnd| {
                 platform.win32_titlebar.viewportCarryChrome(hwnd);
             },
@@ -2838,16 +2828,6 @@ pub fn renderPresent(self: *SDLBackend) void {
     // window is (`mainHeld`). Presented into while a sibling's way ran, every frame waited on its
     // drawable, and the moving window's way ran at 55 frames a second, the main window's at 120.
     const main_moving = platform.window.windowMovingItself(self.window);
-    // A carry window stands over every window only while the app is the active one.
-    if (comptime builtin.target.os.tag == .windows) {
-        const active = appActive();
-        for (&self.viewport_slots) |*slot| {
-            const vp = if (slot.*) |*v| v else continue;
-            if (!vp.passive or vp.carry_topmost == active) continue;
-            vp.carry_topmost = active;
-            if (c.SDL_GetPointerProperty(c.SDL_GetWindowProperties(vp.window), c.SDL_PROP_WINDOW_WIN32_HWND_POINTER, null)) |hwnd| platform.win32_titlebar.viewportCarryTopmost(hwnd, active);
-        }
-    }
     var moving_vp: ?*Viewport = null;
     for (&self.viewport_slots) |*slot| if (slot.*) |*v| if (v.shown and platform.window.windowMovingItself(v.window)) {
         moving_vp = v;
@@ -3587,8 +3567,6 @@ pub fn addEvent(self: *SDLBackend, win: *dvui.Window, event: c.SDL_Event) !bool
             if (self.log_events) {
                 log.debug("event FOCUS_GAINED\n", .{});
             }
-            // A frame to put a carry window back over the others (`renderPresent`).
-            if (builtin.target.os.tag == .windows) self.refresh();
             if (dvui.accesskit_enabled and builtin.target.os.tag == .linux) {
                 dvui.AccessKit.c.accesskit_unix_adapter_update_window_focus_state(win.accesskit.adapter, true);
             } else if (dvui.accesskit_enabled and builtin.target.os.tag == .macos) {
diff --git a/backend/src/platform/win32_titlebar.zig b/backend/src/platform/win32_titlebar.zig
index ca1847dc4..dca4597ca 100644
--- a/backend/src/platform/win32_titlebar.zig
+++ b/backend/src/platform/win32_titlebar.zig
@@ -576,21 +576,6 @@ pub fn viewportCarryChrome(hwnd: *anyopaque) void {
     _ = wm.SetWindowPos(h, @ptrFromInt(@as(usize, @bitCast(HWND_TOPMOST))), 0, 0, 0, 0, @bitCast(SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_FRAMECHANGED));
 }
 
-/// A carry window above every window while the app is active, and, once it is left, only over the
-/// window that owns it (`SDL_SetWindowParent`), which goes behind the other application's windows
-/// with the app: left topmost, the glass of a drop's zone stood over them.
-pub fn viewportCarryTopmost(hwnd: *anyopaque, on: bool) void {
-    if (builtin.target.os.tag != .windows) return;
-    const h: win32.foundation.HWND = @ptrCast(hwnd);
-    const HWND_TOPMOST: isize = -1;
-    const HWND_NOTOPMOST: isize = -2;
-    const SWP_NOSIZE: u32 = 0x0001;
-    const SWP_NOMOVE: u32 = 0x0002;
-    const SWP_NOACTIVATE: u32 = 0x0010;
-    const after: isize = if (on) HWND_TOPMOST else HWND_NOTOPMOST;
-    _ = win32.ui.windows_and_messaging.SetWindowPos(h, @ptrFromInt(@as(usize, @bitCast(after))), 0, 0, 0, 0, @bitCast(SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE));
-}
-
 /// The frame a carry window never has: caption, sizing border, system menu and its buttons.
 const carry_ws_frame: isize = 0x00C00000 | 0x00040000 | viewport_ws_sysmenu | 0x00020000 | 0x00010000;
 
diff --git a/backend/src/platform/window_layout.zig b/backend/src/platform/window_layout.zig
index cc757a2ca..19c21c0e7 100644
--- a/backend/src/platform/window_layout.zig
+++ b/backend/src/platform/window_layout.zig
@@ -126,28 +126,6 @@ pub fn originNudged(cap_x: f64, cap_y: f64, cur_x: f64, cur_y: f64, max_delta: f
     return dx <= max_delta and dy <= max_delta;
 }
 
-/// The app's windows that are not the user's documents: each sits at a popup's level, over every
-/// Space, and is not the main window.
-pub const Transient = enum { menu, dialog, overlay, carry };
-
-/// Whether a transient window leaves the screen while the app is not the active one. Left up, it
-/// stands over another application's windows. A dialog is in the main window's stacking, and a
-/// quiet run is never active, so neither goes. The OS applies it (`hidesOnDeactivate`), so it holds
-/// with no frame of ours running; a drag keeps its windows because pressing in the app keeps it
-/// active.
-pub fn hidesWhenAppLeft(kind: Transient, quiet: bool) bool {
-    return kind != .dialog and !quiet;
-}
-
-test "hidesWhenAppLeft: menus, overlays and carry windows go with the app, dialogs and quiet runs stay" {
-    inline for (.{ Transient.menu, Transient.overlay, Transient.carry }) |kind| {
-        try std.testing.expect(hidesWhenAppLeft(kind, false));
-        try std.testing.expect(!hidesWhenAppLeft(kind, true));
-    }
-    try std.testing.expect(!hidesWhenAppLeft(.dialog, false));
-    try std.testing.expect(!hidesWhenAppLeft(.dialog, true));
-}
-
 test "chooseTitlebarStrip collapsed returns just the buffer" {
     const got = chooseTitlebarStrip(.{
         .collapsed = true,
diff --git a/build/app.zig b/build/app.zig
index 15d8a8c2f..34cf3b592 100644
--- a/build/app.zig
+++ b/build/app.zig
@@ -30,9 +30,6 @@ pub const WebPluginDir = struct {
     };
 };
 
-/// The type of `Chrome.sidebar_edge`, for the build option.
-const ChromeEdge = enum { left, right };
-
 pub const Options = struct {
     /// Every plugin the application links, fizzy's own among them, each in the executables its
     /// `targets` names — see `build.zig`'s `buildApp`.
@@ -101,10 +98,6 @@ pub const Config = struct {
     static_text: bool,
     static_image: bool,
     dynamic_plugins: bool,
-    chrome_sidebar_edge: ChromeEdge,
-    chrome_panel: bool,
-    chrome_menu_bar: bool,
-    chrome_infobar: bool,
     workbench_opts: *std.Build.Step.Options,
     /// Null on the configure pass that fetches Velopack (see `readConfig`).
     msvcup_before_compile: ?*std.Build.Step.Run,
@@ -510,20 +503,6 @@ pub fn readConfig(b: *std.Build, target: std.Build.ResolvedTarget, opts: Options
         "App-owned layout file (pub fn layout(?*anyopaque, *Layout))",
     );
     build_opts.addOption(bool, "has_app_layout", app_layout_path != null);
-    // The frame of fizzy's own shape an app keeps (`src/editor/Chrome.zig`); the defaults are
-    // fizzy's own.
-    const chrome_sidebar_edge = b.option(
-        ChromeEdge,
-        "chrome-sidebar-edge",
-        "Which end of the window the icon rail and Sidebar sit at: left (default) or right",
-    ) orelse .left;
-    const chrome_panel = b.option(bool, "chrome-panel", "Draw the bottom Panel and its Output view (default: true)") orelse true;
-    const chrome_menu_bar = b.option(bool, "chrome-menu-bar", "Draw the in-window menu bar (default: true)") orelse true;
-    const chrome_infobar = b.option(bool, "chrome-infobar", "Draw the infobar (default: true)") orelse true;
-    build_opts.addOption(ChromeEdge, "chrome_sidebar_edge", chrome_sidebar_edge);
-    build_opts.addOption(bool, "chrome_panel", chrome_panel);
-    build_opts.addOption(bool, "chrome_menu_bar", chrome_menu_bar);
-    build_opts.addOption(bool, "chrome_infobar", chrome_infobar);
     const static_workbench = b.option(
         bool,
         "static-workbench",
@@ -618,10 +597,6 @@ pub fn readConfig(b: *std.Build, target: std.Build.ResolvedTarget, opts: Options
         .static_text = static_text,
         .static_image = static_image,
         .dynamic_plugins = dynamic_plugins,
-        .chrome_sidebar_edge = chrome_sidebar_edge,
-        .chrome_panel = chrome_panel,
-        .chrome_menu_bar = chrome_menu_bar,
-        .chrome_infobar = chrome_infobar,
         .workbench_opts = workbench_opts,
         .msvcup_before_compile = msvcup_before_compile,
         .accesskit = accesskit,
@@ -812,10 +787,6 @@ fn native(
         pack_opts.addOption(bool, "static_image", static_image);
         pack_opts.addOption(bool, "dynamic_plugins", dynamic_plugins);
         pack_opts.addOption(bool, "has_app_layout", app_layout_path != null);
-        pack_opts.addOption(ChromeEdge, "chrome_sidebar_edge", cfg.chrome_sidebar_edge);
-        pack_opts.addOption(bool, "chrome_panel", cfg.chrome_panel);
-        pack_opts.addOption(bool, "chrome_menu_bar", cfg.chrome_menu_bar);
-        pack_opts.addOption(bool, "chrome_infobar", cfg.chrome_infobar);
         break :package_blk try fizzy_exe.addFizzyExecutableForTarget(
             b,
             vz,
@@ -1079,9 +1050,6 @@ fn addTests(
         // never-blank visible-range guarantee. std-only by design (see block_heights.zig) so
         // the rules the preview's scroll stability rests on are testable without a Window.
         .{ "fizzy-md-block-heights-tests", "plugins/markdown/src/md/block_heights.zig" },
-        // What the chat composer decides (Enter, its height cap, fences). std-only, so it tests
-        // without a Window.
-        .{ "fizzy-chat-composer-tests", "plugins/chat/src/composer.zig" },
         // Fence language tag → file extension, which is the whole of what the markdown plugin
         // knows about languages: the grammar itself comes from whichever plugin claims that
         // extension. std-only, so the table is testable without a Window.
@@ -1564,11 +1532,6 @@ fn addTests(
         .core = core_module_test,
         .sdk = sdk_module_test,
     }, fizzy_test_module);
-    const chat_module_test = plugins.chat.addStaticModule(b, target, optimize, .{
-        .dvui = dvui_testing_dep.module("dvui_testing"),
-        .core = core_module_test,
-        .sdk = sdk_module_test,
-    }, fizzy_test_module);
     // A `.zip` opened as a mounted folder, as the web opens the site (`tests/demos.zig`).
     const archive_module_test = plugins.archive.addStaticModule(b, target, optimize, .{
         .dvui = dvui_testing_dep.module("dvui_testing"),
@@ -1629,8 +1592,6 @@ fn addTests(
     // built above rather than rooting a second one at the widget — a file may belong to only
     // one module per compilation, and the plugin's own module already owns it.
     integration_module.addImport("text", text_module_test);
-    // The chat composer's growth and Enter are drawn behaviour, so a headless frame checks them.
-    integration_module.addImport("chat", chat_module_test);
     // Same reasoning for the markdown preview: its block virtualization is a claim about what
     // gets *drawn*, which only a real headless frame can check.
     integration_module.addImport("markdown", markdown_module_test);
@@ -2103,16 +2064,6 @@ fn addTests(
         check_integration_step.dependOn(&text_plugin_tests.step);
     }
 
-    {
-        const chat_plugin_tests = b.addTest(.{
-            .name = "fizzy-chat-plugin-tests",
-            .root_module = chat_module_test,
-            .filters = test_filters,
-        });
-        test_integration_step.dependOn(&b.addRunArtifact(chat_plugin_tests).step);
-        check_integration_step.dependOn(&chat_plugin_tests.step);
-    }
-
     // Give the file extension tests a root; the plugin's lazy exports do not collect them.
     {
         const files_tests_module = b.createModule(.{
diff --git a/build/plugins.zig b/build/plugins.zig
index 814995929..1a2e5cdb0 100644
--- a/build/plugins.zig
+++ b/build/plugins.zig
@@ -15,7 +15,6 @@ pub const image = @import("../plugins/image/static/integration.zig");
 pub const archive = @import("../plugins/archive/static/integration.zig");
 pub const devtools = @import("../plugins/devtools/static/integration.zig");
 pub const guides = @import("../plugins/guides/static/integration.zig");
-pub const chat = @import("../plugins/chat/static/integration.zig");
 
 /// Fizzy's own plugins, as entries in the list an application links (`fizzy.plugins`). An entry
 /// with no module is built by fizzy for each executable, wired to that executable's framework.
@@ -27,7 +26,6 @@ pub const entries = struct {
     pub const markdown: BundledPlugin = .{ .name = "markdown" };
     pub const devtools: BundledPlugin = .{ .name = "devtools" };
     pub const guides: BundledPlugin = .{ .name = "guides" };
-    pub const chat: BundledPlugin = .{ .name = "chat" };
 
     /// What fizzy itself links, in its sidebar order.
     pub const all = [_]BundledPlugin{
@@ -150,14 +148,6 @@ pub fn link(b: *std.Build, w: Wiring, plugins: []const BundledPlugin) Linked {
                 .{ .dvui = w.dvui, .core = w.core, .sdk = w.sdk },
                 w.consumer,
             )
-        else if (std.mem.eql(u8, p.name, "chat"))
-            chat.addStaticModule(
-                b,
-                w.target,
-                w.optimize,
-                .{ .dvui = w.dvui, .core = w.core, .sdk = w.sdk },
-                w.consumer,
-            )
         else
             std.debug.panic(
                 "fizzy: plugin '{s}' has no module and is not one of fizzy's own (`fizzy.plugins`)",
diff --git a/build/web.zig b/build/web.zig
index c2f95795f..542dc447a 100644
--- a/build/web.zig
+++ b/build/web.zig
@@ -385,11 +385,6 @@ pub fn build(
     // The far end of a web OAuth round trip (`core.transport.WebOAuth`): the page a provider
     // redirects back to, which posts its location to the opener and closes.
     _ = dir.addCopyFile(b.path("web/oauth-callback.html"), "oauth-callback.html");
-    // The installable page (relative paths, so /app/ and /testapp/ both work) and the icons it
-    // and the iOS home-screen entry name.
-    for ([_][]const u8{ "manifest.webmanifest", "icon-192.png", "icon-512.png" }) |name| {
-        _ = dir.addCopyFile(b.path(b.pathJoin(&.{ "web", name })), name);
-    }
     // The tapes the page can fetch (`?demo=demos/<name>.tape`), built from this commit's scripts.
     const demos: ?std.Build.LazyPath = if (own) demoTapes(b) else null;
     if (demos) |tapes| _ = dir.addCopyDirectory(tapes, "demos", .{});
diff --git a/core/lsp/Client.zig b/core/lsp/Client.zig
index 8feab0ae6..5b63e9315 100644
--- a/core/lsp/Client.zig
+++ b/core/lsp/Client.zig
@@ -595,11 +595,7 @@ fn setHoverReturnScratch(self: *Client, gpa: std.mem.Allocator, text: []const u8
 /// slot for it and no caller needs it (only `resolveCompletionDocumentation`, which reads the
 /// cache directly instead). Items that fail to dupe are skipped, matching `runCompletionJob`'s
 /// existing "partial list beats none" stance.
-fn setCompletionReturnScratch(
-    self: *Client,
-    gpa: std.mem.Allocator,
-    cached: []const CachedCompletionItem,
-) []const CompletionItem {
+fn setCompletionReturnScratch(self: *Client, gpa: std.mem.Allocator, cached: []const CachedCompletionItem) []const CompletionItem {
     for (self.completion_return_scratch.items) |it| {
         gpa.free(it.label);
         gpa.free(it.insert_text);
@@ -666,11 +662,7 @@ pub fn hover(self: *Client, path: []const u8, bytes: []const u8, byte_offset: us
     if (path.len == 0) return null;
 
     const gpa = self.config.allocator;
-    const key: CacheKey = .{
-        .path_hash = std.hash.Wyhash.hash(0, path),
-        .byte_offset = byte_offset,
-        .content_hash = std.hash.Wyhash.hash(0, bytes),
-    };
+    const key: CacheKey = .{ .path_hash = std.hash.Wyhash.hash(0, path), .byte_offset = byte_offset, .content_hash = std.hash.Wyhash.hash(0, bytes) };
 
     // Serve a still-valid cache hit even when the server has crashed — better than blanking
     // every tooltip the moment the pipe closes. Only after a miss do we check liveness.
@@ -750,10 +742,7 @@ pub fn hover(self: *Client, path: []const u8, bytes: []const u8, byte_offset: us
     // is actually waiting on. The job currently in `runHoverJob` (already dequeued) still
     // finishes and caches; only not-yet-started work is dropped.
     self.dropQueuedHoverJobsLocked();
-    self.queue.append(
-        gpa,
-        .{ .path = owned_path, .bytes = owned_bytes, .byte_offset = byte_offset, .key = key },
-    ) catch {
+    self.queue.append(gpa, .{ .path = owned_path, .bytes = owned_bytes, .byte_offset = byte_offset, .key = key }) catch {
         self.queue_lock.unlock();
         gpa.free(owned_path);
         gpa.free(owned_bytes);
@@ -905,11 +894,7 @@ pub fn completion(self: *Client, path: []const u8, bytes: []const u8, byte_offse
     if (!(std.ascii.isAlphanumeric(prev) or prev == '_' or prev == '.' or prev == '@')) return null;
 
     const gpa = self.config.allocator;
-    const key: CacheKey = .{
-        .path_hash = std.hash.Wyhash.hash(0, path),
-        .byte_offset = byte_offset,
-        .content_hash = std.hash.Wyhash.hash(0, bytes),
-    };
+    const key: CacheKey = .{ .path_hash = std.hash.Wyhash.hash(0, path), .byte_offset = byte_offset, .content_hash = std.hash.Wyhash.hash(0, bytes) };
 
     self.completion_cache_lock.lock();
     if (self.completion_cache.get(key)) |entry| {
@@ -964,13 +949,7 @@ pub fn completion(self: *Client, path: []const u8, bytes: []const u8, byte_offse
 /// (same `CacheKey` derivation) so the raw item JSON needed to actually resolve can be found;
 /// `index` out of range, or no completion cache entry for that key at all (evicted, or the
 /// original request never completed), is a clean "nothing to resolve" rather than an error.
-pub fn resolveCompletionDocumentation(
-    self: *Client,
-    path: []const u8,
-    bytes: []const u8,
-    byte_offset: usize,
-    index: usize,
-) ?[]const u8 {
+pub fn resolveCompletionDocumentation(self: *Client, path: []const u8, bytes: []const u8, byte_offset: usize, index: usize) ?[]const u8 {
     if (path.len == 0) return null;
     if (!self.ensureStarted(path)) return null;
     // zls declares `resolveProvider: false` and always answers `completionItem/resolve` with
@@ -979,11 +958,7 @@ pub fn resolveCompletionDocumentation(
     if (!self.completion_resolve_supported) return null;
 
     const gpa = self.config.allocator;
-    const completion_key: CacheKey = .{
-        .path_hash = std.hash.Wyhash.hash(0, path),
-        .byte_offset = byte_offset,
-        .content_hash = std.hash.Wyhash.hash(0, bytes),
-    };
+    const completion_key: CacheKey = .{ .path_hash = std.hash.Wyhash.hash(0, path), .byte_offset = byte_offset, .content_hash = std.hash.Wyhash.hash(0, bytes) };
     const key: ResolveKey = .{ .completion_key = completion_key, .index = index };
 
     self.resolve_cache_lock.lock();
@@ -1070,22 +1045,14 @@ pub fn signatureHelp(self: *Client, path: []const u8, bytes: []const u8, byte_of
     if (!insideOpenCall(bytes, byte_offset)) return null;
 
     const gpa = self.config.allocator;
-    const key: CacheKey = .{
-        .path_hash = std.hash.Wyhash.hash(0, path),
-        .byte_offset = byte_offset,
-        .content_hash = std.hash.Wyhash.hash(0, bytes),
-    };
+    const key: CacheKey = .{ .path_hash = std.hash.Wyhash.hash(0, path), .byte_offset = byte_offset, .content_hash = std.hash.Wyhash.hash(0, bytes) };
 
     self.signature_help_cache_lock.lock();
     if (self.signature_help_cache.get(key)) |entry| {
         // Copy out *while still holding the lock* — see `hover_return_scratch`'s doc comment.
         const result: ?SignatureHelpResult = if (entry.result) |r| blk: {
             const label_copy = self.setSignatureHelpReturnScratch(gpa, r.label) orelse break :blk null;
-            break :blk .{
-                .label = label_copy,
-                .active_param_start = r.active_param_start,
-                .active_param_end = r.active_param_end,
-            };
+            break :blk .{ .label = label_copy, .active_param_start = r.active_param_start, .active_param_end = r.active_param_end };
         } else null;
         self.signature_help_cache_lock.unlock();
         return result;
@@ -1164,10 +1131,7 @@ fn ensureStarted(self: *Client, doc_path: []const u8) bool {
                 // `ConcurrencyUnavailable` is a documented transient condition (pool
                 // exhaustion) — leave state as `not_started` so the next hover retries,
                 // rather than permanently disabling the client the way `.unavailable` would.
-                dvui.log.warn(
-                    "{s}: Io.Group.concurrent(startupThreadMain) failed: {any}",
-                    .{ self.config.language_id, err },
-                );
+                dvui.log.warn("{s}: Io.Group.concurrent(startupThreadMain) failed: {any}", .{ self.config.language_id, err });
                 return false;
             };
             self.state.store(.starting, .release);
@@ -1205,11 +1169,7 @@ fn startupThreadMain(self: *Client, io: std.Io) void {
         if (err == error.ShuttingDown) return;
         dvui.log.warn("{s}: language server unavailable ({any})", .{ self.config.language_id, err });
         var msg_buf: [256]u8 = undefined;
-        const msg = std.mem.print(
-            &msg_buf,
-            "language server unavailable ({any})",
-            .{err},
-        ) catch "language server unavailable";
+        const msg = std.mem.print(&msg_buf, "language server unavailable ({any})", .{err}) catch "language server unavailable";
         self.config.log(self.config.language_id, .warn, msg);
         self.state.store(.unavailable, .release);
         self.config.refresh();
@@ -1262,16 +1222,9 @@ fn spawnProcess(self: *Client, io: std.Io) !void {
     if (self.shutdown.load(.acquire)) return error.ShuttingDown;
 
     const spawned = spawnChild(gpa, io, argv, root) catch |err| {
-        dvui.log.warn(
-            "{s}: could not spawn \"{s}\" ({any}) — hover/goto-definition disabled for this session",
-            .{ self.config.language_id, argv[0], err },
-        );
+        dvui.log.warn("{s}: could not spawn \"{s}\" ({any}) — hover/goto-definition disabled for this session", .{ self.config.language_id, argv[0], err });
         var msg_buf: [256]u8 = undefined;
-        const msg = std.mem.print(
-            &msg_buf,
-            "could not spawn \"{s}\" ({any}) — hover/goto-definition disabled for this session",
-            .{ argv[0], err },
-        ) catch "could not spawn language server";
+        const msg = std.mem.print(&msg_buf, "could not spawn \"{s}\" ({any}) — hover/goto-definition disabled for this session", .{ argv[0], err }) catch "could not spawn language server";
         self.config.log(self.config.language_id, .warn, msg);
         return err;
     };
@@ -1955,16 +1908,7 @@ fn cacheHoverResult(self: *Client, io: std.Io, gpa: std.mem.Allocator, key: Cach
         // for a key whose next answer turned out positive, and linger there unused forever.
         _ = self.unconfirmed_negative_keys.remove(key);
     }
-    self.hover_cache.put(
-        gpa,
-        key,
-        .{
-            .text = owned_text,
-            .seq = self.cache_seq,
-            .cached_at = cached_at,
-            .confirmed_negative = confirmed_negative,
-        },
-    ) catch {
+    self.hover_cache.put(gpa, key, .{ .text = owned_text, .seq = self.cache_seq, .cached_at = cached_at, .confirmed_negative = confirmed_negative }) catch {
         if (owned_text) |t| gpa.free(t);
         return;
     };
@@ -2144,12 +2088,7 @@ fn runCompletionJob(self: *Client, io: std.Io, pc: PendingCompletion) !void {
 /// in the cache and evicts the oldest entry if it's now over `completion_cache_limit`.
 /// `owned_items`, if non-null, must already be owned by `gpa` (the slice and every owned field
 /// inside each entry, `raw_json` included) — this function takes ownership.
-fn cacheCompletionResult(
-    self: *Client,
-    gpa: std.mem.Allocator,
-    key: CacheKey,
-    owned_items: ?[]CachedCompletionItem,
-) void {
+fn cacheCompletionResult(self: *Client, gpa: std.mem.Allocator, key: CacheKey, owned_items: ?[]CachedCompletionItem) void {
     self.completion_cache_lock.lock();
     defer self.completion_cache_lock.unlock();
     self.completion_cache_seq += 1;
@@ -2258,12 +2197,7 @@ fn runSignatureHelpJob(self: *Client, io: std.Io, ps: PendingSignatureHelp) !voi
 /// `SignatureHelpCacheEntry.result`) in the cache and evicts the oldest entry if it's now over
 /// `signature_help_cache_limit`. `owned_result`, if non-null, must already have a gpa-owned
 /// `label` — this function takes ownership.
-fn cacheSignatureHelpResult(
-    self: *Client,
-    gpa: std.mem.Allocator,
-    key: CacheKey,
-    owned_result: ?SignatureHelpResult,
-) void {
+fn cacheSignatureHelpResult(self: *Client, gpa: std.mem.Allocator, key: CacheKey, owned_result: ?SignatureHelpResult) void {
     self.signature_help_cache_lock.lock();
     defer self.signature_help_cache_lock.unlock();
     self.signature_help_cache_seq += 1;
@@ -2619,11 +2553,7 @@ fn resolveSignatureHelp(result: std.json.Value) ?ResolvedSignatureHelp {
     return switch (param_label) {
         .string => |s| blk: {
             const idx = std.mem.find(u8, label, s) orelse break :blk no_emphasis;
-            break :blk ResolvedSignatureHelp{
-                .label = label,
-                .active_param_start = idx,
-                .active_param_end = idx + s.len,
-            };
+            break :blk ResolvedSignatureHelp{ .label = label, .active_param_start = idx, .active_param_end = idx + s.len };
         },
         .array => |arr| blk: {
             if (arr.items.len != 2) break :blk no_emphasis;
@@ -2652,12 +2582,7 @@ const TextEditSpan = struct { start: usize, end: usize, new_text: []const u8 };
 /// correctly: edits are sorted by descending start offset and applied back-to-front, so each
 /// edit's byte range (computed against the *original* `bytes`/positions) stays valid — an
 /// earlier edit's insert/delete would otherwise shift every later offset.
-fn applyTextEdits(
-    gpa: std.mem.Allocator,
-    bytes: []const u8,
-    edits: []const std.json.Value,
-    encoding: Protocol.PositionEncoding,
-) ?[]u8 {
+fn applyTextEdits(gpa: std.mem.Allocator, bytes: []const u8, edits: []const std.json.Value, encoding: Protocol.PositionEncoding) ?[]u8 {
     var spans: std.ArrayList(TextEditSpan) = .empty;
     defer spans.deinit(gpa);
 
@@ -2672,16 +2597,8 @@ fn applyTextEdits(
         const end_char = jsonInt(end_pos, "character") orelse continue;
         if (start_line < 0 or start_char < 0 or end_line < 0 or end_char < 0) continue;
 
-        const start = Protocol.positionToByteOffset(
-            bytes,
-            .{ .line = @intCast(start_line), .character = @intCast(start_char) },
-            encoding,
-        );
-        const end = Protocol.positionToByteOffset(
-            bytes,
-            .{ .line = @intCast(end_line), .character = @intCast(end_char) },
-            encoding,
-        );
+        const start = Protocol.positionToByteOffset(bytes, .{ .line = @intCast(start_line), .character = @intCast(start_char) }, encoding);
+        const end = Protocol.positionToByteOffset(bytes, .{ .line = @intCast(end_line), .character = @intCast(end_char) }, encoding);
         if (end < start) continue;
         spans.append(gpa, .{ .start = start, .end = end, .new_text = new_text }) catch continue;
     }
@@ -2800,12 +2717,7 @@ fn syncDocument(self: *Client, io: std.Io, path: []const u8, bytes: []const u8)
 
     if (send_open) {
         try self.sendNotification(io, "textDocument/didOpen", .{
-            .textDocument = .{
-                .uri = uri,
-                .languageId = self.config.language_id,
-                .version = @as(i32, 1),
-                .text = bytes,
-            },
+            .textDocument = .{ .uri = uri, .languageId = self.config.language_id, .version = @as(i32, 1), .text = bytes },
         });
     } else {
         try self.sendNotification(io, "textDocument/didChange", .{
@@ -2839,10 +2751,7 @@ fn send(self: *Client, io: std.Io, value: anytype) !void {
     Protocol.writeMessage(gpa, &w.interface, value) catch |err| {
         // `WriteFailed` is std.Io.Writer's generic wrapper error; the real underlying OS
         // error (if any) is stashed on the concrete File.Writer for exactly this reason.
-        dvui.log.warn(
-            "{s}: send failed: {any} (underlying file-writer error: {any})",
-            .{ self.config.language_id, err, w.err },
-        );
+        dvui.log.warn("{s}: send failed: {any} (underlying file-writer error: {any})", .{ self.config.language_id, err, w.err });
         return err;
     };
 }
diff --git a/core/lsp/UriUtil.zig b/core/lsp/UriUtil.zig
index 9111e2c75..af231f83e 100644
--- a/core/lsp/UriUtil.zig
+++ b/core/lsp/UriUtil.zig
@@ -65,9 +65,7 @@ pub fn uriToPath(allocator: std.mem.Allocator, uri: []const u8) ![]u8 {
     if (comptime is_windows) {
         // `file:///C:/Users/...` decodes to `/C:/Users/...` above; strip the leading slash and
         // swap separators back to `\` so this round-trips into a usable native Windows path.
-        if (out.items.len >= 3 and out.items[0] == '/' and
-            std.ascii.isAlphabetic(out.items[1]) and out.items[2] == ':')
-        {
+        if (out.items.len >= 3 and out.items[0] == '/' and std.ascii.isAlphabetic(out.items[1]) and out.items[2] == ':') {
             _ = out.orderedRemove(0);
         }
         for (out.items) |*c| {
diff --git a/core/transport/NativeTransport.zig b/core/transport/NativeTransport.zig
index 2724d7195..bfa1fd467 100644
--- a/core/transport/NativeTransport.zig
+++ b/core/transport/NativeTransport.zig
@@ -114,13 +114,7 @@ pub fn transport(self: *NativeTransport) vfs.http.Transport {
 
 const vtable: vfs.http.Transport.VTable = .{ .request = request, .cancel = cancel, .pump = pump };
 
-fn request(
-    ptr: *anyopaque,
-    allocator: std.mem.Allocator,
-    req: vfs.http.Request,
-    cb: vfs.http.DoneFn,
-    ctx: ?*anyopaque,
-) vfs.Error!vfs.http.Job {
+fn request(ptr: *anyopaque, allocator: std.mem.Allocator, req: vfs.http.Request, cb: vfs.http.DoneFn, ctx: ?*anyopaque) vfs.Error!vfs.http.Job {
     const self: *NativeTransport = @ptrCast(@alignCast(ptr));
     if (comptime builtin.target.cpu.arch == .wasm32) return error.Unsupported;
     const a = self.gpa;
@@ -175,11 +169,7 @@ fn worker(job: *Job) void {
     // By its host alone: a URL's path and query can carry tokens, and a trace is for sharing.
     var name_buf: [64]u8 = undefined;
     const host = if (std.Uri.parse(job.url)) |u| (if (u.host) |h| h.percent_encoded else "") else |_| "";
-    const timed = @import("../profile/Spans.zig").span(std.mem.print(
-        &name_buf,
-        "http {t} {s}",
-        .{ job.method, host },
-    ) catch "http");
+    const timed = @import("../profile/Spans.zig").span(std.mem.print(&name_buf, "http {t} {s}", .{ job.method, host }) catch "http");
     const result = perform(job);
     timed.end();
     const self = job.owner;
diff --git a/core/transport/WebOAuth.zig b/core/transport/WebOAuth.zig
index 433e4f4c1..4811b1845 100644
--- a/core/transport/WebOAuth.zig
+++ b/core/transport/WebOAuth.zig
@@ -19,12 +19,7 @@ comptime {
 
 const wasm = struct {
     extern "fizzy" fn fizzy_web_oauth_open(url_ptr: [*]const u8, url_len: usize) void;
-    extern "fizzy" fn fizzy_web_oauth_open_page(
-        html_ptr: [*]const u8,
-        html_len: usize,
-        hash_ptr: [*]const u8,
-        hash_len: usize,
-    ) void;
+    extern "fizzy" fn fizzy_web_oauth_open_page(html_ptr: [*]const u8, html_len: usize, hash_ptr: [*]const u8, hash_len: usize) void;
     /// Writes the callback URL into `buf`; returns the length it needs (may exceed `len`).
     extern "fizzy" fn fizzy_web_oauth_callback_url(buf: [*]u8, len: usize) usize;
 };
@@ -55,13 +50,7 @@ pub fn begin(allocator: std.mem.Allocator, url: []const u8, cb: DoneFn, ctx: ?*a
 /// than one served beside the app: the page opens from a same-origin blob URL with `hash` as
 /// its fragment, and posts `{ fizzyOAuth }` to the opener like `oauth-callback.html` does.
 /// How a plugin loaded at runtime brings its own picker — nothing of it needs serving.
-pub fn beginPage(
-    allocator: std.mem.Allocator,
-    html: []const u8,
-    hash: []const u8,
-    cb: DoneFn,
-    ctx: ?*anyopaque,
-) error{Busy}!void {
+pub fn beginPage(allocator: std.mem.Allocator, html: []const u8, hash: []const u8, cb: DoneFn, ctx: ?*anyopaque) error{Busy}!void {
     if (pending != null) return error.Busy;
     pending = .{ .allocator = allocator, .cb = cb, .ctx = ctx };
     wasm.fizzy_web_oauth_open_page(html.ptr, html.len, hash.ptr, hash.len);
diff --git a/core/transport/WebTransport.zig b/core/transport/WebTransport.zig
index 411e77baa..ba804dd2f 100644
--- a/core/transport/WebTransport.zig
+++ b/core/transport/WebTransport.zig
@@ -58,13 +58,7 @@ pub fn transport(allocator: std.mem.Allocator) vfs.http.Transport {
 
 const vtable: vfs.http.Transport.VTable = .{ .request = request, .cancel = cancel, .pump = pump };
 
-fn request(
-    _: *anyopaque,
-    allocator: std.mem.Allocator,
-    req: vfs.http.Request,
-    cb: vfs.http.DoneFn,
-    ctx: ?*anyopaque,
-) vfs.Error!vfs.http.Job {
+fn request(_: *anyopaque, allocator: std.mem.Allocator, req: vfs.http.Request, cb: vfs.http.DoneFn, ctx: ?*anyopaque) vfs.Error!vfs.http.Job {
     const a = gpa orelse return error.Unsupported;
     const p = try a.create(Pending);
     errdefer a.destroy(p);
@@ -77,8 +71,7 @@ fn request(
     for (req.headers) |h| {
         // The line format is the protocol between Zig and JS; a CR/LF in a value would end
         // the line early (or trap the frame inside `Headers.append`), so it is refused here.
-        if (std.mem.findAny(u8, h.name, "\r\n:") != null or
-            std.mem.findAny(u8, h.value, "\r\n") != null) return error.Http;
+        if (std.mem.findAny(u8, h.name, "\r\n:") != null or std.mem.findAny(u8, h.value, "\r\n") != null) return error.Http;
         try lines.appendSlice(a, h.name);
         try lines.appendSlice(a, ": ");
         try lines.appendSlice(a, h.value);
@@ -90,17 +83,7 @@ fn request(
     p.id = id;
     try pending.put(a, id, p);
     const method = req.method.asSlice();
-    wasm.fizzy_web_request(
-        id,
-        method.ptr,
-        method.len,
-        req.url.ptr,
-        req.url.len,
-        lines.items.ptr,
-        lines.items.len,
-        req.body.ptr,
-        req.body.len,
-    );
+    wasm.fizzy_web_request(id, method.ptr, method.len, req.url.ptr, req.url.len, lines.items.ptr, lines.items.len, req.body.ptr, req.body.len);
     return .{ .id = id };
 }
 
diff --git a/core/widgets/DropZones.zig b/core/widgets/DropZones.zig
index a66ecc084..0db908e0e 100644
--- a/core/widgets/DropZones.zig
+++ b/core/widgets/DropZones.zig
@@ -48,7 +48,7 @@ const motion = @import("glass").motion;
 const liquid_glass = @import("glass").liquid_glass;
 const LiquidField = @import("glass").LiquidField;
 
-pub const Side = @import("DockingWidget/Layout.zig").Side;
+pub const Side = enum { left, right, top, bottom };
 
 pub const Zone = union(enum) {
     /// Into the place itself: a trade for a place that shows one view, a new tab for one that
diff --git a/core/widgets/ScrollArea.zig b/core/widgets/ScrollArea.zig
index bc3361d3d..6bd078b5a 100644
--- a/core/widgets/ScrollArea.zig
+++ b/core/widgets/ScrollArea.zig
@@ -35,9 +35,6 @@ const Touch = struct {
     x: Fling = .{},
     y: Fling = .{},
     dragging: bool = false,
-    coast_start_ns: i128 = 0,
-    coast_origin: dvui.Point = .{},
-    coast_velocity: dvui.Point = .{},
     /// The finger that owns the drag; another finger's release or motion is not this area's.
     finger: dvui.enums.Button = .none,
 };
@@ -59,7 +56,7 @@ pub const tuning: Fling.Tuning = .{
 pub fn init(src: std.builtin.SourceLocation, init_opts: dvui.ScrollAreaWidget.InitOpts, opts: dvui.Options) ScrollArea {
     const area = dvui.scrollArea(src, init_opts, opts);
     const c = &area.scroll.?;
-    var self: ScrollArea = .{
+    const self: ScrollArea = .{
         .area = area,
         .si = area.si,
         .touch = dvui.dataGetPtrDefault(null, c.data().id, "_touch", Touch, .{}),
@@ -80,14 +77,6 @@ pub fn init(src: std.builtin.SourceLocation, init_opts: dvui.ScrollAreaWidget.In
         self.touch.x.cancel();
         self.touch.y.cancel();
     }
-
-    // The coast moves the content before it is laid out, so a frame draws where the clock is at
-    // that frame. Moved after the children, it would draw where the clock was one gap ago, and
-    // an uneven gap would show as an uneven step.
-    if (!self.touch.dragging) {
-        self.coast();
-        if (c.init_opts.frame_viewport == null) c.frame_viewport = self.si.viewport.topLeft();
-    }
     return self;
 }
 
@@ -136,11 +125,10 @@ pub fn deinit(self: *ScrollArea) void {
         t.dragging = false;
         _ = t.x.releaseWindowed(tuning, window_s);
         _ = t.y.releaseWindowed(tuning, window_s);
-        t.coast_start_ns = dvui.frameTimeNS();
-        t.coast_origin = self.si.viewport.topLeft();
-        t.coast_velocity = .{ .x = t.x.vel, .y = t.y.vel };
     }
 
+    if (!t.dragging) self.coast();
+
     // A nested child's propagated motion sets this (parent) area's velocity through dvui's
     // `processMotionScroll`; clear it so dvui's coast never runs beside ours.
     self.si.velocity = .{};
@@ -199,9 +187,9 @@ fn coast(self: *ScrollArea) void {
     const t = self.touch;
     const si = self.si;
     var moved: dvui.Point = .{};
-    const elapsed = @as(f64, @floatFromInt(dvui.frameTimeNS() - t.coast_start_ns)) / std.time.ns_per_s;
-    if (t.x.coasting) moved.x = coastPosition(&t.x, t.coast_origin.x, t.coast_velocity.x, elapsed) - si.viewport.x;
-    if (t.y.coasting) moved.y = coastPosition(&t.y, t.coast_origin.y, t.coast_velocity.y, elapsed) - si.viewport.y;
+    if (t.x.step(tuning)) |d| moved.x = d;
+    if (t.y.step(tuning)) |d| moved.y = d;
+    if (!moved.nonZero()) return;
 
     self.scrollBy(moved);
     if (si.viewport.x < 0 or si.viewport.x > si.scrollMax(.horizontal)) t.x.cancel();
@@ -209,18 +197,6 @@ fn coast(self: *ScrollArea) void {
     if (t.x.coasting or t.y.coasting) dvui.refresh(null, @src(), self.data().id);
 }
 
-// Evaluate from the release, rounding the position once rather than accumulating f32 deltas.
-// Clamp time at the stop speed so the final position also agrees across frame schedules.
-fn coastPosition(fling: *Fling, origin: f32, velocity: f32, elapsed: f64) f32 {
-    const decay: f64 = tuning.decay;
-    const duration = @log(@as(f64, @abs(velocity)) / tuning.stop) / decay;
-    const time = std.math.clamp(elapsed, 0, duration);
-    const keep = @exp(-decay * time);
-    fling.vel = @floatCast(velocity * keep);
-    fling.coasting = elapsed < duration;
-    return @floatCast(origin + velocity / decay * (1 - keep));
-}
-
 fn scrollBy(self: *ScrollArea, by: dvui.Point) void {
     const c = &self.area.scroll.?;
     self.si.viewport.x += by.x;
@@ -236,7 +212,6 @@ var t_use_dvui: bool = false;
 /// Where a child of the area is drawn this frame (physical y, as the renderer would place it),
 /// and whether the renderer snaps there.
 var t_drawn_y: f32 = 0;
-var t_raw_y: f32 = 0;
 var t_snapping: bool = false;
 
 fn testFrame() !dvui.App.Result {
@@ -249,14 +224,13 @@ fn testFrame() !dvui.App.Result {
         t_viewport_y = scroll.si.viewport.y;
     } else {
         var scroll = ScrollArea.init(@src(), .{ .horizontal = .none, .vertical_bar = .hide }, .{ .expand = .both });
-        // Read the final viewport after the area's event handling and edge correction.
+        // After the area's `deinit`, which is where the coast moves it: the frame's final place.
         const si = scroll.si;
         defer t_viewport_y = si.viewport.y;
         defer scroll.deinit();
         const child = dvui.spacer(@src(), .{ .min_size_content = .{ .w = 100, .h = 20000 } });
         t_snapping = dvui.snapToPixels();
         const y = child.rectScale().r.y;
-        t_raw_y = y;
         t_drawn_y = if (t_snapping) @round(y) else y;
     }
     return .ok;
@@ -299,59 +273,28 @@ fn flick() !f32 {
     return t_viewport_y - at_release;
 }
 
-/// How far the content has been drawn to move from the release at each of 150 steps of 33 ms, the clock
+/// How far the viewport has coasted from the release at each of 15 steps of 33 ms, the clock
 /// cut into frames by `gaps_ms` (summing to 33), so different cuts meet at equal timestamps.
-fn coastTrace(gaps_ms: []const u64, out: *[150]f32) !void {
+fn coastTrace(gaps_ms: []const u64, out: *[15]f32) !void {
     var t = try dvui.testing.init(.{ .window_size = .{ .w = 300, .h = 400 } });
     defer t.deinit();
     t_use_dvui = false;
-    _ = try swipe();
-    const at_release = t_raw_y;
-    // A frame draws where the clock is at its start, so end on the last gap and the frames
-    // after it span `gaps_ms` rotated, summing to 33 each step.
+    const at_release = try swipe();
+    // A frame's step spans the gap before it, so end on the last gap and the frames after
+    // it span `gaps_ms` rotated, summing to 33 each step.
     try frameAfter(gaps_ms[gaps_ms.len - 1]);
     for (out) |*slot| {
         for (gaps_ms) |g| try frameAfter(g);
-        slot.* = at_release - t_raw_y;
+        slot.* = t_viewport_y - at_release;
     }
 }
 
 test "the coast is a function of time, not of how the frames cut it" {
-    var steady: [150]f32 = undefined;
-    try coastTrace(&.{ 16, 17 }, &steady);
-    var jittery: [150]f32 = undefined;
+    var steady: [15]f32 = undefined;
+    try coastTrace(&.{33}, &steady);
+    var jittery: [15]f32 = undefined;
     try coastTrace(&.{ 25, 8 }, &jittery);
-    var max_error: f32 = 0;
-    for (steady, jittery) |a, b| max_error = @max(max_error, @abs(a - b));
-    std.debug.print("coast: steady final={d:.6}, jittery final={d:.6}, max difference={d:.6} points\n", .{ steady[149], jittery[149], max_error });
-    try std.testing.expectApproxEqAbs(@as(f32, 0), max_error, 0.0001);
-}
-
-test "coast displacement follows each frame gap" {
-    var t = try dvui.testing.init(.{ .window_size = .{ .w = 300, .h = 400 } });
-    defer t.deinit();
-    t_use_dvui = false;
-    _ = try swipe();
-    var previous_time = dvui.currentWindow().frame_time_ns;
-    try frameAfter(25);
-    var previous_y = t_raw_y;
-    var previous_speed: f32 = std.math.inf(f32);
-    var follows_gaps = true;
-    // frameAfter draws at the current timestamp, then begins the next frame with this gap.
-    // Alternating long and short gaps exposes a displacement applied one frame late.
-    for ([_]u64{ 8, 25, 8, 25, 8, 25, 8, 25 }) |next_gap| {
-        const time = dvui.currentWindow().frame_time_ns;
-        const gap_ms: f32 = @as(f32, @floatFromInt(time - previous_time)) / std.time.ns_per_ms;
-        try frameAfter(next_gap);
-        const displacement = previous_y - t_raw_y;
-        const speed = displacement / gap_ms;
-        std.debug.print("coast: gap={d:.0} ms, displacement={d:.6} points\n", .{ gap_ms, displacement });
-        follows_gaps = follows_gaps and displacement > 0 and speed < previous_speed;
-        previous_time = time;
-        previous_y = t_raw_y;
-        previous_speed = speed;
-    }
-    try std.testing.expect(follows_gaps);
+    for (steady, jittery) |a, b| try std.testing.expectApproxEqAbs(a, b, 0.01);
 }
 
 test "a slow coast draws at a new place every frame, then snaps at rest" {
diff --git a/core/widgets/TreeWidget.zig b/core/widgets/TreeWidget.zig
index 79ad4b5b9..f1e858700 100644
--- a/core/widgets/TreeWidget.zig
+++ b/core/widgets/TreeWidget.zig
@@ -390,8 +390,8 @@ pub fn branch(self: *TreeWidget, src: std.lang.SourceLocation, init_opts: Branch
 pub const Branch = struct {
     pub const InitOptions = struct {
         /// Whether the caller wants the branch open, passed every frame. The caller owns this
-        /// state; the branch animates toward it and reports a click or key press in
-        /// `Branch.requested`.
+        /// state; the branch only eases toward it (`Branch.expanded` is what is drawn) and reports
+        /// a click or key press in `Branch.requested`.
         expanded: bool = false,
 
         // if null, uses widget id
@@ -427,7 +427,8 @@ pub const Branch = struct {
     /// One of the rows carried back over the tree (`TreeWidget.carriedOver`): the rows drawn
     /// inside it are carried with it.
     carried_source: bool = false,
-    /// The caller's open state for this frame.
+    /// What is drawn: open while opening and while closing, until the close animation ends.
+    /// Follows `init_options.expanded` and is never to be copied back into the caller's state.
     expanded: bool = false,
     /// The open state the user asked for this frame (a click, Left/Right, hover-to-open), null
     /// when they asked for nothing. Valid after `expander()`; the caller applies it to its own state.
@@ -435,7 +436,6 @@ pub const Branch = struct {
     /// Left/Right pressed on this row this frame; `expander()` turns it into `requested`.
     key_toggle: bool = false,
     can_expand: bool = false,
-    draw_children: bool = false,
     anim: ?*dvui.AnimateWidget = null,
     /// Populated while `expander_vbox` is active: clip children to `anim`'s content (animated height).
     expander_clip_prev: ?dvui.Rect.Physical = null,
@@ -474,7 +474,7 @@ pub const Branch = struct {
         self.init_options = init_opts;
         self.options = defaults.override(opts);
         self.wd = WidgetData.init(src, .{}, wrapOuter(self.options).override(.{ .rect = .{} }));
-        self.expanded = init_opts.expanded;
+        self.expanded = if (dvui.dataGet(null, self.wd.id, "_expanded", bool)) |e| e else init_opts.expanded;
     }
 
     // can call this after init before install
@@ -567,7 +567,11 @@ pub const Branch = struct {
                 if (rs.r.contains(dp)) {
                     if (!self.expanded) {
                         // Auto-expand after timer so hover over closed folder opens it.
+                        // Set only `init_options.expanded` so `self.expanded` stays false until
+                        // `expander()` runs: that keeps `init_options.expanded != self.expanded` and
+                        // replays the same open animation as a click.
                         if (dvui.timerDone(self.data().id)) {
+                            self.init_options.expanded = true;
                             self.requested = true;
                         } else {
                             _ = dvui.timer(self.data().id, 500_000);
@@ -774,32 +778,38 @@ pub const Branch = struct {
         );
 
         const toggled = clicked or self.key_toggle;
-        const want = self.init_options.expanded;
-        if (toggled) self.requested = !want;
-        if (self.requested != null) dvui.refresh(null, @src(), self.data().id);
+        const want = self.init_options.expanded != toggled;
+        if (toggled) self.requested = want;
 
         const anim = self.anim.?;
-        const target: f32 = if (want) 1 else 0;
-        const progress = dvui.dataGet(null, self.data().id, "branch_progress", f32) orelse target;
-        const active = dvui.animationGet(anim.data().id, "_end");
-        if ((active != null and active.?.end_val != target) or
-            (active == null and progress != target))
-        {
-            dvui.animation(anim.data().id, "_end", .{
-                .start_val = if (active) |a| a.value() else progress,
-                .end_val = target,
-                .end_time = motion.duration(if (want) self.init_options.animation_duration else @divTrunc(self.init_options.animation_duration, 2)),
-                .easing = if (want) self.init_options.animation_easing else motion.settle,
-            });
-        }
-        const animate_progress = anim.init_opts.kind != .none and anim.init_opts.duration != 0;
-        const current = dvui.animationGet(anim.data().id, "_end");
-        const value = if (animate_progress and current != null) current.?.value() else target;
-        anim.val = value;
-        dvui.dataSet(null, self.data().id, "branch_progress", value);
-        self.draw_children = want or value > 0;
-
-        if (self.draw_children) {
+        // A close in flight, through the frame it ends on (when `end()` reports it).
+        const closing_anim = if (dvui.animationGet(anim.data().id, "_end")) |a| (if (a.end_val == 0) a else null) else null;
+        if (want and (!self.expanded or closing_anim != null)) {
+            if (closing_anim) |a| {
+                // Reopen from where the close had got to.
+                dvui.animation(anim.data().id, "_end", .{
+                    .start_val = a.value(),
+                    .end_val = 1.0,
+                    .end_time = anim.init_opts.duration,
+                    .easing = anim.init_opts.easing orelse dvui.easing.linear,
+                });
+                anim.val = a.value();
+            } else {
+                anim.val = 0.0;
+                anim.start();
+            }
+            self.expanded = true;
+        } else if (!want and self.expanded and closing_anim == null) {
+            anim.init_opts.easing = motion.settle;
+            anim.init_opts.duration = motion.duration(@divTrunc(self.init_options.animation_duration, 2));
+            anim.startEnd();
+        }
+
+        if (!want and anim.end()) {
+            self.expanded = false;
+        }
+
+        if (self.expanded) {
             // Always expand the inner box to fill the animation
             const expander_opts = dvui.Options{ .expand = .both };
 
@@ -813,7 +823,7 @@ pub const Branch = struct {
 
         self.can_expand = true;
 
-        return self.draw_children;
+        return self.expanded;
     }
 
     pub fn targetRectScale(self: *Branch) ?dvui.RectScale {
@@ -900,7 +910,7 @@ pub const Branch = struct {
         if (self.carried_source) self.tree.carried_depth -= 1;
 
         if (self.can_expand) {
-            if (self.draw_children) {
+            if (self.expanded) {
                 if (self.expander_clip_prev) |p| {
                     dvui.clipSet(p);
                     self.expander_clip_prev = null;
@@ -910,6 +920,8 @@ pub const Branch = struct {
             if (self.anim) |a| {
                 a.deinit();
             }
+
+            dvui.dataSet(null, self.data().id, "_expanded", self.expanded);
         } else {
             self.hbox.deinit();
             self.button.deinit();
diff --git a/docs/AGENT_WORK.md b/docs/AGENT_WORK.md
index a6b2875b7..174417899 100644
--- a/docs/AGENT_WORK.md
+++ b/docs/AGENT_WORK.md
@@ -152,7 +152,8 @@ Three places, in order: the worker's **local gates** (step 3), which decide whet
 worth pushing; **cross-review** by a different worker; and **CI at ready**. A draft PR runs only
 the light `changes` job (`ci.yml`); `ci-ok` is skipped on drafts. Pushing to a draft costs almost
 nothing and proves nothing; `gh pr ready` starts the full matrix, and `ci-ok` is the required
-check on that run. A reviewer waits for finished checks, so a draft is reviewed from its diff and the gate output in its body,
+check on that run. A reviewer waits for finished checks, so a draft is reviewed from its diff
+and the gate output in its body,
 and a cross-reviewer may give a verdict on a draft without CI. The merge question waits for the
 full CI at ready. Workflow changes require the maintainer's explicit yes before merge.
 
diff --git a/docs/AUTOMATION.md b/docs/AUTOMATION.md
index 472454fb8..ed0f78a94 100644
--- a/docs/AUTOMATION.md
+++ b/docs/AUTOMATION.md
@@ -350,6 +350,7 @@ one.
         .root = "demo://hello",
         .files = .{ .{ .path = "hello.md", .text = "# Hello\n" } },
         .open = .{"hello.md"},       // the last one is active
+        .layout = .keep,             // fizzy leaves the window as it is whatever this says
         .settings = .{ .{ .owner = "markdown", .key = "default_md_view", .value = ".split" } },
     } },
     .chapters = .{ .{ .at = 0, .title = "Hello" } },
diff --git a/docs/DEPENDENCIES.md b/docs/DEPENDENCIES.md
index c2826e8d9..7836bba99 100644
--- a/docs/DEPENDENCIES.md
+++ b/docs/DEPENDENCIES.md
@@ -220,8 +220,7 @@ the patch changes it too, and nothing dvui's own web backend uses is taken away
 - `0008` **`wasm_renderStream`**, a flush's draws in one call: what `WebBackend.flushBatch` sends.
 - `0009` **Custom fragment programs in the draw stream** (`core.gfx.programs`).
 - `0010` **A keyboard's correction replaces the typed word** (`TextInput`): the hidden input holds the
-  sentence fragment before the caret (up to 60 code points). Replacements, native input and
-  composition updates become backspaces and text.
+  word before the caret, and a replacement or recomposition becomes backspaces and the new text.
   Test: `scripts/test-web-text-input.sh` (needs node, or jsc on macOS).
 
 The patches are the commits of a dvui checkout's branch, from the pinned commit. To change one,
diff --git a/docs/PITFALLS.md b/docs/PITFALLS.md
index 59dceace9..ee91fe4be 100644
--- a/docs/PITFALLS.md
+++ b/docs/PITFALLS.md
@@ -49,7 +49,7 @@ Four things in that split cost time on the move to 0.17:
 - **A tarball `zig fetch` cached breaks the next build's hash.** `zig fetch <url>` prints the
   right hash and saves the tarball to the global cache (`~/.cache/zig/p/<hash>.tar.gz`). A build
   that finds it there unpacks it with its top folder kept: no `build.zig.zon` at the package's
-  root, an unnamed `N-V-...` hash, and "hash mismatch". It is not the URL: it hit GitHub
+  root, an unnamed `N-V-…` hash, and "hash mismatch". It is not the URL: it hit GitHub
   `archive/<sha>.tar.gz` URLs (dvui-dev `bd7736d`) and fizzy's own `fizzy-sdk-v0.2.30.tar.gz`
   alike. Delete `p/<hash>.tar.gz` after a `zig fetch` and the build fetches the package itself.
   fizzyedit/plugin-build-action's repin does (fizzyedit/plugin-build-action#4).
@@ -59,7 +59,7 @@ Four things in that split cost time on the move to 0.17:
 Three that the release builds (`zig build package`, MSVC) hit and the macOS build never shows:
 
 - **An `*-windows-msvc` exe must link `oldnames` itself.** MSVC's C runtime spells the POSIX
-  calls `_getcwd`, `_chdir`, ..., and `oldnames.lib` maps the plain names onto them. Zig 0.16
+  calls `_getcwd`, `_chdir`, …, and `oldnames.lib` maps the plain names onto them. Zig 0.16
   linked it into every MSVC exe; 0.17 does not, so C that calls `getcwd` (dvui's
   tinyfiledialogs, fizzy's startup) fails to link with unresolved symbols. `build/exe.zig` adds
   it for `abi == .msvc`; any other MSVC exe built from this tree needs the same line.
@@ -114,10 +114,12 @@ Three that the release builds (`zig build package`, MSVC) hit and the macOS buil
 
 ## Window behaviour notes: clean-room hygiene
 
-Write `docs/window-notes/` in our own words from observed behaviour or documentation read,
-citing only public OS documentation. Do not consult source code or copy code, comments or
-tables from SDL, GLFW or another implementation while writing a note. Our patch descriptions and
-recorded pitfalls can identify a behaviour to investigate; patch files mix prose and
-implementation hunks, so read only the commit-message part above the first `---`.
-Separate recorded observations, documented contracts and cases still awaiting observation,
-and include platform and verification limits so a proposed test is not mistaken for a pass.
+Write `docs/window-notes/` from behaviour observed or documentation read, never from
+source code open in another window. Do not copy code, comments or tables from SDL,
+GLFW or another implementation. Our patch descriptions and recorded pitfalls can
+identify a behaviour to investigate; patch files mix prose and implementation hunks,
+so read only the commit-message part above the first `---` and never open the diff
+hunks while writing a note; read the prose, not implementation hunks, and
+state the behaviour in our own words. Cite only public OS documentation. Separate
+recorded observations, documented contracts and cases still awaiting observation;
+include platform and verification limits so a proposed test is not mistaken for a pass.
diff --git a/docs/PLUGINS.md b/docs/PLUGINS.md
index 77e1715e7..8c7cb7ac8 100644
--- a/docs/PLUGINS.md
+++ b/docs/PLUGINS.md
@@ -1327,7 +1327,6 @@ The SDK ships definitions for the services in this ecosystem, in
 | `"wikilink"` | any indexer (e.g. `brain`) | Resolve `[[Note]]` to a file, plus completion candidates and index state |
 | `"automation"` | the application (fizzy: `app/automation/Service.zig`, over its live driver) | `play` a live tape — input on the app as it is, built with the `tape` module and handed over as ZON or binary bytes — and get a ticket to ask its `outcome` (finished, or interrupted / timed out / stopped before which op); `stop` your own tape; `settled` when nothing is in flight; `snapshot` / `snapshotText` for what is on screen as ZON, a line per widget a person acts on or a tape aims at (role, name, tag, rect, parent — `replay.Snapshot`). One tape at a time, refused while a demo plays; a person's input stops it. For plugin tests, macros, tutorials |
 | `"demos"` | the application (fizzy: `src/editor/Demos.zig`, over its demo player) | `list` every demo the app can play — its own, and each one a plugin registered with `host.registerDemo` (a name, a title, the tape as ZON or binary bytes, copied by the host and dropped when the plugin goes) — with each one's length, chapters and where it came from; `play` one by name, from a chapter if asked; `current` names the one playing; `generation` moves when the list does. A demo opens on a keyframe and sets the person's session aside untouched while it plays, unsaved work and all; refused only while a live tape drives. For a guides browser, a plugin's own demos, an agent |
-| `"chat.provider"` | whoever has a conversation: the host app, a team plugin (the `chat` plugin registers a small in-memory one when nothing else has) | `messages` (the conversation, oldest first), `send` a message (false when refused), `attach` (the provider decides what that means), `status` (`ready`, `busy`, `offline`). The `chat` plugin draws the messages and a composer in the sidebar from it |
 
 Everything a plugin might reasonably ask *fizzy* for lives on `Host` instead — `openFile`,
 `closeDocById`, `docFromPath`, `revealPosition`, `setProjectFolder`, `isPathIgnored`, … — where it
diff --git a/plugins/chat/build.zig b/plugins/chat/build.zig
deleted file mode 100644
index 6102a115c..000000000
--- a/plugins/chat/build.zig
+++ /dev/null
@@ -1,13 +0,0 @@
-//! Standalone build for the chat plugin — the canonical third-party shape.
-//! `cd plugins/chat && zig build` produces `chat.<dylib|dll|so>`. The fizzy-internal
-//! static-embed build lives separately in `static/` and is driven by the root build.
-const std = @import("std");
-const fizzy = @import("fizzy");
-
-pub fn build(b: *std.Build) void {
-    const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
-
-    const plugin = fizzy.plugin.create(b, .{ .target = target, .optimize = optimize });
-    fizzy.plugin.install(b, plugin.lib, .{});
-}
diff --git a/plugins/chat/build.zig.zon b/plugins/chat/build.zig.zon
deleted file mode 100644
index 5764e1a04..000000000
--- a/plugins/chat/build.zig.zon
+++ /dev/null
@@ -1,19 +0,0 @@
-.{
-    .name = .chat,
-    .version = "0.1.0",
-    .minimum_zig_version = "0.17.0",
-    .paths = .{
-        "build.zig",
-        "build.zig.zon",
-        "plugin.zig",
-        "plugin.zig.zon",
-        "src",
-        "static",
-    },
-    .fingerprint = 0x659df2aa507f8c19,
-    .dependencies = .{
-        .fizzy = .{
-            .path = "../../sdk",
-        },
-    },
-}
diff --git a/plugins/chat/plugin.zig b/plugins/chat/plugin.zig
deleted file mode 100644
index e80740975..000000000
--- a/plugins/chat/plugin.zig
+++ /dev/null
@@ -1,87 +0,0 @@
-//! Chat: a conversation and its composer, over the `chat.provider` service. One surface for the
-//! sidebar (`chat.view`) draws the provider's messages and a composer; whoever has a conversation
-//! (the host app, a team plugin) registers the provider and this shows it. Owns no conversation:
-//! when nothing offers one it registers a small in-memory one, so the surface can be tried alone.
-//!
-//! Commands: `chat.show` reveals the view wherever it lives.
-const std = @import("std");
-const sdk = @import("fizzy_sdk");
-const dvui = @import("dvui");
-pub const DemoProvider = @import("src/DemoProvider.zig");
-pub const View = @import("src/View.zig");
-
-/// Injected at build time from `plugin.zig.zon`.
-pub const plugin_options = @import("fizzy_plugin_options");
-pub const plugin_id = plugin_options.id;
-
-pub const view_id = "chat.view";
-
-var plugin: sdk.Plugin = .{
-    .state = undefined,
-    .vtable = &vtable,
-    .id = plugin_id,
-    .display_name = plugin_options.name,
-};
-
-const vtable: sdk.Plugin.VTable = .{ .deinit = deinit };
-
-var host_ptr: ?*sdk.Host = null;
-var view: View = .{};
-var demo: DemoProvider = undefined;
-var demo_api: sdk.services.chat.Api = undefined;
-var demo_registered = false;
-
-pub fn register(host: *sdk.Host) !void {
-    host_ptr = host;
-    plugin.state = @ptrCast(host);
-    try host.registerPlugin(&plugin);
-    try host.registerSurface(.{
-        .id = view_id,
-        .owner = &plugin,
-        .title = "Chat",
-        .icon = .{ .tvg = dvui.entypo.chat },
-        .keywords = sdk.keywords.ide.sidebar,
-        .scrolls_itself = true,
-        .draw = drawView,
-    });
-    try host.registerCommand(.{
-        .id = sdk.Plugin.commandId(plugin_id, "show"),
-        .owner = &plugin,
-        .title = "Show Chat",
-        .run = cmdShow,
-        .icon = dvui.entypo.chat,
-    });
-    if (host.getServiceTyped(sdk.services.chat.Api) == null) {
-        demo = .{ .allocator = host.allocator };
-        demo_api = demo.api();
-        try host.registerService(sdk.services.chat.Api, &demo_api, &plugin);
-        demo_registered = true;
-    }
-}
-
-fn deinit(state: *anyopaque) void {
-    const host: *sdk.Host = @ptrCast(@alignCast(state));
-    view.deinit(host.allocator);
-    view = .{};
-    if (demo_registered) demo.deinit();
-    demo_registered = false;
-    host_ptr = null;
-}
-
-// lint-allow(anyerror): the surface draw signature is the SDK's
-fn drawView(_: ?*anyopaque) anyerror!dvui.App.Result {
-    const host = host_ptr orelse return .ok;
-    view.draw(host.allocator, host.getServiceTyped(sdk.services.chat.Api));
-    return .ok;
-}
-
-/// "Show Chat": the view, wherever it lives, its place opened if it was shut.
-// lint-allow(anyerror): the command run signature is the SDK's
-fn cmdShow(state: *anyopaque) anyerror!void {
-    const host: *sdk.Host = @ptrCast(@alignCast(state));
-    _ = host.revealSurface(view_id);
-}
-
-test {
-    _ = DemoProvider;
-}
diff --git a/plugins/chat/plugin.zig.zon b/plugins/chat/plugin.zig.zon
deleted file mode 100644
index 5de97db02..000000000
--- a/plugins/chat/plugin.zig.zon
+++ /dev/null
@@ -1,8 +0,0 @@
-.{
-    .id = "chat",
-    .name = "Chat",
-    .version = "0.1.0",
-    .min_sdk_version = "",
-    .description = "A conversation and its composer, over the chat.provider service: whoever has a conversation shows it here.",
-    .tags = .{ "chat", "ai" },
-}
diff --git a/plugins/chat/src/DemoProvider.zig b/plugins/chat/src/DemoProvider.zig
deleted file mode 100644
index 8cecb1dcb..000000000
--- a/plugins/chat/src/DemoProvider.zig
+++ /dev/null
@@ -1,68 +0,0 @@
-//! A conversation kept in memory, so the chat surface can be tried with no team behind it. It
-//! answers every message by quoting it. The chat plugin registers it only when no other plugin
-//! has offered `chat.provider`.
-const std = @import("std");
-const sdk = @import("fizzy_sdk");
-
-const Api = sdk.services.chat.Api;
-
-const DemoProvider = @This();
-
-allocator: std.mem.Allocator,
-log: std.ArrayList(Api.Message) = .empty,
-
-pub fn deinit(self: *DemoProvider) void {
-    for (self.log.items) |m| self.allocator.free(m.text);
-    self.log.deinit(self.allocator);
-}
-
-pub fn api(self: *DemoProvider) Api {
-    return .{ .ctx = self, .vtable = &vtable };
-}
-
-const vtable: Api.VTable = .{
-    .messages = messages,
-    .send = send,
-    .attach = attach,
-    .status = status,
-};
-
-fn messages(ctx: *anyopaque) []const Api.Message {
-    const self: *DemoProvider = @ptrCast(@alignCast(ctx));
-    return self.log.items;
-}
-
-fn send(ctx: *anyopaque, text: []const u8) bool {
-    const self: *DemoProvider = @ptrCast(@alignCast(ctx));
-    self.append(.user, text) catch return false;
-    var buf: [256]u8 = undefined;
-    const quoted = text[0..@min(text.len, 200)];
-    const reply = std.fmt.bufPrint(&buf, "You said: {s}", .{quoted}) catch return true;
-    self.append(.assistant, reply) catch {};
-    return true;
-}
-
-fn attach(ctx: *anyopaque) void {
-    const self: *DemoProvider = @ptrCast(@alignCast(ctx));
-    self.append(.system, "The demo conversation has nowhere to keep an attachment.") catch {};
-}
-
-fn status(_: *anyopaque) Api.Status {
-    return .ready;
-}
-
-fn append(self: *DemoProvider, role: Api.Role, text: []const u8) !void {
-    const owned = try self.allocator.dupe(u8, text);
-    errdefer self.allocator.free(owned);
-    try self.log.append(self.allocator, .{ .role = role, .text = owned });
-}
-
-test "sending adds the message and its reply" {
-    var p: DemoProvider = .{ .allocator = std.testing.allocator };
-    defer p.deinit();
-    const a = p.api();
-    try std.testing.expect(a.send("hello"));
-    try std.testing.expectEqual(@as(usize, 2), a.messages().len);
-    try std.testing.expectEqual(Api.Role.user, a.messages()[0].role);
-    try std.testing.expectEqualStrings("You said: hello", a.messages()[1].text);
-}
diff --git a/plugins/chat/src/View.zig b/plugins/chat/src/View.zig
deleted file mode 100644
index 48f12396a..000000000
--- a/plugins/chat/src/View.zig
+++ /dev/null
@@ -1,181 +0,0 @@
-//! The chat surface: the provider's messages above, the composer below. Drawn from the theme and
-//! the app's glass only, so another app's look is the chat's look.
-//!
-//! The composer is a rounded pane of glass with a plus (attach) on its left and a send button on
-//! its right. Its text grows with what is typed up to `composer.max_lines`, then scrolls. Enter
-//! sends on a desktop and is a new line on a phone (`composer.enter`).
-const std = @import("std");
-const sdk = @import("fizzy_sdk");
-const dvui = @import("dvui");
-const core = @import("core");
-const composer = @import("composer.zig");
-
-const Api = sdk.services.chat.Api;
-
-const View = @This();
-
-/// The composer's text, kept across frames.
-text: std.ArrayList(u8) = .empty,
-/// Messages seen last frame: the list scrolls to the end when this grows.
-seen: usize = 0,
-/// The composer's text entry as last drawn, for a test to read: its widget id, its rect and its
-/// scroll state.
-entry_id: dvui.Id = .zero,
-entry_rect: dvui.Rect = .{},
-entry_scroll: dvui.ScrollInfo = .{},
-
-pub fn deinit(self: *View, gpa: std.mem.Allocator) void {
-    self.text.deinit(gpa);
-}
-
-pub fn draw(self: *View, gpa: std.mem.Allocator, provider: ?*Api) void {
-    var column = dvui.box(@src(), .{}, .{ .expand = .both, .background = false });
-    defer column.deinit();
-
-    const api = provider orelse return note("Nothing is offering a conversation (chat.provider).");
-    self.messages(api.*);
-    self.compose(gpa, api.*, column.data());
-}
-
-fn messages(self: *View, api: Api) void {
-    var scroll = core.widgets.ScrollArea.init(@src(), .{ .horizontal = .none, .vertical_bar = .auto_overlay }, .{ .expand = .both, .background = false });
-    defer scroll.deinit();
-
-    const log = api.messages();
-    for (log, 0..) |m, i| message(m, i);
-
-    if (log.len != self.seen) {
-        self.seen = log.len;
-        scroll.si.scrollToOffset(.vertical, std.math.floatMax(f32));
-        dvui.refresh(null, @src(), null);
-    }
-}
-
-fn message(m: Api.Message, i: usize) void {
-    const theme = dvui.themeGet();
-    var box = dvui.box(@src(), .{}, .{ .expand = .horizontal, .id_extra = i, .padding = .{ .x = 8, .y = 4, .w = 8, .h = 4 }, .background = false });
-    defer box.deinit();
-
-    const who = switch (m.role) {
-        .user => "You",
-        .assistant => "Reply",
-        .system => "",
-    };
-    if (who.len > 0) dvui.labelNoFmt(@src(), who, .{}, .{ .color_text = .{ .color = theme.color(.control, .text).opacity(0.6) }, .font = theme.font_body.larger(-2) });
-
-    var segments: composer.Segments = .{ .text = m.text };
-    var n: usize = 0;
-    while (segments.next()) |s| : (n += 1) {
-        if (s.body.len == 0 and s.kind == .text) continue;
-        switch (s.kind) {
-            .text => {
-                var tl = dvui.textLayout(@src(), .{}, .{ .expand = .horizontal, .id_extra = n, .background = false });
-                defer tl.deinit();
-                tl.addText(s.body, .{});
-            },
-            .code => {
-                var block = dvui.box(@src(), .{}, .{
-                    .expand = .horizontal,
-                    .id_extra = n,
-                    .background = true,
-                    .color_fill = .{ .color = theme.color(.control, .fill) },
-                    .corners = core.corners.all(core.corners.small),
-                    .padding = .all(6),
-                    .margin = .{ .y = 2, .h = 2 },
-                });
-                defer block.deinit();
-                var tl = dvui.textLayout(@src(), .{}, .{ .expand = .horizontal, .background = false, .font = theme.font_mono });
-                defer tl.deinit();
-                tl.addText(s.body, .{});
-            },
-        }
-    }
-}
-
-fn compose(self: *View, gpa: std.mem.Allocator, api: Api, parent: *const dvui.WidgetData) void {
-    const theme = dvui.themeGet();
-    const radius = core.corners.card + 4;
-    var pane = dvui.box(@src(), .{ .dir = .horizontal }, .{
-        .expand = .horizontal,
-        .background = false,
-        .corners = core.corners.all(radius),
-        .margin = .all(8),
-        .padding = .all(6),
-    });
-    defer pane.deinit();
-    const r = pane.data().borderRectScale().r;
-    const corners = core.corners.all(radius);
-    if (!core.dialogs.frostPane(pane.data().id, r, corners, pane.data().rectScale().s)) {
-        r.fill(corners.scale(pane.data().rectScale().s, dvui.CornerRect.Physical), .{ .color = .{ .color = core.dialogs.dialogFill() }, .fade = 1 });
-    }
-
-    if (iconButton(@src(), dvui.entypo.plus, "Attach", true)) api.attach();
-
-    const line_h = theme.font_body.lineHeight();
-    const entry_src = @src();
-    const entry_id = pane.data().id.extendId(entry_src, 0);
-    const mobile = core.platform.formFactor() == .mobile;
-    var send = false;
-    for (dvui.events()) |*e| {
-        if (e.handled or e.target_widgetId != entry_id) continue;
-        const ke = switch (e.evt) {
-            .key => |k| k,
-            else => continue,
-        };
-        if (ke.code != .enter or ke.action == .up) continue;
-        const shift = ke.mod.has(.lshift) or ke.mod.has(.rshift);
-        if (composer.enter(shift, mobile) == .send) {
-            e.handle(@src(), parent);
-            send = ke.action == .down;
-        }
-    }
-
-    var entry = dvui.textEntry(entry_src, .{
-        .multiline = true,
-        .break_lines = true,
-        .placeholder = "Message",
-        .text = .{ .array_list = .{ .backing = &self.text, .allocator = gpa } },
-    }, .{
-        .expand = .horizontal,
-        .gravity_y = 0.5,
-        .background = false,
-        .min_size_content = .{ .w = 1, .h = line_h },
-        .max_size_content = .{ .w = std.math.floatMax(f32), .h = line_h * composer.max_lines },
-    });
-    defer entry.deinit();
-    self.entry_id = entry.data().id;
-    self.entry_rect = entry.data().rect;
-    self.entry_scroll = entry.scroll.si.*;
-
-    const text = composer.sendable(self.text.items);
-    if (iconButton(@src(), dvui.entypo.paper_plane, "Send", text != null and api.status() != .offline)) send = true;
-    if (send) {
-        if (text) |t| if (api.send(t)) {
-            self.text.clearRetainingCapacity();
-            entry.textSet("", false);
-        };
-    }
-}
-
-fn iconButton(src: std.lang.SourceLocation, glyph: []const u8, label: []const u8, enabled: bool) bool {
-    const theme = dvui.themeGet();
-    var btn: dvui.ButtonWidget = undefined;
-    btn.init(src, .{}, .{
-        .gravity_y = 1.0,
-        .min_size_content = .{ .w = 18, .h = 18 },
-        .corners = core.corners.all(core.corners.control),
-        .background = false,
-        .label = .{ .text = label },
-    });
-    defer btn.deinit();
-    if (enabled) btn.processEvents();
-    btn.drawBackground();
-    if (enabled) btn.drawFocus();
-    const color = theme.color(.control, .text).opacity(if (enabled) 1 else 0.4);
-    core.icon.icon(@src(), label, glyph, .{ .stroke_color = .white, .fill_color = .white }, .{ .color_text = .{ .color = color }, .expand = .ratio, .gravity_x = 0.5, .gravity_y = 0.5 });
-    return enabled and btn.clicked();
-}
-
-fn note(text: []const u8) void {
-    dvui.labelNoFmt(@src(), text, .{}, .{ .color_text = .{ .color = dvui.themeGet().color(.control, .text).opacity(0.6) }, .padding = .all(6) });
-}
diff --git a/plugins/chat/src/composer.zig b/plugins/chat/src/composer.zig
deleted file mode 100644
index e76b9e44c..000000000
--- a/plugins/chat/src/composer.zig
+++ /dev/null
@@ -1,121 +0,0 @@
-//! What the composer and the message list decide, std-only so it tests without a Window: what
-//! Enter does, how many lines the composer shows, and where a message's ``` fences begin and end.
-const std = @import("std");
-
-/// Lines the composer grows to; past this it scrolls (View caps the entry at this many lines).
-pub const max_lines: usize = 8;
-
-pub const Enter = enum { send, newline };
-
-/// Enter sends on a desktop and is a new line on a phone, where the send button sends; Shift+Enter
-/// is a new line anywhere.
-pub fn enter(shift: bool, mobile: bool) Enter {
-    return if (shift or mobile) .newline else .send;
-}
-
-/// `text` with the whitespace around it removed, or null when nothing is left to send.
-pub fn sendable(text: []const u8) ?[]const u8 {
-    const t = std.mem.trim(u8, text, " \t\r\n");
-    return if (t.len == 0) null else t;
-}
-
-pub const Segment = struct {
-    kind: enum { text, code },
-    body: []const u8,
-    /// The word after the opening fence, for a code segment; empty if none.
-    lang: []const u8 = "",
-};
-
-/// Splits a message into plain text and finished ``` fences, in order. A fence is finished when a
-/// later line is a bare ```; an unfinished one stays text.
-pub const Segments = struct {
-    text: []const u8,
-    pos: usize = 0,
-
-    pub fn next(self: *Segments) ?Segment {
-        const rest = self.text[self.pos..];
-        if (rest.len == 0) return null;
-        var line_start: usize = 0;
-        while (line_start < rest.len) {
-            const line_end = std.mem.findScalarPos(u8, rest, line_start, '\n') orelse rest.len;
-            const line = std.mem.trimEnd(u8, rest[line_start..line_end], "\r");
-            if (std.mem.startsWith(u8, line, "```")) {
-                if (closingFence(rest, line_end)) |close| {
-                    if (line_start > 0) {
-                        self.pos += line_start;
-                        return .{ .kind = .text, .body = std.mem.trim(u8, rest[0..line_start], "\n") };
-                    }
-                    self.pos += close.after;
-                    return .{
-                        .kind = .code,
-                        .body = rest[@min(line_end + 1, close.body_end)..close.body_end],
-                        .lang = std.mem.trim(u8, line[3..], " \t"),
-                    };
-                }
-                break;
-            }
-            line_start = line_end + 1;
-        }
-        self.pos = self.text.len;
-        return .{ .kind = .text, .body = std.mem.trim(u8, rest, "\n") };
-    }
-};
-
-const Close = struct { body_end: usize, after: usize };
-
-/// The line after `open_end` that is a bare ```: where the code before it ends and the text after
-/// it begins.
-fn closingFence(rest: []const u8, open_end: usize) ?Close {
-    var start = open_end + 1;
-    while (start <= rest.len) {
-        const end = std.mem.findScalarPos(u8, rest, start, '\n') orelse rest.len;
-        if (std.mem.eql(u8, std.mem.trim(u8, rest[start..end], " \t\r"), "```")) {
-            return .{ .body_end = if (start > 0) start - 1 else start, .after = @min(end + 1, rest.len) };
-        }
-        if (end == rest.len) return null;
-        start = end + 1;
-    }
-    return null;
-}
-
-test "Enter sends on a desktop and breaks the line on a phone or with Shift" {
-    try std.testing.expectEqual(Enter.send, enter(false, false));
-    try std.testing.expectEqual(Enter.newline, enter(true, false));
-    try std.testing.expectEqual(Enter.newline, enter(false, true));
-    try std.testing.expectEqual(Enter.newline, enter(true, true));
-}
-
-test "only text with something in it can be sent" {
-    try std.testing.expect(sendable(" \n\t") == null);
-    try std.testing.expectEqualStrings("hi", sendable("  hi\n").?);
-}
-
-test "a finished fence is a code segment between its text" {
-    var it: Segments = .{ .text = "before\n```zig\nconst a = 1;\n```\nafter" };
-    const a = it.next().?;
-    try std.testing.expectEqual(.text, a.kind);
-    try std.testing.expectEqualStrings("before", a.body);
-    const b = it.next().?;
-    try std.testing.expectEqual(.code, b.kind);
-    try std.testing.expectEqualStrings("zig", b.lang);
-    try std.testing.expectEqualStrings("const a = 1;", b.body);
-    const c = it.next().?;
-    try std.testing.expectEqualStrings("after", c.body);
-    try std.testing.expect(it.next() == null);
-}
-
-test "an unfinished fence stays text" {
-    var it: Segments = .{ .text = "look\n```\nnot closed" };
-    const a = it.next().?;
-    try std.testing.expectEqual(.text, a.kind);
-    try std.testing.expectEqualStrings("look\n```\nnot closed", a.body);
-    try std.testing.expect(it.next() == null);
-}
-
-test "an empty fence is an empty code segment" {
-    var it: Segments = .{ .text = "```\n```" };
-    const a = it.next().?;
-    try std.testing.expectEqual(.code, a.kind);
-    try std.testing.expectEqualStrings("", a.body);
-    try std.testing.expect(it.next() == null);
-}
diff --git a/plugins/chat/static/integration.zig b/plugins/chat/static/integration.zig
deleted file mode 100644
index 4dd2a2dd9..000000000
--- a/plugins/chat/static/integration.zig
+++ /dev/null
@@ -1,63 +0,0 @@
-//! Chat plugin — fizzy-internal static-embed + bundled-dylib module graph.
-//! Runs only from the fizzy build root, so paths are single fizzy-relative literals.
-const std = @import("std");
-const helpers = @import("../../shared/build/helpers.zig");
-
-pub const id = "chat";
-pub const installDylib = helpers.installDylib;
-
-const module_path = "plugins/chat/plugin.zig";
-const zon_path = "plugins/chat/plugin.zig.zon";
-
-pub const ModuleImports = struct {
-    dvui: *std.Build.Module,
-    core: *std.Build.Module,
-    sdk: *std.Build.Module,
-    proxy_bridge: ?*std.Build.Module = null,
-};
-
-fn applyImports(module: *std.Build.Module, imports: ModuleImports) void {
-    module.addImport("dvui", imports.dvui);
-    module.addImport("core", imports.core);
-    module.addImport("fizzy_sdk", imports.sdk);
-    if (imports.proxy_bridge) |proxy_bridge| module.addImport("proxy_bridge", proxy_bridge);
-}
-
-/// Static `@import("chat")` module for exe / web / tests.
-pub fn addStaticModule(
-    b: *std.Build,
-    target: std.Build.ResolvedTarget,
-    optimize: std.lang.OptimizeMode,
-    imports: ModuleImports,
-    consumer: *std.Build.Module,
-) *std.Build.Module {
-    const mod = helpers.addStaticModule(b, .{
-        .import_name = id,
-        .root_source_file = b.path(module_path),
-        .target = target,
-        .optimize = optimize,
-    }, consumer);
-    // Shared with `addDylib` below via `pluginOptionsFor`'s per-manifest memoization — both
-    // link modes must attach the *same* options step (see its doc comment for why).
-    mod.addOptions(helpers.plugin_options_import, helpers.pluginOptionsFor(b, zon_path));
-    applyImports(mod, imports);
-    return mod;
-}
-
-/// Native dynamic library bundled beside the app (`chat.dylib` / `.dll` / `.so`).
-pub fn addDylib(
-    b: *std.Build,
-    target: std.Build.ResolvedTarget,
-    optimize: std.lang.OptimizeMode,
-    imports: ModuleImports,
-) *std.Build.Step.Compile {
-    const created = helpers.addDylib(b, .{
-        .root_source_file = b.path(module_path),
-        .manifest_zon_path = zon_path,
-        .sdk = imports.sdk,
-        .target = target,
-        .optimize = optimize,
-    });
-    applyImports(created.module, imports);
-    return created.lib;
-}
diff --git a/plugins/workbench/src/Workbench.zig b/plugins/workbench/src/Workbench.zig
index f35d9f30f..ea3ce2a27 100644
--- a/plugins/workbench/src/Workbench.zig
+++ b/plugins/workbench/src/Workbench.zig
@@ -231,40 +231,29 @@ pub fn sideBeside(self: *const Workbench, anchor: u64) Panes.Side {
 }
 
 /// What opening beside the person's pane asks of `core.placement.place`: the other pane that is
-/// shown, if any, and the answer over the person's room and that pane's. Null before the person's
+/// there, if any, and the answer over the person's room and that pane's. Null before the person's
 /// pane has drawn, with no room to judge.
-const Beside = struct { other: ?u64, room: ?core.placement.Size, answer: ?core.placement.Result };
+const Beside = struct { other: ?u64, answer: ?core.placement.Result };
 
-/// A pane other than `here` that is not sliding shut.
-fn otherPane(self: *Workbench, here: u64) ?u64 {
-    for (self.workspaces.values()) |ws| {
-        if (ws.grouping != here and !self.paneClosing(ws.grouping)) return ws.grouping;
-    }
-    return null;
-}
-
-fn besideAnswer(self: *Workbench, here: u64) Beside {
-    const room = self.paneSize(here) orelse return .{ .other = self.otherPane(here), .room = null, .answer = null };
-    // `place` takes the first of these whatever its size, so a pane is a candidate only if the
-    // person can be sent to it: drawn, and in a place of the app's.
+fn besideAnswer(self: *Workbench) Beside {
+    const here = self.open_workspace_grouping;
+    const other = for (self.workspaces.values()) |ws| {
+        if (ws.grouping != here and !self.paneClosing(ws.grouping)) break ws.grouping;
+    } else null;
+    const room = self.paneSize(here) orelse return .{ .other = other, .answer = null };
     var others: [1]core.placement.Size = undefined;
-    var other: ?u64 = null;
-    for (self.workspaces.values()) |ws| {
-        if (ws.grouping == here or self.paneClosing(ws.grouping)) continue;
-        if (self.places) |p| if (!p.placed(p.ctx, ws.grouping)) continue;
-        others[0] = self.paneSize(ws.grouping) orelse continue;
-        other = ws.grouping;
-        break;
-    }
-    const places: []const core.placement.Size = if (other != null) &others else &.{};
-    return .{ .other = other, .room = room, .answer = core.placement.place(room, places) };
+    const places: []const core.placement.Size = if (other) |g| blk: {
+        others[0] = self.paneSize(g) orelse .{ .w = 0, .h = 0 };
+        break :blk &others;
+    } else &.{};
+    return .{ .other = other, .answer = core.placement.place(room, places) };
 }
 
 /// The grouping a document opened beside the person's goes in (`core.placement.place`): another
 /// pane that is there, else a new one when the person's has room for two, else the person's own,
 /// where it becomes a card. The caller makes it the front card, as a plain open does.
 pub fn besideGrouping(self: *Workbench) u64 {
-    const asked = self.besideAnswer(self.open_workspace_grouping);
+    const asked = self.besideAnswer();
     // Not drawn yet, so no room to judge: beside as before, in the other pane if there is one.
     const answer = asked.answer orelse return asked.other orelse self.newGroupingID();
     return switch (answer) {
@@ -274,12 +263,11 @@ pub fn besideGrouping(self: *Workbench) u64 {
     };
 }
 
-/// The edge of `grouping`'s pane an open beside it splits on, or null where it joins a pane or
-/// becomes a card. What a demo's `drop:beside` aims at, over the pane it is aimed at.
-pub fn besideEdge(self: *Workbench, grouping: u64) ?Panes.Side {
-    const asked = self.besideAnswer(grouping);
-    const room = asked.room orelse return null;
-    return switch (asked.answer orelse return null) {
+/// The edge of the person's pane an open beside splits it on, or null where it joins a pane or
+/// becomes a card. What a demo's `drop:beside` aims at.
+pub fn besideEdge(self: *Workbench) ?Panes.Side {
+    const room = self.paneSize(self.open_workspace_grouping) orelse return null;
+    return switch (self.besideAnswer().answer orelse return null) {
         .split => sideFor(room.w, room.h),
         .into, .tab => null,
     };
diff --git a/plugins/workbench/src/Workspace.zig b/plugins/workbench/src/Workspace.zig
index a4eef97db..b9ae713ac 100644
--- a/plugins/workbench/src/Workspace.zig
+++ b/plugins/workbench/src/Workspace.zig
@@ -161,7 +161,7 @@ pub fn draw(self: *Workspace) !dvui.App.Result {
     // The person's pane, when it has the room for an open beside to split it: a tape that drops a
     // tab on the edge asks for this first, or skips the drop (`core.placement`).
     if (core.anchor.wanted() and runtime.workbench().open_workspace_grouping == self.grouping and
-        runtime.workbench().besideEdge(self.grouping) != null) core.anchor.mark(pane_box, "workbench.beside-room", .{});
+        runtime.workbench().besideEdge() != null) core.anchor.mark(pane_box, "workbench.beside-room", .{});
 
     if (tabs.len > 0) {
         self.dropSnapshot();
diff --git a/scripts/check-examples.sh b/scripts/check-examples.sh
index f866248e8..9e7d1ce17 100755
--- a/scripts/check-examples.sh
+++ b/scripts/check-examples.sh
@@ -20,8 +20,6 @@
 #                                        # uses checkouts of your own (example-app/ and
 #                                        # example-plugin/ in that directory), as they are on
 #                                        # disk, copied so they are left untouched
-#   EXAMPLES_BUILDS="" scripts/check-examples.sh
-#                                        # builds none of their apps: the build API fixture alone
 #
 # CI: the examples job of .github/workflows/ci.yml.
 set -euo pipefail
@@ -50,32 +48,29 @@ pack "$root" | gzip > "$work/fizzy.tar.gz"
 bash scripts/pack-sdk.sh "$work/sdk" >/dev/null
 sdk_tarball="$(ls "$work"/sdk/fizzy-sdk-v*.tar.gz)"
 
-builds="${EXAMPLES_BUILDS-plugin minimal studio endless studio-zon replay dvui dvui-sdl3}"
-if [[ -n $builds ]]; then
-  for repo in example-app example-plugin; do
-    if [[ -n "${EXAMPLES_DIR:-}" ]]; then
-      mkdir -p "$work/$repo"
-      pack "$EXAMPLES_DIR/$repo" | tar -x -C "$work/$repo"
-    else
-      git clone --quiet --depth 1 "https://github.com/fizzyedit/$repo" "$work/$repo"
-    fi
-  done
+for repo in example-app example-plugin; do
+  if [[ -n "${EXAMPLES_DIR:-}" ]]; then
+    mkdir -p "$work/$repo"
+    pack "$EXAMPLES_DIR/$repo" | tar -x -C "$work/$repo"
+  else
+    git clone --quiet --depth 1 "https://github.com/fizzyedit/$repo" "$work/$repo"
+  fi
+done
 
-  (cd "$work/example-plugin" && zig fetch --save=fizzy "$sdk_tarball" >/dev/null)
-  # example-app bundles example-plugin (`hello`), pinned by URL: the copy here, on this tree's SDK.
-  pack "$work/example-plugin" | gzip > "$work/example-plugin.tar.gz"
-  (
-    cd "$work/example-app"
-    zig fetch --save=hello "$work/example-plugin.tar.gz" >/dev/null
-    zig fetch --save=fizzy "$work/fizzy.tar.gz" >/dev/null
-    # Its replay app depends on the plugin SDK alone: this tree's, packed as a release would be.
-    zig fetch --save=fizzy_sdk "$sdk_tarball" >/dev/null
-    # So do the plugins it carries, each pinning a released SDK of its own.
-    for plugin in plugins/*/; do
-      (cd "$plugin" && zig fetch --save=fizzy "$sdk_tarball" >/dev/null)
-    done
-  )
-fi
+(cd "$work/example-plugin" && zig fetch --save=fizzy "$sdk_tarball" >/dev/null)
+# example-app bundles example-plugin (`hello`), pinned by URL: the copy here, on this tree's SDK.
+pack "$work/example-plugin" | gzip > "$work/example-plugin.tar.gz"
+(
+  cd "$work/example-app"
+  zig fetch --save=hello "$work/example-plugin.tar.gz" >/dev/null
+  zig fetch --save=fizzy "$work/fizzy.tar.gz" >/dev/null
+  # Its replay app depends on the plugin SDK alone: this tree's, packed as a release would be.
+  zig fetch --save=fizzy_sdk "$sdk_tarball" >/dev/null
+  # So do the plugins it carries, each pinning a released SDK of its own.
+  for plugin in plugins/*/; do
+    (cd "$plugin" && zig fetch --save=fizzy "$sdk_tarball" >/dev/null)
+  done
+)
 
 # The plugin build installs the plugin: into a profile of its own, not this machine's fizzy.
 export FIZZY_PROFILE="$work/profile"
@@ -112,6 +107,8 @@ build_one() {
 }
 export -f build_args build_one
 
+builds="plugin minimal studio endless studio-zon replay dvui dvui-sdl3"
+
 # Each build is one compile of an app that mostly keeps one core busy, so they run side by side,
 # EXAMPLES_JOBS at once (3: CI's runner has 4 cores and 16 GB). First each configuration is
 # configured alone (`-l` lists its steps), which fetches the lazy dependencies it asks for, so
@@ -122,10 +119,8 @@ for b in $builds; do
   for a in "${args[@]:1}"; do [[ $a == -* ]] && opts+=("$a"); done
   (cd "$work/${args[0]}" && zig build -l ${opts[@]+"${opts[@]}"} > /dev/null)
 done
-if [[ -n $builds ]]; then
-  echo "== example-plugin and example-app, against this tree"
-  printf '%s\n' $builds | xargs -P "${EXAMPLES_JOBS:-3}" -n 1 bash -c 'build_one "$1"' _
-fi
+echo "== example-plugin and example-app, against this tree"
+printf '%s\n' $builds | xargs -P "${EXAMPLES_JOBS:-3}" -n 1 bash -c 'build_one "$1"' _
 
 # An app's list is exact: one naming none of fizzy's, workbench included, fails while build.zig
 # configures, which compiles nothing. The build must fail and say which plugin is missing.
@@ -143,63 +138,3 @@ if ! grep -q 'fizzy\.plugins\.workbench' "$work/log-app-only.txt"; then
   exit 1
 fi
 echo "ok    app-only (failed as expected)"
-
-# The build API an app and a plugin package call (`fizzy.framework`, `staticModule`, `addApp`,
-# `addWebSteps`, `addPackageSteps`; design/build-api.md), on a fixture app of its own: two plugin
-# packages, one for both kinds of executable and one `.native` only, which fails to compile if it
-# reaches the wasm.
-fixtures="scripts/fixtures/build-api"
-for id in fixture_both fixture_native; do
-  mkdir -p "$work/$id"
-  cp "$fixtures"/plugin/{build.zig,build.zig.zon,plugin.zig,lib.zig,lib.c} "$work/$id/"
-  sed "s/@ID@/$id/g" "$fixtures/plugin/plugin.zig.zon.tmpl" > "$work/$id/plugin.zig.zon"
-  (cd "$work/$id" && zig fetch --save=fizzy "$sdk_tarball" >/dev/null)
-done
-mkdir -p "$work/fixture-app"
-cp "$fixtures"/app/{build.zig,build.zig.zon} "$work/fixture-app/"
-(cd "$work/fixture-app" && zig fetch --save=fizzy "$work/fizzy.tar.gz" >/dev/null \
-  && zig build -l > /dev/null)
-
-echo "== build API fixture app"
-fixture_fail=0
-# step <label> <ok|fail|any> <expected text in the output> <zig build arguments…>
-step() {
-  local label=$1 want=$2 text=$3 got=0
-  shift 3
-  (cd "$work/fixture-app" && zig build "$@") > "$work/log-fixture.txt" 2>&1 || got=$?
-  if { [[ $want == ok && $got -eq 0 ]] || [[ $want == fail && $got -ne 0 ]] || [[ $want == any ]]; } \
-    && { [[ -z $text ]] || grep -q -- "$text" "$work/log-fixture.txt"; }; then
-    echo "ok    $label"
-  else
-    echo "FAIL  $label (wanted $want, exit $got, output containing '$text')"
-    tail -n 30 "$work/log-fixture.txt" | cut -c1-300 | sed "s/^/      /"
-    fixture_fail=1
-  fi
-}
-step "native executable, both plugins linked" ok "" --prefix "$work/out/fixture"
-# The step list holds what the API adds: `web`, and `package`, `desktop` and `packageall`.
-step "web, package and packageall steps added" ok "packageall" -l
-for name in web package desktop; do
-  grep -q "^  $name " "$work/log-fixture.txt" || { echo "FAIL  step '$name' missing"; fixture_fail=1; }
-done
-step "web build leaves the native-only plugin out" ok "" web --prefix "$work/out/fixture-web"
-[[ -f "$work/out/fixture-web/web/index.html" ]] \
-  || { echo "FAIL  addWebSteps installed no web/index.html"; fixture_fail=1; }
-# `package` runs vpk, which needs dotnet; `--verbose` prints its command line, `vpk-args` on it.
-# Whether vpk then packs the fixture is not the question, so the status is not read; the files of
-# `package-dirs` are staged into the pack input before vpk runs, and that is read from disk.
-if command -v dotnet > /dev/null; then
-  step "vpk-args reach vpk pack" any "--fixture-vpk-arg" package --verbose --prefix "$work/out/fixture-pkg"
-  staged=$(ls "$work"/out/fixture-pkg/*/.pack-input/fixture-helper.txt 2>/dev/null || true)
-  if [[ -n $staged && $(cat "$staged") == "beside the executable" ]]; then
-    echo "ok    package-dirs staged into the pack input"
-  else
-    echo "FAIL  package-dirs file missing from the pack input"
-    fixture_fail=1
-  fi
-else
-  echo "skip  vpk-args reach vpk pack, package-dirs staged (no dotnet)"
-fi
-step "a plugin listed twice is an error" fail "listed twice" -Dfixture-fail=twice
-step "an app's own web step is an error" fail "already has a \`web\` step" -Dfixture-fail=web-taken
-[[ $fixture_fail -eq 0 ]]
diff --git a/scripts/fixtures/build-api/app/build.zig b/scripts/fixtures/build-api/app/build.zig
deleted file mode 100644
index 736fc2c34..000000000
--- a/scripts/fixtures/build-api/app/build.zig
+++ /dev/null
@@ -1,50 +0,0 @@
-//! An application over fizzy's build API, for `scripts/check-examples.sh`: two plugin packages
-//! built with `fizzy.framework` (one for both kinds of executable, one native-only), the web and
-//! package steps, and the failures the API promises.
-//!
-//! `-Dfixture-fail=<case>` builds a list the API refuses: `twice` lists a plugin twice,
-//! `web-taken` has a `web` step already.
-const std = @import("std");
-const fizzy = @import("fizzy");
-const both = @import("fixture_both");
-const native = @import("fixture_native");
-
-pub fn build(b: *std.Build) !void {
-    const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
-    const fail = b.option([]const u8, "fixture-fail", "A case the API must refuse") orelse "";
-
-    // Files that go beside the executable in the pack input, and an argument for `vpk pack`.
-    const helpers = b.addWriteFiles();
-    _ = helpers.add("fixture-helper.txt", "beside the executable\n");
-
-    const fizzy_dep = b.dependency("fizzy", .{
-        .target = target,
-        .optimize = optimize,
-        .@"defer-app" = true,
-        .@"app-name" = @as([]const u8, "fixtureapp"),
-        .@"package-dirs" = &[_]std.Build.LazyPath{helpers.getDirectory()},
-        .@"vpk-args" = &[_][]const u8{ "--fixture-vpk-arg", "1" },
-    });
-    const both_dep = b.dependency("fixture_both", .{});
-    const native_dep = b.dependency("fixture_native", .{});
-
-    const list = [_]fizzy.BundledPlugin{
-        fizzy.plugins.workbench,
-        fizzy.plugins.text,
-        .{ .name = "fixture_both", .targets = &.{
-            .{ .target = .native, .module = both.staticModule(both_dep.builder, fizzy.framework(fizzy_dep, .native)) },
-            .{ .target = .web, .module = both.staticModule(both_dep.builder, fizzy.framework(fizzy_dep, .web)) },
-        } },
-        .{ .name = "fixture_native", .targets = &.{
-            .{ .target = .native, .module = native.staticModule(native_dep.builder, fizzy.framework(fizzy_dep, .native)) },
-        } },
-    };
-    const twice = list ++ [_]fizzy.BundledPlugin{list[2]};
-    const app = try fizzy.addApp(fizzy_dep, if (std.mem.eql(u8, fail, "twice")) &twice else &list);
-    b.installArtifact(app.exe);
-
-    if (std.mem.eql(u8, fail, "web-taken")) _ = b.step("web", "taken before the API's");
-    try fizzy.addWebSteps(b, fizzy_dep);
-    try fizzy.addPackageSteps(b, fizzy_dep);
-}
diff --git a/scripts/fixtures/build-api/app/build.zig.zon b/scripts/fixtures/build-api/app/build.zig.zon
deleted file mode 100644
index eb5bf2540..000000000
--- a/scripts/fixtures/build-api/app/build.zig.zon
+++ /dev/null
@@ -1,16 +0,0 @@
-.{
-    .name = .fixture_app,
-    .version = "0.0.1",
-    .fingerprint = 0x915c21d842947814,
-    .minimum_zig_version = "0.17.0",
-    .paths = .{ "build.zig", "build.zig.zon" },
-    .dependencies = .{
-        // Replaced by `zig fetch --save=fizzy` with this tree.
-        .fizzy = .{
-            .url = "git+https://github.com/fizzyedit/fizzy#d99a7509032aea580d2db7a2eae5100bdb9b6afd",
-            .hash = "fizzy-0.2.0-c46aVltCpgC5UG61y5Nm4TH_52KKUl5xQHTS7SayqK3W",
-        },
-        .fixture_both = .{ .path = "../fixture_both" },
-        .fixture_native = .{ .path = "../fixture_native" },
-    },
-}
diff --git a/scripts/fixtures/build-api/plugin/build.zig b/scripts/fixtures/build-api/plugin/build.zig
deleted file mode 100644
index 62b27d0b3..000000000
--- a/scripts/fixtures/build-api/plugin/build.zig
+++ /dev/null
@@ -1,24 +0,0 @@
-//! A plugin package the way `fizzy.plugin.staticModule` documents it: the module is built against
-//! the framework the application's executables link, with a dependency of its own added.
-const std = @import("std");
-const fizzy = @import("fizzy");
-
-// anytype: the Framework of fizzy's build, a build-time duck type (pinned SDKs have their own type)
-pub fn staticModule(b: *std.Build, framework: anytype) *std.Build.Module {
-    const m = fizzy.plugin.staticModule(b, framework, .{});
-    const lib = b.createModule(.{
-        .root_source_file = b.path("lib.zig"),
-        .target = framework.target,
-        .optimize = framework.optimize,
-    });
-    lib.addCSourceFile(.{ .file = b.path("lib.c") });
-    m.addImport("fixture_lib", lib);
-    return m;
-}
-
-pub fn build(b: *std.Build) void {
-    const target = b.standardTargetOptions(.{});
-    const optimize = b.standardOptimizeOption(.{});
-    const plugin = fizzy.plugin.create(b, .{ .target = target, .optimize = optimize });
-    fizzy.plugin.install(b, plugin.lib, .{});
-}
diff --git a/scripts/fixtures/build-api/plugin/build.zig.zon b/scripts/fixtures/build-api/plugin/build.zig.zon
deleted file mode 100644
index 2644c0d58..000000000
--- a/scripts/fixtures/build-api/plugin/build.zig.zon
+++ /dev/null
@@ -1,14 +0,0 @@
-.{
-    .name = .fixture_plugin,
-    .version = "0.0.1",
-    .minimum_zig_version = "0.17.0",
-    .fingerprint = 0x9b70afac3d2d8bc6,
-    .paths = .{ "build.zig", "build.zig.zon", "plugin.zig", "plugin.zig.zon", "lib.zig", "lib.c" },
-    .dependencies = .{
-        // Replaced by `zig fetch --save=fizzy` with this tree's packed SDK.
-        .fizzy = .{
-            .url = "https://github.com/fizzyedit/fizzy/releases/download/sdk-v0.2.30/fizzy-sdk-v0.2.30.tar.gz",
-            .hash = "fizzy-0.2.30-SGBwY1QnJwDznUMVnSLATxXgH2e8_Vz7eMwLj9UQ0sVU",
-        },
-    },
-}
diff --git a/scripts/fixtures/build-api/plugin/lib.c b/scripts/fixtures/build-api/plugin/lib.c
deleted file mode 100644
index 87c510882..000000000
--- a/scripts/fixtures/build-api/plugin/lib.c
+++ /dev/null
@@ -1,4 +0,0 @@
-// Weak: both fixture packages link this file into one executable.
-__attribute__((weak)) int fixture_answer(void) {
-    return 42;
-}
diff --git a/scripts/fixtures/build-api/plugin/lib.zig b/scripts/fixtures/build-api/plugin/lib.zig
deleted file mode 100644
index 0b9956a00..000000000
--- a/scripts/fixtures/build-api/plugin/lib.zig
+++ /dev/null
@@ -1,3 +0,0 @@
-//! The fixture plugin's dependency of its own: Zig declaring a function that `lib.c` defines, so
-//! a lost import or a lost C source fails the plugin's compile or link.
-pub extern fn fixture_answer() c_int;
diff --git a/scripts/fixtures/build-api/plugin/plugin.zig b/scripts/fixtures/build-api/plugin/plugin.zig
deleted file mode 100644
index dffb3e589..000000000
--- a/scripts/fixtures/build-api/plugin/plugin.zig
+++ /dev/null
@@ -1,76 +0,0 @@
-//! The build-API fixture plugin: one surface, built by `staticModule` for each kind of
-//! executable. `scripts/check-examples.sh` links it into `app/`.
-const std = @import("std");
-const builtin = @import("builtin");
-const sdk = @import("fizzy_sdk");
-const dvui = @import("dvui");
-const core = @import("core");
-const tape = @import("tape");
-const replay = @import("replay");
-const fixture_lib = @import("fixture_lib");
-
-pub const plugin_options = @import("fizzy_plugin_options");
-pub const plugin_id = plugin_options.id;
-
-// The native-only fixture is the same file under another id: a web build that links it
-// fails here, which is how the check sees a `.native` entry kept out of the wasm.
-comptime {
-    if (std.mem.eql(u8, plugin_options.id, "fixture_native") and
-        builtin.cpu.arch == .wasm32)
-    {
-        @compileError("a native-only plugin was linked into the web build");
-    }
-}
-
-// `tape` and `replay` are `core`'s own instances (design/build-api.md): the anchors a plugin
-// publishes through `core` are the very ones `replay` reads, so one file type serves both.
-comptime {
-    if (core.anchor != replay.anchor) @compileError("replay is not core's instance");
-}
-
-// The host writes plugin lifecycle state on the main UI thread.
-var plugin: sdk.Plugin = .{
-    .state = undefined,
-    .vtable = &vtable,
-    .id = plugin_id,
-    .display_name = plugin_options.name,
-};
-
-const vtable: sdk.Plugin.VTable = .{};
-
-pub fn register(host: *sdk.Host) !void {
-    // Calls into the C source of the package's own dependency: it must have reached the link.
-    if (fixture_lib.fixture_answer() != 42) return error.FixtureDependency;
-    try writeAndLoadTape(host.allocator);
-    try host.registerPlugin(&plugin);
-    try host.registerSurface(.{
-        .id = plugin_id ++ ".surface",
-        .owner = &plugin,
-        .icon = .{ .tvg = dvui.entypo.emoji_happy },
-        .title = plugin_options.name,
-        .keywords = sdk.keywords.ide.sidebar,
-        .draw = draw,
-    });
-}
-
-fn draw(_: ?*anyopaque) !dvui.App.Result {
-    dvui.label(@src(), "{s}", .{plugin_id}, .{});
-    return .ok;
-}
-
-/// A plugin writes a demo with `tape.Script`, ships it as bytes and loads it back: the tape
-/// library a plugin imports is the one the host plays with.
-fn writeAndLoadTape(gpa: std.mem.Allocator) !void {
-    var owned = owned: {
-        var script: tape.Script = .init(gpa, plugin_id, plugin_options.name);
-        errdefer script.deinit();
-        try script.command(plugin_id ++ ".hello");
-        break :owned try script.finish();
-    };
-    defer owned.deinit();
-    const bytes = try tape.binary.encode(gpa, owned.tape, .{});
-    defer gpa.free(bytes);
-    var loaded = try tape.Tape.load(gpa, bytes, .{});
-    defer loaded.deinit();
-    if (!@hasDecl(replay.Player, "play")) return error.FixtureReplay;
-}
diff --git a/scripts/fixtures/build-api/plugin/plugin.zig.zon.tmpl b/scripts/fixtures/build-api/plugin/plugin.zig.zon.tmpl
deleted file mode 100644
index 95c87698d..000000000
--- a/scripts/fixtures/build-api/plugin/plugin.zig.zon.tmpl
+++ /dev/null
@@ -1,7 +0,0 @@
-.{
-    .id = "@ID@",
-    .name = "@ID@",
-    .version = "0.0.1",
-    .min_sdk_version = "0.2.30",
-    .description = "A build-API fixture.",
-}
diff --git a/scripts/test-ci-ok.py b/scripts/test-ci-ok.py
new file mode 100644
index 000000000..f0ba17afb
--- /dev/null
+++ b/scripts/test-ci-ok.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""Run the actual ci-ok shell against selected and excluded job outcomes.
+
+Run with python3 scripts/test-ci-ok.py; no YAML package or hosted runner is needed.
+These checks cover the gate shell, not GitHub's event scheduling or cache behaviour.
+"""
+
+import os
+from pathlib import Path
+import subprocess
+import tempfile
+import unittest
+
+
+def run_block(workflow, job, after):
+    """The `run: |` script of the first step of `job` that follows the line `after`.
+
+    The block ends at the first non-blank line indented less than its body, so blank lines,
+    comments and a changed indent in the workflow do not move the extraction.
+    """
+    lines = workflow.split(f'\n  {job}:\n', 1)[1].splitlines()
+    start = next(i for i, line in enumerate(lines) if after in line)
+    run = next(i for i in range(start, len(lines)) if lines[i].strip() == 'run: |')
+    body = []
+    indent = None
+    for line in lines[run + 1:]:
+        if line.strip():
+            width = len(line) - len(line.lstrip())
+            indent = width if indent is None else indent
+            if width < indent:
+                break
+        body.append(line[indent:] if indent is not None else line)
+    return '\n'.join(body)
+
+
+class CiOkTests(unittest.TestCase):
+    def test_changes_selects_work_only_when_ready(self):
+        workflow = (Path(__file__).resolve().parents[1] / '.github/workflows/ci.yml').read_text()
+        self.assertIn('types: [opened, synchronize, reopened, ready_for_review]', workflow)
+        self.assertIn("if: always() && !(github.event_name == 'pull_request' && github.event.pull_request.draft)", workflow)
+        shell = run_block(workflow, 'changes', 'steps:')
+        cases = [
+            ('draft', 'pull_request', 'true', '', 'false', 'false'),
+            ('ready code', 'pull_request', 'false', 'src/Entry.zig', 'true', 'false'),
+            ('ready workflow', 'pull_request', 'false', '.github/workflows/ci.yml', 'true', 'true'),
+            ('ready docs', 'pull_request', 'false', 'README.md', 'false', 'false'),
+            ('main', 'push', '', 'src/Entry.zig', 'true', 'false'),
+            ('queue', 'merge_group', '', 'backend/build.zig', 'true', 'true'),
+            ('manual', 'workflow_dispatch', '', '', 'true', 'true'),
+        ]
+        # A draft must exit before invoking git. Other cases provide a successful base lookup
+        # and the changed paths, without touching refs or depending on checkout history.
+        mock_git = "git() { [ \"$DRAFT\" != true ] || exit 99; if [ \"$1\" = diff ]; then printf '%s\\n' \"$FILES\"; fi; }\n"
+        for name, event, draft, files, code, sdl in cases:
+            with self.subTest(name=name), tempfile.TemporaryDirectory() as directory:
+                output = Path(directory) / 'output'
+                env = dict(os.environ, EVENT=event, DRAFT=draft, FILES=files,
+                           PUSH_BEFORE='main-base', QUEUE_BASE='queue-base',
+                           GITHUB_OUTPUT=str(output))
+                result = subprocess.run(['bash', '-c', mock_git + shell], env=env,
+                                        capture_output=True)
+                self.assertEqual(result.returncode, 0, result.stderr.decode())
+                self.assertEqual(output.read_text(), f'code={code}\nsdl={sdl}\n')
+
+    def test_selected_jobs_must_succeed(self):
+        workflow = (Path(__file__).resolve().parents[1] / '.github/workflows/ci.yml').read_text()
+        shell = run_block(workflow, 'ci-ok', 'steps:')
+        cases = [
+            ('selected success', 'success', 'true', 'false', 'success ' * 6, 'skipped', True),
+            ('docs only', 'success', 'false', 'false', 'skipped ' * 6, 'skipped', True),
+            ('SDL success', 'success', 'true', 'true', 'success ' * 6, 'success', True),
+            ('unexpected skip', 'success', 'true', 'false', 'success skipped', 'skipped', False),
+            ('failure', 'success', 'true', 'false', 'success failure', 'skipped', False),
+            ('cancellation', 'success', 'true', 'false', 'cancelled', 'skipped', False),
+            ('filter failure', 'failure', '', '', 'skipped', 'skipped', False),
+            ('missing SDL success', 'success', 'true', 'true', 'success ' * 6, 'skipped', False),
+        ]
+        for name, changes, code, sdl, results, sdl_result, passed in cases:
+            with self.subTest(name=name):
+                env = dict(os.environ, CHANGES=changes, CODE=code, SDL=sdl,
+                           CODE_RESULTS=results, SDL_RESULT=sdl_result)
+                result = subprocess.run(['bash', '-c', shell], env=env, capture_output=True)
+                self.assertEqual(result.returncode == 0, passed, result.stdout.decode())
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/sdk/src/sdk.zig b/sdk/src/sdk.zig
index a0178237e..8ce17c7e9 100644
--- a/sdk/src/sdk.zig
+++ b/sdk/src/sdk.zig
@@ -121,7 +121,6 @@ pub const services = struct {
     pub const wikilink = @import("services/wikilink.zig");
     pub const automation = @import("services/automation.zig");
     pub const demos = @import("services/demos.zig");
-    pub const chat = @import("services/chat.zig");
     pub const plugins = @import("services/plugins.zig");
 };
 
diff --git a/sdk/src/services/chat.zig b/sdk/src/services/chat.zig
deleted file mode 100644
index 5c9405039..000000000
--- a/sdk/src/services/chat.zig
+++ /dev/null
@@ -1,71 +0,0 @@
-//! The `chat.provider` service: the conversation a chat surface shows and the one who answers it.
-//! The chat plugin draws the messages and the composer and owns no conversation; whoever has one
-//! (the host app, a team plugin, an agent bridge) registers a provider and the surface reads it.
-//! The chat plugin registers a tiny in-memory one when nothing else has, so the surface can be
-//! tried alone.
-//!
-//! Every call is on the UI thread. Optional, like every service: with no provider the surface
-//! says so.
-
-pub const Api = struct {
-    /// Bump whenever this struct's layout changes: `getServiceTyped` refuses a provider whose
-    /// version differs rather than reinterpreting one shape as another across `dlopen`.
-    pub const service_version: u32 = 1;
-    pub const service_name = "chat.provider";
-
-    ctx: *anyopaque,
-    vtable: *const VTable,
-
-    pub const Role = enum(u8) {
-        /// The person typing in the composer.
-        user,
-        /// Whoever answers.
-        assistant,
-        /// The conversation itself: an attachment came, a connection dropped.
-        system,
-    };
-
-    pub const Message = struct {
-        role: Role,
-        /// Plain text; a finished ``` fence in it is drawn as a code block.
-        text: []const u8,
-    };
-
-    pub const Status = enum(u8) {
-        /// Send is accepted.
-        ready,
-        /// An answer is being produced; the surface shows it and still lets the person type.
-        busy,
-        /// Send would be refused: no connection.
-        offline,
-    };
-
-    pub const VTable = struct {
-        messages: *const fn (ctx: *anyopaque) []const Message,
-        send: *const fn (ctx: *anyopaque, text: []const u8) bool,
-        attach: *const fn (ctx: *anyopaque) void,
-        status: *const fn (ctx: *anyopaque) Status,
-    };
-
-    /// The conversation so far, oldest first. Owned by the provider and valid until the next
-    /// `send` or the end of the frame: a caller keeping a message copies it.
-    pub fn messages(self: Api) []const Message {
-        return self.vtable.messages(self.ctx);
-    }
-
-    /// Add `text` as the person's next message. False when the provider refused it (offline); the
-    /// surface then keeps the text in the composer. `text` is only borrowed for the call.
-    pub fn send(self: Api, text: []const u8) bool {
-        return self.vtable.send(self.ctx, text);
-    }
-
-    /// The person asked to attach something. The provider decides what that means (a file picker
-    /// of its own, a drop target) and reports the result as a message.
-    pub fn attach(self: Api) void {
-        self.vtable.attach(self.ctx);
-    }
-
-    pub fn status(self: Api) Status {
-        return self.vtable.status(self.ctx);
-    }
-};
diff --git a/sdk/tape/Script.zig b/sdk/tape/Script.zig
index 90365a1a8..13188b602 100644
--- a/sdk/tape/Script.zig
+++ b/sdk/tape/Script.zig
@@ -150,7 +150,7 @@ pub fn keyframe(self: *Script, kf: Tape.Keyframe) !void {
     const root = try self.dupe(kf.root);
     try self.keyframes.append(
         a,
-        .{ .root = root, .files = files, .open = open, .settings = settings },
+        .{ .root = root, .files = files, .open = open, .layout = kf.layout, .settings = settings },
     );
     try self.push(.{ .at = self.t, .do = .{ .keyframe = @intCast(self.keyframes.items.len - 1) } });
     try self.push(.{ .at = self.t, .do = .{ .wait = .{ .until = .idle } } });
@@ -250,21 +250,16 @@ pub fn waitIdle(self: *Script, opts: WaitOptions) !void {
 pub const Skip = usize;
 
 /// Leave out everything up to `endSkip` when `tag` is drawn already. The gesture to bring it up
-/// goes between, so a person's layout that has it open is left as it is. Waits for the stage to
-/// be idle first: the skip reads the tags of the last frame drawn, which a gesture just before it
-/// has not yet changed.
+/// goes between, so a person's layout that has it open is left as it is.
 pub fn skipIfShown(self: *Script, tag: []const u8) !Skip {
-    try self.waitIdle(.{});
     try self.push(.{ .at = self.t, .do = .{ .skip = .{ .when = .{ .shown = try self.dupe(tag) }, .count = 0 } } });
     return self.ops.items.len - 1;
 }
 
 /// `skipIfShown`'s other half: leave out everything up to `endSkip` when `tag` is not drawn. The
 /// steps for a layout that has `tag` open go between, after those of a `skipIfShown` for one that
-/// has not, so exactly one of the two plays. Waits for the stage to be idle first, as
-/// `skipIfShown` does.
+/// has not, so exactly one of the two plays.
 pub fn skipIfGone(self: *Script, tag: []const u8) !Skip {
-    try self.waitIdle(.{});
     try self.push(.{ .at = self.t, .do = .{ .skip = .{ .when = .{ .gone = try self.dupe(tag) }, .count = 0 } } });
     return self.ops.items.len - 1;
 }
@@ -421,7 +416,6 @@ const testing = std.testing;
 test "a skip counts the ops pushed between it and its end" {
     var s: Script = .init(testing.allocator, "t", "T");
     try s.keyframe(.{ .root = "demo://t" });
-    try s.click(.{ .tag = "first" }, .{});
     const mark = try s.skipIfShown("rail");
     try s.click(.{ .tag = "button" }, .{});
     s.endSkip(mark);
@@ -430,7 +424,6 @@ test "a skip counts the ops pushed between it and its end" {
     defer owned.deinit();
     const ops = owned.tape.ops;
     const skip = ops[mark].do.skip;
-    try testing.expectEqual(Tape.Until.idle, ops[mark - 1].do.wait.until);
     try testing.expectEqualStrings("rail", skip.when.shown);
     // The wait for the button, the aim, the press and the release; the key after is not left out.
     try testing.expectEqual(@as(u32, 4), skip.count);
@@ -440,14 +433,12 @@ test "a skip counts the ops pushed between it and its end" {
 test "skipIfGone leaves its ops out when the tag is not drawn" {
     var s: Script = .init(testing.allocator, "t", "T");
     try s.keyframe(.{ .root = "demo://t" });
-    try s.key("tab");
     const mark = try s.skipIfGone("sheet");
     try s.key("enter");
     s.endSkip(mark);
     var owned = try s.finish();
     defer owned.deinit();
     const skip = owned.tape.ops[mark].do.skip;
-    try testing.expectEqual(Tape.Until.idle, owned.tape.ops[mark - 1].do.wait.until);
     try testing.expectEqualStrings("sheet", skip.when.gone);
     try testing.expectEqual(@as(u32, 1), skip.count);
 }
diff --git a/sdk/tape/Sequencer.zig b/sdk/tape/Sequencer.zig
index 46647c87f..fabf38ddb 100644
--- a/sdk/tape/Sequencer.zig
+++ b/sdk/tape/Sequencer.zig
@@ -1238,45 +1238,3 @@ test "a rewind and seek land on the same moment at every speed" {
         } else expected = landed;
     }
 }
-
-test "script skips after a gesture wait for fresh tags in both directions" {
-    const Script = @import("Script.zig");
-    for ([_]bool{ true, false }) |shown| {
-        var script: Script = .init(testing.allocator, "fresh-tags", "");
-        try script.keyframe(.{ .root = "demo://a" });
-        try script.key("toggle");
-        const mark = if (shown)
-            try script.skipIfShown("panel")
-        else
-            try script.skipIfGone("panel");
-        try script.key("wrong-branch");
-        script.endSkip(mark);
-        try script.key("after");
-        var owned = try script.finish();
-        defer owned.deinit();
-
-        var log: Log = .{};
-        defer log.deinit();
-        // The gesture changes the model before the stage publishes the resulting tags.
-        if (!shown) try log.tags.put(testing.allocator, "panel", .{});
-        var seq: Sequencer = .init(&owned.tape);
-        const until = std.math.inf(f64);
-        try testing.expectEqual(Progress.yielded, seq.advance(until, 16, log.sink()));
-        try testing.expectEqual(Progress.yielded, seq.advance(until, 16, log.sink()));
-        log.idle = false;
-        try testing.expectEqual(Progress.holding, seq.advance(until, 16, log.sink()));
-        try testing.expectEqual(Progress.holding, seq.advance(until, 16, log.sink()));
-        try testing.expectEqualStrings("keyframe demo://a\nkey toggle\n", log.out.items);
-
-        // A fresh frame has settled the gesture and published its tags.
-        if (shown) {
-            try log.tags.put(testing.allocator, "panel", .{});
-        } else {
-            _ = log.tags.remove("panel");
-        }
-        log.idle = true;
-        try testing.expectEqual(Progress.yielded, seq.advance(until, 16, log.sink()));
-        try testing.expectEqualStrings("keyframe demo://a\nkey toggle\nkey after\n", log.out.items);
-        try testing.expect(seq.done());
-    }
-}
diff --git a/sdk/tape/Tape.zig b/sdk/tape/Tape.zig
index a78c10a55..8ff0f51f0 100644
--- a/sdk/tape/Tape.zig
+++ b/sdk/tape/Tape.zig
@@ -232,6 +232,7 @@ pub const Keyframe = struct {
     files: []const File = &.{},
     /// Paths relative to `root`, opened in order; the last one is the active document.
     open: []const []const u8 = &.{},
+    layout: Layout = .keep,
     /// Settings the demo depends on — an editor that closes brackets, a preview beside the text —
     /// put in place at the cut whatever the viewer has chosen, and given back when the demo ends.
     settings: []const Setting = &.{},
@@ -241,6 +242,19 @@ pub const Keyframe = struct {
         for (self.files) |*f| if (std.mem.eql(u8, f.path, path)) return f;
         return null;
     }
+
+    /// How the window is arranged at the cut. The stage's to interpret, like the rest; fizzy's
+    /// leaves every window as it is, whatever is asked.
+    pub const Layout = enum {
+        /// As it is.
+        keep,
+        /// The app's default.
+        reset,
+        /// The app's default with only what the work needs showing, so the eye goes to the
+        /// demo rather than the chrome (fizzy: the documents — no bottom panel, the explorer put
+        /// away until the demo opens it).
+        focused,
+    };
 };
 
 /// One setting, as `settings.zon` spells it.
diff --git a/sdk/tape/binary.zig b/sdk/tape/binary.zig
index f839c86be..28daabb9a 100644
--- a/sdk/tape/binary.zig
+++ b/sdk/tape/binary.zig
@@ -33,9 +33,7 @@
 //! reader refuses a version it does not know (`error.UnsupportedVersion`) rather than guess, and
 //! reads every older one it does. 2 gave a `command` op its arguments, in the record's second
 //! string; a version-1 command has none. 3 added steps, files' owner and format, the blob table
-//! and the deflated form. 4 added the `skip` op. A keyframe once had a layout byte (ahead of three of
-//! padding), which nothing read and is now four bytes of padding: older tapes read the same, and
-//! an older reader reads a newer tape's zero as `keep`, the only layout that ever did anything.
+//! and the deflated form. 4 added the `skip` op.
 const std = @import("std");
 const flate = std.compress.flate;
 const Tape = @import("Tape.zig");
@@ -314,8 +312,8 @@ fn writeBody(gpa: std.mem.Allocator, tape: Tape, w: *std.Io.Writer) !void {
     var settings_at: u32 = 0;
     for (tape.keyframes) |kf| {
         try w.writeInt(u32, table.index(kf.root), .little);
-        // Reserved: versions up to 4 kept a layout byte here that nothing read, then padding.
-        try w.splatByteAll(0, 4);
+        try w.writeByte(@backingInt(kf.layout));
+        try w.splatByteAll(0, 3);
         for ([_]u32{
             files_at,
             count(kf.files.len),
@@ -550,9 +548,11 @@ pub fn read(gpa: std.mem.Allocator, bytes: []const u8, check: Tape.Check) ReadEr
     for (keyframes, 0..) |*kf, i| {
         var f: Reader = .{ .bytes = kf_bytes[i * keyframe_size ..][0..keyframe_size] };
         const root = try strings.get(try f.int(u32));
-        _ = try f.take(4);
+        const layout = std.enums.fromInt(Tape.Keyframe.Layout, try f.int(u8)) orelse return error.Corrupt;
+        _ = try f.take(3);
         kf.* = .{
             .root = root,
+            .layout = layout,
             .files = try slice(Tape.File, files, try f.int(u32), try f.int(u32)),
             .open = try slice([]const u8, open, try f.int(u32), try f.int(u32)),
             .settings = try slice(Tape.Setting, settings, try f.int(u32), try f.int(u32)),
@@ -698,6 +698,7 @@ const Everything = struct {
         .files = &files,
         .open = &.{ "a.md", "b.md" },
         .settings = &settings,
+        .layout = .reset,
     };
     /// A binary document, by its owner, and its steps.
     const sprite = [_]Tape.File{.{
@@ -772,7 +773,7 @@ fn everything() Tape {
 /// `everything` as version 2 could hold it, before steps: what `testdata/everything-v2.tape` is,
 /// written by the version-2 codec.
 fn everythingV2() Tape {
-    const keyframes = [_]Tape.Keyframe{ Everything.keyframe, .{ .root = "demo://t" } };
+    const keyframes = [_]Tape.Keyframe{ Everything.keyframe, .{ .root = "demo://t", .layout = .focused } };
     return Everything.tape(&Everything.ops_v2, &keyframes);
 }
 
diff --git a/src/backend/backend_native.zig b/src/backend/backend_native.zig
index a3cf58fc9..f1141e167 100644
--- a/src/backend/backend_native.zig
+++ b/src/backend/backend_native.zig
@@ -49,11 +49,6 @@ pub const setTitlebarColor = platform.window.setBackground;
 pub const raiseWindow = platform.window.raise;
 pub const toggleFullscreen = platform.window.toggleFullscreen;
 
-/// Every desktop window can; only a browser page may not (`backend_web.zig`).
-pub fn fullscreenSupported() bool {
-    return true;
-}
-
 /// Whether fizzy draws its own title bar here (Windows, Linux): widgets in its strip register
 /// as interactive so the strip's drag does not take their clicks.
 pub const custom_titlebar = platform.titlebar.active;
diff --git a/src/backend/backend_web.zig b/src/backend/backend_web.zig
index 3474f02b2..c8bb7174b 100644
--- a/src/backend/backend_web.zig
+++ b/src/backend/backend_web.zig
@@ -104,12 +104,8 @@ export fn FizzyWebKeyBound(key_len: usize, mods: u32) bool {
 /// backend natively.
 const page = if (builtin.target.cpu.arch == .wasm32) struct {
     extern "fizzy" fn fizzy_web_toggle_fullscreen() void;
-    extern "fizzy" fn fizzy_web_fullscreen_supported() bool;
 } else struct {
     fn fizzy_web_toggle_fullscreen() void {}
-    fn fizzy_web_fullscreen_supported() bool {
-        return true;
-    }
 };
 
 /// The page's Fullscreen API (`web/fizzy.js`), which also takes the keyboard lock so the
@@ -120,12 +116,6 @@ pub fn toggleFullscreen() void {
     page.fizzy_web_toggle_fullscreen();
 }
 
-/// False where the browser has no Fullscreen API for a page (Safari on iPhone), so the command
-/// that asks for it can stand down instead of doing nothing.
-pub fn fullscreenSupported() bool {
-    return page.fizzy_web_fullscreen_supported();
-}
-
 /// Symmetric with the native API: no window state to restore on web.
 pub fn restoreWindowState(_: *dvui.Window) void {}
 
diff --git a/src/editor/Chrome.zig b/src/editor/Chrome.zig
deleted file mode 100644
index 3b6113e04..000000000
--- a/src/editor/Chrome.zig
+++ /dev/null
@@ -1,28 +0,0 @@
-//! What of fizzy's own shape an application keeps: where the sidebar sits, and whether the panel,
-//! the menu bar and the infobar exist. An application sets them as build options
-//! (`-Dchrome-sidebar-edge=right`, `-Dchrome-panel=false`, ...); the defaults are fizzy's own
-//! frame, so nothing changes for fizzy or an app that sets none. Read by the desktop and mobile shapes; an
-//! app-supplied layout (`-Dapp-layout=`) draws its own frame and ignores them.
-const build_opts = @import("build_opts");
-
-const Chrome = @This();
-
-/// The build option's own enum, so the two cannot drift.
-pub const Edge = @TypeOf(build_opts.chrome_sidebar_edge);
-
-/// The end of the window the icon rail and the Sidebar sit at. The Sidebar's width is still its
-/// `extent` in `layout.zon`, whichever edge it is on.
-sidebar_edge: Edge = .left,
-/// The Panel place and fizzy's Output view in it. False draws neither, so nothing opens a panel.
-panel: bool = true,
-/// The in-window menu bar; macOS has only its native menu, so this changes nothing there.
-menu_bar: bool = true,
-infobar: bool = true,
-
-/// What this build was configured with.
-pub const configured: Chrome = .{
-    .sidebar_edge = build_opts.chrome_sidebar_edge,
-    .panel = build_opts.chrome_panel,
-    .menu_bar = build_opts.chrome_menu_bar,
-    .infobar = build_opts.chrome_infobar,
-};
diff --git a/src/editor/Demo.zig b/src/editor/Demo.zig
index f0f4ca188..2813e46c0 100644
--- a/src/editor/Demo.zig
+++ b/src/editor/Demo.zig
@@ -76,7 +76,7 @@ quitting: bool = false,
 /// The window as the person had it when each scene first began (a window's arrangement only), by
 /// keyframe: a seek that replays a scene starts from there, since a keyframe does not arrange the
 /// window itself. Freed when the demo lets go (`freeSaved`).
-entries: std.AutoArrayHashMapUnmanaged(*const automation.Tape.Keyframe, *Arrangement) = .empty,
+entries: std.AutoArrayHashMapUnmanaged(*const automation.Tape.Keyframe, *Snapshot) = .empty,
 /// Every plugin's settings as the demo found them, as ZON, to give back at the end.
 settings_saved: std.ArrayListUnmanaged(SavedSettings) = .empty,
 /// The app's own settings a tape can change, as the demo found them: only the window's material
@@ -110,7 +110,7 @@ const Saved = struct {
     /// The window as the person had it (places, floats, seed tree, the documents' panes), put back
     /// at the tape's end by closing what the tape made (`end`); the panes meanwhile are kept from
     /// `panes.zon` (`Workbench.panes_held`). Null where it could not be noted.
-    arrangement: ?*Arrangement,
+    arrangement: ?*Snapshot,
     /// The one they were in.
     active: ?u64,
     /// The explorer's open folders, and whether its root had opened (`Workbench.file_tree_root_opened`).
@@ -285,8 +285,11 @@ pub fn frame(self: *Demo) void {
             .tape => |bytes| self.playTape(bytes) catch {},
         }
     }
-    // A drop beside is aimed at where the workbench would split the target place, as its room is now.
-    self.editor.app.layout.beside = if (self.active()) .{ .ctx = self, .edge = besideEdge } else null;
+    // A drop beside is aimed at where the workbench would split, as the room is now.
+    self.editor.app.layout.beside = if (self.active())
+        if (self.editor.workbench.besideEdge()) |side| std.meta.stringToEnum(SplitTree.Side, @tagName(side)) else null
+    else
+        null;
     self.snapshot.beginFrame();
     self.live.frame();
     self.player.frame();
@@ -469,9 +472,14 @@ fn begin(ctx: *anyopaque, _: *const automation.Tape) void {
     // Their documents stay open where they are, and nothing of the demo's closes, saves or
     // restores them (`ownsDocument`).
     const gpa = editor.app.gpa;
-    const arrangement: ?*Arrangement = Arrangement.create(editor) catch |err| blk: {
-        dvui.log.warn("demo: could not note the window: {t}", .{err});
-        break :blk null;
+    const arrangement: ?*Snapshot = blk: {
+        const snap = newSnapshot(editor) orelse break :blk null;
+        fillArrangement(editor, snap) catch |err| {
+            dvui.log.warn("demo: could not note the window: {t}", .{err});
+            destroySnapshot(editor, snap);
+            break :blk null;
+        };
+        break :blk snap;
     };
     // Held only when there is something to put back: the panes would be saved as the person's.
     editor.workbench.panes_held = arrangement != null;
@@ -530,9 +538,11 @@ fn end(ctx: *anyopaque) void {
     // documents' panes are the workbench's own, kept from `panes.zon` while the tape played
     // (`Workbench.panes_held`).
     const saved = self.saved orelse return;
-    if (saved.arrangement) |arrangement| {
-        restoreArrangement(editor, arrangement, true) catch |err| dvui.log.warn("demo: could not put the window back: {t}", .{err});
-        arrangement.restoreExplorer(editor);
+    if (saved.arrangement) |snap| {
+        restoreArrangement(editor, snap, true) catch |err| dvui.log.warn("demo: could not put the window back: {t}", .{err});
+        if (snap.explorer_closed != editor.explorer.closed) {
+            if (snap.explorer_closed) editor.explorer.close(editor) else editor.explorer.open(editor);
+        }
     }
     editor.app.layout.dirty = false;
     editor.command_palette.finishClose();
@@ -575,12 +585,13 @@ fn keep(ctx: *anyopaque) void {
 fn freeSaved(self: *Demo) void {
     const gpa = self.editor.app.gpa;
     for (self.entries.values()) |entry| {
-        entry.destroy(gpa);
+        entry.arena.deinit();
+        gpa.destroy(entry);
     }
     self.entries.clearAndFree(gpa);
     const saved = self.saved orelse return;
     if (saved.folder) |f| gpa.free(f);
-    if (saved.arrangement) |arrangement| arrangement.destroy(gpa);
+    if (saved.arrangement) |snap| destroySnapshot(self.editor, snap);
     gpa.free(saved.branches);
     self.saved = null;
 }
@@ -628,11 +639,18 @@ fn enterScene(self: *Demo, kf: *const automation.Tape.Keyframe) void {
     if (self.entries.get(kf)) |entry| {
         restoreArrangement(editor, entry, false) catch |err|
             dvui.log.warn("demo: could not put the window back to where the scene began: {t}", .{err});
-        entry.restoreExplorer(editor);
+        if (entry.explorer_closed != editor.explorer.closed) {
+            if (entry.explorer_closed) editor.explorer.close(editor) else editor.explorer.open(editor);
+        }
         return;
     }
-    const entry = Arrangement.create(editor) catch return;
-    self.entries.put(gpa, kf, entry) catch entry.destroy(gpa);
+    const entry = newSnapshot(editor) orelse return;
+    const stored = blk: {
+        fillArrangement(editor, entry) catch break :blk false;
+        self.entries.put(gpa, kf, entry) catch break :blk false;
+        break :blk true;
+    };
+    if (!stored) destroySnapshot(editor, entry);
 }
 
 // ---- settings --------------------------------------------------------------------------------
@@ -854,26 +872,6 @@ fn commandTitle(ctx: *anyopaque, id: []const u8) ?[]const u8 {
     return c.title;
 }
 
-/// The edge a drop beside aims at over place `name`: where the workbench would split the pane
-/// shown there (a pane of its own tree is named for its grouping). A pane the layout's keywords
-/// show is in no list, so Main is the person's pane.
-pub fn besideEdge(ctx: *anyopaque, name: []const u8) ?SplitTree.Side {
-    const editor = from(ctx).editor;
-    const wb = &editor.workbench;
-    const grouping = Editor.Workspace.groupingOfName(name) orelse editor.workspaces.groupingIn(name) orelse blk: {
-        const main = editor.regionFor(sdk.keywords.ide.main) orelse return null;
-        if (!std.mem.eql(u8, main.name, name)) return null;
-        var layout = Editor.Layout.init(&editor.app.host, &editor.app.layout, editor.app.gpa, editor.app.host.arena());
-        var buf: [64]u8 = undefined;
-        const id = std.mem.print(&buf, Editor.Workspaces.id_prefix ++ "{d}", .{wb.open_workspace_grouping}) catch return null;
-        if (Editor.Layout.ViewDrag.holderOf(&layout, id)) |holder| {
-            if (!std.mem.eql(u8, holder, name)) return null;
-        }
-        break :blk wb.open_workspace_grouping;
-    };
-    return wb.besideEdge(grouping);
-}
-
 /// The place a role names, by what it is rather than what the person's layout calls it.
 fn resolveRole(ctx: *anyopaque, role: []const u8, buf: []u8) ?[]const u8 {
     const keywords = if (std.mem.eql(u8, role, "documents"))
@@ -897,33 +895,32 @@ fn fastForward(ctx: *anyopaque, on: bool) void {
 // ---- snapshots ---------------------------------------------------------------------------------
 
 /// A moment of a scene, for a seek to come back to (see the file comment). Everything in `arena`.
-/// A snapshot of the app as it is now, less what `fill` writes. Takes `arrangement`, which a failed
-/// call frees.
-fn newSnapshot(editor: *Editor, arrangement: Arrangement) ?*Snapshot {
+/// A snapshot of the app as it is now, less what `fill` and `fillArrangement` write.
+fn newSnapshot(editor: *Editor) ?*Snapshot {
     const gpa = editor.app.gpa;
-    const snap = gpa.create(Snapshot) catch {
-        arrangement.arena.deinit();
-        return null;
-    };
+    const snap = gpa.create(Snapshot) catch return null;
     snap.* = .{
         .arena = .init(gpa),
         .root = "",
         .nodes = &.{},
         .docs = &.{},
         .active = null,
-        .arrangement = arrangement,
+        .explorer_closed = editor.explorer.closed,
         .branches = &.{},
         .root_opened = editor.workbench.file_tree_root_opened,
         .settings = &.{},
         .material = editor.app.settings.window_material,
         .focus = dvui.focusedWidgetId() orelse .zero,
         .focus_subwindow = dvui.focusedSubwindowId(),
+        .regions = "",
+        .tree = null,
+        .places = &.{},
+        .panes = undefined,
     };
     return snap;
 }
 
 fn destroySnapshot(editor: *Editor, snap: *Snapshot) void {
-    snap.arrangement.arena.deinit();
     snap.arena.deinit();
     editor.app.gpa.destroy(snap);
 }
@@ -937,7 +934,7 @@ const Snapshot = struct {
     /// Open documents, in the order they were opened, and which was active.
     docs: []const Doc,
     active: ?usize,
-    arrangement: Arrangement,
+    explorer_closed: bool,
     branches: []const dvui.Id,
     /// Whether the tree had opened its root on its own yet (`Workbench.file_tree_root_opened`),
     /// put back with `branches`: a root shut because the tree had not been drawn yet would stay
@@ -947,26 +944,16 @@ const Snapshot = struct {
     material: core.material.Kind,
     focus: dvui.Id,
     focus_subwindow: dvui.Id,
-
-    const Node = struct { path: []const u8, kind: @FieldType(core.vfs.Mem.Node, "kind"), bytes: []const u8 };
-    const Doc = struct { path: []const u8, grouping: u64, state: []const u8 };
-};
-
-/// The app's places as `Arrangement.regions` holds them.
-const RegionsZon = struct { regions: []const fizzy.backend.SavedRegion };
-
-/// How the window is arranged: what a scene's start, a snapshot and the tape's end put back.
-const Arrangement = struct {
-    arena: std.heap.ArenaAllocator,
-    /// The app's places as `layout.zon` would remember them (`Editor.collectSavedRegions`, ZON, by
-    /// name), its seed tree (ZON, null with none), each place's widget state and view, and the
-    /// documents' panes.
+    /// How the window was arranged: the app's places as `layout.zon` would remember them
+    /// (`Editor.collectSavedRegions`, ZON, by name), its seed tree (ZON, null with none), each
+    /// place's widget state and view, and the documents' panes.
     regions: [:0]const u8,
     tree: ?[:0]const u8,
     places: []const Place,
     panes: Editor.Workbench.Arrangement,
-    explorer_closed: bool,
 
+    const Node = struct { path: []const u8, kind: @FieldType(core.vfs.Mem.Node, "kind"), bytes: []const u8 };
+    const Doc = struct { path: []const u8, grouping: u64, state: []const u8 };
     /// A place as it was drawn: how wide (`_size`; zero is shut), where it opens back to (`_open`),
     /// whether it was opened on a window too narrow for it (`_peek`), and the view it showed. The
     /// explorer's place keeps only its view: a restore opens or shuts the explorer itself
@@ -981,66 +968,11 @@ const Arrangement = struct {
         open: ?f32,
         peek: ?bool,
     };
-
-    /// The window as it is now, on its own arena; `destroy` frees it.
-    fn create(editor: *Editor) !*Arrangement {
-        const gpa = editor.app.gpa;
-        const self = try gpa.create(Arrangement);
-        errdefer gpa.destroy(self);
-        self.* = try take(editor, gpa);
-        return self;
-    }
-
-    /// The window as it is now, by value; its arena is in `gpa` and the owner frees it with
-    /// `arena.deinit()` (`destroy` does, for one made by `create`).
-    fn take(editor: *Editor, gpa: std.mem.Allocator) !Arrangement {
-        var arena: std.heap.ArenaAllocator = .init(gpa);
-        errdefer arena.deinit();
-        const a = arena.allocator();
-        const explorer = if (editor.regionFor(sdk.keywords.ide.sidebar)) |r| r.name else "";
-        const regions = editor.app.layout.regions.items;
-        const places = try a.alloc(Place, regions.len);
-        var n: usize = 0;
-        for (regions) |r| {
-            if (r.name.len == 0 or r.id == .zero) continue;
-            const view = editor.app.host.selectionForKey(r.selectionKey());
-            places[n] = .{
-                .id = r.id,
-                .key = r.selectionKey(),
-                .view = if (view) |v| try a.dupe(u8, v) else null,
-                .sized = !r.by_name and !std.mem.eql(u8, r.name, explorer),
-                .size = dvui.dataGet(null, r.id, "_size", f32),
-                .open = dvui.dataGet(null, r.id, "_open", f32),
-                .peek = dvui.dataGet(null, r.id, "_peek", bool),
-            };
-            n += 1;
-        }
-        const saved_regions = try regionsZon(editor, a);
-        const tree = try treeZon(editor, a);
-        const panes = try editor.workbench.arrangement(a);
-        // Copy the arena only after every allocation has updated its buffer list.
-        return .{
-            .arena = arena,
-            .regions = saved_regions,
-            .tree = tree,
-            .places = places[0..n],
-            .panes = panes,
-            .explorer_closed = editor.explorer.closed,
-        };
-    }
-
-    fn destroy(self: *Arrangement, gpa: std.mem.Allocator) void {
-        self.arena.deinit();
-        gpa.destroy(self);
-    }
-
-    /// Open or shut the explorer as it was.
-    fn restoreExplorer(self: *const Arrangement, editor: *Editor) void {
-        if (self.explorer_closed == editor.explorer.closed) return;
-        if (self.explorer_closed) editor.explorer.close(editor) else editor.explorer.open(editor);
-    }
 };
 
+/// The app's places and seed tree as `Snapshot.regions` and `Snapshot.tree` hold them.
+const Arrangement = struct { regions: []const fizzy.backend.SavedRegion };
+
 /// The app's places as ZON, by name, in `gpa`: what a snapshot compares and puts back.
 fn regionsZon(editor: *Editor, gpa: std.mem.Allocator) ![:0]u8 {
     const regions = editor.collectSavedRegions(gpa);
@@ -1053,7 +985,7 @@ fn regionsZon(editor: *Editor, gpa: std.mem.Allocator) ![:0]u8 {
     }.less);
     var aw: std.Io.Writer.Allocating = .init(gpa);
     errdefer aw.deinit();
-    try std.zon.stringify.serializeMaxDepth(RegionsZon{ .regions = regions }, .{}, &aw.writer, 16);
+    try std.zon.stringify.serializeMaxDepth(Arrangement{ .regions = regions }, .{}, &aw.writer, 16);
     return aw.toOwnedSliceSentinel(0);
 }
 
@@ -1076,8 +1008,7 @@ fn capture(ctx: *anyopaque) ?*anyopaque {
     const root = self.mount orelse return null;
     const mem = self.mem orelse return null;
 
-    const arrangement = Arrangement.take(editor, editor.app.gpa) catch return null;
-    const snap = newSnapshot(editor, arrangement) orelse return null;
+    const snap = newSnapshot(editor) orelse return null;
     snap.root = root;
     const ok = fill(self, snap, root, mem) catch false;
     if (!ok) {
@@ -1126,44 +1057,72 @@ fn fill(self: *Demo, snap: *Snapshot, root: []const u8, mem: *core.vfs.Mem) !boo
     }
     snap.settings = settings.items;
 
+    try fillArrangement(editor, snap);
     return true;
 }
 
-/// Put the window back to how `arrangement` found it: the app's places, the
+/// `snap`'s window arrangement: the app's places, seed tree, each place's state, the documents' panes.
+fn fillArrangement(editor: *Editor, snap: *Snapshot) !void {
+    const a = snap.arena.allocator();
+    snap.regions = try regionsZon(editor, a);
+    snap.tree = try treeZon(editor, a);
+    const explorer = if (editor.regionFor(sdk.keywords.ide.sidebar)) |r| r.name else "";
+    const regions = editor.app.layout.regions.items;
+    const places = try a.alloc(Snapshot.Place, regions.len);
+    var n: usize = 0;
+    for (regions) |r| {
+        if (r.name.len == 0 or r.id == .zero) continue;
+        const view = editor.app.host.selectionForKey(r.selectionKey());
+        places[n] = .{
+            .id = r.id,
+            .key = r.selectionKey(),
+            .view = if (view) |v| try a.dupe(u8, v) else null,
+            .sized = !r.by_name and !std.mem.eql(u8, r.name, explorer),
+            .size = dvui.dataGet(null, r.id, "_size", f32),
+            .open = dvui.dataGet(null, r.id, "_open", f32),
+            .peek = dvui.dataGet(null, r.id, "_peek", bool),
+        };
+        n += 1;
+    }
+    snap.places = places[0..n];
+    snap.panes = try editor.workbench.arrangement(a);
+}
+
+/// Put the window back to how `snap` found it (`Snapshot.regions` and on): the app's places, the
 /// floats, the seed tree, the documents' panes and each place's size and view. What is the same
 /// already is left alone, so a restore within one arrangement touches nothing of it. An error —
 /// having changed nothing — when it could not be read back: everything that can fail is done
 /// before anything changes. `graceful`: a float made since flies shut rather than going at once.
-fn restoreArrangement(editor: *Editor, arrangement: *const Arrangement, graceful: bool) !void {
+fn restoreArrangement(editor: *Editor, snap: *const Snapshot, graceful: bool) !void {
     const gpa = editor.app.gpa;
     const state = &editor.app.layout;
     var arena: std.heap.ArenaAllocator = .init(gpa);
     defer arena.deinit();
     var diag: std.zon.parse.Diagnostics = undefined;
 
-    // The app's places as the arrangement had them, where they differ from now.
+    // The app's places as the snapshot had them, where they differ from now.
     const regions: ?[]const fizzy.backend.SavedRegion = blk: {
         const now = try regionsZon(editor, gpa);
         defer gpa.free(now);
-        if (std.mem.eql(u8, now, arrangement.regions)) break :blk null;
-        break :blk (try std.zon.parse.fromSlice(RegionsZon, .{ .gpa = gpa, .arena = arena.allocator(), .source = arrangement.regions, .diagnostics = &diag })).regions;
+        if (std.mem.eql(u8, now, snap.regions)) break :blk null;
+        break :blk (try std.zon.parse.fromSlice(Arrangement, .{ .gpa = gpa, .arena = arena.allocator(), .source = snap.regions, .diagnostics = &diag })).regions;
     };
     // Its seed tree, built, where it differs: null for none at all.
     const same_tree = blk: {
         const now = try treeZon(editor, gpa);
         defer if (now) |t| gpa.free(t);
-        if (now == null or arrangement.tree == null) break :blk now == null and arrangement.tree == null;
-        break :blk std.mem.eql(u8, now.?, arrangement.tree.?);
+        if (now == null or snap.tree == null) break :blk now == null and snap.tree == null;
+        break :blk std.mem.eql(u8, now.?, snap.tree.?);
     };
     var dock: ?core.widgets.DockLayout = null;
-    if (!same_tree) if (arrangement.tree) |source| {
+    if (!same_tree) if (snap.tree) |source| {
         const tree = try std.zon.parse.fromSlice(core.widgets.DockLayout.Snapshot, .{ .gpa = gpa, .arena = arena.allocator(), .source = source, .diagnostics = &diag });
         dock = try core.widgets.DockLayout.fromSnapshot(gpa, tree);
         dock.?.animated = true;
     };
     errdefer if (dock) |*d| d.deinit();
     // The panes: all or nothing, and the last thing that can fail.
-    try editor.workbench.arrange(arrangement.panes);
+    try editor.workbench.arrange(snap.panes);
 
     if (regions) |saved| {
         state.clearArrangement(gpa);
@@ -1209,12 +1168,12 @@ fn restoreArrangement(editor: *Editor, arrangement: *const Arrangement, graceful
     // forgotten too, or a split of that name made again would open at the size this one was left.
     for (state.regions.items) |r| {
         if (r.by_name or r.id == .zero) continue;
-        const had = for (arrangement.places) |p| {
+        const had = for (snap.places) |p| {
             if (p.id == r.id) break true;
         } else false;
         if (!had) @import("app").layout.Layout.State.forgetWidgetSize(r.id);
     }
-    for (arrangement.places) |p| {
+    for (snap.places) |p| {
         if (p.sized) {
             putData(f32, p.id, "_size", p.size);
             // At rest at that size, not easing toward it.
@@ -1252,7 +1211,7 @@ fn restore(ctx: *anyopaque, raw: *anyopaque) bool {
     for (snap.docs) |d| _ = openDoc(editor, d.path) orelse return false;
     // The window as it was, before anything else is put back: it can fail, and fails changing
     // nothing.
-    restoreArrangement(editor, &snap.arrangement, false) catch |err| {
+    restoreArrangement(editor, snap, false) catch |err| {
         dvui.log.warn("demo: could not put the window's layout back: {t}", .{err});
         return false;
     };
@@ -1284,7 +1243,9 @@ fn restore(ctx: *anyopaque, raw: *anyopaque) bool {
         if (openIndex(editor, snap.docs[a].path)) |index| editor.workbench.setActiveDocIndex(index);
     }
 
-    snap.arrangement.restoreExplorer(editor);
+    if (snap.explorer_closed != editor.explorer.closed) {
+        if (snap.explorer_closed) editor.explorer.close(editor) else editor.explorer.open(editor);
+    }
     editor.workbench.open_branches.clearRetainingCapacity();
     for (snap.branches) |id| editor.workbench.setBranchOpen(id, true);
     editor.workbench.file_tree_root_opened = snap.root_opened;
diff --git a/src/editor/Editor.zig b/src/editor/Editor.zig
index 5e1e0e63e..2c99793ad 100644
--- a/src/editor/Editor.zig
+++ b/src/editor/Editor.zig
@@ -67,7 +67,6 @@ const PluginManager = @import("app").store.Manager;
 pub const FilesService = @import("FilesService.zig");
 const SettingsTree = @import("SettingsTree.zig");
 const OutputPanel = @import("OutputPanel.zig");
-pub const Chrome = @import("Chrome.zig");
 const SettingsPluginsZon = @import("app").settings.PluginsZon;
 const file_glyphs = @import("file_glyphs.zig");
 const SettingsWatcher = @import("app").watch.SettingsWatcher;
@@ -201,10 +200,6 @@ sidebar: Sidebar,
 
 infobar: Infobar,
 
-/// The frame of fizzy's shape this build keeps. A field and not a `comptime` read so a test can
-/// draw the shape either way.
-chrome: Chrome = .configured,
-
 /// Whether a text-input widget held keyboard focus at the end of the last frame.
 ///
 /// `dvui.wantTextInput` is the cross-cutting signal — dvui's own `TextEntryWidget`, the text
@@ -2319,15 +2314,13 @@ pub fn postInit(editor: *Editor) !void {
     // even with no document open, since it's a diagnostic view, not a per-file one. Before the
     // plugins, so it is the bottom panel's first view and a plugin's (the dashboard, a terminal)
     // comes after it: a region shows its first view until someone picks another.
-    if (editor.chrome.panel) {
-        try editor.app.host.registerSurface(.{
-            .id = "fizzy.output",
-            .title = "Output",
-            .keywords = sdk.keywords.ide.panel,
-            .persistent = true,
-            .draw = OutputPanel.draw,
-        });
-    }
+    try editor.app.host.registerSurface(.{
+        .id = "fizzy.output",
+        .title = "Output",
+        .keywords = sdk.keywords.ide.panel,
+        .persistent = true,
+        .draw = OutputPanel.draw,
+    });
 
     inline for (bundled_plugins) |m| {
         const extra: ?*anyopaque = if (comptime std.mem.eql(u8, m.plugin_id, "workbench")) @ptrCast(&editor.workbench) else null;
diff --git a/src/editor/Keybinds.zig b/src/editor/Keybinds.zig
index 60d45e264..29db9c310 100644
--- a/src/editor/Keybinds.zig
+++ b/src/editor/Keybinds.zig
@@ -163,9 +163,9 @@ const fizzy_commands = [_]FizzyCommand{
     .{ .id = "fizzy.redo", .title = "Redo", .bind = "redo", .run = cmdRedo, .isEnabled = anyDocOpen, .params = HistoryStep.params, .runWith = HistoryStep.bind(cmdRedoWith), .icon = icons.tvg.lucide.redo },
     .{ .id = "fizzy.copy", .title = "Copy", .bind = "copy", .run = cmdCopy, .isEnabled = cmdCopyEnabled, .icon = icons.tvg.lucide.copy },
     .{ .id = "fizzy.paste", .title = "Paste", .bind = "paste", .run = cmdPaste, .isEnabled = cmdPasteEnabled, .icon = icons.tvg.lucide.@"clipboard-paste" },
-    .{ .id = "fizzy.toggleExplorer", .title = "Toggle Explorer", .bind = "explorer", .run = cmdToggleExplorer, .icon = if (Editor.Chrome.configured.sidebar_edge == .right) icons.tvg.lucide.@"panel-right" else icons.tvg.lucide.@"panel-left" },
+    .{ .id = "fizzy.toggleExplorer", .title = "Toggle Explorer", .bind = "explorer", .run = cmdToggleExplorer, .icon = icons.tvg.lucide.@"panel-left" },
     .{ .id = "fizzy.resetLayout", .title = "Reset Layout", .bind = null, .run = cmdResetLayout, .icon = icons.tvg.lucide.@"rotate-ccw" },
-    .{ .id = "fizzy.toggleFullScreen", .title = "Toggle Full Screen", .bind = null, .run = cmdToggleFullScreen, .isEnabled = cmdToggleFullScreenEnabled, .icon = icons.tvg.lucide.maximize },
+    .{ .id = "fizzy.toggleFullScreen", .title = "Toggle Full Screen", .bind = null, .run = cmdToggleFullScreen, .icon = icons.tvg.lucide.maximize },
     .{ .id = "fizzy.fitView", .title = "Fit to View", .bind = null, .run = cmdFitView, .isEnabled = cmdFitViewEnabled, .icon = icons.tvg.lucide.scan },
     .{ .id = "fizzy.deleteSelection", .title = "Delete Selection", .bind = "delete_selection_contents", .run = cmdDeleteSelection, .isEnabled = cmdDeleteSelectionEnabled, .icon = icons.tvg.lucide.@"trash-2" },
     .{ .id = "fizzy.accept", .title = "Accept", .bind = "activate", .run = cmdAccept, .isEnabled = cmdAcceptEnabled, .icon = icons.tvg.lucide.check },
@@ -696,10 +696,6 @@ fn cmdToggleFullScreen(_: *anyopaque) anyerror!void {
     fizzy.backend.toggleFullscreen();
 }
 
-fn cmdToggleFullScreenEnabled(_: *anyopaque) bool {
-    return fizzy.backend.fullscreenSupported();
-}
-
 fn cmdShowDvuiDemo(_: *anyopaque) anyerror!void {
     dvui.Examples.show_demo_window = !dvui.Examples.show_demo_window;
 }
diff --git a/src/editor/Workspaces.zig b/src/editor/Workspaces.zig
index 3b614299f..1c1bfda8a 100644
--- a/src/editor/Workspaces.zig
+++ b/src/editor/Workspaces.zig
@@ -119,7 +119,6 @@ pub fn sync(self: *Workspaces) void {
         self.settle();
     }
     var first: ?u64 = null;
-    var l = layoutOf(editor);
     for (wb.workspaces.keys()) |g| {
         if (self.assigned(g)) continue;
         if (first == null) {
@@ -127,10 +126,11 @@ pub fn sync(self: *Workspaces) void {
             continue;
         }
         // The anchor's room asks the side, when it has one yet.
+        var l = layoutOf(editor);
         var abuf: [64]u8 = undefined;
         const room = if (Layout.ViewDrag.holderOf(&l, viewId(&abuf, first.?))) |holder| Layout.ViewDrag.placeSize(l.state, holder) else null;
         const side = if (room) |r| Workbench.sideFor(r.w, r.h) else .right;
-        _ = besideIn(&l, g, first.?, side, true);
+        _ = beside(self, g, first.?, side, true);
     }
 }
 
@@ -289,36 +289,22 @@ fn layoutOf(editor: *Editor) Layout {
     return Layout.init(&editor.app.host, &editor.app.layout, editor.app.gpa, editor.app.host.arena());
 }
 
-/// The pane shown in place `name`: the person's own when it is there, else the first held.
-/// Null where the place holds no pane (a pane the keywords show is in no list: the caller's).
-pub fn groupingIn(self: *Workspaces, name: []const u8) ?u64 {
-    const editor = self.editorOf();
-    var l = layoutOf(editor);
-    var buf: [64]u8 = undefined;
-    var first: ?u64 = null;
-    for (self.views.keys()) |g| {
-        const holder = Layout.ViewDrag.holderOf(&l, viewId(&buf, g)) orelse continue;
-        if (!std.mem.eql(u8, holder, name)) continue;
-        if (g == editor.workbench.open_workspace_grouping) return g;
-        first = first orelse g;
-    }
-    return first;
-}
-
 fn beside(ctx: *anyopaque, grouping: u64, anchor: u64, side: Workbench.Panes.Side, adaptive: bool) bool {
     const self: *Workspaces = @ptrCast(@alignCast(ctx));
-    var l = layoutOf(self.editorOf());
-    return besideIn(&l, grouping, anchor, side, adaptive);
-}
-
-fn besideIn(l: *Layout, grouping: u64, anchor: u64, side: Workbench.Panes.Side, adaptive: bool) bool {
+    const editor = self.editorOf();
+    var l = layoutOf(editor);
     var abuf: [64]u8 = undefined;
-    const place = Layout.ViewDrag.holderOf(l, viewId(&abuf, anchor)) orelse return false;
-    const new = Layout.splitOn(l, place, side) orelse return false;
+    const place = Layout.ViewDrag.holderOf(&l, viewId(&abuf, anchor)) orelse return false;
+    const new = Layout.splitOn(&l, place, switch (side) {
+        .left => .left,
+        .right => .right,
+        .top => .top,
+        .bottom => .bottom,
+    }) orelse return false;
     var buf: [64]u8 = undefined;
     const id = l.arena.dupe(u8, viewId(&buf, grouping)) catch return false;
     l.state.assign(l.gpa, new, &.{id}) catch return false;
-    if (adaptive) Layout.markAdaptive(l, new);
+    if (adaptive) Layout.markAdaptive(&l, new);
     l.state.markDirty();
     return true;
 }
@@ -368,7 +354,12 @@ fn open(ctx: *anyopaque, grouping: u64, side: Workbench.Panes.Side) bool {
     var l = layoutOf(self.editorOf());
     var buf: [64]u8 = undefined;
     const place = Layout.ViewDrag.holderOf(&l, viewId(&buf, grouping)) orelse return false;
-    return Layout.splitOn(&l, place, side) != null;
+    return Layout.splitOn(&l, place, switch (side) {
+        .left => .left,
+        .right => .right,
+        .top => .top,
+        .bottom => .bottom,
+    }) != null;
 }
 
 /// The view of the workspace whose only tab is document `id`, if one is.
diff --git a/src/editor/layout.zig b/src/editor/layout.zig
index dbe787f8c..36c9174f4 100644
--- a/src/editor/layout.zig
+++ b/src/editor/layout.zig
@@ -11,8 +11,6 @@ const app = @import("app");
 
 const Layout = app.layout.Layout;
 const Menu = @import("Menu.zig");
-const Sidebar = @import("Sidebar.zig");
-const Chrome = @import("Chrome.zig");
 
 pub const sidebar = sdk.keywords.ide.sidebar;
 pub const bottom = sdk.keywords.ide.panel;
@@ -20,8 +18,6 @@ pub const main_area = sdk.keywords.ide.main;
 
 pub fn layout(ctx: ?*anyopaque, f: *Layout) !dvui.App.Result {
     const editor: *fizzy.Editor = @ptrCast(@alignCast(ctx.?));
-    const chrome = editor.chrome;
-    const rail_left = chrome.sidebar_edge == .left;
     // The card Main and Panel wear, and every float's places with them (`Layout.card`).
     f.card = placeCard(editor);
     // The blur harness: a frosted card above the shape, declared last so it floats over it.
@@ -29,71 +25,42 @@ pub fn layout(ctx: ?*anyopaque, f: *Layout) !dvui.App.Result {
     var body = dvui.box(@src(), .{ .dir = .horizontal }, .{ .expand = .both });
     defer body.deinit();
 
-    var rail_action: Sidebar.Action = .none;
-    if (rail_left) rail_action = try editor.sidebar.draw(editor, f, sidebar);
+    const rail_action = try editor.sidebar.draw(editor, f, sidebar);
 
-    {
-        var stack = dvui.box(@src(), .{ .dir = .vertical }, .{
-            .expand = .both,
-            .background = false,
-        });
-        defer stack.deinit();
-
-        if (chrome.infobar) editor.infobar.draw(editor) catch dvui.log.err("Failed to draw infobar", .{});
-
-        if (chrome.menu_bar and (builtin.target.os.tag != .macos or Menu.debug_force_on_macos)) {
-            const r = try Menu.draw(editor);
-            if (r != .ok) return r;
-        }
+    var stack = dvui.box(@src(), .{ .dir = .vertical }, .{
+        .expand = .both,
+        .background = false,
+    });
+    defer stack.deinit();
 
-        // The window fill shows as a frame around the cards: the rail on one side, so the work area
-        // insets itself on the other.
-        var work = try f.region(@src(), .{ .dir = .horizontal }, .{
-            .expand = .both,
-            .padding = if (rail_left) dvui.Rect{ .w = edge_gutter } else dvui.Rect{ .x = edge_gutter },
-        });
-        defer work.deinit();
-
-        // The Sidebar's sash is the `split` after it on the left and the one before it on the
-        // right, as the Panel's is before it: `Layout.drawPendingSplit` resizes the nearer
-        // `resize` region.
-        if (rail_left) {
-            try sidebarRegion(editor, f);
-            applyRailAction(editor, f, rail_action);
-            f.split(@src(), .{});
-        }
-        try contentRegion(f, chrome);
-        if (!rail_left) {
-            f.split(@src(), .{});
-            try sidebarRegion(editor, f);
-        }
-    }
+    editor.infobar.draw(editor) catch dvui.log.err("Failed to draw infobar", .{});
 
-    if (!rail_left) {
-        rail_action = try editor.sidebar.draw(editor, f, sidebar);
-        applyRailAction(editor, f, rail_action);
+    if (builtin.target.os.tag != .macos or Menu.debug_force_on_macos) {
+        const r = try Menu.draw(editor);
+        if (r != .ok) return r;
     }
 
-    return .ok;
-}
-
-fn sidebarRegion(editor: *fizzy.Editor, f: *Layout) !void {
-    var side = try f.region(@src(), .{
-        .name = "Sidebar",
-        .keywords = sidebar,
-        .content = .{ .ctx = editor, .draw = explorerPane },
-        .resize = true,
-        .collapsible = true,
-    }, .{
-        .min_size_content = .{ .w = 260 },
-        .expand = .vertical,
-        .background = false,
+    var work = try f.region(@src(), .{ .dir = .horizontal }, .{
+        .expand = .both,
+        .padding = .{ .w = edge_gutter },
     });
-    defer side.deinit();
-}
+    defer work.deinit();
+
+    {
+        var side = try f.region(@src(), .{
+            .name = "Sidebar",
+            .keywords = sidebar,
+            .content = .{ .ctx = editor, .draw = explorerPane },
+            .resize = true,
+            .collapsible = true,
+        }, .{
+            .min_size_content = .{ .w = 260 },
+            .expand = .vertical,
+            .background = false,
+        });
+        defer side.deinit();
+    }
 
-/// What the Sidebar and the rail ask of the frame once the Sidebar is drawn.
-fn applyRailAction(editor: *fizzy.Editor, f: *Layout, action: Sidebar.Action) void {
     // `?show=` asked for one file and the room for it (`Editor.show_only_document`).
     if (editor.show_only_document) {
         editor.show_only_document = false;
@@ -101,7 +68,7 @@ fn applyRailAction(editor: *fizzy.Editor, f: *Layout, action: Sidebar.Action) vo
         if (f.state.regionFor(bottom)) |panel| panel.close();
     }
 
-    switch (action) {
+    switch (rail_action) {
         .open => {
             editor.explorer.open(editor);
             // One pane at a time while there is only room for one. On a mobile-width window the
@@ -116,9 +83,9 @@ fn applyRailAction(editor: *fizzy.Editor, f: *Layout, action: Sidebar.Action) vo
         .close => editor.explorer.peekClose(editor),
         .none => {},
     }
-}
 
-fn contentRegion(f: *Layout, chrome: Chrome) !void {
+    f.split(@src(), .{});
+
     var content = try f.region(@src(), .{ .dir = .vertical }, .{ .expand = .both });
     defer content.deinit();
 
@@ -127,7 +94,6 @@ fn contentRegion(f: *Layout, chrome: Chrome) !void {
         defer main.deinit();
     }
 
-    if (!chrome.panel) return;
     f.split(@src(), .{});
 
     {
@@ -148,6 +114,8 @@ fn contentRegion(f: *Layout, chrome: Chrome) !void {
         });
         defer panel.deinit();
     }
+
+    return .ok;
 }
 
 /// Window fill, translucent while the OS window is, rounded like the old
@@ -159,7 +127,7 @@ const place_radius: f32 = 12;
 const place_padding: f32 = 8;
 
 /// The window fill shows as a frame around the place cards — the icon rail on
-/// one side, the infobar above, the status bar below. The other edge has no
+/// the left, the infobar above, the status bar below. The right edge has no
 /// chrome of its own, so the work area insets itself there and the frame
 /// closes; without it Main and Panel run into the window border.
 ///
diff --git a/src/editor/layout_mobile.zig b/src/editor/layout_mobile.zig
index cd0af8f8f..6276a492a 100644
--- a/src/editor/layout_mobile.zig
+++ b/src/editor/layout_mobile.zig
@@ -18,8 +18,8 @@
 //!
 //! **Sheets follow the window's shape.** In portrait a sheet rises from the foot, `sheet_share` of
 //! the height tall and at most `sheet_max_w` wide, centred. In landscape (wider than tall) the
-//! explorer follows `Chrome.sidebar_edge` and the panel takes the opposite side, each at most
-//! `sheet_max_w` wide and `side_share` of the width, with the scrim between them: a tablet or phone
+//! explorer is a side sheet on the left and the panel one on the right, each at most `sheet_max_w`
+//! wide and `side_share` of the width, with the scrim between them: a 1024x768 tablet or a phone
 //! on its side keeps Main's height instead of losing most of it to a slab.
 //!
 //! **A sheet is a resizable region at the foot of a transparent column laid over Main.** Opening
@@ -155,15 +155,9 @@ fn sheets(editor: *fizzy.Editor, f: *Layout) !bool {
 
     const showing = sheetOpen(f, sidebar) or sheetOpen(f, bottom);
     var tapped = false;
-    const explorer_left = editor.chrome.sidebar_edge == .left;
     if (side) {
-        if (explorer_left) {
-            var explorer = try explorerSheet(editor, f, true);
-            defer explorer.deinit();
-        } else if (editor.chrome.panel) {
-            var panel = try panelSheet(f, true);
-            defer panel.deinit();
-        }
+        var explorer = try explorerSheet(editor, f, true);
+        defer explorer.deinit();
     }
 
     {
@@ -178,13 +172,8 @@ fn sheets(editor: *fizzy.Editor, f: *Layout) !bool {
     }
 
     if (side) {
-        if (!explorer_left) {
-            var explorer = try explorerSheet(editor, f, true);
-            defer explorer.deinit();
-        } else if (editor.chrome.panel) {
-            var panel = try panelSheet(f, true);
-            defer panel.deinit();
-        }
+        var panel = try panelSheet(f, true);
+        defer panel.deinit();
     } else {
         // Capped and centred: the regions fill this box, not the window.
         var foot = dvui.box(@src(), .{ .dir = .vertical }, .{
@@ -194,7 +183,7 @@ fn sheets(editor: *fizzy.Editor, f: *Layout) !bool {
             .max_size_content = .width(sheet_max_w),
         });
         defer foot.deinit();
-        if (editor.chrome.panel) {
+        {
             var panel = try panelSheet(f, false);
             defer panel.deinit();
         }
@@ -309,7 +298,7 @@ fn bottomBar(editor: *fizzy.Editor, f: *Layout) !void {
     }
 
     // Only where something draws in the panel.
-    if (editor.chrome.panel and f.matching(bottom).len > 0) {
+    if (f.matching(bottom).len > 0) {
         if (iconButton(@src(), icons.tvg.lucide.terminal, "fizzy.mobile.panel")) {
             const open = sheetOpen(f, bottom);
             if (editor.regionFor(bottom)) |panel| {
diff --git a/src/fizzy.zig b/src/fizzy.zig
index 49da4e0b0..4714a054d 100644
--- a/src/fizzy.zig
+++ b/src/fizzy.zig
@@ -18,8 +18,6 @@ pub const Entry = @import("Entry.zig");
 pub const Editor = @import("editor/Editor.zig");
 /// The mobile shape (`Editor` picks it on mobile); public so the integration tests can drive it.
 pub const layout_mobile = @import("editor/layout_mobile.zig");
-/// fizzy's own desktop shape; public so the integration tests can drive it.
-pub const layout = @import("editor/layout.zig");
 pub const Explorer = @import("editor/explorer/Explorer.zig");
 //pub const Popups = @import("editor/popups/Popups.zig");
 pub const Sidebar = @import("editor/Sidebar.zig");
diff --git a/tests/demos.zig b/tests/demos.zig
index e518a82d5..492694863 100644
--- a/tests/demos.zig
+++ b/tests/demos.zig
@@ -29,7 +29,6 @@ const BundledApp = struct {
     const gpa = std.heap.smp_allocator;
 
     fn up(self: *BundledApp) !void {
-        Watchdog.enter("editor up");
         self.t = try dvui.testing.init(.{ .allocator = gpa, .window_size = .{ .w = 1280, .h = 800 } });
         self.tmp = std.testing.tmpDir(.{});
         const len = try self.tmp.dir.realPath(dvui.io, self.root_buf[0 .. self.root_buf.len - 1]);
@@ -50,7 +49,6 @@ const BundledApp = struct {
 
     /// Quits the way `appQuit` does: after the last frame, with no window current.
     fn down(self: *BundledApp) void {
-        Watchdog.enter("editor down");
         const harness_window = dvui.current_window;
         dvui.current_window = null;
         self.editor.deinit() catch {};
@@ -63,64 +61,6 @@ const BundledApp = struct {
     }
 };
 
-/// Ends the test binary, naming the phase, when the test stays in one phase for `limit_ms`: every
-/// frame loop here is bounded, so what stalls is a block outside them (a join, an await, a futex)
-/// that `zig build test-integration` would otherwise wait on until its runner is killed.
-const Watchdog = struct {
-    const limit_ms = 180_000;
-
-    /// Guards `phase_name` and `phase_count`: `enter` writes them on the test thread, `watch` reads
-    /// them on the watchdog thread.
-    var lock: std.Io.Mutex = .init;
-    var phase_name: []const u8 = "setup";
-    var phase_count: usize = 0;
-    /// Set by `stop` on the test thread to end `watch`; reset after the join so the next test can
-    /// `start` again.
-    var done: std.Io.Event = .unset;
-    /// The watchdog thread: spawned by `start`, joined by `stop`, both on the test thread.
-    var thread: ?std.Thread = null;
-
-    fn start() !void {
-        thread = try std.Thread.spawn(.{}, watch, .{});
-    }
-
-    fn stop() void {
-        done.set(std.testing.io);
-        if (thread) |t| t.join();
-        thread = null;
-        done.reset();
-    }
-
-    /// What the test is doing now; `name` outlives the call.
-    fn enter(name: []const u8) void {
-        lock.lockUncancelable(std.testing.io);
-        defer lock.unlock(std.testing.io);
-        phase_name = name;
-        phase_count += 1;
-    }
-
-    fn watch() void {
-        var seen: ?usize = null;
-        while (true) {
-            done.waitTimeout(std.testing.io, .{ .duration = .{ .raw = .fromMilliseconds(limit_ms), .clock = .awake } }) catch |err| switch (err) {
-                error.Timeout => {
-                    lock.lockUncancelable(std.testing.io);
-                    defer lock.unlock(std.testing.io);
-                    if (seen == phase_count) {
-                        std.debug.print("\nfizzy-demo-tests: phase '{s}' has not ended in {d} s: something outside the bounded frame loops is blocked; aborting\n", .{ phase_name, limit_ms / 1000 });
-                        std.process.abort();
-                    }
-                    seen = phase_count;
-                    continue;
-                },
-                // Nothing cancels this thread; a cancellation would mean the test is already ending.
-                error.Canceled => {},
-            };
-            return;
-        }
-    }
-};
-
 /// A moment straight play reached with nothing left due at it, the app idle: what a seek to `now`
 /// must land on.
 const DemoMoment = struct { now: f64, cursor: usize, print: u64 };
@@ -135,8 +75,6 @@ test "demo: the rail's Files anchor the scripts spell out is the one fizzy publi
 }
 
 test "demo: every bundled demo plays to the end through fizzy's stage, a seek lands on what playing reached, and the person's own folder is theirs again after" {
-    try Watchdog.start();
-    defer Watchdog.stop();
     var app: BundledApp = undefined;
     try app.up();
     defer app.down();
@@ -157,7 +95,6 @@ test "demo: every bundled demo plays to the end through fizzy's stage, a seek la
     const random = prng.random();
 
     for (fizzy.Editor.Demo.catalog.entries) |e| {
-        Watchdog.enter(e.name);
         try app.editor.demo.play(e.name);
 
         // A role in an anchor's name is the place of that kind in the layout as it is.
@@ -174,7 +111,6 @@ test "demo: every bundled demo plays to the end through fizzy's stage, a seek la
         var steady: Steady = .{};
         defer steady.deinit(gpa);
         var frames: usize = 0;
-        var checked_snapshot_memory = false;
         while (p.state != .ended and frames < 20_000) : (frames += 1) {
             _ = try dvui.testing.step(headlessFrame);
             try steady.frame(gpa, app.editor, e.name);
@@ -184,25 +120,11 @@ test "demo: every bundled demo plays to the end through fizzy's stage, a seek la
             // first and replays from the keyframe (`Player.letGo`), which replays a drag cut short
             // no better than it did — a moment the player takes no snapshot at either.
             if (p.input.held.count() > 0) continue;
-            if (!checked_snapshot_memory) {
-                // The app uses smp_allocator for its lifetime; snapshots must also release every
-                // arrangement buffer when captured with an allocator that checks for leaks.
-                // The swap is sound only while capture and release keep nothing in editor state
-                // past the block; a cache there would outlive this allocator.
-                const app_gpa = app.editor.app.gpa;
-                app.editor.app.gpa = gpa;
-                defer app.editor.app.gpa = app_gpa;
-                if (stage.capture()) |snap| {
-                    stage.release(snap);
-                    checked_snapshot_memory = true;
-                }
-            }
             try moments.append(gpa, .{ .now = p.seq.now, .cursor = p.seq.cursor, .print = p.stage.fingerprint().? });
         }
         errdefer std.debug.print("demo '{s}': {t} after {d} frames at {d:.0} of {d} ms\n", .{ e.name, p.state, frames, p.seq.now, p.duration() });
         try std.testing.expectEqual(automation.Player.State.ended, p.state);
         try std.testing.expect(p.seq.done());
-        try std.testing.expect(checked_snapshot_memory);
         try std.testing.expectEqual(@as(u32, 0), p.timeouts);
         try std.testing.expectEqual(@as(u32, 0), p.mismatches);
         try std.testing.expect(moments.items.len > bundled_random_seeks);
@@ -225,13 +147,6 @@ test "demo: every bundled demo plays to the end through fizzy's stage, a seek la
                 break;
             };
         }
-        if (std.mem.eql(u8, e.name, "tour")) {
-            var explorer_prng: std.Random.DefaultPrng = .init(0x6);
-            const explorer_random = explorer_prng.random();
-            var explorer_picks: [bundled_random_seeks]usize = undefined;
-            for (&explorer_picks) |*pick| pick.* = explorer_random.uintLessThan(usize, moments.items.len);
-            try picks.insertSlice(gpa, 0, &explorer_picks);
-        }
         var wrong: usize = 0;
         for (picks.items) |i| {
             const want = moments.items[i];
@@ -263,7 +178,6 @@ test "demo: every bundled demo plays to the end through fizzy's stage, a seek la
         try std.testing.expectEqual(@as(u32, 0), p.timeouts);
     }
 
-    Watchdog.enter("demos service");
     // The `demos` service lists them, fizzy's own in its order, with each one's length and chapters.
     const api = app.editor.demos.api;
     const catalog = fizzy.Editor.Demo.catalog;
@@ -309,7 +223,6 @@ test "demo: every bundled demo plays to the end through fizzy's stage, a seek la
     while (p.state == .seeking and frames < 400) : (frames += 1) _ = try dvui.testing.step(headlessFrame);
     try std.testing.expect(p.seq.now >= @as(f64, @floatFromInt(second)));
 
-    Watchdog.enter("window material");
     // The window's material a tape sets is the demo's: a cut and the end give the person theirs.
     const settings = &app.editor.app.settings;
     p.unload();
@@ -343,7 +256,6 @@ test "demo: every bundled demo plays to the end through fizzy's stage, a seek la
     try std.testing.expectEqual(fizzy.core.material.Kind.blur, settings.window_material);
     settings.window_material = .liquid;
 
-    Watchdog.enter("person's panes");
     // A demo plays among the person's panes: their split and their documents stay where they are
     // through a play, a seek and the end, and the demo's tabs open beside them.
     {
@@ -392,7 +304,6 @@ test "demo: every bundled demo plays to the end through fizzy's stage, a seek la
         try dvui.testing.settle(headlessFrame);
     }
 
-    Watchdog.enter("unsaved work");
     // A demo plays on a stage of its own: unsaved work of the person's never stops one, and is
     // there after it exactly as it was — still open, still unsaved, its history and its pane
     // theirs — through a play, a seek back and an end, with settings.zon never written.
@@ -465,7 +376,6 @@ test "demo: every bundled demo plays to the end through fizzy's stage, a seek la
         try dvui.testing.settle(headlessFrame);
     }
 
-    Watchdog.enter("tour on the person's window");
     // The tour on the person's window: a file they open while it plays is theirs, and the panes
     // the tour splits off are not written to `panes.zon` as theirs and are back as they were when
     // it ends.
@@ -622,7 +532,6 @@ test "demo: every bundled demo plays to the end through fizzy's stage, a seek la
 /// A tour played to its end and reverted closes what it opened, and the window is the person's
 /// again: here with the explorer shut, a window the recording was not made on.
 fn revertClosesWhatTheTourOpened(app: *BundledApp) !void {
-    Watchdog.enter("revertClosesWhatTheTourOpened");
     const editor = app.editor;
     const p = &editor.demo.player;
 
@@ -651,7 +560,6 @@ fn revertClosesWhatTheTourOpened(app: *BundledApp) !void {
 /// A float the person had, then moved while the tour played, is back where it was after the
 /// revert, not flying shut: only what the snapshot lacks glides away.
 fn revertKeepsAMovedFloat(app: *BundledApp) !void {
-    Watchdog.enter("revertKeepsAMovedFloat");
     const editor = app.editor;
     const p = &editor.demo.player;
     const gpa = editor.app.gpa;
@@ -689,7 +597,6 @@ fn revertKeepsAMovedFloat(app: *BundledApp) !void {
 /// arrangement and the documents as they were, reverted too, and a tour stopped or closed from its
 /// bar midway leaves it exactly as it stood at that moment.
 fn tourOnARearrangedLayout(app: *BundledApp) !void {
-    Watchdog.enter("tourOnARearrangedLayout");
     const editor = app.editor;
     const p = &editor.demo.player;
     const name = fizzy.Editor.Demo.catalog.entries[0].name;
@@ -946,7 +853,6 @@ fn encodedDemo(name: []const u8, demo: bool) ![]u8 {
 /// The tour on a phone: the files view is the explorer sheet over the documents, which the role
 /// `explorer` names, and the tour opens it. (Run from the test above: the editor comes up once.)
 fn tourOnAPhone(app: *BundledApp) !void {
-    Watchdog.enter("tourOnAPhone");
     const p = &app.editor.demo.player;
     fizzy.core.platform.cached_form_factor = .mobile;
     defer fizzy.core.platform.cached_form_factor = .desktop;
diff --git a/tests/integration.zig b/tests/integration.zig
index 489969041..a2340a78a 100644
--- a/tests/integration.zig
+++ b/tests/integration.zig
@@ -18,7 +18,6 @@ const fizzy = @import("fizzy");
 const Tracks = @import("app").Tracks;
 const shim = @import("fizzy_shim.zig");
 const TextEntryWidget = @import("text").TextEntryWidget;
-const chat = @import("chat");
 const sdk = @import("fizzy_sdk");
 
 test "shim brings up a dvui.testing window with usable fizzy globals" {
@@ -95,109 +94,6 @@ test "a shell command shadowed by a user binding gives up its native chord" {
     try std.testing.expect(fizzy.Editor.Keybinds.chordShadowed(editor, "fizzy.openFolder"));
 }
 
-// -- chat composer -----------------------------------------------------------------------------
-//
-// The composer is a dvui text entry that grows with its text to a cap; Enter sends on a desktop and
-// breaks the line on a phone or with Shift. What it decides is unit-tested in
-// `plugins/chat/src/composer.zig`; these run it in real frames with real key and text events.
-
-var chat_view: chat.View = .{};
-var chat_provider: chat.DemoProvider = .{ .allocator = std.testing.allocator };
-var chat_api: sdk.services.chat.Api = undefined;
-
-fn chatFrame() !dvui.App.Result {
-    chat_view.draw(std.testing.allocator, &chat_api);
-    return .ok;
-}
-
-fn chatCtx() !dvui.testing {
-    chat_view = .{};
-    chat_provider = .{ .allocator = std.testing.allocator };
-    chat_api = chat_provider.api();
-    var t = try dvui.testing.init(.{ .allocator = std.testing.allocator });
-    errdefer t.deinit();
-    try dvui.testing.settle(chatFrame);
-    dvui.focusWidget(chat_view.entry_id, null, null);
-    try dvui.testing.settle(chatFrame);
-    return t;
-}
-
-fn deinitChat(t: *dvui.testing) void {
-    t.deinit();
-    chat_view.deinit(std.testing.allocator);
-    chat_provider.deinit();
-}
-
-test "the composer grows with its lines to the cap, then scrolls" {
-    var t = try chatCtx();
-    defer deinitChat(&t);
-
-    const one = chat_view.entry_rect.h;
-    var heights: [12]f32 = undefined;
-    for (&heights) |*h| {
-        try dvui.testing.writeText("line\n");
-        try dvui.testing.settle(chatFrame);
-        h.* = chat_view.entry_rect.h;
-    }
-    // Each new line makes it taller until the cap; 8 lines (7 typed newlines on top of the
-    // first) is the last that does.
-    try std.testing.expect(heights[2] > one);
-    try std.testing.expect(heights[5] > heights[2]);
-    const cap = heights[11];
-    try std.testing.expect(cap > heights[5]);
-    try std.testing.expectApproxEqAbs(cap, heights[8], 0.5);
-    try std.testing.expectApproxEqAbs(cap, heights[10], 0.5);
-    try std.testing.expect(chat_view.entry_scroll.virtual_size.h > chat_view.entry_scroll.viewport.h);
-}
-
-test "Enter sends on a desktop and Shift+Enter breaks the line" {
-    var t = try chatCtx();
-    defer deinitChat(&t);
-
-    try dvui.testing.writeText("hi");
-    try dvui.testing.settle(chatFrame);
-    try dvui.testing.pressKey(.enter, .lshift);
-    try dvui.testing.settle(chatFrame);
-    try std.testing.expectEqual(@as(usize, 0), chat_api.messages().len);
-    try std.testing.expectEqualStrings("hi\n", chat_view.text.items);
-
-    try dvui.testing.pressKey(.enter, .none);
-    try dvui.testing.settle(chatFrame);
-    try std.testing.expectEqual(@as(usize, 2), chat_api.messages().len);
-    try std.testing.expectEqualStrings("hi", chat_api.messages()[0].text);
-    try std.testing.expectEqual(@as(usize, 0), chat_view.text.items.len);
-}
-
-test "Enter is a new line on a phone" {
-    fizzy.core.platform.cached_form_factor = .mobile;
-    defer fizzy.core.platform.cached_form_factor = .desktop;
-    var t = try chatCtx();
-    defer deinitChat(&t);
-
-    try dvui.testing.writeText("hi");
-    try dvui.testing.settle(chatFrame);
-    try dvui.testing.pressKey(.enter, .none);
-    try dvui.testing.settle(chatFrame);
-    try std.testing.expectEqual(@as(usize, 0), chat_api.messages().len);
-    try std.testing.expectEqualStrings("hi\n", chat_view.text.items);
-}
-
-test "three messages go through the demo provider and each is answered" {
-    var t = try chatCtx();
-    defer deinitChat(&t);
-
-    for ([_][]const u8{ "one", "two", "three" }) |word| {
-        try dvui.testing.writeText(word);
-        try dvui.testing.settle(chatFrame);
-        try dvui.testing.pressKey(.enter, .none);
-        try dvui.testing.settle(chatFrame);
-    }
-    const log = chat_api.messages();
-    try std.testing.expectEqual(@as(usize, 6), log.len);
-    try std.testing.expectEqualStrings("three", log[4].text);
-    try std.testing.expectEqualStrings("You said: three", log[5].text);
-}
-
 // -- text editing: auto-closing pairs + auto-indent Enter ---------------------------------------
 //
 // These drive the real `TextEntryWidget` through real frames and real key/text events, because
@@ -3085,129 +2981,6 @@ test "a takeover surface appears only while its trigger is selected, and then an
     try std.testing.expectEqualStrings("test.workspace", layout.selected(main).?.id);
 }
 
-// -- the chrome option ---------------------------------------------------------------------------
-// `layout.zig` (fizzy's desktop shape) under each `Chrome`: which end the rail and Sidebar sit at,
-// and whether the Panel exists.
-
-const ChromeFrame = struct {
-    var editor: ?*fizzy.Editor = null;
-    var explorer: fizzy.Explorer = .{};
-    var chrome: fizzy.Editor.Chrome = .{};
-
-    fn menuDraw(_: ?*anyopaque) !void {
-        dvui.labelNoFmt(@src(), "Test menu", .{}, .{});
-    }
-
-    fn frame() !dvui.App.Result {
-        const e = editor.?;
-        fizzy.core.anchor.want();
-        e.chrome = chrome;
-        var layout = fizzy.Editor.Layout.init(&e.app.host, &e.app.layout, e.app.gpa, dvui.currentWindow().arena());
-        const result = try fizzy.layout.layout(e, &layout);
-        e.app.layout.publishRegions();
-        return result;
-    }
-};
-
-fn chromeBounds(editor: *fizzy.Editor, name: []const u8) ?dvui.Rect.Physical {
-    for (editor.app.layout.regions.items) |r| if (std.mem.eql(u8, r.name, name)) return r.bounds;
-    return null;
-}
-
-/// Draw fizzy's shape under `chrome`, with a view in each of its places, and hand `check` the editor.
-// anytype: the checks have inferred error sets.
-fn withChrome(chrome: fizzy.Editor.Chrome, comptime check: anytype) !void {
-    var ctx = try shim.init(std.testing.allocator);
-    defer ctx.deinit(std.testing.allocator);
-    const editor = ctx.editor;
-    editor.app.gpa = std.testing.allocator;
-    defer editor.app.layout.regions.deinit(editor.app.gpa);
-    defer editor.app.layout.regions_building.deinit(editor.app.gpa);
-    defer editor.app.layout.deinitExtents(editor.app.gpa);
-    defer editor.app.layout.deinitQualified(editor.app.gpa);
-    defer editor.app.layout.deinitAssignments(editor.app.gpa);
-
-    editor.infobar = .{};
-    editor.app.host.fizzy_api = .{ .ctx = editor, .vtable = &fizzy.Editor.fizzy_api_vtable };
-    try editor.app.host.registerMenu(.{ .id = "test.menu", .draw = ChromeFrame.menuDraw });
-    ChromeFrame.explorer = .{};
-    editor.explorer = &ChromeFrame.explorer;
-    ChromeFrame.editor = editor;
-    defer ChromeFrame.editor = null;
-    ChromeFrame.chrome = chrome;
-
-    const kw = fizzy.sdk.keywords.ide;
-    try editor.app.host.registerSurface(.{ .id = "test.files", .title = "Files", .keywords = kw.sidebar, .draw = TabsFrame.draw });
-    try editor.app.host.registerSurface(.{ .id = "test.workspace", .title = "Workspace", .keywords = kw.main, .draw = TabsFrame.draw });
-    try editor.app.host.registerSurface(.{ .id = "test.output", .title = "Output", .keywords = kw.panel, .draw = TabsFrame.draw });
-    try dvui.testing.settle(ChromeFrame.frame);
-    try check(editor);
-}
-
-fn expectSidebarLeft(editor: *fizzy.Editor) !void {
-    const side = chromeBounds(editor, "Sidebar") orelse return error.TestUnexpectedResult;
-    const main = chromeBounds(editor, "Main") orelse return error.TestUnexpectedResult;
-    try std.testing.expect(side.x < main.x);
-    // The rail sits left of it.
-    try std.testing.expect(side.x > 0);
-    try std.testing.expect(chromeBounds(editor, "Panel") != null);
-}
-
-fn expectSidebarRight(editor: *fizzy.Editor) !void {
-    const side = chromeBounds(editor, "Sidebar") orelse return error.TestUnexpectedResult;
-    const main = chromeBounds(editor, "Main") orelse return error.TestUnexpectedResult;
-    try std.testing.expect(side.x > main.x + main.w - 1);
-    // The rail takes the window's last stretch, so the Sidebar stops short of the edge.
-    try std.testing.expect(side.x + side.w < dvui.windowRectPixels().w - 20);
-    // And the left edge is Main's, with only the work area's gutter before it.
-    try std.testing.expect(main.x < 40);
-    try std.testing.expect(chromeBounds(editor, "Panel") != null);
-}
-
-fn expectNoPanel(editor: *fizzy.Editor) !void {
-    try std.testing.expect(chromeBounds(editor, "Main") != null);
-    try std.testing.expect(chromeBounds(editor, "Sidebar") != null);
-    try std.testing.expect(chromeBounds(editor, "Panel") == null);
-    try std.testing.expect(editor.regionFor(fizzy.sdk.keywords.ide.panel) == null);
-}
-
-test "chrome: the defaults are fizzy's own frame, Sidebar left of Main with a Panel" {
-    try std.testing.expectEqual(fizzy.Editor.Chrome{}, fizzy.Editor.Chrome.configured);
-    try withChrome(.{}, expectSidebarLeft);
-}
-
-test "chrome: sidebar_edge right puts the rail and Sidebar right of Main" {
-    try withChrome(.{ .sidebar_edge = .right }, expectSidebarRight);
-}
-
-test "chrome: panel false leaves no Panel place" {
-    try withChrome(.{ .panel = false }, expectNoPanel);
-}
-
-fn expectBarsVisible(editor: *fizzy.Editor) !void {
-    const side = chromeBounds(editor, "Sidebar") orelse return error.TestUnexpectedResult;
-    try std.testing.expect(side.h < dvui.windowRectPixels().h - 1);
-}
-
-fn expectBarsHidden(editor: *fizzy.Editor) !void {
-    const side = chromeBounds(editor, "Sidebar") orelse return error.TestUnexpectedResult;
-    try std.testing.expectApproxEqAbs(dvui.windowRectPixels().h, side.h, 0.5);
-}
-
-test "chrome: infobar occupies space only when enabled" {
-    try withChrome(.{ .menu_bar = false }, expectBarsVisible);
-    try withChrome(.{ .menu_bar = false, .infobar = false }, expectBarsHidden);
-}
-
-test "chrome: in-window menu occupies space only when enabled" {
-    const Menu = @import("fizzy").Editor.Menu;
-    const before = Menu.debug_force_on_macos;
-    Menu.debug_force_on_macos = true;
-    defer Menu.debug_force_on_macos = before;
-    try withChrome(.{ .infobar = false }, expectBarsVisible);
-    try withChrome(.{ .menu_bar = false, .infobar = false }, expectBarsHidden);
-}
-
 // -- the mobile shape ----------------------------------------------------------------------------
 // `layout_mobile.zig` under a forced `.mobile` form factor: which places it declares, what it
 // draws, and that mobile's arrangement is kept apart from a desktop's in `layout.zon`.
@@ -3247,7 +3020,6 @@ fn mobileCase(ctx: *shim.Ctx) !void {
     MobileFrame.explorer = .{};
     editor.explorer = &MobileFrame.explorer;
     fizzy.core.platform.cached_form_factor = .mobile;
-    editor.chrome = .{};
     MobileFrame.editor = editor;
     const kw = fizzy.sdk.keywords.ide;
     try editor.app.host.registerSurface(.{ .id = "test.files", .title = "Files", .keywords = kw.sidebar, .draw = TabsFrame.draw });
@@ -3269,7 +3041,6 @@ test "mobile's shape is Main, two shut sheets, a bar of the rail's views and a c
 
     fizzy.core.platform.cached_form_factor = .mobile;
     defer fizzy.core.platform.cached_form_factor = .desktop;
-    editor.chrome = .{};
     MobileFrame.editor = editor;
     defer MobileFrame.editor = null;
 
@@ -4130,33 +3901,6 @@ test "an adaptive split saved beside comes back as the same share stacked" {
     try std.testing.expect(state.splits.setShare("Main/r1", 0.5));
     _ = state.setExtent(editor.app.gpa, "Main/r1", 590);
 
-    // Exercise the same collection, ZON format and reconstruction as a saved layout.
-    const gpa = std.testing.allocator;
-    const regions = editor.collectSavedRegions(gpa);
-    defer gpa.free(regions);
-    var out: std.Io.Writer.Allocating = .init(gpa);
-    defer out.deinit();
-    try std.zon.stringify.serializeMaxDepth(regions, .{}, &out.writer, 64);
-    const text = try gpa.dupeSentinel(u8, out.written(), 0);
-    defer gpa.free(text);
-    var saved_arena: std.heap.ArenaAllocator = .init(gpa);
-    defer saved_arena.deinit();
-    var saved_diag: std.zon.parse.Diagnostics = undefined;
-    const saved = try std.zon.parse.fromSlice([]fizzy.backend.SavedRegion, .{
-        .gpa = gpa,
-        .arena = saved_arena.allocator(),
-        .source = text,
-        .diagnostics = &saved_diag,
-        .ignore_unknown_fields = true,
-    });
-    state.resetLayout(gpa);
-    editor.applySavedRegions(saved);
-    const links = state.splits.collectLinks(gpa);
-    defer gpa.free(links);
-    try std.testing.expectEqual(@as(usize, 1), links.len);
-    try std.testing.expectEqual(@as(?f32, 0.5), links[0].share);
-    try std.testing.expect(links[0].adaptive);
-
     for (0..60) |_| _ = try dvui.testing.step(ColumnCardFrame.frame);
     const top = try ColumnCardFrame.sizeOf(editor, "Main");
     const bottom = try ColumnCardFrame.sizeOf(editor, "Main/r1");
@@ -4164,103 +3908,6 @@ test "an adaptive split saved beside comes back as the same share stacked" {
     try std.testing.expectApproxEqAbs(0.5, bottom.h / (top.h + bottom.h), 0.03);
 }
 
-// A sash dragged while an adaptive split is turned is shown and nothing more: the share the saved
-// extent gave comes back with the turn back, and the next turn uses it, not the drag's.
-test "a drag while an adaptive split is turned is not kept when it turns back" {
-    var ctx = try shim.init(std.testing.allocator);
-    defer ctx.deinit(std.testing.allocator);
-
-    const editor = ctx.editor;
-    editor.app.gpa = std.testing.allocator;
-    defer editor.app.layout.regions.deinit(editor.app.gpa);
-    defer editor.app.layout.regions_building.deinit(editor.app.gpa);
-    defer editor.app.layout.deinitExtents(editor.app.gpa);
-    defer editor.app.layout.deinitAssignments(editor.app.gpa);
-    defer editor.app.layout.deinitQualified(editor.app.gpa);
-
-    ColumnCardFrame.editor = editor;
-    defer ColumnCardFrame.editor = null;
-
-    ctx.t.backend.size = .{ .w = 1180, .h = 820 };
-    ctx.t.backend.size_pixels = .{ .w = 1180, .h = 820 };
-    _ = try dvui.testing.step(ColumnCardFrame.frame);
-    try dvui.testing.settle(ColumnCardFrame.frame);
-    {
-        var layout = fizzy.Editor.Layout.init(&editor.app.host, &editor.app.layout, editor.app.gpa, dvui.currentWindow().arena());
-        try std.testing.expectEqualStrings("Main/r1", layout.splitOn("Main", .right) orelse return error.TestExpectedEqual);
-        layout.markAdaptive("Main/r1");
-    }
-    try dvui.testing.settle(ColumnCardFrame.frame);
-    const old = try ColumnCardFrame.sizeOf(editor, "Main");
-    const new = try ColumnCardFrame.sizeOf(editor, "Main/r1");
-    const share = new.w / (old.w + new.w);
-    const saved_extent = editor.app.layout.extent("Main/r1", 0);
-    editor.app.layout.dirty = false;
-
-    ctx.t.backend.size = .{ .w = 820, .h = 1180 };
-    ctx.t.backend.size_pixels = .{ .w = 820, .h = 1180 };
-    for (0..40) |_| _ = try dvui.testing.step(ColumnCardFrame.frame);
-
-    // The sash dragged to a third of the room, as `Split` writes a drag.
-    const room = (try ColumnCardFrame.sizeOf(editor, "Main")).h + (try ColumnCardFrame.sizeOf(editor, "Main/r1")).h;
-    const leaf = for (editor.app.layout.regions.items) |r| {
-        if (std.mem.eql(u8, r.name, "Main/r1")) break r.id;
-    } else return error.TestExpectedEqual;
-    dvui.dataSet(null, leaf, "_size", room / 3);
-    dvui.dataSet(null, leaf, "_shown", room / 3);
-    for (0..4) |_| _ = try dvui.testing.step(ColumnCardFrame.frame);
-    const dragged = try ColumnCardFrame.sizeOf(editor, "Main/r1");
-    try std.testing.expectApproxEqAbs(room / 3, dragged.h, room * 0.05);
-    try std.testing.expect(!editor.app.layout.dirty);
-    try std.testing.expectEqual(saved_extent, editor.app.layout.extent("Main/r1", 0));
-
-    // Back across: the saved share, not the drag's.
-    ctx.t.backend.size = .{ .w = 1180, .h = 820 };
-    ctx.t.backend.size_pixels = .{ .w = 1180, .h = 820 };
-    for (0..40) |_| _ = try dvui.testing.step(ColumnCardFrame.frame);
-    const left = try ColumnCardFrame.sizeOf(editor, "Main");
-    const right = try ColumnCardFrame.sizeOf(editor, "Main/r1");
-    try std.testing.expectApproxEqAbs(share, right.w / (left.w + right.w), 0.03);
-
-    // And upright again: the share is still the saved one.
-    ctx.t.backend.size = .{ .w = 820, .h = 1180 };
-    ctx.t.backend.size_pixels = .{ .w = 820, .h = 1180 };
-    for (0..40) |_| _ = try dvui.testing.step(ColumnCardFrame.frame);
-    const top = try ColumnCardFrame.sizeOf(editor, "Main");
-    const bottom = try ColumnCardFrame.sizeOf(editor, "Main/r1");
-    try std.testing.expectApproxEqAbs(share, bottom.h / (top.h + bottom.h), 0.03);
-    try std.testing.expect(!editor.app.layout.dirty);
-}
-
-test "an adaptive split saved without a share loads with the ratio absent" {
-    var ctx = try shim.init(std.testing.allocator);
-    defer ctx.deinit(std.testing.allocator);
-    const gpa = std.testing.allocator;
-    const editor = ctx.editor;
-    editor.app.gpa = gpa;
-    defer editor.app.layout.deinitExtents(gpa);
-    defer editor.app.layout.deinitQualified(gpa);
-
-    var arena: std.heap.ArenaAllocator = .init(gpa);
-    defer arena.deinit();
-    var diagnostics: std.zon.parse.Diagnostics = undefined;
-    const saved = try std.zon.parse.fromSlice([]fizzy.backend.SavedRegion, .{
-        .gpa = gpa,
-        .arena = arena.allocator(),
-        .source = ".{.{ .name = \"Main/r1\", .parent = \"Main\", .from = \"right\", .extent = 590, .adaptive = true }}",
-        .diagnostics = &diagnostics,
-        .ignore_unknown_fields = true,
-    });
-    try std.testing.expectEqual(@as(?f32, null), saved[0].share);
-    editor.applySavedRegions(saved);
-    const links = editor.app.layout.splits.collectLinks(gpa);
-    defer gpa.free(links);
-    try std.testing.expectEqual(@as(usize, 1), links.len);
-    try std.testing.expect(links[0].adaptive);
-    try std.testing.expectEqual(@as(?f32, null), links[0].share);
-    try std.testing.expectEqual(@as(f32, 590), editor.app.layout.extent("Main/r1", 0));
-}
-
 /// Main | (Main/r1 over Main/r1/b1) in fizzy's split forest, each holding one view. Main/r1 is two
 /// things at once: the half Main's split minted, and the half its own split kept.
 const NestedSplitCase = struct {
@@ -5900,71 +5547,6 @@ test "dragging a view over its own place shows that place's drop zones" {
     try std.testing.expect(fizzy.core.widgets.DropZones.showing(center.id));
 }
 
-test "drop: beside marks the tall target's bottom rather than the wide source's right" {
-    var ctx = try shim.init(std.testing.allocator);
-    defer ctx.deinit(std.testing.allocator);
-    const editor = ctx.editor;
-    const gpa = std.testing.allocator;
-    editor.app.gpa = gpa;
-    const state = &editor.app.layout;
-    defer state.regions.deinit(gpa);
-    defer state.regions_building.deinit(gpa);
-    defer state.deinitExtents(gpa);
-    defer state.deinitAssignments(gpa);
-    defer state.deinitQualified(gpa);
-    defer state.view_drag.discard(gpa);
-    const source: dvui.Rect.Physical = .{ .x = 0, .y = 0, .w = 1200, .h = 800 };
-    const target: dvui.Rect.Physical = .{ .x = 1200, .y = 0, .w = 820, .h = 1180 };
-    state.registerRegion(gpa, .{ .name = "Source", .keywords = fizzy.sdk.keywords.ide.main, .bounds = source, .size = .{ .w = source.w, .h = source.h } });
-    state.registerRegion(gpa, .{ .name = "Target", .keywords = &.{"slot"}, .bounds = target, .size = .{ .w = target.w, .h = target.h } });
-    state.publishRegions();
-    const Probe = struct {
-        calls: usize = 0,
-        fn edge(raw: *anyopaque, name: []const u8) ?fizzy.Editor.Layout.State.SplitTree.Side {
-            const self: *@This() = @ptrCast(@alignCast(raw));
-            self.calls += 1;
-            const room = if (std.mem.eql(u8, name, "Target")) target else source;
-            return workbench.Workbench.sideFor(room.w, room.h);
-        }
-    };
-    var probe: Probe = .{};
-    state.beside = .{ .ctx = &probe, .edge = Probe.edge };
-    defer state.beside = null;
-    try editor.app.host.registerSurface(.{ .id = "test.view", .title = "View", .keywords = &.{"slot"}, .draw = ManyPanelFrame.draw });
-    try state.assign(gpa, "Source", &.{"test.view"});
-    var layout = fizzy.Editor.Layout.init(&editor.app.host, state, gpa, dvui.currentWindow().arena());
-    const VD = fizzy.Editor.Layout.ViewDrag;
-    const cw = dvui.currentWindow();
-    const mouse = cw.mouse_pt;
-    defer cw.mouse_pt = mouse;
-    cw.mouse_pt = source.center();
-    VD.begin(&layout, "Source", source, source);
-    cw.mouse_pt = target.center();
-    fizzy.core.anchor.want();
-    VD.drawZones(&layout, "Target", dvui.parentGet().extendId(@src(), 0));
-    const beside = dvui.tagGet("drop:beside") orelse return error.TestUnexpectedResult;
-    const bottom = dvui.tagGet("drop:bottom") orelse return error.TestUnexpectedResult;
-    const right = dvui.tagGet("drop:right") orelse return error.TestUnexpectedResult;
-    try std.testing.expectEqual(bottom.rect, beside.rect);
-    try std.testing.expect(!std.meta.eql(right.rect, beside.rect));
-    try std.testing.expectEqual(@as(usize, 1), probe.calls);
-
-    // Main's implicit pane must not borrow the shape of a workspace held elsewhere.
-    const wb = &editor.workbench;
-    const grouping = wb.open_workspace_grouping;
-    var workspace = workbench.Workspace.init(grouping);
-    workspace.pane_rect_physical = source;
-    try wb.workspaces.put(gpa, grouping, workspace);
-    defer wb.workspaces.deinit(gpa);
-    var id_buf: [64]u8 = undefined;
-    const id = try std.mem.print(&id_buf, fizzy.Editor.Workspaces.id_prefix ++ "{d}", .{grouping});
-    try editor.app.host.registerSurface(.{ .id = id, .title = "Workspace", .keywords = &.{"slot"}, .draw = ManyPanelFrame.draw });
-    try state.assign(gpa, "Target", &.{id});
-    editor.demo.editor = editor;
-    editor.app.host.installFizzyApi(.{ .ctx = editor, .vtable = &fizzy.Editor.fizzy_api_vtable });
-    try std.testing.expectEqual(@as(?fizzy.Editor.Layout.State.SplitTree.Side, null), fizzy.Editor.Demo.besideEdge(&editor.demo, "Source"));
-}
-
 // `core` is not a test root, so its widgets' pure rules are tested here.
 const DZ = fizzy.core.widgets.DropZones;
 
@@ -7922,38 +7504,6 @@ test "float: a float in an OS window with its own buttons still has a close a ta
     try std.testing.expectEqual(@as(usize, 0), editor.app.layout.floats.items.items.len);
 }
 
-test "float: a press on the header of a float in an OS window, off its buttons, does not close it" {
-    var case = try ManyPanelCase.init();
-    defer case.deinit();
-    const editor = case.ctx.editor;
-    try case.place("Panel", "Panel", .swap);
-    const floats = editor.app.layout.floats.items.items;
-    try std.testing.expectEqual(@as(usize, 1), floats.len);
-    floats[0].viewport = .{ .rect = floats[0].rect, .os_buttons = true, .buttons_w = 60 };
-
-    const WantFrame = struct {
-        fn frame() !dvui.App.Result {
-            fizzy.core.anchor.want();
-            return ManyPanelFrame.frame();
-        }
-    };
-    try dvui.testing.settle(WantFrame.frame);
-    try dvui.testing.settle(WantFrame.frame);
-
-    const close = dvui.tagGet("float-close:Float 1") orelse return error.TestUnexpectedResult;
-    const header = dvui.tagGet("float-header:Float 1") orelse return error.TestUnexpectedResult;
-    // The header's far end, well clear of the leading traffic light.
-    const pt: dvui.Point.Physical = .{ .x = header.rect.x + header.rect.w - 8, .y = close.rect.y + close.rect.h / 2 };
-    try std.testing.expect(pt.x > close.rect.x + close.rect.w);
-    const cw = dvui.currentWindow();
-    _ = try cw.addEventMouseMotion(.{ .pt = pt });
-    _ = try cw.addEventMouseButton(.left, .press);
-    _ = try cw.addEventMouseButton(.left, .release);
-    try dvui.testing.settle(WantFrame.frame);
-    try dvui.testing.settle(WantFrame.frame);
-    try std.testing.expectEqual(@as(usize, 1), editor.app.layout.floats.items.items.len);
-}
-
 test "float: closing it loses no view its keywords would show nowhere" {
     var case = try ManyPanelCase.init();
     defer case.deinit();
@@ -9125,48 +8675,6 @@ const CarriedTree = struct {
     }
 };
 
-test "tree: an external reopen during closing owns the branch state" {
-    const Scene = struct {
-        // Written by this test and its frame callback on the test thread.
-        var open = true;
-        var expanded = false;
-        var children = false;
-        var requested: ?bool = null;
-        var progress: f32 = 0;
-
-        fn frame() !dvui.App.Result {
-            const tree = fizzy.core.widgets.TreeWidget.tree(@src(), .{}, .{ .expand = .both });
-            defer tree.deinit();
-            const branch = tree.branch(@src(), .{ .expanded = open }, .{ .expand = .horizontal });
-            defer branch.deinit();
-            expanded = branch.expanded;
-            dvui.labelNoFmt(@src(), "folder", .{}, .{});
-            children = branch.expander(@src(), .{}, .{ .expand = .horizontal });
-            requested = branch.requested;
-            progress = branch.anim.?.val.?;
-            if (children) dvui.labelNoFmt(@src(), "child", .{}, .{});
-            return .ok;
-        }
-    };
-    var t = try dvui.testing.init(.{ .allocator = std.testing.allocator });
-    defer t.deinit();
-    Scene.open = true;
-    _ = try dvui.testing.step(Scene.frame);
-    try std.testing.expectEqual(@as(f32, 1), Scene.progress);
-    try dvui.testing.settle(Scene.frame);
-    Scene.open = false;
-    _ = try dvui.testing.step(Scene.frame);
-    try std.testing.expect(!Scene.expanded);
-    try std.testing.expect(Scene.children);
-    try std.testing.expectEqual(@as(?bool, null), Scene.requested);
-    Scene.open = true;
-    _ = try dvui.testing.step(Scene.frame);
-    try std.testing.expect(Scene.expanded);
-    try dvui.testing.settle(Scene.frame);
-    try std.testing.expect(Scene.expanded and Scene.children);
-    try std.testing.expectEqual(@as(?bool, null), Scene.requested);
-}
-
 test "tree: a row carried back over it goes into the folder under the pointer when let go" {
     var t = try dvui.testing.init(.{ .allocator = std.testing.allocator });
     defer t.deinit();
@@ -9276,7 +8784,7 @@ test "tree: a drag put down is not dropped where the pointer last was" {
 }
 
 // A key fold sticks. The caller below keeps its own open state and passes it back each frame, as
-// the settings, file and guides trees do, applying `branch.requested` after `expander()`: Left must
+// the settings, file and guides trees do, reading `branch.expanded` after `expander()`: Left must
 // fold the branch (animated, as a click does) and leave it folded, and Right open it again.
 const KeyFoldTree = struct {
     const TW = fizzy.core.widgets.TreeWidget;
@@ -11522,36 +11030,6 @@ test "headless: the whole editor comes up, opens a file, plays the tour and goes
         // With another pane there, it takes the view; without, the person's own does.
         const taken = wb.besideGrouping();
         if (others > 0) try std.testing.expect(taken != here) else try std.testing.expectEqual(here, taken);
-        // A pane that has not drawn is no place to send the view: it joins the person's pane.
-        if (others > 0) {
-            const other = for (wb.workspaces.values()) |*o| {
-                if (o.grouping != here) break o;
-            } else return error.TestUnexpectedResult;
-            const other_rect = other.pane_rect_physical;
-            defer other.pane_rect_physical = other_rect;
-            other.pane_rect_physical = null;
-            try std.testing.expectEqual(here, wb.besideGrouping());
-        }
-        // A demo's `drop:beside` is the answer for the place it is aimed at, not the person's pane's
-        // for every place: Main's is the pane's edge in its own room, which turns with the room,
-        // and a place that holds no documents has none.
-        if (others == 0) {
-            const Side = fizzy.core.widgets.DockLayout.Side;
-            const main = (editor.regionFor(fizzy.sdk.keywords.ide.main) orelse return error.TestUnexpectedResult).name;
-            const sidebar = (editor.regionFor(fizzy.sdk.keywords.ide.sidebar) orelse return error.TestUnexpectedResult).name;
-            ws.pane_rect_physical = .{ .x = 0, .y = 0, .w = 1200 * s, .h = 800 * s };
-            try std.testing.expectEqual(@as(?Side, .right), fizzy.Editor.Demo.besideEdge(&editor.demo, main));
-            try std.testing.expectEqual(@as(?Side, null), fizzy.Editor.Demo.besideEdge(&editor.demo, sidebar));
-            ws.pane_rect_physical = .{ .x = 0, .y = 0, .w = 820 * s, .h = 1180 * s };
-            try std.testing.expectEqual(@as(?Side, .bottom), fizzy.Editor.Demo.besideEdge(&editor.demo, main));
-            var pane_buf: [32]u8 = undefined;
-            const pane = fizzy.Editor.Workspace.name(&pane_buf, here);
-            try std.testing.expectEqual(@as(?Side, .bottom), fizzy.Editor.Demo.besideEdge(&editor.demo, pane));
-            var other_buf: [32]u8 = undefined;
-            try std.testing.expectEqual(@as(?Side, null), fizzy.Editor.Demo.besideEdge(&editor.demo, fizzy.Editor.Workspace.name(&other_buf, here + 1000)));
-            try std.testing.expectEqual(@as(?Side, null), wb.besideEdge(here + 1000));
-            ws.pane_rect_physical = .{ .x = 0, .y = 0, .w = 390 * s, .h = 844 * s };
-        }
         try std.testing.expectEqual(fizzy.core.widgets.DockLayout.Side.right, workbench.Workbench.sideFor(1200, 800));
         try std.testing.expectEqual(fizzy.core.widgets.DockLayout.Side.bottom, workbench.Workbench.sideFor(820, 1180));
     }
@@ -13760,28 +13238,6 @@ fn openedSheet(size: SheetSize, keywords: []const []const u8, name: []const u8)
     return regionRect(editor, name) orelse error.TestUnexpectedResult;
 }
 
-test "mobile chrome: disabled panel has no place or toggle, landscape explorer follows edge" {
-    for (sheet_sizes) |size| {
-        var ctx = try shim.initSized(std.testing.allocator, .{ .w = size.w, .h = size.h });
-        defer ctx.deinit(std.testing.allocator);
-        try mobileCase(&ctx);
-        defer mobileTeardown(&ctx);
-        const editor = ctx.editor;
-        editor.chrome = .{ .panel = false, .sidebar_edge = .right };
-        try dvui.testing.settle(MobileFrame.frame);
-        try std.testing.expect(chromeBounds(editor, "Panel") == null);
-        try std.testing.expect(editor.regionFor(fizzy.sdk.keywords.ide.panel) == null);
-        try std.testing.expect(dvui.tagGet("fizzy.mobile.panel") == null);
-        editor.regionFor(fizzy.sdk.keywords.ide.sidebar).?.open();
-        try dvui.testing.settle(MobileFrame.frame);
-        const explorer = chromeBounds(editor, "Explorer") orelse return error.TestUnexpectedResult;
-        if (size.w > size.h) {
-            try std.testing.expect(explorer.x > dvui.windowRectPixels().w * 0.4);
-            try std.testing.expectApproxEqAbs(dvui.windowRectPixels().w, explorer.x + explorer.w, 1);
-        }
-    }
-}
-
 test "mobile sheets: capped in width in portrait, side sheets in landscape" {
     const kw = fizzy.sdk.keywords.ide;
     // A sheet's box includes the card's 16 pt of padding.
diff --git a/tests/tapes/soak.zon b/tests/tapes/soak.zon
index 43824b3f3..06fc15b96 100644
--- a/tests/tapes/soak.zon
+++ b/tests/tapes/soak.zon
@@ -17,6 +17,8 @@
             .{ .path = "src/main.zig", .text = "const std = @import(\"std\");\n\npub fn main() void {\n    std.debug.print(\"soak\\n\", .{});\n}\n" },
         },
         .open = .{ "src/main.zig", "README.md" },
+        // The explorer open, so there is a view to float.
+        .layout = .reset,
     }},
     .home = "region:Main",
     .chapters = .{
diff --git a/web/AGENTS.md b/web/AGENTS.md
index 26ab37dfe..579e85caa 100644
--- a/web/AGENTS.md
+++ b/web/AGENTS.md
@@ -49,9 +49,3 @@ The page and its JavaScript (`index.html`, the app's `fizzy.js`, workers). The Z
   dispatch `MouseEvent`s at the canvas ~1 s apart. dvui on the web draws only on request.
 - After `zig build web`, a hand-edited copy of `index.html` keeps a stale cache-buster hash and
   the browser serves the old `web.js`. Regenerate the copy.
-- **A new file the page names goes in `build/web.zig`'s copy list** (`manifest.webmanifest` and its
-  icons are there). Their paths are relative so the one build serves /app/ and /testapp/; keep
-  `start_url` and `scope` at `./`. The page hides View > Toggle Full Screen where the browser has no
-  Fullscreen API (iPhone Safari) through `fizzy_web_fullscreen_supported`, which the worker
-  answers from a flag in its `init` message. An embed (an iframe) gets fullscreen only with
-  `allow="fullscreen"`; without it `document.fullscreenEnabled` is false and the command is hidden.
diff --git a/web/fizzy-worker.js b/web/fizzy-worker.js
index 35979aab5..7d9f641a0 100644
--- a/web/fizzy-worker.js
+++ b/web/fizzy-worker.js
@@ -30,8 +30,6 @@ const env = {
     // The page's `startup`: what to load, open and play once the editor is up.
     startup: { plugins: [], open: [], show: "", demos: [], tape: "" },
     baseURI: "",
-    // Whether the page can go full screen at all (not Safari on iPhone), measured on the page.
-    fullscreenSupported: false,
 };
 const inputStub = { style: {}, value: "", setAttribute() {}, addEventListener() {}, focus() {}, select() {} };
 self.document = {
@@ -216,9 +214,6 @@ const fizzyImports = (target) => ({
     fizzy_web_toggle_fullscreen() {
         postMessage({ type: "fullscreen" });
     },
-    fizzy_web_fullscreen_supported() {
-        return env.fullscreenSupported ? 1 : 0;
-    },
     fizzy_web_now_real_ms() {
         return Date.now();
     },
@@ -615,7 +610,7 @@ function postBoundKeys() {
 
 // ---- start -------------------------------------------------------------------------------
 async function start(init) {
-    Object.assign(env, { size: init.size, prefs: init.prefs, storage: init.storage, storageName: init.storageName, buildStorageName: init.buildStorageName || init.storageName, startup: init.startup, baseURI: init.baseURI, fullscreenSupported: init.fullscreenSupported });
+    Object.assign(env, { size: init.size, prefs: init.prefs, storage: init.storage, storageName: init.storageName, buildStorageName: init.buildStorageName || init.storageName, startup: init.startup, baseURI: init.baseURI });
     adoptCanvas(init.canvas);
     warmRememberedPlugins();
 
diff --git a/web/fizzy.js b/web/fizzy.js
index a1bc15278..d562dc75a 100644
--- a/web/fizzy.js
+++ b/web/fizzy.js
@@ -15,9 +15,6 @@ import { Dvui, TextInput } from "./web.js?cache-buster=TEMPLATE_HASH_WITH_PADDIN
 // /app/) is built with a name of its own (`zig build web -Dweb-storage=...`) and never reads or
 // overwrites the real one's settings, layout or plugins. Stamped by the build.
 const buildStorageName = "__FIZZY_WEB_STORAGE__";
-// iPhone Safari has no Fullscreen API for pages (iPad does); there, "Add to Home Screen"
-// is the way to lose the address bar (manifest.webmanifest).
-const fullscreenSupported = !!(document.fullscreenEnabled && document.documentElement.requestFullscreen);
 
 /**
  * @typedef {object} FizzyOptions
@@ -277,10 +274,6 @@ export class Fizzy {
             document.documentElement.requestFullscreen().catch((err) => console.warn("fizzy: full screen refused:", err));
           }
         },
-        // False where a page cannot go full screen (Safari on iPhone), so the command hides.
-        fizzy_web_fullscreen_supported() {
-          return fullscreenSupported ? 1 : 0;
-        },
         // `Clock.real` for the app's `Io` (src/backend/web_io.zig).
         fizzy_web_now_real_ms() {
           return Date.now();
@@ -946,7 +939,6 @@ export class Fizzy {
         storage,
         storageName,
         buildStorageName,
-        fullscreenSupported,
         startup,
         baseURI: document.baseURI,
       }, [offscreen]));
@@ -1125,7 +1117,7 @@ export class Fizzy {
         axis(1, ev.deltaY, []);
       }, { passive: false });
 
-      // What the keyboard does to the fragment before the caret reaches the worker as typing.
+      // What the keyboard does to the word before the caret reaches the worker as typing.
       const textInput = new TextInput(hidden, {
         text: (text) => post({ type: "text", text }),
         backspace: () => {
diff --git a/web/icon-192.png b/web/icon-192.png
deleted file mode 100644
index 5c08ee639..000000000
Binary files a/web/icon-192.png and /dev/null differ
diff --git a/web/icon-512.png b/web/icon-512.png
deleted file mode 100644
index f53dd1d8f..000000000
Binary files a/web/icon-512.png and /dev/null differ
diff --git a/web/index.html b/web/index.html
index 74968c3df..2c850ded2 100644
--- a/web/index.html
+++ b/web/index.html
@@ -5,12 +5,7 @@
     <meta http-equiv="Cache-Control" content="no-cache, no-store, must-revalidate" />
     <meta http-equiv="Pragma" content="no-cache" />
     <meta http-equiv="Expires" content="0" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover" />
-    <meta name="theme-color" content="#22232a" />
-    <meta name="mobile-web-app-capable" content="yes" />
-    <meta name="apple-mobile-web-app-capable" content="yes" />
-    <link rel="manifest" href="manifest.webmanifest" />
-    <link rel="apple-touch-icon" href="icon-192.png" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>fizzy</title>
     <meta name="description" content="fizzy — pixel art editor in your browser." />
     <link rel="icon" type="image/png" href="/img/icon.png" />
@@ -37,9 +32,6 @@
         width: 100%;
         height: 100%;
         overflow: hidden;
-        /* viewport-fit=cover lets the page run under a notch or home bar in fullscreen and an
-           installed app; keep the editor out of them. Zero everywhere else. */
-        padding: env(safe-area-inset-top) env(safe-area-inset-right) env(safe-area-inset-bottom) env(safe-area-inset-left);
       }
       #dvui-canvas {
         display: block;
diff --git a/web/manifest.webmanifest b/web/manifest.webmanifest
deleted file mode 100644
index 3f7f81f71..000000000
--- a/web/manifest.webmanifest
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-  "name": "fizzy",
-  "short_name": "fizzy",
-  "description": "fizzy: a general editor in your browser.",
-  "start_url": "./",
-  "scope": "./",
-  "display": "standalone",
-  "background_color": "#22232a",
-  "theme_color": "#22232a",
-  "icons": [
-    { "src": "icon-192.png", "sizes": "192x192", "type": "image/png", "purpose": "any" },
-    { "src": "icon-512.png", "sizes": "512x512", "type": "image/png", "purpose": "any" }
-  ]
-}
diff --git a/web/patches/dvui/0010-web-a-keyboard-s-correction-replaces-the-typed-word.patch b/web/patches/dvui/0010-web-a-keyboard-s-correction-replaces-the-typed-word.patch
index 087f3331f..4bc3e1fda 100644
--- a/web/patches/dvui/0010-web-a-keyboard-s-correction-replaces-the-typed-word.patch
+++ b/web/patches/dvui/0010-web-a-keyboard-s-correction-replaces-the-typed-word.patch
@@ -3,17 +3,22 @@ From: Fizzy macos worker <fizzy-macos@users.noreply.github.com>
 Date: Mon, 26 Oct 2026 12:00:00 -0400
 Subject: [PATCH] web: a keyboard's correction replaces the typed word
 
-Keep up to 60 code points of sentence context in the hidden input, including spaces and
-punctuation. Reconcile native input and composition updates against that fragment, and route
-cancelable replacements and soft deletions to the same editor sink. Invalidate context when
-the editor caret moves or the field changes.
+A phone keyboard corrects the word before the caret, but the hidden input stayed empty and
+every beforeinput/compositionend was sent as new text, so "im" became "imI'm". TextInput keeps
+the word typed since the last space in the hidden input, caret at its end, and turns an
+insertReplacementText (its target range, or the selection the keyboard made, when a range is
+empty as it is for an input) or a composition that rewrote the word into backspaces and the
+new text. A pointer, a navigation key, a delete it cannot follow, a blur or another field
+clears the word.
 ---
+ src/backends/web.js | 159 ++++++++++++++++
+ 1 file changed, 128 insertions(+), 31 deletions(-)
 
 diff --git a/src/backends/web.js b/src/backends/web.js
 index cecf29a..cc084e5 100644
 --- a/src/backends/web.js
 +++ b/src/backends/web.js
-@@ -162,16 +162,153 @@ const StylusAction = Object.freeze({
+@@ -162,16 +162,138 @@ const StylusAction = Object.freeze({
      /** motion only */
      move: 1,
      /** motion, then the left button pressed */
@@ -23,12 +28,18 @@ index cecf29a..cc084e5 100644
  });
  
 +/**
-+ * Mirrors a bounded sentence fragment before the editor caret. Keyboard replacements and
-+ * native composition edits become backspaces and text for dvui's own text widgets.
-+ * Pointer and navigation events invalidate the fragment because its document position is unknown.
++ * Keeps the hidden input showing the word before the caret, and turns what a phone keyboard
++ * does to that word into the edits dvui's text widgets understand.
++ *
++ * The widgets draw their own text, so the input is empty and a keyboard has nothing to
++ * correct: autocorrect or a suggestion then arrives as plain new text ("im" becomes "imI'm").
++ * The input holds the word typed since the last space instead, the caret at its end, so a
++ * keyboard replaces it, and a replacement is sent as that many backspaces and then the new
++ * text. The word is only what this class has seen typed; a caret moved by a pointer or a key,
++ * or a delete it cannot follow, clears it.
 + */
 +export class TextInput {
-+    /** The fragment before the caret, as the hidden input shows it. */
++    /** The word before the caret, as the hidden input shows it. */
 +    word = "";
 +    /** @type {boolean} */
 +    composing = false;
@@ -44,8 +55,6 @@ index cecf29a..cc084e5 100644
 +        this.sink = sink;
 +        hidden.addEventListener("beforeinput", (ev) => this.beforeInput(ev));
 +        hidden.addEventListener("compositionstart", () => { this.composing = true; });
-+        hidden.addEventListener("compositionupdate", () => this.sync());
-+        hidden.addEventListener("input", () => this.sync());
 +        hidden.addEventListener("compositionend", (ev) => this.compositionEnd(ev));
 +        hidden.addEventListener("blur", () => this.clear());
 +    }
@@ -53,7 +62,6 @@ index cecf29a..cc084e5 100644
 +    /** Forget the word: the caret moved, or the field changed. */
 +    clear() {
 +        this.word = "";
-+        this.backspaceKey = false;
 +        if (!this.composing && this.hidden.value !== "") this.hidden.value = "";
 +    }
 +
@@ -71,13 +79,11 @@ index cecf29a..cc084e5 100644
 +    set(word) {
 +        this.word = word;
 +        if (!this.composing && this.hidden.value !== word) this.hidden.value = word;
-+        if (!this.composing) this.hidden.selectionStart = this.hidden.selectionEnd = word.length;
 +    }
 +
 +    /** The word after `text` is typed at the caret. */
 +    typed(text) {
-+        // Keep spaces and punctuation: suggestions can replace several words.
-+        this.set(Array.from((this.word + text).split(/[\r\n]/).pop()).slice(-60).join(""));
++        this.set((this.word + text).split(/\s/).pop());
 +    }
 +
 +    /** Replace [start, end) of the word with `text`: the deleted tail, then the text. */
@@ -96,17 +102,13 @@ index cecf29a..cc084e5 100644
 +    }
 +
 +    beforeInput(ev) {
-+        if (ev.isComposing || ev.cancelable === false) return;
 +        ev.preventDefault();
++        if (ev.isComposing) return;
 +        const type = ev.inputType;
-+        if (type !== "deleteContentBackward") this.backspaceKey = false;
 +        if (type === "deleteContentBackward") {
 +            // Soft keyboards usually send the Backspace key as well, which has popped the word.
 +            if (this.backspaceKey) this.backspaceKey = false;
-+            else {
-+                this.sink.backspace();
-+                this.set(Array.from(this.word).slice(0, -1).join(""));
-+            }
++            else this.set(Array.from(this.word).slice(0, -1).join(""));
 +            return;
 +        }
 +        if (type && type.startsWith("delete")) {
@@ -116,7 +118,7 @@ index cecf29a..cc084e5 100644
 +        let text = ev.data;
 +        if (text == null && type === "insertReplacementText" && ev.dataTransfer) text = ev.dataTransfer.getData("text/plain");
 +        if (!text) return;
-+        if (type === "insertReplacementText" || type === "insertText") {
++        if (type === "insertReplacementText") {
 +            // For an input the target ranges are empty; the keyboard selects what it replaces.
 +            const ranges = ev.getTargetRanges ? ev.getTargetRanges() : [];
 +            const start = ranges.length > 0 ? ranges[0].startOffset : this.hidden.selectionStart;
@@ -125,40 +127,28 @@ index cecf29a..cc084e5 100644
 +                this.replace(start, end, text);
 +                return;
 +            }
-+            if (type === "insertReplacementText") {
-+                // No range and a collapsed caret: the keyboard means the word before it.
-+                const word = this.word.match(/\S*$/)[0];
-+                this.replace(this.word.length - word.length, this.word.length, text);
-+                return;
-+            }
 +        }
 +        this.sink.text(text);
 +        this.typed(text);
 +    }
 +
-+    /** Reconcile native edits, including non-cancelable keyboard and composition events. */
-+    sync() {
++    compositionEnd(ev) {
++        this.composing = false;
++        // The input now holds the word as the keyboard composed it. Whatever it shares with the
++        // word the widgets have is untouched; the rest of ours is deleted and theirs typed.
 +        const had = Array.from(this.word);
-+        const now = Array.from(this.hidden.value);
++        let now = Array.from(this.hidden.value);
++        if (now.length === 0 && had.length === 0 && ev.data) now = Array.from(ev.data);
 +        let same = 0;
 +        while (same < had.length && same < now.length && had[same] === now[same]) same++;
 +        for (let i = same; i < had.length; i++) this.sink.backspace();
 +        const text = now.slice(same).join("");
 +        if (text) this.sink.text(text);
-+        this.word = now.join("");
-+        // Do not truncate or reset the DOM during an active composition.
-+        if (!this.composing) {
-+            this.word = "";
-+            this.typed(now.join(""));
-+        }
-+    }
-+
-+    compositionEnd(ev) {
-+        if (!this.hidden.value && !this.word && ev.data) this.hidden.value = ev.data;
-+        this.composing = false;
-+        this.sync();
++        this.word = "";
++        this.typed(now.join(""));
 +    }
 +}
++
  export class Dvui {
      /** @type {WebGL2RenderingContext | WebGLRenderingContext} */
      gl;
@@ -167,7 +157,7 @@ index cecf29a..cc084e5 100644
      /** @type {WebGLBuffer} */
      vertexBuffer;
      /** @type {WebGLProgram} */
-@@ -1164,21 +1292,24 @@ export class Dvui {
+@@ -1164,21 +1286,24 @@ export class Dvui {
                  }
                  if (this.cur !== this.stock) this.useProgram(0, null, 0, 0);
              },
@@ -192,7 +182,7 @@ index cecf29a..cc084e5 100644
                      window.open(url);
                  } else {
                      window.location.href = url;
-@@ -1725,16 +1856,17 @@ export class Dvui {
+@@ -1725,16 +1850,17 @@ export class Dvui {
                      0,
                  );
              }
@@ -210,7 +200,7 @@ index cecf29a..cc084e5 100644
                  // switches tabs and we don't do anything.
                  if (ev.ctrlKey) return;
  
-@@ -1771,49 +1903,32 @@ export class Dvui {
+@@ -1771,49 +1897,32 @@ export class Dvui {
                  (ev.metaKey << 3) + (ev.altKey << 2) + (ev.ctrlKey << 1) +
                  (ev.shiftKey << 0),
              );
diff --git a/web/tests/text-input.test.js b/web/tests/text-input.test.js
index c438956c2..441da2a59 100644
--- a/web/tests/text-input.test.js
+++ b/web/tests/text-input.test.js
@@ -1,4 +1,4 @@
-// The hidden input's fragment and what a keyboard's correction does to the text. Run by
+// The hidden input's word and what a keyboard's correction does to the text. Run by
 // scripts/test-web-text-input.sh against the web.js the build writes (dvui's, patched):
 //   node text-input.test.js <path to the patched web.js>   (or jsc -m, as the script does)
 // A fake input stands in for the page's; the fake sink applies the edits like a text field.
@@ -28,7 +28,7 @@ function fixture() {
     text: (t) => { field.text += t; },
     backspace: () => { field.text = Array.from(field.text).slice(0, -1).join(""); },
   });
-  const fire = (type, ev) => listeners[type]?.(ev);
+  const fire = (type, ev) => listeners[type](ev);
   const type = (data) => fire("beforeinput", { preventDefault() {}, inputType: "insertText", data, isComposing: false });
   const select = (a, b) => { hidden.selectionStart = a; hidden.selectionEnd = b; };
   return { hidden, field, input, fire, type, select };
@@ -57,8 +57,8 @@ const replacement = (data, ranges = []) => ({
 {
   const { field, type, fire, select } = fixture();
   for (const c of "a teh") type(c);
-  select(2, 5);
-  fire("beforeinput", replacement("the", [{ startOffset: 2, endOffset: 5 }]));
+  select(0, 3);
+  fire("beforeinput", replacement("the", [{ startOffset: 0, endOffset: 3 }]));
   check("only the word after the space is replaced", field.text, "a the");
 }
 {
@@ -100,72 +100,6 @@ const replacement = (data, ranges = []) => ({
   check("a navigation key clears it", hidden.value, "");
   check("and leaves the field alone", field.text, "tex");
 }
-{
-  const { field, type, select } = fixture();
-  for (const c of "say dont") type(c);
-  select(4, 8);
-  type("don't");
-  check("insertText suggestion replaces the selected whole word", field.text, "say don't");
-}
-// Native Android events can bypass cancelable beforeinput entirely.
-for (const [before, after] of [
-  ["please dont", "please don't"], ["well im", "well I'm"],
-  ["a well known", "a well-known"], ["i ", "I "],
-  ["see alot", "see a lot"],
-]) {
-  const { hidden, field, type, fire } = fixture();
-  for (const c of before) type(c);
-  check(`context retained: ${before}`, hidden.value, before);
-  hidden.value = after;
-  fire("input", { inputType: "insertText", data: after });
-  check(`suggestion: ${before}`, field.text, after);
-}
-{
-  const { hidden, field, type, fire } = fixture();
-  for (const c of "say teh") type(c);
-  fire("compositionstart", {});
-  hidden.value = "say the";
-  fire("compositionupdate", { data: "the" });
-  check("composition update rewrites the fragment", field.text, "say the");
-  fire("input", { isComposing: true });
-  fire("compositionend", { data: "the" });
-  fire("input", { inputType: "insertText", data: "the" });
-  check("composition final input is not duplicated", field.text, "say the");
-}
-{
-  const { field, type, fire } = fixture();
-  for (const c of "teh") type(c);
-  for (let i = 0; i < 3; i++) fire("beforeinput", {
-    preventDefault() {}, inputType: "deleteContentBackward",
-  });
-  type("the");
-  check("soft deletion and insertion pair", field.text, "the");
-}
-{
-  const { hidden, field, type, fire, input } = fixture();
-  for (const c of "old word") type(c);
-  input.clear(); // The canvas pointerdown invalidates context before moving the caret.
-  field.text = "old "; // Model the editor caret at the tapped insertion point.
-  for (const c of "teh") type(c);
-  hidden.value = "the";
-  fire("input", { inputType: "insertReplacementText" });
-  check("replacement after a tap uses only fresh context", field.text, "old the");
-}
-{
-  const { hidden, field, type, fire } = fixture();
-  for (const c of "x".repeat(80)) type(c);
-  check("fragment is bounded", hidden.value.length, 60);
-  hidden.value = "y" + hidden.value.slice(1);
-  fire("input", {});
-  check("truncation preserves text outside the fragment", field.text, "x".repeat(20) + "y" + "x".repeat(59));
-}
-{
-  const { field, type, fire, select } = fixture();
-  for (const c of "mu") type(c);
-  select(2, 2);
-  fire("beforeinput", replacement("my"));
-  check("collapsed selection, no ranges: the word is replaced", field.text, "my");
-}
 if (failed > 0) {
   print(`text-input: ${failed} failed`);
   exit(1);