@shivaedev/work-board 0.4.0 → 0.5.0

package/src/page/client.ts

@@ -3,98 +3,97 @@ import "/_board/saved-views.js";
 import "/_board/history.js";
 import "/_board/preferences.js";
 import "/_board/search.js";
+import { tick } from "/_board/ages.js";
 import { renderDiagrams } from "/_board/diagrams.js";
 import { applyPage } from "/_board/page-state.js";
-import { pageVersion } from "/_board/navigation.js";
-import { remember } from "/_board/swap.js";
+import "/_board/navigation.js";
+import { remember, swap } from "/_board/swap.js";
+import { refreshLibrary } from "/_board/library.js";
+import { session } from "/_board/native.js";
 
-const since = (modified) => {
-  const seconds = Math.max(0, Math.round((Date.now() - modified) / 1000));
-  if (seconds < 60) return seconds + "s";
-  if (seconds < 3600) return Math.round(seconds / 60) + "m";
-  if (seconds < 172800) return Math.round(seconds / 3600) + "h";
-  return Math.round(seconds / 86400) + "d";
-};
-
-const tick = () => {
-  for (const age of document.querySelectorAll("[data-modified]")) {
-    const ago = since(Number(age.dataset.modified));
-    age.textContent = age.classList.contains("short") ? ago : "updated " + ago + " ago";
-  }
-};
 
 remember(document.getElementById("files"));
 remember(document.getElementById("doc"));
 
+let native = session(window);
 const live = document.getElementById("live");
-let connected = false;
-let dropped = true;
-let failure = "";
-
+const toggle = document.getElementById("updates-toggle");
+let pageFailure = "";
+let navFailure = "";
+let pageWaiting = true;
+let watching = false;
+let navWaiting = true;
+let active = "";
+let releasePage;
 const show = () => {
-  const state = failure !== "" ? "stale" : connected ? "live" : "down";
-  live.dataset.state = state;
-  live.textContent = failure !== "" ? failure : connected ? "live" : "reconnecting";
+  const state = native.registry.get(native.updates.status);
+  const paused = native.registry.get(native.updates.paused);
+  const failure = pageFailure || navFailure;
+  live.dataset.state = paused ? "paused" : failure ? "stale" : !watching || state.connection !== "live" ? "down" : pageWaiting || navWaiting ? "refreshing" : "live";
+  live.textContent = paused ? "updates paused · " + state.pending + (state.pending === 256 ? "+" : "") + " pending updates" : failure || (!watching || state.connection !== "live" ? "reconnecting" : pageWaiting || navWaiting ? "refreshing" : "live");
+  toggle.textContent = paused ? "Resume updates" : "Pause updates";
+  toggle.setAttribute("aria-pressed", String(paused));
+  live.title = "Connection: " + state.connection + "; last observed source watcher: " + (watching ? "watching" : "unavailable") + "; " + (paused ? "automatic reads paused" : pageWaiting || navWaiting ? "reads pending" : failure ? "showing retained source" : "reads settled");
 };
-
-const load = async () => {
-  const version = pageVersion();
+const watchPage = () => {
   const path = location.pathname + location.search;
-  try {
-    const response = await fetch(path, { cache: "no-store" });
-    const next = new DOMParser().parseFromString(await response.text(), "text/html");
-    const files = next.getElementById("files");
-    const doc = next.getElementById("doc");
-    if (version !== pageVersion()) return;
-    if (files === null || doc === null) {
-      failure = "refresh failed (" + response.status + ")";
-      return;
+  if (path === active) return;
+  active = path;
+  releasePage?.();
+  pageFailure = "";
+  const atom = native.api.page.query({ url: path });
+  releasePage = native.registry.subscribe(atom, (value) => {
+    pageWaiting = value.waiting || value._tag === "Initial";
+    if (value._tag === "Failure") pageFailure = "refresh failed";
+    if (value._tag === "Success" && !value.waiting && active === location.pathname + location.search) {
+      const next = new DOMParser().parseFromString(value.value.html, "text/html");
+      pageFailure = applyPage(next, true) ? "" : "refresh failed";
+      tick();
     }
-    failure = "";
-    applyPage(next, true);
-    tick();
-  } catch {
-    if (version !== pageVersion()) return;
-    failure = "refresh failed";
-  }
+    show();
+  }, { immediate: true });
 };
-
-let loading = false;
-let dirty = false;
-const refresh = async () => {
-  if (loading) {
-    dirty = true;
-    return;
+const observe = () => {
+native.registry.subscribe(native.api.navigation.query(), (value) => {
+  navWaiting = value.waiting || value._tag === "Initial";
+  if (value._tag === "Failure") navFailure = "navigation refresh failed";
+  if (value._tag === "Success" && !value.waiting) {
+    navFailure = "";
+    const files = document.getElementById("files");
+    const next = files.cloneNode(false);
+    next.innerHTML = value.value;
+    const current = document.getElementById("doc").dataset.file;
+    for (const link of next.querySelectorAll("a")) if (decodeURIComponent(new URL(link.href, location.href).pathname.slice(1)) === current) link.setAttribute("aria-current", "page");
+    swap(files, next);
+    refreshLibrary();
+    tick();
+    document.dispatchEvent(new Event("board-index-change"));
   }
-  loading = true;
-  do {
-    dirty = false;
-    await load();
-  } while (dirty);
-  loading = false;
-  show();
-};
-
-const events = new EventSource("/events");
-events.addEventListener("ready", () => {
-  connected = true;
-  document.dispatchEvent(new Event("board-index-change"));
   show();
-  if (dropped) refresh();
-  dropped = false;
-});
-const down = () => {
-  connected = false;
-  dropped = true;
+}, { immediate: true });
+native.registry.subscribe(native.api.watcher.query(), (value) => {
+  watching = value._tag === "Success" && value.value.watching;
   show();
+}, { immediate: true });
+native.registry.subscribe(native.updates.status, show);
+native.registry.subscribe(native.updates.paused, (paused) => { show(); if (!paused) document.dispatchEvent(new Event("board-updates-resumed")); });
 };
-events.addEventListener("change", () => { refresh(); document.dispatchEvent(new Event("board-index-change")); });
-events.addEventListener("down", down);
-events.addEventListener("error", down);
+observe();
+toggle.disabled = false;
+toggle.addEventListener("click", () => native.registry.set(native.updates.paused, !native.registry.get(native.updates.paused)));
+document.addEventListener("board-page", watchPage);
+watchPage();
+window.addEventListener("pagehide", () => { releasePage?.(); active = ""; });
+window.addEventListener("pageshow", (event) => {
+  if (!event.persisted) return;
+  native = session(window);
+  pageWaiting = navWaiting = true;
+  watching = false;
+  pageFailure = navFailure = "";
+  observe();
+  watchPage();
+});
 
-document.addEventListener("board-page", tick);
-tick();
-setInterval(tick, 5000);
 renderDiagrams(document);
 `;
 export const preferences = `

package/src/page/navigationScript.ts

@@ -3,6 +3,7 @@ export function navigationScript(): string {
 import { applyPage, capturePage } from "/_board/page-state.js";
 import { reportMissingPassage, restoreReading, scrollToPassage } from "/_board/reading-state.js";
 import { refreshLibrary } from "/_board/library.js";
+import { session } from "/_board/native.js";
 
 const cache = new Map();
 const readingKey = "work-board:reading:" + document.documentElement.dataset.workspace;
@@ -65,20 +66,21 @@ const navigate = async (target, entry) => {
     restoreReading(cached.reading);
   } else status.textContent = "Opening document…";
   try {
-    const response = await fetch(target.pathname + target.search, { cache: "no-store", signal: controller.signal });
-    const page = new DOMParser().parseFromString(await response.text(), "text/html");
+    const native = session(window);
+    const response = await native.read(native.api.page.query({ url: target.pathname + target.search }), controller.signal);
+    const page = new DOMParser().parseFromString(response.html, "text/html");
     if (mine !== version) return;
     if (!applyPage(page, Boolean(cached))) throw new Error("Invalid page");
     displayedId = id;
-    status.textContent = response.ok ? "" : response.status === 404 ? "This document is missing or was renamed." : "This document could not be opened.";
-    if (response.ok) reportMissingPassage();
+    status.textContent = response.status < 400 ? "" : response.status === 404 ? "This document is missing or was renamed." : "This document could not be opened.";
+    if (response.status < 400) reportMissingPassage();
     if (!cached) {
       document.getElementById("doc").focus({ preventScroll: true });
       if (savedReading[id] ?? entry?.reading) restoreReading(savedReading[id] ?? entry.reading);
       else scrollToPassage(target.hash);
     }
   } catch (error) {
-    if (mine !== version || error.name === "AbortError") return;
+    if (mine !== version || controller.signal.aborted) return;
     status.textContent = "Could not open this document. Retry the link or reload the page.";
   }
 };

package/src/page/searchScript.ts

@@ -1,6 +1,7 @@
 export function searchScript(): string {
 	return `
 import { activate, matchingCommands, move, showResults } from "/_board/search-results.js";
+import { session } from "/_board/native.js";
 const dialog = document.getElementById("search-dialog");
 const input = document.getElementById("search-query");
 const status = document.getElementById("search-status");
@@ -25,14 +26,15 @@ const search = async () => {
  status.textContent = "Searching…";
  controller = new AbortController();
  try {
-  const response = await fetch("/_board/search?q=" + encodeURIComponent(query), { cache: "no-store", signal: controller.signal });
-  if (!response.ok) throw new Error("Search unavailable");
-  const body = await response.json();
+  const native = session(window);
+  const atom = native.api.search.query({ query });
+  native.registry.refresh(atom);
+  const body = await native.read(atom, controller.signal);
   if (mine !== version || !dialog.open) return;
   showResults([...commands, ...body.results]);
   status.textContent = (body.total ? (body.total > body.results.length ? "Showing " + body.results.length + " of " : "") + body.total + " matches." : "No document matches.") + (body.unavailable.length ? " Could not read " + body.unavailable.length + " files; results are incomplete." : "");
  } catch (error) {
-  if (mine !== version || error.name === "AbortError") return;
+  if (mine !== version || controller.signal.aborted) return;
   status.textContent = "Search could not be completed. Press Search to retry.";
  }
 };

package/src/page/shell.ts

@@ -33,7 +33,7 @@ export const shell = (
 		'<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>',
-		'<span id="preference-status" role="status"></span></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}</body></html>`,
 	].join("");

package/src/page/stateScript.ts

@@ -22,7 +22,7 @@ export const applyPage = (page, preserve = false) => {
       const content = current.querySelector("#changes-content");
       if (content) incoming.querySelector("#changes-content")?.replaceWith(content.cloneNode(true));
     }
-    swap(current, incoming);
+    swap(current, incoming, true);
   } else {
     current.replaceWith(document.importNode(incoming, true));
     remember(document.getElementById("doc"));

package/src/page/style.ts

@@ -48,6 +48,7 @@ footer { margin-top: 2.5em; padding-top: 1em; border-top: 1px solid var(--border
 `;
 
 const diagrams = `
+[data-live-change] { outline: 2px solid var(--border); outline-offset: 3px; border-radius: 3px; }
 figure.diagram { margin-left: 0; margin-right: 0; }
 figure.diagram[data-state="pending"] { min-height: 12rem; background: var(--surface); border-radius: 6px; }
 figure.diagram .diagram-source { display: none; }

package/src/page/swap.ts

@@ -4,6 +4,12 @@ const containers = new Set(["DIV", "SECTION", "ARTICLE", "HEADER", "FOOTER", "MA
 const structural = (element) => [...element.childNodes].every((node) => node.nodeType === 1 || node.textContent.trim() === "");
 
 const pristine = new WeakMap();
+const flash = (element) => {
+  if (element.matches("[data-modified]")) return;
+  if (!element.matches("p, li, pre, blockquote, h1, h2, h3, h4, h5, h6, .item, .notes, .metadata-panel")) return;
+  element.setAttribute("data-live-change", "");
+  setTimeout(() => element.removeAttribute("data-live-change"), 2500);
+};
 
 export const remember = (element) => {
   pristine.set(element, element.outerHTML);
@@ -13,6 +19,7 @@ export const remember = (element) => {
 const normalized = (element) => {
   const copy = element.cloneNode(true);
   for (const node of [copy, ...copy.querySelectorAll("*")]) {
+    node.removeAttribute("data-live-change");
     if (node.tagName === "DETAILS") node.removeAttribute("open");
     if (node.matches("figure.diagram")) {
       node.querySelector(".diagram-svg")?.remove();
@@ -29,8 +36,10 @@ const signature = (element) => {
   return pristine.get(element);
 };
 
+const normalizedShell = (element) => { const copy = element.cloneNode(false); copy.removeAttribute("data-live-change"); return copy.outerHTML; };
+
 const sameShell = (old, next) =>
-  old.tagName === next.tagName && containers.has(old.tagName) && old.cloneNode(false).outerHTML === next.cloneNode(false).outerHTML;
+  old.tagName === next.tagName && containers.has(old.tagName) && normalizedShell(old) === normalizedShell(next);
 
 const matches = (a, b) => {
   let start = 0;
@@ -55,12 +64,13 @@ const matches = (a, b) => {
   return [...pairs, [a.length, b.length]];
 };
 
-const patch = (current, incoming) => {
+const patch = (current, incoming, highlight) => {
   const selected = current.tagName === "SELECT" ? current.value : null;
   const fallback = incoming.tagName === "SELECT" ? incoming.value : null;
   if (!structural(current) || !structural(incoming)) {
     current.replaceChildren(...incoming.childNodes);
     for (const child of current.children) remember(child);
+    if (highlight) flash(current);
     return;
   }
   const olds = [...current.children];
@@ -68,6 +78,7 @@ const patch = (current, incoming) => {
   const signatures = news.map((next) => next.outerHTML);
   const arrive = (index) => {
     remember(news[index]);
+    if (highlight) flash(news[index]);
     return news[index];
   };
   let i = 0;
@@ -76,7 +87,7 @@ const patch = (current, incoming) => {
     const anchor = olds[kept] ?? null;
     for (; i < kept && j < arrived; i++, j++) {
       if (sameShell(olds[i], news[j])) {
-        patch(olds[i], news[j]);
+        patch(olds[i], news[j], highlight);
         pristine.set(olds[i], signatures[j]);
       } else olds[i].replaceWith(arrive(j));
     }
@@ -110,12 +121,12 @@ const carryDrawings = (drawings, figures) => {
   });
 };
 
-export const swap = (current, incoming) => {
+export const swap = (current, incoming, highlight = false) => {
   const before = keysOf(current);
   const open = new Map(before.map(([key, details]) => [key, details.open]));
   const existing = new Set(before.map(([, details]) => details));
   const drawings = [...current.querySelectorAll("figure.diagram")].map((figure) => figure.querySelector(".diagram-svg"));
-  patch(current, incoming);
+  patch(current, incoming, highlight);
   carryDrawings(drawings, [...current.querySelectorAll("figure.diagram")]);
   for (const [key, details] of keysOf(current)) {
     const was = open.get(key);

package/src/path/isMarkdown.ts

@@ -0,0 +1,6 @@
+function skipped(segment: string): boolean {
+	return segment.startsWith(".") || segment === "node_modules";
+}
+export function isMarkdown(path: string): boolean {
+	return path.endsWith(".md") && !path.split("/").some(skipped);
+}

package/src/rpc/affected.ts

@@ -0,0 +1,77 @@
+import type { Key } from "@shivaedev/effect-contract/keys.ts";
+import { backlinksOf } from "#metadata/backlinks.ts";
+import type { MetadataModel } from "#metadata/model.ts";
+import { documents, identities, index, navigation } from "./keys.ts";
+
+function uncertain(previous: MetadataModel, current: MetadataModel, paths: readonly string[]) {
+	if (previous.unavailable.length > 0 || current.unavailable.length > 0) {
+		return true;
+	}
+	const before = new Map(previous.documents.map((doc) => [doc.file, doc.parsed]));
+	const after = new Map(current.documents.map((doc) => [doc.file, doc.parsed]));
+	const known = new Set([...before.keys(), ...after.keys()]);
+	if (paths.some((path) => !known.has(path))) {
+		return true;
+	}
+	const announced = new Set(paths);
+	return [...known].some((file) => {
+		const old = before.get(file);
+		const next = after.get(file);
+		return !announced.has(file) && (old?.body !== next?.body || old?.raw !== next?.raw || old?.bodyLine !== next?.bodyLine);
+	});
+}
+function connectIdentities(model: MetadataModel, connect: (from: string, to: string) => void) {
+	for (const duplicates of model.ids.values()) {
+		const first = duplicates[0];
+		if (first === undefined) {
+			continue;
+		}
+		for (const duplicate of duplicates.slice(1)) {
+			connect(first.file, duplicate.file);
+			connect(duplicate.file, first.file);
+		}
+	}
+}
+function linkedFiles(models: readonly MetadataModel[], paths: readonly string[]) {
+	const edges = new Map<string, Set<string>>();
+	function connect(from: string, to: string) {
+		const targets = edges.get(from) ?? new Set();
+		targets.add(to);
+		edges.set(from, targets);
+	}
+	for (const model of models) {
+		connectIdentities(model, connect);
+		for (const document of model.documents) {
+			for (const link of backlinksOf(document.file, model)) {
+				connect(document.file, link.file);
+				connect(link.file, document.file);
+			}
+		}
+	}
+	const files = new Set(paths);
+	for (const file of files) {
+		for (const linked of edges.get(file) ?? []) {
+			files.add(linked);
+		}
+	}
+	return files;
+}
+export function affected(previous: MetadataModel, current: MetadataModel, paths: readonly string[]): readonly Key[] | undefined {
+	if (uncertain(previous, current, paths)) {
+		return undefined;
+	}
+	const models = [previous, current];
+	const files = linkedFiles(models, paths);
+	const keys: Key[] = [index.list, navigation.list, ...[...files].map((file) => documents.item(file))];
+	for (const model of models) {
+		if (model.rootFile && files.has(model.rootFile)) {
+			keys.push(documents.item(""));
+		}
+		for (const document of model.documents) {
+			if (files.has(document.file) && document.parsed.fields.id) {
+				keys.push(identities.item(document.parsed.fields.id));
+			}
+		}
+	}
+	return keys;
+}

package/src/rpc/contract.ts

@@ -0,0 +1,62 @@
+import { Schema } from "effect";
+import { Rpc } from "effect/unstable/rpc";
+import { contract } from "@shivaedev/effect-contract/contract.ts";
+import { LiveHint } from "@shivaedev/effect-contract/live.ts";
+import { query } from "@shivaedev/effect-contract/operation.ts";
+import { HistoryInput, HistoryOutput } from "#history/schema.ts";
+import { index, navigation, watcher, workspace } from "./keys.ts";
+import { pageKeys } from "./pageKeys.ts";
+
+export class ReadFailed extends Schema.TaggedError<ReadFailed>()("ReadFailed", { operation: Schema.String, status: Schema.Number }) {}
+const PageUrl = Schema.String.check(
+	Schema.isMaxLength(8192),
+	Schema.makeFilter((value) => {
+		if (!value.startsWith("/") || value.startsWith("//")) {
+			return "Expected a local reading URL";
+		}
+		try {
+			const path = new URL(value, "http://127.0.0.1").pathname;
+			return (
+				path === "/"
+				|| ["/_board/work", "/_board/overview", "/_board/changes"].includes(path)
+				|| /^\/_board\/item\/[^/]+\/$/u.exec(path) !== null
+				|| /\.md$/iu.exec(path) !== null
+				|| "Expected a local reading URL"
+			);
+		} catch {
+			return "Expected a local reading URL";
+		}
+	}),
+);
+const Page = Schema.Struct({ html: Schema.String, status: Schema.Number });
+const Entry = Schema.Struct({
+	file: Schema.String,
+	href: Schema.String,
+	kind: Schema.Literals(["document", "heading", "passage"]),
+	line: Schema.optional(Schema.Number),
+	snippet: Schema.String,
+	text: Schema.String,
+	title: Schema.String,
+});
+const ReadPage = query("page", { payload: { url: PageUrl }, reads: ({ url }) => pageKeys(url), rejections: { ReadFailed }, success: Page });
+const ReadNavigation = query("navigation", { reads: () => [workspace.list, navigation.list], rejections: { ReadFailed }, success: Schema.String });
+const ReadSearch = query("search", {
+	payload: { query: Schema.String.check(Schema.isMaxLength(8192)) },
+	reads: () => [workspace.list, index.list],
+	rejections: { ReadFailed },
+	success: Schema.Struct({ results: Schema.Array(Entry), total: Schema.Number, unavailable: Schema.Array(Schema.String) }),
+});
+const ReadHistory = query("history", {
+	payload: HistoryInput,
+	reads: () => [workspace.list, index.list],
+	rejections: { ReadFailed },
+	success: HistoryOutput,
+});
+const ReadWatcher = query("watcher", {
+	reads: () => [workspace.list, watcher.list],
+	rejections: { ReadFailed },
+	success: Schema.Struct({ watching: Schema.Boolean }),
+});
+export const workContract = contract("work-board", { queries: [ReadPage, ReadNavigation, ReadSearch, ReadHistory, ReadWatcher] });
+export const Subscribe = Rpc.make("work-board.subscribe", { error: ReadFailed, stream: true, success: LiveHint });
+export const workRpcs = workContract.add(Subscribe);

package/src/rpc/hints.ts

@@ -0,0 +1,34 @@
+import { Effect, PubSub, Stream } from "effect";
+import type { LiveHint } from "@shivaedev/effect-contract/live.ts";
+import type { Change, Changes } from "#files/changes.ts";
+import type { Snapshot } from "#search/snapshot.ts";
+import { affected } from "./affected.ts";
+
+export function hints(changes: Changes, index: Effect.Effect<Snapshot, unknown>) {
+	return Stream.unwrap(
+		Effect.gen(function* () {
+			const subscription = yield* PubSub.subscribe(changes.events);
+			let sequence = changes.sequence ? yield* changes.sequence : undefined;
+			let previous = yield* Effect.option(index);
+			function nextHint(change: Change) {
+				return Effect.gen(function* () {
+					const current = yield* Effect.option(index);
+					const contiguous = sequence !== undefined && change.sequence === sequence + 1;
+					sequence = change.sequence;
+					let hint: LiveHint = { _tag: "Resync" };
+					if (contiguous && change._tag === "Changed" && previous._tag === "Some" && current._tag === "Some") {
+						const keys = affected(previous.value.model, current.value.model, change.paths);
+						if (keys !== undefined) {
+							hint = { _tag: "Changed", keys };
+						}
+					}
+					previous = current;
+					return hint;
+				});
+			}
+
+			const changesStream = Stream.fromSubscription(subscription).pipe(Stream.mapEffect(nextHint));
+			return Stream.concat(Stream.succeed<LiveHint>({ _tag: "Resync" }), changesStream);
+		}),
+	);
+}

package/src/rpc/keys.ts

@@ -0,0 +1,9 @@
+import { Schema } from "effect";
+import { collection } from "@shivaedev/effect-contract/keys.ts";
+
+export const workspace = collection("work-board/workspace", Schema.String);
+export const documents = collection("work-board/documents", Schema.String);
+export const identities = collection("work-board/identities", Schema.String);
+export const navigation = collection("work-board/navigation", Schema.String);
+export const index = collection("work-board/index", Schema.String);
+export const watcher = collection("work-board/watcher", Schema.String);

package/src/rpc/pageKeys.ts

@@ -0,0 +1,14 @@
+import type { Key } from "@shivaedev/effect-contract/keys.ts";
+import { documents, identities, index, workspace } from "./keys.ts";
+
+export function pageKeys(url: string): readonly Key[] {
+	const path = new URL(url, "http://127.0.0.1").pathname;
+	const item = /^\/_board\/item\/(?<id>[^/]+)\/$/u.exec(path)?.groups?.id;
+	let key: Key = documents.item(decodeURIComponent(path.slice(1)));
+	if (item) {
+		key = identities.item(decodeURIComponent(item));
+	} else if (path.startsWith("/_board/")) {
+		key = index.list;
+	}
+	return [workspace.list, key];
+}

package/src/rpc/server.ts

@@ -0,0 +1,55 @@
+import { Clock, Effect, Layer, Ref } from "effect";
+import { HttpIncomingMessage, HttpServerResponse } from "effect/unstable/http";
+import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
+import type { Changes } from "#files/changes.ts";
+import { MAX_BYTES } from "#history/limits.ts";
+import { historyResponse } from "#history/response.ts";
+import { HEADERS } from "#http/respond.ts";
+import { navHtml } from "#page/nav.ts";
+import { searchMatch } from "#search/match.ts";
+import type { Snapshot } from "#search/snapshot.ts";
+import { ReadFailed, workRpcs } from "./contract.ts";
+import { hints } from "./hints.ts";
+
+export interface ServerOptions {
+	readonly changes: Changes;
+	readonly home: string | undefined;
+	readonly index: Effect.Effect<Snapshot, unknown>;
+	readonly page: (url: string) => Effect.Effect<HttpServerResponse.HttpServerResponse, unknown>;
+}
+
+export const server = Effect.fn("WorkBoard.server")(function* ({ changes, home, index, page }: ServerOptions) {
+	const handlers = workRpcs.toLayer({
+		"work-board.history": ({ action, baseline }) =>
+			Effect.gen(function* () {
+				const now = yield* Clock.currentTimeMillis;
+				const snapshot = action === "check" ? undefined : yield* index;
+				return historyResponse(baseline, now, snapshot);
+			}).pipe(Effect.catch(() => Effect.fail(new ReadFailed({ operation: "history", status: 500 })))),
+		"work-board.navigation": () =>
+			Effect.map(changes.files, (files) => navHtml(files, "", home)).pipe(
+				Effect.catch(() => Effect.fail(new ReadFailed({ operation: "navigation", status: 500 }))),
+			),
+		"work-board.page": ({ url }) =>
+			page(url).pipe(
+				Effect.flatMap((response) => {
+					if (response.status >= 500 || response.body._tag !== "Uint8Array") {
+						return Effect.fail(new ReadFailed({ operation: "page", status: response.status }));
+					}
+					return Effect.succeed({ html: new TextDecoder().decode(response.body.body), status: response.status });
+				}),
+				Effect.catch((error) => Effect.fail(error instanceof ReadFailed ? error : new ReadFailed({ operation: "page", status: 500 }))),
+			),
+		"work-board.search": ({ query }) =>
+			Effect.map(index, (snapshot) => ({ ...searchMatch(snapshot.entries, query), unavailable: snapshot.unavailable })).pipe(
+				Effect.catch(() => Effect.fail(new ReadFailed({ operation: "search", status: 500 }))),
+			),
+		"work-board.subscribe": () => hints(changes, index),
+		"work-board.watcher": () => Effect.map(Ref.get(changes.watching), (watching) => ({ watching })),
+	});
+	const handler = yield* RpcServer.toHttpEffect(workRpcs).pipe(Effect.provide(Layer.merge(handlers, RpcSerialization.layerNdjson)));
+	return handler.pipe(
+		Effect.provideService(HttpIncomingMessage.MaxBodySize, BigInt(4 * MAX_BYTES + 4096)),
+		Effect.map((response) => HttpServerResponse.setHeaders(response, HEADERS)),
+	);
+});