@tuturuuu/ui 0.37.1 → 0.37.2

package/src/hooks/__tests__/use-visible-workspaces.test.tsx

@@ -0,0 +1,76 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { renderHook, waitFor } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { beforeEach, expect, it, vi } from 'vitest';
+import { useVisibleWorkspaces } from '../use-visible-workspaces';
+import { WorkspaceVisibilityProvider } from '../use-workspace-visibility';
+
+const mocks = vi.hoisted(() => ({ list: vi.fn(), hidden: vi.fn() }));
+vi.mock('@tuturuuu/internal-api/workspaces', () => ({
+  listWorkspaces: mocks.list,
+}));
+vi.mock('@tuturuuu/internal-api/users', () => ({
+  getCurrentUserHiddenWorkspaces: mocks.hidden,
+  updateCurrentUserHiddenWorkspace: vi.fn(),
+}));
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.list.mockResolvedValue([{ id: 'visible' }, { id: 'hidden' }]);
+  mocks.hidden.mockResolvedValue({ hiddenWorkspaceIds: ['hidden'] });
+});
+function fixture() {
+  const client = new QueryClient({
+    defaultOptions: { queries: { retry: false, retryDelay: 0 } },
+  });
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={client}>
+      <WorkspaceVisibilityProvider actorId="A">
+        {children}
+      </WorkspaceVisibilityProvider>
+    </QueryClientProvider>
+  );
+  return { client, wrapper };
+}
+it('retains an explicit zero bound and only exposes known visible choices', async () => {
+  const { client, wrapper } = fixture();
+  const { result } = renderHook(() => useVisibleWorkspaces(true, 0), {
+    wrapper,
+  });
+  await waitFor(() => expect(result.current.data).toEqual([{ id: 'visible' }]));
+  expect(mocks.list).toHaveBeenCalledWith({ limit: 0 });
+  expect(client.getQueryData(['workspace-ui-list', 'A', 0])).toHaveLength(2);
+});
+it('settled private discovery failure is an error rather than permanent loading', async () => {
+  mocks.hidden.mockRejectedValue(new Error('offline'));
+  const { client, wrapper } = fixture();
+  const { result } = renderHook(() => useVisibleWorkspaces(), { wrapper });
+  await waitFor(() =>
+    expect(client.getQueryState(['workspace-hidden', 'A'])?.status).toBe(
+      'error'
+    )
+  );
+  await waitFor(() => expect(result.current.isLoading).toBe(false));
+  expect(result.current.isError).toBe(true);
+  expect(result.current.error?.message).toBe('offline');
+  expect(result.current.data).toBeUndefined();
+});
+
+it('distinguishes an absent personal workspace from one excluded by Hidden preferences', async () => {
+  mocks.list.mockResolvedValue([{ id: 'team', personal: false }]);
+  const { client, wrapper } = fixture();
+  const { result } = renderHook(() => useVisibleWorkspaces(), { wrapper });
+  await waitFor(() =>
+    expect(result.current.personalWorkspaceMissing).toBe(true)
+  );
+  mocks.list.mockResolvedValue([
+    { id: 'team', personal: false },
+    { id: 'personal', personal: true },
+  ]);
+  mocks.hidden.mockResolvedValue({ hiddenWorkspaceIds: ['personal'] });
+  await result.current.refetch();
+  await waitFor(() =>
+    expect(result.current.data).toEqual([{ id: 'team', personal: false }])
+  );
+  expect(result.current.personalWorkspaceMissing).toBe(false);
+  expect(client.getQueryData(['workspace-ui-list', 'A'])).toHaveLength(2);
+});

package/src/hooks/__tests__/use-workspace-visibility.test.tsx

@@ -0,0 +1,155 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, renderHook, waitFor } from '@testing-library/react';
+import type { ReactNode } from 'react';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import {
+  useWorkspaceVisibility,
+  WorkspaceVisibilityProvider,
+} from '../use-workspace-visibility';
+
+const mocks = vi.hoisted(() => ({ get: vi.fn(), put: vi.fn() }));
+vi.mock('@tuturuuu/internal-api/users', () => ({
+  getCurrentUserHiddenWorkspaces: mocks.get,
+  updateCurrentUserHiddenWorkspace: mocks.put,
+}));
+function deferred<T>() {
+  let resolve!: (v: T) => void;
+  let reject!: (e: Error) => void;
+  const promise = new Promise<T>((a, b) => {
+    resolve = a;
+    reject = b;
+  });
+  return { promise, resolve, reject };
+}
+function setup(
+  actor = 'A',
+  client = new QueryClient({
+    defaultOptions: { queries: { retry: false }, mutations: { retry: false } },
+  })
+) {
+  const wrapper = ({ children }: { children: ReactNode }) => (
+    <QueryClientProvider client={client}>
+      <WorkspaceVisibilityProvider actorId={actor}>
+        {children}
+      </WorkspaceVisibilityProvider>
+    </QueryClientProvider>
+  );
+  return { ...renderHook(() => useWorkspaceVisibility(), { wrapper }), client };
+}
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.get.mockResolvedValue({ hiddenWorkspaceIds: [] });
+  mocks.put.mockResolvedValue({});
+});
+describe('private owner-scoped workspace visibility', () => {
+  it('optimistically hides and rolls back only the failed workspace', async () => {
+    const write = deferred<object>();
+    mocks.put.mockReturnValue(write.promise);
+    const hook = setup();
+    await waitFor(() => expect(hook.result.current.known).toBe(true));
+    let operation!: Promise<void>;
+    act(() => {
+      operation = hook.result.current.setHidden('ws-1', true);
+    });
+    await waitFor(() =>
+      expect(hook.result.current.hiddenIds).toEqual(['ws-1'])
+    );
+    await act(async () => {
+      write.reject(new Error('offline'));
+      await expect(operation).rejects.toThrow('offline');
+    });
+    expect(hook.result.current.hiddenIds).toEqual([]);
+    expect(hook.result.current.updateError).not.toBeNull();
+    expect(mocks.put).toHaveBeenCalledWith('ws-1', true, 'A');
+    await act(async () => {
+      await hook.result.current.refetch();
+    });
+    expect(hook.result.current.updateError).toBeNull();
+  });
+  it('a stale refresh cannot replace optimistic state', async () => {
+    const hook = setup();
+    await waitFor(() => expect(hook.result.current.known).toBe(true));
+    const read = deferred<{ hiddenWorkspaceIds: string[] }>();
+    mocks.get
+      .mockImplementationOnce(() => read.promise)
+      .mockResolvedValue({ hiddenWorkspaceIds: ['ws-1'] });
+    act(() => {
+      void hook.result.current.refetch();
+    });
+    await act(async () => {
+      await hook.result.current.setHidden('ws-1', true);
+    });
+    await act(async () => {
+      read.resolve({ hiddenWorkspaceIds: [] });
+    });
+    expect(hook.result.current.hiddenIds).toEqual(['ws-1']);
+  });
+  it('suppresses duplicate writes for the same pending workspace', async () => {
+    const write = deferred<object>();
+    mocks.put.mockReturnValue(write.promise);
+    const hook = setup();
+    await waitFor(() => expect(hook.result.current.known).toBe(true));
+    let operation!: Promise<void>;
+    act(() => {
+      operation = hook.result.current.setHidden('ws-1', true);
+    });
+    await waitFor(() =>
+      expect(hook.result.current.pending.has('ws-1')).toBe(true)
+    );
+    await act(async () => {
+      await hook.result.current.setHidden('ws-1', true);
+    });
+    expect(mocks.put).toHaveBeenCalledTimes(1);
+    await act(async () => {
+      write.resolve({});
+      await operation;
+    });
+  });
+  it('removes private owner caches on logout and ignores late response', async () => {
+    const hook = setup();
+    await waitFor(() => expect(hook.result.current.known).toBe(true));
+    const write = deferred<object>();
+    mocks.put.mockReturnValue(write.promise);
+    let operation!: Promise<void>;
+    act(() => {
+      operation = hook.result.current.setHidden('ws-1', true);
+    });
+    await waitFor(() =>
+      expect(hook.result.current.hiddenIds).toEqual(['ws-1'])
+    );
+    hook.unmount();
+    write.resolve({});
+    await operation;
+    expect(hook.client.getQueryData(['workspace-hidden', 'A'])).toBeUndefined();
+    expect(hook.client.getQueryData(['workspace-hidden', 'B'])).toBeUndefined();
+  });
+  it('two actors use independent hidden cache keys', async () => {
+    mocks.get.mockImplementation(async (actor: string) => ({
+      hiddenWorkspaceIds: actor === 'A' ? ['ws-1'] : [],
+    }));
+    const client = new QueryClient({
+      defaultOptions: { queries: { retry: false } },
+    });
+    const a = setup('A', client);
+    const b = setup('B', client);
+    await waitFor(() => expect(a.result.current.hiddenIds).toEqual(['ws-1']));
+    await waitFor(() => expect(b.result.current.known).toBe(true));
+    expect(b.result.current.hiddenIds).toEqual([]);
+  });
+});
+
+it('settles a refetch safely after logout without returning private old-actor data', async () => {
+  const hook = setup();
+  await waitFor(() => expect(hook.result.current.known).toBe(true));
+  const read = deferred<{ hiddenWorkspaceIds: string[] }>();
+  mocks.get.mockReturnValue(read.promise);
+  let operation!: ReturnType<typeof hook.result.current.refetch>;
+  act(() => {
+    operation = hook.result.current.refetch();
+  });
+  await waitFor(() => expect(mocks.get).toHaveBeenCalledTimes(2));
+  hook.unmount();
+  read.resolve({ hiddenWorkspaceIds: ['old-private'] });
+  await expect(operation).resolves.toBeNull();
+  expect(hook.client.getQueryData(['workspace-hidden', 'A'])).toBeUndefined();
+});

package/src/hooks/__tests__/workspace-actor-lifetime.test.tsx

@@ -0,0 +1,103 @@
+import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
+import { act, render, screen, waitFor } from '@testing-library/react';
+import { beforeEach, expect, it, vi } from 'vitest';
+import { useWorkspaceUser } from '../use-workspace-user';
+import {
+  useWorkspaceVisibility,
+  WorkspaceVisibilityProvider,
+} from '../use-workspace-visibility';
+
+const mocks = vi.hoisted(() => ({ hidden: vi.fn(), profile: vi.fn() }));
+vi.mock('@tuturuuu/internal-api/users', () => ({
+  getCurrentUserHiddenWorkspaces: mocks.hidden,
+  getCurrentUserProfile: mocks.profile,
+  updateCurrentUserHiddenWorkspace: vi.fn(),
+}));
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.hidden.mockResolvedValue({ hiddenWorkspaceIds: ['private'] });
+  mocks.profile.mockResolvedValue({ id: 'A' });
+});
+function Probe() {
+  const hidden = useWorkspaceVisibility();
+  const user = useWorkspaceUser();
+  return (
+    <output>
+      {JSON.stringify({
+        known: hidden.known,
+        ids: hidden.hiddenIds,
+        user: user.data?.id,
+      })}
+    </output>
+  );
+}
+function fixture() {
+  return new QueryClient({
+    defaultOptions: { queries: { retry: false, retryDelay: 0 } },
+  });
+}
+it('retains the root owner cache across same-actor route unmount and remount', async () => {
+  const client = fixture();
+  function Tree({ route }: { route: boolean }) {
+    return (
+      <QueryClientProvider client={client}>
+        <WorkspaceVisibilityProvider actorId="A">
+          {route && (
+            <WorkspaceVisibilityProvider actorId="A">
+              <Probe />
+            </WorkspaceVisibilityProvider>
+          )}
+        </WorkspaceVisibilityProvider>
+      </QueryClientProvider>
+    );
+  }
+  const tree = render(<Tree route />);
+  await waitFor(() =>
+    expect(screen.getByRole('status').textContent).toContain('"known":true')
+  );
+  await waitFor(() =>
+    expect(client.getQueryData(['workspace-user', 'A'])).toMatchObject({
+      id: 'A',
+    })
+  );
+  tree.rerender(<Tree route={false} />);
+  expect(client.getQueryData(['workspace-hidden', 'A'])).toEqual(['private']);
+  tree.rerender(<Tree route />);
+  await waitFor(() =>
+    expect(screen.getByRole('status').textContent).toContain('private')
+  );
+  expect(mocks.hidden).toHaveBeenCalledTimes(1);
+  expect(mocks.profile).toHaveBeenCalledTimes(1);
+  expect(client.getQueryData(['workspace-user'])).toBeUndefined();
+  tree.unmount();
+  expect(client.getQueryData(['workspace-hidden', 'A'])).toBeUndefined();
+  expect(client.getQueryData(['workspace-user', 'A'])).toBeUndefined();
+});
+it('does not read profiles or private preferences without verified identity', async () => {
+  const client = fixture();
+  render(
+    <QueryClientProvider client={client}>
+      <Probe />
+    </QueryClientProvider>
+  );
+  await act(async () => {});
+  expect(mocks.profile).not.toHaveBeenCalled();
+  expect(mocks.hidden).not.toHaveBeenCalled();
+  expect(screen.getByRole('status').textContent).toContain('"known":false');
+});
+it('fails a mismatched route actor closed under a verified root', async () => {
+  const client = fixture();
+  render(
+    <QueryClientProvider client={client}>
+      <WorkspaceVisibilityProvider actorId="B">
+        <WorkspaceVisibilityProvider actorId="A">
+          <Probe />
+        </WorkspaceVisibilityProvider>
+      </WorkspaceVisibilityProvider>
+    </QueryClientProvider>
+  );
+  await act(async () => {});
+  expect(mocks.profile).not.toHaveBeenCalled();
+  expect(mocks.hidden).not.toHaveBeenCalled();
+  expect(screen.getByRole('status').textContent).toContain('"known":false');
+});

package/src/hooks/use-visible-workspaces.ts

@@ -0,0 +1,57 @@
+'use client';
+
+import { useQuery } from '@tanstack/react-query';
+import { listWorkspaces } from '@tuturuuu/internal-api/workspaces';
+import {
+  useWorkspaceActor,
+  useWorkspaceVisibility,
+} from './use-workspace-visibility';
+
+/** UI choices only. Do not use this hook for access or membership reconciliation. */
+export function useVisibleWorkspaces(
+  enabled = true,
+  limit?: number,
+  options?: { refetchInterval?: number }
+) {
+  const actor = useWorkspaceActor();
+  const visibility = useWorkspaceVisibility(enabled);
+  const query = useQuery({
+    queryKey: [
+      'workspace-ui-list',
+      actor?.actorId,
+      ...(limit !== undefined ? [limit] : []),
+    ],
+    enabled: enabled && Boolean(actor),
+    refetchInterval: options?.refetchInterval,
+    queryFn: async () => {
+      actor!.assertActive();
+      const result = await listWorkspaces(
+        limit !== undefined ? { limit } : undefined
+      );
+      actor!.assertActive();
+      return result;
+    },
+  });
+  const data = visibility.known
+    ? query.data?.filter(
+        (workspace) => !visibility.hiddenIds.includes(workspace.id)
+      )
+    : undefined;
+  return {
+    ...query,
+    personalWorkspaceMissing:
+      visibility.known &&
+      query.data !== undefined &&
+      !query.data.some((workspace) => workspace.personal),
+    data,
+    isLoading:
+      enabled &&
+      (query.isLoading || (!visibility.known && !visibility.isError)),
+    isError: query.isError || visibility.isError,
+    error: query.error ?? visibility.error,
+    refetch: async () => {
+      const visibilityResult = await visibility.refetch();
+      return visibilityResult ? query.refetch() : null;
+    },
+  };
+}

package/src/hooks/use-workspace-user.ts

@@ -3,6 +3,7 @@
 import { useQuery } from '@tanstack/react-query';
 import { getCurrentUserProfile } from '@tuturuuu/internal-api/users';
 import type { WorkspaceUser } from '@tuturuuu/types/primitives/WorkspaceUser';
+import { useWorkspaceActor } from './use-workspace-visibility';
 
 /**
  * Hook to fetch the current workspace user with their private details
@@ -10,11 +11,18 @@ import type { WorkspaceUser } from '@tuturuuu/types/primitives/WorkspaceUser';
  *
  * @returns Query object with user data, loading state, and error info
  */
-export function useWorkspaceUser() {
-  return useQuery({
-    queryKey: ['workspace-user'],
+export function useWorkspaceUser(actorId?: string) {
+  const actor = useWorkspaceActor();
+  const resolvedActorId = actorId ?? actor?.actorId;
+  const query = useQuery({
+    queryKey: ['workspace-user', resolvedActorId],
+    enabled: Boolean(actor) && actor?.actorId === resolvedActorId,
     queryFn: async (): Promise<WorkspaceUser> => {
+      actor!.assertActive();
       const data = await getCurrentUserProfile();
+      actor!.assertActive();
+      if (data.id !== resolvedActorId)
+        throw new Error('Workspace account changed');
       return {
         id: data.id,
         email: data.email,
@@ -30,4 +38,8 @@ export function useWorkspaceUser() {
     gcTime: 10 * 60 * 1000, // Keep cached data for 10 minutes
     retry: 1, // Retry once on failure
   });
+  return {
+    ...query,
+    data: actor?.actorId === resolvedActorId ? query.data : undefined,
+  };
 }

package/src/hooks/use-workspace-visibility.ts

@@ -0,0 +1,234 @@
+'use client';
+
+import {
+  type QueryClient,
+  useQuery,
+  useQueryClient,
+} from '@tanstack/react-query';
+import { InternalApiError } from '@tuturuuu/internal-api/client';
+import {
+  getCurrentUserHiddenWorkspaces,
+  updateCurrentUserHiddenWorkspace,
+} from '@tuturuuu/internal-api/users';
+import {
+  createContext,
+  createElement,
+  type ReactNode,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
+
+const controls = new WeakMap<
+  QueryClient,
+  Map<string, { revision: number; pending: Set<string> }>
+>();
+function ownerControl(client: QueryClient, actorId: string) {
+  let actors = controls.get(client);
+  if (!actors) {
+    actors = new Map();
+    controls.set(client, actors);
+  }
+  let control = actors.get(actorId);
+  if (!control) {
+    control = { revision: 0, pending: new Set() };
+    actors.set(actorId, control);
+  }
+  return control;
+}
+
+type ActorScope = {
+  actorId: string;
+  lifetime: { active: boolean };
+  assertActive: () => void;
+};
+const ActorContext = createContext<ActorScope | null>(null);
+
+/** Feed only a server-verified actor; preferences never become membership data. */
+export function WorkspaceVisibilityProvider({
+  actorId,
+  children,
+}: {
+  actorId: string;
+  children: ReactNode;
+}) {
+  const parent = useContext(ActorContext);
+  const current = useRef(actorId);
+  current.current = actorId;
+  const scope = useMemo(() => {
+    if (parent?.actorId === actorId) return parent;
+    const lifetime = { active: true };
+    return {
+      actorId,
+      lifetime,
+      assertActive() {
+        parent?.assertActive();
+        if (
+          !lifetime.active ||
+          current.current !== actorId ||
+          (parent && parent.actorId !== actorId)
+        ) {
+          throw new Error('Workspace account changed');
+        }
+      },
+    };
+  }, [actorId, parent]);
+  const client = useQueryClient();
+  useEffect(() => {
+    if (scope === parent) return;
+    scope.lifetime.active = true;
+    return () => {
+      scope.lifetime.active = false;
+      controls.get(client)?.delete(scope.actorId);
+      // A private cache is never retained across logout/account replacement.
+      client.removeQueries({ queryKey: ['workspace-hidden', scope.actorId] });
+      client.removeQueries({ queryKey: ['workspace-ui-list', scope.actorId] });
+      client.removeQueries({ queryKey: ['user-workspaces', scope.actorId] });
+      client.removeQueries({ queryKey: ['all-user-boards', scope.actorId] });
+      client.removeQueries({ queryKey: ['chat-workspaces', scope.actorId] });
+      client.removeQueries({ queryKey: ['task-source-boards', scope.actorId] });
+      client.removeQueries({ queryKey: ['workspace-user', scope.actorId] });
+      client.removeQueries({
+        queryKey: ['workspace-invitations', scope.actorId],
+      });
+      client.removeQueries({
+        predicate: (query) =>
+          query.queryKey[0] === 'global-command-launcher' &&
+          query.queryKey.includes(scope.actorId),
+      });
+      client.removeQueries({
+        queryKey: ['workspace-select-current-workspace', scope.actorId],
+      });
+    };
+  }, [scope, parent, client]);
+  return createElement(
+    ActorContext.Provider,
+    {
+      key: actorId,
+      value: parent && parent.actorId !== actorId ? null : scope,
+    },
+    children
+  );
+}
+
+export function useWorkspaceActor() {
+  return useContext(ActorContext);
+}
+
+export function useWorkspaceVisibility(enabled = true) {
+  const scope = useWorkspaceActor();
+  const actorId = scope?.actorId;
+  const client = useQueryClient();
+  const key = ['workspace-hidden', actorId] as const;
+  const control = ownerControl(client, actorId ?? 'signed-out');
+  const [pending, setPending] = useState<Set<string>>(new Set());
+  const [updateError, setUpdateError] = useState<Error | null>(null);
+  const query = useQuery({
+    queryKey: key,
+    enabled: enabled && Boolean(scope),
+    queryFn: async () => {
+      scope!.assertActive();
+      if (control.pending.size > 0) {
+        const optimistic = client.getQueryData<string[]>(key);
+        if (optimistic) return optimistic;
+      }
+      const requestRevision = control.revision;
+      const response = await getCurrentUserHiddenWorkspaces(actorId!);
+      scope!.assertActive();
+      // A refresh started before a mutation cannot overwrite its optimistic state.
+      if (requestRevision !== control.revision) {
+        return (
+          client.getQueryData<string[]>(key) ?? response.hiddenWorkspaceIds
+        );
+      }
+      return response.hiddenWorkspaceIds;
+    },
+    staleTime: 30_000,
+    retry: 1,
+  });
+  const accountDenied =
+    query.error instanceof InternalApiError &&
+    [401, 403, 409].includes(query.error.status);
+  const ids = accountDenied ? undefined : query.data;
+  async function setHidden(workspaceId: string, hidden: boolean) {
+    if (!scope || !ids || control.pending.has(workspaceId)) return;
+    scope.assertActive();
+    const ownerKey = ['workspace-hidden', scope.actorId] as const;
+    const wasHidden = ids.includes(workspaceId);
+    control.pending.add(workspaceId);
+    setPending(new Set(control.pending));
+    setUpdateError(null);
+    control.revision++;
+    await client.cancelQueries({ queryKey: ownerKey });
+    scope.assertActive();
+    client.setQueryData<string[]>(ownerKey, (current = []) =>
+      hidden
+        ? [...new Set([...current, workspaceId])]
+        : current.filter((id) => id !== workspaceId)
+    );
+    try {
+      await updateCurrentUserHiddenWorkspace(
+        workspaceId,
+        hidden,
+        scope.actorId
+      );
+      scope.assertActive();
+    } catch (error) {
+      try {
+        scope.assertActive();
+      } catch {
+        return;
+      }
+      client.setQueryData<string[]>(ownerKey, (current = []) =>
+        wasHidden
+          ? [...new Set([...current, workspaceId])]
+          : current.filter((id) => id !== workspaceId)
+      );
+      setUpdateError(
+        error instanceof Error
+          ? error
+          : new Error('Unable to update Hidden workspaces')
+      );
+      throw error;
+    } finally {
+      control.pending.delete(workspaceId);
+      try {
+        scope.assertActive();
+        setPending(new Set(control.pending));
+        if (control.pending.size === 0) {
+          void client.invalidateQueries({ queryKey: ownerKey });
+        }
+      } catch {
+        /* An old account cannot publish into the next account. */
+      }
+    }
+  }
+  return {
+    ...query,
+    refetch: async () => {
+      if (!scope) return null;
+      try {
+        scope.assertActive();
+      } catch {
+        return null;
+      }
+      const result = await query.refetch();
+      try {
+        scope.assertActive();
+      } catch {
+        return null;
+      }
+      if (!result.error) setUpdateError(null);
+      return result;
+    },
+    accountDenied,
+    actorId,
+    hiddenIds: ids ?? [],
+    known: ids !== undefined,
+    pending,
+    updateError,
+    setHidden,
+  };
+}