@critical-path/svelte 0.18.0 → 0.18.2

package/src/index.test.ts

@@ -1,885 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import {
-  createCriticalPathClient,
-  ProjectState,
-  createProjectState,
-  TaskState,
-  createTaskState,
-  WorkflowState,
-  createWorkflowState,
-  CommentState,
-  createCommentState,
-  AttachmentState,
-  createAttachmentState,
-  TaskActivityState,
-  createTaskActivityState,
-  DeliverableState,
-  createDeliverableState,
-  DeliverableSummaryState,
-  createDeliverableSummaryState,
-  KanbanState,
-  createKanbanState,
-  TaskTransitionsState,
-  createTaskTransitionsState,
-  WebMcpState,
-  createWebMcpState,
-  CriticalPathState,
-  createCriticalPathState,
-  TimelineLadderState,
-  createTimelineLadderState,
-  TaskMetricsState,
-  createTaskMetricsState,
-  WorkloadState,
-  createWorkloadState
-} from './index.js';
-import type { CriticalPathClient } from '@critical-path/client';
-import type {
-  Project,
-  Task,
-  Workflow,
-  Comment,
-  Attachment,
-  Deliverable,
-  DeliverableSummary,
-  CriticalPathAnalysis,
-  TimelineLadder,
-  WorkloadDistribution
-} from '@critical-path/core';
-
-describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
-  it('exports client factory and Svelte 5 Runes state factories', () => {
-    expect(createCriticalPathClient).toBeDefined();
-    expect(createProjectState).toBeDefined();
-    expect(createTaskState).toBeDefined();
-    expect(createWorkflowState).toBeDefined();
-    expect(createCommentState).toBeDefined();
-    expect(createAttachmentState).toBeDefined();
-    expect(createTaskActivityState).toBeDefined();
-    expect(createDeliverableState).toBeDefined();
-    expect(createDeliverableSummaryState).toBeDefined();
-    expect(createKanbanState).toBeDefined();
-    expect(createTaskTransitionsState).toBeDefined();
-    expect(ProjectState).toBeDefined();
-    expect(TaskState).toBeDefined();
-    expect(WorkflowState).toBeDefined();
-    expect(CommentState).toBeDefined();
-    expect(AttachmentState).toBeDefined();
-    expect(TaskActivityState).toBeDefined();
-    expect(DeliverableState).toBeDefined();
-    expect(DeliverableSummaryState).toBeDefined();
-    expect(KanbanState).toBeDefined();
-    expect(TaskTransitionsState).toBeDefined();
-    expect(WebMcpState).toBeDefined();
-    expect(createWebMcpState).toBeDefined();
-  });
-
-  describe('WorkflowState', () => {
-    it('fetches and creates workflows', async () => {
-      const mockWf: Workflow = {
-        id: 'wf_1',
-        name: 'Svelte Workflow',
-        isDefault: true,
-        defaultStatusKey: 'todo',
-        statuses: [{ key: 'todo', label: 'To Do', category: 'not_started' }],
-        transitions: [],
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-
-      const mockClient = {
-        getWorkflows: vi.fn().mockResolvedValue([mockWf]),
-        createWorkflow: vi.fn().mockResolvedValue(mockWf)
-      } as unknown as CriticalPathClient;
-
-      const wfState = createWorkflowState(mockClient);
-      await wfState.fetch();
-
-      expect(wfState.data).toEqual([mockWf]);
-    });
-  });
-
-  describe('ProjectState', () => {
-    it('initializes with default empty state', () => {
-      const mockClient = {} as CriticalPathClient;
-      const projectState = createProjectState(mockClient);
-
-      expect(projectState.data).toEqual([]);
-      expect(projectState.loading).toBe(false);
-      expect(projectState.error).toBeNull();
-    });
-
-    it('fetches projects and updates state reactively', async () => {
-      const mockProjects: Project[] = [
-        { id: 'proj_1', name: 'Project 1', key: 'PRJ1', createdAt: '2026-01-01', updatedAt: '2026-01-01' }
-      ];
-      const mockClient = {
-        getProjects: vi.fn().mockResolvedValue(mockProjects)
-      } as unknown as CriticalPathClient;
-
-      const projectState = new ProjectState(mockClient);
-      await projectState.fetch();
-
-      expect(mockClient.getProjects).toHaveBeenCalledOnce();
-      expect(projectState.data).toEqual(mockProjects);
-      expect(projectState.loading).toBe(false);
-      expect(projectState.error).toBeNull();
-    });
-
-    it('creates project optimistically and rolls back on failure', async () => {
-      const mockCreated: Project = {
-        id: 'proj_2',
-        name: 'Project 2',
-        key: 'PRJ2',
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-      const mockClient = {
-        createProject: vi.fn().mockResolvedValue(mockCreated)
-      } as unknown as CriticalPathClient;
-
-      const projectState = new ProjectState(mockClient);
-      const res = await projectState.createProject({ name: 'Project 2', key: 'PRJ2' });
-
-      expect(res).toEqual(mockCreated);
-      expect(projectState.data).toEqual([mockCreated]);
-
-      // Test error rollback
-      const failingClient = {
-        createProject: vi.fn().mockRejectedValue(new Error('Network error'))
-      } as unknown as CriticalPathClient;
-      const failingState = new ProjectState(failingClient);
-
-      await expect(failingState.createProject({ name: 'Failed Proj', key: 'FAIL' })).rejects.toThrow('Network error');
-      expect(failingState.data).toEqual([]);
-    });
-  });
-
-  describe('TaskState', () => {
-    it('fetches, creates, updates status, and deletes tasks with optimistic updates', async () => {
-      const mockTask: Task = {
-        id: 'task_1',
-        projectId: 'proj_1',
-        title: 'Task 1',
-        status: 'todo',
-        priority: 'medium',
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-      const updatedTask: Task = { ...mockTask, status: 'in_progress' };
-
-      const mockClient = {
-        getTasks: vi.fn().mockResolvedValue([mockTask]),
-        createTask: vi.fn().mockResolvedValue(mockTask),
-        updateTask: vi.fn().mockImplementation((taskId: string, updates: Partial<Task>) => Promise.resolve({ ...mockTask, ...updates })),
-        deleteTask: vi.fn().mockResolvedValue(undefined)
-      } as unknown as CriticalPathClient;
-
-      const taskState = createTaskState(mockClient, 'proj_1');
-      await taskState.fetch();
-
-      expect(taskState.data).toEqual([mockTask]);
-
-      // Update status
-      await taskState.updateTaskStatus('task_1', 'in_progress');
-      expect(taskState.data[0].status).toBe('in_progress');
-
-      // Update task generic updates (e.g. todos)
-      await taskState.updateTask('task_1', {
-        todos: [{ id: 'todo_1', title: 'Checklist item', completed: true }]
-      });
-      expect(taskState.data[0].todos).toEqual([{ id: 'todo_1', title: 'Checklist item', completed: true }]);
-
-      // Delete task
-      await taskState.deleteTask('task_1');
-      expect(taskState.data).toEqual([]);
-    });
-
-    it('rolls back task status update on server error', async () => {
-      const mockTask: Task = {
-        id: 'task_1',
-        projectId: 'proj_1',
-        title: 'Task 1',
-        status: 'todo',
-        priority: 'medium',
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-
-      const failingClient = {
-        getTasks: vi.fn().mockResolvedValue([mockTask]),
-        updateTask: vi.fn().mockRejectedValue(new Error('Server error'))
-      } as unknown as CriticalPathClient;
-
-      const taskState = createTaskState(failingClient, 'proj_1');
-      await taskState.fetch();
-
-      await expect(taskState.updateTaskStatus('task_1', 'in_progress')).rejects.toThrow('Server error');
-      // Should be rolled back to 'todo'
-      expect(taskState.data[0].status).toBe('todo');
-    });
-
-    it('rolls back task deletion on server error', async () => {
-      const mockTask: Task = {
-        id: 'task_1',
-        projectId: 'proj_1',
-        title: 'Task 1',
-        status: 'todo',
-        priority: 'medium',
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-
-      const failingClient = {
-        getTasks: vi.fn().mockResolvedValue([mockTask]),
-        deleteTask: vi.fn().mockRejectedValue(new Error('Delete failed'))
-      } as unknown as CriticalPathClient;
-
-      const taskState = createTaskState(failingClient, 'proj_1');
-      await taskState.fetch();
-
-      await expect(taskState.deleteTask('task_1')).rejects.toThrow('Delete failed');
-      // Should restore deleted task
-      expect(taskState.data).toEqual([mockTask]);
-    });
-
-    it('resolves in-flight temporary task when updated or deleted before creation completes', async () => {
-      let resolveCreate: (value: Task) => void;
-      const createPromise = new Promise<Task>((resolve) => {
-        resolveCreate = resolve;
-      });
-
-      const mockClient = {
-        getTasks: vi.fn().mockResolvedValue([]),
-        createTask: vi.fn().mockReturnValue(createPromise),
-        updateTask: vi.fn().mockImplementation((taskId: string, updates: Partial<Task>) =>
-          Promise.resolve({ id: taskId, projectId: 'proj_1', title: 'Real Task', status: 'todo', priority: 'medium', createdAt: '2026-01-01', updatedAt: '2026-01-01', ...updates } as Task)
-        ),
-        deleteTask: vi.fn().mockResolvedValue(undefined)
-      } as unknown as CriticalPathClient;
-
-      const taskState = createTaskState(mockClient, 'proj_1');
-      await taskState.fetch();
-
-      // Start creation
-      const creationAction = taskState.createTask({
-        projectId: 'proj_1',
-        title: 'Draft Task',
-        status: 'todo',
-        priority: 'medium'
-      });
-
-      // While in flight, optimistic task with temp_ ID is present
-      expect(taskState.data.length).toBe(1);
-      const tempId = taskState.data[0].id;
-      expect(tempId.startsWith('temp_')).toBe(true);
-
-      // Immediately update using tempId before creation resolves
-      const updateAction = taskState.updateTask(tempId, { title: 'Renamed Draft Task' });
-
-      // Local optimistic state is updated immediately
-      expect(taskState.data[0].title).toBe('Renamed Draft Task');
-
-      // Now resolve the server creation
-      const serverTask: Task = {
-        id: 'real_task_99',
-        projectId: 'proj_1',
-        title: 'Draft Task',
-        status: 'todo',
-        priority: 'medium',
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-      resolveCreate!(serverTask);
-
-      await creationAction;
-      await updateAction;
-
-      // Verify server update was called with the real task ID, not the temp ID
-      expect(mockClient.updateTask).toHaveBeenCalledWith('real_task_99', { title: 'Renamed Draft Task' });
-
-      // And deleting with the tempId resolves to real_task_99
-      await taskState.deleteTask(tempId);
-      expect(mockClient.deleteTask).toHaveBeenCalledWith('real_task_99');
-      expect(taskState.data.length).toBe(0);
-    });
-  });
-
-  describe('CommentState', () => {
-    it('fetches, creates, updates, and deletes comments', async () => {
-      const mockComment = {
-        id: 'cmt_1',
-        taskId: 'task_1',
-        content: 'Root comment',
-        authorId: 'u1',
-        authorType: 'user' as const,
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-      const updatedComment = { ...mockComment, content: 'Updated comment' };
-      const reactedComment = { ...mockComment, reactions: [{ emoji: '🔥', userId: 'u2', createdAt: '2026-01-01' }] };
-
-      const mockClient = {
-        getComments: vi.fn().mockResolvedValue([mockComment]),
-        addComment: vi.fn().mockResolvedValue(mockComment),
-        updateComment: vi.fn().mockResolvedValue(updatedComment),
-        deleteComment: vi.fn().mockResolvedValue(true),
-        addCommentReaction: vi.fn().mockResolvedValue(reactedComment),
-        removeCommentReaction: vi.fn().mockResolvedValue(mockComment)
-      } as unknown as CriticalPathClient;
-
-      const commentState = new CommentState(mockClient, 'task_1');
-      await commentState.fetch();
-
-      expect(commentState.data).toEqual([mockComment]);
-
-      await commentState.updateComment('cmt_1', { content: 'Updated comment' });
-      expect(commentState.data[0].content).toBe('Updated comment');
-
-      await commentState.addReaction('cmt_1', '🔥');
-      expect(commentState.data[0].reactions).toHaveLength(1);
-      expect(commentState.data[0].reactions?.[0].emoji).toBe('🔥');
-
-      await commentState.removeReaction('cmt_1', '🔥');
-      expect(commentState.data[0].reactions).toBeUndefined();
-
-      await commentState.deleteComment('cmt_1');
-      expect(commentState.data).toEqual([]);
-    });
-  });
-
-  describe('AttachmentState', () => {
-    it('fetches, creates, and deletes attachments', async () => {
-      const mockAttachment = {
-        id: 'att_1',
-        filename: 'spec.pdf',
-        mimeType: 'application/pdf',
-        sizeBytes: 1024,
-        url: 'https://storage.example.com/spec.pdf',
-        uploaderId: 'u1',
-        uploaderType: 'user' as const,
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-
-      const mockClient = {
-        getAttachments: vi.fn().mockResolvedValue([mockAttachment]),
-        createAttachment: vi.fn().mockResolvedValue(mockAttachment),
-        deleteAttachment: vi.fn().mockResolvedValue(true)
-      } as unknown as CriticalPathClient;
-
-      const attachmentState = new AttachmentState(mockClient, { taskId: 'task_1' });
-      await attachmentState.fetch();
-
-      expect(attachmentState.data).toEqual([mockAttachment]);
-
-      await attachmentState.deleteAttachment('att_1');
-      expect(attachmentState.data).toEqual([]);
-    });
-
-    it('rolls back optimistic deletion if deleteAttachment fails', async () => {
-      const mockAttachment = {
-        id: 'att_2',
-        filename: 'notes.txt',
-        mimeType: 'text/plain',
-        sizeBytes: 100,
-        url: 'https://storage.example.com/notes.txt',
-        uploaderId: 'u1',
-        uploaderType: 'user' as const,
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-
-      const mockClient = {
-        getAttachments: vi.fn().mockResolvedValue([mockAttachment]),
-        deleteAttachment: vi.fn().mockRejectedValue(new Error('Network error'))
-      } as unknown as CriticalPathClient;
-
-      const attachmentState = new AttachmentState(mockClient, { taskId: 'task_1' });
-      await attachmentState.fetch();
-
-      expect(attachmentState.data).toHaveLength(1);
-      await expect(attachmentState.deleteAttachment('att_2')).rejects.toThrow('Network error');
-      expect(attachmentState.data).toEqual([mockAttachment]);
-    });
-  });
-
-  describe('TaskActivityState', () => {
-    it('fetches comments and attachments and unifies them into threads with attachments', async () => {
-      const mockComment: Comment = {
-        id: 'cmt_1',
-        taskId: 'task_1',
-        content: 'Comment with attachment',
-        authorId: 'u1',
-        authorType: 'user',
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-
-      const mockAttachment: Attachment = {
-        id: 'att_1',
-        taskId: 'task_1',
-        commentId: 'cmt_1',
-        filename: 'screenshot.png',
-        mimeType: 'image/png',
-        sizeBytes: 2048,
-        url: 'https://storage.example.com/screenshot.png',
-        uploaderId: 'u1',
-        uploaderType: 'user',
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-
-      const mockClient = {
-        getComments: vi.fn().mockResolvedValue([mockComment]),
-        getAttachments: vi.fn().mockResolvedValue([mockAttachment]),
-        addComment: vi.fn().mockResolvedValue(mockComment),
-        createAttachment: vi.fn().mockResolvedValue(mockAttachment),
-        deleteComment: vi.fn().mockResolvedValue(true),
-        deleteAttachment: vi.fn().mockResolvedValue(true)
-      } as unknown as CriticalPathClient;
-
-      const activityState = createTaskActivityState(mockClient, 'task_1');
-      await activityState.fetch();
-
-      expect(activityState.comments).toEqual([mockComment]);
-      expect(activityState.attachments).toEqual([mockAttachment]);
-      expect(activityState.threads).toHaveLength(1);
-      expect(activityState.threads[0].attachments).toEqual([mockAttachment]);
-      expect(activityState.standaloneAttachments).toHaveLength(0);
-
-      await activityState.deleteAttachment('att_1');
-      expect(activityState.attachments).toEqual([]);
-      expect(activityState.threads[0].attachments).toEqual([]);
-    });
-  });
-
-  describe('DeliverableState', () => {
-    it('fetches, creates, updates, and deletes deliverables and gets summary', async () => {
-      const mockDeliverable: Deliverable = {
-        id: 'deliv_1',
-        projectId: 'proj_1',
-        title: 'Commercial Cut 30s',
-        status: 'planned',
-        outputUrls: [],
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-
-      const mockSummary: DeliverableSummary = {
-        deliverable: mockDeliverable,
-        totalTasks: 2,
-        completedTasks: 1,
-        activeTasks: 1,
-        progressPercentage: 50,
-        estimatedHours: 10,
-        loggedHours: 5
-      };
-
-      const mockClient = {
-        getDeliverables: vi.fn().mockResolvedValue([mockDeliverable]),
-        createDeliverable: vi.fn().mockResolvedValue(mockDeliverable),
-        updateDeliverable: vi.fn().mockResolvedValue({ ...mockDeliverable, status: 'delivered' }),
-        deleteDeliverable: vi.fn().mockResolvedValue(true),
-        getDeliverableSummary: vi.fn().mockResolvedValue(mockSummary)
-      } as unknown as CriticalPathClient;
-
-      const state = createDeliverableState(mockClient, 'proj_1');
-      await state.fetch();
-      expect(state.data).toEqual([mockDeliverable]);
-
-      const created = await state.createDeliverable({
-        projectId: 'proj_1',
-        title: 'Commercial Cut 30s'
-      });
-      expect(created).toEqual(mockDeliverable);
-
-      const updated = await state.updateDeliverable('deliv_1', { status: 'delivered' });
-      expect(updated.status).toBe('delivered');
-
-      const summary = await state.getSummary('deliv_1');
-      expect(summary.totalTasks).toBe(2);
-      expect(summary.progressPercentage).toBe(50);
-
-      await state.deleteDeliverable('deliv_1');
-      expect(state.data).toEqual([]);
-    });
-  });
-
-  describe('WebMcpState', () => {
-    it('manages WebMCP registration, project scoping, and unregistration', async () => {
-      const mockDoc: any = {};
-      const mockWin: any = {};
-
-      const mockClient = {
-        getTasks: vi.fn().mockResolvedValue([]),
-        createTask: vi.fn().mockImplementation((input) => Promise.resolve({ id: 't1', ...input }))
-      } as unknown as CriticalPathClient;
-
-      const mcpState = createWebMcpState(mockClient, {
-        projectId: 'proj_svelte',
-        document: mockDoc,
-        window: mockWin
-      });
-
-      expect(mcpState.registered).toBe(true);
-      expect(mcpState.activeProjectId).toBe('proj_svelte');
-      expect(mcpState.tools.length).toBeGreaterThan(0);
-      expect(mockDoc.modelContext).toBeDefined();
-
-      // Execute tool via modelContext
-      const created = await mockDoc.modelContext.executeTool('create_task', {
-        title: 'Svelte 5 Task'
-      });
-      expect(created.projectId).toBe('proj_svelte');
-      expect(created.title).toBe('Svelte 5 Task');
-
-      // Update project ID dynamically
-      mcpState.setProjectId('proj_svelte_2');
-      expect(mcpState.activeProjectId).toBe('proj_svelte_2');
-      expect(mcpState.registered).toBe(true);
-
-      const created2 = await mockDoc.modelContext.executeTool('create_task', {
-        title: 'Svelte 5 Task 2'
-      });
-      expect(created2.projectId).toBe('proj_svelte_2');
-
-      // Unregister
-      mcpState.unregister();
-      expect(mcpState.registered).toBe(false);
-      expect(mcpState.tools).toEqual([]);
-    });
-  });
-
-  describe('KanbanState', () => {
-    it('initializes and buckets tasks into workflow and semantic columns', async () => {
-      const mockTasks: Task[] = [
-        {
-          id: 't_todo',
-          projectId: 'p1',
-          title: 'To Do Task',
-          status: 'todo',
-          priority: 'high',
-          createdAt: '2026-01-01',
-          updatedAt: '2026-01-01'
-        },
-        {
-          id: 't_done',
-          projectId: 'p1',
-          title: 'Done Task',
-          status: 'done',
-          priority: 'low',
-          createdAt: '2026-01-01',
-          updatedAt: '2026-01-01'
-        }
-      ];
-
-      const mockClient = {
-        getTasks: vi.fn().mockResolvedValue(mockTasks),
-        updateTask: vi.fn().mockImplementation((id, updates) => Promise.resolve({ ...mockTasks.find((t) => t.id === id), ...updates }))
-      } as unknown as CriticalPathClient;
-
-      // Workflow grouping
-      const kanban = createKanbanState(mockClient, 'p1');
-      await kanban.fetch();
-
-      expect(kanban.columns.todo).toHaveLength(1);
-      expect(kanban.columns.done).toHaveLength(1);
-      expect(kanban.columns.in_progress).toHaveLength(0);
-
-      // Move task
-      const updated = await kanban.moveTask('t_todo', 'in_progress');
-      expect(updated.status).toBe('in_progress');
-
-      // Semantic grouping
-      const semanticKanban = createKanbanState(mockClient, 'p1', { groupBy: 'semantic' });
-      await semanticKanban.fetch();
-      expect(semanticKanban.columns.not_started).toHaveLength(1);
-      expect(semanticKanban.columns.completed).toHaveLength(1);
-    });
-  });
-
-  describe('TaskTransitionsState', () => {
-    it('fetches allowed transitions for a task', async () => {
-      const mockClient = {
-        getAllowedTaskTransitions: vi.fn().mockResolvedValue(['in_progress', 'canceled'])
-      } as unknown as CriticalPathClient;
-
-      const transitionsState = createTaskTransitionsState(mockClient, 'task_123');
-      expect(transitionsState.allowedTransitions).toEqual([]);
-
-      await transitionsState.fetch();
-      expect(mockClient.getAllowedTaskTransitions).toHaveBeenCalledWith('task_123');
-      expect(transitionsState.allowedTransitions).toEqual(['in_progress', 'canceled']);
-    });
-  });
-
-  describe('DeliverableSummaryState', () => {
-    it('fetches deliverable summary reactively', async () => {
-      const mockDeliverable: Deliverable = {
-        id: 'deliv_1',
-        projectId: 'proj_1',
-        title: 'MVP Launch',
-        status: 'planned',
-        createdAt: '2026-01-01',
-        updatedAt: '2026-01-01'
-      };
-
-      const mockSummary: DeliverableSummary = {
-        deliverable: mockDeliverable,
-        totalTasks: 4,
-        completedTasks: 3,
-        activeTasks: 1,
-        progressPercentage: 75,
-        estimatedHours: 40,
-        loggedHours: 30
-      };
-
-      const mockClient = {
-        getDeliverableSummary: vi.fn().mockResolvedValue(mockSummary)
-      } as unknown as CriticalPathClient;
-
-      const summaryState = createDeliverableSummaryState(mockClient, 'deliv_1');
-      expect(summaryState.summary).toBeNull();
-      expect(summaryState.data).toBeNull();
-
-      await summaryState.fetch();
-      expect(mockClient.getDeliverableSummary).toHaveBeenCalledWith('deliv_1');
-      expect(summaryState.summary).toEqual(mockSummary);
-      expect(summaryState.data).toEqual(mockSummary);
-    });
-  });
-
-  describe('CriticalPathState', () => {
-    it('manages loading, error, and critical path analysis data', async () => {
-      const mockAnalysis: CriticalPathAnalysis = {
-        projectId: 'proj_cpm',
-        calculatedAt: '2026-09-11T12:00:00Z',
-        totalDurationHours: 42,
-        criticalTaskIds: ['t1', 't2'],
-        tasks: []
-      };
-
-      const mockClient = {
-        calculateCriticalPath: vi.fn().mockResolvedValue(mockAnalysis)
-      } as unknown as CriticalPathClient;
-
-      const cpmState = createCriticalPathState(mockClient, 'proj_cpm');
-      expect(cpmState.data).toBeNull();
-      expect(cpmState.loading).toBe(false);
-
-      await cpmState.fetch();
-      expect(mockClient.calculateCriticalPath).toHaveBeenCalledWith('proj_cpm');
-      expect(cpmState.data).toEqual(mockAnalysis);
-      expect(cpmState.loading).toBe(false);
-    });
-  });
-
-  describe('TimelineLadderState', () => {
-    it('manages multi-scale ladder data, levels, and derived rungs', async () => {
-      const mockLadder: TimelineLadder = {
-        projectId: 'proj_ladder',
-        generatedAt: '2026-09-11T12:00:00Z',
-        level: 'all',
-        macro: {
-          projectId: 'proj_ladder',
-          projectName: 'Ladder Proj',
-          totalDurationHours: 50,
-          criticalPathDurationHours: 40,
-          overallProgressPercentage: 60,
-          health: 'on_track',
-          totalTasks: 5,
-          completedTasks: 3,
-          inProgressTasks: 2,
-          blockedTasks: 0,
-          totalEstimatedHours: 50,
-          totalLoggedHours: 25,
-          phases: []
-        },
-        standard: {
-          tasks: [],
-          criticalPathTaskIds: [],
-          dependencies: [],
-          totalDurationHours: 40
-        },
-        concrete: {}
-      };
-
-      const mockClient = {
-        getTimelineLadder: vi.fn().mockResolvedValue(mockLadder)
-      } as unknown as CriticalPathClient;
-
-      const ladderState = createTimelineLadderState(mockClient, 'proj_ladder', { level: 'all' });
-      expect(ladderState.data).toBeNull();
-      expect(ladderState.macro).toBeNull();
-      expect(ladderState.standard).toBeNull();
-      expect(ladderState.concrete).toBeNull();
-
-      await ladderState.fetch();
-      expect(mockClient.getTimelineLadder).toHaveBeenCalledWith('proj_ladder', { level: 'all' });
-      expect(ladderState.data).toEqual(mockLadder);
-      expect(ladderState.macro?.projectName).toBe('Ladder Proj');
-      expect(ladderState.standard?.tasks).toEqual([]);
-      expect(ladderState.concrete).toEqual({});
-
-      await ladderState.setLevel('macro');
-      expect(ladderState.level).toBe('macro');
-      expect(mockClient.getTimelineLadder).toHaveBeenCalledWith('proj_ladder', { level: 'macro' });
-    });
-  });
-
-  describe('TaskMetricsState', () => {
-    it('fetches metrics and progress history and derives subfields', async () => {
-      const mockMetrics = {
-        taskId: 'task_1',
-        inferredActuals: {
-          actualStartDate: '2026-09-01T00:00:00Z',
-          actualEndDate: '2026-09-05T00:00:00Z',
-          isStartDateInferred: false,
-          isEndDateInferred: true,
-          activeWorkingHours: 96
-        },
-        realityDelta: {
-          estimatedHours: 20,
-          loggedHours: 15,
-          varianceHours: -5,
-          effortVarianceHours: -5,
-          accuracyRatio: 0.75,
-          isOverdue: false,
-          isOverEstimate: false
-        },
-        progress: {
-          progressPercentage: 75,
-          source: 'explicit' as const,
-          isExplicit: true,
-          breakdown: { explicitProgress: 75 }
-        },
-        evm: {
-          plannedValue: 20,
-          earnedValue: 15,
-          actualCost: 15,
-          costVariance: 0,
-          scheduleVariance: -5,
-          costPerformanceIndex: 1.0,
-          schedulePerformanceIndex: 0.75
-        }
-      };
-
-      const mockHistory = {
-        taskId: 'task_1',
-        points: [
-          { timestamp: '2026-09-01T00:00:00Z', progress: 0, status: 'todo', semanticStatus: 'not_started' as const, action: 'task.created' },
-          { timestamp: '2026-09-05T00:00:00Z', progress: 75, status: 'in_progress', semanticStatus: 'in_progress' as const, action: 'task.updated' }
-        ],
-        curveProfile: 'linear' as const
-      };
-
-      const mockClient = {
-        getTaskMetrics: vi.fn().mockResolvedValue(mockMetrics),
-        getTaskProgressHistory: vi.fn().mockResolvedValue(mockHistory)
-      } as unknown as CriticalPathClient;
-
-      const state = createTaskMetricsState(mockClient, 'task_1');
-      expect(state.metrics).toBeNull();
-      expect(state.history).toBeNull();
-      expect(state.inferredActuals).toBeNull();
-      expect(state.realityDelta).toBeNull();
-      expect(state.progress).toBeNull();
-      expect(state.evm).toBeNull();
-      expect(state.curveProfile).toBeNull();
-
-      await state.fetchAll();
-      expect(mockClient.getTaskMetrics).toHaveBeenCalledWith('task_1');
-      expect(mockClient.getTaskProgressHistory).toHaveBeenCalledWith('task_1');
-      expect(state.metrics).toEqual(mockMetrics);
-      expect(state.history).toEqual(mockHistory);
-      expect(state.inferredActuals?.activeWorkingHours).toBe(96);
-      expect(state.realityDelta?.effortVarianceHours).toBe(-5);
-      expect(state.progress?.progressPercentage).toBe(75);
-      expect(state.evm?.costPerformanceIndex).toBe(1.0);
-      expect(state.curveProfile).toBe('linear');
-    });
-  });
-
-  describe('WorkloadState & createWorkloadState', () => {
-    it('initializes with default options and fetches workload distribution', async () => {
-      const mockDistribution: WorkloadDistribution = {
-        projectId: 'proj_wl',
-        startDate: '2026-09-01',
-        endDate: '2026-09-14',
-        interval: 'week',
-        groupBy: 'assignee',
-        metric: 'blended',
-        seriesKeys: ['u1', 'u2'],
-        seriesLabels: { u1: 'Alice', u2: 'Bob' },
-        buckets: [
-          {
-            date: '2026-09-01',
-            timestamp: 1788220800000,
-            totalHours: 40,
-            values: { u1: 25, u2: 15 },
-            capacity: { u1: 35, u2: 40 },
-            totalCapacity: 75,
-            utilizationRatio: 0.533
-          }
-        ],
-        totalHours: 40,
-        totalCapacity: 75,
-        averageUtilization: 0.533
-      };
-
-      const mockClient = {
-        getWorkloadDistribution: vi.fn().mockResolvedValue(mockDistribution)
-      } as unknown as CriticalPathClient;
-
-      const state = createWorkloadState(mockClient, 'proj_wl', {
-        interval: 'week',
-        groupBy: 'assignee',
-        metric: 'blended'
-      });
-
-      expect(state.data).toBeNull();
-      expect(state.buckets).toEqual([]);
-      expect(state.seriesKeys).toEqual([]);
-      expect(state.totalHours).toBe(0);
-
-      await state.fetch();
-
-      expect(mockClient.getWorkloadDistribution).toHaveBeenCalledWith('proj_wl', {
-        interval: 'week',
-        groupBy: 'assignee',
-        metric: 'blended'
-      });
-      expect(state.data).toEqual(mockDistribution);
-      expect(state.buckets).toHaveLength(1);
-      expect(state.seriesKeys).toEqual(['u1', 'u2']);
-      expect(state.totalHours).toBe(40);
-      expect(state.totalCapacity).toBe(75);
-      expect(state.averageUtilization).toBe(0.533);
-    });
-
-    it('updates interval and re-fetches', async () => {
-      const mockClient = {
-        getWorkloadDistribution: vi.fn().mockResolvedValue({
-          buckets: [],
-          seriesKeys: [],
-          seriesLabels: {},
-          totalHours: 0,
-          totalCapacity: 0
-        })
-      } as unknown as CriticalPathClient;
-
-      const state = new WorkloadState(mockClient, 'proj_wl');
-      expect(state.interval).toBe('week');
-
-      await state.setInterval('day');
-      expect(state.interval).toBe('day');
-      expect(mockClient.getWorkloadDistribution).toHaveBeenCalledWith(
-        'proj_wl',
-        expect.objectContaining({ interval: 'day' })
-      );
-    });
-  });
-});
-
-
-