@shivaedev/work-board 0.12.0 → 0.13.0

package/src/server/boardRuntime.ts

@@ -0,0 +1,54 @@
+import { Context, Effect, FileSystem, Layer, Path, type PlatformError } from "effect";
+import { DiagnosticsSources } from "#diagnostics/source.ts";
+import type { BoardOptions } from "#server/board.ts";
+import { boardServices } from "#server/boardServices.ts";
+import { daemonDiagnostics } from "#server/diagnostics/daemon.ts";
+import { readDocument } from "#server/document/read.ts";
+import { watchChanges } from "#server/files/changes.ts";
+import { homeIn } from "#server/files/home.ts";
+import { checkBrowserAssets, mermaidRoot } from "#server/http/assets.ts";
+import { Highlighter } from "#server/render/Highlighter.ts";
+import { handlers } from "#server/rpc/handlers.ts";
+import { type Snapshot, searchSnapshot } from "#server/search/snapshot.ts";
+
+export const boardRuntime = Effect.fn("WorkBoard.boardRuntime")(function* (options: BoardOptions) {
+	const home = yield* homeIn(options.root, options.home);
+	const mermaid = yield* mermaidRoot();
+	yield* checkBrowserAssets();
+	const changes = yield* watchChanges(options.root);
+	const platform = (yield* Effect.context<Highlighter | FileSystem.FileSystem | Path.Path>()).pipe(
+		Context.pick(Highlighter, FileSystem.FileSystem, Path.Path),
+	);
+	const index: Effect.Effect<Snapshot, PlatformError.PlatformError, FileSystem.FileSystem | Path.Path> = yield* searchSnapshot(
+		options.root,
+		home,
+		changes,
+		options.maintainer,
+	);
+	const provided = yield* Effect.serviceOption(DiagnosticsSources);
+	const services = yield* Layer.build(
+		boardServices(
+			{ changes, enabled: options.responses === true, index: Effect.provideContext(index, platform), root: options.root },
+			provided._tag === "Some" ? { _tag: "Sources", sources: provided.value } : { _tag: "Read", read: daemonDiagnostics(options.fleetPort) },
+		),
+	);
+	const context = Context.merge(platform, services);
+	const rpcHandlers = yield* handlers({
+		changes,
+		document: (url) =>
+			Effect.provideContext(
+				readDocument({
+					changes,
+					home,
+					index: Effect.provideContext(index, context),
+					root: options.root,
+					writable: options.responses === true,
+				})(url),
+				context,
+			),
+		home,
+		index: Effect.provideContext(index, context),
+		writable: options.responses === true,
+	}).pipe(Effect.provideContext(context));
+	return { changes, context, home, index, mermaid, rpcHandlers };
+});

package/src/server/diagnostics/daemon.ts

@@ -1,7 +1,7 @@
 import { Clock, Effect, Layer } from "effect";
-import { FetchHttpClient } from "effect/unstable/http";
-import { RpcClient, RpcSerialization } from "effect/unstable/rpc";
-import { RpcClientError } from "effect/unstable/rpc/RpcClientError";
+import { FetchHttpClient } from "effect/http";
+import { RpcClient, RpcSerialization } from "effect/rpc";
+import { RpcClientError } from "effect/rpc/RpcClientError";
 import { DAEMON_PORT, DAEMON_RPC_PATH, DiagnosticsContract, type DiagnosticsSnapshot } from "#diagnostics/daemonContract.ts";
 
 const daemonUnavailable = Effect.fn("WorkBoard.daemonUnavailable")(function* (error: unknown, port: number) {

package/src/server/history/html.ts

@@ -18,6 +18,3 @@ export function historyHtml(before: Baseline, current: Baseline): string {
 		.join(" · ");
 	return `<p>Compared with your observation at <time>${escapeHtml(before.recordedAt)}</time>.</p><p role="status">${counts}</p>${result.changes.length === 0 ? "<p>No source changes since that observation.</p>" : ""}${result.issues.length > 0 ? `<aside aria-label="Identity limitations"><ul>${result.issues.map((issue) => `<li>${escapeHtml(issue)}</li>`).join("")}</ul><p>Ambiguous identities are compared by source path only.</p></aside>` : ""}${result.changes.map(changeHtml).join("")}`;
 }
-export function changesHtml(): string {
-	return `<section class="history"><h1>Changes since seen</h1><p>Compare current Markdown with one observation you explicitly remember in this browser. This is an observed source comparison, not an event journal, Git history, authorship, or verified acceptance.</p><p>Remembered source can include old or deleted content. One snapshot per workspace, up to 2 MiB, expires after 30 days and is removed on your next workspace visit. Mark seen replaces it; Clear forgets it. No source writes or cloud storage.</p><div class="history-controls"><button id="history-mark" type="button" disabled>Start remembering changes</button><button id="history-clear" type="button" disabled>Clear remembered history</button><span id="history-storage" role="status"></span></div><noscript><p>Remembering and comparing changes requires JavaScript and browser storage. Markdown, Overview and Work remain readable.</p></noscript><div id="changes-content" aria-live="polite"><p>No comparison has been loaded.</p></div></section><style>.history-controls{display:flex;flex-wrap:wrap;gap:.6rem;align-items:center}.history-change{border-top:1px solid var(--border);padding:1rem 0}.history-source{white-space:pre-wrap;overflow-wrap:anywhere;max-height:32rem;overflow:auto}.history h2{overflow-wrap:anywhere}</style>`;
-}

package/src/server/history/response.ts

@@ -2,6 +2,7 @@ import { escapeHtml } from "#browser/escapeHtml.ts";
 import type { HistoryOutput } from "#history/schema.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
 import { observeBaseline, readBaseline } from "./baseline.ts";
+import { compareHistory } from "./compare.ts";
 import { historyHtml } from "./html.ts";
 
 export function historyResponse(raw: string | null, now: number, snapshot?: Snapshot): HistoryOutput {
@@ -19,5 +20,18 @@ export function historyResponse(raw: string | null, now: number, snapshot?: Snap
 		return { ...output, html: `<p role="status">${escapeHtml(reason)}</p>`, reason };
 	}
 	const current = readBaseline(currentRaw, now).baseline;
-	return { ...output, html: prior.baseline && current ? historyHtml(prior.baseline, current) : output.html, snapshot: currentRaw };
+	const compared = prior.baseline && current ? compareHistory(prior.baseline, current) : undefined;
+	const comparison =
+		compared && prior.baseline
+			? {
+					changes: compared.changes.map(({ before, after, ...change }) => ({
+						...change,
+						after: after ? { file: after.file, source: after.source } : undefined,
+						before: before ? { file: before.file, source: before.source } : undefined,
+					})),
+					issues: compared.issues,
+					recordedAt: prior.baseline.recordedAt,
+				}
+			: undefined;
+	return { ...output, comparison, html: prior.baseline && current ? historyHtml(prior.baseline, current) : output.html, snapshot: currentRaw };
 }

package/src/server/http/assets.ts

@@ -1,45 +1,11 @@
 import { createRequire } from "node:module";
 import { Effect, FileSystem, Path, Schema } from "effect";
-import type { HttpRouter, HttpServerRequest } from "effect/unstable/http";
+import type { HttpRouter, HttpServerRequest } from "effect/http";
 import { InternalServerError } from "@shivaedev/platform/errors/taxonomy.ts";
-import { diagnosticsScript } from "#client/diagnostics/script.ts";
-import { historyScript } from "#client/history/script.ts";
-import { ageScript } from "#client/page/ageScript.ts";
-import { libraryScript } from "#client/page/libraryScript.ts";
-import { navigationScript } from "#client/page/navigationScript.ts";
-import { readingStateScript } from "#client/page/readingStateScript.ts";
-import { client, preferences } from "#client/page/runtime.ts";
-import { diagrams, swap } from "#client/page/scripts.ts";
-import { searchResultsScript } from "#client/page/searchResultsScript.ts";
-import { searchScript } from "#client/page/searchScript.ts";
-import { sidebarScript } from "#client/page/sidebarScript.ts";
-import { pageStateScript } from "#client/page/stateScript.ts";
-import { visualScript } from "#client/page/visualScript.ts";
-import { visualViewport } from "#client/page/visualViewport.ts";
-import { savedScript } from "#client/views/savedScript.ts";
 import { style } from "#server/page/style.ts";
 import { respond } from "./respond.ts";
 
-export const ASSETS: ReadonlyArray<readonly [HttpRouter.PathInput, string, string]> = [
-	["/_board/style.css", style, "text/css"],
-	["/_board/diagnostics.js", diagnosticsScript(), "text/javascript"],
-	["/_board/visuals.js", visualScript(), "text/javascript"],
-	["/_board/visual-viewport.js", visualViewport(), "text/javascript"],
-	["/_board/saved-views.js", savedScript(), "text/javascript"],
-	["/_board/client.js", client, "text/javascript"],
-	["/_board/ages.js", ageScript(), "text/javascript"],
-	["/_board/history.js", historyScript(), "text/javascript"],
-	["/_board/preferences.js", preferences, "text/javascript"],
-	["/_board/search.js", searchScript(), "text/javascript"],
-	["/_board/search-results.js", searchResultsScript(), "text/javascript"],
-	["/_board/sidebar.js", sidebarScript(), "text/javascript"],
-	["/_board/library.js", libraryScript(), "text/javascript"],
-	["/_board/navigation.js", navigationScript(), "text/javascript"],
-	["/_board/page-state.js", pageStateScript(), "text/javascript"],
-	["/_board/reading-state.js", readingStateScript(), "text/javascript"],
-	["/_board/diagrams.js", diagrams, "text/javascript"],
-	["/_board/swap.js", swap, "text/javascript"],
-];
+export const ASSETS: ReadonlyArray<readonly [HttpRouter.PathInput, string, string]> = [["/_board/style.css", style, "text/css"]];
 
 const MERMAID = "/_board/mermaid/";
 

package/src/server/http/attachment.ts

@@ -1,5 +1,5 @@
 import { Effect, FileSystem, Path } from "effect";
-import type { HttpServerRequest } from "effect/unstable/http";
+import type { HttpServerRequest } from "effect/http";
 import { attachmentType } from "#path/attachment.ts";
 import { within } from "#server/files/list.ts";
 import { respond } from "./respond.ts";

package/src/server/http/boardRoutes.ts

@@ -0,0 +1,62 @@
+import { Effect, type FileSystem, type Path, type Scope } from "effect";
+import { HttpRouter, type HttpServerRequest, type HttpServerResponse } from "effect/http";
+import { loopbackOnly } from "@shivaedev/platform/rpc-server/local.ts";
+import type { Diagnostics } from "#diagnostics/source.ts";
+import type { BoardOptions } from "#server/board.ts";
+import type { boardRuntime } from "#server/boardRuntime.ts";
+import type { HandoffsService } from "#server/handoffs/Service.ts";
+import { navHtml } from "#server/page/nav.ts";
+import { shell } from "#server/page/shell.ts";
+import type { Highlighter } from "#server/render/Highlighter.ts";
+import type { Responses } from "#server/responses/service.ts";
+import { ASSET_HANDLERS, MERMAID_ROUTE, mermaidFile } from "./assets.ts";
+import { attachment } from "./attachment.ts";
+import { identity } from "./identity.ts";
+import { inbox } from "./inbox.ts";
+import { overview } from "./overview.ts";
+import { page } from "./page.ts";
+import { respond } from "./respond.ts";
+import { work } from "./work.ts";
+
+type Services = Highlighter | Responses | HandoffsService | Diagnostics | FileSystem.FileSystem | Path.Path;
+type Handler<E> = (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, Services | Scope.Scope>;
+
+export function boardRoutes(options: BoardOptions, runtime: Effect.Success<ReturnType<typeof boardRuntime>>) {
+	return HttpRouter.use((router) =>
+		Effect.gen(function* () {
+			const { changes, context, home, index, mermaid } = runtime;
+			function serve<E>(route: HttpRouter.PathInput, handler: Handler<E>) {
+				return router.add(
+					"GET",
+					route,
+					loopbackOnly((request) => Effect.provideContext(handler(request), context)),
+				);
+			}
+			yield* serve("/_board/attachment/*", attachment(options.root, changes.realRoot));
+			const inboxPage = inbox(index, changes, home);
+			yield* serve("/_board/inbox", inboxPage);
+			const workPage = work(index, changes, home);
+			const overviewPage = overview(index, changes, home);
+			yield* serve("/_board/work", workPage);
+			yield* serve("/_board/overview", overviewPage);
+			for (const [route, asset] of ASSET_HANDLERS) {
+				yield* serve(route, asset);
+			}
+			yield* serve(MERMAID_ROUTE, mermaidFile(mermaid));
+			for (const view of ["changes", "diagnostics", "start", "respond", "handoff", "result"] as const) {
+				yield* serve(`/_board/${view}`, () =>
+					Effect.gen(function* () {
+						const snapshot = yield* index;
+						const nav = navHtml(yield* changes.files, "", home, snapshot);
+						return respond(shell(view, nav, "", changes.realRoot, false, undefined, view === "respond" ? "response" : view, snapshot), "text/html");
+					}),
+				);
+			}
+			const pages = page({ home, root: options.root, writable: options.responses === true }, changes, index);
+			const items = identity(index, pages, changes, home);
+			yield* serve("/_board/item/*", items);
+			yield* serve("/", pages);
+			yield* serve("/*", pages);
+		}),
+	);
+}

package/src/server/http/identity.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import type { HttpServerRequest } from "effect/unstable/http";
+import type { HttpServerRequest } from "effect/http";
 import { escapeHtml } from "#browser/escapeHtml.ts";
 import { fileUrl } from "#files/url.ts";
 import type { Changes } from "#server/files/changes.ts";

package/src/server/http/page.ts

@@ -1,5 +1,5 @@
 import { Effect, FileSystem, Option } from "effect";
-import type { HttpServerRequest } from "effect/unstable/http";
+import type { HttpServerRequest } from "effect/http";
 import { escapeHtml } from "#browser/escapeHtml.ts";
 import { authoredQuestion } from "#server/attention/inbox.ts";
 import { documentBody } from "#server/document/body.ts";
@@ -14,7 +14,6 @@ import { itemIntroduction } from "#server/page/itemIntroduction.ts";
 import { metadataHtml } from "#server/page/metadata.ts";
 import { navHtml } from "#server/page/nav.ts";
 import { shell } from "#server/page/shell.ts";
-import { startHtml } from "#server/page/startHtml.ts";
 import { boardOf } from "#server/render/board.ts";
 import { authoredQuestionHtml } from "#server/responses/authoredQuestionHtml.ts";
 import { readingActions } from "#server/responses/readingActions.ts";
@@ -96,7 +95,7 @@ export function page(options: PageOptions, changes: Changes, index: Effect.Succe
 			);
 		}
 		if (files.length === 0 && requestedPath(request.url) === "" && resolved === undefined && expectedIdentity === undefined) {
-			return respond(layout(startHtml(true)), "text/html");
+			return respond(layout('<p class="empty">Start your local workspace. Enable JavaScript to read project and report templates.</p>'), "text/html");
 		}
 		if (file === undefined) {
 			return missing();

package/src/server/http/respond.ts

@@ -1,4 +1,4 @@
-import { HttpServerResponse } from "effect/unstable/http";
+import { HttpServerResponse } from "effect/http";
 
 const POLICY = [
 	"default-src 'self'",

package/src/server/http/rpcPolicy.ts

@@ -0,0 +1,16 @@
+import { Effect } from "effect";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
+import { HEADERS } from "./respond.ts";
+
+export const RPC_PATH = "/_board/rpc";
+
+export const rpcPolicy = HttpRouter.middleware(
+	(http) =>
+		Effect.gen(function* () {
+			const request = yield* HttpServerRequest.HttpServerRequest;
+			return yield* request.url.split("?")[0] === RPC_PATH
+				? http.pipe(Effect.map((response) => HttpServerResponse.setHeaders(response, HEADERS)))
+				: http;
+		}),
+	{ global: true },
+);

package/src/server/http/work.ts

@@ -1,5 +1,5 @@
 import { Effect } from "effect";
-import type { HttpServerRequest } from "effect/unstable/http";
+import type { HttpServerRequest } from "effect/http";
 import { escapeHtml } from "#browser/escapeHtml.ts";
 import type { Changes } from "#server/files/changes.ts";
 import { navHtml } from "#server/page/nav.ts";

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/composerHtml.ts

@@ -21,5 +21,5 @@ export const composerHtml = Effect.fn("WorkBoard.composerHtml")(function* (
 		.join("");
 	const body = `<label>${template.hasPrompts ? "Overall response / next action (optional)" : "Your response"}<textarea name="body" rows="4" maxlength="32768" ${template.hasPrompts ? "" : "required"}></textarea></label>`;
 	const details = `<details data-key="response-details"><summary>Response details</summary><label>Response kind <select name="type"><option value="answer">Answer (including no)</option><option value="clarify">Ask back / clarify</option><option value="not_now">Not now</option></select></label>${standalone && template.hasPrompts ? body : ""}<label>Supersedes an earlier response (optional)<select name="supersedes"><option value="">Adds feedback; does not supersede</option>${prior}</select></label></details>`;
-	return `<section class="response-panel"><h${standalone ? "2" : "1"}>${standalone ? "Answer this question" : `Respond to ${escapeHtml(q.item)} / ${escapeHtml(q.request)}`}</h${standalone ? "2" : "1"}><p>${escapeHtml(q.reason)}</p><p><a href="${fileUrl(q.source)}">Source: ${escapeHtml(q.source)}</a> · Reviewed SHA-256: <code>${q.reviewedRevision}</code></p><p>${standalone ? "An answer removes this question from the Inbox for this source revision." : "Saved replies are authored feedback. They do not close the request or establish acceptance."}</p>${standalone ? "" : `<section class="response-context">${template.background}</section>`}<details><summary>Exact source being reviewed</summary><pre>${escapeHtml(q.context)}</pre></details><form novalidate id="response-form" data-question="${q.id}" data-writable="${enabled}" data-item="${escapeHtml(q.item)}" data-request="${escapeHtml(q.request)}" data-revision="${q.reviewedRevision}"><label>Local author label <input name="author" maxlength="200" required autocomplete="nickname"></label>${template.controls}${standalone && template.hasPrompts ? "" : body}${details}<pre id="response-draft-recovery" hidden></pre><p>Submit the whole packet together. Drafts stay in this browser for 30 days after the last edit, with a 2 MiB workspace limit. Saved responses are Markdown files in responses/.</p><button id="response-preview" type="button" disabled>Preview Markdown</button><pre id="response-preview-content" hidden></pre><button id="response-submit" type="submit" disabled>Record response</button><button id="response-clear" type="button" disabled>Clear workspace drafts</button><p id="response-status" role="status">${enabled ? "JavaScript is required to record a response." : "Read-only mode. Restart with --responses to explicitly enable local writes."}</p></form>${yield* historyHtml(q, records)}</section>`;
+	return `<section class="response-panel"><h${standalone ? "2" : "1"}>${standalone ? "Answer this question" : `Respond to ${escapeHtml(q.item)} / ${escapeHtml(q.request)}`}</h${standalone ? "2" : "1"}><p>${escapeHtml(q.reason)}</p><p><a href="${fileUrl(q.source)}">Source: ${escapeHtml(q.source)}</a> · Reviewed SHA-256: <code>${q.reviewedRevision}</code></p><p>${standalone ? "An answer removes this question from the Inbox for this source revision." : "Saved replies are authored feedback. They do not close the request or establish acceptance."}</p>${standalone ? "" : `<section class="response-context">${template.background}</section>`}<details><summary>Exact source being reviewed</summary><pre>${escapeHtml(q.context)}</pre></details><form novalidate id="response-form" data-question="${q.id}" data-writable="${enabled}" data-item="${escapeHtml(q.item)}" data-request="${escapeHtml(q.request)}" data-revision="${q.reviewedRevision}"><label>Local author label <input name="author" maxlength="200" required autocomplete="nickname"></label>${template.controls}${standalone && template.hasPrompts ? "" : body}${details}<pre id="response-draft-recovery" hidden></pre><p>Submit the whole packet together. Drafts stay in this browser for seven days after the last edit, with a 256 KiB limit per draft. Saved responses are Markdown files in responses/.</p><button id="response-preview" type="button" disabled>Preview Markdown</button><pre id="response-preview-content" hidden></pre><button id="response-submit" type="submit" disabled>Record response</button><button id="response-clear" type="button" disabled>Clear draft</button><p id="response-status" role="status">${enabled ? "JavaScript is required to record a response." : "Read-only mode. Restart with --responses to explicitly enable local writes."}</p></form>${yield* historyHtml(q, records)}</section>`;
 });

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,12 @@
+import type { Effect } from "effect";
+import type { Document } from "#browser/document/schema.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 home: string | undefined;
+	readonly index: Effect.Effect<Snapshot, unknown>;
+	readonly writable?: boolean;
+}

package/src/server/rpc/handlers.ts

@@ -1,8 +1,8 @@
 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 { 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";
@@ -10,32 +10,30 @@ import { historyResponse } from "#server/history/response.ts";
 import { navigationData } from "#server/navigation/model.ts";
 import { Responses } from "#server/responses/service.ts";
 import { searchMatch } from "#server/search/match.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.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 }) =>
@@ -44,21 +42,26 @@ export const handlers = Effect.fn("WorkBoard.handlers")(function* ({ changes, do
 					const snapshot = action === "check" ? undefined : yield* index;
 					return historyResponse(baseline, now, snapshot);
 				}).pipe(readBoundary),
+			"work-board.inbox": () => Effect.suspend(() => projections.inbox()).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.overview": () => Effect.suspend(() => projections.overview()).pipe(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),
+			"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/serve-cli.ts

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { NodeRuntime, NodeServices } from "@effect/platform-node";
 import { Effect, Layer, Option, Path } from "effect";
-import { Argument, Command, Flag } from "effect/unstable/cli";
+import { Argument, Command, Flag } from "effect/cli";
 import { DAEMON_PORT } from "#diagnostics/daemonContract.ts";
 import { HOST, serveBoard } from "./serve.ts";
 
-const VERSION = "0.12.0";
+const VERSION = "0.13.0";
 
 const serve = Effect.fn("WorkBoard.serve")(function* (input: {
 	readonly dir: string;
@@ -31,15 +31,15 @@ const serve = Effect.fn("WorkBoard.serve")(function* (input: {
 const workBoard = Command.make(
 	"work-board",
 	{
-		dir: Argument.directory("dir", { mustExist: true }).pipe(Argument.withDescription("The folder of markdown files to serve")),
-		fleetPort: Flag.integer("fleet-port").pipe(Flag.withDefault(DAEMON_PORT), Flag.withDescription("Fleet daemon port for Diagnostics at 127.0.0.1")),
-		home: Flag.string("home").pipe(Flag.optional, Flag.withDescription("The file shown as a board at /, relative to the folder")),
-		maintainer: Flag.string("maintainer").pipe(
+		dir: Argument.Directory("dir", { mustExist: true }).pipe(Argument.withDescription("The folder of markdown files to serve")),
+		fleetPort: Flag.Int("fleet-port").pipe(Flag.withDefault(DAEMON_PORT), Flag.withDescription("Fleet daemon port for Diagnostics at 127.0.0.1")),
+		home: Flag.String("home").pipe(Flag.optional, Flag.withDescription("The file shown as a board at /, relative to the folder")),
+		maintainer: Flag.String("maintainer").pipe(
 			Flag.withDefault("maintainer"),
 			Flag.withDescription("The response_from label whose questions appear in the Inbox"),
 		),
-		port: Flag.integer("port").pipe(Flag.withDefault(4747), Flag.withDescription(`The port to listen on at ${HOST}`)),
-		responses: Flag.boolean("responses").pipe(
+		port: Flag.Int("port").pipe(Flag.withDefault(4747), Flag.withDescription(`The port to listen on at ${HOST}`)),
+		responses: Flag.Boolean("responses").pipe(
 			Flag.withDefault(false),
 			Flag.withDescription("Explicitly enable local durable question, response and handoff writes (Linux)"),
 		),

package/src/server/serve.ts

@@ -1,8 +1,12 @@
-import { createServer } from "node:http";
-import { NodeHttpServer } from "@effect/platform-node";
-import { Layer } from "effect";
-import { HttpRouter } from "effect/unstable/http";
-import { type BoardOptions, boardLayer } from "./board.ts";
+import { Effect, Layer } from "effect";
+import { appHost } from "@shivaedev/platform/appHost.ts";
+import { workRpcs } from "#rpc/contract.ts";
+import { boardRuntime } from "#server/boardRuntime.ts";
+import { MAX_BYTES } from "#server/history/limits.ts";
+import { boardRoutes } from "#server/http/boardRoutes.ts";
+import { RPC_PATH, rpcPolicy } from "#server/http/rpcPolicy.ts";
+import { Highlighter } from "#server/render/Highlighter.ts";
+import type { BoardOptions } from "./board.ts";
 
 export const HOST = "127.0.0.1";
 
@@ -10,10 +14,19 @@ export interface ServeOptions extends BoardOptions {
 	readonly port: number;
 }
 
-export function listenOn(port: number) {
-	return NodeHttpServer.layer(createServer, { disablePreemptiveShutdown: true, host: HOST, port });
-}
-
 export function serveBoard(options: ServeOptions) {
-	return HttpRouter.serve(boardLayer(options), { disableLogger: true }).pipe(Layer.provideMerge(listenOn(options.port)));
+	return Layer.unwrap(
+		Effect.gen(function* () {
+			const runtime = yield* boardRuntime(options);
+			return appHost({
+				config: { disablePreemptiveShutdown: true, host: HOST, maxBodySize: 4 * MAX_BYTES + 4096, port: options.port },
+				group: workRpcs,
+				handlers: runtime.rpcHandlers,
+				policy: "loopback",
+				routes: Layer.merge(boardRoutes(options, runtime), rpcPolicy),
+				rpcPath: RPC_PATH,
+				services: Layer.empty,
+			});
+		}),
+	).pipe(Layer.provide(Highlighter.layer));
 }

package/src/server/views/projectionQueries.ts

@@ -0,0 +1,78 @@
+import { Effect } from "effect";
+import { NotFound } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { BoardProjection, InboxProjection, OverviewProjection, WorkProjection } from "#browser/views/schema.ts";
+import { stateOf } from "#browser/views/state.ts";
+import { inboxItems } from "#server/attention/inbox.ts";
+import { attentionRequests } from "#server/attention/requests.ts";
+import { identityUrl, referenceTarget } from "#server/metadata/links.ts";
+import { boardOf, countsOf } from "#server/render/board.ts";
+import type { HandlerOptions } from "#server/rpc/HandlerOptions.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+import type { Item } from "./items.ts";
+import { projectItems } from "./projection.ts";
+
+export function projectionQueries({ index, document }: { readonly index: HandlerOptions["index"]; readonly document: HandlerOptions["document"] }) {
+	function read(url: string) {
+		return document ? document(url) : Effect.fail(new NotFound({ message: "The document is missing." }));
+	}
+	return {
+		board: (url: string) => Effect.map(read(url), (data): BoardProjection => ({ counts: countsOf(boardOf(data.source)), document: data })),
+		inbox: () => Effect.map(index, inboxProjection),
+		overview: () => Effect.map(index, overviewProjection),
+		work: (url: string) =>
+			Effect.gen(function* () {
+				const snapshot = yield* index;
+				const state = stateOf(url);
+				const projection = projectItems(snapshot, state);
+				const waiting = new Map(
+					inboxItems(snapshot)
+						.filter((entry) => !entry.problem)
+						.map((entry) => [entry.id, entry.reason]),
+				);
+				function toItem({ document: source, id, title }: Item) {
+					return { file: source.file, id, metadata: source.parsed.fields, title, waiting: waiting.get(id) };
+				}
+				const selected = projection.selected ? yield* read(identityUrl(projection.selected.id)) : undefined;
+				return {
+					boards: projection.boards.map(toItem),
+					issues: projection.issues,
+					items: projection.items.map(toItem),
+					rows: projection.rows.map(toItem),
+					selected,
+					selectedOutside: projection.selectedOutside,
+					selectionProblem: !state.item || selected ? undefined : selectionProblem(snapshot, state.item),
+					state,
+					title: projection.title,
+					validBoard: projection.validBoard,
+				} satisfies WorkProjection;
+			}),
+	};
+}
+function inboxProjection(snapshot: Snapshot): InboxProjection {
+	return {
+		complete: snapshot.unavailable.length === 0,
+		items: inboxItems(snapshot).map(({ document, ...item }) => ({ ...item, file: document.file })),
+		sourceIssues: snapshot.model.documents.some((document) => (snapshot.model.diagnostics.get(document.file)?.length ?? 0) > 0),
+	};
+}
+function overviewProjection(snapshot: Snapshot): OverviewProjection {
+	const projection = attentionRequests(snapshot);
+	return {
+		...projection,
+		entries: projection.entries.map(({ document, request, ...entry }) => ({
+			...entry,
+			file: document.file,
+			id: request.id,
+			kind: request.kind,
+			reason: request.reason,
+			responseFrom: request.responseFrom,
+			unblocks: request.unblocks.map((target) => ({ href: referenceTarget(target, snapshot.model), label: target })),
+		})),
+		inboxCount: inboxItems(snapshot).length,
+		unavailable: snapshot.unavailable,
+	};
+}
+
+function selectionProblem(snapshot: Snapshot, item: string) {
+	return (snapshot.model.ids.get(item)?.length ?? 0) > 1 ? "has a duplicate ID" : "is missing or its identity changed";
+}