trekoon 0.3.7 → 0.3.8

package/src/board/assets/app.js

@@ -13,7 +13,6 @@ import { createConfirmDialog } from "./components/ConfirmDialog.js";
 import { createEpicsOverview } from "./components/EpicsOverview.js";
 import { panelClasses, renderIcon, sectionLabelClasses, escapeHtml } from "./components/helpers.js";
 
-const SESSION_TOKEN_STORAGE_KEY = "trekoon-board-session-token";
 const SEARCH_FOCUS_KEYS = new Set(["/", "s"]);
 const FOCUSABLE_SELECTOR = [
   "a[href]",
@@ -33,30 +32,15 @@ const FOCUSABLE_SELECTOR = [
 // Session token management
 // ---------------------------------------------------------------------------
 
-function readSessionTokenFromStorage() {
-  try {
-    return (sessionStorage.getItem(SESSION_TOKEN_STORAGE_KEY) || "").trim();
-  } catch {
-    return "";
-  }
-}
-
-function persistSessionToken(token) {
-  try {
-    sessionStorage.setItem(SESSION_TOKEN_STORAGE_KEY, token);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
 function resolveRuntimeSession() {
   const url = new URL(window.location.href);
   const queryToken = (url.searchParams.get("token") || "").trim();
   if (queryToken.length > 0) {
-    return { token: queryToken, shouldScrubAddressBar: persistSessionToken(queryToken) };
+    return { token: queryToken, shouldScrubAddressBar: true };
   }
-  return { token: readSessionTokenFromStorage(), shouldScrubAddressBar: false };
+  const bootstrap = readJsonScript("trekoon-board-bootstrap") ?? {};
+  const bootstrapToken = typeof bootstrap?.token === "string" ? bootstrap.token.trim() : "";
+  return { token: bootstrapToken, shouldScrubAddressBar: false };
 }
 
 function scrubTokenFromAddressBar() {
@@ -149,11 +133,10 @@ export async function bootLegacyBoard(options = {}) {
     if (runtimeSession.shouldScrubAddressBar) scrubTokenFromAddressBar();
 
     // Fetch snapshot
-    let snapshotPayload = readJsonScript("trekoon-board-snapshot") ?? {};
-    if (runtimeSession.token.length > 0) {
-      const headers = new Headers();
-      headers.set("authorization", `Bearer ${runtimeSession.token}`);
-      const response = await fetch("/api/snapshot", { headers });
+    const bootstrap = readJsonScript("trekoon-board-bootstrap") ?? {};
+    let snapshotPayload = bootstrap?.snapshot ?? readJsonScript("trekoon-board-snapshot") ?? {};
+    if ((!snapshotPayload || typeof snapshotPayload !== "object") && runtimeSession.token.length > 0) {
+      const response = await fetch("/api/snapshot");
       const payload = await response.json();
       if (!payload?.ok) throw new Error(payload?.error?.message || "Board request failed");
       snapshotPayload = payload?.data?.snapshot ?? {};

package/src/board/assets/state/api.js

@@ -124,13 +124,12 @@ export function createMutationQueue(model, rerender) {
         model.store.notice = null;
       }
 
-      // Apply optimistic update
-      if (typeof mutation.optimistic === "function") {
-        model.store.snapshot = mutation.optimistic(cloneSnapshot(model.store.snapshot));
-        rerender();
-      }
-
       try {
+        if (typeof mutation.optimistic === "function") {
+          model.store.snapshot = mutation.optimistic(cloneSnapshot(model.store.snapshot));
+          rerender();
+        }
+
         const data = await mutation.request();
 
         if (data?.snapshot) {

package/src/board/assets/state/utils.js

@@ -27,10 +27,10 @@ function normalizeArray(value) {
 
 /**
  * @param {{ id?: string }} record
- * @returns {string}
+ * @returns {string|null}
  */
 function getId(record) {
-  return typeof record?.id === "string" && record.id.length > 0 ? record.id : crypto.randomUUID();
+  return typeof record?.id === "string" && record.id.length > 0 ? record.id : null;
 }
 
 function normalizeTimestamp(value, fallback) {
@@ -42,6 +42,10 @@ function normalizeText(value, fallback = "") {
   return String(value ?? fallback).replace(/\\n/g, "\n");
 }
 
+function normalizeOwner(value) {
+  return typeof value === "string" ? value : null;
+}
+
 /**
  * @param {any[]} tasks
  * @returns {Record<string, number>}
@@ -68,15 +72,21 @@ export function normalizeSnapshot(rawSnapshot) {
   const taskIndex = new Map();
   const subtaskIndex = new Map();
 
-  const tasks = rawTasks.map((task) => {
+  const tasks = rawTasks.flatMap((task) => {
+    const taskId = getId(task);
+    if (!taskId) {
+      return [];
+    }
+
     const createdAt = normalizeTimestamp(task.createdAt, Date.now());
     const normalizedTask = {
-      id: getId(task),
+      id: taskId,
       kind: "task",
       epicId: task.epicId ?? task.epic?.id ?? null,
       title: normalizeText(task.title, "Untitled task"),
       description: normalizeText(task.description),
       status: normalizeStatus(task.status),
+      owner: normalizeOwner(task.owner),
       createdAt,
       updatedAt: normalizeTimestamp(task.updatedAt, createdAt),
       blockedBy: [],
@@ -88,18 +98,24 @@ export function normalizeSnapshot(rawSnapshot) {
     };
 
     taskIndex.set(normalizedTask.id, normalizedTask);
-    return normalizedTask;
+    return [normalizedTask];
   });
 
-  const subtasks = rawSubtasks.map((subtask) => {
+  const subtasks = rawSubtasks.flatMap((subtask) => {
+    const subtaskId = getId(subtask);
+    if (!subtaskId) {
+      return [];
+    }
+
     const createdAt = normalizeTimestamp(subtask.createdAt, Date.now());
     const normalizedSubtask = {
-      id: getId(subtask),
+      id: subtaskId,
       kind: "subtask",
       taskId: subtask.taskId ?? subtask.task?.id ?? null,
       title: normalizeText(subtask.title, "Untitled subtask"),
       description: normalizeText(subtask.description),
       status: normalizeStatus(subtask.status),
+      owner: normalizeOwner(subtask.owner),
       createdAt,
       updatedAt: normalizeTimestamp(subtask.updatedAt, createdAt),
       blockedBy: [],
@@ -110,7 +126,7 @@ export function normalizeSnapshot(rawSnapshot) {
     };
 
     subtaskIndex.set(normalizedSubtask.id, normalizedSubtask);
-    return normalizedSubtask;
+    return [normalizedSubtask];
   });
 
   for (const subtask of subtasks) {
@@ -120,13 +136,22 @@ export function normalizeSnapshot(rawSnapshot) {
     }
   }
 
-  const dependencies = rawDependencies.map((dependency) => ({
-    id: getId(dependency),
-    sourceId: String(dependency.sourceId ?? ""),
-    sourceKind: dependency.sourceKind === "subtask" ? "subtask" : "task",
-    dependsOnId: String(dependency.dependsOnId ?? ""),
-    dependsOnKind: dependency.dependsOnKind === "subtask" ? "subtask" : "task",
-  }));
+  const dependencies = rawDependencies.flatMap((dependency) => {
+    const dependencyId = getId(dependency);
+    const sourceId = typeof dependency?.sourceId === "string" && dependency.sourceId.length > 0 ? dependency.sourceId : null;
+    const dependsOnId = typeof dependency?.dependsOnId === "string" && dependency.dependsOnId.length > 0 ? dependency.dependsOnId : null;
+    if (!dependencyId || !sourceId || !dependsOnId) {
+      return [];
+    }
+
+    return [{
+      id: dependencyId,
+      sourceId,
+      sourceKind: dependency.sourceKind === "subtask" ? "subtask" : "task",
+      dependsOnId,
+      dependsOnKind: dependency.dependsOnKind === "subtask" ? "subtask" : "task",
+    }];
+  });
 
   const lookupNode = (kind, id) => {
     if (kind === "subtask") {
@@ -148,8 +173,12 @@ export function normalizeSnapshot(rawSnapshot) {
     }
   }
 
-  const epics = rawEpics.map((epic) => {
+  const epics = rawEpics.flatMap((epic) => {
     const epicId = getId(epic);
+    if (!epicId) {
+      return [];
+    }
+
     const epicTasks = tasks.filter((task) => task.epicId === epicId);
     const createdAt = normalizeTimestamp(epic.createdAt, Date.now());
     const normalizedEpic = {
@@ -165,7 +194,7 @@ export function normalizeSnapshot(rawSnapshot) {
     };
 
     normalizedEpic.searchText = [normalizedEpic.title, normalizedEpic.description, ...epicTasks.map((task) => task.title)].join(" ").toLowerCase();
-    return normalizedEpic;
+    return [normalizedEpic];
   });
 
   for (const subtask of subtasks) {
@@ -214,6 +243,10 @@ function mergeRecordsById(existingRecords, incomingRecords, deletedIds = []) {
   const indexById = new Map(nextRecords.map((record, index) => [record.id, index]));
 
   for (const record of incomingRecords) {
+    if (typeof record?.id !== "string" || record.id.length === 0) {
+      continue;
+    }
+
     const existingIndex = indexById.get(record.id);
     if (existingIndex === undefined) {
       indexById.set(record.id, nextRecords.length);

package/src/board/routes.ts

@@ -4,7 +4,7 @@ import { safeErrorMessage } from "../commands/error-utils";
 import { MutationService } from "../domain/mutation-service";
 import { TrackerDomain } from "../domain/tracker-domain";
 import { DomainError } from "../domain/types";
-import { buildBoardSnapshot } from "./snapshot";
+import { buildBoardSnapshot, buildBoardSnapshotDelta } from "./snapshot";
 
 interface SnapshotDeltaSelection {
   readonly epicIds?: readonly string[];
@@ -63,6 +63,25 @@ function jsonResponse(status: number, data: unknown): Response {
   });
 }
 
+function readCookieToken(request: Request): string | null {
+  const rawCookie = request.headers.get("cookie");
+  if (!rawCookie) {
+    return null;
+  }
+
+  for (const part of rawCookie.split(";")) {
+    const [name, ...valueParts] = part.split("=");
+    if (name?.trim() !== "trekoon_board_session") {
+      continue;
+    }
+
+    const value = valueParts.join("=").trim();
+    return value.length > 0 ? decodeURIComponent(value) : null;
+  }
+
+  return null;
+}
+
 function extractToken(request: Request, url: URL): string | null {
   const authorization: string | null = request.headers.get("authorization");
   if (authorization?.startsWith("Bearer ")) {
@@ -79,7 +98,7 @@ function extractToken(request: Request, url: URL): string | null {
     return queryToken.trim();
   }
 
-  return null;
+  return readCookieToken(request);
 }
 
 function isSqliteBusyMessage(message: string): boolean {
@@ -147,23 +166,7 @@ function buildMutationResponse(_domain: TrackerDomain, data: Record<string, unkn
   });
 }
 
-function buildSnapshotDelta(domain: TrackerDomain, selection: SnapshotDeltaSelection): Record<string, unknown> {
-  const snapshot = buildBoardSnapshot(domain);
-  const epicIdSet = new Set(selection.epicIds ?? []);
-  const taskIdSet = new Set(selection.taskIds ?? []);
-  const subtaskIdSet = new Set(selection.subtaskIds ?? []);
-  const dependencyIdSet = new Set(selection.dependencyIds ?? []);
-
-  return {
-    generatedAt: snapshot.generatedAt,
-    epics: snapshot.epics.filter((epic) => epicIdSet.has(epic.id)),
-    tasks: snapshot.tasks.filter((task) => taskIdSet.has(task.id)),
-    subtasks: snapshot.subtasks.filter((subtask) => subtaskIdSet.has(subtask.id)),
-    dependencies: snapshot.dependencies.filter((dependency) => dependencyIdSet.has(dependency.id)),
-    deletedSubtaskIds: [...(selection.deletedSubtaskIds ?? [])],
-    deletedDependencyIds: [...(selection.deletedDependencyIds ?? [])],
-  };
-}
+const buildSnapshotDelta = buildBoardSnapshotDelta;
 
 function buildMutationDeltaResponse(
   domain: TrackerDomain,

package/src/board/server.ts

@@ -3,9 +3,11 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, extname, resolve } from "node:path";
 
 import { createBoardApiHandler } from "./routes";
+import { buildBoardSnapshot } from "./snapshot";
 
 import { openTrekoonDatabase, type TrekoonDatabase } from "../storage/database";
 import { resolveStoragePaths } from "../storage/path";
+import { TrackerDomain } from "../domain/tracker-domain";
 
 const CONTENT_TYPES: Record<string, string> = {
   ".css": "text/css; charset=utf-8",
@@ -87,6 +89,37 @@ function isUnavailablePortError(error: unknown): boolean {
   return /^(EADDRINUSE|EACCES)$/i.test(errorCode) || /(EADDRINUSE|EACCES|address already in use|permission denied)/i.test(error.message);
 }
 
+function buildBoardSessionCookie(token: string): string {
+  return `trekoon_board_session=${encodeURIComponent(token)}; Path=/; SameSite=Strict; HttpOnly`;
+}
+
+function serializeInlineJson(value: unknown): string {
+  return JSON.stringify(value)
+    .replace(/</g, "\\u003c")
+    .replace(/>/g, "\\u003e")
+    .replace(/&/g, "\\u0026")
+    .replace(/\u2028/g, "\\u2028")
+    .replace(/\u2029/g, "\\u2029");
+}
+
+function buildBoardBootstrapPayload(database: TrekoonDatabase, token: string): string {
+  const domain = new TrackerDomain(database.db);
+  return serializeInlineJson({
+    token,
+    snapshot: buildBoardSnapshot(domain),
+  });
+}
+
+function injectBoardBootstrap(html: string, bootstrapJson: string): string {
+  const bootstrapTag = `<script id="trekoon-board-bootstrap" type="application/json">${bootstrapJson}</script>`;
+  const closingBodyIndex = html.lastIndexOf("</body>");
+  if (closingBodyIndex === -1) {
+    return `${html}${bootstrapTag}`;
+  }
+
+  return `${html.slice(0, closingBodyIndex)}${bootstrapTag}\n${html.slice(closingBodyIndex)}`;
+}
+
 export function startBoardServer(options: StartBoardServerOptions = {}): BoardServerInfo {
   const cwd: string = options.cwd ?? process.cwd();
   const database: TrekoonDatabase = openTrekoonDatabase(cwd);
@@ -110,6 +143,13 @@ export function startBoardServer(options: StartBoardServerOptions = {}): BoardSe
           return apiHandler(request);
         }
 
+        const responseHeaders: Record<string, string> = {
+          "cache-control": "no-store",
+        };
+        if ((url.searchParams.get("token") ?? "") === token) {
+          responseHeaders["set-cookie"] = buildBoardSessionCookie(token);
+        }
+
         const assetPath = readAssetPath(boardRoot, url.pathname === "/" ? "/index.html" : url.pathname);
         if (assetPath === null) {
           const fallbackPath = readAssetPath(boardRoot, "/index.html");
@@ -117,9 +157,21 @@ export function startBoardServer(options: StartBoardServerOptions = {}): BoardSe
             return new Response("Board assets are not installed", { status: 500 });
           }
 
-          return new Response(readFileSync(fallbackPath), {
+          const html = injectBoardBootstrap(readFileSync(fallbackPath, "utf8"), buildBoardBootstrapPayload(database, token));
+
+          return new Response(html, {
+            headers: {
+              ...responseHeaders,
+              "content-type": "text/html; charset=utf-8",
+            },
+          });
+        }
+
+        if (assetPath.endsWith("/index.html")) {
+          const html = injectBoardBootstrap(readFileSync(assetPath, "utf8"), buildBoardBootstrapPayload(database, token));
+          return new Response(html, {
             headers: {
-              "cache-control": "no-store",
+              ...responseHeaders,
               "content-type": "text/html; charset=utf-8",
             },
           });
@@ -127,7 +179,7 @@ export function startBoardServer(options: StartBoardServerOptions = {}): BoardSe
 
         return new Response(readFileSync(assetPath), {
           headers: {
-            "cache-control": "no-store",
+            ...responseHeaders,
             "content-type": guessContentType(assetPath),
           },
         });
@@ -169,11 +221,12 @@ export function startBoardServer(options: StartBoardServerOptions = {}): BoardSe
 
   const origin: string = `http://127.0.0.1:${port}`;
   const url: string = `${origin}/?token=${encodeURIComponent(token)}`;
+  const fallbackUrl: string = origin;
 
   return {
     origin,
     url,
-    fallbackUrl: url,
+    fallbackUrl,
     token,
     hostname: "127.0.0.1",
     port,

package/src/board/snapshot.ts

@@ -85,6 +85,15 @@ export interface BoardSnapshot {
   };
 }
 
+interface SnapshotDeltaSelection {
+  readonly epicIds?: readonly string[];
+  readonly taskIds?: readonly string[];
+  readonly subtaskIds?: readonly string[];
+  readonly dependencyIds?: readonly string[];
+  readonly deletedSubtaskIds?: readonly string[];
+  readonly deletedDependencyIds?: readonly string[];
+}
+
 function normalizeStatusBucket(status: string): keyof Omit<StatusCounts, "total"> {
   if (status === "todo") return "todo";
   if (status === "blocked") return "blocked";
@@ -125,56 +134,32 @@ function mapDependency(record: DependencyRecord): BoardSnapshotDependency {
   };
 }
 
-export function buildBoardSnapshot(domain: TrackerDomain): BoardSnapshot {
-  const generatedAt = Date.now();
-  const epics = domain.listEpics();
-  const tasks = domain.listTasks();
-  const subtasks = domain.listSubtasks();
-  const sourceIds = [...tasks.map((task) => task.id), ...subtasks.map((subtask) => subtask.id)];
-  const dependenciesBySourceId = domain.listDependenciesBySourceIds(sourceIds);
-  const subtasksByTaskId = new Map<string, SubtaskRecord[]>();
-  const tasksByEpicId = new Map<string, TaskRecord[]>();
+function uniqueIds(ids: readonly string[]): string[] {
+  return [...new Set(ids.filter((id) => id.length > 0))];
+}
+
+function buildDependencyIndexes(dependenciesBySourceId: Map<string, readonly DependencyRecord[]>, sourceIds: readonly string[]) {
   const dependencyIdsBySource = new Map<string, string[]>();
   const blockedByIdsBySource = new Map<string, string[]>();
   const dependentIdsByTarget = new Map<string, string[]>();
   const blocksByTarget = new Map<string, string[]>();
   const dependencies: BoardSnapshotDependency[] = [];
 
-  for (const task of tasks) {
-    const existing = tasksByEpicId.get(task.epicId) ?? [];
-    existing.push(task);
-    tasksByEpicId.set(task.epicId, existing);
-  }
-
-  for (const subtask of subtasks) {
-    const existing = subtasksByTaskId.get(subtask.taskId) ?? [];
-    existing.push(subtask);
-    subtasksByTaskId.set(subtask.taskId, existing);
-  }
-
   for (const sourceId of sourceIds) {
     for (const dependency of dependenciesBySourceId.get(sourceId) ?? []) {
       dependencies.push(mapDependency(dependency));
-
-      const sourceDependencyIds = dependencyIdsBySource.get(dependency.sourceId) ?? [];
-      sourceDependencyIds.push(dependency.id);
-      dependencyIdsBySource.set(dependency.sourceId, sourceDependencyIds);
-
-      const sourceBlockedBy = blockedByIdsBySource.get(dependency.sourceId) ?? [];
-      sourceBlockedBy.push(dependency.dependsOnId);
-      blockedByIdsBySource.set(dependency.sourceId, sourceBlockedBy);
-
-      const targetDependentIds = dependentIdsByTarget.get(dependency.dependsOnId) ?? [];
-      targetDependentIds.push(dependency.id);
-      dependentIdsByTarget.set(dependency.dependsOnId, targetDependentIds);
-
-      const targetBlocks = blocksByTarget.get(dependency.dependsOnId) ?? [];
-      targetBlocks.push(dependency.sourceId);
-      blocksByTarget.set(dependency.dependsOnId, targetBlocks);
+      (dependencyIdsBySource.get(dependency.sourceId) ?? dependencyIdsBySource.set(dependency.sourceId, []).get(dependency.sourceId) ?? []).push(dependency.id);
+      (blockedByIdsBySource.get(dependency.sourceId) ?? blockedByIdsBySource.set(dependency.sourceId, []).get(dependency.sourceId) ?? []).push(dependency.dependsOnId);
+      (dependentIdsByTarget.get(dependency.dependsOnId) ?? dependentIdsByTarget.set(dependency.dependsOnId, []).get(dependency.dependsOnId) ?? []).push(dependency.id);
+      (blocksByTarget.get(dependency.dependsOnId) ?? blocksByTarget.set(dependency.dependsOnId, []).get(dependency.dependsOnId) ?? []).push(dependency.sourceId);
     }
   }
 
-  const snapshotSubtasks: BoardSnapshotSubtask[] = subtasks.map((subtask) => ({
+  return { dependencies, dependencyIdsBySource, blockedByIdsBySource, dependentIdsByTarget, blocksByTarget };
+}
+
+function mapSnapshotSubtask(subtask: SubtaskRecord, indexes: ReturnType<typeof buildDependencyIndexes>): BoardSnapshotSubtask {
+  return {
     id: subtask.id,
     kind: "subtask",
     taskId: subtask.taskId,
@@ -184,12 +169,113 @@ export function buildBoardSnapshot(domain: TrackerDomain): BoardSnapshot {
     owner: subtask.owner ?? null,
     createdAt: subtask.createdAt,
     updatedAt: subtask.updatedAt,
-    blockedBy: blockedByIdsBySource.get(subtask.id) ?? [],
-    blocks: blocksByTarget.get(subtask.id) ?? [],
-    dependencyIds: dependencyIdsBySource.get(subtask.id) ?? [],
-    dependentIds: dependentIdsByTarget.get(subtask.id) ?? [],
+    blockedBy: indexes.blockedByIdsBySource.get(subtask.id) ?? [],
+    blocks: indexes.blocksByTarget.get(subtask.id) ?? [],
+    dependencyIds: indexes.dependencyIdsBySource.get(subtask.id) ?? [],
+    dependentIds: indexes.dependentIdsByTarget.get(subtask.id) ?? [],
     searchText: [subtask.title, subtask.description, subtask.status].join(" ").toLowerCase(),
-  }));
+  };
+}
+
+function mapSnapshotTask(task: TaskRecord, taskSubtasks: readonly BoardSnapshotSubtask[], indexes: ReturnType<typeof buildDependencyIndexes>): BoardSnapshotTask {
+  return {
+    id: task.id,
+    kind: "task",
+    epicId: task.epicId,
+    title: task.title,
+    description: task.description,
+    status: task.status,
+    owner: task.owner ?? null,
+    createdAt: task.createdAt,
+    updatedAt: task.updatedAt,
+    blockedBy: indexes.blockedByIdsBySource.get(task.id) ?? [],
+    blocks: indexes.blocksByTarget.get(task.id) ?? [],
+    dependencyIds: indexes.dependencyIdsBySource.get(task.id) ?? [],
+    dependentIds: indexes.dependentIdsByTarget.get(task.id) ?? [],
+    subtasks: taskSubtasks,
+    searchText: [task.title, task.description, task.status, ...taskSubtasks.map((subtask) => `${subtask.title} ${subtask.description} ${subtask.status}`)].join(" ").toLowerCase(),
+  };
+}
+
+function mapSnapshotEpic(epic: EpicRecord, epicTasks: readonly BoardSnapshotTask[]): BoardSnapshotEpic {
+  return {
+    id: epic.id,
+    title: epic.title,
+    description: epic.description,
+    status: epic.status,
+    createdAt: epic.createdAt,
+    updatedAt: epic.updatedAt,
+    taskIds: epicTasks.map((task) => task.id),
+    counts: deriveFlatCounts(epicTasks),
+    searchText: [epic.title, epic.description, ...epicTasks.map((task) => task.searchText)].join(" ").toLowerCase(),
+  };
+}
+
+export function buildBoardSnapshotDelta(domain: TrackerDomain, selection: SnapshotDeltaSelection): Record<string, unknown> {
+  const epicIds = uniqueIds(selection.epicIds ?? []);
+  const requestedTaskIds = uniqueIds(selection.taskIds ?? []);
+  const requestedSubtaskIds = uniqueIds(selection.subtaskIds ?? []);
+  const requestedDependencyIds = new Set(selection.dependencyIds ?? []);
+  const relatedTaskIds = uniqueIds([
+    ...requestedTaskIds,
+    ...requestedSubtaskIds.map((subtaskId) => domain.getSubtask(subtaskId)?.taskId ?? ""),
+  ]);
+  const tasks = relatedTaskIds.map((taskId) => domain.getTask(taskId)).filter((task): task is TaskRecord => task !== null);
+  const subtasksByTaskId = new Map<string, readonly SubtaskRecord[]>();
+  for (const task of tasks) {
+    subtasksByTaskId.set(task.id, domain.listSubtasks(task.id));
+  }
+  const allSubtasks = uniqueIds([
+    ...requestedSubtaskIds,
+    ...[...subtasksByTaskId.values()].flatMap((taskSubtasks) => taskSubtasks.map((subtask) => subtask.id)),
+  ]).map((subtaskId) => domain.getSubtask(subtaskId)).filter((subtask): subtask is SubtaskRecord => subtask !== null);
+  const sourceIds = uniqueIds([...tasks.map((task) => task.id), ...allSubtasks.map((subtask) => subtask.id)]);
+  const indexes = buildDependencyIndexes(domain.listDependenciesBySourceIds(sourceIds), sourceIds);
+  const snapshotSubtasksByTaskId = new Map<string, BoardSnapshotSubtask[]>();
+  for (const subtask of allSubtasks) {
+    const mappedSubtask = mapSnapshotSubtask(subtask, indexes);
+    const taskSubtasks = snapshotSubtasksByTaskId.get(subtask.taskId) ?? [];
+    taskSubtasks.push(mappedSubtask);
+    snapshotSubtasksByTaskId.set(subtask.taskId, taskSubtasks);
+  }
+  const snapshotTasks = tasks.map((task) => mapSnapshotTask(task, snapshotSubtasksByTaskId.get(task.id) ?? [], indexes));
+  const snapshotEpics = epicIds.map((epicId) => domain.getEpic(epicId)).filter((epic): epic is EpicRecord => epic !== null).map((epic) => mapSnapshotEpic(epic, snapshotTasks.filter((task) => task.epicId === epic.id)));
+
+  return {
+    generatedAt: Date.now(),
+    epics: snapshotEpics,
+    tasks: snapshotTasks.filter((task) => requestedTaskIds.includes(task.id)),
+    subtasks: allSubtasks.map((subtask) => mapSnapshotSubtask(subtask, indexes)).filter((subtask) => requestedSubtaskIds.includes(subtask.id)),
+    dependencies: indexes.dependencies.filter((dependency) => requestedDependencyIds.has(dependency.id)),
+    deletedSubtaskIds: [...(selection.deletedSubtaskIds ?? [])],
+    deletedDependencyIds: [...(selection.deletedDependencyIds ?? [])],
+  };
+}
+
+export function buildBoardSnapshot(domain: TrackerDomain): BoardSnapshot {
+  const generatedAt = Date.now();
+  const epics = domain.listEpics();
+  const tasks = domain.listTasks();
+  const subtasks = domain.listSubtasks();
+  const sourceIds = [...tasks.map((task) => task.id), ...subtasks.map((subtask) => subtask.id)];
+  const dependenciesBySourceId = domain.listDependenciesBySourceIds(sourceIds);
+  const subtasksByTaskId = new Map<string, SubtaskRecord[]>();
+  const tasksByEpicId = new Map<string, TaskRecord[]>();
+  const indexes = buildDependencyIndexes(dependenciesBySourceId, sourceIds);
+
+  for (const task of tasks) {
+    const existing = tasksByEpicId.get(task.epicId) ?? [];
+    existing.push(task);
+    tasksByEpicId.set(task.epicId, existing);
+  }
+
+  for (const subtask of subtasks) {
+    const existing = subtasksByTaskId.get(subtask.taskId) ?? [];
+    existing.push(subtask);
+    subtasksByTaskId.set(subtask.taskId, existing);
+  }
+
+  const snapshotSubtasks: BoardSnapshotSubtask[] = subtasks.map((subtask) => mapSnapshotSubtask(subtask, indexes));
   const snapshotSubtasksByTaskId = new Map<string, BoardSnapshotSubtask[]>();
   for (const subtask of snapshotSubtasks) {
     const existing = snapshotSubtasksByTaskId.get(subtask.taskId) ?? [];
@@ -197,31 +283,7 @@ export function buildBoardSnapshot(domain: TrackerDomain): BoardSnapshot {
     snapshotSubtasksByTaskId.set(subtask.taskId, existing);
   }
 
-  const snapshotTasks: BoardSnapshotTask[] = tasks.map((task) => {
-    const taskSubtasks = snapshotSubtasksByTaskId.get(task.id) ?? [];
-    return {
-      id: task.id,
-      kind: "task",
-      epicId: task.epicId,
-      title: task.title,
-      description: task.description,
-      status: task.status,
-      owner: task.owner ?? null,
-      createdAt: task.createdAt,
-      updatedAt: task.updatedAt,
-      blockedBy: blockedByIdsBySource.get(task.id) ?? [],
-      blocks: blocksByTarget.get(task.id) ?? [],
-      dependencyIds: dependencyIdsBySource.get(task.id) ?? [],
-      dependentIds: dependentIdsByTarget.get(task.id) ?? [],
-      subtasks: taskSubtasks,
-      searchText: [
-        task.title,
-        task.description,
-        task.status,
-        ...taskSubtasks.map((subtask) => `${subtask.title} ${subtask.description} ${subtask.status}`),
-      ].join(" ").toLowerCase(),
-    };
-  });
+  const snapshotTasks: BoardSnapshotTask[] = tasks.map((task) => mapSnapshotTask(task, snapshotSubtasksByTaskId.get(task.id) ?? [], indexes));
   const taskSearchTextByEpicId = new Map<string, string[]>();
   for (const task of snapshotTasks) {
     const existing = taskSearchTextByEpicId.get(task.epicId) ?? [];
@@ -229,32 +291,19 @@ export function buildBoardSnapshot(domain: TrackerDomain): BoardSnapshot {
     taskSearchTextByEpicId.set(task.epicId, existing);
   }
 
-  const snapshotEpics: BoardSnapshotEpic[] = epics.map((epic) => {
-    const epicTasks = tasksByEpicId.get(epic.id) ?? [];
-    return {
-      id: epic.id,
-      title: epic.title,
-      description: epic.description,
-      status: epic.status,
-      createdAt: epic.createdAt,
-      updatedAt: epic.updatedAt,
-      taskIds: epicTasks.map((task) => task.id),
-      counts: deriveFlatCounts(epicTasks),
-      searchText: [epic.title, epic.description, ...(taskSearchTextByEpicId.get(epic.id) ?? [])].join(" ").toLowerCase(),
-    };
-  });
+  const snapshotEpics: BoardSnapshotEpic[] = epics.map((epic) => mapSnapshotEpic(epic, snapshotTasks.filter((task) => task.epicId === epic.id)));
 
   return {
     generatedAt,
     epics: snapshotEpics,
     tasks: snapshotTasks,
     subtasks: snapshotSubtasks,
-    dependencies,
+    dependencies: indexes.dependencies,
     counts: {
       epics: countStatuses(epics),
       tasks: countStatuses(tasks),
       subtasks: countStatuses(subtasks),
-      dependencies: dependencies.length,
+      dependencies: indexes.dependencies.length,
     },
   };
 }