Add bounded sidebar task navigation stack

apps/desktop/src/api/errors.test.ts

@@ -1,13 +1,27 @@
 import {
   decodeWorkflowLabelError,
   decodeWorkflowTaskDependencyError,
+  isProjectMissingError,
+  isTaskMissingError,
   RpcError,
   WorkflowLabelError,
   WorkflowTaskDependencyError,
 } from "./errors";
+import { rpcErrorCodes } from "./rpcErrorCodes";
 
 const labelID = "f74ce532-9e6e-4cf6-b3c1-d67d5a3eedcf";
 
+describe("sidebar missing-entity errors", () => {
+  it("recognizes typed Task and Project missing errors without parsing messages", () => {
+    const error = (code: number, data?: Readonly<Record<string, string>>) =>
+      new RpcError({ code, data, message: "changed", method: "owner.operation" });
+    expect(isTaskMissingError(error(rpcErrorCodes.workflowTaskNotFound))).toBe(true);
+    expect(isProjectMissingError(error(-32000, { reason: "project_not_found" }))).toBe(true);
+    expect(isProjectMissingError(error(rpcErrorCodes.projectNotFound))).toBe(true);
+    expect(isProjectMissingError(new Error("project_not_found"))).toBe(false);
+  });
+});
+
 describe("workflow label RPC errors", () => {
   it.each([
     {

apps/desktop/src/api/errors.ts

@@ -26,6 +26,19 @@ export class RpcError extends Error {
   }
 }
 
+export function isTaskMissingError(error: unknown): boolean {
+  return error instanceof RpcError && error.code === rpcErrorCodes.workflowTaskNotFound;
+}
+
+const projectMissingDataSchema = z.looseObject({ reason: z.literal("project_not_found") });
+export function isProjectMissingError(error: unknown): boolean {
+  return (
+    error instanceof RpcError &&
+    (error.code === rpcErrorCodes.projectNotFound ||
+      projectMissingDataSchema.safeParse(error.data).success)
+  );
+}
+
 export type TaskSearchErrorReason = "normalized_too_short";
 
 export class TaskSearchError extends RpcError {

apps/desktop/src/api/index.ts

@@ -46,6 +46,8 @@ export {
   decodeTaskSearchError,
   decodeWorkflowLabelError,
   decodeWorkflowTaskDependencyError,
+  isProjectMissingError,
+  isTaskMissingError,
   ServerRootMismatchError,
   StartupConfigurationError,
   TransportError,

apps/desktop/src/api/rpcErrorCodes.ts

@@ -1,4 +1,5 @@
 export const rpcErrorCodes = {
+  projectNotFound: -32014,
   workflowTaskNotFound: -32024,
   workflowTaskDependency: -32049,
   workflowTaskSearch: -32052,

apps/desktop/src/app-facade/projectDeletionEvents.test.ts

@@ -0,0 +1,61 @@
+import { createBrowserNativeBridge } from "@app/native-bridge";
+import { QueryClient, QueryObserver } from "@tanstack/react-query";
+import { renderHook } from "@testing-library/react";
+import { createElement, type ReactNode } from "react";
+
+import { isProjectMissingError, RpcError } from "@/api";
+import { createTestServices, TestAppProviders } from "@/test-support/app-services";
+import {
+  invalidateProjectDeleteQueries,
+  useProjectDeletedEvents,
+} from "./projectDeletionEvents";
+import { queryKeys } from "./queryKeys";
+
+describe("Project deletion owner refresh", () => {
+  it.each([
+    ["Project Edit", queryKeys.projectEdit("project-1")],
+    ["New Task", queryKeys.workspaces("project-1")],
+    ["Link Workflow", queryKeys.projectWorkflowLinks("project-1")],
+    ["Project Workflow Editor", queryKeys.projectWorkflowLinks("project-1")],
+  ])("drives the native deletion event through a second %s owner read", async (_name, queryKey) => {
+    const bridge = createBrowserNativeBridge();
+    const services = createTestServices([], bridge);
+    const queryClient = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    let requests = 0;
+    const observer = new QueryObserver(queryClient, {
+      queryFn: async () => {
+        requests += 1;
+        if (requests === 1) return { request: requests };
+        throw new RpcError({
+          code: -32000,
+          data: { reason: "project_not_found" },
+          message: "missing",
+          method: "owner.read",
+        });
+      },
+      queryKey,
+    });
+    const unsubscribe = observer.subscribe(() => undefined);
+    await observer.refetch();
+    let refresh: Promise<void> | undefined;
+    const handler = vi.fn(() => {
+      refresh = invalidateProjectDeleteQueries(queryClient, "project-1");
+    });
+    const wrapper = ({ children }: Readonly<{ children: ReactNode }>) =>
+      createElement(TestAppProviders, { children, services });
+    const view = renderHook(() => {
+      useProjectDeletedEvents(bridge, handler);
+    }, { wrapper });
+    await Promise.resolve();
+
+    await bridge.projectDeletion.notifyDeleted({ projectID: "project-1" });
+    await refresh;
+
+    expect(handler).toHaveBeenCalledOnce();
+    expect(requests).toBe(2);
+    expect(isProjectMissingError(observer.getCurrentResult().error)).toBe(true);
+    view.unmount();
+    unsubscribe();
+    queryClient.clear();
+  });
+});

apps/desktop/src/app-facade/projectDeletionEvents.ts

@@ -5,7 +5,6 @@ import { useEffect } from "react";
 import { errorMessage } from "@/api";
 import { clearLastProjectRoute } from "./projectRoutePersistence";
 import { queryKeys } from "./queryKeys";
-import type { SidebarController } from "./sidebarContext";
 import { removeProjectTaskSearches } from "./taskSearchQueries";
 import { useAppServices } from "./useAppServices";
 
@@ -43,31 +42,26 @@ export function useProjectDeletedEvents(
 }
 
 export async function completeProjectDeletion({
-  closeSidebar,
   navigateHome,
   projectID,
   pushDeletedToast,
   queryClient,
 }: Readonly<{
-  closeSidebar: SidebarController["closeSidebar"];
-  navigateHome: () => Promise<void>;
+  navigateHome?: (() => Promise<void>) | undefined;
   projectID: string;
   pushDeletedToast: () => void;
   queryClient: QueryClient;
 }>): Promise<void> {
   await invalidateProjectDeleteQueries(queryClient, projectID);
   clearLastProjectRoute(projectID);
-  closeSidebar("closed");
-  await navigateHome();
+  if (navigateHome !== undefined) await navigateHome();
   pushDeletedToast();
 }
 
 export async function invalidateProjectDeleteQueries(
   queryClient: QueryClient,
   projectID: string,
 ): Promise<void> {
-  queryClient.removeQueries({ queryKey: queryKeys.projectEdit(projectID) });
-  queryClient.removeQueries({ queryKey: queryKeys.workspaces(projectID) });
   await removeProjectTaskSearches(queryClient, projectID);
   await Promise.all([
     queryClient.invalidateQueries({ queryKey: queryKeys.projects }),
@@ -76,5 +70,6 @@ export async function invalidateProjectDeleteQueries(
     queryClient.invalidateQueries({ queryKey: queryKeys.allBoards }),
     queryClient.invalidateQueries({ queryKey: queryKeys.allAttention }),
     queryClient.invalidateQueries({ queryKey: queryKeys.allTasks }),
+    queryClient.invalidateQueries({ queryKey: queryKeys.allProjectWorkflowLinks, refetchType: "active" }),
   ]);
 }

apps/desktop/src/app-facade/sidebarContext.ts

@@ -1,32 +1,12 @@
-import { createContext, useContext, type ReactNode } from "react";
+import { createContext, createElement, useCallback, useContext, useEffect, useMemo, useState, type ReactNode } from "react";
 
 import type { ResolvedSidebarWidth, SidebarSizePreference } from "./sidebarSizing";
 
 export type SidebarMode = "overlay" | "shift";
 export type SidebarPhase = "closing" | "open";
-
-export type SidebarCancelReason = "closed" | "replaced" | "route_change";
-
-export type SidebarCanceledResult = Readonly<{
-  status: "canceled";
-  reason: SidebarCancelReason;
-}>;
-
-export type SidebarNewTaskResult = Readonly<{
-  status: "submitted";
-  destination: "newTask";
-}>;
-
-export type SidebarTaskDetailResult = Readonly<{
-  status: "closed";
-  destination: "taskDetail";
-}>;
-
-export type SidebarWorkflowResult = Readonly<{
-  status: "completed";
-  destination: "workflow";
-  workflowID: string;
-}>;
+export type SidebarTransitionDirection = "back" | "push" | "replace";
+export type SidebarRootOutcome = "closed" | "released" | "replaced";
+export type SidebarNavigationOutcome = "accepted" | "stale" | "unavailable";
 
 export type WorkflowInspectorSelection =
   | Readonly<{ kind: "workflow" }>
@@ -42,9 +22,6 @@ export type TaskDetailInitialFocus =
   | Readonly<{ kind: "interrupted_current_node" }>
   | Readonly<{ kind: "dependencies" }>;
 
-export type SidebarResult =
-  SidebarCanceledResult | SidebarNewTaskResult | SidebarTaskDetailResult | SidebarWorkflowResult;
-
 export type SidebarDestination =
   | Readonly<{
       kind: "newTask";
@@ -66,8 +43,6 @@ export type SidebarDestination =
       initialFocus?: TaskDetailInitialFocus | undefined;
       taskID: string;
       onMutated?: (() => void) | undefined;
-      // Set when opened from the Home inbox so the sidebar header exposes live
-      // Previous/Next navigation across the attention feed.
       inboxNav?: boolean | undefined;
     }>
   | Readonly<{
@@ -108,23 +83,98 @@ export type SidebarDestination =
       content: ReactNode;
     }>;
 
-export type SidebarController = Readonly<{
+export type SidebarDestinationPolicy = Readonly<{
+  equals(left: SidebarDestination, right: SidebarDestination): boolean;
+  retainedState(destination: SidebarDestination, state: unknown): unknown;
+}>;
+
+export type SidebarPageNavigator = Readonly<{
+  back(): Exclude<SidebarNavigationOutcome, "unavailable">;
+  close(): Exclude<SidebarNavigationOutcome, "unavailable">;
+  push(destination: SidebarDestination): SidebarNavigationOutcome;
+  replace(destination: SidebarDestination): Exclude<SidebarNavigationOutcome, "unavailable">;
+  registerAvailability(availability: Readonly<{ back: boolean; close: boolean }>): () => void;
+  registerCapture(capture: () => unknown): () => void;
+}>;
+
+export type SidebarRootHandle = Readonly<{
+  lifecycle: Promise<SidebarRootOutcome>;
+  release(): void;
+}>;
+
+export type SidebarRootController = Readonly<{
+  open(destination: SidebarDestination): SidebarRootHandle;
+}>;
+
+export type SidebarShellController = Readonly<{
   activeDestination: SidebarDestination | null;
-  closeSidebar(reason?: SidebarCancelReason): void;
-  openSidebar(destination: SidebarDestination): Promise<SidebarResult>;
-  replaceSidebar(destination: SidebarDestination): void;
+  back(): SidebarNavigationOutcome;
+  backAvailable: boolean;
+  canGoBack: boolean;
+  close(): SidebarNavigationOutcome;
+  closeAvailable: boolean;
   phase: SidebarPhase;
-  resolveSidebar(result: Exclude<SidebarResult, SidebarCanceledResult>): void;
-  resizeSidebar(width: ResolvedSidebarWidth): void;
+  resize(width: ResolvedSidebarWidth): void;
   sidebarWidthPx: number;
+  transitionDirection: SidebarTransitionDirection | null;
 }>;
 
-export const SidebarContext = createContext<SidebarController | null>(null);
+export const SidebarRootContext = createContext<SidebarRootController | null>(null);
+export const SidebarShellContext = createContext<SidebarShellController | null>(null);
+const SidebarRootOwnerContext = createContext<SidebarRootController | null>(null);
+
+export function useSidebarRoots(): SidebarRootController {
+  const value = useContext(SidebarRootContext);
+  if (value === null) {
+    throw new Error("SidebarProvider is required");
+  }
+  return value;
+}
 
-export function useSidebar(): SidebarController {
-  const value = useContext(SidebarContext);
+export function useSidebarShell(): SidebarShellController {
+  const value = useContext(SidebarShellContext);
   if (value === null) {
     throw new Error("SidebarProvider is required");
   }
   return value;
 }
+
+export function SidebarRootOwner({ children }: Readonly<{ children: ReactNode }>) {
+  const roots = useSidebarRoots();
+  const [handles] = useState(() => new Set<SidebarRootHandle>());
+  const open = useCallback(
+    (destination: SidebarDestination) => {
+      const handle = roots.open(destination);
+      handles.add(handle);
+      void handle.lifecycle.finally(() => {
+        handles.delete(handle);
+      });
+      return handle;
+    },
+    [handles, roots],
+  );
+  useEffect(
+    () => () => {
+      for (const handle of handles) handle.release();
+      handles.clear();
+    },
+    [handles],
+  );
+  const value = useMemo(() => ({ open }), [open]);
+  return createElement(SidebarRootOwnerContext.Provider, { value }, children);
+}
+
+export function useOwnedSidebarRoots(): SidebarRootController {
+  const value = useContext(SidebarRootOwnerContext);
+  if (value === null) throw new Error("SidebarRootOwner is required");
+  return value;
+}
+
+export function useSidebarBackWhen(
+  condition: boolean,
+  navigator: SidebarPageNavigator | undefined,
+): void {
+  useEffect(() => {
+    if (condition) navigator?.back();
+  }, [condition, navigator]);
+}