@critical-path/svelte 0.3.4 → 0.5.0

package/CHANGELOG.md

@@ -1,5 +1,52 @@
 # @critical-path/svelte
 
+## 0.5.0
+
+### Minor Changes
+
+- 1811922: Add attachment URL validation against large data URIs, sanitize undefined properties in FirebaseStore, provide direct attachment upload routes & SDK methods, and introduce TaskActivityState for combined comment & attachment threads.
+
+### Patch Changes
+
+- Updated dependencies [1811922]
+  - @critical-path/core@0.8.0
+  - @critical-path/client@0.4.0
+
+## 0.4.0
+
+### Minor Changes
+
+- a48a04a: Add threaded conversations, attachment metadata management, and storage adapters (S3 & Firebase Storage):
+  
+  - **`@critical-path/core`**:
+    - Added `Attachment` entity, `CreateAttachmentInput`, `UploadFileInput`, and `FileStorageAdapter` contracts.
+    - Added `InMemoryFileStore`, duck-typed `S3StorageAdapter` (compatible with AWS SDK v3, v2, MinIO, and Cloudflare R2), and `FirebaseStorageAdapter` (compatible with Google Cloud Storage and Firebase Admin SDK).
+    - Extended `Comment` with `authorType` (`user`, `agent`, `system`) and `parentId` for threaded discussions.
+    - Implemented full comment and attachment repository methods across `InMemoryStore`, `SQLiteStore`, and `FirebaseStore`.
+    - Added engine operations for upload, presigning, and deleting attachments with domain events (`comment.*`, `attachment.*`) and webhooks.
+  
+  - **`@critical-path/server`**:
+    - Added RESTful routes for comments (`GET/POST /tasks/:taskId/comments`, `GET/POST /comments`, `GET/PATCH/DELETE /comments/:id`).
+    - Added RESTful routes for attachments (`GET/POST /tasks/:taskId/attachments`, `GET/POST /attachments`, `GET/DELETE /attachments/:id`, `POST /attachments/presign`).
+  
+  - **`@critical-path/client`**:
+    - Added SDK methods `getComments`, `getComment`, `addComment`, `updateComment`, `deleteComment`.
+    - Added SDK methods `getAttachments`, `getAttachment`, `createAttachment`, `deleteAttachment`, and `getPresignedAttachmentUploadUrl`.
+  
+  - **`@critical-path/react`**:
+    - Added `useComments(taskId)` with reactive thread tree derivation (`threads` containing nested `replies`) and comment mutations.
+    - Added `useAttachments(filter)` with attachment creation and deletion.
+  
+  - **`@critical-path/svelte`**:
+    - Added Svelte 5 Rune-based `CommentState` / `createCommentState(client, taskId)` with derived threaded hierarchy.
+    - Added Svelte 5 Rune-based `AttachmentState` / `createAttachmentState(client, filter)`.
+
+### Patch Changes
+
+- Updated dependencies [a48a04a]
+  - @critical-path/core@0.7.0
+  - @critical-path/client@0.3.0
+
 ## 0.3.4
 
 ### Patch Changes

package/README.md

@@ -2,7 +2,7 @@
 
 > **Svelte 5 Runes Reactive Integrations for Critical Path.**
 
-`@critical-path/svelte` provides Svelte 5 Runes reactive state classes and factories (`ProjectState`, `TaskState`) for building project management UIs in Svelte 5 and SvelteKit applications.
+`@critical-path/svelte` provides Svelte 5 Runes reactive state classes and factories (`ProjectState`, `TaskState`, `WorkflowState`, `CommentState`, `AttachmentState`, `TaskActivityState`) for building project management UIs in Svelte 5 and SvelteKit applications.
 
 ---
 
@@ -16,7 +16,9 @@ pnpm add @critical-path/svelte svelte@^5.0.0
 
 ---
 
-## 💡 Usage Example (Svelte 5 Runes)
+## 💡 Usage Examples (Svelte 5 Runes)
+
+### 1. Projects & Tasks
 
 ```svelte
 <script lang="ts">
@@ -50,8 +52,56 @@ pnpm add @critical-path/svelte svelte@^5.0.0
 {/if}
 ```
 
+### 2. Unified Task Activity & Threaded Discussions (`TaskActivityState`)
+
+Combines threaded comments with inline attachments (`attachment.commentId === comment.id`) and standalone attachments in a single reactive store:
+
+```svelte
+<script lang="ts">
+  import { onMount } from 'svelte';
+  import { createCriticalPathClient, createTaskActivityState } from '@critical-path/svelte';
+
+  const client = createCriticalPathClient({ baseUrl: '/api/critical-path' });
+  const activityState = createTaskActivityState(client, 'task_1');
+
+  onMount(() => {
+    activityState.fetch();
+  });
+
+  async function handleSend(text: string, fileUrl?: string) {
+    await activityState.addComment(
+      { content: text, authorId: 'user_1', authorType: 'user' },
+      fileUrl ? [{ filename: 'upload.png', url: fileUrl, uploaderId: 'user_1', mimeType: 'image/png', sizeBytes: 1024 }] : []
+    );
+  }
+</script>
+
+{#each activityState.threads as thread}
+  <div class="comment">
+    <p><strong>{thread.authorId}</strong>: {thread.content}</p>
+    
+    <!-- Inline comment attachments -->
+    {#if thread.attachments.length > 0}
+      <div class="attachments">
+        {#each thread.attachments as att}
+          <a href={att.url} target="_blank">{att.filename}</a>
+        {/each}
+      </div>
+    {/if}
+
+    <!-- Threaded replies -->
+    {#each thread.replies as reply}
+      <div class="reply">
+        <p>↪ {reply.authorId}: {reply.content}</p>
+      </div>
+    {/each}
+  </div>
+{/each}
+```
+
 ---
 
 ## 📄 License
 
 MIT © [Critical Path](https://github.com/Pixerate/Critical-Path)
+

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

@@ -0,0 +1,27 @@
+import type { CriticalPathClient } from '@critical-path/client';
+import type { Comment, Attachment } from '@critical-path/core';
+export interface ThreadedCommentWithAttachments extends Comment {
+    attachments: Attachment[];
+    replies: ThreadedCommentWithAttachments[];
+}
+export declare class TaskActivityState {
+    private client;
+    taskId?: string | undefined;
+    comments: Comment[];
+    attachments: Attachment[];
+    loading: boolean;
+    error: Error | null;
+    threads: ThreadedCommentWithAttachments[];
+    standaloneAttachments: Attachment[];
+    constructor(client: CriticalPathClient, taskId?: string | undefined);
+    fetch(taskId?: string): Promise<void>;
+    addComment(input: Omit<Comment, 'id' | 'taskId' | 'createdAt' | 'updatedAt'>, attachmentInputs?: Array<Omit<Attachment, 'id' | 'taskId' | 'commentId' | 'createdAt' | 'updatedAt'>>): Promise<{
+        comment: Comment;
+        attachments: Attachment[];
+    }>;
+    addAttachment(input: Omit<Attachment, 'id' | 'taskId' | 'createdAt' | 'updatedAt'>): Promise<Attachment>;
+    deleteComment(id: string): Promise<void>;
+    deleteAttachment(id: string): Promise<void>;
+}
+export declare function createTaskActivityState(client: CriticalPathClient, taskId?: string): TaskActivityState;
+//# sourceMappingURL=activity-state.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"activity-state.svelte.d.ts","sourceRoot":"","sources":["../src/activity-state.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE/D,MAAM,WAAW,8BAA+B,SAAQ,OAAO;IAC7D,WAAW,EAAE,UAAU,EAAE,CAAC;IAC1B,OAAO,EAAE,8BAA8B,EAAE,CAAC;CAC3C;AAED,qBAAa,iBAAiB;IA6ChB,OAAO,CAAC,MAAM;IAA6B,MAAM,CAAC,EAAE,MAAM;IA5CtE,QAAQ,YAAyB;IACjC,WAAW,eAA4B;IACvC,OAAO,UAA0B;IACjC,KAAK,eAA8B;IAEnC,OAAO,mCAiCJ;IAEH,qBAAqB,eAElB;gBAEiB,MAAM,EAAE,kBAAkB,EAAS,MAAM,CAAC,EAAE,MAAM,YAAA;IAEhE,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM;IAwBrB,UAAU,CACd,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,CAAC,EACjE,gBAAgB,CAAC,EAAE,KAAK,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,GAAG,WAAW,CAAC,CAAC;;;;IAiCjG,aAAa,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,CAAC;IAelF,aAAa,CAAC,EAAE,EAAE,MAAM;IAWxB,gBAAgB,CAAC,EAAE,EAAE,MAAM;CAUlC;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,kBAAkB,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,iBAAiB,CAEtG"}

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

@@ -0,0 +1,20 @@
+import type { CriticalPathClient } from '@critical-path/client';
+import type { Attachment } from '@critical-path/core';
+export interface AttachmentFilter {
+    taskId?: string;
+    projectId?: string;
+    commentId?: string;
+}
+export declare class AttachmentState {
+    private client;
+    filter?: AttachmentFilter | undefined;
+    data: Attachment[];
+    loading: boolean;
+    error: Error | null;
+    constructor(client: CriticalPathClient, filter?: AttachmentFilter | undefined);
+    fetch(filter?: AttachmentFilter): Promise<void>;
+    createAttachment(input: Omit<Attachment, 'id' | 'createdAt' | 'updatedAt'>): Promise<Attachment>;
+    deleteAttachment(id: string): Promise<void>;
+}
+export declare function createAttachmentState(client: CriticalPathClient, initialFilter?: AttachmentFilter): AttachmentState;
+//# sourceMappingURL=attachment-state.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attachment-state.svelte.d.ts","sourceRoot":"","sources":["../src/attachment-state.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAEtD,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,qBAAa,eAAe;IAKd,OAAO,CAAC,MAAM;IAA6B,MAAM,CAAC,EAAE,gBAAgB;IAJhF,IAAI,eAA4B;IAChC,OAAO,UAA0B;IACjC,KAAK,eAA8B;gBAEf,MAAM,EAAE,kBAAkB,EAAS,MAAM,CAAC,EAAE,gBAAgB,YAAA;IAE1E,KAAK,CAAC,MAAM,CAAC,EAAE,gBAAgB;IAe/B,gBAAgB,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,GAAG,WAAW,GAAG,WAAW,CAAC;IAY1E,gBAAgB,CAAC,EAAE,EAAE,MAAM;CAUlC;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,kBAAkB,EAAE,aAAa,CAAC,EAAE,gBAAgB,GAAG,eAAe,CAEnH"}

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

@@ -0,0 +1,20 @@
+import type { CriticalPathClient } from '@critical-path/client';
+import type { Comment } from '@critical-path/core';
+export interface ThreadedComment extends Comment {
+    replies: ThreadedComment[];
+}
+export declare class CommentState {
+    private client;
+    taskId?: string | undefined;
+    data: Comment[];
+    loading: boolean;
+    error: Error | null;
+    threads: ThreadedComment[];
+    constructor(client: CriticalPathClient, taskId?: string | undefined);
+    fetch(taskId?: string): Promise<void>;
+    addComment(input: Omit<Comment, 'id' | 'taskId' | 'createdAt' | 'updatedAt'>): Promise<Comment>;
+    updateComment(id: string, updates: Partial<Comment>): Promise<Comment>;
+    deleteComment(id: string): Promise<void>;
+}
+export declare function createCommentState(client: CriticalPathClient, taskId?: string): CommentState;
+//# sourceMappingURL=comment-state.svelte.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"comment-state.svelte.d.ts","sourceRoot":"","sources":["../src/comment-state.svelte.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAChE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAEnD,MAAM,WAAW,eAAgB,SAAQ,OAAO;IAC9C,OAAO,EAAE,eAAe,EAAE,CAAC;CAC5B;AAED,qBAAa,YAAY;IAyBX,OAAO,CAAC,MAAM;IAA6B,MAAM,CAAC,EAAE,MAAM;IAxBtE,IAAI,YAAyB;IAC7B,OAAO,UAA0B;IACjC,KAAK,eAA8B;IAEnC,OAAO,oBAkBJ;gBAEiB,MAAM,EAAE,kBAAkB,EAAS,MAAM,CAAC,EAAE,MAAM,YAAA;IAEhE,KAAK,CAAC,MAAM,CAAC,EAAE,MAAM;IAkBrB,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,GAAG,QAAQ,GAAG,WAAW,GAAG,WAAW,CAAC;IAe5E,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;IAYnD,aAAa,CAAC,EAAE,EAAE,MAAM;CAU/B;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,kBAAkB,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,YAAY,CAE5F"}

package/dist/index.d.ts

@@ -3,4 +3,7 @@ export declare function createCriticalPathClient(options: ClientOptions): Critic
 export * from './project-state.svelte.js';
 export * from './task-state.svelte.js';
 export * from './workflow-state.svelte.js';
+export * from './comment-state.svelte.js';
+export * from './attachment-state.svelte.js';
+export * from './activity-state.svelte.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE/E,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,aAAa,GAAG,kBAAkB,CAEnF;AAED,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,KAAK,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE/E,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,aAAa,GAAG,kBAAkB,CAEnF;AAED,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,4BAA4B,CAAC"}

package/dist/index.js

@@ -227,9 +227,297 @@ function s(e) {
 	return new o(e);
 }
 //#endregion
+//#region src/comment-state.svelte.ts
+var c = class {
+	client;
+	taskId;
+	#e = t.state(t.proxy([]));
+	get data() {
+		return t.get(this.#e);
+	}
+	set data(e) {
+		t.set(this.#e, e, !0);
+	}
+	#t = t.state(!1);
+	get loading() {
+		return t.get(this.#t);
+	}
+	set loading(e) {
+		t.set(this.#t, e, !0);
+	}
+	#n = t.state(null);
+	get error() {
+		return t.get(this.#n);
+	}
+	set error(e) {
+		t.set(this.#n, e, !0);
+	}
+	#r = t.derived(() => {
+		let e = /* @__PURE__ */ new Map(), t = [];
+		for (let t of this.data) e.set(t.id, {
+			...t,
+			replies: []
+		});
+		for (let n of this.data) {
+			let r = e.get(n.id);
+			n.parentId && e.has(n.parentId) ? e.get(n.parentId).replies.push(r) : t.push(r);
+		}
+		return t;
+	});
+	get threads() {
+		return t.get(this.#r);
+	}
+	set threads(e) {
+		t.set(this.#r, e);
+	}
+	constructor(e, t) {
+		this.client = e, this.taskId = t;
+	}
+	async fetch(e) {
+		let t = e || this.taskId;
+		if (!t) {
+			this.data = [];
+			return;
+		}
+		this.taskId = t, this.loading = !0, this.error = null;
+		try {
+			this.data = await this.client.getComments(t);
+		} catch (e) {
+			this.error = e instanceof Error ? e : Error(String(e));
+		} finally {
+			this.loading = !1;
+		}
+	}
+	async addComment(e) {
+		if (!this.taskId) throw Error("CommentState requires a taskId to add comments.");
+		try {
+			let t = await this.client.addComment({
+				...e,
+				taskId: this.taskId
+			});
+			return this.data = [...this.data, t], t;
+		} catch (e) {
+			let t = e instanceof Error ? e : Error(String(e));
+			throw this.error = t, t;
+		}
+	}
+	async updateComment(e, t) {
+		try {
+			let n = await this.client.updateComment(e, t);
+			return this.data = this.data.map((t) => t.id === e ? n : t), n;
+		} catch (e) {
+			let t = e instanceof Error ? e : Error(String(e));
+			throw this.error = t, t;
+		}
+	}
+	async deleteComment(e) {
+		try {
+			await this.client.deleteComment(e), this.data = this.data.filter((t) => t.id !== e);
+		} catch (e) {
+			let t = e instanceof Error ? e : Error(String(e));
+			throw this.error = t, t;
+		}
+	}
+};
+function l(e, t) {
+	return new c(e, t);
+}
+//#endregion
+//#region src/attachment-state.svelte.ts
+var u = class {
+	client;
+	filter;
+	#e = t.state(t.proxy([]));
+	get data() {
+		return t.get(this.#e);
+	}
+	set data(e) {
+		t.set(this.#e, e, !0);
+	}
+	#t = t.state(!1);
+	get loading() {
+		return t.get(this.#t);
+	}
+	set loading(e) {
+		t.set(this.#t, e, !0);
+	}
+	#n = t.state(null);
+	get error() {
+		return t.get(this.#n);
+	}
+	set error(e) {
+		t.set(this.#n, e, !0);
+	}
+	constructor(e, t) {
+		this.client = e, this.filter = t;
+	}
+	async fetch(e) {
+		e && (this.filter = e), this.loading = !0, this.error = null;
+		try {
+			this.data = await this.client.getAttachments(this.filter);
+		} catch (e) {
+			this.error = e instanceof Error ? e : Error(String(e));
+		} finally {
+			this.loading = !1;
+		}
+	}
+	async createAttachment(e) {
+		try {
+			let t = await this.client.createAttachment(e);
+			return this.data = [t, ...this.data], t;
+		} catch (e) {
+			let t = e instanceof Error ? e : Error(String(e));
+			throw this.error = t, t;
+		}
+	}
+	async deleteAttachment(e) {
+		try {
+			await this.client.deleteAttachment(e), this.data = this.data.filter((t) => t.id !== e);
+		} catch (e) {
+			let t = e instanceof Error ? e : Error(String(e));
+			throw this.error = t, t;
+		}
+	}
+};
+function d(e, t) {
+	return new u(e, t);
+}
+//#endregion
+//#region src/activity-state.svelte.ts
+var f = class {
+	client;
+	taskId;
+	#e = t.state(t.proxy([]));
+	get comments() {
+		return t.get(this.#e);
+	}
+	set comments(e) {
+		t.set(this.#e, e, !0);
+	}
+	#t = t.state(t.proxy([]));
+	get attachments() {
+		return t.get(this.#t);
+	}
+	set attachments(e) {
+		t.set(this.#t, e, !0);
+	}
+	#n = t.state(!1);
+	get loading() {
+		return t.get(this.#n);
+	}
+	set loading(e) {
+		t.set(this.#n, e, !0);
+	}
+	#r = t.state(null);
+	get error() {
+		return t.get(this.#r);
+	}
+	set error(e) {
+		t.set(this.#r, e, !0);
+	}
+	#i = t.derived(() => {
+		let e = /* @__PURE__ */ new Map(), t = [], n = /* @__PURE__ */ new Map();
+		for (let e of this.attachments) e.commentId && (n.has(e.commentId) || n.set(e.commentId, []), n.get(e.commentId).push(e));
+		for (let t of this.comments) e.set(t.id, {
+			...t,
+			attachments: n.get(t.id) || [],
+			replies: []
+		});
+		for (let n of this.comments) {
+			let r = e.get(n.id);
+			n.parentId && e.has(n.parentId) ? e.get(n.parentId).replies.push(r) : t.push(r);
+		}
+		return t;
+	});
+	get threads() {
+		return t.get(this.#i);
+	}
+	set threads(e) {
+		t.set(this.#i, e);
+	}
+	#a = t.derived(() => this.attachments.filter((e) => !e.commentId));
+	get standaloneAttachments() {
+		return t.get(this.#a);
+	}
+	set standaloneAttachments(e) {
+		t.set(this.#a, e);
+	}
+	constructor(e, t) {
+		this.client = e, this.taskId = t;
+	}
+	async fetch(e) {
+		let t = e || this.taskId;
+		if (!t) {
+			this.comments = [], this.attachments = [];
+			return;
+		}
+		this.taskId = t, this.loading = !0, this.error = null;
+		try {
+			let [e, n] = await Promise.all([this.client.getComments(t), this.client.getAttachments({ taskId: t })]);
+			this.comments = e, this.attachments = n;
+		} catch (e) {
+			this.error = e instanceof Error ? e : Error(String(e));
+		} finally {
+			this.loading = !1;
+		}
+	}
+	async addComment(e, t) {
+		if (!this.taskId) throw Error("TaskActivityState requires a taskId to add comments.");
+		try {
+			let n = await this.client.addComment({
+				...e,
+				taskId: this.taskId
+			}), r = [];
+			return t && t.length > 0 && (r = await Promise.all(t.map((e) => this.client.createAttachment({
+				...e,
+				taskId: this.taskId,
+				commentId: n.id
+			})))), this.comments = [...this.comments, n], r.length > 0 && (this.attachments = [...this.attachments, ...r]), {
+				comment: n,
+				attachments: r
+			};
+		} catch (e) {
+			let t = e instanceof Error ? e : Error(String(e));
+			throw this.error = t, t;
+		}
+	}
+	async addAttachment(e) {
+		if (!this.taskId) throw Error("TaskActivityState requires a taskId to add attachments.");
+		try {
+			let t = await this.client.createAttachment({
+				...e,
+				taskId: this.taskId
+			});
+			return this.attachments = [t, ...this.attachments], t;
+		} catch (e) {
+			let t = e instanceof Error ? e : Error(String(e));
+			throw this.error = t, t;
+		}
+	}
+	async deleteComment(e) {
+		try {
+			await this.client.deleteComment(e), this.comments = this.comments.filter((t) => t.id !== e);
+		} catch (e) {
+			let t = e instanceof Error ? e : Error(String(e));
+			throw this.error = t, t;
+		}
+	}
+	async deleteAttachment(e) {
+		try {
+			await this.client.deleteAttachment(e), this.attachments = this.attachments.filter((t) => t.id !== e);
+		} catch (e) {
+			let t = e instanceof Error ? e : Error(String(e));
+			throw this.error = t, t;
+		}
+	}
+};
+function p(e, t) {
+	return new f(e, t);
+}
+//#endregion
 //#region src/index.ts
-function c(t) {
+function m(t) {
 	return new e(t);
 }
 //#endregion
-export { n as ProjectState, i as TaskState, o as WorkflowState, c as createCriticalPathClient, r as createProjectState, a as createTaskState, s as createWorkflowState };
+export { u as AttachmentState, c as CommentState, n as ProjectState, f as TaskActivityState, i as TaskState, o as WorkflowState, d as createAttachmentState, l as createCommentState, m as createCriticalPathClient, r as createProjectState, p as createTaskActivityState, a as createTaskState, s as createWorkflowState };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@critical-path/svelte",
-  "version": "0.3.4",
+  "version": "0.5.0",
   "description": "Svelte 5 Runes state and reactive integrations for Critical Path headless project management framework",
   "author": "Jack James",
   "license": "MIT",
@@ -18,8 +18,8 @@
     }
   },
   "dependencies": {
-    "@critical-path/client": "0.2.4",
-    "@critical-path/core": "0.6.0"
+    "@critical-path/client": "0.4.0",
+    "@critical-path/core": "0.8.0"
   },
   "peerDependencies": {
     "svelte": "^5.0.0"

package/src/activity-state.svelte.ts

@@ -0,0 +1,156 @@
+/// <reference types="svelte" />
+import type { CriticalPathClient } from '@critical-path/client';
+import type { Comment, Attachment } from '@critical-path/core';
+
+export interface ThreadedCommentWithAttachments extends Comment {
+  attachments: Attachment[];
+  replies: ThreadedCommentWithAttachments[];
+}
+
+export class TaskActivityState {
+  comments = $state<Comment[]>([]);
+  attachments = $state<Attachment[]>([]);
+  loading = $state<boolean>(false);
+  error = $state<Error | null>(null);
+
+  threads = $derived.by(() => {
+    const map = new Map<string, ThreadedCommentWithAttachments>();
+    const roots: ThreadedCommentWithAttachments[] = [];
+
+    // Group attachments by commentId
+    const attachmentsByComment = new Map<string, Attachment[]>();
+    for (const a of this.attachments) {
+      if (a.commentId) {
+        if (!attachmentsByComment.has(a.commentId)) {
+          attachmentsByComment.set(a.commentId, []);
+        }
+        attachmentsByComment.get(a.commentId)!.push(a);
+      }
+    }
+
+    for (const c of this.comments) {
+      map.set(c.id, {
+        ...c,
+        attachments: attachmentsByComment.get(c.id) || [],
+        replies: []
+      });
+    }
+
+    for (const c of this.comments) {
+      const threaded = map.get(c.id)!;
+      if (c.parentId && map.has(c.parentId)) {
+        map.get(c.parentId)!.replies.push(threaded);
+      } else {
+        roots.push(threaded);
+      }
+    }
+
+    return roots;
+  });
+
+  standaloneAttachments = $derived.by(() => {
+    return this.attachments.filter((a) => !a.commentId);
+  });
+
+  constructor(private client: CriticalPathClient, public taskId?: string) {}
+
+  async fetch(taskId?: string) {
+    const targetTaskId = taskId || this.taskId;
+    if (!targetTaskId) {
+      this.comments = [];
+      this.attachments = [];
+      return;
+    }
+    this.taskId = targetTaskId;
+    this.loading = true;
+    this.error = null;
+    try {
+      const [comments, attachments] = await Promise.all([
+        this.client.getComments(targetTaskId),
+        this.client.getAttachments({ taskId: targetTaskId })
+      ]);
+      this.comments = comments;
+      this.attachments = attachments;
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  async addComment(
+    input: Omit<Comment, 'id' | 'taskId' | 'createdAt' | 'updatedAt'>,
+    attachmentInputs?: Array<Omit<Attachment, 'id' | 'taskId' | 'commentId' | 'createdAt' | 'updatedAt'>>
+  ) {
+    if (!this.taskId) {
+      throw new Error('TaskActivityState requires a taskId to add comments.');
+    }
+    try {
+      const comment = await this.client.addComment({ ...input, taskId: this.taskId });
+      let createdAttachments: Attachment[] = [];
+
+      if (attachmentInputs && attachmentInputs.length > 0) {
+        createdAttachments = await Promise.all(
+          attachmentInputs.map((att) =>
+            this.client.createAttachment({
+              ...att,
+              taskId: this.taskId,
+              commentId: comment.id
+            })
+          )
+        );
+      }
+
+      this.comments = [...this.comments, comment];
+      if (createdAttachments.length > 0) {
+        this.attachments = [...this.attachments, ...createdAttachments];
+      }
+      return { comment, attachments: createdAttachments };
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      this.error = errorObj;
+      throw errorObj;
+    }
+  }
+
+  async addAttachment(input: Omit<Attachment, 'id' | 'taskId' | 'createdAt' | 'updatedAt'>) {
+    if (!this.taskId) {
+      throw new Error('TaskActivityState requires a taskId to add attachments.');
+    }
+    try {
+      const created = await this.client.createAttachment({ ...input, taskId: this.taskId });
+      this.attachments = [created, ...this.attachments];
+      return created;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      this.error = errorObj;
+      throw errorObj;
+    }
+  }
+
+  async deleteComment(id: string) {
+    try {
+      await this.client.deleteComment(id);
+      this.comments = this.comments.filter((c) => c.id !== id);
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      this.error = errorObj;
+      throw errorObj;
+    }
+  }
+
+  async deleteAttachment(id: string) {
+    try {
+      await this.client.deleteAttachment(id);
+      this.attachments = this.attachments.filter((a) => a.id !== id);
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      this.error = errorObj;
+      throw errorObj;
+    }
+  }
+}
+
+export function createTaskActivityState(client: CriticalPathClient, taskId?: string): TaskActivityState {
+  return new TaskActivityState(client, taskId);
+}

package/src/attachment-state.svelte.ts

@@ -0,0 +1,59 @@
+/// <reference types="svelte" />
+import type { CriticalPathClient } from '@critical-path/client';
+import type { Attachment } from '@critical-path/core';
+
+export interface AttachmentFilter {
+  taskId?: string;
+  projectId?: string;
+  commentId?: string;
+}
+
+export class AttachmentState {
+  data = $state<Attachment[]>([]);
+  loading = $state<boolean>(false);
+  error = $state<Error | null>(null);
+
+  constructor(private client: CriticalPathClient, public filter?: AttachmentFilter) {}
+
+  async fetch(filter?: AttachmentFilter) {
+    if (filter) {
+      this.filter = filter;
+    }
+    this.loading = true;
+    this.error = null;
+    try {
+      this.data = await this.client.getAttachments(this.filter);
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  async createAttachment(input: Omit<Attachment, 'id' | 'createdAt' | 'updatedAt'>) {
+    try {
+      const created = await this.client.createAttachment(input);
+      this.data = [created, ...this.data];
+      return created;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      this.error = errorObj;
+      throw errorObj;
+    }
+  }
+
+  async deleteAttachment(id: string) {
+    try {
+      await this.client.deleteAttachment(id);
+      this.data = this.data.filter((a) => a.id !== id);
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      this.error = errorObj;
+      throw errorObj;
+    }
+  }
+}
+
+export function createAttachmentState(client: CriticalPathClient, initialFilter?: AttachmentFilter): AttachmentState {
+  return new AttachmentState(client, initialFilter);
+}

package/src/comment-state.svelte.ts

@@ -0,0 +1,95 @@
+/// <reference types="svelte" />
+import type { CriticalPathClient } from '@critical-path/client';
+import type { Comment } from '@critical-path/core';
+
+export interface ThreadedComment extends Comment {
+  replies: ThreadedComment[];
+}
+
+export class CommentState {
+  data = $state<Comment[]>([]);
+  loading = $state<boolean>(false);
+  error = $state<Error | null>(null);
+
+  threads = $derived.by(() => {
+    const map = new Map<string, ThreadedComment>();
+    const roots: ThreadedComment[] = [];
+
+    for (const c of this.data) {
+      map.set(c.id, { ...c, replies: [] });
+    }
+
+    for (const c of this.data) {
+      const threaded = map.get(c.id)!;
+      if (c.parentId && map.has(c.parentId)) {
+        map.get(c.parentId)!.replies.push(threaded);
+      } else {
+        roots.push(threaded);
+      }
+    }
+
+    return roots;
+  });
+
+  constructor(private client: CriticalPathClient, public taskId?: string) {}
+
+  async fetch(taskId?: string) {
+    const targetTaskId = taskId || this.taskId;
+    if (!targetTaskId) {
+      this.data = [];
+      return;
+    }
+    this.taskId = targetTaskId;
+    this.loading = true;
+    this.error = null;
+    try {
+      this.data = await this.client.getComments(targetTaskId);
+    } catch (err) {
+      this.error = err instanceof Error ? err : new Error(String(err));
+    } finally {
+      this.loading = false;
+    }
+  }
+
+  async addComment(input: Omit<Comment, 'id' | 'taskId' | 'createdAt' | 'updatedAt'>) {
+    if (!this.taskId) {
+      throw new Error('CommentState requires a taskId to add comments.');
+    }
+    try {
+      const created = await this.client.addComment({ ...input, taskId: this.taskId });
+      this.data = [...this.data, created];
+      return created;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      this.error = errorObj;
+      throw errorObj;
+    }
+  }
+
+  async updateComment(id: string, updates: Partial<Comment>) {
+    try {
+      const updated = await this.client.updateComment(id, updates);
+      this.data = this.data.map((c) => (c.id === id ? updated : c));
+      return updated;
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      this.error = errorObj;
+      throw errorObj;
+    }
+  }
+
+  async deleteComment(id: string) {
+    try {
+      await this.client.deleteComment(id);
+      this.data = this.data.filter((c) => c.id !== id);
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      this.error = errorObj;
+      throw errorObj;
+    }
+  }
+}
+
+export function createCommentState(client: CriticalPathClient, taskId?: string): CommentState {
+  return new CommentState(client, taskId);
+}

package/src/index.test.ts

@@ -6,10 +6,16 @@ import {
   TaskState,
   createTaskState,
   WorkflowState,
-  createWorkflowState
+  createWorkflowState,
+  CommentState,
+  createCommentState,
+  AttachmentState,
+  createAttachmentState,
+  TaskActivityState,
+  createTaskActivityState
 } from './index.js';
 import type { CriticalPathClient } from '@critical-path/client';
-import type { Project, Task, Workflow } from '@critical-path/core';
+import type { Project, Task, Workflow, Comment, Attachment } from '@critical-path/core';
 
 describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
   it('exports client factory and Svelte 5 Runes state factories', () => {
@@ -17,9 +23,15 @@ describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
     expect(createProjectState).toBeDefined();
     expect(createTaskState).toBeDefined();
     expect(createWorkflowState).toBeDefined();
+    expect(createCommentState).toBeDefined();
+    expect(createAttachmentState).toBeDefined();
+    expect(createTaskActivityState).toBeDefined();
     expect(ProjectState).toBeDefined();
     expect(TaskState).toBeDefined();
     expect(WorkflowState).toBeDefined();
+    expect(CommentState).toBeDefined();
+    expect(AttachmentState).toBeDefined();
+    expect(TaskActivityState).toBeDefined();
   });
 
   describe('WorkflowState', () => {
@@ -185,4 +197,114 @@ describe('@critical-path/svelte Svelte 5 Runes Test Suite', () => {
       expect(taskState.data).toEqual([mockTask]);
     });
   });
+
+  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 mockClient = {
+        getComments: vi.fn().mockResolvedValue([mockComment]),
+        addComment: vi.fn().mockResolvedValue(mockComment),
+        updateComment: vi.fn().mockResolvedValue(updatedComment),
+        deleteComment: vi.fn().mockResolvedValue(true)
+      } 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.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([]);
+    });
+  });
+
+  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);
+    });
+  });
 });
+

package/src/index.ts

@@ -7,3 +7,7 @@ export function createCriticalPathClient(options: ClientOptions): CriticalPathCl
 export * from './project-state.svelte.js';
 export * from './task-state.svelte.js';
 export * from './workflow-state.svelte.js';
+export * from './comment-state.svelte.js';
+export * from './attachment-state.svelte.js';
+export * from './activity-state.svelte.js';
+