@shivaedev/work-board 0.2.0 → 0.3.0

package/package.json

@@ -1,57 +1,57 @@
 {
   "name": "@shivaedev/work-board",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Serve a folder of markdown files as a live local page that updates in place when a file changes",
-  "type": "module",
-  "license": "MIT",
+  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/work-board#readme",
+  "bugs": {
+    "url": "https://github.com/ShivaeDev/platform/issues"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ShivaeDev/platform.git",
     "directory": "packages/work-board"
   },
-  "homepage": "https://github.com/ShivaeDev/platform/tree/main/packages/work-board#readme",
-  "bugs": {
-    "url": "https://github.com/ShivaeDev/platform/issues"
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "imports": {
+    "#test/*": "./test/*",
+    "#*.ts": {
+      "source": "./src/*.ts",
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
   },
-  "engines": {
-    "node": ">=24"
+  "exports": {
+    "./*.ts": {
+      "types": "./dist/*.d.ts",
+      "source": "./src/*.ts",
+      "import": "./dist/*.js",
+      "default": "./dist/*.js"
+    },
+    "./package.json": "./package.json"
   },
-  "sideEffects": false,
   "bin": {
     "work-board": "./dist/cli.js"
   },
   "files": [
     "dist",
     "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.spec.ts",
     "CHANGELOG.md",
     "README.md"
   ],
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "source": "./src/index.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "publishConfig": {
-    "access": "public",
-    "provenance": true
-  },
   "dependencies": {
     "mermaid": "11.16.1",
     "satteri": "0.9.5",
-    "shiki": "4.4.2"
-  },
-  "peerDependencies": {
-    "@effect/platform-node": "4.0.0-rc.112",
-    "@effect/platform-node-shared": "4.0.0-rc.112",
-    "effect": "4.0.0-rc.112"
+    "shiki": "4.4.2",
+    "yaml": "2.9.0"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.112",
     "@effect/platform-node-shared": "4.0.0-rc.112",
+    "@shivaedev/quality": "0.9.0",
     "@types/hast": "3.0.5",
     "@types/mdast": "4.0.4",
     "@types/node": "24.10.1",
@@ -61,13 +61,22 @@
     "typescript": "npm:@typescript/typescript6@6.0.2",
     "vitest": "4.1.9"
   },
+  "peerDependencies": {
+    "@effect/platform-node": "4.0.0-rc.112",
+    "@effect/platform-node-shared": "4.0.0-rc.112",
+    "effect": "4.0.0-rc.112"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "scripts": {
     "build": "node --eval \"import('node:fs').then(({ rmSync }) => rmSync('dist', { force: true, recursive: true }))\" && tsc6 --project tsconfig.build.json",
-    "check": "biome check .",
+    "ready": "pnpm typecheck && pnpm test && pnpm build",
     "test": "vitest run",
-    "test:package": "node scripts/test-package.mjs",
-    "typecheck": "tsc --noEmit",
-    "typecheck:compat": "tsc6 --noEmit",
-    "ready": "pnpm check && pnpm typecheck && pnpm typecheck:compat && pnpm test && pnpm build && pnpm test:package"
+    "typecheck": "tsc --noEmit"
   }
 }

package/src/board.ts

@@ -1,17 +1,22 @@
-import { Effect, type FileSystem, Layer, type Path } from "effect";
+import { Effect, type FileSystem, Layer, type Path, type PlatformError } from "effect";
 import { HttpRouter, type HttpServerRequest, type HttpServerResponse } from "effect/unstable/http";
-import { watchChanges } from "./files/changes.ts";
-import { homeIn } from "./files/home.ts";
-import { ASSETS, MERMAID_ROUTE, mermaidFile, mermaidRoot } from "./http/assets.ts";
-import { events } from "./http/events.ts";
-import { loopbackOnly } from "./http/loopback.ts";
-import { page } from "./http/page.ts";
-import { respond } from "./http/respond.ts";
-import { Highlighter } from "./render/highlighter.ts";
+import { watchChanges } from "#files/changes.ts";
+import { type HomeMissing, homeIn } from "#files/home.ts";
+import { ASSETS, MERMAID_ROUTE, type MermaidMissing, mermaidFile, mermaidRoot } from "#http/assets.ts";
+import { events } from "#http/events.ts";
+import { identity } from "#http/identity.ts";
+import { loopbackOnly } from "#http/loopback.ts";
+import { page } from "#http/page.ts";
+import { respond } from "#http/respond.ts";
+import { search } from "#http/search.ts";
+import { work } from "#http/work.ts";
+import type { RenderFailed } from "#render/failed.ts";
+import { Highlighter } from "#render/highlighter.ts";
+import { searchSnapshot } from "#search/snapshot.ts";
 
 export interface BoardOptions {
-	readonly root: string;
 	readonly home?: string | undefined;
+	readonly root: string;
 }
 
 type Services = Highlighter | FileSystem.FileSystem | Path.Path;
@@ -31,14 +36,22 @@ const routes = (options: BoardOptions) =>
 					loopbackOnly((request) => Effect.provideContext(handler(request), context)),
 				);
 			yield* serve("/events", events(changes));
+			const index = yield* searchSnapshot(options.root, home, changes);
+			yield* serve("/_board/search", search(index));
+			yield* serve("/_board/work", work(index, changes, home));
 			for (const [route, body, contentType] of ASSETS) {
 				yield* serve(route, () => Effect.succeed(respond(body, contentType)));
 			}
 			yield* serve(MERMAID_ROUTE, mermaidFile(mermaid));
-			const pages = page({ root: options.root, home }, changes);
+			const pages = page({ home, root: options.root }, changes, index);
+			yield* serve("/_board/item/*", identity(index, pages, changes, home));
 			yield* serve("/", pages);
 			yield* serve("/*", pages);
 		}),
 	);
 
-export const boardLayer = (options: BoardOptions) => routes(options).pipe(Layer.provide(Highlighter.layer));
+type BoardError = HomeMissing | MermaidMissing | PlatformError.PlatformError | RenderFailed;
+type BoardServices = FileSystem.FileSystem | HttpRouter.HttpRouter | Path.Path | HttpRouter.Request<"Error", PlatformError.PlatformError>;
+
+export const boardLayer = (options: BoardOptions): Layer.Layer<never, BoardError, BoardServices> =>
+	routes(options).pipe(Layer.provide(Highlighter.layer));

package/src/cli.ts

@@ -4,19 +4,19 @@ import { Effect, Layer, Option, Path } from "effect";
 import { Argument, Command, Flag } from "effect/unstable/cli";
 import { HOST, serveBoard } from "./serve.ts";
 
-const VERSION = "0.2.0";
+const VERSION = "0.3.0";
 
 const serve = Effect.fn("WorkBoard.serve")(function* (input: { readonly dir: string; readonly port: number; readonly home: Option.Option<string> }) {
 	const path = yield* Path.Path;
-	return yield* Layer.launch(serveBoard({ root: path.resolve(input.dir), home: Option.getOrUndefined(input.home), port: input.port }));
+	return yield* Layer.launch(serveBoard({ home: Option.getOrUndefined(input.home), port: input.port, root: path.resolve(input.dir) }));
 });
 
 const workBoard = Command.make(
 	"work-board",
 	{
 		dir: Argument.directory("dir", { mustExist: true }).pipe(Argument.withDescription("The folder of markdown files to serve")),
-		port: Flag.integer("port").pipe(Flag.withDefault(4747), Flag.withDescription(`The port to listen on at ${HOST}`)),
 		home: Flag.string("home").pipe(Flag.optional, Flag.withDescription("The file shown as a board at /, relative to the folder")),
+		port: Flag.integer("port").pipe(Flag.withDefault(4747), Flag.withDescription(`The port to listen on at ${HOST}`)),
 	},
 	serve,
 ).pipe(Command.withDescription("Serve a folder of markdown files as a live page that updates in place when a file changes."));

package/src/files/changes.ts

@@ -1,18 +1,19 @@
 import { Data, Deferred, Effect, FileSystem, Option, Path, type PlatformError, PubSub, Ref, Schedule, Stream } from "effect";
 import { isMarkdown, listMarkdown, type MarkdownFile } from "./list.ts";
 
-export type Change = { readonly _tag: "Changed"; readonly paths: ReadonlyArray<string> } | { readonly _tag: "Watching"; readonly watching: boolean };
+export type Change = { readonly _tag: "Changed"; readonly paths: readonly string[] } | { readonly _tag: "Watching"; readonly watching: boolean };
 
 export interface Changes {
-	readonly realRoot: string;
 	readonly events: PubSub.PubSub<Change>;
+	readonly files: Effect.Effect<readonly MarkdownFile[], PlatformError.PlatformError>;
+	readonly realRoot: string;
+	readonly revision: Effect.Effect<number>;
 	readonly watching: Ref.Ref<boolean>;
-	readonly files: Effect.Effect<ReadonlyArray<MarkdownFile>, PlatformError.PlatformError>;
 }
 
 interface Cached {
+	readonly files: readonly MarkdownFile[];
 	readonly generation: number;
-	readonly files: ReadonlyArray<MarkdownFile>;
 }
 
 class WatchEnded extends Data.TaggedError("WatchEnded") {}
@@ -63,9 +64,9 @@ export const watchChanges = Effect.fn("WorkBoard.watchChanges")(function* (root:
 			return hit.value.files;
 		}
 		const listed = yield* listMarkdown(root, realRoot).pipe(Effect.provideService(FileSystem.FileSystem, fs), Effect.provideService(Path.Path, path));
-		yield* Ref.set(cached, Option.some({ generation: now, files: listed }));
+		yield* Ref.set(cached, Option.some({ files: listed, generation: now }));
 		return listed;
 	});
-	const changes: Changes = { realRoot, events, watching, files };
+	const changes: Changes = { events, files, realRoot, revision: Ref.get(generation), watching };
 	return changes;
 });

package/src/files/list.ts

@@ -1,8 +1,8 @@
 import { Effect, FileSystem, Option, Path, type PlatformError } from "effect";
 
 export interface MarkdownFile {
-	readonly path: string;
 	readonly modified: number;
+	readonly path: string;
 }
 
 const skipped = (segment: string): boolean => segment.startsWith(".") || segment === "node_modules";
@@ -15,7 +15,7 @@ const folderOf = (path: string): string => path.slice(0, Math.max(0, path.lastIn
 
 const byFolder = (left: string, right: string): number => folderOf(left).localeCompare(folderOf(right)) || left.localeCompare(right);
 
-type Listing = Effect.Effect<ReadonlyArray<MarkdownFile>, PlatformError.PlatformError>;
+type Listing = Effect.Effect<readonly MarkdownFile[], PlatformError.PlatformError>;
 
 export const listMarkdown = Effect.fn("WorkBoard.listMarkdown")(function* (root: string, realRoot: string) {
 	const fs = yield* FileSystem.FileSystem;
@@ -35,7 +35,7 @@ export const listMarkdown = Effect.fn("WorkBoard.listMarkdown")(function* (root:
 				return yield* Effect.orElseSucceed(folder(relative, real.value), () => []);
 			}
 			const modified = Option.match(info.value.mtime, { onNone: () => 0, onSome: (date) => date.getTime() });
-			return info.value.type === "File" && relative.endsWith(".md") ? [{ path: relative, modified }] : [];
+			return info.value.type === "File" && relative.endsWith(".md") ? [{ modified, path: relative }] : [];
 		});
 	const folder = (relative: string, real: string): Listing =>
 		Effect.gen(function* () {

package/src/files/url.ts

@@ -0,0 +1,3 @@
+export function fileUrl(file: string): string {
+	return `/${file.split("/").map(encodeURIComponent).join("/")}`;
+}

package/src/http/assets.ts

@@ -1,15 +1,30 @@
 import { createRequire } from "node:module";
 import { Data, Effect, FileSystem, Path } from "effect";
 import type { HttpRouter, HttpServerRequest } from "effect/unstable/http";
-import { client } from "../page/client.ts";
-import { diagrams } from "../page/diagrams.ts";
-import { style } from "../page/style.ts";
-import { swap } from "../page/swap.ts";
+import { client, preferences } from "#page/client.ts";
+import { diagrams } from "#page/diagrams.ts";
+import { libraryScript } from "#page/libraryScript.ts";
+import { navigationScript } from "#page/navigationScript.ts";
+import { readingStateScript } from "#page/readingStateScript.ts";
+import { searchResultsScript } from "#page/searchResultsScript.ts";
+import { searchScript } from "#page/searchScript.ts";
+import { pageStateScript } from "#page/stateScript.ts";
+import { style } from "#page/style.ts";
+import { swap } from "#page/swap.ts";
+import { savedScript } from "#views/savedScript.ts";
 import { respond } from "./respond.ts";
 
 export const ASSETS: ReadonlyArray<readonly [HttpRouter.PathInput, string, string]> = [
 	["/_board/style.css", style, "text/css"],
+	["/_board/saved-views.js", savedScript(), "text/javascript"],
 	["/_board/client.js", client, "text/javascript"],
+	["/_board/preferences.js", preferences, "text/javascript"],
+	["/_board/search.js", searchScript(), "text/javascript"],
+	["/_board/search-results.js", searchResultsScript(), "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"],
 ];
@@ -20,7 +35,7 @@ export class MermaidMissing extends Data.TaggedError("MermaidMissing")<{ readonl
 
 export const mermaidRoot = Effect.fn("WorkBoard.mermaidRoot")(function* () {
 	const path = yield* Path.Path;
-	const entry = yield* Effect.try({ try: () => createRequire(import.meta.url).resolve("mermaid"), catch: (cause) => new MermaidMissing({ cause }) });
+	const entry = yield* Effect.try({ catch: (cause) => new MermaidMissing({ cause }), try: () => createRequire(import.meta.url).resolve("mermaid") });
 	return path.dirname(entry);
 });
 
@@ -29,7 +44,7 @@ export const mermaidFile = (mermaidRoot: string) =>
 		const fs = yield* FileSystem.FileSystem;
 		const path = yield* Path.Path;
 		const file = path.resolve(mermaidRoot, new URL(request.url, "http://127.0.0.1").pathname.slice(MERMAID.length));
-		if (!file.startsWith(`${mermaidRoot}${path.sep}`) || !file.endsWith(".mjs") || !(yield* fs.exists(file))) {
+		if (!(file.startsWith(`${mermaidRoot}${path.sep}`) && file.endsWith(".mjs") && (yield* fs.exists(file)))) {
 			return respond("Not found", "text/plain", 404);
 		}
 		return respond(yield* fs.readFile(file), "text/javascript");

package/src/http/events.ts

@@ -1,10 +1,10 @@
 import { Effect, PubSub, Ref, Stream } from "effect";
 import { Sse } from "effect/unstable/encoding";
 import { HttpServerResponse } from "effect/unstable/http";
-import type { Change, Changes } from "../files/changes.ts";
+import type { Change, Changes } from "#files/changes.ts";
 import { HEADERS } from "./respond.ts";
 
-const event = (name: string, data = ""): Sse.Event => ({ _tag: "Event", event: name, id: undefined, data });
+const event = (name: string, data = ""): Sse.Event => ({ _tag: "Event", data, event: name, id: undefined });
 
 const watching = (up: boolean): Sse.Event => event(up ? "ready" : "down");
 

package/src/http/identity.ts

@@ -0,0 +1,62 @@
+import { Effect } from "effect";
+import type { HttpServerRequest } from "effect/unstable/http";
+import type { Changes } from "#files/changes.ts";
+import { fileUrl } from "#files/url.ts";
+import { escapeHtml } from "#page/escape.ts";
+import { navHtml } from "#page/nav.ts";
+import { shell } from "#page/shell.ts";
+import type { searchSnapshot } from "#search/snapshot.ts";
+import type { page } from "./page.ts";
+import { respond } from "./respond.ts";
+
+function requestedIdentity(pathname: string): string {
+	try {
+		return decodeURIComponent(pathname.slice("/_board/item/".length).replace(/\/$/u, ""));
+	} catch {
+		return "";
+	}
+}
+
+export function identity(
+	index: Effect.Success<ReturnType<typeof searchSnapshot>>,
+	pages: ReturnType<typeof page>,
+	changes: Changes,
+	home: string | undefined,
+) {
+	return Effect.fn("WorkBoard.identity")(function* (request: HttpServerRequest.HttpServerRequest) {
+		const pathname = new URL(request.url, "http://127.0.0.1").pathname;
+		const id = requestedIdentity(pathname);
+		if (!pathname.endsWith("/") && /\.md$/iu.exec(id) !== null) {
+			return yield* pages(request);
+		}
+		const snapshot = yield* index;
+		const matches = snapshot.model.ids.get(id) ?? [];
+		if (snapshot.unavailable.length > 0) {
+			return respond(
+				shell(
+					`Item ${id}`,
+					"",
+					`<p class="empty">The workspace index is incomplete. Could not read ${escapeHtml(snapshot.unavailable.join(", "))}; item identity could not be validated. Retry when the files are readable.</p>`,
+					changes.realRoot,
+					false,
+				),
+				"text/html",
+				503,
+			);
+		}
+		if (matches.length === 1 && matches[0]) {
+			return yield* pages(request, matches[0].file, id);
+		}
+		const text =
+			matches.length > 0
+				? `The ID ${id} is duplicated. No document was selected.`
+				: `No item with ID ${id} is available. It may be missing, renamed, or invalid.`;
+		const choices = matches.map((document) => `<li><a href="${escapeHtml(fileUrl(document.file))}">${escapeHtml(document.file)}</a></li>`).join("");
+		const nav = navHtml(yield* changes.files, "", home);
+		return respond(
+			shell(`Item ${id}`, nav, `<p class="empty">${escapeHtml(text)}</p>${choices ? `<ul>${choices}</ul>` : ""}`, changes.realRoot, false),
+			"text/html",
+			matches.length > 0 ? 409 : 404,
+		);
+	});
+}

package/src/http/loopback.ts

@@ -13,8 +13,8 @@ const hostnameOf = (host: string): string | undefined => {
 };
 
 const loopbackAddress = (address: string): boolean => {
-	const unmapped = address.replace(/^::ffff:/i, "");
-	return unmapped === "::1" || /^127(?:\.\d{1,3}){3}$/.test(unmapped);
+	const unmapped = address.replace(/^::ffff:/iu, "");
+	return unmapped === "::1" || /^127(?:\.\d{1,3}){3}$/u.test(unmapped);
 };
 
 const fromLoopback = (request: HttpServerRequest.HttpServerRequest): boolean => {

package/src/http/page.ts

@@ -1,22 +1,26 @@
 import { Effect, FileSystem, Option, Path } from "effect";
 import type { HttpServerRequest } from "effect/unstable/http";
-import type { Changes } from "../files/changes.ts";
-import { type MarkdownFile, within } from "../files/list.ts";
-import { boardHtml } from "../page/board.ts";
-import { documentHtml } from "../page/document.ts";
-import { escapeHtml } from "../page/escape.ts";
-import { navHtml } from "../page/nav.ts";
-import { shell } from "../page/shell.ts";
-import { boardOf } from "../render/board.ts";
+import type { Changes } from "#files/changes.ts";
+import { type MarkdownFile, within } from "#files/list.ts";
+import { metadataModel } from "#metadata/model.ts";
+import { metadataParse } from "#metadata/parse.ts";
+import { boardHtml } from "#page/board.ts";
+import { documentHtml } from "#page/document.ts";
+import { escapeHtml } from "#page/escape.ts";
+import { metadataHtml } from "#page/metadata.ts";
+import { navHtml } from "#page/nav.ts";
+import { shell } from "#page/shell.ts";
+import { boardOf } from "#render/board.ts";
+import type { searchSnapshot } from "#search/snapshot.ts";
 import { respond } from "./respond.ts";
 
 export interface PageOptions {
-	readonly root: string;
 	readonly home: string | undefined;
+	readonly root: string;
 }
 
 const requestedPath = (url: string): string => {
-	const pathname = new URL(url, "http://127.0.0.1").pathname.replace(/^\/+/, "");
+	const pathname = new URL(url, "http://127.0.0.1").pathname.replace(/^\/+/u, "");
 	try {
 		return decodeURIComponent(pathname);
 	} catch {
@@ -26,8 +30,8 @@ const requestedPath = (url: string): string => {
 
 const message = (text: string): string => `<p class="empty">${escapeHtml(text)}</p>`;
 
-export const page = (options: PageOptions, changes: Changes) => {
-	const body = Effect.fn("WorkBoard.pageBody")(function* (file: MarkdownFile) {
+export const page = (options: PageOptions, changes: Changes, index: Effect.Success<ReturnType<typeof searchSnapshot>>) => {
+	const body = Effect.fn("WorkBoard.pageBody")(function* (file: MarkdownFile, expectedIdentity?: string) {
 		const fs = yield* FileSystem.FileSystem;
 		const path = yield* Path.Path;
 		const real = yield* Effect.option(fs.realPath(path.join(options.root, file.path)));
@@ -35,20 +39,53 @@ export const page = (options: PageOptions, changes: Changes) => {
 			return Option.none();
 		}
 		const source = yield* fs.readFileString(real.value);
-		return Option.some(file.path === options.home ? yield* boardHtml(boardOf(source), file.path, file.modified) : yield* documentHtml(source, file));
+		const parsed = metadataParse(source);
+		let identity: string | undefined;
+		const snapshot = yield* index;
+		const model = metadataModel(
+			[...snapshot.documents.filter((document) => document.file !== file.path), { file: file.path, parsed }],
+			snapshot.unavailable,
+			options.home ?? (yield* changes.files)[0]?.path,
+		);
+		const metadata = metadataHtml(parsed, file.path, model);
+		if (snapshot.unavailable.length === 0 && parsed.fields.id && model.ids.get(parsed.fields.id)?.length === 1) {
+			identity = parsed.fields.id;
+		}
+		if (expectedIdentity && identity !== expectedIdentity) {
+			return Option.none();
+		}
+		const html =
+			file.path === options.home
+				? yield* boardHtml(boardOf(parsed.body), file.path, file.modified, metadata)
+				: yield* documentHtml(parsed.body, file, metadata);
+		return Option.some({ html, identity });
 	});
-	return Effect.fn("WorkBoard.page")(function* (request: HttpServerRequest.HttpServerRequest) {
+	return Effect.fn("WorkBoard.page")(function* (request: HttpServerRequest.HttpServerRequest, resolved?: string, expectedIdentity?: string) {
 		const files = yield* changes.files;
-		const requested = requestedPath(request.url) || options.home || files[0]?.path || "";
+		const requested = resolved ?? (requestedPath(request.url) || options.home || files[0]?.path || "");
 		const file = files.find((candidate) => candidate.path === requested);
 		const nav = navHtml(files, requested, options.home);
-		const missing = () => respond(shell(requested, nav, message(`No markdown file at ${requested || options.root}.`)), "text/html", 404);
+		function layout(content: string, identity?: string) {
+			return shell(requested, nav, content, changes.realRoot, requested === options.home, identity);
+		}
+		const missing = () =>
+			respond(
+				layout(
+					message(
+						expectedIdentity
+							? `No item with ID ${expectedIdentity} at ${requested}; its source identity changed or is invalid.`
+							: `No markdown file at ${requested || options.root}.`,
+					),
+				),
+				"text/html",
+				404,
+			);
 		if (file === undefined) {
 			return missing();
 		}
-		return yield* body(file).pipe(
-			Effect.map(Option.match({ onNone: missing, onSome: (main) => respond(shell(file.path, nav, main), "text/html") })),
-			Effect.catch(() => Effect.succeed(respond(shell(file.path, nav, message(`${file.path} could not be read.`)), "text/html", 500))),
+		return yield* body(file, expectedIdentity).pipe(
+			Effect.map(Option.match({ onNone: missing, onSome: (main) => respond(layout(main.html, main.identity), "text/html") })),
+			Effect.catch(() => Effect.succeed(respond(layout(message(`${file.path} could not be read.`)), "text/html", 500))),
 		);
 	});
 };

package/src/http/search.ts

@@ -0,0 +1,13 @@
+import { Effect } from "effect";
+import type { HttpServerRequest } from "effect/unstable/http";
+import { searchMatch } from "#search/match.ts";
+import type { searchSnapshot } from "#search/snapshot.ts";
+import { respond } from "./respond.ts";
+
+export function search(index: Effect.Success<ReturnType<typeof searchSnapshot>>) {
+	return Effect.fn("WorkBoard.search")(function* (request: HttpServerRequest.HttpServerRequest) {
+		const query = new URL(request.url, "http://127.0.0.1").searchParams.get("q") ?? "";
+		const snapshot = yield* index;
+		return respond(JSON.stringify({ ...searchMatch(snapshot.entries, query), unavailable: snapshot.unavailable }), "application/json");
+	});
+}

package/src/http/work.ts

@@ -0,0 +1,41 @@
+import { Effect } from "effect";
+import type { HttpServerRequest } from "effect/unstable/http";
+import type { Changes } from "#files/changes.ts";
+import { escapeHtml } from "#page/escape.ts";
+import { navHtml } from "#page/nav.ts";
+import { shell } from "#page/shell.ts";
+import type { searchSnapshot } from "#search/snapshot.ts";
+import { stateOf } from "#views/state.ts";
+import { workHtml } from "#views/workHtml.ts";
+import { respond } from "./respond.ts";
+
+export function work(index: Effect.Success<ReturnType<typeof searchSnapshot>>, changes: Changes, home: string | undefined) {
+	return Effect.fn("WorkBoard.work")(function* (request: HttpServerRequest.HttpServerRequest) {
+		const snapshot = yield* index;
+		const nav = navHtml(yield* changes.files, "", home);
+		if (snapshot.unavailable.length > 0) {
+			return respond(
+				shell(
+					"Work",
+					nav,
+					`<h1>Workspace incomplete</h1><p class="empty">Could not read ${escapeHtml(snapshot.unavailable.join(", "))}. Work identity and view counts cannot be validated. Read available source files or retry when the workspace is readable.</p>`,
+					changes.realRoot,
+					true,
+					undefined,
+					true,
+				),
+				"text/html",
+				503,
+			);
+		}
+		const result = yield* workHtml(snapshot, stateOf(request.url)).pipe(
+			Effect.catch(() =>
+				Effect.succeed({
+					html: '<h1>Work unavailable</h1><p class="empty">The selected source could not be rendered. Read its Markdown file or retry.</p>',
+					status: 500,
+				}),
+			),
+		);
+		return respond(shell("Work", nav, result.html, changes.realRoot, true, undefined, true), "text/html", result.status);
+	});
+}

package/src/metadata/backlinks.ts

@@ -0,0 +1,39 @@
+import type { MetadataDocument, MetadataModel } from "./model.ts";
+import { referenceFile, sourceFile } from "./sourceLinks.ts";
+
+export interface Backlink {
+	readonly file: string;
+	readonly kind: string;
+	readonly line?: number;
+}
+
+function references(document: MetadataDocument, model: MetadataModel) {
+	const { fields, lines } = document.parsed;
+	return [
+		...(fields.relationships?.map((link, index) => ({
+			kind: link.kind,
+			line: lines[`relationships.${index}.target`],
+			target: referenceFile(link.target, model),
+		})) ?? []),
+		...(fields.items?.map((item, index) => ({ kind: "board member", line: lines[`items.${index}`], target: referenceFile(item, model) })) ?? []),
+		...(fields.evidence?.flatMap((evidence, index) => [
+			{ kind: "evidence source", line: lines[`evidence.${index}.source`], target: sourceFile(evidence.source, document.file, model) },
+			{
+				kind: "criterion evidence",
+				line: lines[`evidence.${index}.criterion`],
+				target: evidence.criterion ? referenceFile(evidence.criterion, model) : undefined,
+			},
+		]) ?? []),
+		...(document.links?.map((link) => ({ kind: "Markdown link", line: undefined, target: sourceFile(link, document.file, model) })) ?? []),
+	];
+}
+
+export function backlinksOf(file: string, model: MetadataModel): readonly Backlink[] {
+	return model.documents.flatMap((document) =>
+		document.file === file
+			? []
+			: references(document, model)
+					.filter((reference) => reference.target === file)
+					.map((reference) => ({ file: document.file, kind: reference.kind, ...(reference.line === undefined ? {} : { line: reference.line }) })),
+	);
+}

package/src/metadata/fields.ts

@@ -0,0 +1,26 @@
+import { Option, Schema } from "effect";
+import type { Diagnostic } from "./parse.ts";
+import { Metadata } from "./schema.ts";
+
+const schemas: ReadonlyMap<string, Schema.ConstraintDecoder<unknown, never>> = new Map(Object.entries(Metadata.to.fields));
+const sourceKeys = new Map([["next_action", "nextAction"]]);
+
+export function metadataFields(data: object, lines: Readonly<Record<string, number>>) {
+	const fields: Record<string, unknown> = {};
+	const diagnostics: Diagnostic[] = [];
+	for (const [field, value] of Object.entries(data)) {
+		const key = sourceKeys.get(field) ?? field;
+		const schema = field === "nextAction" ? undefined : schemas.get(key);
+		if (!schema) {
+			diagnostics.push({ field, line: lines[field] ?? 2, message: `Unknown field ${field}; kept in the original frontmatter.` });
+			continue;
+		}
+		const decoded = Schema.decodeUnknownOption(schema, { onExcessProperty: "error" })(value);
+		if (Option.isNone(decoded)) {
+			diagnostics.push({ field, line: lines[field] ?? 2, message: `Invalid ${field}; kept in the original frontmatter and not interpreted.` });
+		} else {
+			fields[key] = decoded.value;
+		}
+	}
+	return { diagnostics, fields: Schema.decodeUnknownSync(Schema.toType(Metadata))(fields) };
+}