Multi-Agent Collaboration for Team and Friends
TypeScript agent-automationagent-orchestrationagent-workflowai-agentsai-collaborationai-memoryai-workforceautonomous-agentsclaude-codeclaude-code-skillscodexcoding-agentmulti-agentmultiple-agentone-person-businessone-person-companyone-person-teamopencodesolopreneur
fix(web): stabilize server delete navigation (#769)
Gener6219633f68a5
diff --git a/scripts/ci/e2e-shards.mjs b/scripts/ci/e2e-shards.mjsindex 815683f21..9f6053eb2 100644--- a/scripts/ci/e2e-shards.mjs+++ b/scripts/ci/e2e-shards.mjs@@ -78,6 +78,7 @@ export const SPEC_SECONDS = {"54-blog-multizone.spec.ts": 5.485,"55-message-scroll-characterization.spec.ts": 109.548,"56-remote-image-state-contract.spec.ts": 3.122,+ "57-server-delete-navigation-races.spec.ts": 55,}function walk(directory) {diff --git a/scripts/ci/e2e-shards.test.ts b/scripts/ci/e2e-shards.test.tsindex 971969b7d..af28502cd 100644--- a/scripts/ci/e2e-shards.test.ts+++ b/scripts/ci/e2e-shards.test.ts@@ -80,10 +80,10 @@ describe("planE2eShards", () => {expect(new Set(assigned).size).toBe(specs.length)expect(SPEC_SECONDS["55-message-scroll-characterization.spec.ts"]).toBe(109.548)expect(specSeconds).toEqual([- 156.526, 155.455, 155.858, 156.114, 153.041, 153.044, 154.015, 153.713, 154.663,+ 159.424, 161.016, 162.097, 159.838, 161.875, 161.643, 159.966, 161.68, 159.89,])expect(predictedSeconds).toEqual([- 231.526, 230.455, 230.858, 231.114, 228.041, 228.044, 229.015, 228.713, 229.663,+ 234.424, 236.016, 237.097, 234.838, 236.875, 236.643, 234.966, 236.68, 234.89,])expect(first.every((shard) => (shard.fixed_setup_seconds === E2E_FIXED_SETUP_SECONDSdiff --git a/src/web/src/app/c/channels/layout.route-memory.dom.test.ts b/src/web/src/app/c/channels/layout.route-memory.dom.test.tsindex 71576b9a7..307714125 100644--- a/src/web/src/app/c/channels/layout.route-memory.dom.test.ts+++ b/src/web/src/app/c/channels/layout.route-memory.dom.test.ts@@ -1,14 +1,40 @@-import { createElement } from "react"+import { createElement, useLayoutEffect } from "react"import { beforeEach, describe, expect, it, vi } from "vitest"-import { render } from "@/test/react-dom-harness"+import { act, render } from "@/test/react-dom-harness"const mocks = vi.hoisted(() => ({replace: vi.fn(),+ navigatePath: vi.fn(),cancelPendingNavigation: vi.fn(),+ setCurrentServerId: vi.fn(),+ toast: vi.fn(),+ toastApiError: vi.fn(),runEject: vi.fn(),+ deleteServer: vi.fn(),+ deleteServerAction: { current: null as null | (() => Promise<void>) },+ claimNavigation: vi.fn(),+ registerRoute: vi.fn(),+ routeProtected: { current: false },+ routeToken: {},+ clearLastChannel: vi.fn(),+ communityServerId: vi.fn(),+ useServer: vi.fn(),+ servers: { current: [] as Array<{ id: string }> },+ serverDetails: new Map<string, {+ categories: Array<{ channels: Array<{ id: string; pending?: boolean }> }>+ }>(),+ structuralSnapshot: { current: null as null | {+ servers: Array<{ id: string; channels: Array<{ id: string }> }>+ } },+ lastChannels: new Map<string, string>(),serverListSuccess: { current: true },serverListFetching: { current: false },serverAccessRevoked: { current: false },+ queryClient: { getQueryData: vi.fn(), fetchQuery: vi.fn() },+}))++vi.mock("@tanstack/react-query", () => ({+ useQueryClient: () => mocks.queryClient,}))vi.mock("next/navigation", () => ({@@ -17,8 +43,8 @@ vi.mock("next/navigation", () => ({useRouter: () => ({ replace: mocks.replace, prefetch: vi.fn() }),useSearchParams: () => new URLSearchParams(),}))-vi.mock("sonner", () => ({ toast: vi.fn() }))-vi.mock("@/lib/api/client", () => ({ toastApiError: vi.fn() }))+vi.mock("sonner", () => ({ toast: mocks.toast }))+vi.mock("@/lib/api/client", () => ({ toastApiError: mocks.toastApiError }))vi.mock("@/lib/perf/switch-mark", () => ({ markSwitch: vi.fn() }))vi.mock("@/components/ui/dialog", () => ({Dialog: ({ children }: { children: React.ReactNode }) => children,@@ -28,17 +54,45 @@ vi.mock("@/components/community/channels/use-channel-tree", () => ({useChannelTree: () => [],}))vi.mock("@/components/community/shell/shell-frame", () => ({- ShellFrame: ({ children }: { children: React.ReactNode }) => createElement("shell-frame", null, children),+ ShellFrame: ({ children, extraDialogs, ownerDeleteRouteScope }: {+ children: React.ReactNode+ extraDialogs?: React.ReactNode+ ownerDeleteRouteScope?: {+ serverId: string+ token: object+ }+ }) => {+ useLayoutEffect(() => {+ if (!ownerDeleteRouteScope) return+ mocks.registerRoute(+ ownerDeleteRouteScope.serverId,+ ownerDeleteRouteScope.token,+ )+ }, [ownerDeleteRouteScope])+ return createElement("shell-frame", null, children, extraDialogs)+ },}))vi.mock("@/lib/community/community-route", () => ({channelHref: (serverId: string, channelId: string) => `/c/channels/${serverId}/${channelId}`,+ communityServerId: (pathname: string) => mocks.communityServerId(pathname),serverRootHref: (serverId: string) => `/c/channels/${serverId}`,serverModalMarkerCleanupHref: () => null,}))vi.mock("@/hooks/use-mobile", () => ({ useBreakpoint: () => "desktop" }))vi.mock("@/components/community/channels/channel-sidebar", () => ({ ChannelSidebar: () => null }))vi.mock("@/components/community/channels/channel-route", () => ({ ChannelRoute: () => null }))-vi.mock("@/components/community/settings/server-settings", () => ({ ServerSettings: () => null }))+vi.mock("@/components/community/shell/community-pending-frame", () => ({+ CommunityPendingFrame: ({ href }: { href: string }) => createElement("div", {+ "data-testid": "owner-delete-pending-frame",+ "data-href": href,+ }),+}))+vi.mock("@/components/community/settings/server-settings", () => ({+ ServerSettings: ({ onDeleteServer }: { onDeleteServer: () => Promise<void> }) => {+ mocks.deleteServerAction.current = onDeleteServer+ return null+ },+}))vi.mock("@/components/community/image-crop-dialog", () => ({ ImageCropDialog: () => null }))vi.mock("@/lib/community/image-crop", () => ({ validateIconSourceFile: () => ({ ok: true }) }))vi.mock("@alook/shared", () => ({@@ -49,8 +103,11 @@ vi.mock("@alook/shared", () => ({vi.mock("@/lib/community/profile-read", () => ({ readCommunityProfile: vi.fn() }))vi.mock("@/stores/community", () => {const state = {- setCurrentServerId: vi.fn(),- uiHandlers: { cancelPendingNavigation: mocks.cancelPendingNavigation },+ setCurrentServerId: mocks.setCurrentServerId,+ uiHandlers: {+ cancelPendingNavigation: mocks.cancelPendingNavigation,+ navigatePath: mocks.navigatePath,+ },}return {useCommunityStore: { getState: () => state },@@ -62,17 +119,23 @@ vi.mock("@/contexts/community/current-user", () => ({useCurrentUser: () => ({ id: "viewer-1" }),}))vi.mock("@/hooks/community/use-servers", () => ({- useServer: () => ({ server: undefined }),+ serverProjectedQueryFn: () => vi.fn(),+ useServer: (serverId: string | null) => {+ mocks.useServer(serverId)+ return { server: undefined }+ },useServers: () => ({- servers: [],+ servers: mocks.servers.current,isSuccess: mocks.serverListSuccess.current,isFetching: mocks.serverListFetching.current,}),}))vi.mock("@/hooks/community/use-structural-snapshot", () => ({- useStructuralSnapshot: () => null,+ useStructuralSnapshot: () => mocks.structuralSnapshot.current,structuralHintServer: () => null,- hasStructuralServerTree: () => false,+ hasStructuralServerTree: (server: { channels?: unknown[] } | null) => (+ (server?.channels?.length ?? 0) > 0+ ),}))vi.mock("@/hooks/community/use-server-members", () => ({useServerMembers: () => ({@@ -81,10 +144,32 @@ vi.mock("@/hooks/community/use-server-members", () => ({}),}))vi.mock("@/lib/community/eject-server", () => ({+ claimOwnerServerDeleteNavigation: (...args: unknown[]) => mocks.claimNavigation(...args),consumeVoluntaryLeave: vi.fn(),+ createOwnerServerDeleteRouteToken: () => mocks.routeToken,+ isOwnerServerDeleteCommittedRoute: () => true,+ isOwnerServerDeleteRouteProtected: () => mocks.routeProtected.current,+ pickPostEjectDestination: (+ servers: Array<{ id: string }>,+ deletedServerId: string,+ destination: (serverId: string) => string,+ ) => {+ const survivor = servers.find((server) => server.id !== deletedServerId)+ return survivor ? destination(survivor.id) : "/c/me"+ },+ registerOwnerServerDeleteRoute: (...args: unknown[]) => mocks.registerRoute(...args),runAuthoritativeServerEject: (args: Record<string, unknown>) => mocks.runEject(args),}))-vi.mock("@/lib/community/last-channel", () => ({ clearLastChannel: vi.fn() }))+vi.mock("@/lib/community/last-channel", () => ({+ clearLastChannel: (...args: unknown[]) => mocks.clearLastChannel(...args),+ getLastChannel: (serverId: string) => mocks.lastChannels.get(serverId) ?? null,+ pickServerLandingHref: (serverId: string, channelIds: string[], last: string | null) => {+ const channelId = last ?? channelIds[0]+ return channelId+ ? `/c/channels/${serverId}/${channelId}`+ : `/c/channels/${serverId}`+ },+}))vi.mock("@/hooks/community/use-server-panels", () => ({ usePresence: vi.fn() }))vi.mock("@/hooks/community/use-forum-sidebar-threads", () => ({resolveForumSidebarRouteCandidate: () => null,@@ -117,7 +202,27 @@ vi.mock("@/hooks/community/mutations", () => {useDeleteCategory: mutation,useReorderCategories: mutation,useReorderChannels: mutation,- useDeleteServer: mutation,+ useDeleteServer: (callbacks: {+ routeToken: object+ onSuccess: (+ args: { serverId: string },+ result: { needsNavigation: boolean },+ ) => void+ onError: (error: Error, args: { serverId: string }) => void+ }) => ({+ mutate: (args: { serverId: string }) => {+ mocks.routeProtected.current = true+ mocks.deleteServer(args, {+ onSuccess: (needsNavigation = true) => {+ callbacks.onSuccess(args, { needsNavigation })+ },+ onError: (error: Error) => {+ mocks.routeProtected.current = false+ callbacks.onError(error, args)+ },+ })+ },+ }),useUpdateServer: mutation,useUploadServerIcon: mutation,useSetServerNotifLevel: mutation,@@ -129,43 +234,288 @@ vi.mock("@/hooks/community/mutations", () => {import ServerLayout from "./layout"-describe("ServerLayout cold-entry ejection context", () => {+describe("ServerLayout deletion routing", () => {beforeEach(() => {+ window.history.replaceState({}, "", "/c/channels/missing-server/missing-channel")mocks.replace.mockClear()+ mocks.navigatePath.mockClear()mocks.cancelPendingNavigation.mockClear()+ mocks.setCurrentServerId.mockClear()+ mocks.toast.mockClear()+ mocks.toastApiError.mockClear()mocks.runEject.mockReset()+ mocks.deleteServer.mockReset()+ mocks.claimNavigation.mockReset()+ mocks.claimNavigation.mockReturnValue(true)+ mocks.registerRoute.mockReset()+ mocks.registerRoute.mockReturnValue("ordinary")+ mocks.routeProtected.current = false+ mocks.clearLastChannel.mockClear()+ mocks.communityServerId.mockReset()+ mocks.communityServerId.mockImplementation((pathname: string) => (+ pathname.match(/^\/c\/channels\/([^/?#]+)/)?.[1] ?? null+ ))+ mocks.deleteServerAction.current = null+ mocks.useServer.mockClear()+ mocks.servers.current = []+ mocks.serverDetails.clear()+ mocks.structuralSnapshot.current = null+ mocks.lastChannels.clear()mocks.serverListSuccess.current = truemocks.serverListFetching.current = falsemocks.serverAccessRevoked.current = false- mocks.runEject.mockImplementation((args: { replace: (destination: string) => void }) => {+ mocks.queryClient.getQueryData.mockImplementation((key: unknown[]) => {+ if (key.length === 2 && key[1] === "servers") {+ return { servers: mocks.servers.current }+ }+ return mocks.serverDetails.get(String(key.at(-1)))+ })+ mocks.queryClient.fetchQuery.mockReset()+ mocks.queryClient.fetchQuery.mockImplementation(({ queryKey }: { queryKey: unknown[] }) => (+ Promise.resolve(mocks.serverDetails.get(String(queryKey.at(-1))))+ ))+ mocks.runEject.mockReturnValue(false)+ })++ it("checks the current pathname before running the generic eject", () => {+ expect(window.location.href).toContain("://")++ render(createElement(ServerLayout, null, createElement("div")))++ expect(mocks.communityServerId).toHaveBeenCalledWith(window.location.pathname)+ expect(mocks.communityServerId).not.toHaveBeenCalledWith(window.location.href)+ expect(mocks.runEject).toHaveBeenCalledOnce()+ })++ it("passes the authenticated leaf and target-specific revoke facts to generic eject", () => {+ mocks.serverListSuccess.current = false+ mocks.serverListFetching.current = true+ mocks.serverAccessRevoked.current = true+ mocks.runEject.mockImplementation((args: {+ replace: (destination: string) => void+ }) => {args.replace("/c/me/machines")return true})- })- it("passes authenticated account and exact leaf to the authoritative eject owner", () => {render(createElement(ServerLayout, null, createElement("div")))expect(mocks.runEject).toHaveBeenCalledWith(expect.objectContaining({serverId: "missing-server",accountId: "viewer-1",routeHref: "/c/channels/missing-server/missing-channel",+ isSuccess: true,+ isFetching: false,}))expect(mocks.cancelPendingNavigation).toHaveBeenCalledTimes(1)expect(mocks.replace).toHaveBeenCalledWith("/c/me/machines")+ expect(mocks.registerRoute).toHaveBeenCalledWith("missing-server", mocks.routeToken)})- it("treats a target-specific access revoke as definitive while the list read is retired", () => {- mocks.serverListSuccess.current = false- mocks.serverListFetching.current = true- mocks.serverAccessRevoked.current = true+ it("suppresses optimistic/list eject and replaces directly to the survivor Channel leaf", async () => {+ mocks.servers.current = [+ { id: "missing-server" },+ { id: "surviving-server" },+ ]+ mocks.serverDetails.set("surviving-server", {+ categories: [{ channels: [+ { id: "channel-default" },+ { id: "channel-remembered" },+ ] }],+ })+ mocks.lastChannels.set("surviving-server", "channel-remembered")+ mocks.runEject.mockImplementation((args: {+ ownerDeleteRouteProtected?: boolean+ servers: Array<{ id: string }>+ }) => !args.ownerDeleteRouteProtected+ && !args.servers.some((server) => server.id === "missing-server"))+ const rendered = render(createElement(ServerLayout, null, createElement("div")))++ await act(async () => mocks.deleteServerAction.current?.())+ const callbacks = mocks.deleteServer.mock.calls[0]![1] as {+ onSuccess: (needsNavigation?: boolean) => void+ }+ mocks.servers.current = [{ id: "surviving-server" }]+ rendered.rerender(createElement(ServerLayout, null, createElement("div")))+ expect(mocks.runEject).toHaveBeenLastCalledWith(expect.objectContaining({+ ownerDeleteRouteProtected: true,+ }))+ expect(mocks.useServer).toHaveBeenLastCalledWith(null)+ expect(rendered.getByTestId("owner-delete-pending-frame")).toBeInTheDocument()+ expect(mocks.replace).not.toHaveBeenCalled()++ await act(async () => callbacks.onSuccess())+ expect(mocks.claimNavigation).toHaveBeenCalledExactlyOnceWith(+ "missing-server",+ mocks.routeToken,+ "/c/channels/surviving-server/channel-remembered",+ )+ expect(mocks.replace).toHaveBeenCalledExactlyOnceWith(+ "/c/channels/surviving-server/channel-remembered",+ )+ expect(mocks.navigatePath).not.toHaveBeenCalled()+ expect(mocks.setCurrentServerId).not.toHaveBeenCalledWith(null)+ expect(mocks.toast).toHaveBeenCalledExactlyOnceWith("Server deleted")+ })+ it("replaces directly to /c/me when no Server survives", async () => {+ mocks.servers.current = [{ id: "missing-server" }]render(createElement(ServerLayout, null, createElement("div")))- expect(mocks.runEject).toHaveBeenCalledWith(expect.objectContaining({- serverId: "missing-server",- isSuccess: true,- isFetching: false,+ await act(async () => mocks.deleteServerAction.current?.())+ const callbacks = mocks.deleteServer.mock.calls[0]![1] as {+ onSuccess: (needsNavigation?: boolean) => void+ }+ mocks.servers.current = []+ await act(async () => callbacks.onSuccess())++ expect(mocks.claimNavigation).toHaveBeenCalledExactlyOnceWith(+ "missing-server",+ mocks.routeToken,+ "/c/me",+ )+ expect(mocks.replace).toHaveBeenCalledExactlyOnceWith("/c/me")+ expect(mocks.navigatePath).not.toHaveBeenCalled()+ })++ it("resolves a survivor leaf from the structural snapshot without waiting for a fetch", async () => {+ mocks.servers.current = [+ { id: "missing-server" },+ { id: "surviving-server" },+ ]+ mocks.structuralSnapshot.current = {+ servers: [{+ id: "surviving-server",+ channels: [{ id: "channel-structural" }],+ }],+ }+ render(createElement(ServerLayout, null, createElement("div")))++ await act(async () => mocks.deleteServerAction.current?.())+ const callbacks = mocks.deleteServer.mock.calls[0]![1] as {+ onSuccess: (needsNavigation?: boolean) => void+ }+ mocks.servers.current = [{ id: "surviving-server" }]+ await act(async () => callbacks.onSuccess())++ expect(mocks.queryClient.fetchQuery).not.toHaveBeenCalled()+ expect(mocks.claimNavigation).toHaveBeenCalledWith(+ "missing-server",+ mocks.routeToken,+ "/c/channels/surviving-server/channel-structural",+ )+ })++ it("keeps an already committed safe route without resolving or navigating", async () => {+ mocks.servers.current = [+ { id: "missing-server" },+ { id: "surviving-server" },+ ]+ render(createElement(ServerLayout, null, createElement("div")))++ await act(async () => mocks.deleteServerAction.current?.())+ const callbacks = mocks.deleteServer.mock.calls[0]![1] as {+ onSuccess: (needsNavigation?: boolean) => void+ }+ await act(async () => callbacks.onSuccess(false))++ expect(mocks.claimNavigation).not.toHaveBeenCalled()+ expect(mocks.replace).not.toHaveBeenCalled()+ expect(mocks.toast).toHaveBeenCalledExactlyOnceWith("Server deleted")+ expect(mocks.clearLastChannel).toHaveBeenCalledWith("missing-server")+ })++ it("drops a resolved target when the transaction claim loses to a safe commit", async () => {+ mocks.servers.current = [+ { id: "missing-server" },+ { id: "surviving-server" },+ ]+ mocks.serverDetails.set("surviving-server", {+ categories: [{ channels: [{ id: "channel-default" }] }],+ })+ mocks.claimNavigation.mockReturnValue(false)+ render(createElement(ServerLayout, null, createElement("div")))++ await act(async () => mocks.deleteServerAction.current?.())+ const callbacks = mocks.deleteServer.mock.calls[0]![1] as {+ onSuccess: (needsNavigation?: boolean) => void+ }+ await act(async () => callbacks.onSuccess())++ expect(mocks.claimNavigation).toHaveBeenCalledOnce()+ expect(mocks.replace).not.toHaveBeenCalled()+ })++ it("treats a deleted-Server route first committed after terminal cleanup as ordinary", () => {+ mocks.routeProtected.current = true+ mocks.registerRoute.mockImplementation(() => {+ mocks.routeProtected.current = false+ return "ordinary"+ })+ mocks.servers.current = [{ id: "surviving-server" }]+ mocks.runEject.mockImplementation((args: {+ ownerDeleteRouteProtected?: boolean+ replace: (destination: string) => void+ }) => {+ if (args.ownerDeleteRouteProtected) return false+ args.replace("/c/channels/surviving-server")+ return true+ })++ render(createElement(ServerLayout, null, createElement("div")))++ expect(mocks.registerRoute).toHaveBeenCalledWith("missing-server", mocks.routeToken)+ expect(mocks.runEject).toHaveBeenLastCalledWith(expect.objectContaining({+ ownerDeleteRouteProtected: false,+ }))+ expect(mocks.replace).toHaveBeenCalledExactlyOnceWith(+ "/c/channels/surviving-server",+ )+ })++ it("clears a failed delete without navigation and restores ordinary eject eligibility", async () => {+ mocks.servers.current = [+ { id: "missing-server" },+ { id: "surviving-server" },+ ]+ mocks.runEject.mockImplementation((args: {+ ownerDeleteRouteProtected?: boolean+ servers: Array<{ id: string }>+ replace: (destination: string) => void+ }) => {+ if (args.ownerDeleteRouteProtected+ || args.servers.some((server) => server.id === "missing-server")) return false+ args.replace("/c/channels/surviving-server")+ return true+ })+ const rendered = render(createElement(ServerLayout, null, createElement("div")))++ await act(async () => mocks.deleteServerAction.current?.())+ const callbacks = mocks.deleteServer.mock.calls[0]![1] as {+ onError: (error: Error) => void+ }+ mocks.servers.current = [{ id: "surviving-server" }]+ rendered.rerender(createElement(ServerLayout, null, createElement("div")))+ expect(mocks.replace).not.toHaveBeenCalled()++ const error = new Error("delete failed")+ await act(async () => callbacks.onError(error))+ mocks.servers.current = [+ { id: "missing-server" },+ { id: "surviving-server" },+ ]+ rendered.rerender(createElement(ServerLayout, null, createElement("div")))+ expect(mocks.replace).not.toHaveBeenCalled()+ expect(mocks.toastApiError).toHaveBeenCalledWith(error, "Failed to delete server")+ expect(mocks.useServer).toHaveBeenLastCalledWith("missing-server")++ mocks.servers.current = [{ id: "surviving-server" }]+ rendered.rerender(createElement(ServerLayout, null, createElement("div")))+ expect(mocks.runEject).toHaveBeenLastCalledWith(expect.objectContaining({+ ownerDeleteRouteProtected: false,}))+ expect(mocks.replace).toHaveBeenCalledExactlyOnceWith(+ "/c/channels/surviving-server",+ )})})diff --git a/src/web/src/app/c/channels/layout.tsx b/src/web/src/app/c/channels/layout.tsxindex ebb8c2b8d..910356873 100644--- a/src/web/src/app/c/channels/layout.tsx+++ b/src/web/src/app/c/channels/layout.tsx@@ -2,6 +2,7 @@import { useCallback, useEffect, useMemo, useRef, useState, type ReactNode } from "react"import { useParams, usePathname, useRouter, useSearchParams } from "next/navigation"+import { useQueryClient } from "@tanstack/react-query"import { toast } from "sonner"import { toastApiError } from "@/lib/api/client"import { markSwitch } from "@/lib/perf/switch-mark"@@ -9,12 +10,14 @@ import { Dialog, DialogContent } from "@/components/ui/dialog"import { ShellFrame } from "@/components/community/shell/shell-frame"import {channelHref,+ communityServerId,serverModalMarkerCleanupHref,serverRootHref,} from "@/lib/community/community-route"import { useBreakpoint } from "@/hooks/use-mobile"import { ChannelSidebarScope } from "@/components/community/channels/channel-sidebar-tree-owner"import { ChannelRoute } from "@/components/community/channels/channel-route"+import { CommunityPendingFrame } from "@/components/community/shell/community-pending-frame"import { ServerSettings } from "@/components/community/settings/server-settings"import { ImageCropDialog } from "@/components/community/image-crop-dialog"import { validateIconSourceFile } from "@/lib/community/image-crop"@@ -27,13 +30,27 @@ import {useCurrentChannelMeta,} from "@/stores/community"import { useCurrentUser } from "@/contexts/community/current-user"-import { useServer, useServers } from "@/hooks/community/use-servers"+import {+ useServer,+ useServers,+ serverProjectedQueryFn,+ type ServerDetail,+ type ServersResponse,+} from "@/hooks/community/use-servers"import { useServerMembers } from "@/hooks/community/use-server-members"import {+ claimOwnerServerDeleteNavigation,consumeVoluntaryLeave,+ createOwnerServerDeleteRouteToken,+ isOwnerServerDeleteRouteProtected,runAuthoritativeServerEject,} from "@/lib/community/eject-server"-import { clearLastChannel } from "@/lib/community/last-channel"+import {+ clearLastChannel,+ getLastChannel,+ pickServerLandingHref,+} from "@/lib/community/last-channel"+import { communityKeys } from "@/lib/query-keys"import { usePresence } from "@/hooks/community/use-server-panels"import {resolveForumSidebarRouteCandidate,@@ -75,10 +92,23 @@ export default function ServerLayout({ children }: { children: ReactNode }) {const pathname = usePathname()const serverId = decodeURIComponent(params.serverId)const routeChannelId = params.channelId ? decodeURIComponent(params.channelId) : null+ const ownerDeleteRouteIdentity = useMemo(+ () => ({+ serverId,+ token: createOwnerServerDeleteRouteToken(),+ }),+ [serverId],+ )+ const ownerDeleteRouteToken = ownerDeleteRouteIdentity.token+ const ownerDeleteRouteProtected = isOwnerServerDeleteRouteProtected(+ serverId,+ ownerDeleteRouteToken,+ )const hasChannel = !!routeChannelIdconst breakpoint = useBreakpoint()const router = useRouter()+ const queryClient = useQueryClient()const cancelPendingNavigation = useCallback(() => {useCommunityStore.getState().uiHandlers.cancelPendingNavigation?.()}, [])@@ -91,7 +121,7 @@ export default function ServerLayout({ children }: { children: ReactNode }) {() => structuralHintServer(structuralSnapshot, serverId),[serverId, structuralSnapshot],)- const { server: currentServer } = useServer(serverId)+ const { server: currentServer } = useServer(ownerDeleteRouteProtected ? null : serverId)const structuralTreeReady = hasStructuralServerTree(structuralServer)const sidebarCategories = useMemo(() => currentServer?.categories ?? (structuralTreeReady ? structuralServer?.categoriesView : undefined) ?? [],@@ -162,6 +192,31 @@ export default function ServerLayout({ children }: { children: ReactNode }) {return grouped}, [forumSidebar.threads])+ const serversList = useServers()+ const serverDestination = useCallback(async (id: string) => {+ const structural = structuralSnapshot?.servers.find((server) => server.id === id)+ const lastChannel = getLastChannel(id)+ let detail = queryClient.getQueryData<ServerDetail>(communityKeys.server(id))+ if (!detail && !lastChannel && !hasStructuralServerTree(structural)) {+ try {+ detail = await queryClient.fetchQuery({+ queryKey: communityKeys.server(id),+ queryFn: serverProjectedQueryFn(queryClient, id),+ staleTime: Infinity,+ })+ } catch {+ // The server landing route remains the safe fallback if its detail+ // cannot be resolved. Its ordinary loader owns retry/error handling.+ }+ }+ const channelIds = detail?.categories.flatMap((category) =>+ category.channels+ .filter((channel) => !channel.pending)+ .map((channel) => channel.id),+ ) ?? structural?.channels.map((channel) => channel.id) ?? []+ return pickServerLandingHref(id, channelIds, lastChannel)+ }, [queryClient, structuralSnapshot])+// Mutationsconst createChannelMut = useCreateChannel()const renameChannelMut = useRenameChannel()@@ -172,7 +227,31 @@ export default function ServerLayout({ children }: { children: ReactNode }) {const deleteCategoryMut = useDeleteCategory()const reorderCategoriesMut = useReorderCategories()const reorderChannelsMut = useReorderChannels()- const deleteServerMut = useDeleteServer()+ const deleteServerMut = useDeleteServer({+ routeToken: ownerDeleteRouteToken,+ onSuccess: ({ serverId: deletedServerId }, { needsNavigation }) => {+ toast("Server deleted")+ clearLastChannel(deletedServerId)+ if (!needsNavigation) return+ void (async () => {+ const servers = queryClient.getQueryData<ServersResponse>(+ communityKeys.servers(),+ )?.servers ?? []+ const survivor = servers.find((server) => server.id !== deletedServerId)+ const destination = survivor+ ? await serverDestination(survivor.id)+ : "/c/me"+ if (!claimOwnerServerDeleteNavigation(+ deletedServerId,+ ownerDeleteRouteToken,+ destination,+ )) return+ cancelPendingNavigation()+ router.replace(destination)+ })()+ },+ onError: (error) => toastApiError(error, "Failed to delete server"),+ })const updateServerMut = useUpdateServer()const uploadServerIconMut = useUploadServerIcon()const setServerNotifMut = useSetServerNotifLevel()@@ -198,10 +277,11 @@ export default function ServerLayout({ children }: { children: ReactNode }) {// true after a first 5xx, while a failed background refetch may retain// last-good data; treating either as authoritative ejects valid URLs on a// transient read failure. The ref prevents a re-fire during navigation.- const serversList = useServers()const ejectedRef = useRef(false)useEffect(() => {if (ejectedRef.current) return+ if (typeof window !== "undefined"+ && communityServerId(window.location.pathname) !== serverId) returnejectedRef.current = runAuthoritativeServerEject({serverId,servers: serversList.servers,@@ -209,6 +289,7 @@ export default function ServerLayout({ children }: { children: ReactNode }) {// target advanced the access epoch and retired an in-flight list read.isSuccess: serverAccessRevoked || serversList.isSuccess,isFetching: serverAccessRevoked ? false : serversList.isFetching,+ ownerDeleteRouteProtected: isOwnerServerDeleteRouteProtected(serverId),consumeVoluntaryLeave,clearLastChannel,toast,@@ -484,15 +565,7 @@ export default function ServerLayout({ children }: { children: ReactNode }) {onCopyInvite={(code) => { navigator.clipboard?.writeText(`${window.location.origin}/c/invite/${code}`); toast("Invite copied") }}onDeleteServer={async () => {closeSettings()- deleteServerMut.mutate({ serverId }, {- onSuccess: () => {- toast("Server deleted")- useCommunityStore.getState().setCurrentServerId(null)- cancelPendingNavigation()- useCommunityStore.getState().uiHandlers.navigatePath?.("/c/me")- },- onError: (e) => toastApiError(e, "Failed to delete server"),- })+ deleteServerMut.mutate({ serverId })}}onUploadIcon={() => {const input = document.createElement("input")@@ -549,7 +622,9 @@ export default function ServerLayout({ children }: { children: ReactNode }) {const structuralFrameHref = routeChannelId? channelHref(serverId, routeChannelId): serverRootHref(serverId)- const content = routeChannelId+ const content = ownerDeleteRouteProtected+ ? <CommunityPendingFrame href={pathname} />+ : routeChannelId? (<ChannelRoutekey={`${serverId}/${routeChannelId}`}@@ -568,6 +643,7 @@ export default function ServerLayout({ children }: { children: ReactNode }) {extraDialogs={<>{serverSettingsDialog}{iconCropDialog}</>}onOpenActiveServerSettings={onSidebarOpenSettings}onOpenActiveServerInvite={onRailOpenActiveInvite}+ ownerDeleteRouteScope={ownerDeleteRouteIdentity}>{content}</ShellFrame>diff --git a/src/web/src/app/c/community-shell.identity.dom.test.ts b/src/web/src/app/c/community-shell.identity.dom.test.tsindex 1a28ed587..fc12f9117 100644--- a/src/web/src/app/c/community-shell.identity.dom.test.ts+++ b/src/web/src/app/c/community-shell.identity.dom.test.ts@@ -42,6 +42,9 @@ vi.mock("@/components/community/onboarding/community-onboarding-form", () => ({vi.mock("@/components/community/shell/community-ws-reconnect-overlay", () => ({CommunityWsReconnectBoundary: ({ children }: { children: React.ReactNode }) => children,}))+vi.mock("@/components/community/shell/owner-server-delete-route-guard", () => ({+ OwnerServerDeleteRouteGuard: () => null,+}))import { CommunityShell } from "./community-shell"diff --git a/src/web/src/app/c/community-shell.tsx b/src/web/src/app/c/community-shell.tsxindex d72116f64..69050f4c4 100644--- a/src/web/src/app/c/community-shell.tsx+++ b/src/web/src/app/c/community-shell.tsx@@ -14,6 +14,7 @@ import { PerfTraceBootstrap } from "@/components/perf/perf-trace-bootstrap"import { CommunityOnboardingForm } from "@/components/community/onboarding/community-onboarding-form"import { CommunityWsReconnectBoundary } from "@/components/community/shell/community-ws-reconnect-overlay"import { useCommunityWsStore } from "@/stores/community/ws"+import { OwnerServerDeleteRouteGuard } from "@/components/community/shell/owner-server-delete-route-guard"/*** Client wrapper that provides the QueryClient, CurrentUser, and the@@ -113,6 +114,7 @@ function CommunityBootstrap({ children }: { children: ReactNode }) {<><PerfTraceBootstrap /><CommunityWsReconnectBoundary>+ <OwnerServerDeleteRouteGuard /><CommunityOnboardingForm />{children}</CommunityWsReconnectBoundary>diff --git a/src/web/src/components/community/shell/owner-server-delete-route-guard.dom.test.tsx b/src/web/src/components/community/shell/owner-server-delete-route-guard.dom.test.tsxnew file mode 100644index 000000000..64e04dbfc--- /dev/null+++ b/src/web/src/components/community/shell/owner-server-delete-route-guard.dom.test.tsx@@ -0,0 +1,73 @@+import { createElement } from "react"+import { beforeEach, describe, expect, it, vi } from "vitest"+import { render } from "@/test/react-dom-harness"++const mocks = vi.hoisted(() => ({+ pathname: "/c/channels/deleted/channel-1",+ completed: true,+ runEject: vi.fn(() => true),+ replace: vi.fn(),+ getQueryData: vi.fn(() => ({ servers: [{ id: "survivor" }] })),+ getQueryState: vi.fn(() => ({ status: "success", fetchStatus: "idle" })),+ subscribe: vi.fn(),+}))++vi.mock("next/navigation", () => ({+ usePathname: () => mocks.pathname,+ useRouter: () => ({ replace: mocks.replace }),+}))+vi.mock("@tanstack/react-query", () => ({+ useQueryClient: () => ({+ getQueryData: mocks.getQueryData,+ getQueryState: mocks.getQueryState,+ getQueryCache: () => ({+ subscribe: mocks.subscribe,+ find: () => ({ queryHash: "servers" }),+ }),+ }),+}))+vi.mock("sonner", () => ({ toast: vi.fn() }))+vi.mock("@/contexts/community/current-user", () => ({+ useCurrentUser: () => ({ id: "viewer-1" }),+}))+vi.mock("@/lib/community/eject-server", () => ({+ consumeVoluntaryLeave: vi.fn(),+ isOwnerServerDeleteCompleted: () => mocks.completed,+ runAuthoritativeServerEject: mocks.runEject,+}))+vi.mock("@/lib/community/last-channel", () => ({ clearLastChannel: vi.fn() }))++import { OwnerServerDeleteRouteGuard } from "./owner-server-delete-route-guard"++describe("OwnerServerDeleteRouteGuard", () => {+ beforeEach(() => {+ mocks.pathname = "/c/channels/deleted/channel-1"+ mocks.completed = true+ mocks.runEject.mockClear()+ mocks.getQueryData.mockClear()+ mocks.getQueryState.mockClear()+ mocks.subscribe.mockReset()+ })++ it("rechecks a completed delete from cached server-list state without mounting a query observer", () => {+ render(createElement(OwnerServerDeleteRouteGuard))++ expect(mocks.runEject).toHaveBeenCalledWith(expect.objectContaining({+ serverId: "deleted",+ servers: [{ id: "survivor" }],+ isSuccess: true,+ isFetching: false,+ routeHref: "/c/channels/deleted/channel-1",+ }))+ expect(mocks.subscribe).not.toHaveBeenCalled()+ })++ it("does not touch the server-list cache for ordinary routes", () => {+ mocks.completed = false+ render(createElement(OwnerServerDeleteRouteGuard))++ expect(mocks.runEject).not.toHaveBeenCalled()+ expect(mocks.getQueryData).not.toHaveBeenCalled()+ expect(mocks.subscribe).not.toHaveBeenCalled()+ })+})diff --git a/src/web/src/components/community/shell/owner-server-delete-route-guard.tsx b/src/web/src/components/community/shell/owner-server-delete-route-guard.tsxnew file mode 100644index 000000000..f4cff0ced--- /dev/null+++ b/src/web/src/components/community/shell/owner-server-delete-route-guard.tsx@@ -0,0 +1,59 @@+"use client"++import { useEffect } from "react"+import { usePathname, useRouter } from "next/navigation"+import { useQueryClient } from "@tanstack/react-query"+import { toast } from "sonner"+import { useCurrentUser } from "@/contexts/community/current-user"+import type { ServersResponse } from "@/hooks/community/use-servers"+import { communityServerId } from "@/lib/community/community-route"+import {+ consumeVoluntaryLeave,+ isOwnerServerDeleteCompleted,+ runAuthoritativeServerEject,+} from "@/lib/community/eject-server"+import { clearLastChannel } from "@/lib/community/last-channel"+import { communityKeys } from "@/lib/query-keys"++/** Rechecks cached deleted-server history entries from the persistent `/c` tree. */+export function OwnerServerDeleteRouteGuard() {+ const pathname = usePathname()+ const router = useRouter()+ const queryClient = useQueryClient()+ const currentUser = useCurrentUser()++ useEffect(() => {+ const serverId = communityServerId(pathname)+ if (!serverId || !isOwnerServerDeleteCompleted(serverId)) return++ const eject = () => {+ const key = communityKeys.servers()+ const state = queryClient.getQueryState(key)+ const servers = queryClient.getQueryData<ServersResponse>(key)?.servers ?? []+ return runAuthoritativeServerEject({+ serverId,+ servers,+ isSuccess: state?.status === "success",+ isFetching: state?.fetchStatus === "fetching",+ consumeVoluntaryLeave,+ clearLastChannel,+ toast,+ accountId: currentUser.id,+ routeHref: pathname,+ replace: (destination) => router.replace(destination),+ })+ }++ if (eject()) return+ const unsubscribe = queryClient.getQueryCache().subscribe((event) => {+ if (event.query.queryHash !== queryClient.getQueryCache().find({+ queryKey: communityKeys.servers(),+ exact: true,+ })?.queryHash) return+ if (eject()) unsubscribe()+ })+ return unsubscribe+ }, [currentUser.id, pathname, queryClient, router])++ return null+}diff --git a/src/web/src/components/community/shell/shell-frame-types.ts b/src/web/src/components/community/shell/shell-frame-types.tsindex c0cc21242..b06136dc0 100644--- a/src/web/src/components/community/shell/shell-frame-types.ts+++ b/src/web/src/components/community/shell/shell-frame-types.ts@@ -1,4 +1,5 @@import type { ReactNode } from "react"+import type { OwnerServerDeleteRouteToken } from "@/lib/community/eject-server"import type { View } from "./shell-types"export type ShellFrameProps = {@@ -10,6 +11,10 @@ export type ShellFrameProps = {extraDialogs?: ReactNodeonOpenActiveServerSettings?: () => voidonOpenActiveServerInvite?: () => void+ ownerDeleteRouteScope?: {+ serverId: string+ token: OwnerServerDeleteRouteToken+ }}export type ShellRouter = {diff --git a/src/web/src/components/community/shell/shell-frame.dom.test.ts b/src/web/src/components/community/shell/shell-frame.dom.test.tsindex 1b9235e48..28d8d62a2 100644--- a/src/web/src/components/community/shell/shell-frame.dom.test.ts+++ b/src/web/src/components/community/shell/shell-frame.dom.test.ts@@ -4,6 +4,7 @@ import { render } from "@/test/react-dom-harness"import { ShellFrame } from "./shell-frame"const mocks = vi.hoisted(() => {+ const serverCache = new Set<string>()const handlers = {previewImage: vi.fn(),previewAttachment: vi.fn(),@@ -15,13 +16,21 @@ const mocks = vi.hoisted(() => {currentHref: { current: "/c/channels/s1" },pendingHref: { current: null as string | null },navigationPending: { current: false },- serverCache: new Set<string>(),+ serverCache,+ queryClient: {+ getQueryData: (key: unknown[]) => serverCache.has(String(key.at(-1)))+ ? { id: key.at(-1) }+ : undefined,+ },structuralSnapshot: { current: null as null | Record<string, unknown> },breakpoint: { current: "desktop" },onboardingState: { current: null as Record<string, unknown> | null },replace: vi.fn(),push: vi.fn(),registerUiHandlers: vi.fn(),+ observeOwnerDelete: vi.fn(),+ registerOwnerDelete: vi.fn(() => "ordinary"),+ flushOwnerDelete: vi.fn(),handlers,rail: {railProps: {},@@ -48,11 +57,14 @@ const mocks = vi.hoisted(() => {})vi.mock("@tanstack/react-query", () => ({- useQueryClient: () => ({- getQueryData: (key: unknown[]) => mocks.serverCache.has(String(key.at(-1)))- ? { id: key.at(-1) }- : undefined,- }),+ useQueryClient: () => mocks.queryClient,+}))+vi.mock("@/hooks/community/community-ws/scope-eviction", () => ({+ flushOwnerServerDeleteRouteCommit: (...args: unknown[]) => mocks.flushOwnerDelete(...args),+}))+vi.mock("@/lib/community/eject-server", () => ({+ observeOwnerServerDeleteRouteCommit: (...args: unknown[]) => mocks.observeOwnerDelete(...args),+ registerOwnerServerDeleteRoute: (...args: unknown[]) => mocks.registerOwnerDelete(...args),}))vi.mock("@/hooks/use-mobile", () => ({ useBreakpoint: () => mocks.breakpoint.current }))vi.mock("@/lib/community-onboarding", () => ({@@ -136,6 +148,9 @@ describe("ShellFrame orchestration", () => {mocks.breakpoint.current = "desktop"mocks.onboardingState.current = nullmocks.registerUiHandlers.mockClear()+ mocks.observeOwnerDelete.mockClear()+ mocks.registerOwnerDelete.mockClear()+ mocks.flushOwnerDelete.mockClear()mocks.replace.mockClear()mocks.push.mockClear()mocks.railOptions.mockClear()@@ -167,6 +182,28 @@ describe("ShellFrame orchestration", () => {frameHref: "/c/channels/s1/c2",}))expect(checkpoint().mode).toBe("committed")+ expect(mocks.observeOwnerDelete).toHaveBeenLastCalledWith("/c/channels/s1/c2")+ expect(mocks.flushOwnerDelete).toHaveBeenLastCalledWith(+ mocks.queryClient,+ )+ expect(mocks.observeOwnerDelete.mock.invocationCallOrder.at(-1)).toBeLessThan(+ mocks.flushOwnerDelete.mock.invocationCallOrder.at(-1) ?? 0,+ )+ })++ it("registers the route token at the same committed-frame boundary", () => {+ const token = {}+ mocks.registerOwnerDelete.mockReturnValueOnce("participant")++ render(createElement(ShellFrame, {+ ...baseProps,+ ownerDeleteRouteScope: { serverId: "s1", token },+ }))++ expect(mocks.registerOwnerDelete).toHaveBeenCalledWith("s1", token)+ expect(mocks.registerOwnerDelete.mock.invocationCallOrder[0]).toBeLessThan(+ mocks.observeOwnerDelete.mock.invocationCallOrder[0] ?? 0,+ )})it("keeps the committed surface until exact frame evidence arrives", () => {diff --git a/src/web/src/components/community/shell/shell-frame.tsx b/src/web/src/components/community/shell/shell-frame.tsxindex ddeb7e8b0..6f5206d4b 100644--- a/src/web/src/components/community/shell/shell-frame.tsx+++ b/src/web/src/components/community/shell/shell-frame.tsx@@ -30,6 +30,11 @@ import {userBarExtensionReducer,} from "./user-bar-extension-state"import { useShellDaemonUpdateController } from "./use-shell-daemon-update-controller"+import { flushOwnerServerDeleteRouteCommit } from "@/hooks/community/community-ws/scope-eviction"+import {+ observeOwnerServerDeleteRouteCommit,+ registerOwnerServerDeleteRoute,+} from "@/lib/community/eject-server"/** Shared community shell orchestration for the server and DM layouts. */export function ShellFrame(props: ShellFrameProps) {@@ -42,6 +47,7 @@ export function ShellFrame(props: ShellFrameProps) {extraDialogs,onOpenActiveServerSettings,onOpenActiveServerInvite,+ ownerDeleteRouteScope,} = propsconst queryClient = useQueryClient()const currentUser = useCurrentUser()@@ -62,7 +68,19 @@ export function ShellFrame(props: ShellFrameProps) {committedFrameRef.current = nextsetCommittedFrame(next)}, [])- useLayoutEffect(() => commitFrame(frameHref), [commitFrame, frameHref])+ useLayoutEffect(() => {+ commitFrame(frameHref)+ if (ownerDeleteRouteScope) {+ registerOwnerServerDeleteRoute(+ ownerDeleteRouteScope.serverId,+ ownerDeleteRouteScope.token,+ )+ }+ observeOwnerServerDeleteRouteCommit(frameHref)+ }, [commitFrame, frameHref, ownerDeleteRouteScope])+ useEffect(() => {+ flushOwnerServerDeleteRouteCommit(queryClient)+ }, [frameHref, queryClient])const navigation = useCommunityNavigationController(committedFrame)const replacePath = navigation.replaceconst route = resolveCommunityRoute(committedFrame.pathname)diff --git a/src/web/src/hooks/community/community-ws/scope-eviction.test.ts b/src/web/src/hooks/community/community-ws/scope-eviction.test.tsnew file mode 100644index 000000000..c516be1b1--- /dev/null+++ b/src/web/src/hooks/community/community-ws/scope-eviction.test.ts@@ -0,0 +1,124 @@+import { QueryClient } from "@tanstack/react-query"+import { beforeEach, describe, expect, it, vi } from "vitest"+import { communityKeys } from "@/lib/query-keys"+import {+ beginOwnerServerDelete,+ cancelOwnerServerDelete,+ commitOwnerServerDelete,+ createOwnerServerDeleteRouteToken,+ isOwnerServerDeleteRouteProtected,+ observeOwnerServerDeleteRouteCommit,+} from "@/lib/community/eject-server"+import {+ evictServerChannelScopes,+ flushOwnerServerDeleteAfterSuccess,+ flushOwnerServerDeleteRouteCommit,+} from "./scope-eviction"++describe("owner-delete scope eviction", () => {+ const deletedServerId = "srv_owner_deleted"+ const otherServerId = "srv_other"++ beforeEach(() => {+ cancelOwnerServerDelete(deletedServerId)+ cancelOwnerServerDelete(otherServerId)+ })++ it("merges mutation and WS eviction until one safe route commit flushes once", () => {+ const queryClient = new QueryClient()+ queryClient.setQueryData(communityKeys.server(deletedServerId), {+ id: deletedServerId,+ categories: [],+ })+ const removeQueries = vi.spyOn(queryClient, "removeQueries")+ const token = createOwnerServerDeleteRouteToken()++ beginOwnerServerDelete(deletedServerId, token)+ expect(evictServerChannelScopes(queryClient, deletedServerId)).toBe(false)+ expect(commitOwnerServerDelete(deletedServerId, token)).toBe(false)+ expect(evictServerChannelScopes(queryClient, deletedServerId)).toBe(false)+ expect(queryClient.getQueryState(communityKeys.server(deletedServerId))).toBeDefined()++ expect(observeOwnerServerDeleteRouteCommit(+ `/c/channels/${deletedServerId}/channel-1`,+ )).toEqual([])+ expect(flushOwnerServerDeleteRouteCommit(queryClient)).toEqual([])++ expect(observeOwnerServerDeleteRouteCommit("/c/me")).toEqual([deletedServerId])+ expect(flushOwnerServerDeleteRouteCommit(queryClient)).toEqual([deletedServerId])+ expect(queryClient.getQueryState(communityKeys.server(deletedServerId))).toBeUndefined()+ expect(removeQueries).toHaveBeenCalledTimes(1)+ expect(isOwnerServerDeleteRouteProtected(deletedServerId)).toBe(false)+ expect(isOwnerServerDeleteRouteProtected(deletedServerId, token)).toBe(true)++ expect(evictServerChannelScopes(queryClient, deletedServerId)).toBe(false)+ expect(flushOwnerServerDeleteRouteCommit(queryClient)).toEqual([])+ expect(removeQueries).toHaveBeenCalledTimes(1)+ })++ it("keeps unrelated Servers immediate and releases a cancelled attempt", () => {+ const queryClient = new QueryClient()+ queryClient.setQueryData(communityKeys.server(deletedServerId), {+ id: deletedServerId,+ categories: [],+ })+ queryClient.setQueryData(communityKeys.server(otherServerId), {+ id: otherServerId,+ categories: [],+ })+ const token = createOwnerServerDeleteRouteToken()++ beginOwnerServerDelete(deletedServerId, token)+ expect(evictServerChannelScopes(queryClient, otherServerId)).toBe(true)+ expect(queryClient.getQueryState(communityKeys.server(otherServerId))).toBeUndefined()+ expect(queryClient.getQueryState(communityKeys.server(deletedServerId))).toBeDefined()++ cancelOwnerServerDelete(deletedServerId, token)+ expect(evictServerChannelScopes(queryClient, deletedServerId)).toBe(true)+ expect(queryClient.getQueryState(communityKeys.server(deletedServerId))).toBeUndefined()+ })++ it("flushes immediately when success follows an already-safe commit", () => {+ const queryClient = new QueryClient()+ queryClient.setQueryData(communityKeys.server(deletedServerId), {+ id: deletedServerId,+ categories: [],+ })+ const removeQueries = vi.spyOn(queryClient, "removeQueries")+ const token = createOwnerServerDeleteRouteToken()++ beginOwnerServerDelete(deletedServerId, token)+ expect(observeOwnerServerDeleteRouteCommit("/c/me")).toEqual([])+ expect(commitOwnerServerDelete(deletedServerId, token)).toBe(true)+ expect(flushOwnerServerDeleteAfterSuccess(queryClient, deletedServerId)).toBe(true)++ expect(queryClient.getQueryState(communityKeys.server(deletedServerId))).toBeUndefined()+ expect(removeQueries).toHaveBeenCalledTimes(1)+ expect(flushOwnerServerDeleteAfterSuccess(queryClient, deletedServerId)).toBe(false)+ expect(flushOwnerServerDeleteRouteCommit(queryClient)).toEqual([])+ expect(removeQueries).toHaveBeenCalledTimes(1)+ })++ it("uses the latest committed route fact at DELETE success", () => {+ const queryClient = new QueryClient()+ queryClient.setQueryData(communityKeys.server(deletedServerId), {+ id: deletedServerId,+ categories: [],+ })+ const removeQueries = vi.spyOn(queryClient, "removeQueries")+ const token = createOwnerServerDeleteRouteToken()++ beginOwnerServerDelete(deletedServerId, token)+ observeOwnerServerDeleteRouteCommit("/c/me")+ observeOwnerServerDeleteRouteCommit(+ `/c/channels/${deletedServerId}/channel-1`,+ )+ expect(commitOwnerServerDelete(deletedServerId, token)).toBe(false)+ expect(flushOwnerServerDeleteAfterSuccess(queryClient, deletedServerId)).toBe(false)+ expect(removeQueries).not.toHaveBeenCalled()++ expect(observeOwnerServerDeleteRouteCommit("/c/me")).toEqual([deletedServerId])+ expect(flushOwnerServerDeleteRouteCommit(queryClient)).toEqual([deletedServerId])+ expect(removeQueries).toHaveBeenCalledTimes(1)+ })+})diff --git a/src/web/src/hooks/community/community-ws/scope-eviction.ts b/src/web/src/hooks/community/community-ws/scope-eviction.tsindex 26914f28d..352ca3528 100644--- a/src/web/src/hooks/community/community-ws/scope-eviction.ts+++ b/src/web/src/hooks/community/community-ws/scope-eviction.ts@@ -5,6 +5,13 @@ import { useCommunityStore } from "@/stores/community"import { useMessageStreamStore } from "@/stores/community/message-stream"import { clearTypingIndicator } from "./typing"import { updateStructuralSnapshot } from "@/lib/community/structural-snapshot"+import {+ claimOwnerServerDeleteScopeFlush,+ completeOwnerServerDeleteScopeFlush,+ isOwnerServerDeleteScopeFlushReady,+ isOwnerServerDeleteScopeEvictionBlocked,+ ownerServerDeleteScopeFlushCandidates,+} from "@/lib/community/eject-server"type ThreadPageLike = {serverId?: string@@ -101,7 +108,7 @@ export function evictScopeContent(}}-export function evictServerChannelScopes(queryClient: QueryClient, serverId: string) {+function evictServerChannelScopesNow(queryClient: QueryClient, serverId: string) {useCommunityWsStore.getState().revokeServerAccess(serverId)for (const id of collectChannelScopeIds(queryClient, serverId)) {evictScopeContent(queryClient, serverId, id)@@ -123,3 +130,40 @@ export function evictServerChannelScopes(queryClient: QueryClient, serverId: str}updateStructuralSnapshot(queryClient, { type: "removeServer", serverId })}++export function evictServerChannelScopes(queryClient: QueryClient, serverId: string): boolean {+ if (isOwnerServerDeleteScopeEvictionBlocked(serverId)) return false+ evictServerChannelScopesNow(queryClient, serverId)+ return true+}++function flushOwnerServerDeleteScopes(+ queryClient: QueryClient,+ serverIds: readonly string[],+): string[] {+ const flushed: string[] = []+ for (const serverId of serverIds) {+ if (!isOwnerServerDeleteScopeFlushReady(serverId)) continue+ if (!claimOwnerServerDeleteScopeFlush(serverId)) continue+ evictServerChannelScopesNow(queryClient, serverId)+ if (!completeOwnerServerDeleteScopeFlush(serverId)) continue+ flushed.push(serverId)+ }+ return flushed+}++export function flushOwnerServerDeleteAfterSuccess(+ queryClient: QueryClient,+ serverId: string,+): boolean {+ return flushOwnerServerDeleteScopes(queryClient, [serverId]).length === 1+}++export function flushOwnerServerDeleteRouteCommit(+ queryClient: QueryClient,+): string[] {+ return flushOwnerServerDeleteScopes(+ queryClient,+ ownerServerDeleteScopeFlushCandidates(),+ )+}diff --git a/src/web/src/hooks/community/mutations/servers.dom.test.tsx b/src/web/src/hooks/community/mutations/servers.dom.test.tsxnew file mode 100644index 000000000..50a877d2f--- /dev/null+++ b/src/web/src/hooks/community/mutations/servers.dom.test.tsx@@ -0,0 +1,177 @@+import React from "react"+import { QueryClient, QueryClientProvider } from "@tanstack/react-query"+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest"+import { act, renderHook, waitFor } from "@/test/react-dom-harness"+import { communityKeys } from "@/lib/query-keys"+import {+ cancelOwnerServerDelete,+ claimOwnerServerDeleteNavigation,+ claimOwnerServerDeleteScopeFlush,+ completeOwnerServerDeleteScopeFlush,+ createOwnerServerDeleteRouteToken,+ isOwnerServerDeleteRouteProtected,+ observeOwnerServerDeleteRouteCommit,+} from "@/lib/community/eject-server"+import { useDeleteServer } from "./servers"++const mocks = vi.hoisted(() => ({+ api: vi.fn(),+ evictServerChannelScopes: vi.fn(),+ flushOwnerServerDeleteAfterSuccess: vi.fn(),+}))++vi.mock("@/lib/api/client", () => ({+ apiFetch: mocks.api,+ readUploadError: vi.fn(),+}))++vi.mock("@/hooks/community/community-ws/scope-eviction", () => ({+ evictServerChannelScopes: mocks.evictServerChannelScopes,+ flushOwnerServerDeleteAfterSuccess: mocks.flushOwnerServerDeleteAfterSuccess,+}))++type Deferred<T> = {+ promise: Promise<T>+ resolve: (value: T) => void+ reject: (error: unknown) => void+}++function deferred<T>(): Deferred<T> {+ let resolve!: (value: T) => void+ let reject!: (error: unknown) => void+ const promise = new Promise<T>((resolvePromise, rejectPromise) => {+ resolve = resolvePromise+ reject = rejectPromise+ })+ return { promise, resolve, reject }+}++function setup(+ serverId: string,+ callbacks: Parameters<typeof useDeleteServer>[0],+) {+ const client = new QueryClient({+ defaultOptions: { queries: { retry: false }, mutations: { retry: false } },+ })+ client.setQueryData(communityKeys.servers(), {+ servers: [{ id: serverId }],+ })+ const wrapper = ({ children }: { children: React.ReactNode }) => (+ <QueryClientProvider client={client}>{children}</QueryClientProvider>+ )+ return {+ client,+ ...renderHook(+ ({ activeCallbacks }) => useDeleteServer(activeCallbacks),+ { initialProps: { activeCallbacks: callbacks }, wrapper },+ ),+ }+}++describe("useDeleteServer — unmounted caller", () => {+ const serverIds = [+ "srv_unmounted_success",+ "srv_unmounted_failure",+ "srv_rerendered_success",+ ]++ beforeEach(() => {+ mocks.api.mockReset()+ mocks.evictServerChannelScopes.mockReset()+ mocks.flushOwnerServerDeleteAfterSuccess.mockReset()+ for (const serverId of serverIds) cancelOwnerServerDelete(serverId)+ })++ afterEach(() => {+ for (const serverId of serverIds) cancelOwnerServerDelete(serverId)+ })++ it("keeps the successful navigation handoff after the calling component unmounts", async () => {+ const serverId = serverIds[0]+ const request = deferred<void>()+ const onSuccess = vi.fn()+ const routeToken = createOwnerServerDeleteRouteToken()+ mocks.api.mockReturnValueOnce(request.promise)+ const view = setup(serverId, { routeToken, onSuccess })++ act(() => view.result.current.mutate({ serverId }))+ await waitFor(() => {+ expect(mocks.api).toHaveBeenCalledOnce()+ expect(view.client.getQueryData<{ servers: unknown[] }>(+ communityKeys.servers(),+ )?.servers).toEqual([])+ expect(isOwnerServerDeleteRouteProtected(serverId)).toBe(true)+ })+ view.unmount()++ request.resolve(undefined)+ await waitFor(() => expect(onSuccess).toHaveBeenCalledOnce())+ expect(onSuccess).toHaveBeenCalledWith({ serverId }, { needsNavigation: true })+ expect(isOwnerServerDeleteRouteProtected(serverId)).toBe(true)+ expect(claimOwnerServerDeleteNavigation(serverId, routeToken, "/c/me")).toBe(true)++ observeOwnerServerDeleteRouteCommit("/c/me")+ expect(claimOwnerServerDeleteScopeFlush(serverId)).toBe(true)+ expect(completeOwnerServerDeleteScopeFlush(serverId)).toBe(true)+ expect(isOwnerServerDeleteRouteProtected(serverId)).toBe(false)+ expect(isOwnerServerDeleteRouteProtected(serverId, routeToken)).toBe(true)+ })++ it("rolls back and clears coordination before reporting an unmounted failure", async () => {+ const serverId = serverIds[1]+ const request = deferred<void>()+ const failure = new Error("delete failed")+ const routeToken = createOwnerServerDeleteRouteToken()+ const clientRef: { current: QueryClient | null } = { current: null }+ const onError = vi.fn(() => {+ expect(clientRef.current?.getQueryData<{ servers: Array<{ id: string }> }>(+ communityKeys.servers(),+ )?.servers).toEqual([{ id: serverId }])+ expect(isOwnerServerDeleteRouteProtected(serverId)).toBe(false)+ })+ mocks.api.mockReturnValueOnce(request.promise)+ const view = setup(serverId, { routeToken, onError })+ clientRef.current = view.client++ act(() => view.result.current.mutate({ serverId }))+ await waitFor(() => {+ expect(mocks.api).toHaveBeenCalledOnce()+ expect(isOwnerServerDeleteRouteProtected(serverId)).toBe(true)+ })+ view.unmount()++ request.reject(failure)+ await waitFor(() => expect(onError).toHaveBeenCalledOnce())+ expect(onError).toHaveBeenCalledWith(failure, { serverId })+ observeOwnerServerDeleteRouteCommit("/c/me")+ expect(claimOwnerServerDeleteScopeFlush(serverId)).toBe(false)+ expect(isOwnerServerDeleteRouteProtected(serverId, routeToken)).toBe(false)+ })++ it("finishes with the originating token and callback after the route layout rerenders", async () => {+ const serverId = serverIds[2]+ const request = deferred<void>()+ const originToken = createOwnerServerDeleteRouteToken()+ const survivorToken = createOwnerServerDeleteRouteToken()+ const originSuccess = vi.fn()+ const survivorSuccess = vi.fn()+ mocks.api.mockReturnValueOnce(request.promise)+ const view = setup(serverId, { routeToken: originToken, onSuccess: originSuccess })++ act(() => view.result.current.mutate({ serverId }))+ await waitFor(() => expect(isOwnerServerDeleteRouteProtected(serverId)).toBe(true))+ observeOwnerServerDeleteRouteCommit("/c/channels/survivor/channel-1")+ view.rerender({+ activeCallbacks: { routeToken: survivorToken, onSuccess: survivorSuccess },+ })++ request.resolve(undefined)+ await waitFor(() => expect(originSuccess).toHaveBeenCalledOnce())+ expect(originSuccess).toHaveBeenCalledWith({ serverId }, { needsNavigation: false })+ expect(survivorSuccess).not.toHaveBeenCalled()+ expect(mocks.flushOwnerServerDeleteAfterSuccess).toHaveBeenCalledWith(+ view.client,+ serverId,+ )+ })+})diff --git a/src/web/src/hooks/community/mutations/servers.test.ts b/src/web/src/hooks/community/mutations/servers.test.tsindex c1d3b7b9f..a92102231 100644--- a/src/web/src/hooks/community/mutations/servers.test.ts+++ b/src/web/src/hooks/community/mutations/servers.test.ts@@ -113,7 +113,10 @@ describe("useLeaveServer — optimistic + rollback", () => {apiFetchMock.mockRejectedValueOnce(new Error("boom"))const mod = await load()if (operation === "leave") mod.useLeaveServer()- else mod.useDeleteServer()+ else {+ const lifecycle = await import("@/lib/community/eject-server")+ mod.useDeleteServer({ routeToken: lifecycle.createOwnerServerDeleteRouteToken() })+ }await runMutation({ serverId: "srv_1" }).catch(() => {})const cache = capturedQc.getQueryData<{ servers: { id: string }[] }>(communityKeys.servers())expect(cache?.servers).toHaveLength(1)@@ -152,9 +155,23 @@ describe("useLeaveServer — optimistic + rollback", () => {categories: [],})if (operation === "leave") mod.useLeaveServer()- else mod.useDeleteServer()+ else {+ const lifecycle = await import("@/lib/community/eject-server")+ mod.useDeleteServer({ routeToken: lifecycle.createOwnerServerDeleteRouteToken() })+ }await runMutation({ serverId: "srv_1" })+ if (operation === "delete") {+ expect(useCommunityStore.getState().currentServerId).toBe("srv_1")+ const { flushOwnerServerDeleteRouteCommit } = await import(+ "@/hooks/community/community-ws/scope-eviction"+ )+ const { observeOwnerServerDeleteRouteCommit } = await import(+ "@/lib/community/eject-server"+ )+ expect(observeOwnerServerDeleteRouteCommit("/c/me")).toEqual(["srv_1"])+ expect(flushOwnerServerDeleteRouteCommit(capturedQc)).toEqual(["srv_1"])+ }expect(useCommunityStore.getState()).toMatchObject({currentServerId: null,@@ -167,10 +184,123 @@ describe("useLeaveServer — optimistic + rollback", () => {expect(capturedQc.getQueryData<{serverOrder: string[]}>(communityKeys.structuralSnapshot())?.serverOrder).toEqual([])+ if (operation === "delete") {+ const lifecycle = await import("@/lib/community/eject-server")+ expect(lifecycle.isOwnerServerDeleteRouteProtected("srv_1")).toBe(false)+ }},)})+describe("useDeleteServer — navigation lifecycle", () => {+ it("reports zero navigation and flushes once when a safe route committed before success", async () => {+ const args = { serverId: "srv_delete_after_safe_commit" }+ capturedQc.setQueryData(communityKeys.servers(), {+ servers: [{ id: args.serverId }],+ })+ capturedQc.setQueryData(communityKeys.server(args.serverId), {+ id: args.serverId,+ categories: [],+ })+ apiFetchMock.mockResolvedValueOnce(undefined)+ const mod = await load()+ const lifecycle = await import("@/lib/community/eject-server")+ const routeToken = lifecycle.createOwnerServerDeleteRouteToken()+ const onSuccess = vi.fn()+ mod.useDeleteServer({ routeToken, onSuccess })+ const { flushOwnerServerDeleteRouteCommit } = await import(+ "@/hooks/community/community-ws/scope-eviction"+ )+ lifecycle.cancelOwnerServerDelete(args.serverId)+ const removeQueries = vi.spyOn(capturedQc, "removeQueries")+ const cfg = capturedConfig as MutConfig<typeof args, unknown>++ const context = await cfg.onMutate?.(args)+ expect(lifecycle.observeOwnerServerDeleteRouteCommit("/c/me")).toEqual([])+ expect(flushOwnerServerDeleteRouteCommit(capturedQc)).toEqual([])+ expect(capturedQc.getQueryState(communityKeys.server(args.serverId))).toBeDefined()+ await cfg.mutationFn?.(args)+ cfg.onSuccess?.(undefined, args, context)++ expect(capturedQc.getQueryState(communityKeys.server(args.serverId))).toBeUndefined()+ expect(removeQueries).toHaveBeenCalledTimes(1)+ expect(onSuccess).toHaveBeenCalledWith(args, { needsNavigation: false })+ expect(flushOwnerServerDeleteRouteCommit(capturedQc)).toEqual([])+ expect(removeQueries).toHaveBeenCalledTimes(1)+ expect(lifecycle.isOwnerServerDeleteRouteProtected(args.serverId)).toBe(false)+ expect(lifecycle.isOwnerServerDeleteRouteProtected(args.serverId, routeToken)).toBe(true)+ })++ it("requests one navigation while the deleted route remains committed", async () => {+ const args = { serverId: "srv_delete" }+ capturedQc.setQueryData(communityKeys.servers(), {+ servers: [{ id: args.serverId }],+ })+ apiFetchMock.mockResolvedValueOnce(undefined)+ const mod = await load()+ const lifecycle = await import("@/lib/community/eject-server")+ const routeToken = lifecycle.createOwnerServerDeleteRouteToken()+ const onSuccess = vi.fn()+ mod.useDeleteServer({ routeToken, onSuccess })+ lifecycle.cancelOwnerServerDelete(args.serverId)+ const cfg = capturedConfig as MutConfig<typeof args, unknown>++ const context = await cfg.onMutate?.(args)+ expect(lifecycle.isOwnerServerDeleteRouteProtected(args.serverId)).toBe(true)+ expect(capturedQc.getQueryData<{ servers: unknown[] }>(+ communityKeys.servers(),+ )?.servers).toEqual([])+ await cfg.mutationFn?.(args)++ cfg.onSuccess?.(undefined, args, context)+ expect(onSuccess).toHaveBeenCalledWith(args, { needsNavigation: true })+ expect(lifecycle.claimOwnerServerDeleteNavigation(+ args.serverId,+ routeToken,+ "/c/me",+ )).toBe(true)+ const { flushOwnerServerDeleteRouteCommit } = await import(+ "@/hooks/community/community-ws/scope-eviction"+ )+ expect(lifecycle.observeOwnerServerDeleteRouteCommit("/c/me")).toEqual([+ args.serverId,+ ])+ expect(flushOwnerServerDeleteRouteCommit(capturedQc)).toEqual([+ args.serverId,+ ])+ expect(lifecycle.isOwnerServerDeleteRouteProtected(args.serverId)).toBe(false)+ expect(lifecycle.isOwnerServerDeleteRouteProtected(args.serverId, routeToken)).toBe(true)+ })++ it("restores the Server row and clears coordination after DELETE failure", async () => {+ const args = { serverId: "srv_delete_failed" }+ capturedQc.setQueryData(communityKeys.servers(), {+ servers: [{ id: args.serverId }],+ })+ const mod = await load()+ const lifecycle = await import("@/lib/community/eject-server")+ const routeToken = lifecycle.createOwnerServerDeleteRouteToken()+ const onError = vi.fn()+ mod.useDeleteServer({ routeToken, onError })+ lifecycle.cancelOwnerServerDelete(args.serverId)+ const cfg = capturedConfig as MutConfig<typeof args, unknown>++ const context = await cfg.onMutate?.(args)+ expect(lifecycle.isOwnerServerDeleteRouteProtected(args.serverId)).toBe(true)+ const failure = new Error("failed")+ cfg.onError?.(failure, args, context)++ expect(capturedQc.getQueryData<{ servers: Array<{ id: string }> }>(+ communityKeys.servers(),+ )?.servers).toEqual([{ id: args.serverId }])+ expect(onError).toHaveBeenCalledWith(failure, args)+ expect(lifecycle.isOwnerServerDeleteRouteProtected(args.serverId)).toBe(false)+ expect(lifecycle.isOwnerServerDeleteRouteProtected(args.serverId, routeToken)).toBe(false)+ lifecycle.observeOwnerServerDeleteRouteCommit("/c/me")+ expect(lifecycle.claimOwnerServerDeleteScopeFlush(args.serverId)).toBe(false)+ })+})+describe("useUpdateServer — rollback on both caches", () => {it("restores server-detail + servers-list on failure", async () => {seedStructuralSnapshot()diff --git a/src/web/src/hooks/community/mutations/servers.ts b/src/web/src/hooks/community/mutations/servers.tsindex a9e9d18e7..7d7e4ec46 100644--- a/src/web/src/hooks/community/mutations/servers.ts+++ b/src/web/src/hooks/community/mutations/servers.ts@@ -10,7 +10,16 @@ import {type AccountUnreadScopeToken,} from "@/hooks/community/account-unread-projection"import { updateStructuralSnapshot } from "@/lib/community/structural-snapshot"-import { evictServerChannelScopes } from "@/hooks/community/community-ws/scope-eviction"+import {+ evictServerChannelScopes,+ flushOwnerServerDeleteAfterSuccess,+} from "@/hooks/community/community-ws/scope-eviction"+import {+ beginOwnerServerDelete,+ cancelOwnerServerDelete,+ commitOwnerServerDelete,+ type OwnerServerDeleteRouteToken,+} from "@/lib/community/eject-server"/*** Server-scoped mutations. `create`/`join` invalidate the rail; `leave`/`delete`@@ -74,6 +83,14 @@ export function useJoinServer() {// ── Leave / delete server ──────────────────────────────────────────────────export type LeaveServerArgs = { serverId: string }+type DeleteServerCallbacks = {+ routeToken: OwnerServerDeleteRouteToken+ onSuccess?: (+ args: LeaveServerArgs,+ result: { needsNavigation: boolean },+ ) => void+ onError?: (error: Error, args: LeaveServerArgs) => void+}export function useLeaveServer() {const queryClient = useQueryClient()@@ -112,17 +129,21 @@ export function useLeaveServer() {})}-export function useDeleteServer() {+export function useDeleteServer(callbacks: DeleteServerCallbacks) {const queryClient = useQueryClient()const unreadProjection = getActiveAccountUnreadProjection(queryClient)return useMutation<void, Error, LeaveServerArgs, {snapshot: ServersResponse | undefinedtoken: AccountUnreadScopeToken+ routeToken: OwnerServerDeleteRouteToken+ onSuccess: DeleteServerCallbacks["onSuccess"]+ onError: DeleteServerCallbacks["onError"]}>({mutationFn: async ({ serverId }) => {await apiFetch(`/api/community/servers/${serverId}`, { method: "DELETE" })},onMutate: async (args) => {+ beginOwnerServerDelete(args.serverId, callbacks.routeToken)const key = communityKeys.servers()await queryClient.cancelQueries({ queryKey: key })const snapshot = queryClient.getQueryData<ServersResponse>(key)@@ -132,19 +153,29 @@ export function useDeleteServer() {return {snapshot,token: unreadProjection.beginScopeRetirement({ kind: "server", serverId: args.serverId }),+ routeToken: callbacks.routeToken,+ onSuccess: callbacks.onSuccess,+ onError: callbacks.onError,}},- onError: (_err, _args, ctx) => {+ onError: (error, args, ctx) => {if (ctx) unreadProjection.rollbackScopeRetirement(ctx.token)if (ctx?.snapshot) queryClient.setQueryData(communityKeys.servers(), ctx.snapshot)+ cancelOwnerServerDelete(args.serverId, ctx?.routeToken ?? callbacks.routeToken)+ const onError = ctx?.onError ?? callbacks.onError+ onError?.(error, args)},onSuccess: (_data, args, context) => {+ const scopeFlushReady = commitOwnerServerDelete(args.serverId, context.routeToken)unreadProjection.commitScopeRetirement(context.token)- evictServerChannelScopes(queryClient, args.serverId)+ if (scopeFlushReady) {+ flushOwnerServerDeleteAfterSuccess(queryClient, args.serverId)+ }void queryClient.invalidateQueries({queryKey: communityKeys.channelRefDirectory(),exact: true,})+ context.onSuccess?.(args, { needsNavigation: !scopeFlushReady })},})}diff --git a/src/web/src/lib/community/community-route.test.ts b/src/web/src/lib/community/community-route.test.tsindex 84029c2e0..f82f35fa8 100644--- a/src/web/src/lib/community/community-route.test.ts+++ b/src/web/src/lib/community/community-route.test.ts@@ -110,6 +110,12 @@ describe("community route", () => {expect(communityServerId(href)).toBe(serverId)})+ it("accepts a pathname but rejects an absolute URL at the parser boundary", () => {+ expect(communityServerId("/c/channels/server_1/channel_1")).toBe("server_1")+ expect(communityServerId("https://alook.local/c/channels/server_1/channel_1"))+ .toBeNull()+ })+it("normalizes query order and keeps structural scope independent from hash", () => {expect(normalizeCommunityHref("/c/channels/server_1/channel_1?z=2&a=1#message")).toEqual({diff --git a/src/web/src/lib/community/eject-server.test.ts b/src/web/src/lib/community/eject-server.test.tsindex d79a4a150..58a24c588 100644--- a/src/web/src/lib/community/eject-server.test.ts+++ b/src/web/src/lib/community/eject-server.test.ts@@ -1,16 +1,28 @@-import { describe, it, expect, vi } from "vitest"+import { beforeEach, describe, expect, it, vi } from "vitest"import {- markVoluntaryLeave,+ beginOwnerServerDelete,+ cancelOwnerServerDelete,+ claimOwnerServerDeleteNavigation,+ claimOwnerServerDeleteScopeFlush,+ commitOwnerServerDelete,+ completeOwnerServerDeleteScopeFlush,consumeVoluntaryLeave,+ createOwnerServerDeleteRouteToken,+ isDefinitiveChildMetaFailure,+ isOwnerServerDeleteCompleted,+ isOwnerServerDeleteRouteProtected,+ isOwnerServerDeleteScopeEvictionBlocked,+ markVoluntaryLeave,+ observeOwnerServerDeleteRouteCommit,pickPostEjectDestination,+ registerOwnerServerDeleteRoute,runAuthoritativeServerEject,- isDefinitiveChildMetaFailure,} from "./eject-server"import type { Server } from "./models/navigation"import { ApiError } from "@/lib/errors"import {- commitLastCommunityRoute,clearCommunityColdEntryAttempts,+ commitLastCommunityRoute,resolveCommunityColdEntryDestination,} from "./last-community-route"@@ -26,6 +38,11 @@ function makeServer(id: string): Server {}}+function terminalize(serverId: string): void {+ expect(claimOwnerServerDeleteScopeFlush(serverId)).toBe(true)+ expect(completeOwnerServerDeleteScopeFlush(serverId)).toBe(true)+}+describe("voluntary-leave marker", () => {it("marked id consumes as true, then false on the second read", () => {markVoluntaryLeave("srv_a")@@ -36,13 +53,156 @@ describe("voluntary-leave marker", () => {it("unrelated ids consume as false", () => {markVoluntaryLeave("srv_b")expect(consumeVoluntaryLeave("srv_other")).toBe(false)- // srv_b still marked — clean it up to keep test isolationexpect(consumeVoluntaryLeave("srv_b")).toBe(true)})})+describe("owner-delete single-navigation lifecycle", () => {+ const serverId = "srv_deleted"++ beforeEach(() => {+ cancelOwnerServerDelete(serverId)+ })++ it("claims exactly one survivor navigation while the deleted route is committed", () => {+ const origin = createOwnerServerDeleteRouteToken()+ beginOwnerServerDelete(serverId, origin)++ expect(commitOwnerServerDelete(serverId, origin)).toBe(false)+ expect(claimOwnerServerDeleteNavigation(+ serverId,+ origin,+ "/c/channels/srv_next/channel_remembered",+ )).toBe(true)+ expect(claimOwnerServerDeleteNavigation(serverId, origin, "/c/me")).toBe(false)+ expect(isOwnerServerDeleteRouteProtected(serverId, origin)).toBe(true)++ expect(observeOwnerServerDeleteRouteCommit(+ "/c/channels/srv_next/channel_remembered",+ )).toEqual([serverId])+ terminalize(serverId)+ expect(isOwnerServerDeleteCompleted(serverId)).toBe(true)+ expect(isOwnerServerDeleteRouteProtected(serverId)).toBe(false)+ expect(isOwnerServerDeleteRouteProtected(serverId, origin)).toBe(true)+ expect(isOwnerServerDeleteScopeEvictionBlocked(serverId)).toBe(true)+ })++ it("keeps duplicate begin as a participant without transferring origin ownership", () => {+ const origin = createOwnerServerDeleteRouteToken()+ const duplicate = createOwnerServerDeleteRouteToken()+ beginOwnerServerDelete(serverId, origin)+ beginOwnerServerDelete(serverId, duplicate)++ expect(commitOwnerServerDelete(serverId, duplicate)).toBe(false)+ cancelOwnerServerDelete(serverId, duplicate)+ expect(claimOwnerServerDeleteNavigation(serverId, duplicate, "/c/me")).toBe(false)++ expect(commitOwnerServerDelete(serverId, origin)).toBe(false)+ expect(claimOwnerServerDeleteNavigation(serverId, origin, "/c/me")).toBe(true)+ expect(observeOwnerServerDeleteRouteCommit("/c/me")).toEqual([serverId])+ terminalize(serverId)++ expect(isOwnerServerDeleteRouteProtected(serverId, origin)).toBe(true)+ expect(isOwnerServerDeleteRouteProtected(serverId, duplicate)).toBe(true)+ })++ it.each([+ "/c/channels/srv_next/channel_remembered",+ "/c/me/friends",+ ])("keeps an already committed safe route and issues no navigation: %s", (safeHref) => {+ const origin = createOwnerServerDeleteRouteToken()+ beginOwnerServerDelete(serverId, origin)+ expect(observeOwnerServerDeleteRouteCommit(safeHref)).toEqual([])++ expect(commitOwnerServerDelete(serverId, origin)).toBe(true)+ expect(claimOwnerServerDeleteNavigation(+ serverId,+ origin,+ "/c/channels/srv_next/channel_remembered",+ )).toBe(false)+ terminalize(serverId)+ expect(isOwnerServerDeleteRouteProtected(serverId)).toBe(false)+ })++ it("turns a resolver result into a no-op when a safe route commits first", () => {+ const origin = createOwnerServerDeleteRouteToken()+ beginOwnerServerDelete(serverId, origin)+ expect(commitOwnerServerDelete(serverId, origin)).toBe(false)++ expect(observeOwnerServerDeleteRouteCommit("/c/me")).toEqual([serverId])+ expect(claimOwnerServerDeleteNavigation(+ serverId,+ origin,+ "/c/channels/srv_next/channel_default",+ )).toBe(false)+ terminalize(serverId)+ })++ it("lets either the claimed target or a newer user route finish cleanup", () => {+ for (const safeHref of [+ "/c/channels/srv_next/channel_default",+ "/c/me/machines",+ ]) {+ const origin = createOwnerServerDeleteRouteToken()+ beginOwnerServerDelete(serverId, origin)+ expect(commitOwnerServerDelete(serverId, origin)).toBe(false)+ expect(claimOwnerServerDeleteNavigation(+ serverId,+ origin,+ "/c/channels/srv_next/channel_default",+ )).toBe(true)+ expect(observeOwnerServerDeleteRouteCommit(safeHref)).toEqual([serverId])+ terminalize(serverId)+ expect(isOwnerServerDeleteRouteProtected(serverId)).toBe(false)+ }+ })++ it("tombstones only route instances committed before the terminal boundary", () => {+ const origin = createOwnerServerDeleteRouteToken()+ const preTerminal = createOwnerServerDeleteRouteToken()+ const postTerminal = createOwnerServerDeleteRouteToken()+ beginOwnerServerDelete(serverId, origin)+ expect(registerOwnerServerDeleteRoute(serverId, preTerminal)).toBe("participant")+ expect(commitOwnerServerDelete(serverId, origin)).toBe(false)+ observeOwnerServerDeleteRouteCommit("/c/me")+ terminalize(serverId)++ expect(isOwnerServerDeleteRouteProtected(serverId, origin)).toBe(true)+ expect(isOwnerServerDeleteRouteProtected(serverId, preTerminal)).toBe(true)+ expect(registerOwnerServerDeleteRoute(serverId, postTerminal)).toBe("ordinary")+ expect(isOwnerServerDeleteRouteProtected(serverId, postTerminal)).toBe(false)+ expect(registerOwnerServerDeleteRoute(serverId, origin)).toBe("ordinary")+ expect(isOwnerServerDeleteRouteProtected(serverId, origin)).toBe(false)+ expect(isOwnerServerDeleteRouteProtected(serverId, preTerminal)).toBe(true)+ })++ it("classifies registration after the terminal claim as ordinary", () => {+ const origin = createOwnerServerDeleteRouteToken()+ const lateCommit = createOwnerServerDeleteRouteToken()+ beginOwnerServerDelete(serverId, origin)+ commitOwnerServerDelete(serverId, origin)+ observeOwnerServerDeleteRouteCommit("/c/me")++ expect(claimOwnerServerDeleteScopeFlush(serverId)).toBe(true)+ expect(registerOwnerServerDeleteRoute(serverId, lateCommit)).toBe("ordinary")+ expect(completeOwnerServerDeleteScopeFlush(serverId)).toBe(true)+ expect(isOwnerServerDeleteRouteProtected(serverId, lateCommit)).toBe(false)+ })++ it("cancels a failed request without navigation, flush, or tombstone", () => {+ const origin = createOwnerServerDeleteRouteToken()+ beginOwnerServerDelete(serverId, origin)+ cancelOwnerServerDelete(serverId, origin)++ expect(claimOwnerServerDeleteNavigation(serverId, origin, "/c/me")).toBe(false)+ expect(claimOwnerServerDeleteScopeFlush(serverId)).toBe(false)+ expect(isOwnerServerDeleteRouteProtected(serverId, origin)).toBe(false)+ expect(isOwnerServerDeleteScopeEvictionBlocked(serverId)).toBe(false)+ })+})+describe("runAuthoritativeServerEject", () => {- const target = { id: "srv_target" } as Server+ const target = makeServer("srv_target")const callbacks = () => ({consumeVoluntaryLeave: vi.fn(() => false),clearLastChannel: vi.fn(),@@ -50,46 +210,68 @@ describe("runAuthoritativeServerEject", () => {replace: vi.fn(),})- it("keeps the URL and last-channel through first 500, then accepts a success containing the target", () => {+ beforeEach(() => {+ cancelOwnerServerDelete(target.id)+ })++ it("keeps the URL through failures, refetches, and snapshots containing the target", () => {const sideEffects = callbacks()expect(runAuthoritativeServerEject({serverId: target.id, servers: [], isSuccess: false, isFetching: false, ...sideEffects,})).toBe(false)+ expect(runAuthoritativeServerEject({+ serverId: target.id, servers: [target], isSuccess: false, isFetching: false, ...sideEffects,+ })).toBe(false)+ expect(runAuthoritativeServerEject({+ serverId: target.id, servers: [], isSuccess: true, isFetching: true, ...sideEffects,+ })).toBe(false)expect(runAuthoritativeServerEject({serverId: target.id, servers: [target], isSuccess: true, isFetching: false, ...sideEffects,})).toBe(false)expect(sideEffects.replace).not.toHaveBeenCalled()- expect(sideEffects.toast).not.toHaveBeenCalled()- expect(sideEffects.clearLastChannel).not.toHaveBeenCalled()})- it("does not eject from last-good data when a refetch errors", () => {+ it("does not consume optimistic absence while owner delete protects the route", () => {const sideEffects = callbacks()expect(runAuthoritativeServerEject({- serverId: target.id, servers: [target], isSuccess: false, isFetching: false, ...sideEffects,+ serverId: target.id,+ servers: [],+ isSuccess: true,+ isFetching: false,+ ownerDeleteRouteProtected: true,+ ...sideEffects,})).toBe(false)expect(sideEffects.replace).not.toHaveBeenCalled()expect(sideEffects.toast).not.toHaveBeenCalled()expect(sideEffects.clearLastChannel).not.toHaveBeenCalled()})- it("does not decide absence while a successful snapshot is still fetching", () => {+ it("ejects, clears memory, and toasts only on settled authoritative absence", () => {const sideEffects = callbacks()expect(runAuthoritativeServerEject({- serverId: target.id, servers: [], isSuccess: true, isFetching: true, ...sideEffects,- })).toBe(false)- expect(sideEffects.replace).not.toHaveBeenCalled()+ serverId: target.id,+ servers: [makeServer("srv_remaining")],+ isSuccess: true,+ isFetching: false,+ ...sideEffects,+ })).toBe(true)+ expect(sideEffects.clearLastChannel).toHaveBeenCalledWith(target.id)+ expect(sideEffects.toast).toHaveBeenCalledWith("You're no longer in this server")+ expect(sideEffects.replace).toHaveBeenCalledWith("/c/channels/srv_remaining")})- it("ejects, clears memory, and toasts only when settled success explicitly lacks the target", () => {+ it("keeps voluntary leave silent", () => {const sideEffects = callbacks()- const remaining = { id: "srv_remaining" } as Server+ sideEffects.consumeVoluntaryLeave.mockReturnValue(true)expect(runAuthoritativeServerEject({- serverId: target.id, servers: [remaining], isSuccess: true, isFetching: false, ...sideEffects,+ serverId: target.id,+ servers: [],+ isSuccess: true,+ isFetching: false,+ ...sideEffects,})).toBe(true)- expect(sideEffects.clearLastChannel).toHaveBeenCalledWith(target.id)- expect(sideEffects.toast).toHaveBeenCalledWith("You're no longer in this server")- expect(sideEffects.replace).toHaveBeenCalledWith("/c/channels/srv_remaining")+ expect(sideEffects.replace).toHaveBeenCalledWith("/c/me")+ expect(sideEffects.toast).not.toHaveBeenCalled()})it("clears a matching cold-entry route and falls back once to Machines", () => {@@ -125,7 +307,7 @@ describe("runAuthoritativeServerEject", () => {})describe("isDefinitiveChildMetaFailure", () => {- it("keeps the existing 403/404 bounce boundary without treating 5xx as absence", () => {+ it("keeps 403/404 definitive without treating 5xx as absence", () => {expect(isDefinitiveChildMetaFailure(new ApiError("forbidden", 403))).toBe(true)expect(isDefinitiveChildMetaFailure(new ApiError("missing", 404))).toBe(true)expect(isDefinitiveChildMetaFailure(new ApiError("transient", 500))).toBe(false)@@ -134,28 +316,29 @@ describe("isDefinitiveChildMetaFailure", () => {})describe("pickPostEjectDestination", () => {- it("returns the first other server when one remains", () => {- const servers = [makeServer("srv_ejected"), makeServer("srv_next"), makeServer("srv_third")]- expect(pickPostEjectDestination(servers, "srv_ejected")).toBe(- "/c/channels/srv_next",- )- })-- it("uses array order (railOrder is applied by the API before this call)", () => {- // Simulate a rail with the ejected server in the middle — the picker- // must still land on the first non-ejected id from left to right.- const servers = [makeServer("srv_first"), makeServer("srv_ejected"), makeServer("srv_third")]+ it("uses the first surviving Server in API rail order", () => {+ const servers = [+ makeServer("srv_first"),+ makeServer("srv_ejected"),+ makeServer("srv_third"),+ ]expect(pickPostEjectDestination(servers, "srv_ejected")).toBe("/c/channels/srv_first",)})- it("returns /c/me when the ejected server was the only one", () => {- const servers = [makeServer("srv_only")]- expect(pickPostEjectDestination(servers, "srv_only")).toBe("/c/me")+ it("uses the surviving Server's remembered/default Channel resolver", () => {+ const destination = vi.fn(() => "/c/channels/srv_next/channel_default")+ expect(pickPostEjectDestination(+ [makeServer("srv_ejected"), makeServer("srv_next")],+ "srv_ejected",+ destination,+ )).toBe("/c/channels/srv_next/channel_default")+ expect(destination).toHaveBeenCalledExactlyOnceWith("srv_next")})- it("returns /c/me when the list is empty", () => {+ it("returns /c/me when no Server survives", () => {+ expect(pickPostEjectDestination([makeServer("srv_only")], "srv_only")).toBe("/c/me")expect(pickPostEjectDestination([], "srv_anything")).toBe("/c/me")})})diff --git a/src/web/src/lib/community/eject-server.ts b/src/web/src/lib/community/eject-server.tsindex 1d6177d31..14b0f2e3f 100644--- a/src/web/src/lib/community/eject-server.ts+++ b/src/web/src/lib/community/eject-server.ts@@ -1,5 +1,6 @@import type { Server } from "./models/navigation"import { ApiError } from "@/lib/errors"+import { communityServerId } from "./community-route"import {COMMUNITY_COLD_ENTRY_FALLBACK,consumeCommunityColdEntryFailure,@@ -16,6 +17,52 @@ import {// the coordination warrants. Same trick as `wsStore.hasSeenMessage`.const voluntaryLeaves = new Set<string>()+export type OwnerServerDeleteRouteToken = object++type OwnerServerDeleteRecord = {+ serverId: string+ request: "pending" | "resolving" | "navigating"+ originToken: OwnerServerDeleteRouteToken+ participantTokens: Set<OwnerServerDeleteRouteToken>+ lastCommittedHref: string+ targetHref: string | null+ navigationIssued: boolean+ scopes: "retained" | "flushing"+}++type OwnerServerDeleteState = {+ transactions: Map<string, OwnerServerDeleteRecord>+ tombstones: WeakMap<OwnerServerDeleteRouteToken, string>+ flushedServerIds: Set<string>+}++type OwnerServerDeleteWindow = Window & {+ __alookOwnerServerDeleteStateV8?: OwnerServerDeleteState+}++const ownerServerDeleteFallback: OwnerServerDeleteState = {+ transactions: new Map(),+ tombstones: new WeakMap(),+ flushedServerIds: new Set(),+}++function ownerServerDeleteState(): OwnerServerDeleteState {+ if (typeof window === "undefined") return ownerServerDeleteFallback+ const scope = window as OwnerServerDeleteWindow+ scope.__alookOwnerServerDeleteStateV8 ??= {+ transactions: new Map(),+ tombstones: new WeakMap(),+ flushedServerIds: new Set(),+ }+ return scope.__alookOwnerServerDeleteStateV8+}++function ownerServerDeleteScopeFlushReady(record: OwnerServerDeleteRecord): boolean {+ return record.request !== "pending"+ && communityServerId(record.lastCommittedHref) !== record.serverId+ && record.scopes === "retained"+}+export function markVoluntaryLeave(serverId: string): void {voluntaryLeaves.add(serverId)}@@ -25,6 +72,141 @@ export function consumeVoluntaryLeave(serverId: string): boolean {return voluntaryLeaves.delete(serverId)}+export function createOwnerServerDeleteRouteToken(): OwnerServerDeleteRouteToken {+ return {}+}++export function registerOwnerServerDeleteRoute(+ serverId: string,+ token: OwnerServerDeleteRouteToken,+): "participant" | "ordinary" {+ const state = ownerServerDeleteState()+ const record = state.transactions.get(serverId)+ if (record?.scopes === "retained") {+ record.participantTokens.add(token)+ return "participant"+ }+ if (state.tombstones.get(token) === serverId) state.tombstones.delete(token)+ return "ordinary"+}++export function beginOwnerServerDelete(+ serverId: string,+ originToken: OwnerServerDeleteRouteToken,+): void {+ const state = ownerServerDeleteState()+ const current = state.transactions.get(serverId)+ if (current) {+ if (current.scopes === "retained") current.participantTokens.add(originToken)+ return+ }+ state.flushedServerIds.delete(serverId)+ state.transactions.set(serverId, {+ serverId,+ request: "pending",+ originToken,+ participantTokens: new Set([originToken]),+ lastCommittedHref: `/c/channels/${encodeURIComponent(serverId)}`,+ targetHref: null,+ navigationIssued: false,+ scopes: "retained",+ })+}++export function commitOwnerServerDelete(+ serverId: string,+ originToken: OwnerServerDeleteRouteToken,+): boolean {+ const record = ownerServerDeleteState().transactions.get(serverId)+ if (!record || record.originToken !== originToken || record.request !== "pending") return false+ record.request = "resolving"+ return ownerServerDeleteScopeFlushReady(record)+}++export function cancelOwnerServerDelete(+ serverId: string,+ originToken?: OwnerServerDeleteRouteToken,+): void {+ const state = ownerServerDeleteState()+ const record = state.transactions.get(serverId)+ if (record && (!originToken || record.originToken === originToken)) {+ state.transactions.delete(serverId)+ }+}++export function claimOwnerServerDeleteNavigation(+ serverId: string,+ originToken: OwnerServerDeleteRouteToken,+ targetHref: string,+): boolean {+ const record = ownerServerDeleteState().transactions.get(serverId)+ if (!record+ || record.originToken !== originToken+ || record.request !== "resolving"+ || record.scopes !== "retained"+ || record.navigationIssued+ || communityServerId(record.lastCommittedHref) !== serverId+ || communityServerId(targetHref) === serverId) return false+ record.request = "navigating"+ record.targetHref = targetHref+ record.navigationIssued = true+ return true+}++export function isOwnerServerDeleteRouteProtected(+ serverId: string,+ token?: OwnerServerDeleteRouteToken,+): boolean {+ const state = ownerServerDeleteState()+ if (state.transactions.has(serverId)) return true+ return token ? state.tombstones.get(token) === serverId : false+}++export function isOwnerServerDeleteScopeEvictionBlocked(serverId: string): boolean {+ const state = ownerServerDeleteState()+ return state.transactions.has(serverId) || state.flushedServerIds.has(serverId)+}++export function isOwnerServerDeleteCompleted(serverId: string): boolean {+ return ownerServerDeleteState().flushedServerIds.has(serverId)+}++export function observeOwnerServerDeleteRouteCommit(committedHref: string): string[] {+ const state = ownerServerDeleteState()+ for (const record of state.transactions.values()) {+ record.lastCommittedHref = committedHref+ }+ return ownerServerDeleteScopeFlushCandidates()+}++export function ownerServerDeleteScopeFlushCandidates(): string[] {+ return [...ownerServerDeleteState().transactions]+ .filter(([, record]) => ownerServerDeleteScopeFlushReady(record))+ .map(([serverId]) => serverId)+}++export function isOwnerServerDeleteScopeFlushReady(serverId: string): boolean {+ const record = ownerServerDeleteState().transactions.get(serverId)+ return record ? ownerServerDeleteScopeFlushReady(record) : false+}++export function claimOwnerServerDeleteScopeFlush(serverId: string): boolean {+ const record = ownerServerDeleteState().transactions.get(serverId)+ if (!record || !ownerServerDeleteScopeFlushReady(record)) return false+ record.scopes = "flushing"+ return true+}++export function completeOwnerServerDeleteScopeFlush(serverId: string): boolean {+ const state = ownerServerDeleteState()+ const record = state.transactions.get(serverId)+ if (!record || record.scopes !== "flushing") return false+ for (const token of record.participantTokens) state.tombstones.set(token, serverId)+ state.flushedServerIds.add(serverId)+ state.transactions.delete(serverId)+ return true+}+export function isDefinitiveChildMetaFailure(error: unknown): boolean {return error instanceof ApiError && (error.status === 403 || error.status === 404)}@@ -35,10 +217,11 @@ export function isDefinitiveChildMetaFailure(error: unknown): boolean {export function pickPostEjectDestination(servers: readonly Server[],ejectedServerId: string,+ serverDestination?: (serverId: string) => string,): string {const remaining = servers.filter((s) => s.id !== ejectedServerId)if (remaining.length === 0) return "/c/me"- return `/c/channels/${remaining[0].id}`+ return serverDestination?.(remaining[0].id) ?? `/c/channels/${remaining[0].id}`}export function runAuthoritativeServerEject(args: {@@ -46,6 +229,7 @@ export function runAuthoritativeServerEject(args: {servers: readonly Server[]isSuccess: booleanisFetching: boolean+ ownerDeleteRouteProtected?: booleanconsumeVoluntaryLeave: (serverId: string) => booleanclearLastChannel: (serverId: string) => voidtoast: (message: string) => void@@ -58,7 +242,7 @@ export function runAuthoritativeServerEject(args: {// retain last-good data; neither may become an existence/membership verdict.if (!args.isSuccess || args.isFetching) return falseif (args.servers.some((server) => server.id === args.serverId)) return false-+ if (args.ownerDeleteRouteProtected) return falseargs.clearLastChannel(args.serverId)const voluntary = args.consumeVoluntaryLeave(args.serverId)if (!voluntary) args.toast("You're no longer in this server")diff --git a/src/web/src/test/e2e-ui/28-community-delete-media-cleanup.spec.ts b/src/web/src/test/e2e-ui/28-community-delete-media-cleanup.spec.tsindex 5bf70d39b..cae8df47d 100644--- a/src/web/src/test/e2e-ui/28-community-delete-media-cleanup.spec.ts+++ b/src/web/src/test/e2e-ui/28-community-delete-media-cleanup.spec.ts@@ -97,7 +97,7 @@ async function status(}test("existing channel/server deletes converge UI, WS, pending rows, linked media, and icon reads", async ({ asUser }) => {- test.setTimeout(150_000)+ test.setTimeout(210_000)const stamp = Date.now()const channelServerId = await seedServer("alice", `C1 channel ${stamp}`)const channelId = await seedChannel("alice", channelServerId, `delete-media-${stamp}`, "text")@@ -121,7 +121,7 @@ test("existing channel/server deletes converge UI, WS, pending rows, linked mediawait gotoAfterUserWsAuth(alice.page, `/c/channels/${channelServerId}/${channelId}`)await gotoAfterUserWsAuth(bob.page, `/c/channels/${channelServerId}/${channelId}`)- await expect(bob.page.getByTestId(tid.channelRow(channelId))).toBeVisible()+ await expect(bob.page.getByTestId(tid.channelRow(channelId))).toBeVisible({ timeout: 30_000 })expect(await status("bob", `/api/community/channels/${channelId}`, "DELETE")).toBe(403)expect(await status("carol", `/api/community/channels/${channelId}`, "DELETE")).toBe(403)@@ -165,7 +165,14 @@ test("existing channel/server deletes converge UI, WS, pending rows, linked medi}).click()expect((await serverDeleteResponse).status()).toBe(204)- await expect(alice.page).toHaveURL(/\/c\/me(?:\/friends)?$/)+ await expect(alice.page).not.toHaveURL(new RegExp(`/c/channels/${serverId}(?:/|$)`))+ await expect(alice.page).toHaveURL(/\/c\/channels\/[^/]+\/[^/]+$/)+ const deleteLanding = new URL(alice.page.url()).pathname.match(+ /^\/c\/channels\/([^/]+)\/([^/]+)$/,+ )+ expect(deleteLanding).not.toBeNull()+ expect(deleteLanding?.[1]).not.toBe(serverId)+ expect(await status("alice", `/api/community/channels/${deleteLanding?.[2]}`)).toBe(200)await expect(alice.page.getByTestId(tid.serverIcon(serverId))).toHaveCount(0)await expect(alice.page.getByTestId(tid.channelRow(serverChannelId))).toHaveCount(0)await expect(alice.page.getByTestId(tid.composerInput)).toHaveCount(0)@@ -182,6 +189,7 @@ test("existing channel/server deletes converge UI, WS, pending rows, linked mediawait alice.page.goBack()await expect(alice.page).not.toHaveURL(new RegExp(`/c/channels/${serverId}/`))+ // Regression: a fresh Back visit must not settle on the survivor Server root.await expect(alice.page).toHaveURL(/\/c\/channels\/[^/]+\/[^/]+$/)const siblingRoute = new URL(alice.page.url()).pathname.match(/^\/c\/channels\/([^/]+)\/([^/]+)$/)expect(siblingRoute).not.toBeNull()@@ -196,7 +204,9 @@ test("existing channel/server deletes converge UI, WS, pending rows, linked mediexpect(liveServers.servers.some(({ id }) => id === serverId)).toBe(false)expect(await status("alice", `/api/community/channels/${siblingChannelId}`)).toBe(200)await expect(alice.page.getByTestId(tid.serverIcon(siblingServerId))).toBeVisible()- await expect(alice.page.getByTestId(tid.channelRow(siblingChannelId))).toBeVisible()+ await expect(alice.page.getByTestId(tid.channelRow(siblingChannelId))).toBeVisible({+ timeout: 30_000,+ })await alice.page.reload()await expect(alice.page).toHaveURL(new RegExp(`/c/channels/${siblingServerId}/${siblingChannelId}$`))await expect(alice.page.getByTestId(tid.serverIcon(serverId))).toHaveCount(0)diff --git a/src/web/src/test/e2e-ui/57-server-delete-navigation-races.spec.ts b/src/web/src/test/e2e-ui/57-server-delete-navigation-races.spec.tsnew file mode 100644index 000000000..09b7ebd80--- /dev/null+++ b/src/web/src/test/e2e-ui/57-server-delete-navigation-races.spec.ts@@ -0,0 +1,357 @@+import type { Page, WebSocket } from "@playwright/test"+import { expect, sessionCookie, test } from "./_fixtures/community-fixture"+import { gotoAfterUserWsAuth, openServer } from "./_fixtures/actions"+import { seedChannel, seedServer } from "./_fixtures/seed"+import { tid } from "./_fixtures/testids"+import { WEB_URL } from "./_setup/paths"+import type { UserKey } from "./_setup/users"++type Deferred<T> = {+ promise: Promise<T>+ resolve: (value: T) => void+}++function captureServerDeletes(page: Page) {+ const frames: Array<{ type: string; serverId?: string }> = []+ const sockets = new Set<WebSocket>()+ page.on("websocket", (socket) => {+ sockets.add(socket)+ socket.on("framereceived", ({ payload }) => {+ try {+ const frame = JSON.parse(payload.toString()) as { type: string; serverId?: string }+ if (frame.type === "community:server.delete") frames.push(frame)+ } catch {}+ })+ })+ return { frames, sockets }+}++function deferred<T>(): Deferred<T> {+ let resolve!: (value: T) => void+ const promise = new Promise<T>((resolvePromise) => {+ resolve = resolvePromise+ })+ return { promise, resolve }+}++async function serverIds(key: UserKey): Promise<string[]> {+ const response = await fetch(`${WEB_URL}/api/community/servers`, {+ headers: { Cookie: sessionCookie(key), Origin: WEB_URL },+ })+ expect(response.status).toBe(200)+ const body = await response.json() as { servers: Array<{ id: string }> }+ return body.servers.map((server) => server.id)+}++async function seedServerRoute(+ key: UserKey,+ name: string,+): Promise<{ serverId: string; channelId: string }> {+ const serverId = await seedServer(key, name)+ const channelId = await seedChannel(key, serverId, `${name} channel`, "text")+ return { serverId, channelId }+}++async function clickDeleteServer(page: Page, serverId: string): Promise<void> {+ await page.getByTestId(tid.serverIcon(serverId)).click({ button: "right" })+ await page.getByTestId(tid.serverSettingsOpen).click()+ await expect(page.getByTestId(tid.settingsShell)).toBeVisible()+ await page.getByRole("button", { name: "Delete Server", exact: true }).click()+ await page.getByRole("dialog").getByRole("button", {+ name: "Delete Server",+ exact: true,+ }).click()+}++async function delayDelete(page: Page, serverId: string) {+ const release = deferred<void>()+ const intercepted = deferred<void>()+ const pattern = `**/api/community/servers/${serverId}`+ await page.route(pattern, async (route) => {+ if (route.request().method() !== "DELETE") {+ await route.continue()+ return+ }+ intercepted.resolve()+ await release.promise+ await route.continue()+ })+ const response = page.waitForResponse((candidate) => (+ candidate.request().method() === "DELETE"+ && new URL(candidate.url()).pathname === `/api/community/servers/${serverId}`+ ))+ await clickDeleteServer(page, serverId)+ await intercepted.promise+ return {+ release: () => release.resolve(),+ response,+ cleanup: () => page.unroute(pattern),+ }+}++async function delayServerRsc(page: Page, serverId: string) {+ const release = deferred<void>()+ const intercepted = deferred<void>()+ const pattern = "**/c/channels/**"+ await page.route(pattern, async (route) => {+ const url = new URL(route.request().url())+ const targetsServer = url.pathname === `/c/channels/${serverId}`+ || url.pathname.startsWith(`/c/channels/${serverId}/`)+ if (!targetsServer || !url.searchParams.has("_rsc")) {+ await route.continue()+ return+ }+ intercepted.resolve()+ await release.promise+ await route.continue()+ })+ return {+ intercepted: intercepted.promise,+ release: () => release.resolve(),+ cleanup: () => page.unroute(pattern),+ }+}++async function installHistoryRecorder(page: Page): Promise<void> {+ await page.evaluate(() => {+ const scope = window as typeof window & {+ __serverDeleteHistoryWrites?: Array<{ method: "push" | "replace"; href: string | null }>+ __serverDeleteHistoryWrapped?: boolean+ }+ scope.__serverDeleteHistoryWrites = []+ if (scope.__serverDeleteHistoryWrapped) return+ scope.__serverDeleteHistoryWrapped = true+ const nativePush = history.pushState+ const nativeReplace = history.replaceState+ history.pushState = function (data, unused, url) {+ scope.__serverDeleteHistoryWrites?.push({+ method: "push",+ href: url === undefined || url === null ? null : String(url),+ })+ return nativePush.call(this, data, unused, url)+ }+ history.replaceState = function (data, unused, url) {+ scope.__serverDeleteHistoryWrites?.push({+ method: "replace",+ href: url === undefined || url === null ? null : String(url),+ })+ return nativeReplace.call(this, data, unused, url)+ }+ })+}++async function resetHistoryRecorder(page: Page): Promise<void> {+ await page.evaluate(() => {+ const scope = window as typeof window & {+ __serverDeleteHistoryWrites?: unknown[]+ }+ scope.__serverDeleteHistoryWrites = []+ })+}++async function divergentHistoryWrites(page: Page, expectedPathname: string) {+ return page.evaluate((expected) => {+ const scope = window as typeof window & {+ __serverDeleteHistoryWrites?: Array<{ method: "push" | "replace"; href: string | null }>+ }+ return (scope.__serverDeleteHistoryWrites ?? []).filter(({ href }) => (+ href !== null && new URL(href, location.origin).pathname !== expected+ ))+ }, expectedPathname)+}++async function expectServerLeaf(page: Page, serverId: string): Promise<string> {+ await expect(page).toHaveURL(new RegExp(`/c/channels/${serverId}/[^/]+$`))+ return new URL(page.url()).pathname+}++test.describe.configure({ mode: "serial" })++test("deleting the only Server replaces once to Home", async ({ asUser }) => {+ const route = await seedServerRoute("dave", `delete-only-${Date.now()}`)+ const dave = await asUser("dave")+ await gotoAfterUserWsAuth(+ dave.page,+ `/c/channels/${route.serverId}/${route.channelId}`,+ )+ await installHistoryRecorder(dave.page)+ await resetHistoryRecorder(dave.page)+ const response = dave.page.waitForResponse((candidate) => (+ candidate.request().method() === "DELETE"+ && new URL(candidate.url()).pathname === `/api/community/servers/${route.serverId}`+ ))++ await clickDeleteServer(dave.page, route.serverId)++ expect((await response).status()).toBe(204)+ await expect(dave.page).toHaveURL("/c/me")+ await expect(dave.page.getByTestId(tid.serverIcon(route.serverId))).toHaveCount(0)+ expect(await divergentHistoryWrites(dave.page, "/c/me")).toEqual([])+})++for (const testCase of [+ { key: "alice" as const, name: "computed target", chooseUserRoute: (ids: string[]) => ids[0] },+ { key: "bob" as const, name: "different safe route", chooseUserRoute: (ids: string[]) => ids[1] },+]) {+ test(`a committed ${testCase.name} wins before DELETE success with no later history write`, async ({ asUser }) => {+ const stamp = Date.now()+ const survivorA = await seedServerRoute(testCase.key, `survivor-a-${stamp}`)+ const survivorB = await seedServerRoute(testCase.key, `survivor-b-${stamp}`)+ const deleted = await seedServerRoute(testCase.key, `deleted-${stamp}`)+ const page = (await asUser(testCase.key)).page+ await gotoAfterUserWsAuth(+ page,+ `/c/channels/${deleted.serverId}/${deleted.channelId}`,+ )+ await installHistoryRecorder(page)+ const survivors = (await serverIds(testCase.key)).filter((id) => id !== deleted.serverId)+ expect(survivors).toContain(survivorA.serverId)+ expect(survivors).toContain(survivorB.serverId)+ const userServerId = testCase.chooseUserRoute(survivors)+ expect(userServerId).toBeTruthy()+ const deletion = await delayDelete(page, deleted.serverId)++ await openServer(page, userServerId)+ const safePathname = await expectServerLeaf(page, userServerId)+ await resetHistoryRecorder(page)+ deletion.release()++ expect((await deletion.response).status()).toBe(204)+ await expect(page).toHaveURL(safePathname)+ await expect(page.getByText("Server deleted", { exact: true })).toBeVisible()+ expect(await divergentHistoryWrites(page, safePathname)).toEqual([])+ await deletion.cleanup()+ })+}++test("slow target RSC survives delete/list/WS convergence and lands on its remembered Channel", async ({ asUser }) => {+ const stamp = Date.now()+ const ensuredSurvivor = await seedServerRoute("carol", `slow-target-${stamp}`)+ const deleted = await seedServerRoute("carol", `slow-deleted-${stamp}`)+ const page = (await asUser("carol")).page+ await gotoAfterUserWsAuth(+ page,+ `/c/channels/${ensuredSurvivor.serverId}/${ensuredSurvivor.channelId}`,+ )+ const targetServerId = (await serverIds("carol")).find((id) => id !== deleted.serverId)+ expect(targetServerId).toBeTruthy()+ await openServer(page, targetServerId!)+ const targetPathname = await expectServerLeaf(page, targetServerId!)+ await expect(page.getByTestId(tid.composerInput)).toBeVisible()+ await openServer(page, deleted.serverId)+ const targetRsc = await delayServerRsc(page, targetServerId!)+ const response = page.waitForResponse((candidate) => (+ candidate.request().method() === "DELETE"+ && new URL(candidate.url()).pathname === `/api/community/servers/${deleted.serverId}`+ ))++ await clickDeleteServer(page, deleted.serverId)++ expect((await response).status()).toBe(204)+ await targetRsc.intercepted+ expect(new URL(page.url()).pathname).not.toBe("/c/me")+ targetRsc.release()+ expect(await expectServerLeaf(page, targetServerId!)).toBe(targetPathname)+ await expect(page.getByTestId(tid.serverIcon(deleted.serverId))).toHaveCount(0)+ await targetRsc.cleanup()+})++test("a newer user navigation wins while the delete target RSC is pending", async ({ asUser }) => {+ const stamp = Date.now()+ const candidateA = await seedServerRoute("dave", `queued-target-a-${stamp}`)+ const candidateB = await seedServerRoute("dave", `queued-target-b-${stamp}`)+ const deleted = await seedServerRoute("dave", `queued-deleted-${stamp}`)+ const page = (await asUser("dave")).page+ await gotoAfterUserWsAuth(+ page,+ `/c/channels/${candidateA.serverId}/${candidateA.channelId}`,+ )+ const targetServerId = (await serverIds("dave")).find((id) => id !== deleted.serverId)+ expect(targetServerId).toBeTruthy()+ const userRoute = [candidateA, candidateB].find(({ serverId }) => (+ serverId !== targetServerId+ ))+ expect(userRoute).toBeTruthy()+ await openServer(page, targetServerId!)+ await expectServerLeaf(page, targetServerId!)+ await openServer(page, deleted.serverId)+ const targetRsc = await delayServerRsc(page, targetServerId!)+ const response = page.waitForResponse((candidate) => (+ candidate.request().method() === "DELETE"+ && new URL(candidate.url()).pathname === `/api/community/servers/${deleted.serverId}`+ ))++ await clickDeleteServer(page, deleted.serverId)++ expect((await response).status()).toBe(204)+ await targetRsc.intercepted+ await page.getByTestId(tid.serverIcon(userRoute!.serverId)).click()+ targetRsc.release()+ await expectServerLeaf(page, userRoute!.serverId)+ await expect(page).not.toHaveURL(new RegExp(`/c/channels/${targetServerId}(?:/|$)`), {+ timeout: 2_000,+ })+ await targetRsc.cleanup()+})++test("a Back visit after terminal cleanup is an ordinary missing route", async ({ asUser }) => {+ const stamp = Date.now()+ const survivor = await seedServerRoute("alice", `terminal-survivor-${stamp}`)+ const deleted = await seedServerRoute("alice", `terminal-deleted-${stamp}`)+ const page = (await asUser("alice")).page+ await gotoAfterUserWsAuth(+ page,+ `/c/channels/${deleted.serverId}/${deleted.channelId}`,+ )+ const deletion = await delayDelete(page, deleted.serverId)+ await openServer(page, survivor.serverId)+ const safePathname = await expectServerLeaf(page, survivor.serverId)++ deletion.release()+ expect((await deletion.response).status()).toBe(204)+ await expect(page).toHaveURL(safePathname)+ await expect(page.getByText("Server deleted", { exact: true })).toBeVisible()+ await page.goBack({ waitUntil: "commit" })++ await expect(page).not.toHaveURL(new RegExp(`/c/channels/${deleted.serverId}(?:/|$)`))+ await expect(page).toHaveURL(/\/c\/channels\/[^/]+\/[^/]+$/)+ await deletion.cleanup()+})++test("a failed DELETE keeps the current route and emits no success frame", async ({ asUser }) => {+ const route = await seedServerRoute("carol", `failed-delete-${Date.now()}`)+ const page = (await asUser("carol")).page+ const deletes = captureServerDeletes(page)+ const pathname = `/c/channels/${route.serverId}/${route.channelId}`+ await gotoAfterUserWsAuth(page, pathname)+ const pattern = `**/api/community/servers/${route.serverId}`+ await page.route(pattern, async (request) => {+ if (request.request().method() !== "DELETE") {+ await request.continue()+ return+ }+ await request.fulfill({+ status: 500,+ contentType: "application/json",+ body: JSON.stringify({ error: "forced delete failure" }),+ })+ })+ const response = page.waitForResponse((candidate) => (+ candidate.request().method() === "DELETE"+ && new URL(candidate.url()).pathname === `/api/community/servers/${route.serverId}`+ ))++ await clickDeleteServer(page, route.serverId)++ expect((await response).status()).toBe(500)+ await expect(page).toHaveURL(pathname)+ await expect(page.getByText("Server deleted", { exact: true })).toHaveCount(0)+ await expect(page.getByTestId(tid.serverIcon(route.serverId))).toBeVisible()+ await expect(page.getByTestId(tid.channelRow(route.channelId))).toBeVisible()+ await expect(page.getByTestId(tid.composerInput)).toHaveCount(1)+ await expect.poll(() => deletes.frames.filter((frame) => (+ frame.serverId === route.serverId+ ))).toHaveLength(0)+ expect(await serverIds("carol")).toContain(route.serverId)+ await page.unroute(pattern)+})