@shivaedev/work-board 0.12.0 → 0.14.0

package/src/server/navigation/model.ts

@@ -1,79 +1,24 @@
-import { type Navigation, type NavigationFile, NavigationFolder } from "#browser/navigation/schema.ts";
-import { fileUrl } from "#files/url.ts";
-import { fleetRecords, inboxItems } from "#server/attention/inbox.ts";
+import type { Navigation } from "#browser/Navigation.ts";
+import { openItem } from "#server/attention/inbox.ts";
+import { attentionProjection } from "#server/attention/projection.ts";
 import type { MarkdownFile } from "#server/files/list.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
+import { goals } from "#server/views/goals.ts";
 
 export function inboxCount(snapshot?: Snapshot): number | null {
-	return !snapshot || snapshot.unavailable.length > 0 ? null : inboxItems(snapshot).length;
+	return snapshot && snapshot.unavailable.length === 0 ? attentionProjection(snapshot).you.length : null;
 }
-
-function fileData(file: MarkdownFile, current: string): NavigationFile {
-	return {
-		current: file.path === current,
-		href: fileUrl(file.path),
-		modified: file.modified,
-		name: file.path.slice(file.path.lastIndexOf("/") + 1).replace(/\.md$/u, ""),
-		path: file.path,
-	};
-}
-
-function homeData(file: string, snapshot: Snapshot | undefined) {
-	const id = snapshot?.documents.find((document) => document.file === file)?.parsed.fields.id;
+export function navigationData(files: readonly MarkdownFile[], _current: string, home: string | undefined, snapshot?: Snapshot): Navigation {
+	const id = snapshot?.documents.find((document) => document.file === home)?.parsed.fields.id;
 	const unique = id !== undefined && snapshot?.unavailable.length === 0 && snapshot.model.ids.get(id)?.length === 1;
-	return { file, ...(unique ? { identity: id } : {}) };
-}
-
-interface Branch {
-	active: boolean;
-	count: number;
-	readonly files: NavigationFile[];
-	readonly folders: Map<string, Branch>;
-	readonly name: string;
-	readonly path: string;
-}
-
-function branch(path: string, name: string): Branch {
-	return { active: false, count: 0, files: [], folders: new Map(), name, path };
-}
-
-function folderData(folder: Branch): NavigationFolder {
-	return new NavigationFolder({
-		...folder,
-		folders: [...folder.folders].sort(([left], [right]) => left.localeCompare(right)).map(([, child]) => folderData(child)),
-	});
-}
-
-export function navigationData(files: readonly MarkdownFile[], current: string, home: string | undefined, snapshot?: Snapshot): Navigation {
-	const generated = snapshot ? fleetRecords(snapshot.model) : new Set<string>();
-	const records = files.filter((file) => generated.has(file.path)).map((file) => fileData(file, current));
-	const visible = files.filter((file) => !generated.has(file.path));
-	const root = branch("", "");
-	const ordered = [
-		...visible.filter((file) => file.path === home),
-		...visible.filter((file) => file.path !== home).toSorted((left, right) => left.path.localeCompare(right.path)),
-	];
-	for (const file of ordered) {
-		let parent = root;
-		parent.count += 1;
-		parent.active ||= file.path === current;
-		const parts = file.path === home ? [] : file.path.split("/").slice(0, -1);
-		for (const name of parts) {
-			let child = parent.folders.get(name);
-			if (child === undefined) {
-				child = branch(parent.path === "" ? name : `${parent.path}/${name}`, name);
-				parent.folders.set(name, child);
-			}
-			child.count += 1;
-			child.active ||= file.path === current;
-			parent = child;
-		}
-		parent.files.push(fileData(file, current));
-	}
 	return {
-		...(home === undefined ? {} : { home: homeData(home, snapshot) }),
+		...(home === undefined ? {} : { home: { file: home, ...(unique ? { identity: id } : {}) } }),
+		counts: {
+			goals: snapshot ? goals(snapshot).goals.length : 0,
+			library: files.length,
+			now: snapshot?.documents.filter((document) => document.parsed.fields.kind === "task" && openItem(document)).length ?? 0,
+			system: snapshot ? [...snapshot.model.diagnostics.values()].flat().length + snapshot.unavailable.length : 0,
+		},
 		inboxCount: inboxCount(snapshot),
-		records: { active: records.some((file) => file.current), count: records.length, files: records },
-		tree: folderData(root),
 	};
 }

package/src/server/packageInfo.ts

@@ -0,0 +1,2 @@
+export const NAME = "work-board";
+export const VERSION = "0.14.0";

package/src/server/page/initialTheme.ts

@@ -0,0 +1,13 @@
+export const THEME_ROUTE = "/_board/theme.js";
+export const INITIAL_THEME_SCRIPT = `(() => {
+  const root = document.documentElement;
+  let theme = "system";
+  try {
+    const saved = JSON.parse(localStorage.getItem("work-board:appearance:" + root.dataset.workspace) || "{}");
+    if (saved.theme === "dark" || saved.theme === "light") theme = saved.theme;
+  } catch {}
+  const dark = theme === "dark" || (theme === "system" && matchMedia("(prefers-color-scheme: dark)").matches);
+  root.dataset.theme = theme;
+  root.dataset.scheme = dark ? "dark" : "light";
+  root.classList.toggle("dark", dark);
+})();`;

package/src/server/page/shell.ts

@@ -1,50 +1,12 @@
 import { escapeHtml } from "#browser/escapeHtml.ts";
-import { fileUrl } from "#files/url.ts";
-import type { Snapshot } from "#server/search/snapshot.ts";
-import { inboxCount } from "./nav.ts";
-import { searchDialog } from "./searchDialog.ts";
-import { visualDialog } from "./visualDialog.ts";
+import { THEME_ROUTE } from "./initialTheme.ts";
 
-function location(file: string): string {
-	return file
-		.split("/")
-		.map((part) => `<span>${escapeHtml(part)}</span>`)
-		.join('<span class="separator">/</span>');
-}
-
-export function shell(
-	title: string,
-	nav: string,
-	main: string,
-	workspace: string,
-	board: boolean,
-	identity?: string,
-	view: boolean | "diagnostics" | "overview" | "changes" | "start" | "response" | "handoff" | "result" | "inbox" = false,
-	snapshot?: Snapshot,
-): string {
-	const legacy = [
-		'<a class="skip" href="#doc">Skip to content</a><div class="workspace">',
-		'<aside id="sidebar" class="sidebar" aria-label="Workspace navigation"><a class="brand" href="/">work board<span>Local workspace</span></a>',
-		`<nav id="primary-navigation" class="primary-navigation" aria-label="Workspace"><a id="home-open" href="/">Home</a><a id="inbox-open" class="inbox-link" href="/_board/inbox"${view === "inbox" ? ' aria-current="page"' : ""}>Inbox <span id="inbox-count" class="inbox-count" aria-label="${inboxCount(snapshot)} waiting">${inboxCount(snapshot)}</span></a>`,
-		`<a id="overview-open" href="/_board/overview"${view === "overview" ? ' aria-current="page"' : ""}>Overview</a><a id="work-open" href="/_board/work?view=board"${view === true ? ' aria-current="page"' : ""}>Work</a><a id="changes-open" href="/_board/changes"${view === "changes" ? ' aria-current="page"' : ""}>Changes</a><a id="diagnostics-open" href="/_board/diagnostics"${view === "diagnostics" ? ' aria-current="page"' : ""}>Diagnostics</a></nav>`,
-		'<button id="library-open" type="button" aria-haspopup="dialog" aria-controls="library-dialog" disabled>Recent documents</button><a id="start-open" class="start-open" href="/_board/start">Getting started</a><h2 class="nav-heading">Project files</h2>',
-		`<nav id="files" class="files" aria-label="Project files">${nav}</nav></aside>`,
-		'<div id="sidebar-backdrop" class="sidebar-backdrop" hidden></div><div class="page"><header class="bar"><button id="sidebar-toggle" type="button" aria-controls="sidebar" aria-expanded="true">Files</button>',
-		`<nav id="breadcrumbs" class="breadcrumbs" aria-label="File location"><a href="/">Workspace</a><span class="separator">/</span>${location(title)}</nav>`,
-		`<a id="inbox-topbar" class="inbox-link work-open" href="/_board/inbox"${view === "inbox" ? ' aria-current="page"' : ""}>Inbox <span id="inbox-topbar-count" class="inbox-count" aria-label="${inboxCount(snapshot)} waiting">${inboxCount(snapshot)}</span></a><button id="search-open" type="button" disabled aria-haspopup="dialog" aria-controls="search-dialog">Search <kbd>⌘/Ctrl K</kbd></button><span id="live" class="live" role="status">connecting</span><span id="navigation-status" role="status"></span></header>`,
-		'<div class="preferences" role="group" aria-label="Reading preferences">',
-		'<div class="preference"><label for="theme">Theme</label><select id="theme"><option value="system">System</option><option value="light">Light</option><option value="dark">Dark</option></select></div>',
-		'<div class="preference"><label for="density">Density</label><select id="density"><option value="comfortable">Comfortable</option><option value="compact">Compact</option></select></div>',
-		'<button id="updates-toggle" type="button" aria-pressed="false" disabled>Pause updates</button><span id="preference-status" role="status"></span></div>',
-		`<main${view ? ` data-view="${typeof view === "string" ? view : "work"}"` : ""}${identity ? ` data-identity="${escapeHtml(identity)}"` : ""} id="doc" data-file="${escapeHtml(title)}" data-url="${escapeHtml(fileUrl(title))}" class="${board ? "board-view" : "document-view"}" tabindex="-1">${main}</main>`,
-		`</div></div>${searchDialog}${visualDialog}<dialog id="library-dialog" aria-labelledby="library-title"><div class="search-header"><h2 id="library-title">Reading history</h2><button id="library-close" type="button">Close</button></div><div id="reading-library" class="reading-library"></div></dialog>`,
-	].join("");
+export function shell(title: string, workspace: string): string {
 	return [
 		`<!doctype html><html lang="en" data-workspace="${escapeHtml(workspace)}"><head><meta charset="utf-8">`,
 		'<meta name="viewport" content="width=device-width, initial-scale=1"><meta name="color-scheme" content="light dark">',
-		`<title>${escapeHtml(title)}</title>`,
-		'<link rel="stylesheet" href="/_board/react.css"><link rel="stylesheet" href="/_board/style.css"><script type="module" src="/_board/react.js"></script>',
-		`</head><body><noscript data-board-fallback><style>html:not([data-js]) figure.diagram .diagram-source{display:block}html:not([data-js]) figure.diagram[data-state="pending"]{min-height:0}</style>${legacy}</noscript>`,
-		`<div data-board-react-root></div><template id="board-legacy-page">${legacy}</template></body></html>`,
+		`<title>${escapeHtml(title)}</title><script src="${THEME_ROUTE}"></script>`,
+		'<link rel="stylesheet" href="/_board/react.css"><script type="module" src="/_board/react.js"></script>',
+		"</head><body><div data-board-react-root></div></body></html>",
 	].join("");
 }

package/src/server/page/startTemplates.ts

@@ -47,8 +47,8 @@ Explain the decision in context; do not require the reader to reconstruct it.
 ## Options and tradeoffs
 | Option | Benefit | Cost | Evidence |
 | --- | --- | --- | --- |
-| First option | Not recorded | Not recorded | Not recorded |
-| Second option | Not recorded | Not recorded | Not recorded |
+| First option | | | |
+| Second option | | | |
 
 ## Recommendation
 State your take and what remains uncertain.
@@ -96,7 +96,7 @@ Explain what changed and why. Link the relevant source files or patch.
 [Investigation and alternatives](investigation.md)
 
 ## Checks and evidence
-Not recorded. Replace this with actual commands, observations and local evidence links.
+Add actual commands, observations and local evidence links.
 Recorded evidence does not by itself establish verified acceptance.
 
 ## Limits and unresolved questions

package/src/server/responseIndex.ts

@@ -0,0 +1,97 @@
+import type { Question, RecordedResponse } from "#browser/responses/schema.ts";
+import { currentResponses } from "#responses/current.ts";
+import type { MetadataDocument, MetadataModel } from "#server/metadata/model.ts";
+import { malformedResponse, questionFrom, responseFrom } from "#server/responses/records.ts";
+
+interface ResponseGroup {
+	readonly ambiguous: boolean;
+	readonly answered: boolean;
+	readonly current: readonly RecordedResponse[];
+	readonly responses: readonly RecordedResponse[];
+}
+interface ResponseIndex {
+	readonly malformed: boolean;
+	readonly questions: ReadonlyMap<string, Question>;
+	readonly questionsFor: (item: string, request?: string) => readonly Question[];
+	readonly receiptProblems: boolean;
+	readonly receipts: ReadonlyMap<string, readonly MetadataDocument[]>;
+	readonly responses: ReadonlyMap<string, RecordedResponse>;
+	readonly responsesFor: (question: Question) => ResponseGroup;
+}
+
+const cached = new WeakMap<MetadataModel, ResponseIndex>();
+const empty: ResponseGroup = { ambiguous: false, answered: false, current: [], responses: [] };
+
+function append<A>(groups: Map<string, A[]>, key: string, value: A) {
+	const matches = groups.get(key) ?? [];
+	matches.push(value);
+	groups.set(key, matches);
+}
+
+function responseGroups(records: ReadonlyMap<string, RecordedResponse>, model: MetadataModel) {
+	const grouped = new Map<string, RecordedResponse[]>();
+	for (const record of records.values()) {
+		append(grouped, `${record.response.question}\0${record.response.reviewedRevision}`, record);
+	}
+	return new Map(
+		[...grouped].map(([key, responses]) => {
+			responses.sort((left, right) => left.response.recordedAt - right.response.recordedAt || left.id.localeCompare(right.id));
+			return [
+				key,
+				{
+					ambiguous: responses.some((record) => model.ids.get(record.id)?.length !== 1),
+					answered: responses.some((record) => record.response.type === "answer" && model.ids.get(record.id)?.length === 1),
+					current: currentResponses(responses),
+					responses,
+				},
+			] as const;
+		}),
+	);
+}
+
+function buildIndex(model: MetadataModel): ResponseIndex {
+	const questions = new Map<string, Question>();
+	const items = new Map<string, Question[]>();
+	const requests = new Map<string, Question[]>();
+	const responses = new Map<string, RecordedResponse>();
+	const receipts = new Map<string, MetadataDocument[]>();
+	let malformed = false;
+	let receiptProblems = false;
+	for (const document of model.documents) {
+		const question = questionFrom(document);
+		if (question) {
+			questions.set(document.file, question);
+			append(items, question.question.item, question);
+			append(requests, `${question.question.item}\0${question.question.request}`, question);
+		}
+		const response = responseFrom(document);
+		if (response) {
+			responses.set(document.file, response);
+		}
+		const receipt = document.parsed.fields.requestReceipt;
+		if (receipt) {
+			append(receipts, receipt.question, document);
+		}
+		malformed ||= malformedResponse(document);
+		receiptProblems ||= document.parsed.diagnostics.some((problem) => problem.field === "request_receipt" || problem.field === "requestReceipt");
+	}
+	const groups = responseGroups(responses, model);
+	return {
+		malformed,
+		questions,
+		questionsFor: (item, request) => (request === undefined ? items.get(item) : requests.get(`${item}\0${request}`)) ?? [],
+		receiptProblems,
+		receipts,
+		responses,
+		responsesFor: (question) => groups.get(`${question.id}\0${question.question.reviewedRevision}`) ?? empty,
+	};
+}
+
+export function responseIndex(model: MetadataModel): ResponseIndex {
+	let hit = cached.get(model);
+	if (!hit) {
+		hit = buildIndex(model);
+		cached.set(model, hit);
+	}
+	return hit;
+}

package/src/server/responses/agent.ts

@@ -1,8 +1,8 @@
 import * as NodeHttpClient from "@effect/platform-node/NodeHttpClient";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as RpcClient from "effect/unstable/rpc/RpcClient";
-import * as RpcSerialization from "effect/unstable/rpc/RpcSerialization";
+import * as RpcClient from "effect/rpc/RpcClient";
+import * as RpcSerialization from "effect/rpc/RpcSerialization";
 import { BadRequest } from "@shivaedev/platform/errors/taxonomy.ts";
 import { responseContract } from "#rpc/responseContract.ts";
 import { waitForResponse } from "./waitFor.ts";

package/src/server/responses/history.ts

@@ -1,17 +1,15 @@
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import type { QuestionPreview } from "#browser/responses/schema.ts";
+import { responseIndex } from "#server/responseIndex.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
-import { malformedResponse, questionFrom, responsesFor } from "./records.ts";
 
 export function responseHistory(data: Snapshot, preview: QuestionPreview) {
-	if (data.unavailable.length > 0 || data.documents.some(malformedResponse)) {
+	const index = responseIndex(data.model);
+	if (data.unavailable.length > 0 || index.malformed) {
 		throw new ServiceUnavailable({ message: "Response history is incomplete or malformed. Check the source diagnostics and retry." });
 	}
-	const questions = data.documents.flatMap((document) => {
-		const question = questionFrom(document);
-		return question && question.question.item === preview.item && question.question.request === preview.request ? [question] : [];
-	});
-	const responses = questions.flatMap((question) => responsesFor(data.documents, question).responses);
+	const questions = index.questionsFor(preview.item, preview.request);
+	const responses = questions.flatMap((question) => index.responsesFor(question).responses);
 	if ([...questions, ...responses].some((record) => data.model.ids.get(record.id)?.length !== 1)) {
 		throw new ServiceUnavailable({
 			message: "Response history includes ambiguous identities. Give each recorded question and response a unique ID, then retry.",

package/src/server/responses/locate.ts

@@ -3,9 +3,8 @@ import { BadRequest, NotFound, PreconditionFailed, ServiceUnavailable } from "@s
 import { rpcBoundary } from "@shivaedev/platform/rpc-server/boundary.ts";
 import type { QuestionPreview } from "#browser/responses/schema.ts";
 import type { ResponseRejection } from "#rpc/rejections.ts";
+import { currentDocument } from "#server/currentDocument.ts";
 import { markdownPath } from "#server/files/markdownPath.ts";
-import { metadataModel } from "#server/metadata/model.ts";
-import { metadataParse } from "#server/metadata/parse.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
 import { questionId, revisionOf } from "./records.ts";
 import { requestSource } from "./requestSource.ts";
@@ -30,10 +29,8 @@ export function locate(root: string, realRoot: string, snapshot: Effect.Effect<S
 		if (new TextEncoder().encode(source).length > 256 * 1024) {
 			return yield* Effect.fail(new BadRequest({ message: "Question context is limited to 256 KiB; use a focused source document." }));
 		}
-		const parsed = metadataParse(source);
-		const documents = [...data.documents.filter((document) => document.file !== entry.document.file), { file: entry.document.file, parsed }];
-		const model = metadataModel(documents, data.unavailable, data.model.rootFile);
-		const fresh = requestSource({ ...data, documents, model }, item, request);
+		const current = currentDocument(data, entry.document.file, source, data.model.rootFile);
+		const fresh = requestSource(current.snapshot, item, request);
 		if (!fresh) {
 			return yield* Effect.fail(
 				new PreconditionFailed({

package/src/server/responses/optionPrompt.ts

@@ -3,7 +3,7 @@ import type { Prompt } from "#browser/responses/Prompt.ts";
 import type { Metadata } from "#metadata/schema.ts";
 
 export function optionPrompt(fields: Metadata): Prompt | undefined {
-	if (fields.kind !== "question" || fields.question || fields.options === undefined) {
+	if (!["question", "decision"].includes(fields.kind ?? "") || fields.question || fields.options === undefined) {
 		return undefined;
 	}
 	if (new Set(fields.options.map((option) => option.label)).size !== fields.options.length) {

package/src/server/responses/read.ts

@@ -1,18 +1,22 @@
 import { Effect } from "effect";
 import { BadRequest, Conflict, NotFound, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { Reading } from "#browser/responses/schema.ts";
 import type { ResponseRejection } from "#rpc/rejections.ts";
-import type { MetadataDocument } from "#server/metadata/model.ts";
+import type { MetadataDocument, MetadataModel } from "#server/metadata/model.ts";
+import { responseIndex } from "#server/responseIndex.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
-import { malformedResponse, questionFrom, responsesFor } from "./records.ts";
 
-const registeredQuestion = Effect.fn("WorkBoard.registeredQuestion")(function* (matches: readonly MetadataDocument[] | undefined) {
+const registeredQuestion = Effect.fn("WorkBoard.registeredQuestion")(function* (
+	matches: readonly MetadataDocument[] | undefined,
+	model: MetadataModel,
+) {
 	if (!matches?.length) {
 		return yield* Effect.fail(new NotFound({ message: "The registered question is missing." }));
 	}
 	if (matches.length !== 1) {
 		return yield* Effect.fail(new Conflict({ message: "The registered question identity is ambiguous; response history is unknown." }));
 	}
-	const question = matches[0] && questionFrom(matches[0]);
+	const question = matches[0] && responseIndex(model).questions.get(matches[0].file);
 	if (!question) {
 		return yield* Effect.fail(new Conflict({ message: "This identity is not a valid registered question; response history is unknown." }));
 	}
@@ -24,16 +28,17 @@ export function readResponses(snapshot: Effect.Effect<Snapshot, ResponseRejectio
 		if (data.unavailable.length > 0) {
 			return yield* Effect.fail(new ServiceUnavailable({ message: "The workspace index is incomplete; no response can be selected safely." }));
 		}
-		const question = yield* registeredQuestion(data.model.ids.get(id));
+		const question = yield* registeredQuestion(data.model.ids.get(id), data.model);
 		if (new TextEncoder().encode(question.context).length > 256 * 1024) {
 			return yield* Effect.fail(new BadRequest({ message: "The registered context exceeds the 256 KiB limit." }));
 		}
-		if (data.documents.some(malformedResponse)) {
+		const index = responseIndex(data.model);
+		if (index.malformed) {
 			return yield* Effect.fail(
 				new ServiceUnavailable({ message: "A response record is malformed; response history cannot be established safely." }),
 			);
 		}
-		const result = responsesFor(data.documents, question);
+		const result: Reading = { question, responses: [...index.responsesFor(question).responses] };
 		if (result.responses.some((candidate) => candidate.body.length > 32_768)) {
 			return yield* Effect.fail(new BadRequest({ message: "A recorded response exceeds the supported text limit; read its source file directly." }));
 		}

package/src/server/responses/waitFor.ts

@@ -1,7 +1,7 @@
 import { Schema } from "effect";
 import * as Clock from "effect/Clock";
 import * as Effect from "effect/Effect";
-import type { RpcClientError } from "effect/unstable/rpc/RpcClientError";
+import type { RpcClientError } from "effect/rpc/RpcClientError";
 import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import type { WaitReading } from "#browser/responses/schema.ts";
 import { ResponseRejection, Unanswered } from "#rpc/rejections.ts";

package/src/server/rpc/HandlerOptions.ts

@@ -0,0 +1,16 @@
+import type { Effect } from "effect";
+import type { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { Document } from "#browser/document/schema.ts";
+import type { Server } from "#rpc/Server.ts";
+import type { Changes } from "#server/files/changes.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+
+export interface HandlerOptions {
+	readonly changes: Changes;
+	readonly document?: (url: string) => Effect.Effect<Document, unknown>;
+	readonly fleetPort?: number | null;
+	readonly home: string | undefined;
+	readonly index: Effect.Effect<Snapshot, unknown>;
+	readonly server?: Effect.Effect<typeof Server.Type, ServiceUnavailable>;
+	readonly writable?: boolean;
+}

package/src/server/rpc/handlers.ts

@@ -1,64 +1,75 @@
-import { Clock, Effect, Layer, Ref, Stream } from "effect";
-import type { HttpServerResponse } from "effect/unstable/http";
-import { InternalServerError, NotFound } from "@shivaedev/platform/errors/taxonomy.ts";
+import { Effect, Layer, Ref, Stream } from "effect";
+import { InternalServerError, NotFound, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
 import { rpcBoundary } from "@shivaedev/platform/rpc-server/boundary.ts";
 import { requestTracingLayer } from "@shivaedev/platform/rpc-server/tracing.ts";
+import { Diagnostics } from "#diagnostics/source.ts";
 import { workRpcs } from "#rpc/contract.ts";
 import { DocumentRejection, ResponseRejection } from "#rpc/rejections.ts";
 import { HandoffsService } from "#server/handoffs/Service.ts";
-import { historyResponse } from "#server/history/response.ts";
+import { libraryData } from "#server/navigation/libraryData.ts";
 import { navigationData } from "#server/navigation/model.ts";
 import { Responses } from "#server/responses/service.ts";
 import { searchMatch } from "#server/search/match.ts";
+import { fleetItems } from "#server/views/fleetItems.ts";
+import { goals } from "#server/views/goals.ts";
+import { projectionQueries } from "#server/views/projectionQueries.ts";
+import { remainingQueries } from "#server/views/remainingQueries.ts";
+import type { HandlerOptions } from "./HandlerOptions.ts";
 import { hints } from "./hints.ts";
-import type { ServerOptions } from "./transport.ts";
 
 const readBoundary = rpcBoundary(InternalServerError, { unexpected: (message) => new InternalServerError({ message }) });
 const documentBoundary = rpcBoundary(DocumentRejection, { unexpected: (message) => new InternalServerError({ message }) });
 const responseBoundary = rpcBoundary(ResponseRejection, { unexpected: (message) => new InternalServerError({ message }) });
 
-function readablePage(response: HttpServerResponse.HttpServerResponse) {
-	if (response.status >= 500 || response.body._tag !== "Uint8Array") {
-		return Effect.fail(
-			new InternalServerError({
-				message: `Page response is unreadable (status ${response.status}, body ${response.body._tag}). Retry the page; if it still fails, restart Work Board.`,
-			}),
-		);
-	}
-	return Effect.succeed({ html: new TextDecoder().decode(response.body.body), status: response.status });
-}
-
-export const handlers = Effect.fn("WorkBoard.handlers")(function* ({ changes, document, home, index, page }: ServerOptions) {
+export const handlers = Effect.fn("WorkBoard.handlers")(function* (options: HandlerOptions) {
+	const { changes, document, home, index } = options;
+	const projections = projectionQueries({ document, index });
 	const handoffs = yield* HandoffsService;
 	const responses = yield* Responses;
+	const diagnostics = yield* Diagnostics;
+	const remaining = remainingQueries(options, { diagnostics, handoffs, responses });
 	return workRpcs
 		.toLayer({
 			"work-board.awaitResponse": (input) => Effect.suspend(() => responses.awaitResponse(input)).pipe(responseBoundary),
+			"work-board.board": ({ url }) => Effect.suspend(() => projections.board(url)).pipe(documentBoundary),
+			"work-board.diagnostics": () => remaining.diagnostics().pipe(readBoundary),
 			"work-board.document": ({ url }) =>
 				Effect.suspend(() => (document ? document(url) : Effect.fail(new NotFound({ message: "The document is missing." })))).pipe(documentBoundary),
+			"work-board.fleetItems": () => fleetItems(options),
+			"work-board.goals": () =>
+				Effect.gen(function* () {
+					const snapshot = yield* index;
+					return goals(snapshot, yield* fleetItems({ ...options, index: Effect.succeed(snapshot) }));
+				}).pipe(readBoundary),
+			"work-board.handoff": ({ url }) => remaining.handoff(url).pipe(documentBoundary),
 			"work-board.handoffSource": ({ item }) => Effect.suspend(() => handoffs.locate(item)).pipe(responseBoundary),
 			"work-board.handoffs": ({ item }) => Effect.suspend(() => handoffs.read(item)).pipe(responseBoundary),
-			"work-board.history": ({ action, baseline }) =>
+			"work-board.inbox": () => Effect.suspend(() => projections.inbox()).pipe(readBoundary),
+			"work-board.library": (input) =>
 				Effect.gen(function* () {
-					const now = yield* Clock.currentTimeMillis;
-					const snapshot = action === "check" ? undefined : yield* index;
-					return historyResponse(baseline, now, snapshot);
+					return libraryData(yield* changes.files, yield* index, input);
 				}).pipe(readBoundary),
 			"work-board.navigation": ({ current }) =>
 				Effect.gen(function* () {
 					return navigationData(yield* changes.files, current, home, yield* index);
 				}).pipe(readBoundary),
-			"work-board.page": ({ url }) => Effect.suspend(() => page(url)).pipe(Effect.flatMap(readablePage), readBoundary),
 			"work-board.prepareHandoff": (input) => Effect.suspend(() => handoffs.prepare(input)).pipe(responseBoundary),
 			"work-board.question": ({ item, request }) => Effect.suspend(() => responses.locate(item, request)).pipe(responseBoundary),
 			"work-board.recordResponse": (input) => Effect.suspend(() => responses.record(input)).pipe(responseBoundary),
 			"work-board.registerQuestion": (input) => Effect.suspend(() => responses.register(input)).pipe(responseBoundary),
+			"work-board.respond": ({ url }) => remaining.respond(url).pipe(documentBoundary),
 			"work-board.responses": ({ question }) => Effect.suspend(() => responses.read(question)).pipe(responseBoundary),
+			"work-board.result": ({ url }) => remaining.result(url).pipe(documentBoundary),
 			"work-board.search": ({ query }) =>
-				Effect.map(index, (snapshot) => ({ ...searchMatch(snapshot.entries, query), unavailable: snapshot.unavailable })).pipe(readBoundary),
+				Effect.map(index, (snapshot) => ({ ...searchMatch(snapshot.entries, query, snapshot.modified), unavailable: snapshot.unavailable })).pipe(
+					readBoundary,
+				),
+			"work-board.server": () => options.server ?? Effect.fail(new ServiceUnavailable({ message: "The board server address is unavailable." })),
+			"work-board.start": () => remaining.start().pipe(readBoundary),
 			"work-board.subscribe": () =>
 				hints(changes, index).pipe(Stream.catchCause((cause) => Stream.fromEffect(Effect.failCause(cause).pipe(readBoundary)))),
 			"work-board.watcher": () => Effect.map(Ref.get(changes.watching), (watching) => ({ watching })).pipe(readBoundary),
+			"work-board.work": ({ url }) => Effect.suspend(() => projections.work(url)).pipe(documentBoundary),
 		})
 		.pipe(Layer.provideMerge(requestTracingLayer()));
 });

package/src/server/search/entries.ts

@@ -13,8 +13,13 @@ import { linkCollector } from "./linkCollector.ts";
 export interface Entry {
 	readonly file: string;
 	readonly href: string;
+	readonly id?: string | undefined;
+	readonly inactive?: boolean;
+	readonly itemKind?: string | undefined;
 	readonly kind: "document" | "heading" | "passage";
 	readonly line?: number;
+	readonly record?: boolean;
+	readonly status?: string | undefined;
 	readonly text: string;
 	readonly title: string;
 }

package/src/server/search/match.ts

@@ -1,28 +1,63 @@
 import type { Entry } from "./entries.ts";
+import { searchSnippet } from "./snippet.ts";
 
 function normalize(text: string): string {
 	return text.normalize("NFKC").toLowerCase().replace(/\s+/gu, " ").trim();
 }
 
-export function searchMatch(entries: readonly Entry[], query: string) {
-	const phrase = normalize(query.slice(0, 200));
+function resultType(entry: Entry): number {
+	if (entry.kind === "document" && entry.itemKind) {
+		return 0;
+	}
+	return entry.record ? 2 : 1;
+}
+
+function relevance(entry: Entry, terms: readonly string[], phrase: string, text: string) {
+	const identity = normalize(`${entry.title} ${entry.id ?? ""}`);
+	const titleMatch = entry.kind === "document" && terms.every((term) => identity.includes(term));
+	const ranks = { document: 2, heading: 4, passage: 6 };
+	return { rank: (entry.record ? 10 : 0) + ranks[entry.kind] + (text.includes(phrase) ? 0 : 1), title: titleMatch ? 0 : 1 };
+}
+
+export function searchMatch(entries: readonly Entry[], query: string, modified: ReadonlyMap<string, number> = new Map()) {
+	const input = normalize(query.slice(0, 200));
+	const records = input.startsWith("records:");
+	const phrase = records ? input.slice("records:".length).trim() : input;
 	const terms = phrase.split(" ").filter(Boolean).slice(0, 8);
 	if (terms.length === 0) {
 		return { results: [], total: 0 };
 	}
+	const items = new Map(entries.filter((entry) => entry.kind === "document" && entry.itemKind).map((entry) => [entry.file, entry]));
 	const matches = entries
 		.flatMap((entry, order) => {
 			const text = normalize(entry.text);
-			if (!terms.every((term) => text.includes(term))) {
+			if ((!records && entry.record) || !terms.every((term) => text.includes(term))) {
 				return [];
 			}
-			const at = Math.max(0, entry.text.toLowerCase().indexOf(terms[0] ?? ""));
-			const start = Math.max(0, at - 50);
-			const snippet = (start ? "…" : "") + entry.text.slice(start, start + 180) + (entry.text.length > start + 180 ? "…" : "");
-			const ranks = { document: 0, heading: 2, passage: 4 };
-			const rank = ranks[entry.kind] + (text.includes(phrase) ? 0 : 1);
-			return [{ entry: { ...entry, snippet }, order, rank }];
+			const snippet = searchSnippet(entry.kind === "document" ? entry.title : entry.text, terms[0] ?? "");
+			const item = entry.kind === "document" ? undefined : items.get(entry.file);
+			return (item ? [item, entry] : [entry]).map((result) => ({
+				...relevance(result, terms, phrase, text),
+				entry: { ...result, snippet },
+				group: result.inactive ? 1 : 0,
+				modified: modified.get(result.file) ?? 0,
+				order,
+				type: resultType(result),
+			}));
 		})
-		.sort((left, right) => left.rank - right.rank || left.order - right.order);
-	return { results: matches.slice(0, 40).map((match) => match.entry), total: matches.length };
+		.sort(
+			(left, right) =>
+				left.type - right.type
+				|| left.group - right.group
+				|| left.title - right.title
+				|| right.modified - left.modified
+				|| left.rank - right.rank
+				|| left.order - right.order,
+		);
+	const anchors = new Map<string, (typeof matches)[number]["entry"]>();
+	for (const match of matches) {
+		anchors.set(match.entry.href, anchors.get(match.entry.href) ?? match.entry);
+	}
+	const results = [...anchors.values()];
+	return { results: results.slice(0, 40), total: results.length };
 }