@critical-path/svelte 0.11.0 → 0.13.0

package/dist/kanban-state.svelte.d.ts

@@ -0,0 +1,24 @@
+import type { CriticalPathClient } from '@critical-path/client';
+import type { Task, TaskStatus, StatusDefinition } from '@critical-path/core';
+export interface KanbanStateOptions {
+    groupBy?: 'workflow' | 'semantic';
+    customDefinitions?: StatusDefinition[];
+}
+export declare class KanbanState {
+    projectId?: string | undefined;
+    options: KanbanStateOptions;
+    private taskState;
+    get data(): Task[];
+    get tasks(): Task[];
+    get loading(): boolean;
+    get error(): Error | null;
+    columns: Record<string, Task[]>;
+    constructor(client: CriticalPathClient, projectId?: string | undefined, options?: KanbanStateOptions);
+    fetch(): Promise<void>;
+    createTask(input: Omit<Task, 'id' | 'createdAt' | 'updatedAt'>): Promise<Task>;
+    moveTask(taskId: string, targetStatus: TaskStatus): Promise<Task>;
+    updateTaskStatus(taskId: string, status: TaskStatus): Promise<Task>;
+    deleteTask(taskId: string): Promise<boolean | undefined>;
+}
+export declare function createKanbanState(client: CriticalPathClient, projectId?: string, options?: KanbanStateOptions): KanbanState;
+//# sourceMappingURL=kanban-state.svelte.d.ts.map

package/dist/kanban-state.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kanban-state.svelte.d.ts","sourceRoot":"","sources":["../src/kanban-state.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,IAAI,EAAE,UAAU,EAAE,gBAAgB,EAAkB,MAAM,qBAAqB,CAAC;AAI9F,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IAClC,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAC;CACxC;AAED,qBAAa,WAAW;IAmEb,SAAS,CAAC,EAAE,MAAM;IAClB,OAAO,EAAE,kBAAkB;IAnEpC,OAAO,CAAC,SAAS,CAAY;IAE7B,IAAI,IAAI,IAAI,IAAI,EAAE,CAEjB;IAED,IAAI,KAAK,IAAI,IAAI,EAAE,CAElB;IAED,IAAI,OAAO,IAAI,OAAO,CAErB;IAED,IAAI,KAAK,IAAI,KAAK,GAAG,IAAI,CAExB;IAED,OAAO,yBA4CJ;gBAGD,MAAM,EAAE,kBAAkB,EACnB,SAAS,CAAC,EAAE,MAAM,YAAA,EAClB,OAAO,GAAE,kBAAuB;IAKnC,KAAK;IAIL,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,EAAE,IAAI,GAAG,WAAW,GAAG,WAAW,CAAC;IAI9D,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU;IAIjD,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU;IAInD,UAAU,CAAC,MAAM,EAAE,MAAM;CAGhC;AAED,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,kBAAkB,EAC1B,SAAS,CAAC,EAAE,MAAM,EAClB,OAAO,CAAC,EAAE,kBAAkB,GAC3B,WAAW,CAEb"}

package/dist/task-transitions-state.svelte.d.ts

@@ -0,0 +1,12 @@
+import type { CriticalPathClient } from '@critical-path/client';
+export declare class TaskTransitionsState {
+    private client;
+    taskId?: string | undefined;
+    allowedTransitions: string[];
+    loading: boolean;
+    error: Error | null;
+    constructor(client: CriticalPathClient, taskId?: string | undefined);
+    fetch(taskId?: string): Promise<void>;
+}
+export declare function createTaskTransitionsState(client: CriticalPathClient, taskId?: string): TaskTransitionsState;
+//# sourceMappingURL=task-transitions-state.svelte.d.ts.map

package/dist/task-transitions-state.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-transitions-state.svelte.d.ts","sourceRoot":"","sources":["../src/task-transitions-state.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE,qBAAa,oBAAoB;IAKnB,OAAO,CAAC,MAAM;IAA6B,MAAM,CAAC,EAAE,MAAM;IAJtE,kBAAkB,WAAwB;IAC1C,OAAO,UAA0B;IACjC,KAAK,eAA8B;gBAEf,MAAM,EAAE,kBAAkB,EAAS,MAAM,CAAC,EAAE,MAAM,YAAA;IAEhE,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM;CAkB5B;AAED,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,kBAAkB,EAC1B,MAAM,CAAC,EAAE,MAAM,GACd,oBAAoB,CAEtB"}

package/dist/timeline-ladder-state.svelte.d.ts

@@ -0,0 +1,23 @@
+import type { CriticalPathClient } from '@critical-path/client';
+import type { TimelineLadder, TimelineLadderOptions, AbstractionLevel, MacroTimelineSummary, ConcreteTaskEvidence } from '@critical-path/core';
+export declare class TimelineLadderState {
+    private client;
+    projectId: string;
+    data: TimelineLadder | null;
+    level: AbstractionLevel;
+    loading: boolean;
+    error: Error | null;
+    macro: MacroTimelineSummary | null;
+    standard: {
+        tasks: import("@critical-path/client").StandardTaskTimelineItem[];
+        criticalPathTaskIds: string[];
+        dependencies: import("@critical-path/core").TaskDependency[];
+        totalDurationHours: number;
+    } | null | undefined;
+    concrete: Record<string, ConcreteTaskEvidence> | null;
+    constructor(client: CriticalPathClient, projectId: string, initialOptions?: TimelineLadderOptions);
+    setLevel(newLevel: AbstractionLevel): Promise<void>;
+    fetch(options?: TimelineLadderOptions): Promise<void>;
+}
+export declare function createTimelineLadderState(client: CriticalPathClient, projectId: string, initialOptions?: TimelineLadderOptions): TimelineLadderState;
+//# sourceMappingURL=timeline-ladder-state.svelte.d.ts.map

package/dist/timeline-ladder-state.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"timeline-ladder-state.svelte.d.ts","sourceRoot":"","sources":["../src/timeline-ladder-state.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EACV,cAAc,EACd,qBAAqB,EACrB,gBAAgB,EAChB,oBAAoB,EACpB,oBAAoB,EACrB,MAAM,qBAAqB,CAAC;AAE7B,qBAAa,mBAAmB;IAW5B,OAAO,CAAC,MAAM;IACP,SAAS,EAAE,MAAM;IAX1B,IAAI,wBAAuC;IAC3C,KAAK,mBAAmC;IACxC,OAAO,UAA0B;IACjC,KAAK,eAA8B;IAEnC,KAAK,8BAAmE;IACxE,QAAQ;;;;;yBAA4E;IACpF,QAAQ,8CAAsF;gBAGpF,MAAM,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,EACxB,cAAc,CAAC,EAAE,qBAAqB;IAOlC,QAAQ,CAAC,QAAQ,EAAE,gBAAgB;IAKnC,KAAK,CAAC,OAAO,CAAC,EAAE,qBAAqB;CAc5C;AAED,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,kBAAkB,EAC1B,SAAS,EAAE,MAAM,EACjB,cAAc,CAAC,EAAE,qBAAqB,GACrC,mBAAmB,CAErB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@critical-path/svelte",
-  "version": "0.11.0",
+  "version": "0.13.0",
   "description": "Svelte 5 Runes state and reactive integrations for Critical Path headless project management framework",
   "author": "Jack James",
   "license": "MIT",
@@ -18,9 +18,9 @@
     }
   },
   "dependencies": {
-    "@critical-path/core": "0.15.2",
-    "@critical-path/client": "0.9.2",
-    "@critical-path/mcp": "0.2.0"
+    "@critical-path/mcp": "0.3.0",
+    "@critical-path/client": "0.10.0",
+    "@critical-path/core": "0.16.0"
   },
   "peerDependencies": {
     "svelte": "^5.0.0"

package/src/critical-path-state.svelte.ts

@@ -0,0 +1,33 @@
+/// <reference types="svelte" />
+import type { CriticalPathClient } from '@critical-path/client';
+import type { CriticalPathAnalysis } from '@critical-path/core';
+
+export class CriticalPathState {
+  data = $state<CriticalPathAnalysis | null>(null);
+  loading = $state<boolean>(false);
+  error = $state<Error | null>(null);
+
+  constructor(
+    private client: CriticalPathClient,
+    public projectId: string
+  ) {}
+
+  async fetch() {
+    this.loading = true;
+    this.error = null;
+    try {
+      this.data = await this.client.calculateCriticalPath(this.projectId);
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      this.loading = false;
+    }
+  }
+}
+
+export function createCriticalPathState(
+  client: CriticalPathClient,
+  projectId: string
+): CriticalPathState {
+  return new CriticalPathState(client, projectId);
+}

package/src/deliverable-summary-state.svelte.ts

@@ -0,0 +1,41 @@
+/// <reference types="svelte" />
+import type { CriticalPathClient } from '@critical-path/client';
+import type { DeliverableSummary } from '@critical-path/core';
+
+export class DeliverableSummaryState {
+  summary = $state<DeliverableSummary | null>(null);
+  loading = $state<boolean>(false);
+  error = $state<Error | null>(null);
+
+  get data(): DeliverableSummary | null {
+    return this.summary;
+  }
+
+  constructor(private client: CriticalPathClient, public deliverableId?: string) {}
+
+  async fetch(deliverableId?: string) {
+    const targetId = deliverableId || this.deliverableId;
+    if (!targetId) {
+      this.summary = null;
+      this.loading = false;
+      return;
+    }
+    this.deliverableId = targetId;
+    this.loading = true;
+    this.error = null;
+    try {
+      this.summary = await this.client.getDeliverableSummary(targetId);
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      this.loading = false;
+    }
+  }
+}
+
+export function createDeliverableSummaryState(
+  client: CriticalPathClient,
+  deliverableId?: string
+): DeliverableSummaryState {
+  return new DeliverableSummaryState(client, deliverableId);
+}

package/src/index.test.ts

@@ -15,11 +15,31 @@ import {
   createTaskActivityState,
   DeliverableState,
   createDeliverableState,
+  DeliverableSummaryState,
+  createDeliverableSummaryState,
+  KanbanState,
+  createKanbanState,
+  TaskTransitionsState,
+  createTaskTransitionsState,
   WebMcpState,
-  createWebMcpState
+  createWebMcpState,
+  CriticalPathState,
+  createCriticalPathState,
+  TimelineLadderState,
+  createTimelineLadderState
 } from './index.js';
 import type { CriticalPathClient } from '@critical-path/client';
-import type { Project, Task, Workflow, Comment, Attachment, Deliverable, DeliverableSummary } from '@critical-path/core';
+import type {
+  Project,
+  Task,
+  Workflow,
+  Comment,
+  Attachment,
+  Deliverable,
+  DeliverableSummary,
+  CriticalPathAnalysis,
+  TimelineLadder
+} from '@critical-path/core';
 
 describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
   it('exports client factory and Svelte 5 Runes state factories', () => {
@@ -31,6 +51,9 @@ describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
     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();
@@ -38,6 +61,11 @@ describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
     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', () => {
@@ -455,6 +483,184 @@ describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
       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' });
+    });
+  });
 });
 
 
+

package/src/index.ts

@@ -11,5 +11,11 @@ export * from './comment-state.svelte.js';
 export * from './attachment-state.svelte.js';
 export * from './activity-state.svelte.js';
 export * from './deliverable-state.svelte.js';
+export * from './deliverable-summary-state.svelte.js';
+export * from './kanban-state.svelte.js';
+export * from './task-transitions-state.svelte.js';
 export * from './webmcp-state.svelte.js';
+export * from './critical-path-state.svelte.js';
+export * from './timeline-ladder-state.svelte.js';
+
 

package/src/kanban-state.svelte.ts

@@ -0,0 +1,112 @@
+/// <reference types="svelte" />
+import type { CriticalPathClient } from '@critical-path/client';
+import type { Task, TaskStatus, StatusDefinition, SemanticStatus } from '@critical-path/core';
+import { resolveStatusDefinition } from '@critical-path/core';
+import { TaskState } from './task-state.svelte.js';
+
+export interface KanbanStateOptions {
+  groupBy?: 'workflow' | 'semantic';
+  customDefinitions?: StatusDefinition[];
+}
+
+export class KanbanState {
+  private taskState: TaskState;
+
+  get data(): Task[] {
+    return this.taskState.data;
+  }
+
+  get tasks(): Task[] {
+    return this.taskState.data;
+  }
+
+  get loading(): boolean {
+    return this.taskState.loading;
+  }
+
+  get error(): Error | null {
+    return this.taskState.error;
+  }
+
+  columns = $derived.by<Record<string, Task[]>>(() => {
+    const tasks = this.taskState.data;
+    if (this.options?.groupBy === 'semantic') {
+      const semanticCols: Record<SemanticStatus, Task[]> = {
+        not_started: [],
+        in_progress: [],
+        completed: [],
+        canceled: []
+      };
+      for (const task of tasks) {
+        const category =
+          task.semanticStatus ||
+          resolveStatusDefinition(task.status, this.options?.customDefinitions).category;
+        if (semanticCols[category]) {
+          semanticCols[category].push(task);
+        } else {
+          semanticCols.not_started.push(task);
+        }
+      }
+      return semanticCols;
+    }
+
+    const workflowCols: Record<string, Task[]> = {};
+    if (this.options?.customDefinitions && this.options.customDefinitions.length > 0) {
+      for (const def of this.options.customDefinitions) {
+        workflowCols[def.key] = [];
+      }
+    } else {
+      workflowCols.backlog = [];
+      workflowCols.todo = [];
+      workflowCols.in_progress = [];
+      workflowCols.in_review = [];
+      workflowCols.done = [];
+      workflowCols.canceled = [];
+    }
+
+    for (const task of tasks) {
+      if (!workflowCols[task.status]) {
+        workflowCols[task.status] = [];
+      }
+      workflowCols[task.status].push(task);
+    }
+
+    return workflowCols;
+  });
+
+  constructor(
+    client: CriticalPathClient,
+    public projectId?: string,
+    public options: KanbanStateOptions = {}
+  ) {
+    this.taskState = new TaskState(client, projectId);
+  }
+
+  async fetch() {
+    return this.taskState.fetch();
+  }
+
+  async createTask(input: Omit<Task, 'id' | 'createdAt' | 'updatedAt'>) {
+    return this.taskState.createTask(input);
+  }
+
+  async moveTask(taskId: string, targetStatus: TaskStatus) {
+    return this.taskState.updateTaskStatus(taskId, targetStatus);
+  }
+
+  async updateTaskStatus(taskId: string, status: TaskStatus) {
+    return this.taskState.updateTaskStatus(taskId, status);
+  }
+
+  async deleteTask(taskId: string) {
+    return this.taskState.deleteTask(taskId);
+  }
+}
+
+export function createKanbanState(
+  client: CriticalPathClient,
+  projectId?: string,
+  options?: KanbanStateOptions
+): KanbanState {
+  return new KanbanState(client, projectId, options);
+}

package/src/task-transitions-state.svelte.ts

@@ -0,0 +1,36 @@
+/// <reference types="svelte" />
+import type { CriticalPathClient } from '@critical-path/client';
+
+export class TaskTransitionsState {
+  allowedTransitions = $state<string[]>([]);
+  loading = $state<boolean>(false);
+  error = $state<Error | null>(null);
+
+  constructor(private client: CriticalPathClient, public taskId?: string) {}
+
+  async fetch(taskId?: string) {
+    const targetTaskId = taskId || this.taskId;
+    if (!targetTaskId) {
+      this.allowedTransitions = [];
+      this.loading = false;
+      return;
+    }
+    this.taskId = targetTaskId;
+    this.loading = true;
+    this.error = null;
+    try {
+      this.allowedTransitions = await this.client.getAllowedTaskTransitions(targetTaskId);
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      this.loading = false;
+    }
+  }
+}
+
+export function createTaskTransitionsState(
+  client: CriticalPathClient,
+  taskId?: string
+): TaskTransitionsState {
+  return new TaskTransitionsState(client, taskId);
+}

package/src/timeline-ladder-state.svelte.ts

@@ -0,0 +1,58 @@
+/// <reference types="svelte" />
+import type { CriticalPathClient } from '@critical-path/client';
+import type {
+  TimelineLadder,
+  TimelineLadderOptions,
+  AbstractionLevel,
+  MacroTimelineSummary,
+  ConcreteTaskEvidence
+} from '@critical-path/core';
+
+export class TimelineLadderState {
+  data = $state<TimelineLadder | null>(null);
+  level = $state<AbstractionLevel>('all');
+  loading = $state<boolean>(false);
+  error = $state<Error | null>(null);
+
+  macro = $derived<MacroTimelineSummary | null>(this.data?.macro ?? null);
+  standard = $derived<TimelineLadder['standard'] | null>(this.data?.standard ?? null);
+  concrete = $derived<Record<string, ConcreteTaskEvidence> | null>(this.data?.concrete ?? null);
+
+  constructor(
+    private client: CriticalPathClient,
+    public projectId: string,
+    initialOptions?: TimelineLadderOptions
+  ) {
+    if (initialOptions?.level) {
+      this.level = initialOptions.level;
+    }
+  }
+
+  async setLevel(newLevel: AbstractionLevel) {
+    this.level = newLevel;
+    await this.fetch();
+  }
+
+  async fetch(options?: TimelineLadderOptions) {
+    this.loading = true;
+    this.error = null;
+    try {
+      this.data = await this.client.getTimelineLadder(this.projectId, {
+        level: this.level,
+        ...options
+      });
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      this.loading = false;
+    }
+  }
+}
+
+export function createTimelineLadderState(
+  client: CriticalPathClient,
+  projectId: string,
+  initialOptions?: TimelineLadderOptions
+): TimelineLadderState {
+  return new TimelineLadderState(client, projectId, initialOptions);
+}