diff --git a/packages/app/e2e/regression/timeline-stream.spec.ts b/packages/app/e2e/regression/timeline-stream.spec.ts index 1fc26e26097..3c5dee1b2f1 100644 --- a/packages/app/e2e/regression/timeline-stream.spec.ts +++ b/packages/app/e2e/regression/timeline-stream.spec.ts @@ -3317,6 +3317,16 @@ test("reaches the quote action from the keyboard and blocks a selection over the await expect(more).not.toBeFocused() expect(await page.evaluate(() => !!document.activeElement?.closest('[data-component="timeline-quote"]'))).toBe(false) await expect(composer).toHaveCount(1) + + // A press that turns into a native drag of the selection ends with dragend, and no pointerup follows. + await page.evaluate(() => window.getSelection()?.removeAllRanges()) + await expect(toolbar).toHaveCount(0) + await short.hover() + await page.mouse.down() + await page.evaluate(() => document.dispatchEvent(new Event("dragend"))) + await short.evaluate((element) => window.getSelection()?.selectAllChildren(element)) + await expect(toolbar).toBeVisible() + await page.mouse.up() }) function pauseExitAnimations(locator: Locator) { diff --git a/packages/app/src/session/composer/queue-machine.test.ts b/packages/app/src/session/composer/queue-machine.test.ts index f7b5cea73d2..35294e55033 100644 --- a/packages/app/src/session/composer/queue-machine.test.ts +++ b/packages/app/src/session/composer/queue-machine.test.ts @@ -2,6 +2,7 @@ import { describe, expect, test } from "bun:test" import type { Prompt } from "@/composer/state" import { createQueueState, + movedTarget, selectQueueRows, transitionQueue, viewQueue, @@ -169,6 +170,55 @@ describe("queue changes run one at a time", () => { }) }) +describe("replaced inbox IDs", () => { + const moved = (state: QueueState) => viewQueue(state, { working: true, behavior: "queue" }).moved + + // Edits `id` as a queued prompt; its replacement and the prompts after it take `next`. + function edit(state: QueueState, id: string, next: string[]) { + const confirmed = replay(state, [ + { type: "edit.start", id, reverted: false, draft: draft("") }, + { type: "edit.confirm", delivery: "queue", reverted: false, prompt: prompt(`${id} edited`), ids: next }, + ]) + + return { state: confirmed.state, attempt: runs(confirmed.effects)[0].attempt } + } + + test("an edit's replacements chain across later edits until their prompts leave the queue", () => { + const first = edit(createQueueState([one]), "inb_1", ["msg_1"]) + // In flight, the panel already sees the replacement it may swap in. + expect(moved(first.state)).toEqual({ inb_1: "msg_1" }) + + const settled = replay(first.state, [ + { type: "inbox.synced", items: [item("msg_1")] }, + { type: "mutation.succeeded", attempt: first.attempt }, + ]).state + + expect(settled.status).toBe("idle") + expect(moved(settled)).toEqual({ inb_1: "msg_1" }) + + const second = edit(settled, "msg_1", ["msg_2"]) + + const chained = replay(second.state, [ + { type: "inbox.synced", items: [item("msg_2")] }, + { type: "mutation.succeeded", attempt: second.attempt }, + ]).state + + expect(movedTarget(moved(chained), "inb_1", new Set(["msg_2"]))).toBe("msg_2") + expect(movedTarget(moved(chained), "inb_1", new Set(["msg_1", "msg_2"]))).toBe("msg_1") + + // Once the last replacement is delivered, nothing it maps is queued. + expect(moved(transitionQueue(chained, { type: "inbox.synced", items: [] }).state)).toEqual({}) + }) + + test("a failed edit leaves no replacement behind", () => { + const sent = edit(createQueueState([one, two]), "inb_1", ["msg_1", "msg_2"]) + expect(moved(sent.state)).toEqual({ inb_1: "msg_1", inb_2: "msg_2" }) + + const failed = transitionQueue(sent.state, { type: "mutation.failed", attempt: sent.attempt, hidden: [] }) + expect(moved(failed.state)).toEqual({}) + }) +}) + describe("optimistic rows", () => { test("a steer hides its row until the server confirms or refuses it", () => { const requested = transitionQueue(createQueueState([one, two]), { type: "steer.requested", id: "inb_1" }) diff --git a/packages/app/src/session/composer/queue-machine.ts b/packages/app/src/session/composer/queue-machine.ts index e089d817265..f887d2e9101 100644 --- a/packages/app/src/session/composer/queue-machine.ts +++ b/packages/app/src/session/composer/queue-machine.ts @@ -80,8 +80,13 @@ type QueueBase = { readonly seq: number readonly items: readonly QueuedPrompt[] readonly gone: readonly GoneEntry[] + // Each inbox ID a finished edit or reorder replaced, mapped to the ID admitted in its place, so the strip can swap + // the row in place. An entry is dropped once no ID along its chain is queued. + readonly moved: Readonly> } +const NO_MOVES: Readonly> = Object.freeze({}) + // Operations run one at a time in the order they were requested: `active` is in flight and `pending` waits for it. export type QueueState = | (QueueBase & { readonly status: "idle" }) @@ -157,10 +162,12 @@ export type QueueView = { readonly undoing: boolean readonly delivery: ComposerDelivery readonly alternate: ComposerDelivery | undefined + /** Inbox IDs replaced by an edit or reorder, finished or in flight, mapped to their replacements. */ + readonly moved: Readonly> } export function createQueueState(items: readonly QueuedPrompt[]): QueueState { - return { status: "idle", seq: 0, items, gone: [] } + return { status: "idle", seq: 0, items, gone: [], moved: NO_MOVES } } export function transitionQueue(state: QueueState, event: QueueEvent): QueueTransition { @@ -200,7 +207,10 @@ export function transitionQueue(state: QueueState, event: QueueEvent): QueueTran const closed = state.status === "editing" || state.status === "editing-while-mutating" ? closeEdit(state) : state // Operations in flight still finish: the server may already hold half of an edit. - return changed({ ...closed, gone: [] }, [...(edit ? [restore(edit, false)] : []), { type: "timer.clearAll" }]) + return changed({ ...closed, gone: [], moved: NO_MOVES }, [ + ...(edit ? [restore(edit, false)] : []), + { type: "timer.clearAll" }, + ]) } return settle(state, event) @@ -256,9 +266,30 @@ export function viewQueue( undoing: state.status === "mutating" && state.active.type === "undo", delivery: context.working ? context.behavior : "steer", alternate: editing ? "steer" : context.working ? (context.behavior === "queue" ? "steer" : "queue") : undefined, + moved: selectQueueMoved(state), } } +export function selectQueueMoved(state: QueueState) { + const active = state.status === "mutating" || state.status === "editing-while-mutating" ? state.active : undefined + + if ((active?.type !== "edit" && active?.type !== "reorder") || !Object.keys(active.moved).length) return state.moved + + return { ...state.moved, ...active.moved } +} + +/** The first ID along `id`'s chain of replacements that `listed` holds. */ +export function movedTarget(moved: Readonly>, id: string, listed: ReadonlySet) { + // Every replacement is a freshly minted ID, so a chain cannot loop; the bound only guards malformed input. + const hops = Object.keys(moved).length + + for (let next = moved[id], step = 0; next !== undefined && step < hops; next = moved[next], step++) { + if (listed.has(next)) return next + } + + return undefined +} + export function editingID(state: QueueState) { return editOf(state)?.id } @@ -272,7 +303,15 @@ function synced(state: QueueState, items: readonly QueuedPrompt[]): QueueTransit gone.some((entry) => entry.expiry === expiry) ? [] : [{ type: "timer.clear", expiry }], ) - const next = { ...state, items, gone } + // A replacement in flight can continue a finished one's chain. + const chains = selectQueueMoved(state) + + const kept = Object.entries(state.moved).filter( + ([, id]) => listed.has(id) || movedTarget(chains, id, listed) !== undefined, + ) + + const moved = kept.length === Object.keys(state.moved).length ? state.moved : Object.fromEntries(kept) + const next = { ...state, items, gone, moved } if (next.status !== "editing" && next.status !== "editing-while-mutating") return changed(next, cleared) @@ -312,7 +351,7 @@ function startEdit(state: QueueState, event: Extract