Commit 5208bdeb0db95063091a29f97af3548436c5f291 | the-knife

author	Theo Browne <me@t3.gg> 2026-08-08 21:46:27-04:00
committer	GitHub <noreply@github.com> 2026-08-08 18:46:27-07:00
log	5208bdeb0db95063091a29f97af3548436c5f291
tree	ca904cdb3f9be70b72800c5758db8dbda48c1000
parent	a6c9b41f902fba2a4137806c09e829935e91baac
signature	Signed by PGP key B5690EEEBB952194

fix(web): pinned reorder no longer reshuffles while writes land (#5767)

Co-authored-by: Claude Fable 5 <noreply@anthropic.com>

1 files changed, 47 insertions(+), 23 deletions(-)

apps
- web
  - src
    components
    Sidebar.tsx

apps/web/src/components/Sidebar.tsx+47-23

 @@ -2269,22 +2269,28 @@ export default function Sidebar() {
   );
   // Drag-to-reorder for the pinned block. A drop computes ONE fractional key
   // for the moved thread and sends it to that thread's own server (see
-  // planPinnedReorder for the keyless-neighbor materialization case). The
+  // planPinnedReorder for the keyless-neighbor materialization case, which
-  // optimistic order keeps the card where it was dropped until the
+  // instead rewrites every key in the section). The optimistic order keeps
-  // confirming event round-trips; canonical order matching it releases the
+  // the card where it was dropped until EVERY key the drop wrote is
-  // override, and a failed write clears it (the card snaps back) with a toast.
+  // reflected in canonical state — a section rewrite is several sequential
-  // ANY membership change (new pin, unpin, snooze/wake) also releases it:
+  // writes, and releasing on the first landed key would expose the
-  // the override can't say where members it never saw belong, and holding it
+  // half-written canonical order, reshuffling the block once per write.
-  // would misplace them and launder the stale order into later drags.
+  // A failed write clears the override (the card snaps back) with a toast.
+  // A key we did NOT write landing (a concurrent client's reorder that must
+  // win) and ANY membership change (new pin, unpin, snooze/wake) also
+  // release it: the override can't say where members it never saw belong,
+  // and holding it would launder a stale order into later drags.
   const pinnedDndSensors = useSensors(
     useSensor(PointerSensor, { activationConstraint: { distance: 6 } }),
   );
   const [optimisticPinnedOrder, setOptimisticPinnedOrder] = useState<{
     readonly order: readonly string[];
-    /** pinOrderKey per thread as of the drop, so ANY landed write (ours
+    /** pinOrderKey per thread as of the drop — the baseline that tells a
-        confirming, or a concurrent one from another client) releases the
+        concurrent client's write apart from one of our own landing. */
-        override rather than fighting canonical state. */
     readonly keysAtDrop: ReadonlyMap<string, string | null>;
+    /** The keys this drop writes (one per planned assignment). The
+        override holds until all of them appear in canonical state. */
+    readonly assignedKeys: ReadonlyMap<string, string>;
   } | null>(null);
   const orderedPinnedThreads = useMemo(() => {
     if (optimisticPinnedOrder === null) return pinnedThreads;
 @@ -2303,24 +2309,32 @@ export default function Sidebar() {
       scopedThreadKey(scopeThreadRef(thread.environmentId, thread.id)),
     );
     // The override represents one drop against one snapshot of the world.
-    // Release it as soon as the world moves on in any way: membership
+    // Release it when the world moves on: membership changed (pin/unpin/
-    // changed (pin/unpin/snooze/wake — the override can't say where members
+    // snooze/wake — the override can't say where members it never saw
-    // it never saw belong), a key changed (our write confirming, or a
+    // belong), a key changed to something we did NOT write (a concurrent
-    // concurrent client's reorder that must win), or canonical already
+    // client's reorder that must win), every key we wrote has landed, or
-    // matches. Holding it longer would misplace newcomers and launder the
+    // canonical already matches. Releasing on the FIRST landed key instead
-    // stale order into later drags.
+    // of the last exposes the half-written order mid-materialization and
+    // the block visibly reshuffles once per write.
     const membershipChanged =
       canonicalKeys.length !== optimisticPinnedOrder.order.length ||
       canonicalKeys.some((key) => !optimisticPinnedOrder.order.includes(key));
-    const anyKeyLanded = canonical.some(
+    const foreignKeyLanded = canonical.some((thread, index) => {
-      (thread, index) =>
+      const threadKey = canonicalKeys[index]!;
-        optimisticPinnedOrder.keysAtDrop.get(canonicalKeys[index]!) !==
+      const currentKey = thread.pinOrderKey ?? null;
-        (thread.pinOrderKey ?? null),
+      if (currentKey === optimisticPinnedOrder.keysAtDrop.get(threadKey)) return false;
+      return currentKey !== optimisticPinnedOrder.assignedKeys.get(threadKey);
+    });
+    const currentKeyByThreadKey = new Map(
+      canonical.map((thread, index) => [canonicalKeys[index]!, thread.pinOrderKey ?? null]),
+    );
+    const allAssignmentsLanded = [...optimisticPinnedOrder.assignedKeys].every(
+      ([threadKey, orderKey]) => currentKeyByThreadKey.get(threadKey) === orderKey,
     );
     const orderConfirmed =
       !membershipChanged &&
       canonicalKeys.every((key, index) => key === optimisticPinnedOrder.order[index]);
-    if (membershipChanged || anyKeyLanded || orderConfirmed) {
+    if (membershipChanged || foreignKeyLanded || allAssignmentsLanded || orderConfirmed) {
       setOptimisticPinnedOrder(null);
     }
   }, [optimisticPinnedOrder, pinnedThreads, reorderablePinnedKeys]);
 @@ -2390,7 +2404,13 @@ export default function Sidebar() {
         movedId: activeKey,
       });
       if (assignments.length === 0) return;
-      setOptimisticPinnedOrder({ order: newOrder, keysAtDrop });
+      setOptimisticPinnedOrder({
+        order: newOrder,
+        keysAtDrop,
+        assignedKeys: new Map(
+          assignments.map((assignment) => [assignment.id, assignment.orderKey]),
+        ),
+      });
       void (async () => {
         // Sequential, stop on first failure. There is deliberately no
         // rollback: every key write is a complete, valid placement on its
 @@ -2404,8 +2424,12 @@ export default function Sidebar() {
             scopeThreadRef(thread.environmentId, thread.id),
             assignment.orderKey,
           );
-          if (result._tag === "Failure" && !isAtomCommandInterrupted(result)) {
+          if (result._tag === "Failure") {
+            // Any failure — interrupted included — releases the override:
+            // a key that never lands would otherwise hold it until some
+            // unrelated world change came along.
             setOptimisticPinnedOrder(null);
+            if (isAtomCommandInterrupted(result)) return;
             const error = squashAtomCommandFailure(result);
             toastManager.add(
               stackedThreadToast({