Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.
fix(web): pinned reorder no longer reshuffles while writes land (#5767)
Theo Browne5208bdeb0db9
diff --git a/apps/web/src/components/Sidebar.tsx b/apps/web/src/components/Sidebar.tsxindex 75c580402..f6cd9f7b1 100644--- a/apps/web/src/components/Sidebar.tsx+++ b/apps/web/src/components/Sidebar.tsx@@ -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- // optimistic order keeps the card where it was dropped until the- // confirming event round-trips; canonical order matching it releases the- // override, and a failed write clears it (the card snaps back) with a toast.- // ANY membership change (new pin, unpin, snooze/wake) also releases it:- // the override can't say where members it never saw belong, and holding it- // would misplace them and launder the stale order into later drags.+ // planPinnedReorder for the keyless-neighbor materialization case, which+ // instead rewrites every key in the section). The optimistic order keeps+ // the card where it was dropped until EVERY key the drop wrote is+ // reflected in canonical state — a section rewrite is several sequential+ // writes, and releasing on the first landed key would expose the+ // half-written canonical order, reshuffling the block once per write.+ // 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- confirming, or a concurrent one from another client) releases the- override rather than fighting canonical state. */+ /** pinOrderKey per thread as of the drop — the baseline that tells a+ concurrent client's write apart from one of our own landing. */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- // changed (pin/unpin/snooze/wake — the override can't say where members- // it never saw belong), a key changed (our write confirming, or a- // concurrent client's reorder that must win), or canonical already- // matches. Holding it longer would misplace newcomers and launder the- // stale order into later drags.+ // Release it when the world moves on: membership changed (pin/unpin/+ // snooze/wake — the override can't say where members it never saw+ // belong), a key changed to something we did NOT write (a concurrent+ // client's reorder that must win), every key we wrote has landed, or+ // canonical already matches. Releasing on the FIRST landed key instead+ // 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(- (thread, index) =>- optimisticPinnedOrder.keysAtDrop.get(canonicalKeys[index]!) !==- (thread.pinOrderKey ?? null),+ const foreignKeyLanded = canonical.some((thread, index) => {+ const threadKey = canonicalKeys[index]!;+ const currentKey = 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({