@critical-path/svelte 0.10.2 → 0.12.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/webmcp-state.svelte.d.ts

@@ -0,0 +1,26 @@
+import type { CriticalPathClient } from '@critical-path/client';
+export interface WebMcpStateOptions {
+    projectId?: string;
+    tools?: string[];
+    autoRegister?: boolean;
+    document?: any;
+    navigator?: any;
+    window?: any;
+    onToolExecuted?: (toolName: string, input: any, result: any) => void;
+}
+export declare class WebMcpState {
+    private client;
+    private options;
+    registered: boolean;
+    activeProjectId: string | undefined;
+    tools: string[];
+    error: Error | null;
+    private handle;
+    private abortController;
+    constructor(client: CriticalPathClient, options?: WebMcpStateOptions);
+    register(): void;
+    unregister(): void;
+    setProjectId(projectId?: string): void;
+}
+export declare function createWebMcpState(client: CriticalPathClient, options?: WebMcpStateOptions): WebMcpState;
+//# sourceMappingURL=webmcp-state.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webmcp-state.svelte.d.ts","sourceRoot":"","sources":["../src/webmcp-state.svelte.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAGhE,MAAM,WAAW,kBAAkB;IACjC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,GAAG,CAAC;IACf,SAAS,CAAC,EAAE,GAAG,CAAC;IAChB,MAAM,CAAC,EAAE,GAAG,CAAC;IACb,cAAc,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,IAAI,CAAC;CACtE;AAED,qBAAa,WAAW;IASV,OAAO,CAAC,MAAM;IAAsB,OAAO,CAAC,OAAO;IAR/D,UAAU,UAA0B;IACpC,eAAe,qBAAyC;IACxD,KAAK,WAAwB;IAC7B,KAAK,eAA8B;IAEnC,OAAO,CAAC,MAAM,CAAqC;IACnD,OAAO,CAAC,eAAe,CAAgC;gBAEnC,MAAM,EAAE,kBAAkB,EAAU,OAAO,GAAE,kBAAuB;IAOxF,QAAQ,IAAI,IAAI;IA0BhB,UAAU,IAAI,IAAI;IAUlB,YAAY,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI;CAQvC;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,kBAAkB,GAAG,WAAW,CAEvG"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@critical-path/svelte",
-  "version": "0.10.2",
+  "version": "0.12.0",
   "description": "Svelte 5 Runes state and reactive integrations for Critical Path headless project management framework",
   "author": "Jack James",
   "license": "MIT",
@@ -19,7 +19,8 @@
   },
   "dependencies": {
     "@critical-path/client": "0.9.2",
-    "@critical-path/core": "0.15.2"
+    "@critical-path/core": "0.15.2",
+    "@critical-path/mcp": "0.2.0"
   },
   "peerDependencies": {
     "svelte": "^5.0.0"

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

@@ -14,7 +14,15 @@ import {
   TaskActivityState,
   createTaskActivityState,
   DeliverableState,
-  createDeliverableState
+  createDeliverableState,
+  DeliverableSummaryState,
+  createDeliverableSummaryState,
+  KanbanState,
+  createKanbanState,
+  TaskTransitionsState,
+  createTaskTransitionsState,
+  WebMcpState,
+  createWebMcpState
 } from './index.js';
 import type { CriticalPathClient } from '@critical-path/client';
 import type { Project, Task, Workflow, Comment, Attachment, Deliverable, DeliverableSummary } from '@critical-path/core';
@@ -29,6 +37,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();
@@ -36,6 +47,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', () => {
@@ -408,5 +424,151 @@ describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
       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);
+    });
+  });
 });
 
+
+

package/src/index.ts

@@ -11,4 +11,9 @@ 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';
+
 

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/webmcp-state.svelte.ts

@@ -0,0 +1,78 @@
+import type { CriticalPathClient } from '@critical-path/client';
+import { registerWebMcpTools, type WebMcpRegistryHandle } from '@critical-path/mcp/web';
+
+export interface WebMcpStateOptions {
+  projectId?: string;
+  tools?: string[];
+  autoRegister?: boolean;
+  document?: any;
+  navigator?: any;
+  window?: any;
+  onToolExecuted?: (toolName: string, input: any, result: any) => void;
+}
+
+export class WebMcpState {
+  registered = $state<boolean>(false);
+  activeProjectId = $state<string | undefined>(undefined);
+  tools = $state<string[]>([]);
+  error = $state<Error | null>(null);
+
+  private handle: WebMcpRegistryHandle | null = null;
+  private abortController: AbortController | null = null;
+
+  constructor(private client: CriticalPathClient, private options: WebMcpStateOptions = {}) {
+    this.activeProjectId = options.projectId;
+    if (options.autoRegister ?? true) {
+      this.register();
+    }
+  }
+
+  register(): void {
+    if (this.registered) return;
+    this.error = null;
+
+    try {
+      this.abortController = new AbortController();
+      this.handle = registerWebMcpTools({
+        client: this.client,
+        projectId: this.activeProjectId,
+        tools: this.options.tools,
+        signal: this.abortController.signal,
+        document: this.options.document,
+        navigator: this.options.navigator,
+        window: this.options.window,
+        onToolExecuted: (name, input, result) => {
+          this.options.onToolExecuted?.(name, input, result);
+        }
+      });
+      this.tools = this.handle.getRegisteredTools().map((t) => t.name);
+      this.registered = true;
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+      this.registered = false;
+    }
+  }
+
+  unregister(): void {
+    if (!this.registered) return;
+    this.abortController?.abort();
+    this.handle?.unregister();
+    this.handle = null;
+    this.abortController = null;
+    this.registered = false;
+    this.tools = [];
+  }
+
+  setProjectId(projectId?: string): void {
+    if (this.activeProjectId === projectId) return;
+    this.activeProjectId = projectId;
+    if (this.registered) {
+      this.unregister();
+      this.register();
+    }
+  }
+}
+
+export function createWebMcpState(client: CriticalPathClient, options?: WebMcpStateOptions): WebMcpState {
+  return new WebMcpState(client, options);
+}