From 26994a9a225ac6494ebc5a80d9375c2e6d3a4411 Mon Sep 17 00:00:00 2001
From: mpJunot <junot-hery-nantenaina.montpre@epitech.eu>
Date: Wed, 11 Feb 2026 00:48:53 +0100
Subject: [PATCH 1/9] chore(backend): add BoardTemplate model and visibility
 migrations

---
 .../migration.sql                             | 25 ++++++++
 .../migration.sql                             |  2 +
 backend/prisma/schema.prisma                  | 61 +++++++++++++------
 3 files changed, 71 insertions(+), 17 deletions(-)
 create mode 100644 backend/prisma/migrations/20260210185600_add_board_templates/migration.sql
 create mode 100644 backend/prisma/migrations/20260210223940_add_visibility_to_template/migration.sql

diff --git a/backend/prisma/migrations/20260210185600_add_board_templates/migration.sql b/backend/prisma/migrations/20260210185600_add_board_templates/migration.sql
new file mode 100644
index 0000000..28d86ff
--- /dev/null
+++ b/backend/prisma/migrations/20260210185600_add_board_templates/migration.sql
@@ -0,0 +1,25 @@
+-- CreateTable
+CREATE TABLE "board_templates" (
+    "id" TEXT NOT NULL,
+    "name" TEXT NOT NULL,
+    "description" TEXT NOT NULL,
+    "lists" JSONB NOT NULL,
+    "workspaceId" TEXT,
+    "creatorId" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "board_templates_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "board_templates_workspaceId_idx" ON "board_templates"("workspaceId");
+
+-- CreateIndex
+CREATE INDEX "board_templates_creatorId_idx" ON "board_templates"("creatorId");
+
+-- AddForeignKey
+ALTER TABLE "board_templates" ADD CONSTRAINT "board_templates_workspaceId_fkey" FOREIGN KEY ("workspaceId") REFERENCES "workspaces"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
+-- AddForeignKey
+ALTER TABLE "board_templates" ADD CONSTRAINT "board_templates_creatorId_fkey" FOREIGN KEY ("creatorId") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/backend/prisma/migrations/20260210223940_add_visibility_to_template/migration.sql b/backend/prisma/migrations/20260210223940_add_visibility_to_template/migration.sql
new file mode 100644
index 0000000..dbf65a4
--- /dev/null
+++ b/backend/prisma/migrations/20260210223940_add_visibility_to_template/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "board_templates" ADD COLUMN     "visibility" "Visibility" NOT NULL DEFAULT 'PRIVATE';
diff --git a/backend/prisma/schema.prisma b/backend/prisma/schema.prisma
index 05a8123..b127a00 100644
--- a/backend/prisma/schema.prisma
+++ b/backend/prisma/schema.prisma
@@ -107,6 +107,7 @@ model Workspace {
   boards      Board[]
   memberships WorkspaceMember[]
   invitations WorkspaceInvitation[]
+  templates   BoardTemplate[]
 
   @@map("workspaces")
 }
@@ -132,18 +133,19 @@ model User {
   createdAt                DateTime  @default(now())
   updatedAt                DateTime  @updatedAt
 
-  createdBoards        Board[]               @relation("BoardCreator")
-  boardMembers         BoardMember[]
-  cardAssignees        CardAssignee[]
-  comments             Comment[]
-  attachments          Attachment[]
-  workspaceMemberships WorkspaceMember[]
-  notifications        Notification[]
-  oauthAccounts        OAuthAccount[]
-  sentInvitations      WorkspaceInvitation[] @relation("InvitationInviter")
-  receivedInvitations  WorkspaceInvitation[] @relation("InvitationInvitee")
-  activities           Activity[]
+  createdBoards           Board[]                      @relation("BoardCreator")
+  boardMembers            BoardMember[]
+  cardAssignees           CardAssignee[]
+  comments                Comment[]
+  attachments             Attachment[]
+  workspaceMemberships    WorkspaceMember[]
+  notifications           Notification[]
+  oauthAccounts           OAuthAccount[]
+  sentInvitations         WorkspaceInvitation[]        @relation("InvitationInviter")
+  receivedInvitations     WorkspaceInvitation[]        @relation("InvitationInvitee")
+  activities              Activity[]
   notificationPreferences UserNotificationPreferences?
+  createdTemplates        BoardTemplate[]
 
   @@map("users")
 }
@@ -154,12 +156,12 @@ model User {
 // Per-user notification settings (email frequency, desktop notifications).
 
 model UserNotificationPreferences {
-  id                      String                    @id @default(uuid())
-  userId                  String                    @unique
-  emailFrequency          NotificationEmailFrequency @default(PERIODICALLY)
-  allowDesktopNotifications Boolean                 @default(false)
-  createdAt               DateTime                  @default(now())
-  updatedAt               DateTime                  @updatedAt
+  id                        String                     @id @default(uuid())
+  userId                    String                     @unique
+  emailFrequency            NotificationEmailFrequency @default(PERIODICALLY)
+  allowDesktopNotifications Boolean                    @default(false)
+  createdAt                 DateTime                   @default(now())
+  updatedAt                 DateTime                   @updatedAt
 
   user User @relation(fields: [userId], references: [id], onDelete: Cascade)
 
@@ -526,3 +528,28 @@ model WorkspaceInvitation {
   @@index([status])
   @@map("workspace_invitations")
 }
+
+// ----------------------------------------------------------------------------
+// BoardTemplate (CRUD - custom templates)
+// ----------------------------------------------------------------------------
+// User-created board templates. Lists stored as JSON: [{ title, position, sampleCards?: [{ title, position }] }].
+// workspaceId null = global template; otherwise template is scoped to that workspace.
+
+model BoardTemplate {
+  id          String   @id @default(uuid())
+  name        String
+  description String
+  lists       Json
+  visibility  Visibility @default(PRIVATE)
+  workspaceId String?
+  creatorId   String
+  createdAt   DateTime @default(now())
+  updatedAt   DateTime @updatedAt
+
+  workspace Workspace? @relation(fields: [workspaceId], references: [id], onDelete: Cascade)
+  creator   User       @relation(fields: [creatorId], references: [id], onDelete: Cascade)
+
+  @@index([workspaceId])
+  @@index([creatorId])
+  @@map("board_templates")
+}

From 6fed6473ce8aea9fc7db3af7421a82ec1d091738 Mon Sep 17 00:00:00 2001
From: mpJunot <junot-hery-nantenaina.montpre@epitech.eu>
Date: Wed, 11 Feb 2026 00:49:05 +0100
Subject: [PATCH 2/9] feat(backend): add templates module (CRUD, visibility,
 createFromBoard)

---
 .../templates/dto/create-template.input.ts    |  34 ++
 .../templates/dto/template-list.input.ts      |  32 ++
 .../templates/dto/update-template.input.ts    |  35 ++
 .../templates/entities/template-list.type.ts  |  22 +
 .../templates/entities/template.entity.ts     |  33 ++
 .../src/modules/templates/templates.module.ts |  11 +
 .../templates/templates.resolver.spec.ts      | 135 +++++
 .../modules/templates/templates.resolver.ts   |  79 +++
 .../templates/templates.service.spec.ts       | 461 ++++++++++++++++++
 .../modules/templates/templates.service.ts    | 340 +++++++++++++
 10 files changed, 1182 insertions(+)
 create mode 100644 backend/src/modules/templates/dto/create-template.input.ts
 create mode 100644 backend/src/modules/templates/dto/template-list.input.ts
 create mode 100644 backend/src/modules/templates/dto/update-template.input.ts
 create mode 100644 backend/src/modules/templates/entities/template-list.type.ts
 create mode 100644 backend/src/modules/templates/entities/template.entity.ts
 create mode 100644 backend/src/modules/templates/templates.module.ts
 create mode 100644 backend/src/modules/templates/templates.resolver.spec.ts
 create mode 100644 backend/src/modules/templates/templates.resolver.ts
 create mode 100644 backend/src/modules/templates/templates.service.spec.ts
 create mode 100644 backend/src/modules/templates/templates.service.ts

diff --git a/backend/src/modules/templates/dto/create-template.input.ts b/backend/src/modules/templates/dto/create-template.input.ts
new file mode 100644
index 0000000..05ffede
--- /dev/null
+++ b/backend/src/modules/templates/dto/create-template.input.ts
@@ -0,0 +1,34 @@
+import { InputType, Field, ID } from '@nestjs/graphql';
+import { IsNotEmpty, IsString, IsOptional, IsArray, ValidateNested, IsEnum } from 'class-validator';
+import { Type } from 'class-transformer';
+import { Visibility } from '@prisma/client';
+import { TemplateListInput } from './template-list.input';
+
+@InputType()
+export class CreateTemplateInput {
+  @Field()
+  @IsNotEmpty()
+  @IsString()
+  name: string;
+
+  @Field()
+  @IsNotEmpty()
+  @IsString()
+  description: string;
+
+  @Field(() => [TemplateListInput])
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => TemplateListInput)
+  lists: TemplateListInput[];
+
+  @Field(() => Visibility, { nullable: true })
+  @IsOptional()
+  @IsEnum(Visibility)
+  visibility?: Visibility;
+
+  @Field(() => ID, { nullable: true })
+  @IsOptional()
+  @IsString()
+  workspaceId?: string;
+}
diff --git a/backend/src/modules/templates/dto/template-list.input.ts b/backend/src/modules/templates/dto/template-list.input.ts
new file mode 100644
index 0000000..73673da
--- /dev/null
+++ b/backend/src/modules/templates/dto/template-list.input.ts
@@ -0,0 +1,32 @@
+import { InputType, Field, Int, Float } from '@nestjs/graphql';
+import { IsString, IsNumber, IsOptional, IsArray, ValidateNested } from 'class-validator';
+import { Type } from 'class-transformer';
+
+@InputType()
+export class TemplateSampleCardInput {
+  @Field()
+  @IsString()
+  title: string;
+
+  @Field(() => Float)
+  @IsNumber()
+  position: number;
+}
+
+@InputType()
+export class TemplateListInput {
+  @Field()
+  @IsString()
+  title: string;
+
+  @Field(() => Int)
+  @IsNumber()
+  position: number;
+
+  @Field(() => [TemplateSampleCardInput], { nullable: true })
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => TemplateSampleCardInput)
+  sampleCards?: TemplateSampleCardInput[];
+}
diff --git a/backend/src/modules/templates/dto/update-template.input.ts b/backend/src/modules/templates/dto/update-template.input.ts
new file mode 100644
index 0000000..91ef889
--- /dev/null
+++ b/backend/src/modules/templates/dto/update-template.input.ts
@@ -0,0 +1,35 @@
+import { InputType, Field, ID } from '@nestjs/graphql';
+import { IsNotEmpty, IsString, IsOptional, IsArray, ValidateNested, IsEnum } from 'class-validator';
+import { Type } from 'class-transformer';
+import { Visibility } from '@prisma/client';
+import { TemplateListInput } from './template-list.input';
+
+@InputType()
+export class UpdateTemplateInput {
+  @Field(() => ID)
+  @IsNotEmpty()
+  @IsString()
+  id: string;
+
+  @Field({ nullable: true })
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @Field({ nullable: true })
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  @Field(() => [TemplateListInput], { nullable: true })
+  @IsOptional()
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => TemplateListInput)
+  lists?: TemplateListInput[];
+
+  @Field(() => Visibility, { nullable: true })
+  @IsOptional()
+  @IsEnum(Visibility)
+  visibility?: Visibility;
+}
diff --git a/backend/src/modules/templates/entities/template-list.type.ts b/backend/src/modules/templates/entities/template-list.type.ts
new file mode 100644
index 0000000..eee55da
--- /dev/null
+++ b/backend/src/modules/templates/entities/template-list.type.ts
@@ -0,0 +1,22 @@
+import { ObjectType, Field, Float, Int } from '@nestjs/graphql';
+
+@ObjectType()
+export class TemplateSampleCard {
+  @Field()
+  title: string;
+
+  @Field(() => Float)
+  position: number;
+}
+
+@ObjectType()
+export class TemplateListType {
+  @Field()
+  title: string;
+
+  @Field(() => Int)
+  position: number;
+
+  @Field(() => [TemplateSampleCard], { nullable: true })
+  sampleCards?: TemplateSampleCard[];
+}
diff --git a/backend/src/modules/templates/entities/template.entity.ts b/backend/src/modules/templates/entities/template.entity.ts
new file mode 100644
index 0000000..48c591d
--- /dev/null
+++ b/backend/src/modules/templates/entities/template.entity.ts
@@ -0,0 +1,33 @@
+import { ObjectType, Field, ID } from '@nestjs/graphql';
+import { Visibility } from '@prisma/client';
+import { TemplateListType } from './template-list.type';
+
+@ObjectType()
+export class Template {
+  @Field(() => ID)
+  id: string;
+
+  @Field()
+  name: string;
+
+  @Field()
+  description: string;
+
+  @Field(() => [TemplateListType])
+  lists: TemplateListType[];
+
+  @Field(() => Visibility)
+  visibility: Visibility;
+
+  @Field(() => ID, { nullable: true })
+  workspaceId?: string;
+
+  @Field(() => ID)
+  creatorId: string;
+
+  @Field()
+  createdAt: Date;
+
+  @Field()
+  updatedAt: Date;
+}
diff --git a/backend/src/modules/templates/templates.module.ts b/backend/src/modules/templates/templates.module.ts
new file mode 100644
index 0000000..1191d1a
--- /dev/null
+++ b/backend/src/modules/templates/templates.module.ts
@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { TemplatesService } from './templates.service';
+import { TemplatesResolver } from './templates.resolver';
+import { PrismaModule } from '../../prisma/prisma.module';
+
+@Module({
+  imports: [PrismaModule],
+  providers: [TemplatesResolver, TemplatesService],
+  exports: [TemplatesService],
+})
+export class TemplatesModule {}
diff --git a/backend/src/modules/templates/templates.resolver.spec.ts b/backend/src/modules/templates/templates.resolver.spec.ts
new file mode 100644
index 0000000..cedb9a3
--- /dev/null
+++ b/backend/src/modules/templates/templates.resolver.spec.ts
@@ -0,0 +1,135 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { TemplatesResolver } from './templates.resolver';
+import { TemplatesService } from './templates.service';
+
+describe('TemplatesResolver', () => {
+  let resolver: TemplatesResolver;
+
+  const mockTemplate = {
+    id: 'tpl-1',
+    name: 'My Template',
+    description: 'Description',
+    lists: [{ title: 'To Do', position: 0 }, { title: 'Done', position: 1 }],
+    creatorId: 'user-1',
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+
+  const mockTemplatesService = {
+    create: jest.fn(),
+    createFromBoard: jest.fn(),
+    findOne: jest.fn(),
+    findAll: jest.fn(),
+    update: jest.fn(),
+    delete: jest.fn(),
+  };
+
+  const mockUser = { id: 'user-1' };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        TemplatesResolver,
+        { provide: TemplatesService, useValue: mockTemplatesService },
+      ],
+    }).compile();
+
+    resolver = module.get<TemplatesResolver>(TemplatesResolver);
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(resolver).toBeDefined();
+  });
+
+  describe('template', () => {
+    it('should return a template by id', async () => {
+      mockTemplatesService.findOne.mockResolvedValue(mockTemplate);
+
+      const result = await resolver.template('tpl-1', mockUser);
+
+      expect(result).toEqual(mockTemplate);
+      expect(mockTemplatesService.findOne).toHaveBeenCalledWith('tpl-1', mockUser.id);
+    });
+  });
+
+  describe('templates', () => {
+    it('should return templates list', async () => {
+      mockTemplatesService.findAll.mockResolvedValue([mockTemplate]);
+
+      const result = await resolver.templates(null, mockUser);
+
+      expect(result).toHaveLength(1);
+      expect(mockTemplatesService.findAll).toHaveBeenCalledWith(null, mockUser.id);
+    });
+  });
+
+  describe('createTemplate', () => {
+    it('should create a template', async () => {
+      mockTemplatesService.create.mockResolvedValue(mockTemplate);
+
+      const input = {
+        name: 'My Template',
+        description: 'Description',
+        lists: [{ title: 'To Do', position: 0 }, { title: 'Done', position: 1 }],
+      };
+
+      const result = await resolver.createTemplate(input, mockUser);
+
+      expect(result).toEqual(mockTemplate);
+      expect(mockTemplatesService.create).toHaveBeenCalledWith(input, mockUser.id);
+    });
+  });
+
+  describe('createTemplateFromBoard', () => {
+    it('should create a template from a board', async () => {
+      mockTemplatesService.createFromBoard.mockResolvedValue(mockTemplate);
+
+      const result = await resolver.createTemplateFromBoard('board-1', 'My board template', mockUser);
+
+      expect(result).toEqual(mockTemplate);
+      expect(mockTemplatesService.createFromBoard).toHaveBeenCalledWith(
+        'board-1',
+        mockUser.id,
+        'My board template',
+      );
+    });
+
+    it('should create a template from board without name', async () => {
+      mockTemplatesService.createFromBoard.mockResolvedValue(mockTemplate);
+
+      await resolver.createTemplateFromBoard('board-1', undefined, mockUser);
+
+      expect(mockTemplatesService.createFromBoard).toHaveBeenCalledWith(
+        'board-1',
+        mockUser.id,
+        undefined,
+      );
+    });
+  });
+
+  describe('updateTemplate', () => {
+    it('should update a template', async () => {
+      const updated = { ...mockTemplate, name: 'Updated' };
+      mockTemplatesService.update.mockResolvedValue(updated);
+
+      const result = await resolver.updateTemplate(
+        { id: 'tpl-1', name: 'Updated' },
+        mockUser,
+      );
+
+      expect(result.name).toBe('Updated');
+    });
+  });
+
+  describe('deleteTemplate', () => {
+    it('should delete a template', async () => {
+      mockTemplatesService.delete.mockResolvedValue(true);
+
+      const result = await resolver.deleteTemplate('tpl-1', mockUser);
+
+      expect(result).toBe(true);
+      expect(mockTemplatesService.delete).toHaveBeenCalledWith('tpl-1', mockUser.id);
+    });
+  });
+});
diff --git a/backend/src/modules/templates/templates.resolver.ts b/backend/src/modules/templates/templates.resolver.ts
new file mode 100644
index 0000000..48f77b4
--- /dev/null
+++ b/backend/src/modules/templates/templates.resolver.ts
@@ -0,0 +1,79 @@
+import { Resolver, Query, Mutation, Args, ID } from '@nestjs/graphql';
+import { UseGuards } from '@nestjs/common';
+import { TemplatesService } from './templates.service';
+import { Template } from './entities/template.entity';
+import { CreateTemplateInput } from './dto/create-template.input';
+import { UpdateTemplateInput } from './dto/update-template.input';
+import { GqlAuthGuard } from '../../common/guards/gql-auth.guard';
+import { CurrentUser } from '../../common/decorators/current-user.decorator';
+
+@Resolver(() => Template)
+@UseGuards(GqlAuthGuard)
+export class TemplatesResolver {
+  constructor(private readonly templatesService: TemplatesService) {}
+
+  @Query(() => Template, {
+    name: 'template',
+    description: 'Get a template by ID. User must have access (global or workspace member).',
+  })
+  async template(
+    @Args('id', { type: () => ID }) id: string,
+    @CurrentUser() user: any,
+  ): Promise<Template> {
+    return this.templatesService.findOne(id, user.id);
+  }
+
+  @Query(() => [Template], {
+    name: 'templates',
+    description:
+      'List templates. If workspaceId is provided, returns global + workspace templates; otherwise global only.',
+  })
+  async templates(
+    @Args('workspaceId', { type: () => ID, nullable: true }) workspaceId: string | null | undefined,
+    @CurrentUser() user: any,
+  ): Promise<Template[]> {
+    return this.templatesService.findAll(workspaceId ?? null, user.id);
+  }
+
+  @Mutation(() => Template, {
+    description: 'Create a custom board template. Optional workspaceId to scope to a workspace.',
+  })
+  async createTemplate(
+    @Args('input') input: CreateTemplateInput,
+    @CurrentUser() user: any,
+  ): Promise<Template> {
+    return this.templatesService.create(input, user.id);
+  }
+
+  @Mutation(() => Template, {
+    description:
+      'Create a template from an existing board (lists and cards become template structure).',
+  })
+  async createTemplateFromBoard(
+    @Args('boardId', { type: () => ID }) boardId: string,
+    @Args('name', { type: () => String, nullable: true }) name: string | undefined,
+    @CurrentUser() user: any,
+  ): Promise<Template> {
+    return this.templatesService.createFromBoard(boardId, user.id, name);
+  }
+
+  @Mutation(() => Template, {
+    description: 'Update a template. Only creator or workspace admin.',
+  })
+  async updateTemplate(
+    @Args('input') input: UpdateTemplateInput,
+    @CurrentUser() user: any,
+  ): Promise<Template> {
+    return this.templatesService.update(input, user.id);
+  }
+
+  @Mutation(() => Boolean, {
+    description: 'Delete a template. Only creator or workspace admin.',
+  })
+  async deleteTemplate(
+    @Args('id', { type: () => ID }) id: string,
+    @CurrentUser() user: any,
+  ): Promise<boolean> {
+    return this.templatesService.delete(id, user.id);
+  }
+}
diff --git a/backend/src/modules/templates/templates.service.spec.ts b/backend/src/modules/templates/templates.service.spec.ts
new file mode 100644
index 0000000..dc07dd5
--- /dev/null
+++ b/backend/src/modules/templates/templates.service.spec.ts
@@ -0,0 +1,461 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import {
+  NotFoundException,
+  ForbiddenException,
+  BadRequestException,
+} from '@nestjs/common';
+import { Role } from '@prisma/client';
+import { TemplatesService } from './templates.service';
+import { PrismaService } from '../../prisma/prisma.service';
+
+describe('TemplatesService', () => {
+  let service: TemplatesService;
+
+  const mockPrismaService = {
+    board: {
+      findUnique: jest.fn(),
+    },
+    boardTemplate: {
+      create: jest.fn(),
+      findUnique: jest.fn(),
+      findMany: jest.fn(),
+      update: jest.fn(),
+      delete: jest.fn(),
+    },
+    workspaceMember: {
+      findUnique: jest.fn(),
+      findMany: jest.fn(),
+    },
+  };
+
+  const mockUser = { id: 'user-1' };
+
+  const mockTemplateRow = {
+    id: 'tpl-1',
+    name: 'My Template',
+    description: 'Description',
+    lists: [{ title: 'To Do', position: 0 }, { title: 'Done', position: 1 }],
+    visibility: 'PRIVATE' as const,
+    workspaceId: null,
+    creatorId: 'user-1',
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  };
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        TemplatesService,
+        { provide: PrismaService, useValue: mockPrismaService },
+      ],
+    }).compile();
+
+    service = module.get<TemplatesService>(TemplatesService);
+    jest.clearAllMocks();
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('create', () => {
+    it('should create a global template', async () => {
+      mockPrismaService.boardTemplate.create.mockResolvedValue(mockTemplateRow);
+
+      const result = await service.create(
+        {
+          name: 'My Template',
+          description: 'Description',
+          lists: [{ title: 'To Do', position: 0 }, { title: 'Done', position: 1 }],
+        },
+        mockUser.id,
+      );
+
+      expect(result.id).toBe('tpl-1');
+      expect(result.name).toBe('My Template');
+      expect(mockPrismaService.boardTemplate.create).toHaveBeenCalled();
+    });
+
+    it('should reject empty lists', async () => {
+      await expect(
+        service.create(
+          { name: 'T', description: 'D', lists: [] },
+          mockUser.id,
+        ),
+      ).rejects.toBeInstanceOf(BadRequestException);
+    });
+
+    it('should reject when not a workspace member', async () => {
+      mockPrismaService.workspaceMember.findUnique.mockResolvedValue(null);
+
+      await expect(
+        service.create(
+          {
+            name: 'T',
+            description: 'D',
+            lists: [{ title: 'To Do', position: 0 }],
+            workspaceId: 'ws-1',
+          },
+          mockUser.id,
+        ),
+      ).rejects.toBeInstanceOf(ForbiddenException);
+    });
+
+    it('should reject when workspace member is OBSERVER', async () => {
+      mockPrismaService.workspaceMember.findUnique.mockResolvedValue({
+        role: Role.OBSERVER,
+      });
+
+      await expect(
+        service.create(
+          {
+            name: 'T',
+            description: 'D',
+            lists: [{ title: 'To Do', position: 0 }],
+            workspaceId: 'ws-1',
+          },
+          mockUser.id,
+        ),
+      ).rejects.toBeInstanceOf(ForbiddenException);
+    });
+  });
+
+  describe('createFromBoard', () => {
+    it('should create a template from a board', async () => {
+      const mockBoard = {
+        id: 'board-1',
+        title: 'My Board',
+        description: 'Desc',
+        visibility: 'PRIVATE',
+        workspaceId: 'ws-1',
+        members: [{ userId: mockUser.id }],
+        workspace: { memberships: [{ userId: mockUser.id }] },
+        lists: [
+          {
+            id: 'list-1',
+            title: 'To Do',
+            position: 0,
+            cards: [
+              { id: 'c1', title: 'Card 1', position: 0 },
+              { id: 'c2', title: 'Card 2', position: 1 },
+            ],
+          },
+        ],
+      };
+      mockPrismaService.board.findUnique.mockResolvedValue(mockBoard);
+      mockPrismaService.workspaceMember.findUnique.mockResolvedValue({ role: Role.ADMIN });
+      mockPrismaService.boardTemplate.create.mockResolvedValue(mockTemplateRow);
+
+      const result = await service.createFromBoard('board-1', mockUser.id, 'From board');
+
+      expect(result.id).toBe('tpl-1');
+      expect(mockPrismaService.board.findUnique).toHaveBeenCalledWith(
+        expect.objectContaining({ where: { id: 'board-1' } }),
+      );
+      expect(mockPrismaService.boardTemplate.create).toHaveBeenCalled();
+    });
+
+    it('should throw when board not found', async () => {
+      mockPrismaService.board.findUnique.mockResolvedValue(null);
+
+      await expect(
+        service.createFromBoard('unknown', mockUser.id),
+      ).rejects.toBeInstanceOf(NotFoundException);
+    });
+
+    it('should throw when board has no lists', async () => {
+      mockPrismaService.board.findUnique.mockResolvedValue({
+        id: 'board-1',
+        title: 'Empty',
+        description: '',
+        visibility: 'PRIVATE',
+        workspaceId: null,
+        members: [{ userId: mockUser.id }],
+        workspace: null,
+        lists: [],
+      });
+
+      await expect(
+        service.createFromBoard('board-1', mockUser.id),
+      ).rejects.toBeInstanceOf(BadRequestException);
+    });
+
+    it('should throw when user has no access to board', async () => {
+      mockPrismaService.board.findUnique.mockResolvedValue({
+        id: 'board-1',
+        title: 'Other Board',
+        description: '',
+        visibility: 'PRIVATE',
+        workspaceId: null,
+        members: [{ userId: 'other-user' }],
+        workspace: null,
+        lists: [{ id: 'l1', title: 'List', position: 0, cards: [] }],
+      });
+
+      await expect(
+        service.createFromBoard('board-1', mockUser.id),
+      ).rejects.toBeInstanceOf(ForbiddenException);
+    });
+  });
+
+  describe('findOne', () => {
+    it('should return a template', async () => {
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(mockTemplateRow);
+
+      const result = await service.findOne('tpl-1', mockUser.id);
+
+      expect(result.id).toBe('tpl-1');
+    });
+
+    it('should throw when not found', async () => {
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(null);
+
+      await expect(service.findOne('unknown', mockUser.id)).rejects.toBeInstanceOf(
+        NotFoundException,
+      );
+    });
+
+    it('should return template when visibility PUBLIC and user is workspace member', async () => {
+      const row = { ...mockTemplateRow, visibility: 'PUBLIC' as const, workspaceId: 'ws-1', creatorId: 'other-user' };
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(row);
+      mockPrismaService.workspaceMember.findUnique.mockResolvedValue({ userId: mockUser.id });
+
+      const result = await service.findOne('tpl-1', mockUser.id);
+
+      expect(result.id).toBe('tpl-1');
+    });
+
+    it('should return template when visibility WORKSPACE and user is workspace member', async () => {
+      const row = { ...mockTemplateRow, visibility: 'WORKSPACE' as const, workspaceId: 'ws-1', creatorId: 'other-user' };
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(row);
+      mockPrismaService.workspaceMember.findUnique.mockResolvedValue({ userId: mockUser.id });
+
+      const result = await service.findOne('tpl-1', mockUser.id);
+
+      expect(result.id).toBe('tpl-1');
+    });
+
+    it('should return template when visibility PUBLIC even if user is not workspace member', async () => {
+      const row = { ...mockTemplateRow, visibility: 'PUBLIC' as const, workspaceId: 'ws-1', creatorId: 'other-user' };
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(row);
+
+      const result = await service.findOne('tpl-1', mockUser.id);
+
+      expect(result.id).toBe('tpl-1');
+      expect(mockPrismaService.workspaceMember.findUnique).not.toHaveBeenCalled();
+    });
+
+    it('should throw when visibility PRIVATE and user is not creator', async () => {
+      const row = { ...mockTemplateRow, creatorId: 'other-user' };
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(row);
+
+      await expect(service.findOne('tpl-1', mockUser.id)).rejects.toBeInstanceOf(
+        ForbiddenException,
+      );
+    });
+  });
+
+  describe('findAll', () => {
+    it('should return global templates when workspaceId is null', async () => {
+      mockPrismaService.workspaceMember.findMany.mockResolvedValue([]);
+      mockPrismaService.boardTemplate.findMany.mockResolvedValue([mockTemplateRow]);
+
+      const result = await service.findAll(null, mockUser.id);
+
+      expect(result).toHaveLength(1);
+      expect(mockPrismaService.boardTemplate.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({
+            AND: expect.arrayContaining([
+              { workspaceId: null },
+              expect.anything(),
+            ]),
+          }),
+        }),
+      );
+    });
+
+    it('should return workspace templates when workspaceId is provided and user is member', async () => {
+      mockPrismaService.workspaceMember.findUnique.mockResolvedValue({ workspaceId: 'ws-1' });
+      mockPrismaService.workspaceMember.findMany.mockResolvedValue([{ workspaceId: 'ws-1' }]);
+      mockPrismaService.boardTemplate.findMany.mockResolvedValue([mockTemplateRow]);
+
+      const result = await service.findAll('ws-1', mockUser.id);
+
+      expect(result).toHaveLength(1);
+      expect(mockPrismaService.boardTemplate.findMany).toHaveBeenCalledWith(
+        expect.objectContaining({
+          where: expect.objectContaining({
+            AND: expect.arrayContaining([
+              { OR: [{ workspaceId: null }, { workspaceId: 'ws-1' }] },
+              expect.anything(),
+            ]),
+          }),
+        }),
+      );
+    });
+
+    it('should throw when workspaceId provided but user is not a member', async () => {
+      mockPrismaService.workspaceMember.findUnique.mockResolvedValue(null);
+
+      await expect(service.findAll('ws-1', mockUser.id)).rejects.toBeInstanceOf(
+        ForbiddenException,
+      );
+    });
+  });
+
+  describe('getTemplateForBoard', () => {
+    it('should return null when template not found', async () => {
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(null);
+
+      const result = await service.getTemplateForBoard('unknown', mockUser.id);
+
+      expect(result).toBeNull();
+    });
+
+    it('should return null when user has no access', async () => {
+      const row = { ...mockTemplateRow, creatorId: 'other-user' };
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(row);
+
+      const result = await service.getTemplateForBoard('tpl-1', mockUser.id);
+
+      expect(result).toBeNull();
+    });
+
+    it('should return lists when user has access', async () => {
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(mockTemplateRow);
+
+      const result = await service.getTemplateForBoard('tpl-1', mockUser.id);
+
+      expect(result).toEqual({
+        lists: [
+          { title: 'To Do', position: 0 },
+          { title: 'Done', position: 1 },
+        ],
+      });
+    });
+  });
+
+  describe('update', () => {
+    it('should update a template', async () => {
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(mockTemplateRow);
+      mockPrismaService.boardTemplate.update.mockResolvedValue({
+        ...mockTemplateRow,
+        name: 'Updated',
+      });
+
+      const result = await service.update(
+        { id: 'tpl-1', name: 'Updated' },
+        mockUser.id,
+      );
+
+      expect(result.name).toBe('Updated');
+    });
+
+    it('should update template with lists and visibility', async () => {
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(mockTemplateRow);
+      mockPrismaService.boardTemplate.update.mockResolvedValue({
+        ...mockTemplateRow,
+        lists: [{ title: 'New List', position: 0 }],
+        visibility: 'PUBLIC',
+      });
+
+      await service.update(
+        {
+          id: 'tpl-1',
+          lists: [{ title: 'New List', position: 0 }],
+          visibility: 'PUBLIC',
+        },
+        mockUser.id,
+      );
+
+      expect(mockPrismaService.boardTemplate.update).toHaveBeenCalledWith(
+        expect.objectContaining({
+          data: expect.objectContaining({
+            lists: [{ title: 'New List', position: 0 }],
+            visibility: 'PUBLIC',
+          }),
+        }),
+      );
+    });
+
+    it('should update template with lists containing sampleCards', async () => {
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(mockTemplateRow);
+      const updatedRow = {
+        ...mockTemplateRow,
+        lists: [{ title: 'Col', position: 0, sampleCards: [{ title: 'Card', position: 0 }] }],
+      };
+      mockPrismaService.boardTemplate.update.mockResolvedValue(updatedRow);
+
+      await service.update(
+        {
+          id: 'tpl-1',
+          lists: [
+            { title: 'Col', position: 0, sampleCards: [{ title: 'Card', position: 0 }] },
+          ],
+        },
+        mockUser.id,
+      );
+
+      expect(mockPrismaService.boardTemplate.update).toHaveBeenCalledWith(
+        expect.objectContaining({
+          data: expect.objectContaining({
+            lists: [
+              { title: 'Col', position: 0, sampleCards: [{ title: 'Card', position: 0 }] },
+            ],
+          }),
+        }),
+      );
+    });
+
+    it('should throw when template not found', async () => {
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(null);
+
+      await expect(
+        service.update({ id: 'unknown', name: 'X' }, mockUser.id),
+      ).rejects.toBeInstanceOf(NotFoundException);
+    });
+
+    it('should throw when updating global template as non-creator', async () => {
+      const row = { ...mockTemplateRow, creatorId: 'other-user', workspaceId: null };
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(row);
+
+      await expect(
+        service.update({ id: 'tpl-1', name: 'X' }, mockUser.id),
+      ).rejects.toBeInstanceOf(ForbiddenException);
+    });
+
+    it('should throw when user is workspace member but not ADMIN', async () => {
+      const row = { ...mockTemplateRow, creatorId: 'other-user', workspaceId: 'ws-1' };
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(row);
+      mockPrismaService.workspaceMember.findUnique.mockResolvedValue({ role: Role.MEMBER });
+
+      await expect(
+        service.update({ id: 'tpl-1', name: 'X' }, mockUser.id),
+      ).rejects.toBeInstanceOf(ForbiddenException);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete a template', async () => {
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(mockTemplateRow);
+      mockPrismaService.boardTemplate.delete.mockResolvedValue(undefined);
+
+      const result = await service.delete('tpl-1', mockUser.id);
+
+      expect(result).toBe(true);
+      expect(mockPrismaService.boardTemplate.delete).toHaveBeenCalledWith({
+        where: { id: 'tpl-1' },
+      });
+    });
+
+    it('should throw when deleting global template as non-creator', async () => {
+      const row = { ...mockTemplateRow, creatorId: 'other-user', workspaceId: null };
+      mockPrismaService.boardTemplate.findUnique.mockResolvedValue(row);
+
+      await expect(service.delete('tpl-1', mockUser.id)).rejects.toBeInstanceOf(
+        ForbiddenException,
+      );
+    });
+  });
+});
diff --git a/backend/src/modules/templates/templates.service.ts b/backend/src/modules/templates/templates.service.ts
new file mode 100644
index 0000000..14d9ea9
--- /dev/null
+++ b/backend/src/modules/templates/templates.service.ts
@@ -0,0 +1,340 @@
+import {
+  Injectable,
+  NotFoundException,
+  ForbiddenException,
+  BadRequestException,
+} from '@nestjs/common';
+import { Prisma, Role } from '@prisma/client';
+import { Visibility } from '@prisma/client';
+import { PrismaService } from '../../prisma/prisma.service';
+import { CreateTemplateInput } from './dto/create-template.input';
+import { UpdateTemplateInput } from './dto/update-template.input';
+import { Template } from './entities/template.entity';
+
+type ListRow = { title: string; position: number; sampleCards?: { title: string; position: number }[] };
+
+/** Shape of BoardTemplate from DB (schema has visibility; Prisma client may need regenerate). */
+type BoardTemplateRow = {
+  id: string;
+  name: string;
+  description: string;
+  lists: unknown;
+  visibility: Visibility;
+  workspaceId: string | null;
+  creatorId: string;
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+function toTemplateListType(list: ListRow) {
+  return {
+    title: list.title,
+    position: list.position,
+    ...(list.sampleCards && { sampleCards: list.sampleCards }),
+  };
+}
+
+@Injectable()
+export class TemplatesService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async create(input: CreateTemplateInput, userId: string): Promise<Template> {
+    if (input.workspaceId) {
+      const membership = await this.prisma.workspaceMember.findUnique({
+        where: {
+          workspaceId_userId: { workspaceId: input.workspaceId, userId },
+        },
+      });
+      if (!membership) {
+        throw new ForbiddenException('You are not a member of this workspace');
+      }
+      if (membership.role === Role.OBSERVER) {
+        throw new ForbiddenException('Observers cannot create templates');
+      }
+    }
+
+    if (!input.lists?.length) {
+      throw new BadRequestException('At least one list is required');
+    }
+
+    const listsJson = input.lists.map((l) => ({
+      title: l.title,
+      position: l.position,
+      ...(l.sampleCards?.length && { sampleCards: l.sampleCards }),
+    }));
+
+    const visibility =
+      input.visibility != null ? input.visibility : Visibility.PRIVATE;
+
+    const row = await this.prisma.boardTemplate.create({
+      data: {
+        name: input.name,
+        description: input.description,
+        lists: listsJson as unknown as Prisma.InputJsonValue,
+        visibility,
+        workspaceId: input.workspaceId,
+        creatorId: userId,
+      } as unknown as Prisma.BoardTemplateCreateInput,
+    });
+
+    return this.toTemplate(row as BoardTemplateRow);
+  }
+
+  /**
+   * Create a template from an existing board (lists + cards as sample cards).
+   * User must have access to the board.
+   */
+  async createFromBoard(
+    boardId: string,
+    userId: string,
+    name?: string,
+  ): Promise<Template> {
+    const board = await this.prisma.board.findUnique({
+      where: { id: boardId },
+      include: {
+        members: true,
+        workspace: { include: { memberships: true } },
+        lists: {
+          where: { isArchived: false },
+          orderBy: { position: 'asc' },
+          include: {
+            cards: {
+              where: { isArchived: false },
+              orderBy: { position: 'asc' },
+            },
+          },
+        },
+      },
+    });
+
+    if (!board) {
+      throw new NotFoundException('Board not found');
+    }
+
+    await this.checkBoardAccess(board, userId);
+
+    if (!board.lists.length) {
+      throw new BadRequestException('Board has no lists to use as template');
+    }
+
+    const lists = board.lists.map((list) => ({
+      title: list.title,
+      position: list.position,
+      sampleCards: list.cards.map((card, index) => ({
+        title: card.title,
+        position: index,
+      })),
+    }));
+
+    return this.create(
+      {
+        name: name ?? board.title,
+        description: board.description ?? '',
+        lists,
+        visibility: Visibility.PRIVATE,
+        workspaceId: board.workspaceId ?? undefined,
+      },
+      userId,
+    );
+  }
+
+  async findOne(id: string, userId: string): Promise<Template> {
+    const row = await this.prisma.boardTemplate.findUnique({
+      where: { id },
+    });
+    if (!row) {
+      throw new NotFoundException('Template not found');
+    }
+    await this.checkTemplateAccess(row as BoardTemplateRow, userId);
+    return this.toTemplate(row as BoardTemplateRow);
+  }
+
+  /**
+   * List templates: global (workspaceId null) + optionally those of the given workspace.
+   * Visibility: PRIVATE = only creator; WORKSPACE = creator + workspace members; PUBLIC = everyone.
+   * If workspaceId is provided, user must be a member; filters by workspace (null or that workspace).
+   */
+  async findAll(workspaceId: string | null, userId: string): Promise<Template[]> {
+    if (workspaceId) {
+      const membership = await this.prisma.workspaceMember.findUnique({
+        where: {
+          workspaceId_userId: { workspaceId, userId },
+        },
+      });
+      if (!membership) {
+        throw new ForbiddenException('You are not a member of this workspace');
+      }
+    }
+
+    const workspaceFilter = workspaceId
+      ? { OR: [{ workspaceId: null }, { workspaceId }] }
+      : { workspaceId: null };
+
+    const userWorkspaceIds = await this.prisma.workspaceMember
+      .findMany({
+        where: { userId },
+        select: { workspaceId: true },
+      })
+      .then((rows) => rows.map((r) => r.workspaceId));
+
+    const rows = await this.prisma.boardTemplate.findMany({
+      where: {
+        AND: [
+          workspaceFilter,
+          {
+            OR: [
+              { creatorId: userId },
+              { visibility: Visibility.PUBLIC },
+              {
+                visibility: Visibility.WORKSPACE,
+                workspaceId: { in: userWorkspaceIds },
+              },
+            ],
+          },
+        ],
+      } as Prisma.BoardTemplateWhereInput,
+      orderBy: { createdAt: 'desc' },
+    });
+
+    return rows.map((r) => this.toTemplate(r as BoardTemplateRow));
+  }
+
+  async update(input: UpdateTemplateInput, userId: string): Promise<Template> {
+    const row = await this.prisma.boardTemplate.findUnique({
+      where: { id: input.id },
+    });
+    if (!row) {
+      throw new NotFoundException('Template not found');
+    }
+    await this.checkTemplateEditPermission(row as BoardTemplateRow, userId);
+
+    const updateData: Prisma.BoardTemplateUpdateInput & { visibility?: Visibility } = {};
+    if (input.name !== undefined) updateData.name = input.name;
+    if (input.description !== undefined) updateData.description = input.description;
+    if (input.visibility !== undefined) updateData.visibility = input.visibility;
+    if (input.lists !== undefined) {
+      if (!input.lists.length) {
+        throw new BadRequestException('At least one list is required');
+      }
+      updateData.lists = input.lists.map((l) => ({
+        title: l.title,
+        position: l.position,
+        ...(l.sampleCards?.length && { sampleCards: l.sampleCards }),
+      })) as unknown as Prisma.InputJsonValue;
+    }
+
+    const updated = await this.prisma.boardTemplate.update({
+      where: { id: input.id },
+      data: updateData as Prisma.BoardTemplateUpdateInput,
+    });
+    return this.toTemplate(updated as BoardTemplateRow);
+  }
+
+  async delete(id: string, userId: string): Promise<boolean> {
+    const row = await this.prisma.boardTemplate.findUnique({
+      where: { id },
+    });
+    if (!row) {
+      throw new NotFoundException('Template not found');
+    }
+    await this.checkTemplateEditPermission(row as BoardTemplateRow, userId);
+    await this.prisma.boardTemplate.delete({ where: { id } });
+    return true;
+  }
+
+  /**
+   * Resolve template by id for board creation. Returns null if not found or no access.
+   * Used by BoardsService when templateId is a UUID (custom template).
+   */
+  async getTemplateForBoard(
+    templateId: string,
+    userId: string,
+  ): Promise<{ lists: ListRow[] } | null> {
+    const row = await this.prisma.boardTemplate.findUnique({
+      where: { id: templateId },
+    });
+    if (!row) return null;
+    try {
+      await this.checkTemplateAccess(row as BoardTemplateRow, userId);
+    } catch {
+      return null;
+    }
+    const lists = row.lists as ListRow[];
+    return { lists: Array.isArray(lists) ? lists : [] };
+  }
+
+  private async checkBoardAccess(
+    board: {
+      visibility: string;
+      members: { userId: string }[];
+      workspaceId: string | null;
+      workspace?: { memberships: { userId: string }[] };
+    },
+    userId: string,
+  ): Promise<void> {
+    if (board.visibility === 'PUBLIC') return;
+    if (board.members.some((m) => m.userId === userId)) return;
+    if (
+      board.visibility === 'WORKSPACE' &&
+      board.workspaceId &&
+      board.workspace?.memberships.some((m) => m.userId === userId)
+    ) {
+      return;
+    }
+    throw new ForbiddenException('You do not have access to this board');
+  }
+
+  private async checkTemplateAccess(
+    row: {
+      workspaceId: string | null;
+      creatorId: string;
+      visibility: Visibility;
+    },
+    userId: string,
+  ): Promise<void> {
+    if (row.creatorId === userId) return;
+    if (row.visibility === Visibility.PUBLIC) return;
+    if (row.visibility === Visibility.WORKSPACE && row.workspaceId) {
+      const membership = await this.prisma.workspaceMember.findUnique({
+        where: {
+          workspaceId_userId: { workspaceId: row.workspaceId, userId },
+        },
+      });
+      if (membership) return;
+    }
+    throw new ForbiddenException('You do not have access to this template');
+  }
+
+  private async checkTemplateEditPermission(
+    row: { workspaceId: string | null; creatorId: string },
+    userId: string,
+  ): Promise<void> {
+    if (row.creatorId === userId) return;
+    if (!row.workspaceId) {
+      throw new ForbiddenException('Only the creator can edit this template');
+    }
+    const membership = await this.prisma.workspaceMember.findUnique({
+      where: {
+        workspaceId_userId: { workspaceId: row.workspaceId, userId },
+      },
+    });
+    if (!membership || membership.role !== Role.ADMIN) {
+      throw new ForbiddenException('Only the creator or a workspace admin can edit this template');
+    }
+  }
+
+  private toTemplate(row: BoardTemplateRow): Template {
+    const lists = (row.lists as ListRow[]) ?? [];
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      lists: lists.map(toTemplateListType),
+      visibility: row.visibility,
+      workspaceId: row.workspaceId ?? undefined,
+      creatorId: row.creatorId,
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+}

From 493c623e882371223da6e2279ab18852db7f0397 Mon Sep 17 00:00:00 2001
From: mpJunot <junot-hery-nantenaina.montpre@epitech.eu>
Date: Wed, 11 Feb 2026 00:49:14 +0100
Subject: [PATCH 3/9] feat(backend): add predefined board templates (blank,
 kanban, sprint, project)

---
 backend/src/modules/boards/board-templates.ts |  72 ++++++++
 backend/src/modules/boards/boards.module.ts   |   3 +-
 .../modules/boards/boards.resolver.spec.ts    |  31 ++++
 backend/src/modules/boards/boards.resolver.ts |  26 +++
 .../src/modules/boards/boards.service.spec.ts |   9 +
 backend/src/modules/boards/boards.service.ts  | 168 +++++++++++++++++-
 .../modules/boards/dto/copy-board.input.ts    |  38 ++++
 .../modules/boards/dto/create-board.input.ts  |   5 +
 .../boards/entities/board-template.entity.ts  |  16 ++
 9 files changed, 359 insertions(+), 9 deletions(-)
 create mode 100644 backend/src/modules/boards/board-templates.ts
 create mode 100644 backend/src/modules/boards/dto/copy-board.input.ts
 create mode 100644 backend/src/modules/boards/entities/board-template.entity.ts

diff --git a/backend/src/modules/boards/board-templates.ts b/backend/src/modules/boards/board-templates.ts
new file mode 100644
index 0000000..f2bcf79
--- /dev/null
+++ b/backend/src/modules/boards/board-templates.ts
@@ -0,0 +1,72 @@
+/**
+ * Predefined board templates (Trello-style).
+ * Each template defines list titles and optional sample cards per list.
+ */
+
+export type BoardTemplateList = {
+  title: string;
+  position: number;
+  sampleCards?: { title: string; position: number }[];
+};
+
+export type BoardTemplate = {
+  id: string;
+  name: string;
+  description: string;
+  lists: BoardTemplateList[];
+};
+
+export const BOARD_TEMPLATES: BoardTemplate[] = [
+  {
+    id: 'blank',
+    name: 'Blank',
+    description: 'Empty board with To Do, Doing, Done',
+    lists: [
+      { title: 'To Do', position: 0 },
+      { title: 'Doing', position: 1 },
+      { title: 'Done', position: 2 },
+    ],
+  },
+  {
+    id: 'kanban',
+    name: 'Kanban',
+    description: 'Classic Kanban: To Do, In Progress, Done',
+    lists: [
+      { title: 'To Do', position: 0, sampleCards: [{ title: 'Get started', position: 0 }] },
+      { title: 'In Progress', position: 1 },
+      { title: 'Done', position: 2 },
+    ],
+  },
+  {
+    id: 'sprint',
+    name: 'Sprint',
+    description: 'Agile sprint: Backlog, To Do, In Progress, In Review, Done',
+    lists: [
+      { title: 'Backlog', position: 0 },
+      { title: 'To Do', position: 1 },
+      { title: 'In Progress', position: 2 },
+      { title: 'In Review', position: 3 },
+      { title: 'Done', position: 4 },
+    ],
+  },
+  {
+    id: 'project',
+    name: 'Project',
+    description: 'Project tracking: To Do, In Progress, Blocked, Done',
+    lists: [
+      { title: 'To Do', position: 0 },
+      { title: 'In Progress', position: 1 },
+      { title: 'Blocked', position: 2 },
+      { title: 'Done', position: 3 },
+    ],
+  },
+];
+
+const TEMPLATES_BY_ID = new Map(BOARD_TEMPLATES.map((t) => [t.id, t]));
+
+export function getBoardTemplate(templateId: string | null | undefined): BoardTemplate {
+  if (!templateId) {
+    return BOARD_TEMPLATES[0]; // blank
+  }
+  return TEMPLATES_BY_ID.get(templateId) ?? BOARD_TEMPLATES[0];
+}
diff --git a/backend/src/modules/boards/boards.module.ts b/backend/src/modules/boards/boards.module.ts
index 33c3ac2..bad19a6 100644
--- a/backend/src/modules/boards/boards.module.ts
+++ b/backend/src/modules/boards/boards.module.ts
@@ -5,9 +5,10 @@ import { BoardSubscriptionResolver } from './board-subscription.resolver';
 import { PrismaModule } from '../../prisma/prisma.module';
 import { ActivityModule } from '../activity/activity.module';
 import { NotificationsModule } from '../notifications/notifications.module';
+import { TemplatesModule } from '../templates/templates.module';
 
 @Module({
-  imports: [PrismaModule, ActivityModule, NotificationsModule],
+  imports: [PrismaModule, ActivityModule, NotificationsModule, TemplatesModule],
   providers: [BoardsResolver, BoardSubscriptionResolver, BoardsService],
   exports: [BoardsService],
 })
diff --git a/backend/src/modules/boards/boards.resolver.spec.ts b/backend/src/modules/boards/boards.resolver.spec.ts
index f6484f5..a1ad46f 100644
--- a/backend/src/modules/boards/boards.resolver.spec.ts
+++ b/backend/src/modules/boards/boards.resolver.spec.ts
@@ -12,6 +12,7 @@ describe('BoardsResolver', () => {
 
   const mockBoardsService = {
     create: jest.fn(),
+    copy: jest.fn(),
     findOne: jest.fn(),
     findByWorkspace: jest.fn(),
     update: jest.fn(),
@@ -144,6 +145,36 @@ describe('BoardsResolver', () => {
     });
   });
 
+  describe('copyBoard', () => {
+    it('should copy a board', async () => {
+      const input = {
+        sourceBoardId: 'board-1',
+        title: 'Copied Board',
+        workspaceId: 'workspace-1',
+      };
+
+      const copiedBoard = { ...mockBoard, id: 'board-2', title: 'Copied Board' };
+      mockBoardsService.copy.mockResolvedValue(copiedBoard);
+
+      const result = await resolver.copyBoard(input, mockUser);
+
+      expect(result).toEqual(copiedBoard);
+      expect(service.copy).toHaveBeenCalledWith(input, mockUser.id);
+    });
+  });
+
+  describe('boardTemplates', () => {
+    it('should return predefined board templates', () => {
+      const result = resolver.boardTemplates();
+      expect(Array.isArray(result)).toBe(true);
+      expect(result.length).toBeGreaterThan(0);
+      expect(result[0]).toHaveProperty('id');
+      expect(result[0]).toHaveProperty('name');
+      expect(result[0]).toHaveProperty('description');
+      expect(result[0]).toHaveProperty('listTitles');
+    });
+  });
+
   describe('board', () => {
     it('should return a board by id', async () => {
       mockBoardsService.findOne.mockResolvedValue(mockBoard);
diff --git a/backend/src/modules/boards/boards.resolver.ts b/backend/src/modules/boards/boards.resolver.ts
index 624af7b..a285595 100644
--- a/backend/src/modules/boards/boards.resolver.ts
+++ b/backend/src/modules/boards/boards.resolver.ts
@@ -4,7 +4,10 @@ import { PubSub } from 'graphql-subscriptions';
 import { BoardsService } from './boards.service';
 import { Board } from './entities/board.entity';
 import { BoardMemberWithUser } from './entities/board-member.entity';
+import { BoardTemplate } from './entities/board-template.entity';
+import { BOARD_TEMPLATES } from './board-templates';
 import { CreateBoardInput } from './dto/create-board.input';
+import { CopyBoardInput } from './dto/copy-board.input';
 import { UpdateBoardInput } from './dto/update-board.input';
 import { AddBoardMemberInput } from './dto/add-board-member.input';
 import { UpdateBoardMemberRoleInput } from './dto/update-board-member-role.input';
@@ -51,6 +54,29 @@ export class BoardsResolver {
     return this.boardsService.create(input, user.id);
   }
 
+  @Mutation(() => Board, {
+    description: 'Copy a board (lists, cards, labels, checklists). New board has current user as ADMIN.',
+  })
+  async copyBoard(
+    @Args('input') input: CopyBoardInput,
+    @CurrentUser() user: any,
+  ): Promise<Board> {
+    return this.boardsService.copy(input, user.id);
+  }
+
+  @Query(() => [BoardTemplate], {
+    name: 'boardTemplates',
+    description: 'List predefined board templates (blank, kanban, sprint, project).',
+  })
+  boardTemplates(): BoardTemplate[] {
+    return BOARD_TEMPLATES.map((t) => ({
+      id: t.id,
+      name: t.name,
+      description: t.description,
+      listTitles: t.lists.map((l) => l.title),
+    }));
+  }
+
   @Query(() => Board, {
     name: 'board',
     description: 'Get a board by ID. Access based on visibility and membership.',
diff --git a/backend/src/modules/boards/boards.service.spec.ts b/backend/src/modules/boards/boards.service.spec.ts
index b15c826..a8f7550 100644
--- a/backend/src/modules/boards/boards.service.spec.ts
+++ b/backend/src/modules/boards/boards.service.spec.ts
@@ -3,6 +3,7 @@ import { NotFoundException, ForbiddenException, ConflictException, BadRequestExc
 import { BoardsService } from './boards.service';
 import { PrismaService } from '../../prisma/prisma.service';
 import { NotificationsService } from '../notifications/notifications.service';
+import { TemplatesService } from '../templates/templates.service';
 import { Role, Visibility } from '@prisma/client';
 
 describe('BoardsService', () => {
@@ -37,6 +38,10 @@ describe('BoardsService', () => {
     create: jest.fn().mockResolvedValue({ id: 'notif-1', userId: 'user-1', type: 'BOARD_INVITATION', read: false, createdAt: new Date() }),
   };
 
+  const mockTemplatesService = {
+    getTemplateForBoard: jest.fn().mockResolvedValue(null),
+  };
+
   const mockUser = {
     id: 'user-1',
     email: 'test@example.com',
@@ -77,6 +82,10 @@ describe('BoardsService', () => {
           provide: NotificationsService,
           useValue: mockNotificationsService,
         },
+        {
+          provide: TemplatesService,
+          useValue: mockTemplatesService,
+        },
       ],
     }).compile();
 
diff --git a/backend/src/modules/boards/boards.service.ts b/backend/src/modules/boards/boards.service.ts
index 8786518..dee9ae2 100644
--- a/backend/src/modules/boards/boards.service.ts
+++ b/backend/src/modules/boards/boards.service.ts
@@ -3,16 +3,22 @@ import { NotificationType, Role } from '@prisma/client';
 import { PrismaService } from '../../prisma/prisma.service';
 import { NotificationsService } from '../notifications/notifications.service';
 import { CreateBoardInput } from './dto/create-board.input';
+import { CopyBoardInput } from './dto/copy-board.input';
+import { getBoardTemplate } from './board-templates';
 import { UpdateBoardInput } from './dto/update-board.input';
+import { TemplatesService } from '../templates/templates.service';
 import { AddBoardMemberInput } from './dto/add-board-member.input';
 import { Board } from './entities/board.entity';
 import { BoardMemberWithUser } from './entities/board-member.entity';
 
+const SYSTEM_TEMPLATE_IDS = new Set(['blank', 'kanban', 'sprint', 'project']);
+
 @Injectable()
 export class BoardsService {
   constructor(
     private prisma: PrismaService,
     private notificationsService: NotificationsService,
+    private templatesService: TemplatesService,
   ) {}
 
   /**
@@ -51,14 +57,28 @@ export class BoardsService {
       }
     }
 
-    // Default columns for new boards (To Do, Doing, Done)
-    const defaultLists = [
-      { title: 'To Do', position: 0 },
-      { title: 'Doing', position: 1 },
-      { title: 'Done', position: 2 },
-    ];
+    let templateLists: { title: string; position: number; sampleCards?: { title: string; position: number }[] }[];
+    if (input.templateId && !SYSTEM_TEMPLATE_IDS.has(input.templateId)) {
+      const custom = await this.templatesService.getTemplateForBoard(input.templateId, userId);
+      templateLists = custom?.lists ?? getBoardTemplate(input.templateId).lists;
+    } else {
+      templateLists = getBoardTemplate(input.templateId).lists;
+    }
+    const listsCreate = templateLists.map((list) => ({
+      title: list.title,
+      position: list.position,
+      ...(list.sampleCards?.length
+        ? {
+            cards: {
+              create: list.sampleCards.map((c) => ({
+                title: c.title,
+                position: c.position,
+              })),
+            },
+          }
+        : {}),
+    }));
 
-    // Create board with creator as ADMIN and default lists
     const board = await this.prisma.board.create({
       data: {
         title: input.title,
@@ -74,7 +94,7 @@ export class BoardsService {
           },
         },
         lists: {
-          create: defaultLists,
+          create: listsCreate,
         },
       },
     });
@@ -82,6 +102,138 @@ export class BoardsService {
     return board;
   }
 
+  /**
+   * Copy a board: create a new board with the same lists, cards, labels, and checklists.
+   * Does not copy members (except current user as ADMIN), comments, attachments, or assignees.
+   */
+  async copy(input: CopyBoardInput, userId: string): Promise<Board> {
+    const source = await this.prisma.board.findUnique({
+      where: { id: input.sourceBoardId },
+      include: {
+        members: true,
+        workspace: { include: { memberships: true } },
+        labels: true,
+        lists: {
+          where: { isArchived: false },
+          orderBy: { position: 'asc' },
+          include: {
+            cards: {
+              where: { isArchived: false },
+              orderBy: { position: 'asc' },
+              include: {
+                labels: true,
+                checklists: { include: { items: true } },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!source) {
+      throw new NotFoundException('Board not found');
+    }
+
+    await this.checkBoardAccess(source, userId);
+
+    const workspaceId = input.workspaceId ?? source.workspaceId;
+    if (workspaceId) {
+      const membership = await this.prisma.workspaceMember.findUnique({
+        where: {
+          workspaceId_userId: { workspaceId, userId },
+        },
+      });
+      if (!membership) {
+        throw new ForbiddenException('You are not a member of this workspace');
+      }
+      if (membership.role === Role.OBSERVER) {
+        throw new ForbiddenException('Observers cannot create boards');
+      }
+    }
+
+    const newBoard = await this.prisma.$transaction(async (tx) => {
+      const board = await tx.board.create({
+        data: {
+          title: input.title,
+          description: input.description ?? source.description,
+          workspaceId,
+          visibility: input.visibility ?? source.visibility,
+          background: input.background ?? source.background,
+          creatorId: userId,
+          members: {
+            create: { userId, role: Role.ADMIN },
+          },
+        },
+      });
+
+      const labelIdMap = new Map<string, string>();
+      for (const label of source.labels) {
+        const created = await tx.label.create({
+          data: {
+            boardId: board.id,
+            name: label.name,
+            color: label.color,
+          },
+        });
+        labelIdMap.set(label.id, created.id);
+      }
+
+      for (const list of source.lists) {
+        const newList = await tx.list.create({
+          data: {
+            boardId: board.id,
+            title: list.title,
+            position: list.position,
+          },
+        });
+
+        for (const card of list.cards) {
+          const newCard = await tx.card.create({
+            data: {
+              listId: newList.id,
+              title: card.title,
+              description: card.description,
+              background: card.background,
+              startDate: card.startDate,
+              dueDate: card.dueDate,
+              position: card.position,
+              completed: card.completed,
+            },
+          });
+
+          for (const cl of card.labels) {
+            const newLabelId = labelIdMap.get(cl.labelId);
+            if (newLabelId) {
+              await tx.cardLabel.create({
+                data: { cardId: newCard.id, labelId: newLabelId },
+              });
+            }
+          }
+
+          for (const checklist of card.checklists) {
+            const newChecklist = await tx.checklist.create({
+              data: { cardId: newCard.id, title: checklist.title },
+            });
+            for (const item of checklist.items) {
+              await tx.checklistItem.create({
+                data: {
+                  checklistId: newChecklist.id,
+                  content: item.content,
+                  checked: item.checked,
+                  position: item.position,
+                },
+              });
+            }
+          }
+        }
+      }
+
+      return board;
+    });
+
+    return newBoard;
+  }
+
   /**
    * Find board by ID
    * - User must be a member of the board OR workspace
diff --git a/backend/src/modules/boards/dto/copy-board.input.ts b/backend/src/modules/boards/dto/copy-board.input.ts
new file mode 100644
index 0000000..ff634f7
--- /dev/null
+++ b/backend/src/modules/boards/dto/copy-board.input.ts
@@ -0,0 +1,38 @@
+import { InputType, Field, ID } from '@nestjs/graphql';
+import { IsNotEmpty, IsString, IsOptional, IsEnum, IsUUID } from 'class-validator';
+import { Visibility } from '@prisma/client';
+
+@InputType()
+export class CopyBoardInput {
+  @Field(() => ID, {
+    description: 'ID of the board to copy (lists, cards, labels, checklists).',
+  })
+  @IsNotEmpty()
+  @IsUUID()
+  sourceBoardId: string;
+
+  @Field({ description: 'Title for the new board.' })
+  @IsNotEmpty()
+  @IsString()
+  title: string;
+
+  @Field(() => ID, { nullable: true })
+  @IsOptional()
+  @IsUUID()
+  workspaceId?: string;
+
+  @Field({ nullable: true })
+  @IsOptional()
+  @IsString()
+  description?: string;
+
+  @Field(() => Visibility, { nullable: true })
+  @IsOptional()
+  @IsEnum(Visibility)
+  visibility?: Visibility;
+
+  @Field({ nullable: true })
+  @IsOptional()
+  @IsString()
+  background?: string;
+}
diff --git a/backend/src/modules/boards/dto/create-board.input.ts b/backend/src/modules/boards/dto/create-board.input.ts
index 8db7706..d6bbc46 100644
--- a/backend/src/modules/boards/dto/create-board.input.ts
+++ b/backend/src/modules/boards/dto/create-board.input.ts
@@ -28,4 +28,9 @@ export class CreateBoardInput {
   @IsOptional()
   @IsString()
   background?: string;
+
+  @Field({ nullable: true, description: 'Predefined template: blank, kanban, sprint, project' })
+  @IsOptional()
+  @IsString()
+  templateId?: string;
 }
diff --git a/backend/src/modules/boards/entities/board-template.entity.ts b/backend/src/modules/boards/entities/board-template.entity.ts
new file mode 100644
index 0000000..1c3f31a
--- /dev/null
+++ b/backend/src/modules/boards/entities/board-template.entity.ts
@@ -0,0 +1,16 @@
+import { ObjectType, Field } from '@nestjs/graphql';
+
+@ObjectType()
+export class BoardTemplate {
+  @Field()
+  id: string;
+
+  @Field()
+  name: string;
+
+  @Field()
+  description: string;
+
+  @Field(() => [String], { description: 'List titles in order' })
+  listTitles: string[];
+}

From 85930546e7279ffbf2b2b4e917ab42c736a6e385 Mon Sep 17 00:00:00 2001
From: mpJunot <junot-hery-nantenaina.montpre@epitech.eu>
Date: Wed, 11 Feb 2026 00:49:38 +0100
Subject: [PATCH 4/9] chore(backend): register templates module and update
 GraphQL schema

---
 backend/src/app.module.ts      |   2 +
 backend/src/graphql/schema.gql | 109 +++++++++++++++++++++++++++++++++
 2 files changed, 111 insertions(+)

diff --git a/backend/src/app.module.ts b/backend/src/app.module.ts
index 2298842..18b1a3c 100644
--- a/backend/src/app.module.ts
+++ b/backend/src/app.module.ts
@@ -23,6 +23,7 @@ import { AttachmentsModule } from './modules/attachments/attachments.module';
 import { UploadModule } from './modules/upload/upload.module';
 import { ActivityModule } from './modules/activity/activity.module';
 import { NotificationsModule } from './modules/notifications/notifications.module';
+import { TemplatesModule } from './modules/templates/templates.module';
 import { SubscriptionsModule } from './common/subscriptions/subscriptions.module';
 import { validateWsConnection } from './common/subscriptions/ws-auth';
 import { GqlAuthGuard } from './common/guards/gql-auth.guard';
@@ -110,6 +111,7 @@ import { HealthController } from './common/controllers/health.controller';
     UploadModule,
     ActivityModule,
     NotificationsModule,
+    TemplatesModule,
   ],
   controllers: [HealthController],
   providers: [
diff --git a/backend/src/graphql/schema.gql b/backend/src/graphql/schema.gql
index b4abe4b..56f0c2d 100644
--- a/backend/src/graphql/schema.gql
+++ b/backend/src/graphql/schema.gql
@@ -115,6 +115,15 @@ type BoardMemberWithUser {
   userId: ID!
 }
 
+type BoardTemplate {
+  description: String!
+  id: String!
+
+  """List titles in order"""
+  listTitles: [String!]!
+  name: String!
+}
+
 type Card {
   assignees: [MemberUser!]
   background: String
@@ -173,6 +182,19 @@ type CommentDeletedEvent {
   commentId: ID!
 }
 
+input CopyBoardInput {
+  background: String
+  description: String
+
+  """ID of the board to copy (lists, cards, labels, checklists)."""
+  sourceBoardId: ID!
+
+  """Title for the new board."""
+  title: String!
+  visibility: Visibility
+  workspaceId: ID
+}
+
 input CreateAttachmentInput {
   cardId: ID!
   filename: String!
@@ -183,6 +205,9 @@ input CreateAttachmentInput {
 input CreateBoardInput {
   background: String
   description: String
+
+  """Predefined template: blank, kanban, sprint, project"""
+  templateId: String
   title: String!
   visibility: Visibility
   workspaceId: ID
@@ -227,6 +252,14 @@ input CreateListInput {
   title: String!
 }
 
+input CreateTemplateInput {
+  description: String!
+  lists: [TemplateListInput!]!
+  name: String!
+  visibility: Visibility
+  workspaceId: ID
+}
+
 input CreateUserInput {
   avatar: String
   description: String
@@ -356,6 +389,11 @@ type Mutation {
   """
   cancelInvitation(invitationId: ID!): Boolean!
 
+  """
+  Copy a board (lists, cards, labels, checklists). New board has current user as ADMIN.
+  """
+  copyBoard(input: CopyBoardInput!): Board!
+
   """Create an attachment on a card."""
   createAttachment(input: CreateAttachmentInput!): Attachment!
 
@@ -383,6 +421,16 @@ type Mutation {
   """
   createList(input: CreateListInput!): List!
 
+  """
+  Create a custom board template. Optional workspaceId to scope to a workspace.
+  """
+  createTemplate(input: CreateTemplateInput!): Template!
+
+  """
+  Create a template from an existing board (lists and cards become template structure).
+  """
+  createTemplateFromBoard(boardId: ID!, name: String): Template!
+
   """Create a new user (requires authentication)"""
   createUser(input: CreateUserInput!): User!
 
@@ -413,6 +461,9 @@ type Mutation {
   """Delete a list. Cards are automatically deleted via cascade."""
   deleteList(id: ID!): Boolean!
 
+  """Delete a template. Only creator or workspace admin."""
+  deleteTemplate(id: ID!): Boolean!
+
   """Delete a user by ID (requires authentication)"""
   deleteUser(id: ID!): Boolean!
 
@@ -536,6 +587,9 @@ type Mutation {
   """Update current user notification preferences."""
   updateMyNotificationPreferences(input: UpdateNotificationPreferencesInput!): NotificationPreferences!
 
+  """Update a template. Only creator or workspace admin."""
+  updateTemplate(input: UpdateTemplateInput!): Template!
+
   """Update an existing user (requires authentication)"""
   updateUser(id: ID!, input: UpdateUserInput!): User!
 
@@ -647,6 +701,9 @@ type Query {
   """List all labels for a board. User must have access to the board."""
   boardLabels(boardId: ID!): [Label!]!
 
+  """List predefined board templates (blank, kanban, sprint, project)."""
+  boardTemplates: [BoardTemplate!]!
+
   """Get a card by ID. User must have access to the board."""
   card(id: ID!): Card!
 
@@ -692,6 +749,16 @@ type Query {
   """Get all workspaces where the current user is a member"""
   myWorkspaces: [Workspace!]!
 
+  """
+  Get a template by ID. User must have access (global or workspace member).
+  """
+  template(id: ID!): Template!
+
+  """
+  List templates. If workspaceId is provided, returns global + workspace templates; otherwise global only.
+  """
+  templates(workspaceId: ID): [Template!]!
+
   """Get a user by ID (requires authentication)"""
   user(id: ID!): User
 
@@ -824,6 +891,40 @@ type Subscription {
   workspaceMembersUpdated(workspaceId: ID!): Boolean!
 }
 
+type Template {
+  createdAt: DateTime!
+  creatorId: ID!
+  description: String!
+  id: ID!
+  lists: [TemplateListType!]!
+  name: String!
+  updatedAt: DateTime!
+  visibility: Visibility!
+  workspaceId: ID
+}
+
+input TemplateListInput {
+  position: Int!
+  sampleCards: [TemplateSampleCardInput!]
+  title: String!
+}
+
+type TemplateListType {
+  position: Int!
+  sampleCards: [TemplateSampleCard!]
+  title: String!
+}
+
+type TemplateSampleCard {
+  position: Float!
+  title: String!
+}
+
+input TemplateSampleCardInput {
+  position: Float!
+  title: String!
+}
+
 input UnassignMemberFromCardInput {
   cardId: ID!
   userId: ID!
@@ -903,6 +1004,14 @@ input UpdateNotificationPreferencesInput {
   emailFrequency: NotificationEmailFrequency
 }
 
+input UpdateTemplateInput {
+  description: String
+  id: ID!
+  lists: [TemplateListInput!]
+  name: String
+  visibility: Visibility
+}
+
 input UpdateUserInput {
   avatar: String
   description: String

From 66ce0ce7d1cfa064aa54231fc4c6d58da4dbc65c Mon Sep 17 00:00:00 2001
From: mpJunot <junot-hery-nantenaina.montpre@epitech.eu>
Date: Wed, 11 Feb 2026 00:49:43 +0100
Subject: [PATCH 5/9] test(backend): add workspace-members-subscription
 resolver spec

---
 backend/jest.config.js                        |  3 +
 ...pace-members-subscription.resolver.spec.ts | 78 +++++++++++++++++++
 2 files changed, 81 insertions(+)
 create mode 100644 backend/src/modules/invitations/workspace-members-subscription.resolver.spec.ts

diff --git a/backend/jest.config.js b/backend/jest.config.js
index 9b1198b..acaa5eb 100644
--- a/backend/jest.config.js
+++ b/backend/jest.config.js
@@ -1,6 +1,9 @@
 module.exports = {
   moduleFileExtensions: ['js', 'json', 'ts'],
   rootDir: 'src',
+  moduleNameMapper: {
+    '^@/(.*)$': '<rootDir>/$1',
+  },
   testRegex: '.*\\.spec\\.ts$',
   transform: {
     '^.+\\.(t|j)s$': 'ts-jest',
diff --git a/backend/src/modules/invitations/workspace-members-subscription.resolver.spec.ts b/backend/src/modules/invitations/workspace-members-subscription.resolver.spec.ts
new file mode 100644
index 0000000..a93180d
--- /dev/null
+++ b/backend/src/modules/invitations/workspace-members-subscription.resolver.spec.ts
@@ -0,0 +1,78 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { WorkspaceMembersSubscriptionResolver } from './workspace-members-subscription.resolver';
+import { PUB_SUB } from '../../common/subscriptions/pubsub.provider';
+import { GqlAuthGuard } from '../../common/guards/gql-auth.guard';
+import {
+  TRIGGER_WORKSPACE_MEMBERS_UPDATED,
+  TRIGGER_WORKSPACE_INVITATIONS_UPDATED,
+  TRIGGER_MY_INVITATIONS_UPDATED,
+} from './workspace-members-subscription.resolver';
+
+describe('WorkspaceMembersSubscriptionResolver', () => {
+  let resolver: WorkspaceMembersSubscriptionResolver;
+  let pubSub: { asyncIterableIterator: jest.Mock };
+
+  beforeEach(async () => {
+    const mockIterator = { [Symbol.asyncIterator]: jest.fn() };
+    pubSub = {
+      asyncIterableIterator: jest.fn().mockReturnValue(mockIterator),
+    };
+
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [
+        WorkspaceMembersSubscriptionResolver,
+        {
+          provide: PUB_SUB,
+          useValue: pubSub,
+        },
+      ],
+    })
+      .overrideGuard(GqlAuthGuard)
+      .useValue({ canActivate: () => true })
+      .compile();
+
+    resolver = module.get<WorkspaceMembersSubscriptionResolver>(
+      WorkspaceMembersSubscriptionResolver,
+    );
+  });
+
+  it('should be defined', () => {
+    expect(resolver).toBeDefined();
+  });
+
+  describe('workspaceMembersUpdated', () => {
+    it('should return async iterable for TRIGGER_WORKSPACE_MEMBERS_UPDATED', () => {
+      const result = resolver.workspaceMembersUpdated('ws-1');
+
+      expect(pubSub.asyncIterableIterator).toHaveBeenCalledWith(
+        TRIGGER_WORKSPACE_MEMBERS_UPDATED,
+      );
+      expect(result).toBeDefined();
+      expect(typeof result[Symbol.asyncIterator]).toBe('function');
+    });
+  });
+
+  describe('workspaceInvitationsUpdated', () => {
+    it('should return async iterable for TRIGGER_WORKSPACE_INVITATIONS_UPDATED', () => {
+      const result = resolver.workspaceInvitationsUpdated('ws-1');
+
+      expect(pubSub.asyncIterableIterator).toHaveBeenCalledWith(
+        TRIGGER_WORKSPACE_INVITATIONS_UPDATED,
+      );
+      expect(result).toBeDefined();
+      expect(typeof result[Symbol.asyncIterator]).toBe('function');
+    });
+  });
+
+  describe('myInvitationsUpdated', () => {
+    it('should return async iterable for TRIGGER_MY_INVITATIONS_UPDATED', () => {
+      const result = resolver.myInvitationsUpdated('user-1');
+
+      expect(pubSub.asyncIterableIterator).toHaveBeenCalledWith(
+        TRIGGER_MY_INVITATIONS_UPDATED,
+      );
+      expect(result).toBeDefined();
+      expect(typeof result[Symbol.asyncIterator]).toBe('function');
+    });
+  });
+});

From 5a66f4b4d39af5f563d0498e1c46a818b969a1ae Mon Sep 17 00:00:00 2001
From: mpJunot <junot-hery-nantenaina.montpre@epitech.eu>
Date: Wed, 11 Feb 2026 00:49:47 +0100
Subject: [PATCH 6/9] feat(frontend): add templates gallery, detail page and
 create template

---
 frontend/app/templates/[id]/page.tsx          | 306 ++++++++++++++++++
 .../components/CreateTemplateModal.tsx        | 228 +++++++++++++
 frontend/app/templates/page.tsx               | 296 +++++++++++++++++
 frontend/components/ui/breadcrumb.tsx         | 109 +++++++
 frontend/lib/actions/templates.ts             | 146 +++++++++
 5 files changed, 1085 insertions(+)
 create mode 100644 frontend/app/templates/[id]/page.tsx
 create mode 100644 frontend/app/templates/components/CreateTemplateModal.tsx
 create mode 100644 frontend/app/templates/page.tsx
 create mode 100644 frontend/components/ui/breadcrumb.tsx
 create mode 100644 frontend/lib/actions/templates.ts

diff --git a/frontend/app/templates/[id]/page.tsx b/frontend/app/templates/[id]/page.tsx
new file mode 100644
index 0000000..9dc8703
--- /dev/null
+++ b/frontend/app/templates/[id]/page.tsx
@@ -0,0 +1,306 @@
+'use client';
+
+import React, { useState, useEffect } from 'react';
+import Link from 'next/link';
+import { useParams, useRouter } from 'next/navigation';
+import { getTemplate } from '@/lib/actions/templates';
+import { getBoardTemplates } from '@/lib/actions/boards';
+import { useWorkspacesQuery } from '@/lib/queries/workspaces';
+import { Button } from '@/components/ui/button';
+import {
+  LayoutGrid,
+  Lock,
+  Users,
+  Globe,
+  List,
+  FileText,
+  ArrowLeft,
+} from 'lucide-react';
+import {
+  Breadcrumb,
+  BreadcrumbItem,
+  BreadcrumbLink,
+  BreadcrumbList,
+  BreadcrumbPage,
+  BreadcrumbSeparator,
+} from '@/components/ui/breadcrumb';
+import type { Template } from '@/lib/actions/templates';
+import type { Visibility } from '@/lib/graphql-types';
+
+const TEMPLATE_PREVIEW_CLASS: Record<string, string> = {
+  blank: 'bg-gradient-to-br from-slate-500 to-slate-700',
+  kanban: 'bg-gradient-to-br from-blue-500 to-indigo-600',
+  sprint: 'bg-gradient-to-br from-amber-500 to-orange-600',
+  project: 'bg-gradient-to-br from-emerald-500 to-teal-600',
+};
+
+function VisibilityBadge({ visibility }: { visibility: Visibility }) {
+  const config = {
+    PRIVATE: { icon: Lock, label: 'Private' },
+    WORKSPACE: { icon: Users, label: 'Workspace' },
+    PUBLIC: { icon: Globe, label: 'Public' },
+  } as const;
+  const { icon: Icon, label } = config[visibility];
+  return (
+    <span className='inline-flex items-center gap-1 rounded-full bg-muted px-2 py-1 text-xs text-muted-foreground'>
+      <Icon className='h-3.5 w-3.5' />
+      {label}
+    </span>
+  );
+}
+
+type TemplateDetail =
+  | Template
+  | { id: string; name: string; description: string; listTitles: string[] };
+
+function isFullTemplate(t: TemplateDetail): t is Template {
+  return 'lists' in t && Array.isArray((t as Template).lists);
+}
+
+export default function TemplateDetailPage() {
+  const params = useParams();
+  const router = useRouter();
+  const id = typeof params.id === 'string' ? params.id : '';
+  const [template, setTemplate] = useState<TemplateDetail | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const { data: workspacesData } = useWorkspacesQuery(!!id);
+  const workspaces = (workspacesData ?? []) as { id: string; name: string }[];
+  const firstWorkspaceId = workspaces[0]?.id;
+
+  useEffect(() => {
+    if (!id) {
+      setLoading(false);
+      setError('Missing template id');
+      return;
+    }
+    let cancelled = false;
+    const PREDEFINED_IDS = new Set(['blank', 'kanban', 'sprint', 'project']);
+    (async () => {
+      try {
+        const predefinedList = await getBoardTemplates();
+        const predefined = predefinedList.find((t) => t.id === id);
+        if (!cancelled && predefined) {
+          setTemplate({
+            id: predefined.id,
+            name: predefined.name,
+            description: predefined.description,
+            listTitles: predefined.listTitles ?? [],
+          });
+          setError(null);
+          return;
+        }
+        if (PREDEFINED_IDS.has(id)) {
+          if (!cancelled) {
+            setError('Template not found');
+            setTemplate(null);
+          }
+          return;
+        }
+        const custom = await getTemplate(id);
+        if (!cancelled && custom?.id) {
+          setTemplate(custom);
+          setError(null);
+        }
+      } catch {
+        if (!cancelled) {
+          setError('Failed to load template');
+          setTemplate(null);
+        }
+      } finally {
+        if (!cancelled) setLoading(false);
+      }
+    })();
+    return () => {
+      cancelled = true;
+    };
+  }, [id]);
+
+  const handleUseTemplate = () => {
+    if (firstWorkspaceId) {
+      router.push(
+        `/workspaces/${firstWorkspaceId}/boards?create=1&template=${encodeURIComponent(id)}`,
+      );
+    } else {
+      router.push(`/dashboard?create=1&template=${encodeURIComponent(id)}`);
+    }
+  };
+
+  if (loading) {
+    return (
+      <div className='min-h-screen bg-background flex items-center justify-center'>
+        <div className='animate-spin h-8 w-8 border-2 border-primary border-t-transparent rounded-full' />
+      </div>
+    );
+  }
+
+  if (error || !template) {
+    return (
+      <div className='min-h-screen bg-background px-4 py-8'>
+        <div className='mx-auto max-w-2xl text-center'>
+          <p className='text-muted-foreground mb-4'>
+            {error ?? 'Template not found'}
+          </p>
+          <Button asChild variant='outline'>
+            <Link href='/templates'>Back to templates</Link>
+          </Button>
+        </div>
+      </div>
+    );
+  }
+
+  const fullTemplate = isFullTemplate(template);
+  const gradientClass =
+    TEMPLATE_PREVIEW_CLASS[template.id] ??
+    'bg-gradient-to-br from-violet-500 to-purple-600';
+
+  return (
+    <div className='min-h-screen bg-background text-foreground'>
+      <div className='mx-auto max-w-4xl px-4 py-8 sm:px-6'>
+        <Breadcrumb className='mb-6'>
+          <BreadcrumbList>
+            <BreadcrumbItem>
+              <BreadcrumbLink asChild>
+                <Link
+                  href={
+                    firstWorkspaceId
+                      ? `/workspaces/${firstWorkspaceId}/boards`
+                      : '/dashboard'
+                  }
+                >
+                  {firstWorkspaceId ? 'Boards' : 'Dashboard'}
+                </Link>
+              </BreadcrumbLink>
+            </BreadcrumbItem>
+            <BreadcrumbSeparator />
+            <BreadcrumbItem>
+              <BreadcrumbLink asChild>
+                <Link href='/templates'>Templates</Link>
+              </BreadcrumbLink>
+            </BreadcrumbItem>
+            <BreadcrumbSeparator />
+            <BreadcrumbItem>
+              <BreadcrumbPage className='truncate max-w-[200px] sm:max-w-none'>
+                {template.name}
+              </BreadcrumbPage>
+            </BreadcrumbItem>
+          </BreadcrumbList>
+        </Breadcrumb>
+
+        {/* Header */}
+        <div className='mb-8 flex flex-col gap-4 sm:flex-row sm:items-start sm:justify-between'>
+          <div className='flex gap-4'>
+            <div
+              className={`h-20 w-20 shrink-0 rounded-xl ${gradientClass} flex items-center justify-center`}
+            >
+              <LayoutGrid className='h-10 w-10 text-white/90' />
+            </div>
+            <div className='min-w-0'>
+              <h1 className='text-2xl font-semibold tracking-tight truncate'>
+                {template.name}
+              </h1>
+              {fullTemplate && 'visibility' in template && (
+                <div className='mt-2'>
+                  <VisibilityBadge visibility={template.visibility} />
+                </div>
+              )}
+              {template.description ? (
+                <p className='mt-2 text-sm text-muted-foreground whitespace-pre-wrap'>
+                  {template.description}
+                </p>
+              ) : null}
+            </div>
+          </div>
+          <div className='flex gap-2 shrink-0'>
+            <Button variant='outline' asChild>
+              <Link href='/templates'>
+                <ArrowLeft className='h-4 w-4 mr-2' />
+                Back
+              </Link>
+            </Button>
+            <Button onClick={handleUseTemplate} disabled={!firstWorkspaceId}>
+              Use this template
+            </Button>
+          </div>
+        </div>
+
+        {/* Lists & cards */}
+        <section className='rounded-xl border border-accent bg-card overflow-hidden'>
+          <div className='border-b border-accent px-4 py-3 flex items-center gap-2'>
+            <List className='h-4 w-4 text-muted-foreground' />
+            <h2 className='font-medium'>Structure</h2>
+          </div>
+          <div className='p-4'>
+            {fullTemplate ? (
+              template.lists?.length ? (
+                <div className='space-y-4'>
+                  {[...template.lists]
+                    .sort((a, b) => (a.position ?? 0) - (b.position ?? 0))
+                    .map((list, index) => (
+                      <div
+                        key={`${list.title}-${index}`}
+                        className='rounded-lg border border-accent bg-muted/30 overflow-hidden'
+                      >
+                        <div className='px-4 py-2.5 bg-muted/50 border-b border-accent font-medium text-sm flex items-center gap-2'>
+                          <span className='rounded bg-primary/20 px-1.5 py-0.5 text-xs text-primary'>
+                            List {index + 1}
+                          </span>
+                          {list.title}
+                        </div>
+                        {list.sampleCards && list.sampleCards.length > 0 ? (
+                          <ul className='divide-y divide-accent'>
+                            {[...list.sampleCards]
+                              .sort(
+                                (a, b) => (a.position ?? 0) - (b.position ?? 0),
+                              )
+                              .map((card, cardIndex) => (
+                                <li
+                                  key={`${card.title}-${cardIndex}`}
+                                  className='px-4 py-2.5 flex items-center gap-2 text-sm'
+                                >
+                                  <FileText className='h-4 w-4 text-muted-foreground shrink-0' />
+                                  <span>{card.title}</span>
+                                </li>
+                              ))}
+                          </ul>
+                        ) : (
+                          <p className='px-4 py-3 text-sm text-muted-foreground'>
+                            No sample cards
+                          </p>
+                        )}
+                      </div>
+                    ))}
+                </div>
+              ) : (
+                <p className='text-sm text-muted-foreground py-4'>
+                  This template has no lists.
+                </p>
+              )
+            ) : (
+              <ul className='space-y-2'>
+                {'listTitles' in template &&
+                  (template.listTitles ?? []).map((title, index) => (
+                    <li
+                      key={`${title}-${index}`}
+                      className='flex items-center gap-2 rounded-lg border border-accent bg-muted/30 px-4 py-2.5'
+                    >
+                      <span className='rounded bg-primary/20 px-1.5 py-0.5 text-xs text-primary'>
+                        {index + 1}
+                      </span>
+                      <span className='font-medium'>{title}</span>
+                    </li>
+                  ))}
+              </ul>
+            )}
+          </div>
+        </section>
+
+        {!firstWorkspaceId && (
+          <p className='mt-4 text-center text-sm text-muted-foreground'>
+            Create a workspace to use this template when creating a board.
+          </p>
+        )}
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/app/templates/components/CreateTemplateModal.tsx b/frontend/app/templates/components/CreateTemplateModal.tsx
new file mode 100644
index 0000000..4e20547
--- /dev/null
+++ b/frontend/app/templates/components/CreateTemplateModal.tsx
@@ -0,0 +1,228 @@
+'use client';
+
+import React, { useState } from 'react';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import { useWorkspacesQuery } from '@/lib/queries/workspaces';
+import {
+  createTemplate,
+  type CreateTemplateInput,
+  type Visibility,
+} from '@/lib/actions/templates';
+import { toast } from '@/lib/toast';
+import { Plus, Trash2 } from 'lucide-react';
+
+type Props = {
+  open: boolean;
+  onClose: () => void;
+  onSuccess: () => void;
+  defaultWorkspaceId?: string | null;
+};
+
+export function CreateTemplateModal({
+  open,
+  onClose,
+  onSuccess,
+  defaultWorkspaceId,
+}: Props) {
+  const [name, setName] = useState('');
+  const [description, setDescription] = useState('');
+  const [visibility, setVisibility] = useState<Visibility>('PRIVATE');
+  const [workspaceId, setWorkspaceId] = useState<string | null>(
+    defaultWorkspaceId ?? null,
+  );
+  const [lists, setLists] = useState<{ title: string }[]>([
+    { title: 'To Do' },
+    { title: 'In Progress' },
+    { title: 'Done' },
+  ]);
+  const [submitting, setSubmitting] = useState(false);
+
+  const { data: workspacesData } = useWorkspacesQuery(open);
+  const workspaces = (workspacesData ?? []) as { id: string; name: string }[];
+
+  const addList = () => {
+    setLists((prev) => [...prev, { title: '' }]);
+  };
+
+  const removeList = (index: number) => {
+    setLists((prev) => prev.filter((_, i) => i !== index));
+  };
+
+  const updateListTitle = (index: number, title: string) => {
+    setLists((prev) => prev.map((l, i) => (i === index ? { ...l, title } : l)));
+  };
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    const trimmedName = name.trim();
+    const trimmedDesc = description.trim();
+    const trimmedLists = lists
+      .map((l) => l.title.trim())
+      .filter(Boolean)
+      .map((title, position) => ({ title, position }));
+
+    if (!trimmedName) {
+      toast.error('Name is required');
+      return;
+    }
+    if (trimmedLists.length === 0) {
+      toast.error('Add at least one list');
+      return;
+    }
+
+    setSubmitting(true);
+    try {
+      const input: CreateTemplateInput = {
+        name: trimmedName,
+        description: trimmedDesc || 'Board template',
+        lists: trimmedLists,
+        visibility,
+        workspaceId: workspaceId || undefined,
+      };
+      await createTemplate(input);
+      toast.success('Template created');
+      setName('');
+      setDescription('');
+      setLists([
+        { title: 'To Do' },
+        { title: 'In Progress' },
+        { title: 'Done' },
+      ]);
+      setVisibility('PRIVATE');
+      setWorkspaceId(defaultWorkspaceId ?? null);
+      onSuccess();
+      onClose();
+    } catch (err) {
+      const message =
+        err instanceof Error ? err.message : 'Failed to create template';
+      toast.error(message);
+    } finally {
+      setSubmitting(false);
+    }
+  };
+
+  return (
+    <Dialog open={open} onOpenChange={(isOpen) => !isOpen && onClose()}>
+      <DialogContent className='border-accent sm:max-w-lg'>
+        <DialogHeader>
+          <DialogTitle>Create template</DialogTitle>
+          <DialogDescription>
+            Define a board template with a name, description and list columns.
+            You can use it when creating a new board.
+          </DialogDescription>
+        </DialogHeader>
+        <form onSubmit={handleSubmit} className='space-y-4'>
+          <div className='space-y-2'>
+            <Label htmlFor='template-name'>Name</Label>
+            <Input
+              id='template-name'
+              value={name}
+              onChange={(e) => setName(e.target.value)}
+              placeholder='e.g. Sprint planning'
+            />
+          </div>
+          <div className='space-y-2'>
+            <Label htmlFor='template-desc'>Description</Label>
+            <Input
+              id='template-desc'
+              value={description}
+              onChange={(e) => setDescription(e.target.value)}
+              placeholder='Short description'
+            />
+          </div>
+          <div className='space-y-2'>
+            <Label>Visibility</Label>
+            <Select
+              value={visibility}
+              onValueChange={(v) => setVisibility(v as Visibility)}
+            >
+              <SelectTrigger className='border-accent'>
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent className='border-accent'>
+                <SelectItem value='PRIVATE'>Private (only you)</SelectItem>
+                <SelectItem value='WORKSPACE'>
+                  Workspace (members of the workspace)
+                </SelectItem>
+                <SelectItem value='PUBLIC'>Public (everyone)</SelectItem>
+              </SelectContent>
+            </Select>
+          </div>
+          <div className='space-y-2'>
+            <Label>Workspace (optional)</Label>
+            <Select
+              value={workspaceId ?? 'none'}
+              onValueChange={(v) => setWorkspaceId(v === 'none' ? null : v)}
+            >
+              <SelectTrigger className='border-accent'>
+                <SelectValue placeholder='Global template' />
+              </SelectTrigger>
+              <SelectContent className='border-accent'>
+                <SelectItem value='none'>Global (all workspaces)</SelectItem>
+                {workspaces.map((w) => (
+                  <SelectItem key={w.id} value={w.id}>
+                    {w.name}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+          </div>
+          <div className='space-y-2'>
+            <div className='flex items-center justify-between'>
+              <Label>Lists</Label>
+              <Button type='button' variant='ghost' size='sm' onClick={addList}>
+                <Plus className='h-4 w-4 mr-1' /> Add list
+              </Button>
+            </div>
+            <div className='space-y-2 max-h-48 overflow-y-auto'>
+              {lists.map((list, index) => (
+                <div key={index} className='flex gap-2 items-center'>
+                  <Input
+                    value={list.title}
+                    onChange={(e) => updateListTitle(index, e.target.value)}
+                    placeholder={`List ${index + 1}`}
+                  />
+                  <Button
+                    type='button'
+                    variant='ghost'
+                    size='icon'
+                    onClick={() => removeList(index)}
+                    disabled={lists.length <= 1}
+                    aria-label='Remove list'
+                  >
+                    <Trash2 className='h-4 w-4 text-muted-foreground' />
+                  </Button>
+                </div>
+              ))}
+            </div>
+          </div>
+          <DialogFooter>
+            <Button type='button' variant='outline' onClick={onClose}>
+              Cancel
+            </Button>
+            <Button type='submit' disabled={submitting}>
+              {submitting ? 'Creating…' : 'Create template'}
+            </Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
+  );
+}
diff --git a/frontend/app/templates/page.tsx b/frontend/app/templates/page.tsx
new file mode 100644
index 0000000..e643129
--- /dev/null
+++ b/frontend/app/templates/page.tsx
@@ -0,0 +1,296 @@
+'use client';
+
+import React, { useState, useEffect, useMemo, useCallback } from 'react';
+import { useRouter } from 'next/navigation';
+import Link from 'next/link';
+import { getBoardTemplates } from '@/lib/actions/boards';
+import { getTemplates } from '@/lib/actions/templates';
+import { useWorkspacesQuery } from '@/lib/queries/workspaces';
+import { useCurrentUserQuery } from '@/lib/queries/users';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import {
+  Search,
+  LayoutGrid,
+  User,
+  Plus,
+  Lock,
+  Users,
+  Globe,
+  Eye,
+} from 'lucide-react';
+import {
+  Breadcrumb,
+  BreadcrumbItem,
+  BreadcrumbLink,
+  BreadcrumbList,
+  BreadcrumbPage,
+  BreadcrumbSeparator,
+} from '@/components/ui/breadcrumb';
+import { CreateTemplateModal } from './components/CreateTemplateModal';
+import type { Visibility } from '@/lib/actions/templates';
+
+type TemplateDisplay = {
+  id: string;
+  name: string;
+  description: string;
+  listTitles: string[];
+  visibility?: Visibility;
+  /** Set for custom templates; used to show "You" vs "Community" */
+  creatorId?: string;
+};
+
+const TEMPLATE_PREVIEW_CLASS: Record<string, string> = {
+  blank: 'bg-gradient-to-br from-slate-500 to-slate-700',
+  kanban: 'bg-gradient-to-br from-blue-500 to-indigo-600',
+  sprint: 'bg-gradient-to-br from-amber-500 to-orange-600',
+  project: 'bg-gradient-to-br from-emerald-500 to-teal-600',
+};
+
+const TEMPLATE_AUTHOR = 'Epitrello';
+
+function VisibilityBadge({ visibility }: { visibility: Visibility }) {
+  const config = {
+    PRIVATE: { icon: Lock, label: 'Private' },
+    WORKSPACE: { icon: Users, label: 'Workspace' },
+    PUBLIC: { icon: Globe, label: 'Public' },
+  } as const;
+  const { icon: Icon, label } = config[visibility];
+  return (
+    <span className='inline-flex items-center gap-1 rounded-full bg-muted px-2 py-0.5 text-xs text-muted-foreground'>
+      <Icon className='h-3 w-3' />
+      {label}
+    </span>
+  );
+}
+
+export default function TemplateGalleryPage() {
+  const router = useRouter();
+  const [templates, setTemplates] = useState<TemplateDisplay[]>([]);
+  const [search, setSearch] = useState('');
+  const [showCreateModal, setShowCreateModal] = useState(false);
+  const { data: workspacesData } = useWorkspacesQuery(true);
+  const { data: currentUser } = useCurrentUserQuery();
+  const workspaces = (workspacesData ?? []) as { id: string; name: string }[];
+  const firstWorkspaceId = workspaces[0]?.id;
+  const currentUserId = currentUser?.id ?? null;
+
+  const loadTemplates = useCallback(async (): Promise<TemplateDisplay[]> => {
+    try {
+      const [predefined, custom] = await Promise.all([
+        getBoardTemplates(),
+        getTemplates(firstWorkspaceId ?? null),
+      ]);
+      const predefinedDisplay: TemplateDisplay[] = predefined.map((t) => ({
+        id: t.id,
+        name: t.name,
+        description: t.description,
+        listTitles: t.listTitles,
+      }));
+      const customDisplay: TemplateDisplay[] = custom.map((t) => ({
+        id: t.id,
+        name: t.name,
+        description: t.description,
+        listTitles: t.lists.map((l) => l.title),
+        visibility: t.visibility,
+        creatorId: t.creatorId,
+      }));
+      return [...predefinedDisplay, ...customDisplay];
+    } catch {
+      return [];
+    }
+  }, [firstWorkspaceId]);
+
+  useEffect(() => {
+    let cancelled = false;
+    loadTemplates().then((data) => {
+      if (!cancelled) setTemplates(data);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [loadTemplates]);
+
+  const refreshTemplates = useCallback(() => {
+    loadTemplates().then(setTemplates);
+  }, [loadTemplates]);
+
+  const filteredTemplates = useMemo(() => {
+    if (!search.trim()) return templates;
+    const q = search.toLowerCase();
+    return templates.filter(
+      (t) =>
+        t.name.toLowerCase().includes(q) ||
+        t.description.toLowerCase().includes(q) ||
+        t.listTitles.some((l) => l.toLowerCase().includes(q)),
+    );
+  }, [templates, search]);
+
+  const handleUseTemplate = (templateId: string) => {
+    if (firstWorkspaceId) {
+      router.push(
+        `/workspaces/${firstWorkspaceId}/boards?create=1&template=${encodeURIComponent(templateId)}`,
+      );
+    } else {
+      router.push(
+        `/dashboard?create=1&template=${encodeURIComponent(templateId)}`,
+      );
+    }
+  };
+
+  return (
+    <div className='min-h-screen bg-background text-foreground'>
+      <div className='mx-auto max-w-6xl px-4 py-8 sm:px-6'>
+        <Breadcrumb className='mb-6'>
+          <BreadcrumbList>
+            <BreadcrumbItem>
+              <BreadcrumbLink asChild>
+                <Link
+                  href={
+                    firstWorkspaceId
+                      ? `/workspaces/${firstWorkspaceId}/boards`
+                      : '/dashboard'
+                  }
+                >
+                  {firstWorkspaceId ? 'Boards' : 'Dashboard'}
+                </Link>
+              </BreadcrumbLink>
+            </BreadcrumbItem>
+            <BreadcrumbSeparator />
+            <BreadcrumbItem>
+              <BreadcrumbPage>Template gallery</BreadcrumbPage>
+            </BreadcrumbItem>
+          </BreadcrumbList>
+        </Breadcrumb>
+
+        {/* Header + Search */}
+        <div className='mb-8 flex flex-col gap-4 sm:flex-row sm:items-center sm:justify-between'>
+          <div className='flex items-center gap-3'>
+            <div className='flex h-10 w-10 items-center justify-center rounded-lg bg-primary/10'>
+              <LayoutGrid className='h-5 w-5 text-primary' />
+            </div>
+            <div>
+              <h1 className='text-2xl font-semibold tracking-tight'>
+                Board templates
+              </h1>
+              <p className='text-sm text-muted-foreground'>
+                Start from a template to get going faster
+              </p>
+            </div>
+          </div>
+          <div className='flex flex-col gap-3 sm:flex-row sm:items-center'>
+            <Button onClick={() => setShowCreateModal(true)}>
+              <Plus className='h-4 w-4 mr-2' />
+              Create template
+            </Button>
+            <div className='relative w-full sm:w-72'>
+              <Search className='absolute left-3 top-1/2 h-4 w-4 -translate-y-1/2 text-muted-foreground' />
+              <Input
+                type='search'
+                placeholder='Find template'
+                value={search}
+                onChange={(e) => setSearch(e.target.value)}
+                className='pl-9 border-accent bg-background'
+                aria-label='Search templates'
+              />
+            </div>
+          </div>
+        </div>
+
+        <CreateTemplateModal
+          open={showCreateModal}
+          onClose={() => setShowCreateModal(false)}
+          onSuccess={refreshTemplates}
+          defaultWorkspaceId={firstWorkspaceId ?? null}
+        />
+
+        {/* Grid */}
+        <section>
+          <h2 className='sr-only'>Templates</h2>
+          {filteredTemplates.length === 0 ? (
+            <div className='rounded-xl border border-accent bg-card p-12 text-center text-muted-foreground'>
+              {templates.length === 0
+                ? 'Loading templates…'
+                : 'No template matches your search.'}
+            </div>
+          ) : (
+            <div className='grid gap-6 sm:grid-cols-2 lg:grid-cols-3'>
+              {filteredTemplates.map((template) => (
+                <article
+                  key={template.id}
+                  className='group flex flex-col overflow-hidden rounded-xl border border-accent bg-card shadow-sm transition-shadow hover:shadow-md'
+                >
+                  {/* Preview */}
+                  <div
+                    className={`relative h-28 shrink-0 ${TEMPLATE_PREVIEW_CLASS[template.id] ?? 'bg-linear-to-br from-violet-500 to-purple-600'}`}
+                  >
+                    <div className='absolute inset-0 flex items-center justify-center opacity-90'>
+                      <span className='rounded-md bg-black/20 px-3 py-1.5 text-sm font-medium text-white backdrop-blur-sm'>
+                        {template.name}
+                      </span>
+                    </div>
+                  </div>
+
+                  <div className='flex flex-1 flex-col p-4'>
+                    <div className='mb-2 flex items-center gap-2'>
+                      <div className='flex h-8 w-8 items-center justify-center rounded-full bg-primary/10'>
+                        <User className='h-4 w-4 text-primary' />
+                      </div>
+                      <div className='min-w-0 flex-1'>
+                        <div className='flex items-center gap-2 flex-wrap'>
+                          <h3 className='font-semibold truncate'>
+                            {template.name}
+                          </h3>
+                          {template.visibility && (
+                            <VisibilityBadge visibility={template.visibility} />
+                          )}
+                        </div>
+                        <p className='text-xs text-muted-foreground'>
+                          by{' '}
+                          {template.creatorId && template.creatorId === currentUserId
+                            ? 'You'
+                            : template.creatorId
+                              ? 'Community'
+                              : TEMPLATE_AUTHOR}
+                        </p>
+                      </div>
+                    </div>
+                    <p
+                      className='mb-4 text-sm text-muted-foreground line-clamp-3'
+                      title={template.description || undefined}
+                    >
+                      {template.description || 'No description'}
+                    </p>
+                    <p className='mb-4 text-xs text-muted-foreground'>
+                      Lists: {template.listTitles.join(' · ')}
+                    </p>
+                    <div className='mt-auto flex gap-2'>
+                      <Button variant='outline' className='flex-1' asChild>
+                        <Link href={`/templates/${template.id}`}>
+                          <Eye className='h-4 w-4 mr-2' />
+                          View
+                        </Link>
+                      </Button>
+                      <Button
+                        className='flex-1'
+                        onClick={() => handleUseTemplate(template.id)}
+                        disabled={!firstWorkspaceId}
+                      >
+                        Use template
+                      </Button>
+                    </div>
+                    {!firstWorkspaceId && (
+                      <p className='mt-2 text-center text-xs text-muted-foreground'>
+                        Create a workspace first to use templates
+                      </p>
+                    )}
+                  </div>
+                </article>
+              ))}
+            </div>
+          )}
+        </section>
+      </div>
+    </div>
+  );
+}
diff --git a/frontend/components/ui/breadcrumb.tsx b/frontend/components/ui/breadcrumb.tsx
new file mode 100644
index 0000000..542e762
--- /dev/null
+++ b/frontend/components/ui/breadcrumb.tsx
@@ -0,0 +1,109 @@
+import * as React from "react"
+import { ChevronRight, MoreHorizontal } from "lucide-react"
+import { Slot } from "radix-ui"
+
+import { cn } from "@/lib/utils"
+
+function Breadcrumb({ ...props }: React.ComponentProps<"nav">) {
+  return <nav aria-label="breadcrumb" data-slot="breadcrumb" {...props} />
+}
+
+function BreadcrumbList({ className, ...props }: React.ComponentProps<"ol">) {
+  return (
+    <ol
+      data-slot="breadcrumb-list"
+      className={cn(
+        "text-muted-foreground flex flex-wrap items-center gap-1.5 text-sm break-words sm:gap-2.5",
+        className
+      )}
+      {...props}
+    />
+  )
+}
+
+function BreadcrumbItem({ className, ...props }: React.ComponentProps<"li">) {
+  return (
+    <li
+      data-slot="breadcrumb-item"
+      className={cn("inline-flex items-center gap-1.5", className)}
+      {...props}
+    />
+  )
+}
+
+function BreadcrumbLink({
+  asChild,
+  className,
+  ...props
+}: React.ComponentProps<"a"> & {
+  asChild?: boolean
+}) {
+  const Comp = asChild ? Slot.Root : "a"
+
+  return (
+    <Comp
+      data-slot="breadcrumb-link"
+      className={cn("hover:text-foreground transition-colors", className)}
+      {...props}
+    />
+  )
+}
+
+function BreadcrumbPage({ className, ...props }: React.ComponentProps<"span">) {
+  return (
+    <span
+      data-slot="breadcrumb-page"
+      role="link"
+      aria-disabled="true"
+      aria-current="page"
+      className={cn("text-foreground font-normal", className)}
+      {...props}
+    />
+  )
+}
+
+function BreadcrumbSeparator({
+  children,
+  className,
+  ...props
+}: React.ComponentProps<"li">) {
+  return (
+    <li
+      data-slot="breadcrumb-separator"
+      role="presentation"
+      aria-hidden="true"
+      className={cn("[&>svg]:size-3.5", className)}
+      {...props}
+    >
+      {children ?? <ChevronRight />}
+    </li>
+  )
+}
+
+function BreadcrumbEllipsis({
+  className,
+  ...props
+}: React.ComponentProps<"span">) {
+  return (
+    <span
+      data-slot="breadcrumb-ellipsis"
+      role="presentation"
+      aria-hidden="true"
+      className={cn("flex size-9 items-center justify-center", className)}
+      {...props}
+    >
+      <MoreHorizontal className="size-4" />
+      <span className="sr-only">More</span>
+    </span>
+  )
+}
+
+export {
+  Breadcrumb,
+  BreadcrumbList,
+  BreadcrumbItem,
+  BreadcrumbLink,
+  BreadcrumbPage,
+  BreadcrumbSeparator,
+  BreadcrumbEllipsis,
+}
diff --git a/frontend/lib/actions/templates.ts b/frontend/lib/actions/templates.ts
new file mode 100644
index 0000000..ff87b00
--- /dev/null
+++ b/frontend/lib/actions/templates.ts
@@ -0,0 +1,146 @@
+import { graphqlRequest } from '../graphql-client';
+import type {
+  CreateTemplateInput,
+  Template,
+  UpdateTemplateInput,
+  Visibility,
+} from '@/lib/graphql-types';
+
+export type { CreateTemplateInput, Template, UpdateTemplateInput, Visibility };
+
+/**
+ * Fetch custom templates. If workspaceId is provided, returns global + workspace templates.
+ */
+export async function getTemplates(workspaceId: string | null): Promise<Template[]> {
+  const query = `
+    query Templates($workspaceId: ID) {
+      templates(workspaceId: $workspaceId) {
+        id
+        name
+        description
+        lists { title position sampleCards { title position } }
+        visibility
+        workspaceId
+        creatorId
+        createdAt
+        updatedAt
+      }
+    }
+  `;
+  const result = await graphqlRequest<{ templates: Template[] }>(query, { workspaceId });
+  return result.templates;
+}
+
+/**
+ * Fetch a single template by id.
+ */
+export async function getTemplate(id: string): Promise<Template> {
+  const query = `
+    query Template($id: ID!) {
+      template(id: $id) {
+        id
+        name
+        description
+        lists { title position sampleCards { title position } }
+        visibility
+        workspaceId
+        creatorId
+        createdAt
+        updatedAt
+      }
+    }
+  `;
+  const result = await graphqlRequest<{ template: Template }>(query, { id });
+  if (!result?.template) {
+    throw new Error('Template not found');
+  }
+  return result.template;
+}
+
+/**
+ * Create a custom board template.
+ */
+export async function createTemplate(input: CreateTemplateInput): Promise<Template> {
+  const mutation = `
+    mutation CreateTemplate($input: CreateTemplateInput!) {
+      createTemplate(input: $input) {
+        id
+        name
+        description
+        lists { title position sampleCards { title position } }
+        visibility
+        workspaceId
+        creatorId
+        createdAt
+        updatedAt
+      }
+    }
+  `;
+  const result = await graphqlRequest<{ createTemplate: Template }>(mutation, { input });
+  return result.createTemplate;
+}
+
+/**
+ * Update a custom template.
+ */
+export async function updateTemplate(input: UpdateTemplateInput): Promise<Template> {
+  const mutation = `
+    mutation UpdateTemplate($input: UpdateTemplateInput!) {
+      updateTemplate(input: $input) {
+        id
+        name
+        description
+        lists { title position sampleCards { title position } }
+        visibility
+        workspaceId
+        creatorId
+        createdAt
+        updatedAt
+      }
+    }
+  `;
+  const result = await graphqlRequest<{ updateTemplate: Template }>(mutation, { input });
+  return result.updateTemplate;
+}
+
+/**
+ * Delete a custom template.
+ */
+export async function deleteTemplate(id: string): Promise<boolean> {
+  const mutation = `
+    mutation DeleteTemplate($id: ID!) {
+      deleteTemplate(id: $id)
+    }
+  `;
+  const result = await graphqlRequest<{ deleteTemplate: boolean }>(mutation, { id });
+  return result.deleteTemplate;
+}
+
+/**
+ * Create a template from an existing board (lists and cards become template structure).
+ */
+export async function createTemplateFromBoard(
+  boardId: string,
+  name?: string | null,
+): Promise<Template> {
+  const mutation = `
+    mutation CreateTemplateFromBoard($boardId: ID!, $name: String) {
+      createTemplateFromBoard(boardId: $boardId, name: $name) {
+        id
+        name
+        description
+        lists { title position sampleCards { title position } }
+        visibility
+        workspaceId
+        creatorId
+        createdAt
+        updatedAt
+      }
+    }
+  `;
+  const result = await graphqlRequest<{ createTemplateFromBoard: Template }>(mutation, {
+    boardId,
+    name: name ?? undefined,
+  });
+  return result.createTemplateFromBoard;
+}

From 89f873e552f9c3ec71d9cfc06148706211b502c5 Mon Sep 17 00:00:00 2001
From: mpJunot <junot-hery-nantenaina.montpre@epitech.eu>
Date: Wed, 11 Feb 2026 00:49:52 +0100
Subject: [PATCH 7/9] feat(frontend): integrate templates in boards (Save as
 template, template picker)

---
 .../[id]/components/BoardHeader/BoardMenu.tsx |  45 +-
 .../BoardHeader/BoardMenuDialogs.tsx          |  58 ++-
 frontend/app/workspaces/[id]/boards/page.tsx  |  26 +-
 frontend/components/CreateBoardModal.tsx      |  68 ++-
 frontend/lib/actions/boards.ts                |  58 ++-
 frontend/lib/graphql-types.ts                 | 431 ++++++++++++++++++
 6 files changed, 674 insertions(+), 12 deletions(-)

diff --git a/frontend/app/boards/[id]/components/BoardHeader/BoardMenu.tsx b/frontend/app/boards/[id]/components/BoardHeader/BoardMenu.tsx
index c98a124..1ed3137 100644
--- a/frontend/app/boards/[id]/components/BoardHeader/BoardMenu.tsx
+++ b/frontend/app/boards/[id]/components/BoardHeader/BoardMenu.tsx
@@ -12,6 +12,7 @@ import {
   Archive,
   EyeIcon,
   Copy,
+  LayoutTemplate,
   Mail,
   LogOut,
   Eye,
@@ -35,10 +36,11 @@ import { getVisibilityDescription } from '@/components/BoardView';
 import { getAvatarColor } from '@/lib/utils/avatar-colors';
 import { toast } from '@/lib/toast';
 import {
-  createBoard,
+  copyBoard,
   leaveBoard,
   updateBoardMemberRole,
 } from '@/lib/actions/boards';
+import { createTemplateFromBoard } from '@/lib/actions/templates';
 import { ChangeBackgroundDialog } from './ChangeBackgroundDialog';
 import { LabelsDialog } from './LabelsDialog';
 import { AboutBoardDialog } from './AboutBoardDialog';
@@ -88,6 +90,9 @@ export function BoardMenu({
   const [leaveBoardAdminUserId, setLeaveBoardAdminUserId] = useState('');
   const [leavingBoard, setLeavingBoard] = useState(false);
   const [isStarred, setIsStarred] = useState(false);
+  const [showSaveAsTemplateDialog, setShowSaveAsTemplateDialog] = useState(false);
+  const [saveAsTemplateName, setSaveAsTemplateName] = useState(board.title);
+  const [savingAsTemplate, setSavingAsTemplate] = useState(false);
 
   const STARRED_STORAGE_KEY = 'epitrello-starred-board-ids';
 
@@ -114,6 +119,25 @@ export function BoardMenu({
     (m) => m.userId !== currentUserId && m.role !== 'ADMIN',
   );
 
+  const handleSaveAsTemplate = async () => {
+    if (!saveAsTemplateName.trim()) {
+      toast.error('Please enter a template name');
+      return;
+    }
+    setSavingAsTemplate(true);
+    try {
+      await createTemplateFromBoard(board.id, saveAsTemplateName.trim());
+      toast.success('Template created');
+      setShowSaveAsTemplateDialog(false);
+      router.push('/templates');
+    } catch (err: unknown) {
+      const message = err instanceof Error ? err.message : 'Failed to create template';
+      toast.error(message);
+    } finally {
+      setSavingAsTemplate(false);
+    }
+  };
+
   const handleCopyBoard = async () => {
     if (!copyBoardTitle.trim()) {
       toast.error('Please enter a board name');
@@ -122,7 +146,8 @@ export function BoardMenu({
 
     setCopying(true);
     try {
-      const newBoard = await createBoard({
+      const newBoard = await copyBoard({
+        sourceBoardId: board.id,
         title: copyBoardTitle,
         description: board.description || undefined,
         background: board.background || undefined,
@@ -501,6 +526,16 @@ export function BoardMenu({
                   <Copy className='w-4 h-4' />
                   <span>Copy board</span>
                 </DropdownMenuItem>
+                <DropdownMenuItem
+                  className='flex items-center gap-2'
+                  onClick={() => {
+                    setSaveAsTemplateName(board.title);
+                    setShowSaveAsTemplateDialog(true);
+                  }}
+                >
+                  <LayoutTemplate className='w-4 h-4' />
+                  <span>Save as template</span>
+                </DropdownMenuItem>
                 <DropdownMenuItem
                   className='flex items-center gap-2'
                   onClick={() => setShowEmailDialog(true)}
@@ -528,6 +563,12 @@ export function BoardMenu({
         setCopyBoardTitle={setCopyBoardTitle}
         copying={copying}
         onCopyBoard={handleCopyBoard}
+        showSaveAsTemplateDialog={showSaveAsTemplateDialog}
+        setShowSaveAsTemplateDialog={setShowSaveAsTemplateDialog}
+        saveAsTemplateName={saveAsTemplateName}
+        setSaveAsTemplateName={setSaveAsTemplateName}
+        savingAsTemplate={savingAsTemplate}
+        onSaveAsTemplate={handleSaveAsTemplate}
         showEmailDialog={showEmailDialog}
         setShowEmailDialog={setShowEmailDialog}
         emailAddress={emailAddress}
diff --git a/frontend/app/boards/[id]/components/BoardHeader/BoardMenuDialogs.tsx b/frontend/app/boards/[id]/components/BoardHeader/BoardMenuDialogs.tsx
index ae222b6..4238e9f 100644
--- a/frontend/app/boards/[id]/components/BoardHeader/BoardMenuDialogs.tsx
+++ b/frontend/app/boards/[id]/components/BoardHeader/BoardMenuDialogs.tsx
@@ -26,6 +26,12 @@ export type BoardMenuDialogsProps = {
   setCopyBoardTitle: (v: string) => void;
   copying: boolean;
   onCopyBoard: () => Promise<void>;
+  showSaveAsTemplateDialog: boolean;
+  setShowSaveAsTemplateDialog: (v: boolean) => void;
+  saveAsTemplateName: string;
+  setSaveAsTemplateName: (v: string) => void;
+  savingAsTemplate: boolean;
+  onSaveAsTemplate: () => Promise<void>;
   showEmailDialog: boolean;
   setShowEmailDialog: (v: boolean) => void;
   emailAddress: string;
@@ -48,6 +54,12 @@ export function BoardMenuDialogs({
   setCopyBoardTitle,
   copying,
   onCopyBoard,
+  showSaveAsTemplateDialog,
+  setShowSaveAsTemplateDialog,
+  saveAsTemplateName,
+  setSaveAsTemplateName,
+  savingAsTemplate,
+  onSaveAsTemplate,
   showEmailDialog,
   setShowEmailDialog,
   emailAddress,
@@ -69,9 +81,9 @@ export function BoardMenuDialogs({
           <DialogHeader>
             <DialogTitle>Copy board</DialogTitle>
             <DialogDescription>
-              Create a new board with the same title, description, background
-              and visibility. The new board will have default lists (To Do,
-              Doing, Done).
+              Create a new board with the same lists, cards, labels and
+              checklists. You will be the only member. Comments and attachments
+              are not copied.
             </DialogDescription>
           </DialogHeader>
           <div className='space-y-4 py-4'>
@@ -107,6 +119,46 @@ export function BoardMenuDialogs({
         </DialogContent>
       </Dialog>
 
+      <Dialog open={showSaveAsTemplateDialog} onOpenChange={setShowSaveAsTemplateDialog}>
+        <DialogContent className='sm:max-w-md border-accent'>
+          <DialogHeader>
+            <DialogTitle>Save as template</DialogTitle>
+            <DialogDescription>
+              Create a reusable template from this board. Lists and card titles
+              will be saved so you can create new boards from it later.
+            </DialogDescription>
+          </DialogHeader>
+          <div className='space-y-4 py-4'>
+            <div className='space-y-2'>
+              <Label htmlFor='save-as-template-name'>Template name</Label>
+              <Input
+                id='save-as-template-name'
+                placeholder='Enter template name'
+                value={saveAsTemplateName}
+                onChange={(e) => setSaveAsTemplateName(e.target.value)}
+                onKeyDown={(e) => {
+                  if (e.key === 'Enter') onSaveAsTemplate();
+                }}
+              />
+            </div>
+            <div className='flex justify-end gap-2'>
+              <Button
+                variant='outline'
+                onClick={() => setShowSaveAsTemplateDialog(false)}
+              >
+                Cancel
+              </Button>
+              <Button
+                onClick={onSaveAsTemplate}
+                disabled={savingAsTemplate || !saveAsTemplateName.trim()}
+              >
+                {savingAsTemplate ? 'Creating...' : 'Create template'}
+              </Button>
+            </div>
+          </div>
+        </DialogContent>
+      </Dialog>
+
       <Dialog open={showLeaveBoardDialog} onOpenChange={setShowLeaveBoardDialog}>
         <DialogContent className='sm:max-w-md border-accent'>
           <DialogHeader>
diff --git a/frontend/app/workspaces/[id]/boards/page.tsx b/frontend/app/workspaces/[id]/boards/page.tsx
index c2e70b0..0a7fd50 100644
--- a/frontend/app/workspaces/[id]/boards/page.tsx
+++ b/frontend/app/workspaces/[id]/boards/page.tsx
@@ -1,7 +1,7 @@
 'use client';
 
-import React, { useState, useCallback, useMemo } from 'react';
-import { useParams, useRouter } from 'next/navigation';
+import React, { useState, useCallback, useMemo, useEffect } from 'react';
+import { useParams, useRouter, useSearchParams } from 'next/navigation';
 import CreateBoardModal from '@/components/CreateBoardModal';
 import { createBoard, Visibility } from '@/lib/actions/boards';
 import { toast } from '@/lib/toast';
@@ -171,13 +171,27 @@ function CreateBoardCard({
 export default function WorkspaceBoardsPage() {
   const params = useParams();
   const router = useRouter();
+  const searchParams = useSearchParams();
   const workspaceId = params.id as string;
   const queryClient = useQueryClient();
   const [showCreate, setShowCreate] = useState(false);
+  const [initialTemplateId, setInitialTemplateId] = useState<string | undefined>();
   const [starredIds, setStarredIds] = useState<string[]>(() =>
     getStarredBoardIds()
   );
 
+  useEffect(() => {
+    const create = searchParams.get('create');
+    const template = searchParams.get('template');
+    if (create === '1') {
+      queueMicrotask(() => {
+        setShowCreate(true);
+        if (template) setInitialTemplateId(template);
+      });
+      router.replace(`/workspaces/${workspaceId}/boards`, { scroll: false });
+    }
+  }, [searchParams, workspaceId, router]);
+
   const { data: workspace } = useWorkspaceQuery(workspaceId);
   const { permissions } = useWorkspaceRole(workspaceId);
   const { data: currentUser } = useCurrentUserQuery();
@@ -426,12 +440,17 @@ export default function WorkspaceBoardsPage() {
 
       <CreateBoardModal
         open={showCreate}
-        onClose={() => setShowCreate(false)}
+        onClose={() => {
+          setShowCreate(false);
+          setInitialTemplateId(undefined);
+        }}
+        initialTemplateId={initialTemplateId}
         onCreate={async (payload: {
           name: string;
           workspaceId?: string;
           visibility?: string;
           background?: string;
+          templateId?: string;
         }) => {
           try {
             const visMap: Record<string, Visibility> = {
@@ -446,6 +465,7 @@ export default function WorkspaceBoardsPage() {
                 : undefined,
               workspaceId: payload.workspaceId || workspaceId,
               background: payload.background,
+              templateId: payload.templateId,
             });
             await queryClient.invalidateQueries({
               queryKey: workspaceBoardsQueryKey(workspaceId),
diff --git a/frontend/components/CreateBoardModal.tsx b/frontend/components/CreateBoardModal.tsx
index 65fad25..005b175 100644
--- a/frontend/components/CreateBoardModal.tsx
+++ b/frontend/components/CreateBoardModal.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import React, { useState } from 'react';
+import React, { useState, useEffect } from 'react';
 import { toast } from '@/lib/toast';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
@@ -21,6 +21,8 @@ import {
   DialogTitle,
 } from '@/components/ui/dialog';
 import { useWorkspacesQuery } from '@/lib/queries/workspaces';
+import { getBoardTemplates, type BoardTemplate } from '@/lib/actions/boards';
+import { LayoutGrid, List } from 'lucide-react';
 
 const BOARD_COLORS = [
   {
@@ -59,6 +61,7 @@ export default function CreateBoardModal({
   open,
   onClose,
   onCreate,
+  initialTemplateId,
 }: {
   open: boolean;
   onClose: () => void;
@@ -67,12 +70,17 @@ export default function CreateBoardModal({
     workspaceId?: string;
     visibility?: string;
     background?: string;
+    templateId?: string;
   }) => void;
+  /** When opening from the template gallery, preselect this template. */
+  initialTemplateId?: string;
 }) {
   const [name, setName] = useState('');
   const [selectedColor, setSelectedColor] = useState<string>(
     BOARD_COLORS[1].value,
   );
+  const [templates, setTemplates] = useState<BoardTemplate[]>([]);
+  const [selectedTemplateId, setSelectedTemplateId] = useState<string>('blank');
   const { data: workspacesData } = useWorkspacesQuery(!!open);
   const workspaces = (workspacesData ?? []).map((w) => ({
     id: w.id,
@@ -82,6 +90,29 @@ export default function CreateBoardModal({
   const [visibility, setVisibility] = useState<string>('personal');
   const effectiveWorkspaceId = workspaceId ?? workspaces[0]?.id;
 
+  useEffect(() => {
+    if (open) {
+      getBoardTemplates()
+        .then(setTemplates)
+        .catch(() =>
+          setTemplates([
+            {
+              id: 'blank',
+              name: 'Blank',
+              description: 'Empty board with To Do, Doing, Done',
+              listTitles: ['To Do', 'Doing', 'Done'],
+            },
+          ])
+        );
+    }
+  }, [open]);
+
+  useEffect(() => {
+    if (open && initialTemplateId) {
+      queueMicrotask(() => setSelectedTemplateId(initialTemplateId));
+    }
+  }, [open, initialTemplateId]);
+
   const submit = (e?: React.FormEvent) => {
     if (e) e.preventDefault();
     if (!name.trim()) {
@@ -97,9 +128,11 @@ export default function CreateBoardModal({
       workspaceId: effectiveWorkspaceId,
       visibility,
       background: selectedColor,
+      templateId: selectedTemplateId || undefined,
     });
     setName('');
     setSelectedColor(BOARD_COLORS[1].value);
+    setSelectedTemplateId('blank');
     onClose();
   };
 
@@ -131,6 +164,39 @@ export default function CreateBoardModal({
             />
           </div>
 
+          <div className='space-y-2'>
+            <Label>Template</Label>
+            <p className='text-sm text-muted-foreground'>
+              Choose a layout with predefined lists
+            </p>
+            <div className='grid grid-cols-2 gap-2'>
+              {templates.map((t) => (
+                <button
+                  key={t.id}
+                  type='button'
+                  onClick={() => setSelectedTemplateId(t.id)}
+                  className={`flex flex-col items-start gap-1 rounded-lg border-2 p-3 text-left transition-colors hover:bg-accent/50 ${
+                    selectedTemplateId === t.id
+                      ? 'border-primary bg-primary/5'
+                      : 'border-accent'
+                  }`}
+                >
+                  <span className='flex items-center gap-2 font-medium'>
+                    <LayoutGrid className='h-4 w-4 shrink-0' />
+                    {t.name}
+                  </span>
+                  <span className='text-xs text-muted-foreground line-clamp-2'>
+                    {t.description}
+                  </span>
+                  <span className='flex items-center gap-1 text-xs text-muted-foreground'>
+                    <List className='h-3 w-3' />
+                    {t.listTitles.join(' · ')}
+                  </span>
+                </button>
+              ))}
+            </div>
+          </div>
+
           <div className='space-y-2'>
             <Label htmlFor='board-workspace'>Workspace</Label>
             <Select
diff --git a/frontend/lib/actions/boards.ts b/frontend/lib/actions/boards.ts
index d688bbd..dcbe45f 100644
--- a/frontend/lib/actions/boards.ts
+++ b/frontend/lib/actions/boards.ts
@@ -2,6 +2,7 @@ import { graphqlRequest } from '../graphql-client';
 import type {
   Board as GqlBoard,
   BoardMemberWithUser,
+  BoardTemplate,
   Visibility,
   List as GqlList,
   Card as GqlCard,
@@ -15,15 +16,43 @@ export type Board = Omit<GqlBoard, 'lists'> & {
   }>;
 };
 
-export type { Visibility, BoardMemberWithUser };
+export type { BoardTemplate, Visibility, BoardMemberWithUser };
+
+export type CreateBoardInput = GqlCreateBoardInput & { templateId?: string };
+
+export type CopyBoardInput = {
+  sourceBoardId: string;
+  title: string;
+  workspaceId?: string;
+  description?: string;
+  visibility?: Visibility;
+  background?: string;
+};
 
-export type CreateBoardInput = GqlCreateBoardInput;
 export type UpdateBoardInput = GqlUpdateBoardInput;
 
 export type BoardDetail = Board;
 
 /**
- * Create a new board (backend integration)
+ * Fetch predefined board templates (blank, kanban, sprint, project).
+ */
+export async function getBoardTemplates(): Promise<BoardTemplate[]> {
+  const query = `
+    query BoardTemplates {
+      boardTemplates {
+        id
+        name
+        description
+        listTitles
+      }
+    }
+  `;
+  const result = await graphqlRequest<{ boardTemplates: BoardTemplate[] }>(query);
+  return result.boardTemplates;
+}
+
+/**
+ * Create a new board (backend integration). Optionally use a templateId (blank, kanban, sprint, project).
  */
 export async function createBoard(input: CreateBoardInput): Promise<Board> {
   const mutation = `
@@ -45,6 +74,29 @@ export async function createBoard(input: CreateBoardInput): Promise<Board> {
   return result.createBoard;
 }
 
+/**
+ * Copy a board (lists, cards, labels, checklists). Returns the new board.
+ */
+export async function copyBoard(input: CopyBoardInput): Promise<Board> {
+  const mutation = `
+    mutation CopyBoard($input: CopyBoardInput!) {
+      copyBoard(input: $input) {
+        id
+        title
+        description
+        background
+        visibility
+        workspaceId
+        createdAt
+        updatedAt
+      }
+    }
+  `;
+
+  const result = await graphqlRequest<{ copyBoard: Board }>(mutation, { input });
+  return result.copyBoard;
+}
+
 /**
  * Get a board by ID (backend integration)
  * Now includes lists with cards
diff --git a/frontend/lib/graphql-types.ts b/frontend/lib/graphql-types.ts
index 51ca8b3..f663722 100644
--- a/frontend/lib/graphql-types.ts
+++ b/frontend/lib/graphql-types.ts
@@ -16,6 +16,46 @@ export type Scalars = {
   DateTime: { input: string; output: string; }
 };
 
+export type Activity = {
+  __typename?: 'Activity';
+  board?: Maybe<Board>;
+  boardId: Scalars['ID']['output'];
+  cardId?: Maybe<Scalars['ID']['output']>;
+  createdAt: Scalars['DateTime']['output'];
+  id: Scalars['ID']['output'];
+  listId?: Maybe<Scalars['ID']['output']>;
+  payload?: Maybe<ActivityPayload>;
+  type: ActivityType;
+  user?: Maybe<User>;
+  userId: Scalars['ID']['output'];
+};
+
+export type ActivityPayload = {
+  __typename?: 'ActivityPayload';
+  boardTitle?: Maybe<Scalars['String']['output']>;
+  cardTitle?: Maybe<Scalars['String']['output']>;
+  commentPreview?: Maybe<Scalars['String']['output']>;
+  listName?: Maybe<Scalars['String']['output']>;
+  memberName?: Maybe<Scalars['String']['output']>;
+  targetListName?: Maybe<Scalars['String']['output']>;
+};
+
+/** Type of user action recorded in the activity log */
+export type ActivityType =
+  | 'BOARD_ARCHIVED'
+  | 'BOARD_UNARCHIVED'
+  | 'CARD_ARCHIVED'
+  | 'CARD_COMPLETED'
+  | 'CARD_CREATED'
+  | 'CARD_MOVED'
+  | 'CARD_UNARCHIVED'
+  | 'CARD_UNCOMPLETED'
+  | 'COMMENT_ADDED'
+  | 'LIST_ARCHIVED'
+  | 'LIST_UNARCHIVED'
+  | 'MEMBER_ADDED_TO_BOARD'
+  | 'MEMBER_ADDED_TO_CARD';
+
 export type AddBoardMemberInput = {
   boardId: Scalars['ID']['input'];
   role?: InputMaybe<Scalars['String']['input']>;
@@ -76,6 +116,12 @@ export type Board = {
   workspaceId?: Maybe<Scalars['ID']['output']>;
 };
 
+export type BoardActivityInput = {
+  /** Cursor for pagination (activity id). */
+  cursor?: InputMaybe<Scalars['ID']['input']>;
+  limit?: InputMaybe<Scalars['Int']['input']>;
+};
+
 export type BoardMemberWithUser = {
   __typename?: 'BoardMemberWithUser';
   boardId: Scalars['ID']['output'];
@@ -86,6 +132,15 @@ export type BoardMemberWithUser = {
   userId: Scalars['ID']['output'];
 };
 
+export type BoardTemplate = {
+  __typename?: 'BoardTemplate';
+  description: Scalars['String']['output'];
+  id: Scalars['String']['output'];
+  /** List titles in order */
+  listTitles: Array<Scalars['String']['output']>;
+  name: Scalars['String']['output'];
+};
+
 export type Card = {
   __typename?: 'Card';
   assignees?: Maybe<Array<MemberUser>>;
@@ -96,6 +151,7 @@ export type Card = {
   description?: Maybe<Scalars['String']['output']>;
   dueDate?: Maybe<Scalars['DateTime']['output']>;
   id: Scalars['ID']['output'];
+  isArchived: Scalars['Boolean']['output'];
   labels?: Maybe<Array<Label>>;
   listId: Scalars['ID']['output'];
   position: Scalars['Float']['output'];
@@ -142,6 +198,23 @@ export type Comment = {
   updatedAt: Scalars['DateTime']['output'];
 };
 
+export type CommentDeletedEvent = {
+  __typename?: 'CommentDeletedEvent';
+  cardId: Scalars['ID']['output'];
+  commentId: Scalars['ID']['output'];
+};
+
+export type CopyBoardInput = {
+  background?: InputMaybe<Scalars['String']['input']>;
+  description?: InputMaybe<Scalars['String']['input']>;
+  /** ID of the board to copy (lists, cards, labels, checklists). */
+  sourceBoardId: Scalars['ID']['input'];
+  /** Title for the new board. */
+  title: Scalars['String']['input'];
+  visibility?: InputMaybe<Visibility>;
+  workspaceId?: InputMaybe<Scalars['ID']['input']>;
+};
+
 export type CreateAttachmentInput = {
   cardId: Scalars['ID']['input'];
   filename: Scalars['String']['input'];
@@ -152,6 +225,8 @@ export type CreateAttachmentInput = {
 export type CreateBoardInput = {
   background?: InputMaybe<Scalars['String']['input']>;
   description?: InputMaybe<Scalars['String']['input']>;
+  /** Predefined template: blank, kanban, sprint, project */
+  templateId?: InputMaybe<Scalars['String']['input']>;
   title: Scalars['String']['input'];
   visibility?: InputMaybe<Visibility>;
   workspaceId?: InputMaybe<Scalars['ID']['input']>;
@@ -193,8 +268,17 @@ export type CreateListInput = {
   title: Scalars['String']['input'];
 };
 
+export type CreateTemplateInput = {
+  description: Scalars['String']['input'];
+  lists: Array<TemplateListInput>;
+  name: Scalars['String']['input'];
+  visibility?: InputMaybe<Visibility>;
+  workspaceId?: InputMaybe<Scalars['ID']['input']>;
+};
+
 export type CreateUserInput = {
   avatar?: InputMaybe<Scalars['String']['input']>;
+  description?: InputMaybe<Scalars['String']['input']>;
   email: Scalars['String']['input'];
   name: Scalars['String']['input'];
   password: Scalars['String']['input'];
@@ -296,12 +380,16 @@ export type Mutation = {
   addLabelToCard: Card;
   /** Archive a board. User must be ADMIN or MEMBER. */
   archiveBoard: Board;
+  /** Archive a card. User must have access to the board. */
+  archiveCard: Card;
   /** Archive a list. User must have access to the board. */
   archiveList: List;
   /** Assign a member to a card. User must have access to the board. */
   assignMemberToCard: Card;
   /** Cancel a pending invitation. Only the inviter or workspace admin can cancel. */
   cancelInvitation: Scalars['Boolean']['output'];
+  /** Copy a board (lists, cards, labels, checklists). New board has current user as ADMIN. */
+  copyBoard: Board;
   /** Create an attachment on a card. */
   createAttachment: Attachment;
   /** Create a new board. User must be ADMIN or MEMBER of the workspace (if provided). */
@@ -316,6 +404,10 @@ export type Mutation = {
   createLabel: Label;
   /** Create a new list. Position is calculated automatically if not provided. */
   createList: List;
+  /** Create a custom board template. Optional workspaceId to scope to a workspace. */
+  createTemplate: Template;
+  /** Create a template from an existing board (lists and cards become template structure). */
+  createTemplateFromBoard: Template;
   /** Create a new user (requires authentication) */
   createUser: User;
   /** Create a new workspace. The creator becomes an ADMIN automatically. */
@@ -336,6 +428,8 @@ export type Mutation = {
   deleteLabel: Scalars['Boolean']['output'];
   /** Delete a list. Cards are automatically deleted via cascade. */
   deleteList: Scalars['Boolean']['output'];
+  /** Delete a template. Only creator or workspace admin. */
+  deleteTemplate: Scalars['Boolean']['output'];
   /** Delete a user by ID (requires authentication) */
   deleteUser: Scalars['Boolean']['output'];
   /** Delete a workspace. Only ADMIN members can delete. */
@@ -352,6 +446,10 @@ export type Mutation = {
   leaveWorkspace: Scalars['Boolean']['output'];
   /** Login with email and password. Returns a JWT token for authenticated requests. */
   login: AuthPayload;
+  /** Mark all notifications as read for the current user. Returns count updated. */
+  markAllNotificationsRead: Scalars['Int']['output'];
+  /** Mark a notification as read. */
+  markNotificationRead: Notification;
   /** Move a card to a different list within the same board. Position is calculated automatically if not provided. */
   moveCard: Card;
   /** Register a new user account. If companyName is provided, a workspace is automatically created. */
@@ -374,6 +472,10 @@ export type Mutation = {
   resetPassword: MessageResponse;
   /** Unarchive a board. User must be ADMIN or MEMBER. */
   unarchiveBoard: Board;
+  /** Unarchive a card. User must have access to the board. */
+  unarchiveCard: Card;
+  /** Unarchive a list. User must have access to the board. */
+  unarchiveList: List;
   /** Unassign a member from a card. User must have access to the board. */
   unassignMemberFromCard: Card;
   /** Update an attachment. Uploader only. */
@@ -396,6 +498,10 @@ export type Mutation = {
   updateList: List;
   /** Update a member role in a workspace. Only ADMIN can update roles. */
   updateMemberRole: Scalars['Boolean']['output'];
+  /** Update current user notification preferences. */
+  updateMyNotificationPreferences: NotificationPreferences;
+  /** Update a template. Only creator or workspace admin. */
+  updateTemplate: Template;
   /** Update an existing user (requires authentication) */
   updateUser: User;
   /** Update a workspace. Only ADMIN members can update. */
@@ -430,6 +536,11 @@ export type MutationArchiveBoardArgs = {
 };
 
 
+export type MutationArchiveCardArgs = {
+  id: Scalars['ID']['input'];
+};
+
+
 export type MutationArchiveListArgs = {
   id: Scalars['ID']['input'];
 };
@@ -445,6 +556,11 @@ export type MutationCancelInvitationArgs = {
 };
 
 
+export type MutationCopyBoardArgs = {
+  input: CopyBoardInput;
+};
+
+
 export type MutationCreateAttachmentArgs = {
   input: CreateAttachmentInput;
 };
@@ -480,6 +596,17 @@ export type MutationCreateListArgs = {
 };
 
 
+export type MutationCreateTemplateArgs = {
+  input: CreateTemplateInput;
+};
+
+
+export type MutationCreateTemplateFromBoardArgs = {
+  boardId: Scalars['ID']['input'];
+  name?: InputMaybe<Scalars['String']['input']>;
+};
+
+
 export type MutationCreateUserArgs = {
   input: CreateUserInput;
 };
@@ -530,6 +657,11 @@ export type MutationDeleteListArgs = {
 };
 
 
+export type MutationDeleteTemplateArgs = {
+  id: Scalars['ID']['input'];
+};
+
+
 export type MutationDeleteUserArgs = {
   id: Scalars['ID']['input'];
 };
@@ -570,6 +702,11 @@ export type MutationLoginArgs = {
 };
 
 
+export type MutationMarkNotificationReadArgs = {
+  id: Scalars['ID']['input'];
+};
+
+
 export type MutationMoveCardArgs = {
   input: MoveCardInput;
 };
@@ -626,6 +763,16 @@ export type MutationUnarchiveBoardArgs = {
 };
 
 
+export type MutationUnarchiveCardArgs = {
+  id: Scalars['ID']['input'];
+};
+
+
+export type MutationUnarchiveListArgs = {
+  id: Scalars['ID']['input'];
+};
+
+
 export type MutationUnassignMemberFromCardArgs = {
   input: UnassignMemberFromCardInput;
 };
@@ -681,6 +828,16 @@ export type MutationUpdateMemberRoleArgs = {
 };
 
 
+export type MutationUpdateMyNotificationPreferencesArgs = {
+  input: UpdateNotificationPreferencesInput;
+};
+
+
+export type MutationUpdateTemplateArgs = {
+  input: UpdateTemplateInput;
+};
+
+
 export type MutationUpdateUserArgs = {
   id: Scalars['ID']['input'];
   input: UpdateUserInput;
@@ -697,14 +854,89 @@ export type MutationVerifyEmailArgs = {
   token: Scalars['String']['input'];
 };
 
+export type MyActivityInput = {
+  /** Cursor for pagination (activity id). Fetch activities older than this. */
+  cursor?: InputMaybe<Scalars['ID']['input']>;
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  /** Filter by workspace IDs. Only activities from boards in these workspaces. */
+  workspaceIds?: InputMaybe<Array<Scalars['ID']['input']>>;
+};
+
+export type MyActivityResult = {
+  __typename?: 'MyActivityResult';
+  activities: Array<Activity>;
+  hasMore: Scalars['Boolean']['output'];
+  /** Cursor for next page (last activity id) */
+  nextCursor?: Maybe<Scalars['ID']['output']>;
+};
+
+export type MyNotificationsInput = {
+  /** Cursor for pagination (notification id) */
+  cursor?: InputMaybe<Scalars['String']['input']>;
+  /** Max number of notifications to return (default 20, max 50) */
+  limit?: InputMaybe<Scalars['Int']['input']>;
+  /** If true, only unread notifications */
+  unreadOnly?: InputMaybe<Scalars['Boolean']['input']>;
+};
+
+export type MyNotificationsResult = {
+  __typename?: 'MyNotificationsResult';
+  hasMore: Scalars['Boolean']['output'];
+  /** Cursor for next page (last notification id) */
+  nextCursor?: Maybe<Scalars['String']['output']>;
+  notifications: Array<Notification>;
+};
+
+export type Notification = {
+  __typename?: 'Notification';
+  createdAt: Scalars['DateTime']['output'];
+  id: Scalars['ID']['output'];
+  /** JSON payload (cardId, boardId, workspaceId, etc.) */
+  payload?: Maybe<Scalars['String']['output']>;
+  read: Scalars['Boolean']['output'];
+  type: NotificationType;
+  userId: Scalars['ID']['output'];
+};
+
+/** How often to receive notification emails. */
+export type NotificationEmailFrequency =
+  | 'DAILY'
+  | 'INSTANT'
+  | 'NEVER'
+  | 'PERIODICALLY';
+
+export type NotificationPreferences = {
+  __typename?: 'NotificationPreferences';
+  allowDesktopNotifications: Scalars['Boolean']['output'];
+  emailFrequency: NotificationEmailFrequency;
+};
+
+/** Type of notification (card assigned, due soon, comment, invitation, etc.) */
+export type NotificationType =
+  | 'BOARD_INVITATION'
+  | 'CARD_ASSIGNED'
+  | 'CARD_DUE_SOON'
+  | 'COMMENT_ADDED'
+  | 'WORKSPACE_INVITATION';
+
 export type Query = {
   __typename?: 'Query';
+  /** Get activity feed from all boards the user has access to (all members). Optional workspace filter. */
+  activityFeed: MyActivityResult;
+  /** Get archived cards for a board. User must have access to the board. */
+  archivedCards: Array<Card>;
+  /** Get archived lists for a board. User must have access to the board. */
+  archivedLists: Array<List>;
   /** Get an attachment by ID. User must have access to the board. */
   attachment: Attachment;
   /** Get a board by ID. Access based on visibility and membership. */
   board: Board;
+  /** Get activity for a board (all members). User must have access to the board. */
+  boardActivity: MyActivityResult;
   /** List all labels for a board. User must have access to the board. */
   boardLabels: Array<Label>;
+  /** List predefined board templates (blank, kanban, sprint, project). */
+  boardTemplates: Array<BoardTemplate>;
   /** Get a card by ID. User must have access to the board. */
   card: Card;
   /** List attachments for a card. User must have access to the board. */
@@ -721,10 +953,20 @@ export type Query = {
   list: List;
   /** Get the currently authenticated user information */
   me?: Maybe<User>;
+  /** Get current user activity log with optional workspace filter and pagination. */
+  myActivity: MyActivityResult;
   /** Get all pending invitations for the current user. */
   myInvitations: Array<WorkspaceInvitation>;
+  /** Get current user notification preferences (email frequency, desktop notifications). */
+  myNotificationPreferences: NotificationPreferences;
+  /** Get current user notifications with pagination and optional unread filter. */
+  myNotifications: MyNotificationsResult;
   /** Get all workspaces where the current user is a member */
   myWorkspaces: Array<Workspace>;
+  /** Get a template by ID. User must have access (global or workspace member). */
+  template: Template;
+  /** List templates. If workspaceId is provided, returns global + workspace templates; otherwise global only. */
+  templates: Array<Template>;
   /** Get a user by ID (requires authentication) */
   user?: Maybe<User>;
   /** Get a user by email (for invite flows; requires authentication) */
@@ -744,6 +986,21 @@ export type Query = {
 };
 
 
+export type QueryActivityFeedArgs = {
+  input?: InputMaybe<MyActivityInput>;
+};
+
+
+export type QueryArchivedCardsArgs = {
+  boardId: Scalars['ID']['input'];
+};
+
+
+export type QueryArchivedListsArgs = {
+  boardId: Scalars['ID']['input'];
+};
+
+
 export type QueryAttachmentArgs = {
   id: Scalars['ID']['input'];
 };
@@ -754,6 +1011,12 @@ export type QueryBoardArgs = {
 };
 
 
+export type QueryBoardActivityArgs = {
+  boardId: Scalars['String']['input'];
+  input?: InputMaybe<BoardActivityInput>;
+};
+
+
 export type QueryBoardLabelsArgs = {
   boardId: Scalars['ID']['input'];
 };
@@ -794,6 +1057,26 @@ export type QueryListArgs = {
 };
 
 
+export type QueryMyActivityArgs = {
+  input?: InputMaybe<MyActivityInput>;
+};
+
+
+export type QueryMyNotificationsArgs = {
+  input?: InputMaybe<MyNotificationsInput>;
+};
+
+
+export type QueryTemplateArgs = {
+  id: Scalars['ID']['input'];
+};
+
+
+export type QueryTemplatesArgs = {
+  workspaceId?: InputMaybe<Scalars['ID']['input']>;
+};
+
+
 export type QueryUserArgs = {
   id: Scalars['ID']['input'];
 };
@@ -877,6 +1160,140 @@ export type RespondInvitationInput = {
   invitationId: Scalars['String']['input'];
 };
 
+export type Subscription = {
+  __typename?: 'Subscription';
+  /** Subscribe to board members changes (add/remove/role). Refetch board to get updated members. */
+  boardMembersUpdated: Scalars['Boolean']['output'];
+  /** Subscribe to board metadata changes for a single board. */
+  boardUpdated: Board;
+  /** Subscribe to card deletions for a board. */
+  cardDeleted: Scalars['ID']['output'];
+  /** Subscribe to card create/update/move/delete for a board. */
+  cardUpdated: Card;
+  /** Subscribe to updates for a single card (e.g. card modal). */
+  cardUpdatedByCardId: Card;
+  /** Subscribe to new comments on a card. Filter by cardId. */
+  commentAdded: Comment;
+  /** Subscribe to comment deletions on a card. Payload has commentId and cardId. */
+  commentDeleted: CommentDeletedEvent;
+  /** Subscribe to comment edits on a card. Filter by cardId. */
+  commentUpdated: Comment;
+  /** Subscribe to list deletions for a board. */
+  listDeleted: Scalars['ID']['output'];
+  /** Subscribe to list create/update/reorder/delete for a board. */
+  listUpdated: List;
+  /** Subscribe to current user invitations changes (new invite, accept, reject, cancel). Invalidate myInvitations query when received. */
+  myInvitationsUpdated: Scalars['Boolean']['output'];
+  /** Real-time notifications for the current user (WebSocket). */
+  notificationReceived: Notification;
+  /** Subscribe to workspace pending invitations changes (invite, cancel, accept, reject). Invalidate workspace invitations query when received. */
+  workspaceInvitationsUpdated: Scalars['Boolean']['output'];
+  /** Subscribe to workspace members changes (add, remove, role update). Invalidate workspace members query when received. */
+  workspaceMembersUpdated: Scalars['Boolean']['output'];
+};
+
+
+export type SubscriptionBoardMembersUpdatedArgs = {
+  boardId: Scalars['ID']['input'];
+};
+
+
+export type SubscriptionBoardUpdatedArgs = {
+  boardId: Scalars['ID']['input'];
+};
+
+
+export type SubscriptionCardDeletedArgs = {
+  boardId: Scalars['ID']['input'];
+};
+
+
+export type SubscriptionCardUpdatedArgs = {
+  boardId: Scalars['ID']['input'];
+};
+
+
+export type SubscriptionCardUpdatedByCardIdArgs = {
+  cardId: Scalars['ID']['input'];
+};
+
+
+export type SubscriptionCommentAddedArgs = {
+  cardId: Scalars['ID']['input'];
+};
+
+
+export type SubscriptionCommentDeletedArgs = {
+  cardId: Scalars['ID']['input'];
+};
+
+
+export type SubscriptionCommentUpdatedArgs = {
+  cardId: Scalars['ID']['input'];
+};
+
+
+export type SubscriptionListDeletedArgs = {
+  boardId: Scalars['ID']['input'];
+};
+
+
+export type SubscriptionListUpdatedArgs = {
+  boardId: Scalars['ID']['input'];
+};
+
+
+export type SubscriptionMyInvitationsUpdatedArgs = {
+  userId: Scalars['ID']['input'];
+};
+
+
+export type SubscriptionWorkspaceInvitationsUpdatedArgs = {
+  workspaceId: Scalars['ID']['input'];
+};
+
+
+export type SubscriptionWorkspaceMembersUpdatedArgs = {
+  workspaceId: Scalars['ID']['input'];
+};
+
+export type Template = {
+  __typename?: 'Template';
+  createdAt: Scalars['DateTime']['output'];
+  creatorId: Scalars['ID']['output'];
+  description: Scalars['String']['output'];
+  id: Scalars['ID']['output'];
+  lists: Array<TemplateListType>;
+  name: Scalars['String']['output'];
+  updatedAt: Scalars['DateTime']['output'];
+  visibility: Visibility;
+  workspaceId?: Maybe<Scalars['ID']['output']>;
+};
+
+export type TemplateListInput = {
+  position: Scalars['Int']['input'];
+  sampleCards?: InputMaybe<Array<TemplateSampleCardInput>>;
+  title: Scalars['String']['input'];
+};
+
+export type TemplateListType = {
+  __typename?: 'TemplateListType';
+  position: Scalars['Int']['output'];
+  sampleCards?: Maybe<Array<TemplateSampleCard>>;
+  title: Scalars['String']['output'];
+};
+
+export type TemplateSampleCard = {
+  __typename?: 'TemplateSampleCard';
+  position: Scalars['Float']['output'];
+  title: Scalars['String']['output'];
+};
+
+export type TemplateSampleCardInput = {
+  position: Scalars['Float']['input'];
+  title: Scalars['String']['input'];
+};
+
 export type UnassignMemberFromCardInput = {
   cardId: Scalars['ID']['input'];
   userId: Scalars['ID']['input'];
@@ -950,8 +1367,22 @@ export type UpdateMemberRoleInput = {
   workspaceId: Scalars['String']['input'];
 };
 
+export type UpdateNotificationPreferencesInput = {
+  allowDesktopNotifications?: InputMaybe<Scalars['Boolean']['input']>;
+  emailFrequency?: InputMaybe<NotificationEmailFrequency>;
+};
+
+export type UpdateTemplateInput = {
+  description?: InputMaybe<Scalars['String']['input']>;
+  id: Scalars['ID']['input'];
+  lists?: InputMaybe<Array<TemplateListInput>>;
+  name?: InputMaybe<Scalars['String']['input']>;
+  visibility?: InputMaybe<Visibility>;
+};
+
 export type UpdateUserInput = {
   avatar?: InputMaybe<Scalars['String']['input']>;
+  description?: InputMaybe<Scalars['String']['input']>;
   email?: InputMaybe<Scalars['String']['input']>;
   name?: InputMaybe<Scalars['String']['input']>;
   password?: InputMaybe<Scalars['String']['input']>;

From d007b9e3a621f989961e448026220aa51051c947 Mon Sep 17 00:00:00 2001
From: mpJunot <junot-hery-nantenaina.montpre@epitech.eu>
Date: Wed, 11 Feb 2026 00:49:57 +0100
Subject: [PATCH 8/9] fix(frontend): Topbar cleanup, invitations Suspense,
 MemberItem props, cards page

---
 frontend/app/cards/page.tsx                   |  49 ++---
 frontend/app/globals.css                      |   1 -
 frontend/app/invitations/accept/page.tsx      |  30 +++-
 frontend/app/invitations/reject/page.tsx      |  69 ++++---
 .../members/components/GuestsTabContent.tsx   |   2 +-
 .../members/components/MembersTabContent.tsx  |   2 +-
 frontend/components/Sidebar.tsx               |  17 +-
 frontend/components/Topbar.tsx                | 169 +-----------------
 8 files changed, 118 insertions(+), 221 deletions(-)

diff --git a/frontend/app/cards/page.tsx b/frontend/app/cards/page.tsx
index 0850339..b7b3406 100644
--- a/frontend/app/cards/page.tsx
+++ b/frontend/app/cards/page.tsx
@@ -184,7 +184,9 @@ async function fetchAllCards(): Promise<CardsPageData> {
     const da = a.dueDate ? new Date(a.dueDate).getTime() : 0;
     const db = b.dueDate ? new Date(b.dueDate).getTime() : 0;
     if (da !== db) return da - db;
-    return a.boardTitle.localeCompare(b.boardTitle) || a.title.localeCompare(b.title);
+    return (
+      a.boardTitle.localeCompare(b.boardTitle) || a.title.localeCompare(b.title)
+    );
   });
 
   return { cards, currentUserId: me.id };
@@ -196,28 +198,29 @@ export default async function CardsPage() {
   return (
     <main className='flex h-full w-full flex-col p-8 md:p-12 overflow-auto'>
       <div className='flex min-h-0 flex-1 flex-col gap-6 w-full max-w-5xl'>
-      <div className='space-y-2'>
-        <h1 className='text-2xl font-semibold'>Cards</h1>
-        <p className='text-sm text-muted-foreground'>
-          All cards across your boards. Sort by board, list, or due date. Filter by board, list, labels, due date, or assignee.
-        </p>
-      </div>
-
-      {cards.length === 0 ? (
-        <Empty className='rounded-lg border border-dashed border-muted bg-muted/30'>
-          <EmptyHeader>
-            <EmptyMedia variant='icon'>
-              <LayoutGrid className='size-6' />
-            </EmptyMedia>
-            <EmptyTitle>No cards yet</EmptyTitle>
-            <EmptyDescription>
-              Create cards on your boards and they will appear here
-            </EmptyDescription>
-          </EmptyHeader>
-        </Empty>
-      ) : (
-        <CardsTable cards={cards} currentUserId={currentUserId} />
-      )}
+        <div className='space-y-2'>
+          <h1 className='text-2xl font-semibold'>Cards</h1>
+          <p className='text-sm text-muted-foreground'>
+            All cards across your boards. Sort by board, list, or due date.
+            Filter by board, list, labels, due date, or assignee.
+          </p>
+        </div>
+
+        {cards.length === 0 ? (
+          <Empty className='rounded-lg bg-muted/30'>
+            <EmptyHeader>
+              <EmptyMedia variant='icon'>
+                <LayoutGrid className='size-6' />
+              </EmptyMedia>
+              <EmptyTitle>No cards yet</EmptyTitle>
+              <EmptyDescription>
+                Create cards on your boards and they will appear here
+              </EmptyDescription>
+            </EmptyHeader>
+          </Empty>
+        ) : (
+          <CardsTable cards={cards} currentUserId={currentUserId} />
+        )}
       </div>
     </main>
   );
diff --git a/frontend/app/globals.css b/frontend/app/globals.css
index c5a3d73..79c30c8 100644
--- a/frontend/app/globals.css
+++ b/frontend/app/globals.css
@@ -581,7 +581,6 @@ html {
 
   [data-slot="sidebar-container"] {
     border-right: none !important;
-    border-left: none !important;
   }
 
   /* Sidebar sous le Topbar quand .topbar-above est sur le parent */
diff --git a/frontend/app/invitations/accept/page.tsx b/frontend/app/invitations/accept/page.tsx
index c218cef..33ecae0 100644
--- a/frontend/app/invitations/accept/page.tsx
+++ b/frontend/app/invitations/accept/page.tsx
@@ -1,12 +1,12 @@
 'use client';
 
-import { useEffect, useState } from 'react';
+import { Suspense, useEffect, useState } from 'react';
 import { useRouter, useSearchParams } from 'next/navigation';
 import { acceptInvitation } from '@/lib/actions/workspaces';
 import { toast } from '@/lib/toast';
 import { getAuthToken } from '@/lib/graphql-client';
 
-export default function AcceptInvitationPage() {
+function AcceptInvitationContent() {
   const router = useRouter();
   const searchParams = useSearchParams();
   const id = searchParams.get('id');
@@ -77,3 +77,29 @@ export default function AcceptInvitationPage() {
   );
 }
 
+export default function AcceptInvitationPage() {
+  return (
+    <Suspense
+      fallback={
+        <div className='h-full min-h-screen flex flex-col p-8 md:p-12 bg-background'>
+          <div className='flex-1 flex items-center justify-center'>
+            <div className='max-w-md w-full p-6 rounded-lg border border-accent bg-card shadow-sm text-center space-y-3'>
+              <h1 className='text-xl font-semibold text-foreground'>
+                Accepting invitation
+              </h1>
+              <p className='text-sm text-muted-foreground'>
+                Loading...
+              </p>
+              <div className='flex justify-center pt-2'>
+                <div className='animate-spin h-6 w-6 border-2 border-trello-blue border-t-transparent rounded-full' />
+              </div>
+            </div>
+          </div>
+        </div>
+      }
+    >
+      <AcceptInvitationContent />
+    </Suspense>
+  );
+}
+
diff --git a/frontend/app/invitations/reject/page.tsx b/frontend/app/invitations/reject/page.tsx
index 37bb580..e08ac80 100644
--- a/frontend/app/invitations/reject/page.tsx
+++ b/frontend/app/invitations/reject/page.tsx
@@ -1,18 +1,18 @@
 'use client';
 
-import { useEffect, useState } from 'react';
+import { Suspense, useEffect, useState } from 'react';
 import { useRouter, useSearchParams } from 'next/navigation';
 import { rejectInvitation } from '@/lib/actions/workspaces';
 import { toast } from '@/lib/toast';
 import { getAuthToken } from '@/lib/graphql-client';
 
-export default function RejectInvitationPage() {
+function RejectInvitationContent() {
   const router = useRouter();
   const searchParams = useSearchParams();
   const id = searchParams.get('id');
-  const [status, setStatus] = useState<'idle' | 'processing' | 'done' | 'error'>(
-    id ? 'idle' : 'error',
-  );
+  const [status, setStatus] = useState<
+    'idle' | 'processing' | 'done' | 'error'
+  >(id ? 'idle' : 'error');
   const [message, setMessage] = useState<string>(
     id ? 'Processing invitation...' : 'Missing invitation id in URL.',
   );
@@ -53,27 +53,50 @@ export default function RejectInvitationPage() {
     <div className='h-full min-h-screen flex flex-col p-8 md:p-12 bg-background'>
       <div className='flex-1 flex items-center justify-center'>
         <div className='max-w-md w-full p-6 rounded-lg border border-accent bg-card shadow-sm text-center space-y-3'>
-        <h1 className='text-xl font-semibold text-foreground'>
-          Rejecting invitation
-        </h1>
-        <p className='text-sm text-muted-foreground'>{message}</p>
-        {status === 'processing' && (
-          <div className='flex items-center justify-center pt-2'>
-            <div className='animate-spin h-6 w-6 border-2 border-trello-blue border-t-transparent rounded-full' />
-          </div>
-        )}
-        {status === 'error' && (
-          <button
-            type='button'
-            onClick={() => router.push('/invitations')}
-            className='mt-2 inline-flex items-center justify-center px-3 py-1.5 text-sm font-medium rounded-md bg-primary text-primary-foreground hover:bg-primary/90'
-          >
-            Go to my invitations
-          </button>
-        )}
+          <h1 className='text-xl font-semibold text-foreground'>
+            Rejecting invitation
+          </h1>
+          <p className='text-sm text-muted-foreground'>{message}</p>
+          {status === 'processing' && (
+            <div className='flex items-center justify-center pt-2'>
+              <div className='animate-spin h-6 w-6 border-2 border-trello-blue border-t-transparent rounded-full' />
+            </div>
+          )}
+          {status === 'error' && (
+            <button
+              type='button'
+              onClick={() => router.push('/invitations')}
+              className='mt-2 inline-flex items-center justify-center px-3 py-1.5 text-sm font-medium rounded-md bg-primary text-primary-foreground hover:bg-primary/90'
+            >
+              Go to my invitations
+            </button>
+          )}
         </div>
       </div>
     </div>
   );
 }
 
+export default function RejectInvitationPage() {
+  return (
+    <Suspense
+      fallback={
+        <div className='h-full min-h-screen flex flex-col p-8 md:p-12 bg-background'>
+          <div className='flex-1 flex items-center justify-center'>
+            <div className='max-w-md w-full p-6 rounded-lg border border-accent bg-card shadow-sm text-center space-y-3'>
+              <h1 className='text-xl font-semibold text-foreground'>
+                Rejecting invitation
+              </h1>
+              <p className='text-sm text-muted-foreground'>Loading...</p>
+              <div className='flex justify-center pt-2'>
+                <div className='animate-spin h-6 w-6 border-2 border-trello-blue border-t-transparent rounded-full' />
+              </div>
+            </div>
+          </div>
+        </div>
+      }
+    >
+      <RejectInvitationContent />
+    </Suspense>
+  );
+}
diff --git a/frontend/app/workspaces/[id]/members/components/GuestsTabContent.tsx b/frontend/app/workspaces/[id]/members/components/GuestsTabContent.tsx
index 874e569..e5bea9d 100644
--- a/frontend/app/workspaces/[id]/members/components/GuestsTabContent.tsx
+++ b/frontend/app/workspaces/[id]/members/components/GuestsTabContent.tsx
@@ -89,7 +89,7 @@ export function GuestsTabContent({
                 onAssignAdmin={onAssignAdmin}
                 onRemoveFromWorkspace={onRemoveFromWorkspace}
                 onRemoveFromWorkspaceAndBoards={onRemoveFromWorkspaceAndBoards}
-                isRemoving={removing === guest.userId}
+                removing={removing}
                 canRemove={canRemove}
                 memberBoards={getBoardsForMember(
                   workspaceBoards,
diff --git a/frontend/app/workspaces/[id]/members/components/MembersTabContent.tsx b/frontend/app/workspaces/[id]/members/components/MembersTabContent.tsx
index 22e05a6..57f4147 100644
--- a/frontend/app/workspaces/[id]/members/components/MembersTabContent.tsx
+++ b/frontend/app/workspaces/[id]/members/components/MembersTabContent.tsx
@@ -168,7 +168,7 @@ export function MembersTabContent({
                 onAssignAdmin={onAssignAdmin}
                 onRemoveFromWorkspace={onRemoveFromWorkspace}
                 onRemoveFromWorkspaceAndBoards={onRemoveFromWorkspaceAndBoards}
-                isRemoving={removing === member.userId}
+                removing={removing}
                 canRemove={canRemove}
                 canUpdateRole={canUpdateRole}
                 onRoleChange={onRoleChange}
diff --git a/frontend/components/Sidebar.tsx b/frontend/components/Sidebar.tsx
index c44e3e0..defecd8 100644
--- a/frontend/components/Sidebar.tsx
+++ b/frontend/components/Sidebar.tsx
@@ -16,13 +16,14 @@ import {
   Home,
   Plus,
   LayoutGrid,
+  LayoutTemplate,
+  Activity,
   Users,
   Settings,
   ChevronDown,
   Mail,
   Building2,
   CreditCard,
-  ListTodo,
 } from 'lucide-react';
 import { Button } from '@/components/ui/button';
 import { Input } from '@/components/ui/input';
@@ -273,10 +274,20 @@ export default function AppSidebar() {
                     isActive={pathname === '/activity'}
                     tooltip='Activity'
                   >
-                    <ListTodo />
+                    <Activity />
                     <span>Activity</span>
                   </SidebarMenuButton>
                 </SidebarMenuItem>
+                <SidebarMenuItem>
+                  <SidebarMenuButton
+                    onClick={() => router.push('/templates')}
+                    isActive={pathname === '/templates'}
+                    tooltip='Template gallery'
+                  >
+                    <LayoutTemplate />
+                    <span>Templates</span>
+                  </SidebarMenuButton>
+                </SidebarMenuItem>
               </SidebarMenu>
             </SidebarGroupContent>
           </SidebarGroup>
@@ -418,7 +429,7 @@ export default function AppSidebar() {
                               isActive={activityActive}
                               tooltip='Activity'
                             >
-                              <ListTodo />
+                              <Activity />
                               <span>Activity</span>
                             </SidebarMenuButton>
                           </SidebarMenuItem>
diff --git a/frontend/components/Topbar.tsx b/frontend/components/Topbar.tsx
index af6dba6..50f4cf8 100644
--- a/frontend/components/Topbar.tsx
+++ b/frontend/components/Topbar.tsx
@@ -5,18 +5,15 @@ import Link from 'next/link';
 import { usePathname, useRouter } from 'next/navigation';
 import CreateBoardModal from './CreateBoardModal';
 import { toast } from '@/lib/toast';
-import { Search, Bell, HelpCircle, Keyboard, Zap } from 'lucide-react';
+import { Search, Bell } from 'lucide-react';
 import { Button } from '@/components/ui/button';
 import { ThemeToggle } from './ThemeToggle';
 import { SearchWithAdvancedInput } from './SearchWithAdvancedInput';
 import {
   Dialog,
   DialogContent,
-  DialogDescription,
-  DialogHeader,
   DialogTitle,
 } from '@/components/ui/dialog';
-import { Separator } from '@/components/ui/separator';
 import {
   clearAuthToken,
   clearEpitrelloLocalStorage,
@@ -116,7 +113,6 @@ export default function Topbar() {
   const [userName, setUserName] = useState<string>('');
   const [userEmail, setUserEmail] = useState<string>('');
   const [userAvatar, setUserAvatar] = useState<string | undefined>(undefined);
-  const [showHelpDialog, setShowHelpDialog] = useState(false);
   const [showSearchDialog, setShowSearchDialog] = useState(false);
   const [notificationsOpen, setNotificationsOpen] = useState(false);
   const router = useRouter();
@@ -434,7 +430,7 @@ export default function Topbar() {
                           : 'U'}
                     </AvatarFallback>
                   </Avatar>
-                  <div className='flex flex-col'>
+                  <div className='flex flex-col gap-1'>
                     <p className='text-sm font-medium leading-none'>
                       {userName || 'User'}
                     </p>
@@ -445,18 +441,6 @@ export default function Topbar() {
                 </div>
               </DropdownMenuLabel>
               <DropdownMenuSeparator />
-              <DropdownMenuItem asChild>
-                <a
-                  href='#'
-                  onClick={(e) => {
-                    e.preventDefault();
-                    alert('Switch accounts (not implemented)');
-                  }}
-                  className='cursor-pointer'
-                >
-                  Switch accounts
-                </a>
-              </DropdownMenuItem>
               <DropdownMenuItem asChild>
                 <Link href='/settings' className='cursor-pointer'>
                   Manage account
@@ -487,19 +471,6 @@ export default function Topbar() {
                 </Link>
               </DropdownMenuItem>
               <DropdownMenuSeparator />
-              <DropdownMenuItem asChild>
-                <a
-                  href='#'
-                  onClick={(e) => {
-                    e.preventDefault();
-                    alert('Help (not implemented)');
-                  }}
-                  className='cursor-pointer'
-                >
-                  Help
-                </a>
-              </DropdownMenuItem>
-              <DropdownMenuSeparator />
               <DropdownMenuItem
                 onClick={handleSignOut}
                 className='cursor-pointer text-red-600'
@@ -524,142 +495,6 @@ export default function Topbar() {
         </DialogContent>
       </Dialog>
 
-      {/* Help Dialog */}
-      <Dialog open={showHelpDialog} onOpenChange={setShowHelpDialog}>
-        <DialogContent className='max-w-2xl max-h-[80vh] overflow-y-auto'>
-          <DialogHeader>
-            <DialogTitle className='flex items-center gap-2'>
-              <HelpCircle className='h-5 w-5' />
-              Epitrello Help Center
-            </DialogTitle>
-            <DialogDescription>
-              Learn how to use Epitrello to organize your projects effectively.
-            </DialogDescription>
-          </DialogHeader>
-
-          <div className='space-y-6 mt-4'>
-            {/* Getting Started */}
-            <div className='space-y-3'>
-              <h3 className='text-base font-semibold flex items-center gap-2'>
-                <Zap className='h-4 w-4' />
-                Getting started
-              </h3>
-              <ul className='space-y-2 text-sm text-muted-foreground ml-6'>
-                <li className='list-disc'>
-                  Create a <strong>workspace</strong> to organize your projects
-                  by team or domain
-                </li>
-                <li className='list-disc'>
-                  Add <strong>boards</strong> for each project in your workspace
-                </li>
-                <li className='list-disc'>
-                  Use <strong>lists</strong> to represent your workflow stages
-                  (To Do, In Progress, Done)
-                </li>
-                <li className='list-disc'>
-                  Create <strong>cards</strong> for each task and drag them
-                  between lists
-                </li>
-              </ul>
-            </div>
-
-            <Separator />
-
-            {/* Key Features */}
-            <div className='space-y-3'>
-              <h3 className='text-base font-semibold'>Key features</h3>
-              <div className='space-y-3 text-sm'>
-                <div>
-                  <strong className='text-foreground'>Interactive cards</strong>
-                  <p className='text-muted-foreground'>
-                    Add descriptions, checklists, labels and due dates to your
-                    cards.
-                  </p>
-                </div>
-                <div>
-                  <strong className='text-foreground'>
-                    Team collaboration
-                  </strong>
-                  <p className='text-muted-foreground'>
-                    Invite members, assign tasks and comment on cards to
-                    collaborate.
-                  </p>
-                </div>
-                <div>
-                  <strong className='text-foreground'>Customization</strong>
-                  <p className='text-muted-foreground'>
-                    Choose backgrounds for your boards and organize them to your
-                    preferences.
-                  </p>
-                </div>
-              </div>
-            </div>
-
-            <Separator />
-
-            {/* Keyboard Shortcuts */}
-            <div className='space-y-3'>
-              <h3 className='text-base font-semibold flex items-center gap-2'>
-                <Keyboard className='h-4 w-4' />
-                Keyboard shortcuts
-              </h3>
-              <div className='grid grid-cols-1 sm:grid-cols-2 gap-2 text-sm'>
-                <div className='flex justify-between p-2 rounded bg-muted/50'>
-                  <span className='text-muted-foreground'>New card</span>
-                  <kbd className='px-2 py-1 text-xs bg-background border rounded'>
-                    N
-                  </kbd>
-                </div>
-                <div className='flex justify-between p-2 rounded bg-muted/50'>
-                  <span className='text-muted-foreground'>Search</span>
-                  <kbd className='px-2 py-1 text-xs bg-background border rounded'>
-                    Ctrl+F
-                  </kbd>
-                </div>
-                <div className='flex justify-between p-2 rounded bg-muted/50'>
-                  <span className='text-muted-foreground'>New board</span>
-                  <kbd className='px-2 py-1 text-xs bg-background border rounded'>
-                    B
-                  </kbd>
-                </div>
-                <div className='flex justify-between p-2 rounded bg-muted/50'>
-                  <span className='text-muted-foreground'>Help</span>
-                  <kbd className='px-2 py-1 text-xs bg-background border rounded'>
-                    ?
-                  </kbd>
-                </div>
-              </div>
-            </div>
-
-            <Separator />
-
-            {/* Support */}
-            <div className='space-y-3'>
-              <h3 className='text-base font-semibold'>Need more help?</h3>
-              <p className='text-sm text-muted-foreground'>
-                Check the full documentation or contact support for more
-                information.
-              </p>
-              <div className='flex gap-2'>
-                <Button
-                  variant='outline'
-                  size='sm'
-                  onClick={() => toast.info('Documentation coming soon')}
-                >
-                  Documentation
-                </Button>
-                <Button
-                  variant='outline'
-                  size='sm'
-                  onClick={() => toast.info('Support coming soon')}
-                >
-                  Contact support
-                </Button>
-              </div>
-            </div>
-          </div>
-        </DialogContent>
-      </Dialog>
     </header>
   );
 }

From 98a099e7528b1e39ea5da954a07fcf61ae326558 Mon Sep 17 00:00:00 2001
From: mpJunot <junot-hery-nantenaina.montpre@epitech.eu>
Date: Wed, 11 Feb 2026 00:50:25 +0100
Subject: [PATCH 9/9] chore(frontend): update dependencies

---
 frontend/package.json   |   1 +
 frontend/pnpm-lock.yaml | 656 +++++++++++++++++++++++++++++++++++++++-
 2 files changed, 643 insertions(+), 14 deletions(-)

diff --git a/frontend/package.json b/frontend/package.json
index 91ae51c..9f75a83 100644
--- a/frontend/package.json
+++ b/frontend/package.json
@@ -54,6 +54,7 @@
     "lucide-react": "^0.562.0",
     "next": "16.0.1",
     "next-themes": "^0.4.6",
+    "radix-ui": "^1.4.3",
     "react": "19.2.0",
     "react-day-picker": "^9.13.0",
     "react-dom": "19.2.0",
diff --git a/frontend/pnpm-lock.yaml b/frontend/pnpm-lock.yaml
index cd07b6d..3126936 100644
--- a/frontend/pnpm-lock.yaml
+++ b/frontend/pnpm-lock.yaml
@@ -95,6 +95,9 @@ importers:
       next-themes:
         specifier: ^0.4.6
         version: 0.4.6(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      radix-ui:
+        specifier: ^1.4.3
+        version: 1.4.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
       react:
         specifier: 19.2.0
         version: 19.2.0
@@ -1368,6 +1371,45 @@ packages:
   '@radix-ui/primitive@1.1.3':
     resolution: {integrity: sha512-JTF99U/6XIjCBo0wqkU5sK10glYe27MRRsfwoiq5zzOEZLHU3A3KCMa5X/azekYRCJ0HlwI0crAXS/5dEHTzDg==}
 
+  '@radix-ui/react-accessible-icon@1.1.7':
+    resolution: {integrity: sha512-XM+E4WXl0OqUJFovy6GjmxxFyx9opfCAIUku4dlKRd5YEPqt4kALOkQOp0Of6reHuUkJuiPBEc5k0o4z4lTC8A==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-accordion@1.2.12':
+    resolution: {integrity: sha512-T4nygeh9YE9dLRPhAHSeOZi7HBXo+0kYIPJXayZfvWOWA0+n3dESrZbjfDPUABkUNym6Hd+f2IR113To8D2GPA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-alert-dialog@1.1.15':
+    resolution: {integrity: sha512-oTVLkEw5GpdRe29BqJ0LSDFWI3qu0vR1M0mUkOQWDIUnY/QIkLpgDMWuKxP94c2NAC2LGcgVhG1ImF3jkZ5wXw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-arrow@1.1.7':
     resolution: {integrity: sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==}
     peerDependencies:
@@ -1381,6 +1423,32 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-aspect-ratio@1.1.7':
+    resolution: {integrity: sha512-Yq6lvO9HQyPwev1onK1daHCHqXVLzPhSVjmsNjCa2Zcxy2f7uJD2itDtxknv6FzAKCwD1qQkeVDmX/cev13n/g==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-avatar@1.1.10':
+    resolution: {integrity: sha512-V8piFfWapM5OmNCXTzVQY+E1rDa53zY+MQ4Y7356v4fFz6vqCyUtIz2rUD44ZEdwg78/jKmMJHj07+C/Z/rcog==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-avatar@1.1.11':
     resolution: {integrity: sha512-0Qk603AHGV28BOBO34p7IgD5m+V5Sg/YovfayABkoDDBM5d3NCx0Mp4gGrjzLGes1jV5eNOE1r3itqOR33VC6Q==}
     peerDependencies:
@@ -1442,6 +1510,19 @@ packages:
       '@types/react':
         optional: true
 
+  '@radix-ui/react-context-menu@2.2.16':
+    resolution: {integrity: sha512-O8morBEW+HsVG28gYDZPTrT9UUovQUlJue5YO836tiTJhuIWBm/zQHc7j388sHWtdH/xUZurK9olD2+pcqx5ww==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-context@1.1.2':
     resolution: {integrity: sha512-jCi/QKUM2r1Ju5a3J64TH2A5SpKAgh0LpknyqdQ4m6DCV0xJ2HG1xARRwNGPQfi1SLdLWZ1OJz6F4OMBBNiGJA==}
     peerDependencies:
@@ -1530,6 +1611,32 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-form@0.1.8':
+    resolution: {integrity: sha512-QM70k4Zwjttifr5a4sZFts9fn8FzHYvQ5PiB19O2HsYibaHSVt9fH9rzB0XZo/YcM+b7t/p7lYCT/F5eOeF5yQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-hover-card@1.1.15':
+    resolution: {integrity: sha512-qgTkjNT1CfKMoP0rcasmlH2r1DAiYicWsDsufxl940sT2wHNEWWv6FMWIQXWhVdmC1d/HYfbhQx60KYyAtKxjg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-id@1.1.1':
     resolution: {integrity: sha512-kGkGegYIdQsOb4XjsfM97rXsiHaBwco+hFI66oO4s9LU+PLAC5oJ7khdOVFxkhsmlbpUqDAvXw11CluXP+jkHg==}
     peerDependencies:
@@ -1539,6 +1646,19 @@ packages:
       '@types/react':
         optional: true
 
+  '@radix-ui/react-label@2.1.7':
+    resolution: {integrity: sha512-YT1GqPSL8kJn20djelMX7/cTRp/Y9w5IZHvfxQTVHrOqa2yMl7i/UfMqKRU5V7mEyKTrUVgJXhNQPVCG8PBLoQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-label@2.1.8':
     resolution: {integrity: sha512-FmXs37I6hSBVDlO4y764TNz1rLgKwjJMQ0EGte6F3Cb3f4bIuHB/iLa/8I9VKkmOy+gNHq8rql3j686ACVV21A==}
     peerDependencies:
@@ -1565,6 +1685,58 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-menubar@1.1.16':
+    resolution: {integrity: sha512-EB1FktTz5xRRi2Er974AUQZWg2yVBb1yjip38/lgwtCVRd3a+maUoGHN/xs9Yv8SY8QwbSEb+YrxGadVWbEutA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-navigation-menu@1.2.14':
+    resolution: {integrity: sha512-YB9mTFQvCOAQMHU+C/jVl96WmuWeltyUEpRJJky51huhds5W2FQr1J8D/16sQlf0ozxkPK8uF3niQMdUwZPv5w==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-one-time-password-field@0.1.8':
+    resolution: {integrity: sha512-ycS4rbwURavDPVjCb5iS3aG4lURFDILi6sKI/WITUMZ13gMmn/xGjpLoqBAalhJaDk8I3UbCM5GzKHrnzwHbvg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-password-toggle-field@0.1.3':
+    resolution: {integrity: sha512-/UuCrDBWravcaMix4TdT+qlNdVwOM1Nck9kWx/vafXsdfj1ChfhOdfi3cy9SGBpWgTXwYCuboT/oYpJy3clqfw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-popover@1.1.15':
     resolution: {integrity: sha512-kr0X2+6Yy/vJzLYJUPCZEc8SfQcf+1COFoAqauJm74umQhta9M7lNJHP7QQS3vkvcGLQUbWpMzwrXYwrYztHKA==}
     peerDependencies:
@@ -1643,6 +1815,19 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-progress@1.1.7':
+    resolution: {integrity: sha512-vPdg/tF6YC/ynuBIJlk1mm7Le0VgW6ub6J2UWnTQ7/D23KXcPI1qy+0vBkgKgd38RCMJavBXpB83HPNFMTb0Fg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-progress@1.1.8':
     resolution: {integrity: sha512-+gISHcSPUJ7ktBy9RnTqbdKW78bcGke3t6taawyZ71pio1JewwGSJizycs7rLhGTvMJYCQB1DBK4KQsxs7U8dA==}
     peerDependencies:
@@ -1656,6 +1841,19 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-radio-group@1.3.8':
+    resolution: {integrity: sha512-VBKYIYImA5zsxACdisNQ3BjCBfmbGH3kQlnFVqlWU4tXwjy7cGX8ta80BcrO+WJXIn5iBylEH3K6ZTlee//lgQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-roving-focus@1.1.11':
     resolution: {integrity: sha512-7A6S9jSgm/S+7MdtNDSb+IU859vQqJ/QAtcYQcfFC6W8RS4IxIZDldLR0xqCFZ6DCyrQLjLPsxtTNch5jVA4lA==}
     peerDependencies:
@@ -1695,6 +1893,19 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-separator@1.1.7':
+    resolution: {integrity: sha512-0HEb8R9E8A+jZjvmFCy/J4xhbXy3TV+9XSnGJ3KvTtjlIUy/YQ/p6UYZvi7YbeoeXdyU9+Y3scizK6hkY37baA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-separator@1.1.8':
     resolution: {integrity: sha512-sDvqVY4itsKwwSMEe0jtKgfTh+72Sy3gPmQpjqcQneqQ4PFmr/1I0YA+2/puilhggCe2gJcx5EBAYFkWkdpa5g==}
     peerDependencies:
@@ -1708,6 +1919,19 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-slider@1.3.6':
+    resolution: {integrity: sha512-JPYb1GuM1bxfjMRlNLE+BcmBC8onfCi60Blk7OBqi2MLTFdS+8401U4uFjnwkOr49BLmXxLC6JHkvAsx5OJvHw==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-slot@1.2.3':
     resolution: {integrity: sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==}
     peerDependencies:
@@ -1765,6 +1989,45 @@ packages:
       '@types/react-dom':
         optional: true
 
+  '@radix-ui/react-toggle-group@1.1.11':
+    resolution: {integrity: sha512-5umnS0T8JQzQT6HbPyO7Hh9dgd82NmS36DQr+X/YJ9ctFNCiiQd6IJAYYZ33LUwm8M+taCz5t2ui29fHZc4Y6Q==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-toggle@1.1.10':
+    resolution: {integrity: sha512-lS1odchhFTeZv3xwHH31YPObmJn8gOg7Lq12inrr0+BH/l3Tsq32VfjqH1oh80ARM3mlkfMic15n0kg4sD1poQ==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
+  '@radix-ui/react-toolbar@1.1.11':
+    resolution: {integrity: sha512-4ol06/1bLoFu1nwUqzdD4Y5RZ9oDdKeiHIsntug54Hcr1pgaHiPqHFEaXI1IFP/EsOfROQZ8Mig9VTIRza6Tjg==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   '@radix-ui/react-tooltip@1.2.8':
     resolution: {integrity: sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg==}
     peerDependencies:
@@ -4085,6 +4348,19 @@ packages:
   queue-microtask@1.2.3:
     resolution: {integrity: sha512-NuaNSa6flKT5JaSYQzJok04JzTL1CA6aGhv5rfLW3PgqA+M2ChpZQnAC8h8i4ZFkBS8X5RqkDBHA7r4hej3K9A==}
 
+  radix-ui@1.4.3:
+    resolution: {integrity: sha512-aWizCQiyeAenIdUbqEpXgRA1ya65P13NKn/W8rWkcN0OPkRDxdBVLWnIEDsS2RpwCK2nobI7oMUSmexzTDyAmA==}
+    peerDependencies:
+      '@types/react': '*'
+      '@types/react-dom': '*'
+      react: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+      react-dom: ^16.8 || ^17.0 || ^18.0 || ^19.0 || ^19.0.0-rc
+    peerDependenciesMeta:
+      '@types/react':
+        optional: true
+      '@types/react-dom':
+        optional: true
+
   react-day-picker@9.13.0:
     resolution: {integrity: sha512-euzj5Hlq+lOHqI53NiuNhCP8HWgsPf/bBAVijR50hNaY1XwjKjShAnIe8jm8RD2W9IJUvihDIZ+KrmqfFzNhFQ==}
     engines: {node: '>=18'}
@@ -6258,45 +6534,107 @@ snapshots:
 
   '@radix-ui/primitive@1.1.3': {}
 
-  '@radix-ui/react-arrow@1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+  '@radix-ui/react-accessible-icon@1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
     dependencies:
-      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
       react: 19.2.0
       react-dom: 19.2.0(react@19.2.0)
     optionalDependencies:
       '@types/react': 19.2.2
       '@types/react-dom': 19.2.2(@types/react@19.2.2)
 
-  '@radix-ui/react-avatar@1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+  '@radix-ui/react-accordion@1.2.12(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
     dependencies:
-      '@radix-ui/react-context': 1.1.3(@types/react@19.2.2)(react@19.2.0)
-      '@radix-ui/react-primitive': 2.1.4(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
-      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.2)(react@19.2.0)
-      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.2)(react@19.2.0)
-      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collapsible': 1.1.12(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
       react: 19.2.0
       react-dom: 19.2.0(react@19.2.0)
     optionalDependencies:
       '@types/react': 19.2.2
       '@types/react-dom': 19.2.2(@types/react@19.2.2)
 
-  '@radix-ui/react-checkbox@1.3.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+  '@radix-ui/react-alert-dialog@1.1.15(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
       '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
       '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
-      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-dialog': 1.1.15(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
       '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
-      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
-      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.2)(react@19.2.0)
-      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.2)(react@19.2.0)
       react: 19.2.0
       react-dom: 19.2.0(react@19.2.0)
     optionalDependencies:
       '@types/react': 19.2.2
       '@types/react-dom': 19.2.2(@types/react@19.2.2)
 
-  '@radix-ui/react-collapsible@1.1.12(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+  '@radix-ui/react-arrow@1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
+  '@radix-ui/react-aspect-ratio@1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
+  '@radix-ui/react-avatar@1.1.10(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
+  '@radix-ui/react-avatar@1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/react-context': 1.1.3(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.4(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
+  '@radix-ui/react-checkbox@1.3.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
+  '@radix-ui/react-collapsible@1.1.12(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
       '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
@@ -6330,6 +6668,20 @@ snapshots:
     optionalDependencies:
       '@types/react': 19.2.2
 
+  '@radix-ui/react-context-menu@2.2.16(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-menu': 2.1.16(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
   '@radix-ui/react-context@1.1.2(@types/react@19.2.2)(react@19.2.0)':
     dependencies:
       react: 19.2.0
@@ -6415,6 +6767,37 @@ snapshots:
       '@types/react': 19.2.2
       '@types/react-dom': 19.2.2(@types/react@19.2.2)
 
+  '@radix-ui/react-form@0.1.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-label': 2.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
+  '@radix-ui/react-hover-card@1.1.15(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-popper': 1.2.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
   '@radix-ui/react-id@1.1.1(@types/react@19.2.2)(react@19.2.0)':
     dependencies:
       '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.2)(react@19.2.0)
@@ -6422,6 +6805,15 @@ snapshots:
     optionalDependencies:
       '@types/react': 19.2.2
 
+  '@radix-ui/react-label@2.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
   '@radix-ui/react-label@2.1.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
     dependencies:
       '@radix-ui/react-primitive': 2.1.4(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
@@ -6457,6 +6849,82 @@ snapshots:
       '@types/react': 19.2.2
       '@types/react-dom': 19.2.2(@types/react@19.2.2)
 
+  '@radix-ui/react-menubar@1.1.16(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-menu': 2.1.16(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
+  '@radix-ui/react-navigation-menu@1.2.14(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
+  '@radix-ui/react-one-time-password-field@0.1.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/number': 1.1.1
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
+  '@radix-ui/react-password-toggle-field@0.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-id': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.2)(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
   '@radix-ui/react-popover@1.1.15(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
@@ -6536,6 +7004,16 @@ snapshots:
       '@types/react': 19.2.2
       '@types/react-dom': 19.2.2(@types/react@19.2.2)
 
+  '@radix-ui/react-progress@1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
   '@radix-ui/react-progress@1.1.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
     dependencies:
       '@radix-ui/react-context': 1.1.3(@types/react@19.2.2)(react@19.2.0)
@@ -6546,6 +7024,24 @@ snapshots:
       '@types/react': 19.2.2
       '@types/react-dom': 19.2.2(@types/react@19.2.2)
 
+  '@radix-ui/react-radio-group@1.3.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
   '@radix-ui/react-roving-focus@1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
@@ -6609,6 +7105,15 @@ snapshots:
       '@types/react': 19.2.2
       '@types/react-dom': 19.2.2(@types/react@19.2.2)
 
+  '@radix-ui/react-separator@1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
   '@radix-ui/react-separator@1.1.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
     dependencies:
       '@radix-ui/react-primitive': 2.1.4(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
@@ -6618,6 +7123,25 @@ snapshots:
       '@types/react': 19.2.2
       '@types/react-dom': 19.2.2(@types/react@19.2.2)
 
+  '@radix-ui/react-slider@1.3.6(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/number': 1.1.1
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-previous': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
   '@radix-ui/react-slot@1.2.3(@types/react@19.2.2)(react@19.2.0)':
     dependencies:
       '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
@@ -6683,6 +7207,47 @@ snapshots:
       '@types/react': 19.2.2
       '@types/react-dom': 19.2.2(@types/react@19.2.2)
 
+  '@radix-ui/react-toggle-group@1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-toggle': 1.1.10(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
+  '@radix-ui/react-toggle@1.1.10(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
+  '@radix-ui/react-toolbar@1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-separator': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-toggle-group': 1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
   '@radix-ui/react-tooltip@1.2.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)':
     dependencies:
       '@radix-ui/primitive': 1.1.3
@@ -9202,6 +9767,69 @@ snapshots:
 
   queue-microtask@1.2.3: {}
 
+  radix-ui@1.4.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0):
+    dependencies:
+      '@radix-ui/primitive': 1.1.3
+      '@radix-ui/react-accessible-icon': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-accordion': 1.2.12(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-alert-dialog': 1.1.15(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-arrow': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-aspect-ratio': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-avatar': 1.1.10(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-checkbox': 1.3.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-collapsible': 1.1.12(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-collection': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-compose-refs': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-context': 1.1.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-context-menu': 2.2.16(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-dialog': 1.1.15(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-direction': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-dismissable-layer': 1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-dropdown-menu': 2.1.16(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-focus-guards': 1.1.3(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-focus-scope': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-form': 0.1.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-hover-card': 1.1.15(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-label': 2.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-menu': 2.1.16(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-menubar': 1.1.16(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-navigation-menu': 1.2.14(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-one-time-password-field': 0.1.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-password-toggle-field': 0.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-popover': 1.1.15(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-popper': 1.2.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-portal': 1.1.9(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-presence': 1.1.5(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-primitive': 2.1.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-progress': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-radio-group': 1.3.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-roving-focus': 1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-scroll-area': 1.2.10(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-select': 2.2.6(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-separator': 1.1.7(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-slider': 1.3.6(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-slot': 1.2.3(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-switch': 1.2.6(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-tabs': 1.1.13(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-toast': 1.2.15(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-toggle': 1.1.10(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-toggle-group': 1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-toolbar': 1.1.11(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-tooltip': 1.2.8(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      '@radix-ui/react-use-callback-ref': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-controllable-state': 1.2.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-effect-event': 0.0.2(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-escape-keydown': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-is-hydrated': 0.1.0(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-layout-effect': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-use-size': 1.1.1(@types/react@19.2.2)(react@19.2.0)
+      '@radix-ui/react-visually-hidden': 1.2.3(@types/react-dom@19.2.2(@types/react@19.2.2))(@types/react@19.2.2)(react-dom@19.2.0(react@19.2.0))(react@19.2.0)
+      react: 19.2.0
+      react-dom: 19.2.0(react@19.2.0)
+    optionalDependencies:
+      '@types/react': 19.2.2
+      '@types/react-dom': 19.2.2(@types/react@19.2.2)
+
   react-day-picker@9.13.0(react@19.2.0):
     dependencies:
       '@date-fns/tz': 1.4.1