@shivaedev/work-board 0.12.0 → 0.14.0

package/src/server/search/metadataEntries.ts

@@ -1,4 +1,6 @@
 import { fileUrl } from "#files/url.ts";
+import { fleetRecords } from "#server/attention/inbox.ts";
+import { closedItem, deferredItem } from "#server/attention/status.ts";
 import { identityUrl } from "#server/metadata/links.ts";
 import type { MetadataDocument, MetadataModel } from "#server/metadata/model.ts";
 import { attentionEntries } from "./attentionEntries.ts";
@@ -8,18 +10,26 @@ function itemUrl(document: MetadataDocument, model: MetadataModel): string {
 	const id = document.parsed.fields.id;
 	return model.unavailable.length === 0 && id && model.ids.get(id)?.length === 1 ? identityUrl(id) : fileUrl(document.file);
 }
-export function metadataEntries(entries: readonly Entry[], documents: readonly MetadataDocument[], model: MetadataModel): readonly Entry[] {
+export function metadataEntries(
+	entries: readonly Entry[],
+	documents: readonly MetadataDocument[],
+	model: MetadataModel,
+	records: ReadonlySet<string> = fleetRecords(model),
+): readonly Entry[] {
 	const sources = new Map(documents.map((document) => [document.file, document]));
 	const enriched = entries.map((entry) => {
 		const document = sources.get(entry.file);
-		if (entry.kind !== "document" || !document) {
+		if (!document) {
 			return entry;
 		}
 		const fields = document.parsed.fields;
 		return {
 			...entry,
-			href: itemUrl(document, model),
-			text: [entry.text, fields.id, fields.kind, fields.status, fields.owner, fields.nextAction].filter(Boolean).join(" "),
+			href: entry.kind === "document" ? itemUrl(document, model) : entry.href,
+			text:
+				entry.kind === "document"
+					? [entry.text, fields.id, fields.kind, fields.status, fields.owner, fields.nextAction].filter(Boolean).join(" ")
+					: entry.text,
 		};
 	});
 	for (const document of documents) {
@@ -40,5 +50,20 @@ export function metadataEntries(entries: readonly Entry[], documents: readonly M
 			});
 		}
 	}
-	return enriched;
+	return enriched.map((entry) => {
+		const document = sources.get(entry.file);
+		const fields = document?.parsed.fields;
+		return {
+			...entry,
+			id: fields?.id,
+			inactive: document ? closedItem(document) || deferredItem(document) : false,
+			itemKind: fields?.kind,
+			record:
+				entry.file === "fleet/status.md"
+				|| entry.file.startsWith("responses/fleet-report.")
+				|| records.has(entry.file)
+				|| Boolean(fields?.question || fields?.response || fields?.requestReceipt),
+			status: fields?.status,
+		};
+	});
 }

package/src/server/search/snippet.ts

@@ -0,0 +1,9 @@
+export function searchSnippet(text: string, term: string): string {
+	const source = text.trim();
+	if (/^(?:\{|---)/u.test(source) || /(?:^|[\s{,])(?:(?:"[^"\n]+"|'[^'\n]+')\s*:|[a-zA-Z_][\w.-]*\s*:(?:\s|["[{\d]))/u.test(source)) {
+		return "";
+	}
+	const at = Math.max(0, source.toLowerCase().indexOf(term));
+	const start = Math.max(0, at - 50);
+	return (start ? "…" : "") + source.slice(start, start + 180) + (source.length > start + 180 ? "…" : "");
+}

package/src/server/search/updateEntries.ts

@@ -1,3 +1,4 @@
+import { fleetRecords } from "#server/attention/inbox.ts";
 import type { MetadataModel } from "#server/metadata/model.ts";
 import type { Entry } from "./entries.ts";
 import { metadataEntries } from "./metadataEntries.ts";
@@ -5,9 +6,11 @@ import type { IndexedDocument } from "./readDocument.ts";
 
 export function updateEntries() {
 	let previous: MetadataModel | undefined;
+	let grouped: ReadonlySet<string> = new Set();
 	let sources = new Map<string, IndexedDocument>();
 	let enriched = new Map<string, readonly Entry[]>();
 	return (records: ReadonlyMap<string, IndexedDocument>, model: MetadataModel): readonly Entry[] => {
+		const recordsNow = fleetRecords(model);
 		const next = new Map<string, readonly Entry[]>();
 		for (const [file, record] of records) {
 			const id = record.document.parsed.fields.id;
@@ -18,12 +21,13 @@ export function updateEntries() {
 			const hit = enriched.get(file);
 			next.set(
 				file,
-				hit && sources.get(file) === record && unique === wasUnique && complete === wasComplete
+				hit && sources.get(file) === record && unique === wasUnique && complete === wasComplete && recordsNow.has(file) === grouped.has(file)
 					? hit
-					: metadataEntries(record.entries, [record.document], model),
+					: metadataEntries(record.entries, [record.document], model, recordsNow),
 			);
 		}
 		previous = model;
+		grouped = recordsNow;
 		sources = new Map(records);
 		enriched = next;
 		return [

package/src/server/serve-cli.ts

@@ -1,12 +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 { VERSION } from "#server/packageInfo.ts";
 import { HOST, serveBoard } from "./serve.ts";
 
-const VERSION = "0.12.0";
-
 const serve = Effect.fn("WorkBoard.serve")(function* (input: {
 	readonly dir: string;
 	readonly fleetPort: number;
@@ -31,15 +30,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,15 @@
-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 { Context, Deferred, Effect, Layer, Path } from "effect";
+import { HttpServer } from "effect/http";
+import * as NetAddress from "effect/net/NetAddress";
+import { appHost } from "@shivaedev/platform/appHost.ts";
+import { workRpcs } from "#rpc/contract.ts";
+import type { Server } from "#rpc/Server.ts";
+import { boardRuntime } from "#server/boardRuntime.ts";
+import { boardRoutes } from "#server/http/boardRoutes.ts";
+import { MAX_BYTES, RPC_PATH, rpcPolicy } from "#server/http/rpcPolicy.ts";
+import { Highlighter } from "#server/render/Highlighter.ts";
+import type { BoardOptions } from "./board.ts";
+import { boardSocket } from "./boardSocket.ts";
 
 export const HOST = "127.0.0.1";
 
@@ -10,10 +17,31 @@ 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 directory = (yield* Path.Path).resolve(options.root);
+			const info = yield* Deferred.make<typeof Server.Type>();
+			const runtime = yield* boardRuntime(options, Deferred.await(info));
+			const handlers = Layer.succeedContext(yield* Layer.build(runtime.rpcHandlers));
+			yield* boardSocket(directory, handlers);
+			const host = yield* Layer.build(
+				appHost({
+					config: { disablePreemptiveShutdown: true, host: HOST, maxBodySize: 4 * MAX_BYTES + 4096, port: options.port },
+					group: workRpcs,
+					handlers,
+					policy: "loopback",
+					routes: Layer.merge(boardRoutes(options, runtime), rpcPolicy),
+					rpcPath: RPC_PATH,
+					services: Layer.empty,
+				}),
+			);
+			const { address } = Context.get(host, HttpServer.HttpServer);
+			if (!NetAddress.isInetAddress(address)) {
+				return yield* Effect.die(new Error("The board browser server did not listen on TCP."));
+			}
+			yield* Deferred.succeed(info, { directory, url: `http://${HOST}:${address.port}/` });
+			return Layer.succeedContext(host);
+		}),
+	).pipe(Layer.provide(Highlighter.layer));
 }

package/src/server/views/fleetApproval.ts

@@ -0,0 +1,12 @@
+import { parseDocument } from "yaml";
+import type { ParsedMetadata } from "#integration/metadata.ts";
+
+export function fleetApproval(parsed: ParsedMetadata): boolean {
+	if (!(parsed.raw && parsed.lines.fleet !== undefined)) {
+		return false;
+	}
+	const lines = parsed.raw.split(/\r?\n/u);
+	const closing = lines.findLastIndex((line) => line.trimEnd() === "---");
+	const document = parseDocument(lines.slice(1, closing).join("\n"));
+	return document.errors.length === 0 && document.warnings.length === 0 && document.get("fleet") === "approved";
+}

package/src/server/views/fleetItems.ts

@@ -0,0 +1,28 @@
+import { Effect } from "effect";
+import type { FleetItemsProjection } from "#browser/views/FleetItemsProjection.ts";
+import { DAEMON_PORT } from "#diagnostics/daemonContract.ts";
+import { daemonUnavailableReason, readDaemon } from "#server/diagnostics/daemon.ts";
+import type { HandlerOptions } from "#server/rpc/HandlerOptions.ts";
+import { itemsOf } from "#server/views/items.ts";
+
+export function fleetItems({ index, fleetPort = DAEMON_PORT }: Pick<HandlerOptions, "index" | "fleetPort">): Effect.Effect<FleetItemsProjection> {
+	if (fleetPort === null) {
+		return Effect.succeed({ reason: "Fleet daemon is not configured for this Board", state: "unavailable" });
+	}
+	return Effect.gen(function* () {
+		const result = yield* readDaemon(fleetPort, (client) => client("daemon.fleetItems", {})).pipe(Effect.result);
+		if (result._tag === "Failure") {
+			return { reason: daemonUnavailableReason(result.failure, fleetPort), state: "unavailable" as const };
+		}
+		const data = result.success;
+		const snapshot = yield* index;
+		const documents = new Map(
+			itemsOf(snapshot).map(({ id, document, title }) => [id, { file: document.file, metadata: document.parsed.fields, title }]),
+		);
+		return {
+			completed: data.completed.map((item) => ({ ...item, document: documents.get(item.workId) ?? null })),
+			items: data.items.map((item) => ({ ...item, document: documents.get(item.workId) ?? null })),
+			state: "ready" as const,
+		};
+	}).pipe(Effect.catchCause(() => Effect.succeed({ reason: "Board documents could not be read for Fleet items", state: "unavailable" as const })));
+}

package/src/server/views/goals.ts

@@ -0,0 +1,63 @@
+import type { FleetItemsProjection } from "#browser/views/FleetItemsProjection.ts";
+import type { GoalsProjection } from "#browser/views/GoalsProjection.ts";
+import { goalWorkGroup } from "#browser/views/goalWorkState.ts";
+import { inboxItems, openItem } from "#server/attention/inbox.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+import { type Item, itemsOf } from "./items.ts";
+
+function countsOf(items: readonly Item[], fleet: FleetItemsProjection | undefined) {
+	const counts = { done: 0, "in progress": 0, planned: 0 };
+	const runs = fleet?.state === "ready" ? [...fleet.items, ...fleet.completed] : [];
+	for (const item of items) {
+		const group = goalWorkGroup(item.document.parsed.fields.status, runs.find((run) => run.workId === item.id)?.stage);
+		const status = { Deferred: "planned", Done: "done", "In progress": "in progress", Planned: "planned" } as const;
+		counts[status[group]] += 1;
+	}
+	return counts;
+}
+
+export function goals(snapshot: Snapshot, fleet?: FleetItemsProjection): GoalsProjection {
+	const items = itemsOf(snapshot);
+	const claims = snapshot.documents.flatMap((document) => document.parsed.fields.evidence ?? []);
+	const asks = inboxItems(snapshot);
+	const projects = items.filter((item) => item.document.parsed.fields.kind === "project").sort((a, b) => a.id.localeCompare(b.id));
+	function toGoal({ id, title, document }: Item) {
+		const fields = document.parsed.fields;
+		const linked = items.filter((item) =>
+			item.document.parsed.fields.relationships?.some(
+				(link) => link.kind === "implements" && (link.target === id || link.target.startsWith(`${id}#`)),
+			),
+		);
+		const unblocks = new Set([id, ...linked.map((item) => item.id)]);
+		return {
+			counts: countsOf(linked, fleet),
+			criteria: (fields.criteria ?? []).map((criterion) => {
+				const target = `${id}#${criterion.id}`;
+				const work = linked.filter((item) =>
+					item.document.parsed.fields.relationships?.some((link) => link.kind === "implements" && link.target === target),
+				);
+				return {
+					...criterion,
+					counts: countsOf(work, fleet),
+					evidence: claims.filter((claim) => claim.criterion === target).length,
+					linked: work.length,
+				};
+			}),
+			id,
+			linked: linked.length,
+			nextAction: fields.nextAction,
+			openAsks: asks.filter((ask) => ask.unblocks.some((target) => unblocks.has(target.split("#")[0] ?? ""))).length,
+			owner: fields.owner,
+			status: fields.status,
+			title,
+			unlinked: linked.length === 0,
+		};
+	}
+	return {
+		closedGoals: projects.filter((item) => !openItem(item.document)).map(toGoal),
+		goals: projects.filter((item) => openItem(item.document)).map(toGoal),
+		items: items
+			.filter((item) => item.document.parsed.fields.relationships?.some((link) => link.kind === "implements"))
+			.map(({ document, id, title }) => ({ file: document.file, id, metadata: document.parsed.fields, title })),
+	};
+}

package/src/server/views/projection.ts

@@ -1,3 +1,4 @@
+import { isWork } from "#browser/views/now.ts";
 import type { Snapshot } from "#server/search/snapshot.ts";
 import { filterItems, type Item, itemsOf } from "./items.ts";
 import type { State } from "./state.ts";
@@ -35,7 +36,7 @@ export function projectItems(snapshot: Snapshot, state: State): Projection {
 	const boards = known.filter((item) => item.document.parsed.fields.kind === "board");
 	const board = boards.find((item) => item.id === state.board);
 	const membership = board ? boardItems(board, known, snapshot) : undefined;
-	const items = membership?.found ?? known.filter((item) => item.document.parsed.fields.kind !== "board");
+	const items = (membership?.found ?? known).filter((item) => isWork(item.document.parsed.fields));
 	const rows = filterItems(items, state);
 	const selected = known.find((item) => item.id === state.item);
 	const issues =
@@ -53,7 +54,7 @@ export function projectItems(snapshot: Snapshot, state: State): Projection {
 		rows,
 		selected,
 		selectedOutside: selected !== undefined && !rows.some((item) => item.id === selected.id),
-		title: board?.title ?? "All work",
+		title: board?.title ?? (state.view === "now" ? "Now" : "All work"),
 		validBoard: !state.board || board !== undefined,
 	};
 }

package/src/server/views/projectionQueries.ts

@@ -0,0 +1,60 @@
+import { Effect } from "effect";
+import { NotFound } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { BoardProjection, WorkProjection } from "#browser/views/schema.ts";
+import { stateOf } from "#browser/views/state.ts";
+import { inboxItems } from "#server/attention/inbox.ts";
+import { attentionProjection } from "#server/attention/projection.ts";
+import { identityUrl } 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 { fleetApproval } from "./fleetApproval.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, attentionProjection),
+		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,
+						fleetApproved: fleetApproval(source.parsed),
+						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 selectionProblem(snapshot: Snapshot, item: string) {
+	return (snapshot.model.ids.get(item)?.length ?? 0) > 1 ? "has a duplicate ID" : "is missing or its identity changed";
+}

package/src/server/views/remainingQueries.ts

@@ -0,0 +1,74 @@
+import { Clock, Effect } from "effect";
+import { Conflict, NotFound } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { Diagnostics } from "#diagnostics/source.ts";
+import type { HandoffsService } from "#server/handoffs/Service.ts";
+import { identityUrl } from "#server/metadata/links.ts";
+import { metadataParse } from "#server/metadata/parse.ts";
+import { startTemplates } from "#server/page/startTemplates.ts";
+import type { Responses } from "#server/responses/service.ts";
+import type { HandlerOptions } from "#server/rpc/HandlerOptions.ts";
+import { resultProjection } from "./resultProjection.ts";
+export function remainingQueries(
+	{ changes, document, index, writable }: HandlerOptions,
+	services: {
+		readonly diagnostics: typeof Diagnostics.Service;
+		readonly responses: typeof Responses.Service;
+		readonly handoffs: typeof HandoffsService.Service;
+	},
+) {
+	function read(url: string) {
+		return document ? document(url) : Effect.fail(new NotFound({ message: "The document is missing." }));
+	}
+	return {
+		diagnostics: () =>
+			Effect.gen(function* () {
+				return { now: yield* Clock.currentTimeMillis, sources: yield* services.diagnostics.read() };
+			}),
+		handoff: (url: string) =>
+			Effect.gen(function* () {
+				const item = new URL(url, "http://127.0.0.1").searchParams.get("item") ?? "";
+				const service = services.handoffs;
+				const result = yield* Effect.result(service.locate(item));
+				const source = result._tag === "Success" ? result.success : undefined;
+				const parsed = metadataParse(source?.context ?? "");
+				return {
+					background: parsed.body,
+					goal: /^#\s+(?<title>.+)$/mu.exec(parsed.body)?.groups?.title ?? item,
+					item,
+					nextAction: parsed.fields.nextAction ?? "",
+					reading: yield* service.read(item),
+					source,
+					unavailable: result._tag === "Failure" ? String(result.failure) : undefined,
+					writable: writable === true,
+				};
+			}),
+		respond: (url: string) =>
+			Effect.gen(function* () {
+				const params = new URL(url, "http://127.0.0.1").searchParams;
+				const service = services.responses;
+				const preview = yield* service.locate(params.get("item") ?? "", params.get("request") ?? "");
+				yield* service.read(preview.id).pipe(Effect.catch((error) => (error._tag === "NotFound" ? Effect.void : Effect.fail(error))));
+				const responses = yield* service.history(preview);
+				const data = yield* read(identityUrl(preview.item));
+				const request = data.requests.find((entry) => entry.id === preview.request);
+				if (!request) {
+					return yield* Effect.fail(new Conflict({ message: "The response request is unavailable." }));
+				}
+				return { document: data, request: { ...request, preview, responses } };
+			}),
+		result: (url: string) =>
+			Effect.gen(function* () {
+				const item = new URL(url, "http://127.0.0.1").searchParams.get("item") ?? "";
+				const data = yield* index;
+				const matches = data.model.ids.get(item);
+				const result = matches?.length === 1 ? matches[0] : undefined;
+				if (result?.parsed.fields.kind !== "result" || data.unavailable.length > 0) {
+					return yield* Effect.fail(
+						new Conflict({ message: "Choose one uniquely identified, readable result. Missing or ambiguous work is not accepted." }),
+					);
+				}
+				return yield* resultProjection(result, data, yield* read(identityUrl(item)));
+			}),
+		start: () => Effect.map(changes.files, (files) => ({ empty: files.length === 0, templates: startTemplates })),
+	};
+}

package/src/server/views/resultProjection.ts

@@ -0,0 +1,45 @@
+import { Effect } from "effect";
+import type { Document } from "#browser/document/schema.ts";
+import type { ResultProjection } from "#browser/views/ResultProjection.ts";
+import type { MetadataDocument } from "#server/metadata/model.ts";
+import { readResponses } from "#server/responses/read.ts";
+import { malformedResponse, questionFrom, revisionOf } from "#server/responses/records.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+import { resultTargets } from "./resultTargets.ts";
+export const resultProjection = Effect.fn("WorkBoard.resultProjection")(function* (
+	result: MetadataDocument,
+	data: Snapshot,
+	document: Document,
+): Effect.fn.Return<ResultProjection> {
+	const revision = revisionOf((result.parsed.raw ?? "") + result.parsed.body);
+	const criteria = resultTargets(result, data, document);
+	const questions = data.documents.flatMap((entry) => {
+		const question = questionFrom(entry);
+		return question && question.question.item === result.parsed.fields.id ? [question] : [];
+	});
+	const read = readResponses(Effect.succeed(data));
+	const readings = yield* Effect.forEach(questions, (question) => Effect.result(read(question.id)));
+	const feedbackUnknown =
+		data.unavailable.length > 0
+		|| data.documents.some((entry) => malformedResponse(entry) || (entry.parsed.fields.kind === "question" && !questionFrom(entry)))
+		|| readings.some((entry) => entry._tag === "Failure");
+	function file(id: string) {
+		return data.model.ids.get(id)?.[0]?.file ?? `responses/${id}.md`;
+	}
+	const feedback = feedbackUnknown
+		? []
+		: readings.flatMap((entry) =>
+				entry._tag === "Success"
+					? entry.success.responses.map((response) => ({
+							matching: entry.success.question.question.reviewedRevision === revision && entry.success.question.question.source === result.file,
+							question: entry.success.question,
+							questionFile: file(entry.success.question.id),
+							response,
+							responseFile: file(response.id),
+							supersedesFile: response.response.supersedes ? file(response.response.supersedes) : undefined,
+						}))
+					: [],
+			);
+	feedback.sort((a, b) => b.response.response.recordedAt - a.response.response.recordedAt || a.response.id.localeCompare(b.response.id));
+	return { document, feedback, feedbackUnknown, revision, targets: criteria };
+});

package/src/server/views/resultTargets.ts

@@ -0,0 +1,34 @@
+import type { Document } from "#browser/document/schema.ts";
+import type { ResultProjection } from "#browser/views/ResultProjection.ts";
+import { referenceTarget } from "#server/metadata/links.ts";
+import type { MetadataDocument } from "#server/metadata/model.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+export function resultTargets(result: MetadataDocument, data: Snapshot, document: Document): ResultProjection["targets"] {
+	const targets = new Set(result.parsed.fields.relationships?.map((entry) => entry.target));
+	if (result.parsed.fields.id) {
+		targets.add(result.parsed.fields.id);
+	}
+	function link(label: string, target: string) {
+		return { href: referenceTarget(target, data.model), label };
+	}
+	function criterionRow(id: string, entry: { readonly id: string; readonly text: string }) {
+		const reference = `${id}#${entry.id}`;
+		const claims = referenceTarget(reference, data.model)
+			? (result.parsed.fields.evidence ?? []).flatMap((claim, index) => {
+					if (claim.criterion !== reference) {
+						return [];
+					}
+					const resolved = document.reading?.evidenceSources[index];
+					return [{ ...claim, problem: resolved?.problem ?? "", source: { href: resolved?.href, label: claim.source } }];
+				})
+			: [];
+		return { claims, link: link(entry.text, reference), text: entry.text };
+	}
+	return [...targets].map((target) => {
+		const [id = "", criterion] = target.split("#");
+		const source = data.model.ids.get(id)?.[0];
+		const available = Boolean(source && referenceTarget(target, data.model));
+		const entries = available ? (source?.parsed.fields.criteria ?? []).filter((entry) => !criterion || entry.id === criterion) : [];
+		return { available, criteria: entries.map((entry) => criterionRow(id, entry)), link: link(target, target), status: source?.parsed.fields.status };
+	});
+}

package/src/server/views/state.ts

@@ -1,47 +1,12 @@
-import { Option, Schema } from "effect";
-
-const View = Schema.Literals(["board", "table"]);
-const Sort = Schema.Literals(["title", "owner", "status"]);
-export const State = Schema.Struct({
-	board: Schema.String,
-	item: Schema.String,
-	owner: Schema.String,
-	query: Schema.String,
-	sort: Sort,
-	status: Schema.String,
-	view: View,
-});
+import { fieldFilter as filter, stateOf as readState, viewUrl as urlOf, State as ViewState } from "#browser/views/state.ts";
+export const State = ViewState;
 export type State = typeof State.Type;
-
 export function stateOf(url: string): State {
-	const params = new URL(url, "http://127.0.0.1").searchParams;
-	return {
-		board: params.get("board") ?? "",
-		item: params.get("item") ?? "",
-		owner: params.get("owner") ?? "",
-		query: (params.get("q") ?? "").slice(0, 200),
-		sort: Option.getOrElse(Schema.decodeUnknownOption(Sort)(params.get("sort")), () => "title"),
-		status: params.get("status") ?? "",
-		view: Option.getOrElse(Schema.decodeUnknownOption(View)(params.get("view")), () => "board"),
-	};
+	return readState(url);
 }
 export function viewUrl(state: State, changes: Partial<State> = {}, hash = ""): string {
-	const next = { ...state, ...changes };
-	const params = new URLSearchParams({ view: next.view });
-	for (const [key, value] of Object.entries({
-		board: next.board,
-		item: next.item,
-		owner: next.owner,
-		q: next.query,
-		sort: next.sort,
-		status: next.status,
-	})) {
-		if (value) {
-			params.set(key, value);
-		}
-	}
-	return `/_board/work?${params}${hash ? `#${hash}` : ""}`;
+	return urlOf(state, changes, hash);
 }
 export function fieldFilter(value: string | undefined): string {
-	return value === undefined ? "missing" : `value:${value}`;
+	return filter(value);
 }

package/dist/browser/navigation/html.d.ts

@@ -1,3 +0,0 @@
-import type { Navigation } from "./schema.ts";
-export declare function navigationHtml(data: Navigation): string;
-//# sourceMappingURL=html.d.ts.map

package/dist/browser/navigation/html.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"html.d.ts","sourceRoot":"","sources":["../../../src/browser/navigation/html.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAoC,MAAM,aAAa,CAAC;AAmBhF,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAQvD"}

package/dist/browser/navigation/html.js

@@ -1,25 +0,0 @@
-import { escapeHtml } from "#browser/escapeHtml.ts";
-function link(file) {
-    const here = file.current ? ' aria-current="page"' : "";
-    const age = `<span class="age short" data-modified="${file.modified}"></span>`;
-    return `<a href="${file.href}"${here}>${escapeHtml(file.name)}</a>${age}`;
-}
-function contents(folder, count) {
-    const files = folder.files.map((file) => `<li>${link(file)}</li>`).join("");
-    const folders = folder.folders
-        .map((child) => {
-        const open = child.active ? " open" : "";
-        return `<li class="file-folder"><details data-key="folder:${escapeHtml(child.path)}"${open}><summary>${escapeHtml(child.name)}/ (${child.count})</summary>${contents(child)}</details></li>`;
-    })
-        .join("");
-    return `<ul${count === undefined ? "" : ` data-inbox-count="${count}"`}>${files}${folders}</ul>`;
-}
-export function navigationHtml(data) {
-    const records = data.records;
-    const open = records.active ? " open" : "";
-    const fleet = records.count === 0
-        ? ""
-        : `<details data-key="fleet-records"${open}><summary>Fleet records (${records.count})</summary><ul>${records.files.map((file) => `<li>${link(file)}</li>`).join("")}</ul></details>`;
-    return contents(data.tree, String(data.inboxCount ?? "?")) + fleet;
-}
-//# sourceMappingURL=html.js.map

package/dist/browser/navigation/html.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"html.js","sourceRoot":"","sources":["../../../src/browser/navigation/html.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGpD,SAAS,IAAI,CAAC,IAAoB;IACjC,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,EAAE,CAAC;IACxD,MAAM,GAAG,GAAG,0CAA0C,IAAI,CAAC,QAAQ,WAAW,CAAC;IAC/E,OAAO,YAAY,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;AAC3E,CAAC;AAED,SAAS,QAAQ,CAAC,MAAwB,EAAE,KAAc;IACzD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;IAC5E,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO;SAC5B,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE;QACd,MAAM,IAAI,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;QACzC,OAAO,qDAAqD,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,aAAa,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC,KAAK,cAAc,QAAQ,CAAC,KAAK,CAAC,iBAAiB,CAAC;IAC9L,CAAC,CAAC;SACD,IAAI,CAAC,EAAE,CAAC,CAAC;IACX,OAAO,MAAM,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,sBAAsB,KAAK,GAAG,IAAI,KAAK,GAAG,OAAO,OAAO,CAAC;AAClG,CAAC;AAED,MAAM,UAAU,cAAc,CAAC,IAAgB;IAC9C,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC;IAC7B,MAAM,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC;IAC3C,MAAM,KAAK,GACV,OAAO,CAAC,KAAK,KAAK,CAAC;QAClB,CAAC,CAAC,EAAE;QACJ,CAAC,CAAC,oCAAoC,IAAI,4BAA4B,OAAO,CAAC,KAAK,kBAAkB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC;IACvL,OAAO,QAAQ,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,UAAU,IAAI,GAAG,CAAC,CAAC,GAAG,KAAK,CAAC;AACpE,CAAC"}