@shivaedev/work-board 0.12.0 → 0.13.0

package/src/client/react/visualSources.ts

@@ -0,0 +1,105 @@
+import { Clock, Effect } from "effect";
+import { useEffect } from "react";
+
+export interface VisualSource {
+	readonly alt: string;
+	readonly local: string;
+	readonly src: string;
+}
+export interface VisualSelection {
+	readonly drawing?: SVGSVGElement;
+	readonly images: readonly VisualSource[];
+	readonly origin: HTMLElement;
+	readonly selected: number;
+}
+export function useVisualSources(inspect: (selection: VisualSelection) => void) {
+	useEffect(() => {
+		let revision = 0;
+		function refresh() {
+			revision += 1;
+			for (const graphic of document.querySelectorAll<HTMLImageElement>("#doc img[data-local-image]")) {
+				graphic.tabIndex = 0;
+				graphic.setAttribute("role", "button");
+				graphic.setAttribute("aria-label", `Inspect image: ${graphic.alt || "Local image"}`);
+				const url = new URL(graphic.dataset.localImage ?? graphic.src, location.href);
+				url.searchParams.set("_wb", `${Effect.runSync(Clock.currentTimeMillis)}-${revision}`);
+				graphic.src = url.href;
+				graphic.onerror = () => {
+					if (!graphic.isConnected || graphic.nextElementSibling?.hasAttribute("data-image-error")) {
+						return;
+					}
+					const error = document.createElement("span");
+					error.setAttribute("data-image-error", "");
+					error.setAttribute("role", "status");
+					error.textContent = "Image unavailable. Check the local path, supported type, workspace boundary and 16 MiB limit.";
+					graphic.after(error);
+				};
+				graphic.onload = () => {
+					if (graphic.nextElementSibling?.hasAttribute("data-image-error")) {
+						graphic.nextElementSibling.remove();
+					}
+				};
+			}
+		}
+		function image(source: HTMLImageElement) {
+			const images = [...document.querySelectorAll<HTMLImageElement>("#doc img[data-local-image]")];
+			inspect({
+				images: images.map((entry) => ({ alt: entry.alt, local: entry.dataset.localImage ?? entry.src, src: entry.src })),
+				origin: source,
+				selected: images.indexOf(source),
+			});
+		}
+		function click(event: MouseEvent) {
+			if (
+				event.defaultPrevented
+				|| event.button !== 0
+				|| event.ctrlKey
+				|| event.metaKey
+				|| event.shiftKey
+				|| event.altKey
+				|| !(event.target instanceof Element)
+			) {
+				return;
+			}
+			inspectTarget(event, event.target);
+		}
+		function inspectTarget(event: MouseEvent, target: Element) {
+			const trigger = target.closest<HTMLButtonElement>("#doc [data-inspect-diagram]");
+			const drawing = trigger?.closest("figure")?.querySelector("svg");
+			if (trigger && !trigger.disabled && drawing) {
+				inspect({ drawing, images: [], origin: trigger, selected: -1 });
+				return;
+			}
+			const link = target.closest<HTMLAnchorElement>('#doc a[href^="/_board/attachment/"]');
+			if (link && !link.hasAttribute("download") && (!link.target || link.target === "_self")) {
+				event.preventDefault();
+				inspect({
+					images: [{ alt: link.textContent ?? "", local: link.getAttribute("href") ?? link.href, src: link.href }],
+					origin: link,
+					selected: 0,
+				});
+				return;
+			}
+			const source = target.closest<HTMLImageElement>("#doc img[data-local-image]");
+			if (source) {
+				event.preventDefault();
+				image(source);
+			}
+		}
+		function key(event: KeyboardEvent) {
+			if (["Enter", " "].includes(event.key) && event.target instanceof HTMLImageElement && event.target.matches("#doc img[data-local-image]")) {
+				event.preventDefault();
+				image(event.target);
+			}
+		}
+		document.addEventListener("click", click);
+		document.addEventListener("keydown", key);
+		document.addEventListener("board-page", refresh);
+		refresh();
+		return () => {
+			document.removeEventListener("click", click);
+			document.removeEventListener("keydown", key);
+			document.removeEventListener("board-page", refresh);
+		};
+	}, [inspect]);
+}

package/src/client/reconcile/{signature.ts → normalized.ts}

@@ -1,8 +1,3 @@
-const containers = new Set(["DIV", "SECTION", "ARTICLE", "HEADER", "FOOTER", "MAIN", "NAV", "FORM", "SELECT", "LABEL", "ASIDE", "DETAILS"]);
-const pristine = new WeakMap<Element, string>();
-export function structural(element: Element) {
-	return [...element.childNodes].every((node) => node.nodeType === 1 || node.textContent?.trim() === "");
-}
 export function flash(element: Element) {
 	if (element.matches("[data-modified]") || !element.matches("p, li, pre, blockquote, h1, h2, h3, h4, h5, h6, .item, .notes, .metadata-panel")) {
 		return;
@@ -29,38 +24,6 @@ export function normalized(element: Element) {
 	}
 	return copy.outerHTML;
 }
-export function remember(element: Element) {
-	pristine.set(element, normalized(element));
-	if (containers.has(element.tagName)) {
-		for (const child of element.children) {
-			remember(child);
-		}
-	}
-}
-export function signature(element: Element) {
-	if (!pristine.has(element)) {
-		pristine.set(element, normalized(element));
-	}
-	return pristine.get(element);
-}
-export function record(element: Element, value: string) {
-	pristine.set(element, value);
-}
-function normalizedShell(element: Element) {
-	const copy = element.cloneNode(false);
-	if (!(copy instanceof Element)) {
-		throw new Error("Expected an element");
-	}
-	copy.removeAttribute("data-live-change");
-	if (copy.tagName === "DETAILS") {
-		copy.removeAttribute("open");
-	}
-	return copy.outerHTML;
-}
-export function sameShell(old: Element, next: Element) {
-	return old.tagName === next.tagName && containers.has(old.tagName) && normalizedShell(old) === normalizedShell(next);
-}
-
 function normalizeNode(node: Element) {
 	node.removeAttribute("data-live-change");
 	if (node.tagName === "DETAILS") {

package/src/client/responses/answerRecovery.ts

@@ -0,0 +1,37 @@
+import { Schema } from "effect";
+import type { ResponseInput } from "./formSchema.ts";
+
+export const AnswerRecovery = Schema.Union([
+	Schema.String,
+	Schema.Struct({
+		contexts: Schema.Array(Schema.Struct({ context: Schema.String, text: Schema.String })),
+		legacy: Schema.optionalKey(Schema.String),
+	}),
+	Schema.Undefined,
+]);
+type Recovery = typeof AnswerRecovery.Encoded;
+const HEADING = "Earlier template answers (selections cleared; review before choosing again):";
+
+export function answerRecovery(draft: Pick<ResponseInput, "answers" | "question" | "revision" | "recovery">, same: boolean): Recovery {
+	if (same || !draft.answers?.some((answer) => answer.selected.length > 0 || answer.text.length > 0)) {
+		return draft.recovery;
+	}
+	const context = JSON.stringify([draft.question, draft.revision]);
+	const text = JSON.stringify(draft.answers, null, 2);
+	const recovered = typeof draft.recovery === "string" ? { contexts: [], legacy: draft.recovery } : (draft.recovery ?? { contexts: [] });
+	const existing = recovered.contexts.some((entry) => entry.context === context);
+	const contexts = existing
+		? recovered.contexts.map((entry) => (entry.context === context ? { context, text } : entry))
+		: [...recovered.contexts, { context, text }];
+	const legacy = recovered.legacy?.replaceAll(`${HEADING}\n${text}\n`, "");
+	return { contexts, ...(legacy ? { legacy } : {}) };
+}
+
+export function recoveryText(recovery: Recovery): string {
+	if (typeof recovery === "string") {
+		return recovery;
+	}
+	return [...(recovery?.contexts ?? []).map((entry) => `${HEADING}\nReviewed context: ${entry.context}\n${entry.text}`), recovery?.legacy ?? ""]
+		.filter(Boolean)
+		.join("\n");
+}

package/src/client/responses/authorLabel.ts

@@ -1,18 +1,18 @@
-export function authorLabel(storage: Storage | undefined, workspace: string | undefined) {
+export function authorLabel(storage: () => Storage, workspace: string | undefined) {
 	const key = `work-board:author:${workspace ?? ""}`;
 	function read(draft: string) {
 		if (draft) {
 			return draft;
 		}
 		try {
-			return storage?.getItem(key)?.slice(0, 200) ?? "";
+			return storage().getItem(key)?.slice(0, 200) ?? "";
 		} catch {
 			return "";
 		}
 	}
 	function save(value: string) {
 		try {
-			storage?.setItem(key, value.slice(0, 200));
+			storage().setItem(key, value.slice(0, 200));
 			return true;
 		} catch {
 			return false;

package/src/client/responses/failure.ts

@@ -0,0 +1,13 @@
+import { Schema } from "effect";
+import { InternalServerError } from "@shivaedev/platform/errors/taxonomy.ts";
+import { PublicationUncertain, ResponseRejection } from "#rpc/rejections.ts";
+export function responseFailure(error: unknown) {
+	const outcome =
+		Schema.is(ResponseRejection)(error) && !(error instanceof PublicationUncertain) && !(error instanceof InternalServerError)
+			? "rejected"
+			: "uncertain";
+	return {
+		outcome,
+		text: `${outcome === "rejected" ? "Rejected" : "Uncertain"}: ${String(error)}. Draft retained. Preview and retry with the same identity; saved content will be reconciled.`,
+	};
+}

package/src/client/responses/formSchema.ts

@@ -1,10 +1,13 @@
 import { Schema } from "effect";
 import { DraftInput, ResponseKind, Revision } from "#browser/responses/schema.ts";
+import { AnswerRecovery } from "./answerRecovery.ts";
 
 export function responseFormSchema(hasPrompts: boolean) {
 	return Schema.Struct({
 		...DraftInput.fields,
+		answerContext: Schema.optional(Schema.String),
 		body: hasPrompts ? DraftInput.fields.body : DraftInput.fields.body.check(Schema.isMinLength(1)),
+		recovery: Schema.optionalKey(AnswerRecovery),
 		revision: Revision,
 		type: Schema.String.pipe(Schema.decodeTo(ResponseKind)),
 	}).check(
@@ -21,3 +24,4 @@ export function responseFormSchema(hasPrompts: boolean) {
 }
 
 export type ResponseSubmission = ReturnType<typeof responseFormSchema>["Type"];
+export type ResponseInput = ReturnType<typeof responseFormSchema>["Encoded"];

package/src/client/responses/preview.ts

@@ -1,7 +1,7 @@
 import { answerBody } from "#browser/responses/answerBody.ts";
 import type { Prompt } from "#browser/responses/Prompt.ts";
-import type { Draft } from "./drafts.ts";
+import type { ResponseInput } from "./formSchema.ts";
 
-export function responsePreview(draft: Draft, question: string, prompts: readonly Prompt[] = []): string {
+export function responsePreview(draft: ResponseInput, question: string, prompts: readonly Prompt[] = []): string {
 	return `New file: responses/${draft.id}.md\nRegistration (if needed): responses/${question}.md\nRecorded time is assigned by the server when saving.\n\n---\n${JSON.stringify({ id: draft.id, kind: "response", response: { answers: draft.answers, author: draft.author, question, reviewedRevision: draft.revision, supersedes: draft.supersedes, type: draft.type } }, null, 2)}\n---\n${draft.answers ? answerBody(prompts, draft.answers, draft.body) : draft.body}`;
 }

package/src/client/responses/retainContext.ts

@@ -0,0 +1,15 @@
+import type { Form } from "@shivaedev/effect-form/shape.ts";
+import type { ResponseSubmission, responseFormSchema } from "./formSchema.ts";
+
+type ResponseForm = Form<ReturnType<typeof responseFormSchema>["fields"], ResponseSubmission, unknown, never>;
+export function retainContext(form: ResponseForm, saved: ResponseSubmission) {
+	if (form.values.value.id) {
+		return;
+	}
+	form.change("id", `response.${crypto.randomUUID()}`);
+	form.change("question", saved.question);
+	form.change("revision", saved.revision);
+	if (!form.values.value.answerContext) {
+		form.change("answerContext", saved.answerContext);
+	}
+}

package/src/client/responses/summary.ts

@@ -0,0 +1,25 @@
+import type { Prompt } from "#browser/responses/Prompt.ts";
+import type { PromptAnswer } from "#browser/responses/schema.ts";
+import type { ResponseInput } from "./formSchema.ts";
+export function responseSummary(values: ResponseInput, prompts: readonly Prompt[], answers: readonly PromptAnswer[] | undefined) {
+	const missing =
+		values.type === "answer"
+			? prompts.filter((prompt) => {
+					const answer = answers?.find((entry) => entry.prompt === prompt.id);
+					return !(answer?.text.trim() || answer?.selected.length);
+				})
+			: [];
+	return [
+		values.author.trim() ? "" : "Add your local author label.",
+		missing.length > 0 ? `Unanswered prompts: ${missing.map((prompt) => `Question ${prompts.indexOf(prompt) + 1} · ${prompt.id}`).join("; ")}.` : "",
+	]
+		.filter(Boolean)
+		.join(" ");
+}
+
+export function responseReadiness(valid: boolean, previewed: boolean) {
+	if (!valid) {
+		return "This draft is invalid. Review the response fields before recording.";
+	}
+	return previewed ? "Preview ready. Record this response when you are ready." : "Draft ready. Preview the Markdown before recording it.";
+}

package/src/client/sourceChanged.ts

@@ -0,0 +1,3 @@
+export function sourceChanged() {
+	return "Source changed since this draft. Your text is retained; review the new source and preview to bind it to this revision.";
+}

package/src/diagnostics/daemonContract.ts

@@ -1,8 +1,8 @@
 import { Schema } from "effect";
 import { contract } from "@shivaedev/effect-contract/contract.ts";
 import { query } from "@shivaedev/effect-contract/operation.ts";
+import { CodexLimits, GithubLimits } from "#browser/diagnostics/schema.ts";
 import { FleetHealth } from "./health.ts";
-import { CodexLimits, GithubLimits } from "./source.ts";
 
 const Timestamp = Schema.Number.check(Schema.isFinite(), Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(8_640_000_000_000_000));
 

package/src/diagnostics/source.ts

@@ -1,5 +1,6 @@
 import { Clock, Context, Effect, Schema } from "effect";
 import { defineService } from "@shivaedev/effect-service/define-service.ts";
+import * as limits from "#browser/diagnostics/schema.ts";
 import type { FleetHealth } from "./health.ts";
 
 export class SourceFailure extends Schema.TaggedError<SourceFailure>()("SourceFailure", {
@@ -7,19 +8,11 @@ export class SourceFailure extends Schema.TaggedError<SourceFailure>()("SourceFa
 	message: Schema.String,
 }) {}
 
-export const UsageWindow = Schema.Struct({
-	resetsAt: Schema.NullOr(Schema.Int.check(Schema.isGreaterThanOrEqualTo(0), Schema.isLessThanOrEqualTo(8_640_000_000_000))),
-	usedPercent: Schema.Number.check(Schema.isFinite(), Schema.isGreaterThanOrEqualTo(0)),
-	windowDurationMins: Schema.NullOr(Schema.Int.check(Schema.isGreaterThan(0))),
-});
-export type UsageWindow = typeof UsageWindow.Type;
-export const CodexLimits = Schema.Struct({ primary: Schema.NullOr(UsageWindow), secondary: Schema.NullOr(UsageWindow) });
+export const { CodexLimits, GithubLimits, GithubWindow, UsageWindow } = limits;
 export type CodexLimits = typeof CodexLimits.Type;
-const Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-export const GithubWindow = Schema.Struct({ limit: Count, remaining: Count, reset: Count.check(Schema.isLessThanOrEqualTo(8_640_000_000_000)) });
-export type GithubWindow = typeof GithubWindow.Type;
-export const GithubLimits = Schema.Struct({ core: GithubWindow, graphql: GithubWindow });
 export type GithubLimits = typeof GithubLimits.Type;
+export type GithubWindow = typeof GithubWindow.Type;
+export type UsageWindow = typeof UsageWindow.Type;
 export type Source<A> = Effect.Effect<A, SourceFailure>;
 export interface Sources {
 	readonly codex: Source<CodexLimits>;
@@ -28,9 +21,7 @@ export interface Sources {
 }
 export class DiagnosticsSources extends Context.Service<DiagnosticsSources, Sources>()("WorkBoard/DiagnosticsSources") {}
 
-export type Observation<A> =
-	| { readonly state: "ready"; readonly observedAt: number; readonly value: A }
-	| { readonly state: "not-configured" | "error"; readonly observedAt: number; readonly cause: string };
+export type Observation<A> = limits.Observation<A>;
 
 export const observe = Effect.fn("WorkBoard.observe")(function* <A>(source: Source<A>): Generator<Effect.Effect<unknown>, Observation<A>, never> {
 	const result = yield* Effect.result(source);

package/src/history/schema.ts

@@ -27,7 +27,22 @@ export const Baseline = Schema.Struct({
 export type Baseline = typeof Baseline.Type;
 
 export const HistoryInput = Schema.Struct({ action: Schema.Literals(["check", "compare", "observe"]), baseline: Schema.NullOr(Schema.String) });
+const Source = Schema.Struct({ file: Schema.String, source: Schema.String });
+export const HistoryComparison = Schema.Struct({
+	changes: Schema.Array(
+		Schema.Struct({
+			after: Schema.optional(Source),
+			before: Schema.optional(Source),
+			kind: Schema.Literals(["added", "removed", "changed"]),
+			reasons: Schema.Array(Schema.String),
+		}),
+	),
+	issues: Schema.Array(Schema.String),
+	recordedAt: Schema.String,
+});
+export type HistoryComparison = typeof HistoryComparison.Type;
 export const HistoryOutput = Schema.Struct({
+	comparison: Schema.optional(HistoryComparison),
 	discardBaseline: Schema.Boolean,
 	html: Schema.String,
 	reason: Schema.String,

package/src/rpc/contract.ts

@@ -6,6 +6,9 @@ import { InternalServerError } from "@shivaedev/platform/errors/taxonomy.ts";
 import { RequestTracing } from "@shivaedev/platform/rpc/middleware.ts";
 import { Document } from "#browser/document/schema.ts";
 import { Navigation } from "#browser/navigation/schema.ts";
+import { ResultProjection } from "#browser/views/ResultProjection.ts";
+import { DiagnosticsProjection, HandoffProjection, RespondProjection, StartProjection } from "#browser/views/remaining.ts";
+import { BoardProjection, InboxProjection, OverviewProjection, WorkProjection } from "#browser/views/schema.ts";
 import { HistoryInput, HistoryOutput } from "#history/schema.ts";
 import { handoffContract } from "#rpc/handoffContract.ts";
 import { responseContract } from "#rpc/responseContract.ts";
@@ -43,7 +46,6 @@ const PageUrl = Schema.String.check(
 		}
 	}),
 );
-const Page = Schema.Struct({ html: Schema.String, status: Schema.Number });
 const Entry = Schema.Struct({
 	file: Schema.String,
 	href: Schema.String,
@@ -53,13 +55,50 @@ const Entry = Schema.Struct({
 	text: Schema.String,
 	title: Schema.String,
 });
-const ReadPage = query("page", { payload: { url: PageUrl }, reads: ({ url }) => pageKeys(url), rejections: { InternalServerError }, success: Page });
 const ReadDocument = query("document", {
 	payload: { url: PageUrl },
 	reads: ({ url }) => [...pageKeys(url), index.list],
 	rejections: documentRejections,
 	success: Document,
 });
+const ReadBoard = query("board", {
+	payload: { url: PageUrl },
+	reads: ({ url }) => pageKeys(url),
+	rejections: documentRejections,
+	success: BoardProjection,
+});
+const ReadWork = query("work", {
+	payload: { url: PageUrl },
+	reads: () => [workspace.list, index.list],
+	rejections: documentRejections,
+	success: WorkProjection,
+});
+const ReadOverview = query("overview", {
+	reads: () => [workspace.list, index.list],
+	rejections: { InternalServerError },
+	success: OverviewProjection,
+});
+const ReadInbox = query("inbox", { reads: () => [workspace.list, index.list], rejections: { InternalServerError }, success: InboxProjection });
+const ReadDiagnostics = query("diagnostics", { reads: () => [workspace.list], rejections: { InternalServerError }, success: DiagnosticsProjection });
+const ReadStart = query("start", { reads: () => [workspace.list, index.list], rejections: { InternalServerError }, success: StartProjection });
+const ReadRespond = query("respond", {
+	payload: { url: PageUrl },
+	reads: ({ url }) => [...pageKeys(url), index.list],
+	rejections: documentRejections,
+	success: RespondProjection,
+});
+const ReadHandoff = query("handoff", {
+	payload: { url: PageUrl },
+	reads: () => [workspace.list, index.list],
+	rejections: documentRejections,
+	success: HandoffProjection,
+});
+const ReadResult = query("result", {
+	payload: { url: PageUrl },
+	reads: () => [workspace.list, index.list],
+	rejections: documentRejections,
+	success: ResultProjection,
+});
 const ReadNavigation = query("navigation", {
 	payload: { current: Schema.String.check(Schema.isMaxLength(8192)) },
 	reads: () => [workspace.list, navigation.list],
@@ -85,7 +124,22 @@ const ReadWatcher = query("watcher", {
 });
 export const Subscribe = stream("subscribe", { reads: () => [workspace.list], rejections: { InternalServerError }, success: LiveHint });
 export const workContract = contract("work-board", {
-	queries: [ReadPage, ReadDocument, ReadNavigation, ReadSearch, ReadHistory, ReadWatcher],
+	queries: [
+		ReadDocument,
+		ReadBoard,
+		ReadWork,
+		ReadOverview,
+		ReadInbox,
+		ReadDiagnostics,
+		ReadStart,
+		ReadRespond,
+		ReadHandoff,
+		ReadResult,
+		ReadNavigation,
+		ReadSearch,
+		ReadHistory,
+		ReadWatcher,
+	],
 	streams: [Subscribe],
 }).middleware(RequestTracing);
 export const workRpcs = workContract.merge(responseContract).merge(handoffContract);

package/src/server/board.ts

@@ -1,33 +1,16 @@
-import { Context, Effect, FileSystem, Layer, Path, type PlatformError, type Scope } from "effect";
-import { HttpRouter, HttpServerRequest, type HttpServerResponse } from "effect/unstable/http";
+import { Effect, type FileSystem, Layer, type Path, type PlatformError } from "effect";
+import { HttpRouter } from "effect/http";
+import { RpcSerialization, RpcServer } from "effect/rpc";
 import type { InternalServerError } from "@shivaedev/platform/errors/taxonomy.ts";
-import { loopbackOnly } from "@shivaedev/platform/rpc-server/local.ts";
-import { Diagnostics, DiagnosticsSources } from "#diagnostics/source.ts";
+import { localRpcGuard } from "@shivaedev/platform/rpc-server/local.ts";
 import type { RenderFailed } from "#render/failed.ts";
-import { boardServices } from "#server/boardServices.ts";
-import { daemonDiagnostics } from "#server/diagnostics/daemon.ts";
-import { diagnosticsPage } from "#server/diagnostics/page.ts";
-import { readDocument } from "#server/document/read.ts";
-import { watchChanges } from "#server/files/changes.ts";
-import { type HomeMissing, homeIn } from "#server/files/home.ts";
-import { handoffPage } from "#server/handoffs/page.ts";
-import type { HandoffsService } from "#server/handoffs/Service.ts";
-import { ASSET_HANDLERS, checkBrowserAssets, MERMAID_ROUTE, type MermaidMissing, mermaidFile, mermaidRoot } from "#server/http/assets.ts";
-import { attachment } from "#server/http/attachment.ts";
-import { changesPage } from "#server/http/changesPage.ts";
-import { identity } from "#server/http/identity.ts";
-import { inbox } from "#server/http/inbox.ts";
-import { overview } from "#server/http/overview.ts";
-import { page } from "#server/http/page.ts";
-import { readPage } from "#server/http/readPage.ts";
-import { start } from "#server/http/start.ts";
-import { work } from "#server/http/work.ts";
+import { workRpcs } from "#rpc/contract.ts";
+import { boardRuntime } from "#server/boardRuntime.ts";
+import type { HomeMissing } from "#server/files/home.ts";
+import type { MermaidMissing } from "#server/http/assets.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 { responsePage } from "#server/responses/page.ts";
-import type { Responses } from "#server/responses/service.ts";
-import { resultPage } from "#server/results/page.ts";
-import { server } from "#server/rpc/transport.ts";
-import { searchSnapshot } from "#server/search/snapshot.ts";
 
 export interface BoardOptions {
 	readonly fleetPort?: number;
@@ -37,104 +20,6 @@ export interface BoardOptions {
 	readonly root: string;
 }
 
-type Services = Highlighter | Responses | HandoffsService | Diagnostics | FileSystem.FileSystem | Path.Path;
-type Handler<E> = (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, Services | Scope.Scope>;
-
-function routes(options: BoardOptions) {
-	return HttpRouter.use((router) =>
-		Effect.gen(function* () {
-			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 = 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);
-			function serve<E>(route: HttpRouter.PathInput, handler: Handler<E>, method: "GET" | "POST" = "GET") {
-				return router.add(
-					method,
-					route,
-					loopbackOnly((request) => Effect.provideContext(handler(request), context)),
-				);
-			}
-			yield* serve("/_board/attachment/*", attachment(options.root, changes.realRoot));
-			const healthPage = diagnosticsPage(
-				Effect.flatMap(Diagnostics, (service) => service.read()).pipe(Effect.provideContext(context)),
-				changes,
-				home,
-				index,
-			);
-			yield* serve("/_board/diagnostics", () => healthPage);
-			const inboxPage = inbox(index, changes, home);
-			yield* serve("/_board/inbox", inboxPage);
-			const startPage = start(changes, home, index);
-			yield* serve("/_board/start", startPage);
-			const workPage = work(index, changes, home);
-			const result = resultPage(index, changes, home);
-			yield* serve("/_board/result", result);
-			const overviewPage = overview(index, changes, home);
-			const historyPage = changesPage(changes, home, index);
-			yield* serve("/_board/work", workPage);
-			yield* serve("/_board/overview", overviewPage);
-			yield* serve("/_board/changes", historyPage);
-			for (const [route, asset] of ASSET_HANDLERS) {
-				yield* serve(route, asset);
-			}
-			yield* serve(MERMAID_ROUTE, mermaidFile(mermaid));
-			const replyPage = responsePage(changes, home, options.responses === true, index);
-			yield* serve("/_board/respond", replyPage);
-			const handoff = handoffPage(changes, home, options.responses === true, index);
-			yield* serve("/_board/handoff", handoff);
-			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);
-			const reading = readPage<PlatformError.PlatformError, Services>(
-				{
-					"/_board/changes": () => historyPage(),
-					"/_board/diagnostics": () => healthPage,
-					"/_board/handoff": handoff,
-					"/_board/inbox": () => inboxPage(),
-					"/_board/overview": () => overviewPage(),
-					"/_board/respond": replyPage,
-					"/_board/result": result,
-					"/_board/start": () => startPage(),
-					"/_board/work": workPage,
-				},
-				(request) => (new URL(request.url, "http://127.0.0.1").pathname.startsWith("/_board/item/") ? items(request) : pages(request)),
-			);
-			const rpc = yield* server({
-				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),
-				page: (url) => Effect.provideContext(reading(url), context),
-			}).pipe(Effect.provideContext(context));
-			yield* serve("/_board/rpc", (request) => rpc.pipe(Effect.provideService(HttpServerRequest.HttpServerRequest, request)), "POST");
-			yield* serve("/", pages);
-			yield* serve("/*", pages);
-		}),
-	);
-}
-
 type BoardError = InternalServerError | HomeMissing | MermaidMissing | PlatformError.PlatformError | RenderFailed;
 type BoardServices =
 	| FileSystem.FileSystem
@@ -143,5 +28,18 @@ type BoardServices =
 	| HttpRouter.Request<"Error", InternalServerError | PlatformError.PlatformError>;
 
 export function boardLayer(options: BoardOptions): Layer.Layer<never, BoardError, BoardServices> {
-	return routes(options).pipe(Layer.provide(Highlighter.layer));
+	return Layer.unwrap(
+		Effect.gen(function* () {
+			const runtime = yield* boardRuntime(options);
+			const rpc = RpcServer.layerHttp({ group: workRpcs, path: RPC_PATH, protocol: "http" }).pipe(
+				Layer.provide([
+					runtime.rpcHandlers,
+					RpcSerialization.layerNdjson,
+					HttpRouter.middleware((http) => localRpcGuard(http).pipe(Effect.provideService(RpcSerialization.RpcSerialization, RpcSerialization.ndjson)))
+						.layer,
+				]),
+			);
+			return Layer.mergeAll(boardRoutes(options, runtime), rpc, rpcPolicy);
+		}),
+	).pipe(Layer.provide(Highlighter.layer));
 }