@tuturuuu/utils 0.24.2 → 0.25.1

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## [0.25.1](https://github.com/tutur3u/platform/compare/utils-v0.25.0...utils-v0.25.1) (2026-08-15)
+
+
+### Bug Fixes
+
+* **contacts:** harden invited profile access ([19878d0](https://github.com/tutur3u/platform/commit/19878d06466eafc8cef74af52e14ddbdb6eef510))
+
+## [0.25.0](https://github.com/tutur3u/platform/compare/utils-v0.24.2...utils-v0.25.0) (2026-08-14)
+
+
+### Features
+
+* **workspaces:** assign roles to pending invites ([#5125](https://github.com/tutur3u/platform/issues/5125)) ([d4052fd](https://github.com/tutur3u/platform/commit/d4052fd40de66bda4e9535740bbcfd5a8da19123))
+
+
+### Bug Fixes
+
+* **contacts:** harden satellite workspace access ([b160723](https://github.com/tutur3u/platform/commit/b160723b509062a4f8edf2694c0af27c25c05775))
+* **tasks:** keep dropped cards in destination ([de9353b](https://github.com/tutur3u/platform/commit/de9353b0b3574b240c0caa478ba52935d3ad00bb))
+* **tasks:** render dropped tasks immediately ([1dcdb65](https://github.com/tutur3u/platform/commit/1dcdb655ff960c59f91b93b7f13622d1b65f6f48))
+
 ## [0.24.2](https://github.com/tutur3u/platform/compare/utils-v0.24.1...utils-v0.24.2) (2026-08-11)
 
 

package/biome.json

@@ -1,5 +1,5 @@
 {
   "root": false,
-  "$schema": "https://biomejs.dev/schemas/2.5.7/schema.json",
+  "$schema": "https://biomejs.dev/schemas/2.5.8/schema.json",
   "extends": "//"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tuturuuu/utils",
   "license": "MIT",
-  "version": "0.24.2",
+  "version": "0.25.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/tutur3u/platform",
@@ -17,14 +17,14 @@
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
-    "@noble/ciphers": "^2.2.0",
-    "@noble/hashes": "^2.2.0",
+    "@noble/ciphers": "^2.3.0",
+    "@noble/hashes": "^2.3.0",
     "@tanstack/react-query": "^5.101.4",
-    "@tiptap/core": "3.29.2",
-    "@tiptap/react": "3.29.2",
+    "@tiptap/core": "3.30.0",
+    "@tiptap/react": "3.30.0",
     "@tuturuuu/google": "0.1.0",
     "@tuturuuu/icons": "0.1.0",
-    "@tuturuuu/internal-api": "0.29.1",
+    "@tuturuuu/internal-api": "0.31.0",
     "@tuturuuu/supabase": "0.5.0",
     "@upstash/ratelimit": "^2.0.8",
     "@upstash/redis": "^1.38.2",
@@ -34,7 +34,7 @@
     "diff": "^9.0.0",
     "effect": "^3.22.1",
     "moment": "^2.30.1",
-    "next": "^16.3.0",
+    "next": "^16.3.1",
     "prosemirror-model": "^1.25.11",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
@@ -48,11 +48,11 @@
     "@tuturuuu/types": "0.27.0",
     "@tuturuuu/typescript-config": "0.1.1",
     "@types/diff": "^8.0.0",
-    "@types/node": "^26.1.2",
+    "@types/node": "^26.2.0",
     "@types/react": "^19.2.18",
     "@vitejs/plugin-react": "^6.0.5",
     "typescript": "7.0.2",
-    "vite": "^8.2.0",
+    "vite": "^8.2.1",
     "vitest": "^4.1.10"
   },
   "exports": {

package/src/__tests__/optimistic-task-cache.test.ts

@@ -0,0 +1,117 @@
+import { QueryClient } from '@tanstack/react-query';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+import { describe, expect, it } from 'vitest';
+import {
+  insertOptimisticTaskIntoBoardCaches,
+  reconcileOptimisticTaskInBoardCaches,
+  removeOptimisticTaskFromBoardCaches,
+} from '../task-helper/optimistic-task-cache';
+
+function task(id: string, listId = 'list-1'): Task {
+  return {
+    assignees: [],
+    created_at: '2026-08-14T00:00:00.000Z',
+    id,
+    labels: [],
+    list_id: listId,
+    name: id,
+    projects: [],
+  } as unknown as Task;
+}
+
+describe('optimistic task creation cache lifecycle', () => {
+  it('inserts the pending task into the board and every mounted full-task variant', () => {
+    const queryClient = new QueryClient();
+    const boardId = 'board-1';
+    const existingTask = task('existing');
+    const optimisticTask = {
+      ...task('optimistic-1'),
+      _isOptimistic: true,
+    } as Task;
+
+    queryClient.setQueryData(['tasks', boardId], [existingTask]);
+    queryClient.setQueryData(['tasks-full', boardId], [existingTask]);
+    queryClient.setQueryData(
+      ['tasks-full', boardId, 'filtered'],
+      [existingTask]
+    );
+    queryClient.setQueryData(['tasks-full', 'another-board'], [existingTask]);
+
+    insertOptimisticTaskIntoBoardCaches(queryClient, boardId, optimisticTask);
+
+    expect(queryClient.getQueryData(['tasks', boardId])).toEqual([
+      existingTask,
+      optimisticTask,
+    ]);
+    expect(queryClient.getQueryData(['tasks-full', boardId])).toEqual([
+      existingTask,
+      optimisticTask,
+    ]);
+    expect(
+      queryClient.getQueryData(['tasks-full', boardId, 'filtered'])
+    ).toEqual([existingTask, optimisticTask]);
+    expect(queryClient.getQueryData(['tasks-full', 'another-board'])).toEqual([
+      existingTask,
+    ]);
+  });
+
+  it('replaces the pending task without duplicating a realtime server task', () => {
+    const queryClient = new QueryClient();
+    const boardId = 'board-1';
+    const optimisticTask = {
+      ...task('optimistic-1'),
+      _isOptimistic: true,
+    } as Task;
+    const createdTask = task('created-1');
+
+    queryClient.setQueryData(['tasks', boardId], [optimisticTask]);
+    queryClient.setQueryData(
+      ['tasks-full', boardId, 'filtered'],
+      [optimisticTask, createdTask]
+    );
+
+    reconcileOptimisticTaskInBoardCaches(
+      queryClient,
+      boardId,
+      optimisticTask.id,
+      createdTask
+    );
+
+    expect(queryClient.getQueryData(['tasks', boardId])).toEqual([createdTask]);
+    expect(
+      queryClient.getQueryData(['tasks-full', boardId, 'filtered'])
+    ).toEqual([createdTask]);
+  });
+
+  it('rolls back only the failed optimistic task', () => {
+    const queryClient = new QueryClient();
+    const boardId = 'board-1';
+    const optimisticTask = {
+      ...task('optimistic-1'),
+      _isOptimistic: true,
+    } as Task;
+    const concurrentTask = task('concurrent');
+
+    queryClient.setQueryData(
+      ['tasks', boardId],
+      [optimisticTask, concurrentTask]
+    );
+    queryClient.setQueryData(
+      ['tasks-full', boardId, 'filtered'],
+      [optimisticTask, concurrentTask]
+    );
+
+    removeOptimisticTaskFromBoardCaches(
+      queryClient,
+      boardId,
+      optimisticTask.id
+    );
+
+    expect(queryClient.getQueryData(['tasks', boardId])).toEqual([
+      concurrentTask,
+    ]);
+    expect(
+      queryClient.getQueryData(['tasks-full', boardId, 'filtered'])
+    ).toEqual([concurrentTask]);
+  });
+});

package/src/__tests__/task-reorder-cache.test.ts

@@ -1,7 +1,9 @@
+import { QueryClient } from '@tanstack/react-query';
 import type { Task } from '@tuturuuu/types/primitives/Task';
 import { describe, expect, it, vi } from 'vitest';
 
 import {
+  cancelStaleTaskBoardQueries,
   mergeOptimisticReorderedTaskIntoCache,
   mergeServerReorderedTaskIntoCache,
 } from '../task/reorder';
@@ -19,6 +21,22 @@ function createTask(overrides: Partial<Task> = {}): Task {
 }
 
 describe('reorder task cache helpers', () => {
+  it('cancels stale board fetches without reverting the dropped destination', () => {
+    const queryClient = new QueryClient();
+    const cancelQueries = vi.spyOn(queryClient, 'cancelQueries');
+
+    cancelStaleTaskBoardQueries(queryClient, 'board-1');
+
+    expect(cancelQueries).toHaveBeenCalledWith(
+      { queryKey: ['tasks', 'board-1'] },
+      { revert: false }
+    );
+    expect(cancelQueries).toHaveBeenCalledWith(
+      { queryKey: ['tasks-full', 'board-1'] },
+      { revert: false }
+    );
+  });
+
   it('marks optimistic list moves so stale list loads cannot move the card back', () => {
     vi.useFakeTimers();
     vi.setSystemTime(new Date('2026-05-07T01:00:00.000Z'));

package/src/next-config.test.ts

@@ -3,11 +3,13 @@ import { describe, expect, it } from 'vitest';
 import {
   createTuturuuuNextConfig,
   createTuturuuuWebWorkspaceApiRewrites,
+  getTuturuuuNextOptimizePackageImports,
   isTuturuuuNextCacheComponentsEnabled,
   isTuturuuuNextReactCompilerEnabled,
   isTuturuuuTurbopackRustReactCompilerEnabled,
   resolveTuturuuuInfrastructureAppUrl,
   resolveTuturuuuWebAppUrl,
+  TUTURUUU_NEXT_IMAGE_MINIMUM_CACHE_TTL_SECONDS,
   TUTURUUU_NEXT_IMAGE_REMOTE_PATTERNS,
   TUTURUUU_NEXT_OPTIMIZE_PACKAGE_IMPORTS,
   trimTrailingSlashes,
@@ -26,6 +28,9 @@ describe('createTuturuuuNextConfig', () => {
     expect(config.images?.remotePatterns).toEqual(
       TUTURUUU_NEXT_IMAGE_REMOTE_PATTERNS
     );
+    expect(config.images?.minimumCacheTTL).toBe(
+      TUTURUUU_NEXT_IMAGE_MINIMUM_CACHE_TTL_SECONDS
+    );
     expect(config.poweredByHeader).toBe(false);
     expect(config.reactCompiler).toBe(true);
     expect(config.reactStrictMode).toBe(true);
@@ -170,6 +175,25 @@ describe('createTuturuuuNextConfig', () => {
     ]);
   });
 
+  it('stabilizes the webpack-only E2E satellite fallback', () => {
+    const originalWebpackBuild = process.env.NEXT_WEBPACK_BUILD;
+
+    try {
+      process.env.NEXT_WEBPACK_BUILD = '1';
+      const config = createTuturuuuNextConfig();
+
+      expect(config.experimental?.devMemoryThresholdRestart).toBe(false);
+      expect(config.experimental?.optimizePackageImports).toEqual([]);
+      expect(config.experimental?.turbopackRustReactCompiler).toBe(false);
+    } finally {
+      if (originalWebpackBuild === undefined) {
+        delete process.env.NEXT_WEBPACK_BUILD;
+      } else {
+        process.env.NEXT_WEBPACK_BUILD = originalWebpackBuild;
+      }
+    }
+  });
+
   it('dedupes image remote patterns while preserving app additions', () => {
     const config = createTuturuuuNextConfig({
       images: {
@@ -198,6 +222,7 @@ describe('createTuturuuuNextConfig', () => {
       partialPrefetching: false,
       reactCompiler: false,
       transpilePackages: ['@tuturuuu/ui'],
+      images: { minimumCacheTTL: 86_400 },
       experimental: {
         cpus: 2,
         turbopackFileSystemCacheForBuild: false,
@@ -213,6 +238,7 @@ describe('createTuturuuuNextConfig', () => {
     expect(config.partialPrefetching).toBe(false);
     expect(config.reactCompiler).toBe(true);
     expect(config.transpilePackages).toEqual(['@tuturuuu/ui']);
+    expect(config.images?.minimumCacheTTL).toBe(86_400);
     expect(config.experimental?.cpus).toBe(2);
     expect(config.experimental?.turbopackFileSystemCacheForBuild).toBe(false);
     expect(config.experimental?.turbopackRustReactCompiler).toBe(false);
@@ -259,6 +285,11 @@ describe('createTuturuuuWebWorkspaceApiRewrites', () => {
         source: '/api/workspaces/invitations',
         destination: 'https://tuturuuu.com/api/workspaces/invitations',
       },
+      {
+        source: '/api/v1/workspaces/:wsId/settings/permissions',
+        destination:
+          'https://tuturuuu.com/api/v1/workspaces/:wsId/settings/permissions',
+      },
     ]);
   });
 });
@@ -296,6 +327,22 @@ describe('isTuturuuuTurbopackRustReactCompilerEnabled', () => {
   });
 });
 
+describe('getTuturuuuNextOptimizePackageImports', () => {
+  it('keeps shared package optimization for Turbopack', () => {
+    expect(getTuturuuuNextOptimizePackageImports(['@tuturuuu/ui'], {})).toEqual(
+      [...TUTURUUU_NEXT_OPTIMIZE_PACKAGE_IMPORTS, '@tuturuuu/ui']
+    );
+  });
+
+  it('avoids webpack React Server Consumer Manifest barrel corruption', () => {
+    expect(
+      getTuturuuuNextOptimizePackageImports(['@tuturuuu/ui'], {
+        NEXT_WEBPACK_BUILD: '1',
+      })
+    ).toEqual(['@tuturuuu/ui']);
+  });
+});
+
 describe('isTuturuuuNextReactCompilerEnabled', () => {
   it('keeps React Compiler enabled for next dev', () => {
     expect(

package/src/next-config.ts

@@ -15,6 +15,7 @@ export const TUTURUUU_NEXT_OPTIMIZE_PACKAGE_IMPORTS = [
 
 export const TUTURUUU_WEB_WORKSPACE_API_RESERVED_PATHS = [
   '/api/workspaces/invitations',
+  '/api/v1/workspaces/:wsId/settings/permissions',
 ] as const;
 
 type NextImageConfig = NonNullable<NextConfig['images']>;
@@ -37,6 +38,8 @@ export const TUTURUUU_NEXT_IMAGE_REMOTE_PATTERNS = [
   },
 ] satisfies NextImageRemotePattern[];
 
+export const TUTURUUU_NEXT_IMAGE_MINIMUM_CACHE_TTL_SECONDS = 7 * 24 * 60 * 60;
+
 const TUTURUUU_ANTI_FRAMING_SOURCE =
   '/:path((?!api/v1/workspaces/[^/]+/external-projects/assets/[^/]+/webgl(?:/|$)).*)';
 
@@ -93,6 +96,20 @@ export function isTuturuuuTurbopackRustReactCompilerEnabled(
   return env.NEXT_WEBPACK_BUILD !== '1';
 }
 
+export function getTuturuuuNextOptimizePackageImports(
+  appImports: readonly string[] | undefined,
+  env: Environment = process.env
+) {
+  // Next's webpack dev server can leave optimized workspace-package barrels
+  // out of the React Server Consumer Manifest after enough on-demand route
+  // compilations. E2E-owned satellites deliberately use webpack, so retain
+  // only explicit app imports there and keep the shared optimization for
+  // normal Turbopack development and production builds.
+  return env.NEXT_WEBPACK_BUILD === '1'
+    ? [...(appImports ?? [])]
+    : mergeStringArrays(TUTURUUU_NEXT_OPTIMIZE_PACKAGE_IMPORTS, appImports);
+}
+
 export function createTuturuuuNextConfig(config: NextConfig = {}): NextConfig {
   const experimentalConfig = config.experimental ?? {};
   const imageConfig = config.images ?? {};
@@ -111,6 +128,9 @@ export function createTuturuuuNextConfig(config: NextConfig = {}): NextConfig {
     ),
     images: {
       ...imageConfig,
+      minimumCacheTTL:
+        imageConfig.minimumCacheTTL ??
+        TUTURUUU_NEXT_IMAGE_MINIMUM_CACHE_TTL_SECONDS,
       remotePatterns: mergeRemotePatterns(
         TUTURUUU_NEXT_IMAGE_REMOTE_PATTERNS,
         imageConfig.remotePatterns
@@ -128,8 +148,10 @@ export function createTuturuuuNextConfig(config: NextConfig = {}): NextConfig {
       turbopackRustReactCompiler:
         experimentalConfig.turbopackRustReactCompiler ??
         isTuturuuuTurbopackRustReactCompilerEnabled(),
-      optimizePackageImports: mergeStringArrays(
-        TUTURUUU_NEXT_OPTIMIZE_PACKAGE_IMPORTS,
+      devMemoryThresholdRestart:
+        experimentalConfig.devMemoryThresholdRestart ??
+        process.env.NEXT_WEBPACK_BUILD !== '1',
+      optimizePackageImports: getTuturuuuNextOptimizePackageImports(
         experimentalConfig.optimizePackageImports
       ),
     },

package/src/platform-release.test.ts

@@ -7,7 +7,7 @@ import {
 
 describe('platform release metadata', () => {
   it('uses the centralized shared browser app version', () => {
-    expect(TUTURUUU_PLATFORM_VERSION).toBe('0.36.2'); // x-release-please-version
+    expect(TUTURUUU_PLATFORM_VERSION).toBe('0.38.0'); // x-release-please-version
   });
 
   it('preserves the source timestamp in builtAt and derives a short hash', () => {

package/src/platform-release.ts

@@ -1,6 +1,6 @@
 import { PLATFORM_BUILD_METADATA } from './generated/platform-build-metadata';
 
-export const TUTURUUU_PLATFORM_VERSION = '0.36.2'; // x-release-please-version
+export const TUTURUUU_PLATFORM_VERSION = '0.38.0'; // x-release-please-version
 
 export type PlatformBuildMetadataInput = {
   /** ISO timestamp of the source commit used for the build, not deployment time. */

package/src/task/reorder.ts

@@ -1,5 +1,6 @@
 import {
   type QueryClient,
+  type QueryKey,
   useMutation,
   useQueryClient,
 } from '@tanstack/react-query';
@@ -31,6 +32,7 @@ type ReorderTaskMutationInput = {
   newSortKey: number;
   optimisticPreviousTasks?: Task[];
   optimisticPreviousFullTasks?: Task[];
+  optimisticPreviousFullTaskEntries?: [QueryKey, Task[] | undefined][];
 };
 
 export function mergeOptimisticReorderedTaskIntoCache(
@@ -93,9 +95,24 @@ function setReorderedTaskCache(
 ) {
   queryClient.setQueryData(['tasks', boardId], updater);
 
-  if (queryClient.getQueryData<Task[]>(['tasks-full', boardId])) {
-    queryClient.setQueryData(['tasks-full', boardId], updater);
-  }
+  queryClient.setQueriesData<Task[]>(
+    { queryKey: ['tasks-full', boardId] },
+    updater
+  );
+}
+
+export function cancelStaleTaskBoardQueries(
+  queryClient: QueryClient,
+  boardId: string
+) {
+  void queryClient.cancelQueries(
+    { queryKey: ['tasks', boardId] },
+    { revert: false }
+  );
+  void queryClient.cancelQueries(
+    { queryKey: ['tasks-full', boardId] },
+    { revert: false }
+  );
 }
 
 // Reorder task within the same list or move to a different list with specific position
@@ -139,19 +156,21 @@ export function useReorderTask(boardId: string, wsId: string) {
       newSortKey,
       optimisticPreviousTasks,
       optimisticPreviousFullTasks,
+      optimisticPreviousFullTaskEntries,
     }) => {
       // Snapshot the previous value
       const previousTasks = queryClient.getQueryData<Task[]>([
         'tasks',
         boardId,
       ]);
-      const previousFullTasks = queryClient.getQueryData<Task[]>([
-        'tasks-full',
-        boardId,
-      ]);
+      const previousFullTaskEntries = queryClient.getQueriesData<Task[]>({
+        queryKey: ['tasks-full', boardId],
+      });
 
-      // Cancel any outgoing refetches without delaying the optimistic landing.
-      void queryClient.cancelQueries({ queryKey: ['tasks', boardId] });
+      // Keep the drop preview visible while cancelling stale board responses.
+      // The default cancellation behavior reverts to the pre-fetch snapshot,
+      // which makes a dropped card briefly jump back to its source list.
+      cancelStaleTaskBoardQueries(queryClient, boardId);
 
       // Check if moving to a done or closed list
       const targetList = queryClient.getQueryData(['task_lists', boardId]) as
@@ -194,7 +213,16 @@ export function useReorderTask(boardId: string, wsId: string) {
 
       return {
         previousTasks: optimisticPreviousTasks ?? previousTasks,
-        previousFullTasks: optimisticPreviousFullTasks ?? previousFullTasks,
+        previousFullTaskEntries:
+          optimisticPreviousFullTaskEntries ??
+          (optimisticPreviousFullTasks
+            ? [
+                [['tasks-full', boardId], optimisticPreviousFullTasks] as [
+                  QueryKey,
+                  Task[],
+                ],
+              ]
+            : previousFullTaskEntries),
         blockedTaskIdsPromise,
       };
     },
@@ -202,11 +230,8 @@ export function useReorderTask(boardId: string, wsId: string) {
       if (context?.previousTasks) {
         queryClient.setQueryData(['tasks', boardId], context.previousTasks);
       }
-      if (context?.previousFullTasks) {
-        queryClient.setQueryData(
-          ['tasks-full', boardId],
-          context.previousFullTasks
-        );
+      for (const [queryKey, tasks] of context?.previousFullTaskEntries ?? []) {
+        queryClient.setQueryData(queryKey, tasks);
       }
 
       console.error('Failed to reorder task:', err);

package/src/task-helper/optimistic-task-cache.ts

@@ -0,0 +1,105 @@
+import type { QueryClient } from '@tanstack/react-query';
+import type { Task } from '@tuturuuu/types/primitives/Task';
+
+export type OptimisticTask = Task & { _isOptimistic: true };
+
+function updateOptimisticTaskCaches(
+  queryClient: QueryClient,
+  boardId: string,
+  updater: (tasks: Task[] | undefined) => Task[] | undefined
+) {
+  queryClient.setQueryData<Task[]>(['tasks', boardId], updater);
+  queryClient.setQueriesData<Task[]>(
+    { queryKey: ['tasks-full', boardId] },
+    updater
+  );
+}
+
+export function createOptimisticTask(
+  task: Partial<Task> & Pick<Task, 'list_id' | 'name'>,
+  options: { id?: string; now?: Date } = {}
+): OptimisticTask {
+  const now = options.now ?? new Date();
+  const id =
+    options.id ??
+    `optimistic-${
+      typeof crypto !== 'undefined' && 'randomUUID' in crypto
+        ? crypto.randomUUID()
+        : `${now.getTime()}-${Math.random().toString(36).slice(2)}`
+    }`;
+
+  return {
+    ...task,
+    _isOptimistic: true,
+    assignees: task.assignees ?? [],
+    created_at: task.created_at ?? now.toISOString(),
+    id,
+    labels: task.labels ?? [],
+    projects: task.projects ?? [],
+  } as OptimisticTask;
+}
+
+export function insertOptimisticTaskIntoBoardCaches(
+  queryClient: QueryClient,
+  boardId: string,
+  optimisticTask: Task
+) {
+  void queryClient.cancelQueries(
+    { queryKey: ['tasks', boardId] },
+    { revert: false }
+  );
+  void queryClient.cancelQueries(
+    { queryKey: ['tasks-full', boardId] },
+    { revert: false }
+  );
+
+  updateOptimisticTaskCaches(queryClient, boardId, (tasks) => {
+    const currentTasks = tasks ?? [];
+    if (currentTasks.some((task) => task.id === optimisticTask.id)) {
+      return currentTasks;
+    }
+    return [...currentTasks, optimisticTask];
+  });
+}
+
+export function reconcileOptimisticTaskInBoardCaches(
+  queryClient: QueryClient,
+  boardId: string,
+  optimisticTaskId: string,
+  createdTask: Task
+) {
+  updateOptimisticTaskCaches(queryClient, boardId, (tasks) => {
+    if (!tasks) return [createdTask];
+
+    const optimisticIndex = tasks.findIndex(
+      (task) => task.id === optimisticTaskId
+    );
+    const createdIndex = tasks.findIndex((task) => task.id === createdTask.id);
+    const insertionIndex =
+      optimisticIndex >= 0
+        ? optimisticIndex
+        : createdIndex >= 0
+          ? createdIndex
+          : tasks.length;
+    const nextTasks = tasks.filter(
+      (task) => task.id !== optimisticTaskId && task.id !== createdTask.id
+    );
+
+    nextTasks.splice(
+      Math.min(insertionIndex, nextTasks.length),
+      0,
+      createdTask
+    );
+    return nextTasks;
+  });
+}
+
+export function removeOptimisticTaskFromBoardCaches(
+  queryClient: QueryClient,
+  boardId: string,
+  optimisticTaskId: string
+) {
+  updateOptimisticTaskCaches(queryClient, boardId, (tasks) =>
+    tasks?.filter((task) => task.id !== optimisticTaskId)
+  );
+}

package/src/task-helper/task-hooks-basic.ts

@@ -6,6 +6,12 @@ import {
 } from '@tuturuuu/internal-api/tasks';
 import type { Task } from '@tuturuuu/types/primitives/Task';
 
+import {
+  createOptimisticTask,
+  insertOptimisticTaskIntoBoardCaches,
+  reconcileOptimisticTaskInBoardCaches,
+  removeOptimisticTaskFromBoardCaches,
+} from './optimistic-task-cache';
 import { getBrowserApiOptions, toWorkspaceTaskUpdatePayload } from './shared';
 
 export function useUpdateTask(boardId: string, wsId?: string) {
@@ -165,69 +171,36 @@ export function useCreateTask(boardId: string, wsId?: string) {
       return createdTask as Task;
     },
     onMutate: async ({ listId, task }) => {
-      await queryClient.cancelQueries({ queryKey: ['tasks', boardId] });
-
-      const previousTasks = queryClient.getQueryData(['tasks', boardId]);
       const trimmedName = task.name?.trim() ?? '';
-
-      const optimisticTask: Task = {
+      const optimisticTask = createOptimisticTask({
         ...task,
-        id: `temp-${Date.now()}`,
         name: trimmedName,
         list_id: listId,
         closed_at: undefined,
         deleted_at: undefined,
-        created_at: new Date().toISOString(),
-        updated_at: new Date().toISOString(),
-        assignees: [],
-      } as Task;
+      });
 
-      queryClient.setQueryData(
-        ['tasks', boardId],
-        (old: Task[] | undefined) => {
-          if (!old) return [optimisticTask];
-          return [...old, optimisticTask];
-        }
-      );
+      insertOptimisticTaskIntoBoardCaches(queryClient, boardId, optimisticTask);
 
-      return { previousTasks, optimisticTask };
+      return { optimisticTask };
     },
     onError: (err, _, context) => {
-      if (context?.previousTasks) {
-        queryClient.setQueryData(['tasks', boardId], context.previousTasks);
-      } else if (context?.optimisticTask) {
-        queryClient.setQueryData(
-          ['tasks', boardId],
-          (old: Task[] | undefined) => {
-            if (!old) return old;
-            const nextTasks = old.filter(
-              (task) => task.id !== context.optimisticTask.id
-            );
-            return nextTasks.length > 0 ? nextTasks : undefined;
-          }
+      if (context?.optimisticTask) {
+        removeOptimisticTaskFromBoardCaches(
+          queryClient,
+          boardId,
+          context.optimisticTask.id
         );
       }
 
       console.error('Failed to create task:', err);
     },
     onSuccess: (newTask, _, context) => {
-      queryClient.setQueryData(
-        ['tasks', boardId],
-        (old: Task[] | undefined) => {
-          const optimisticTaskId = context?.optimisticTask.id;
-
-          if (!old) return [newTask];
-
-          const nextTasks = optimisticTaskId
-            ? old.map((task) => (task.id === optimisticTaskId ? newTask : task))
-            : [...old];
-
-          if (nextTasks.some((task) => task.id === newTask.id)) {
-            return nextTasks;
-          }
-
-          return [...nextTasks, newTask];
-        }
+      reconcileOptimisticTaskInBoardCaches(
+        queryClient,
+        boardId,
+        context?.optimisticTask.id ?? newTask.id,
+        newTask
       );
     },
   });

package/src/task-helper.ts

@@ -2,6 +2,7 @@ export { reorderTask, useReorderTask } from './task/reorder';
 export { transformAssignees, transformTaskRecord } from './task/transformers';
 export * from './task-helper/board';
 export * from './task-helper/bulk-actions';
+export * from './task-helper/optimistic-task-cache';
 export * from './task-helper/personal-external-staging';
 export * from './task-helper/recycle-bin';
 export * from './task-helper/relationships';

package/src/workspace-helper.ts

@@ -676,7 +676,7 @@ export interface PermissionsResult {
   withoutPermission(permission: PermissionId): boolean;
 }
 
-async function resolveWorkspaceIdForPermissions({
+export async function resolveWorkspaceIdForPrincipal({
   authorizationClient,
   principal,
   wsId,
@@ -773,7 +773,7 @@ async function getPermissionsImpl({
   // Handle "personal" workspace slug by looking up the user's personal workspace
   let resolvedWorkspaceId: string;
   try {
-    resolvedWorkspaceId = await resolveWorkspaceIdForPermissions({
+    resolvedWorkspaceId = await resolveWorkspaceIdForPrincipal({
       authorizationClient: sbAdmin,
       principal,
       wsId,

package/src/workspace-user-link.test.ts

@@ -50,4 +50,55 @@ describe('getWorkspaceUserLinkForUser', () => {
     expect(mocks.createClient).not.toHaveBeenCalled();
     expect(mocks.createAdminClient).not.toHaveBeenCalled();
   });
+
+  it('returns a link created by a concurrent repair even when its own RPC errors', async () => {
+    const repairedLink = {
+      created_at: '2026-08-14T00:00:00.000Z',
+      platform_user_id: 'platform-user-1',
+      virtual_user_id: 'virtual-user-1',
+      ws_id: 'workspace-1',
+    };
+    const initialMaybeSingle = vi
+      .fn()
+      .mockResolvedValue({ data: null, error: null });
+    const repairedMaybeSingle = vi
+      .fn()
+      .mockResolvedValue({ data: repairedLink, error: null });
+    const createLookupClient = (maybeSingle: ReturnType<typeof vi.fn>) => ({
+      from: vi.fn(() => ({
+        select: vi.fn(() => ({
+          eq: vi.fn(() => ({
+            eq: vi.fn(() => ({
+              limit: vi.fn(() => ({ maybeSingle })),
+            })),
+          })),
+        })),
+      })),
+    });
+    const authorizationClient = createLookupClient(initialMaybeSingle);
+    const adminClient = {
+      ...createLookupClient(repairedMaybeSingle),
+      rpc: vi.fn().mockResolvedValue({
+        error: new Error('duplicate repair already completed'),
+      }),
+    };
+    mocks.verifyWorkspaceMembershipType.mockResolvedValue({
+      membershipType: 'MEMBER',
+      ok: true,
+    });
+    mocks.createAdminClient.mockResolvedValue(adminClient);
+
+    await expect(
+      getWorkspaceUserLinkForUser('workspace-1', 'platform-user-1', {
+        authorizationClient:
+          authorizationClient as unknown as TypedSupabaseClient,
+      })
+    ).resolves.toEqual(repairedLink);
+
+    expect(adminClient.rpc).toHaveBeenCalledWith('ensure_workspace_user_link', {
+      target_user_id: 'platform-user-1',
+      target_ws_id: 'workspace-1',
+    });
+    expect(repairedMaybeSingle).toHaveBeenCalledOnce();
+  });
 });

package/src/workspace-user-link.ts

@@ -37,6 +37,25 @@ function toLink(row: LinkRow): WorkspaceUserLink {
   };
 }
 
+async function readWorkspaceUserLink(
+  supabase: TypedSupabaseClient,
+  wsId: string,
+  userId: string
+) {
+  const { data, error } = await supabase
+    .from('workspace_user_linked_users')
+    .select(LINK_SELECT)
+    .eq('platform_user_id', userId)
+    .eq('ws_id', wsId)
+    .limit(1)
+    .maybeSingle();
+
+  return {
+    error,
+    link: data ? toLink(data as LinkRow) : null,
+  };
+}
+
 /**
  * Resolves the workspace-user link for an EXPLICIT platform user id.
  *
@@ -60,15 +79,13 @@ export async function getWorkspaceUserLinkForUser(
   const supabase = authorizationClient ?? (await createClient());
   const resolvedWsId = resolveWorkspaceId(wsId);
 
-  const { data: workspaceUser } = await supabase
-    .from('workspace_user_linked_users')
-    .select(LINK_SELECT)
-    .eq('platform_user_id', userId)
-    .eq('ws_id', resolvedWsId)
-    .limit(1)
-    .maybeSingle();
+  const initialLookup = await readWorkspaceUserLink(
+    supabase,
+    resolvedWsId,
+    userId
+  );
 
-  if (workspaceUser) return toLink(workspaceUser as LinkRow);
+  if (initialLookup.link) return initialLookup.link;
 
   if (!autoRepair) return null;
 
@@ -94,23 +111,29 @@ export async function getWorkspaceUserLinkForUser(
       target_ws_id: resolvedWsId,
     });
 
+    // Always re-read with the service-role client, including after an RPC
+    // error. Another layout/page/API request may have repaired the same member
+    // concurrently, and returning null here would turn a valid membership into
+    // a route-level 404 or an empty profile-scoped module.
+    const repairedLookup = await readWorkspaceUserLink(
+      sbAdmin,
+      resolvedWsId,
+      userId
+    );
+
+    if (repairedLookup.link) return repairedLookup.link;
+
     if (repairError) {
       console.error(
         '[getWorkspaceUserLinkForUser] Failed to auto-repair workspace user link:',
         repairError
       );
-      return null;
+    } else if (repairedLookup.error) {
+      console.error(
+        '[getWorkspaceUserLinkForUser] Failed to fetch repaired workspace user link:',
+        repairedLookup.error
+      );
     }
-
-    const { data: repairedUser } = await supabase
-      .from('workspace_user_linked_users')
-      .select(LINK_SELECT)
-      .eq('platform_user_id', userId)
-      .eq('ws_id', resolvedWsId)
-      .limit(1)
-      .maybeSingle();
-
-    if (repairedUser) return toLink(repairedUser as LinkRow);
   } catch (err) {
     console.error(
       '[getWorkspaceUserLinkForUser] Error during auto-repair:',