@shivaedev/work-board 0.11.0 → 0.12.0

package/src/http/page.ts

@@ -1,95 +0,0 @@
-import { Effect, FileSystem, Option } from "effect";
-import type { HttpServerRequest } from "effect/unstable/http";
-import type { Changes } from "#files/changes.ts";
-import type { MarkdownFile } from "#files/list.ts";
-import { markdownPath } from "#files/markdownPath.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 { startHtml } from "#page/startHtml.ts";
-import { boardOf } from "#render/board.ts";
-import type { searchSnapshot } from "#search/snapshot.ts";
-import { respond } from "./respond.ts";
-
-export interface PageOptions {
-	readonly home: string | undefined;
-	readonly root: string;
-}
-
-const requestedPath = (url: string): string => {
-	const pathname = new URL(url, "http://127.0.0.1").pathname.replace(/^\/+/u, "");
-	try {
-		return decodeURIComponent(pathname);
-	} catch {
-		return pathname;
-	}
-};
-
-const message = (text: string): string => `<p class="empty">${escapeHtml(text)}</p>`;
-
-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 real = yield* markdownPath(options.root, changes.realRoot, file.path);
-		if (real === undefined) {
-			return Option.none();
-		}
-		const source = yield* fs.readFileString(real);
-		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, resolved?: string, expectedIdentity?: string) {
-		const files = yield* changes.files;
-		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);
-		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 (files.length === 0 && requestedPath(request.url) === "" && resolved === undefined && expectedIdentity === undefined) {
-			return respond(layout(startHtml(true)), "text/html");
-		}
-		if (file === undefined) {
-			return missing();
-		}
-		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/respond.ts

@@ -1,20 +0,0 @@
-import { HttpServerResponse } from "effect/unstable/http";
-
-const POLICY = [
-	"default-src 'self'",
-	"script-src 'self'",
-	"style-src 'self' 'unsafe-inline'",
-	"img-src 'self' data: https:",
-	"object-src 'none'",
-	"form-action 'none'",
-	"frame-src 'none'",
-	"base-uri 'none'",
-	"frame-ancestors 'none'",
-].join("; ");
-
-export const HEADERS = { "cache-control": "no-store", "content-security-policy": POLICY, "x-content-type-options": "nosniff" };
-
-export const respond = (body: string | Uint8Array, contentType: string, status = 200): HttpServerResponse.HttpServerResponse =>
-	typeof body === "string"
-		? HttpServerResponse.text(body, { contentType: `${contentType}; charset=utf-8`, headers: HEADERS, status })
-		: HttpServerResponse.uint8Array(body, { contentType, headers: HEADERS, status });

package/src/http/sameOrigin.ts

@@ -1,14 +0,0 @@
-import type { HttpServerRequest } from "effect/unstable/http";
-
-export function sameOrigin(request: HttpServerRequest.HttpServerRequest): boolean {
-	const origin = request.headers.origin;
-	if (origin === undefined) {
-		return true;
-	}
-	try {
-		const url = new URL(origin);
-		return url.protocol === "http:" && url.host === request.headers.host;
-	} catch {
-		return false;
-	}
-}

package/src/http/search.ts

@@ -1,13 +0,0 @@
-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/start.ts

@@ -1,16 +0,0 @@
-import { Effect } from "effect";
-import type { Changes } from "#files/changes.ts";
-import { navHtml } from "#page/nav.ts";
-import { shell } from "#page/shell.ts";
-import { startHtml } from "#page/startHtml.ts";
-import { respond } from "./respond.ts";
-
-export function start(changes: Changes, home: string | undefined) {
-	return Effect.fn("WorkBoard.start")(function* () {
-		const files = yield* changes.files;
-		return respond(
-			shell("Getting started", navHtml(files, "", home), startHtml(files.length === 0), changes.realRoot, false, undefined, "start"),
-			"text/html",
-		);
-	});
-}

package/src/http/work.ts

@@ -1,41 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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.handoff ? [{ kind: "agent handoff", line: lines.handoff, target: referenceFile(fields.handoff.item, model) }] : []),
-		...(fields.question ? [{ kind: "reviewed question", line: lines.question, target: referenceFile(fields.question.item, model) }] : []),
-		...(fields.response ? [{ kind: "recorded response", line: lines.response, target: referenceFile(fields.response.question, model) }] : []),
-		...(fields.response?.supersedes
-			? [{ kind: "superseding response", line: lines.response, target: referenceFile(fields.response.supersedes, model) }]
-			: []),
-		...(fields.attention?.flatMap((request, index) =>
-			request.unblocks.map((target, targetIndex) => ({
-				kind: "attention target",
-				line: lines[`attention.${index}.unblocks.${targetIndex}`],
-				target: referenceFile(target, model),
-			})),
-		) ?? []),
-		...(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

@@ -1,26 +0,0 @@
-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) };
-}

package/src/metadata/model.ts

@@ -1,27 +0,0 @@
-import type { Diagnostic, ParsedMetadata } from "./parse.ts";
-import { metadataProblems } from "./problems.ts";
-
-export interface MetadataDocument {
-	readonly file: string;
-	readonly links?: readonly string[];
-	readonly parsed: ParsedMetadata;
-}
-export interface MetadataModel {
-	readonly diagnostics: ReadonlyMap<string, readonly Diagnostic[]>;
-	readonly documents: readonly MetadataDocument[];
-	readonly ids: ReadonlyMap<string, readonly MetadataDocument[]>;
-	readonly rootFile: string | undefined;
-	readonly unavailable: readonly string[];
-}
-
-export function metadataModel(documents: readonly MetadataDocument[], unavailable: readonly string[] = [], rootFile?: string): MetadataModel {
-	const ids = new Map<string, MetadataDocument[]>();
-	for (const document of documents) {
-		const id = document.parsed.fields.id;
-		if (id) {
-			ids.set(id, [...(ids.get(id) ?? []), document]);
-		}
-	}
-	const diagnostics = new Map(documents.map((document) => [document.file, metadataProblems(document, ids, unavailable)]));
-	return { diagnostics, documents, ids, rootFile, unavailable };
-}

package/src/metadata/parse.ts

@@ -1,62 +0,0 @@
-import { LineCounter, parseDocument } from "yaml";
-import { metadataFields } from "./fields.ts";
-import { metadataLocations } from "./locations.ts";
-import type { Metadata } from "./schema.ts";
-
-export interface Diagnostic {
-	readonly field?: string;
-	readonly line: number;
-	readonly message: string;
-}
-export interface ParsedMetadata {
-	readonly body: string;
-	readonly bodyLine: number;
-	readonly diagnostics: readonly Diagnostic[];
-	readonly fields: Metadata;
-	readonly lines: Readonly<Record<string, number>>;
-	readonly raw?: string;
-}
-
-export function metadataParse(source: string): ParsedMetadata {
-	const plain: ParsedMetadata = { body: source, bodyLine: 1, diagnostics: [], fields: {}, lines: {} };
-	const opening = /^\uFEFF?---[ \t]*\r?\n/u.exec(source);
-	if (!opening) {
-		return plain;
-	}
-	const remainder = source.slice(opening[0].length);
-	const closing = /^---[ \t]*\r?$/mu.exec(remainder);
-	if (!closing) {
-		return { ...plain, diagnostics: [{ line: 1, message: "Unterminated frontmatter; the original Markdown is shown." }] };
-	}
-	let end = opening[0].length + closing.index + closing[0].length;
-	if (source[end] === "\n") {
-		end += 1;
-	}
-	const raw = source.slice(0, end);
-	const body = source.slice(end);
-	const bodyLine = raw.split("\n").length;
-	const counter = new LineCounter();
-	const doc = parseDocument(remainder.slice(0, closing.index), { lineCounter: counter });
-	const lines = metadataLocations(doc.contents, counter);
-	const diagnostics: Diagnostic[] = [...doc.errors, ...doc.warnings].map((error) => ({
-		line: (error.linePos?.[0].line ?? 1) + 1,
-		message: error.message,
-	}));
-	const result = { body, bodyLine, diagnostics, fields: {}, lines, raw };
-	if (doc.errors.length > 0 || doc.warnings.length > 0) {
-		return result;
-	}
-	let data: unknown;
-	try {
-		data = doc.toJS({ maxAliasCount: 50 });
-	} catch {
-		return { ...result, diagnostics: [...diagnostics, { line: 2, message: "Frontmatter aliases could not be expanded safely." }] };
-	}
-	if (data === null) {
-		return result;
-	}
-	if (typeof data !== "object" || Array.isArray(data)) {
-		return { ...plain, diagnostics: [{ line: 2, message: "Frontmatter must be a mapping; the original Markdown is shown." }] };
-	}
-	return { ...result, ...metadataFields(data, lines) };
-}

package/src/metadata/problems.ts

@@ -1,70 +0,0 @@
-import { attentionProblems } from "./attentionProblems.ts";
-import type { MetadataDocument } from "./model.ts";
-import type { Diagnostic } from "./parse.ts";
-
-function referenceProblem(target: string, ids: ReadonlyMap<string, readonly MetadataDocument[]>): string | undefined {
-	const [id = "", criterion] = target.split("#");
-	const matches = ids.get(id);
-	if (!matches?.length) {
-		return `Unresolved reference ${target}.`;
-	}
-	if (matches.length > 1) {
-		return `Ambiguous reference ${target}; the ID is duplicated.`;
-	}
-	if (criterion && matches[0]?.parsed.fields.criteria?.filter((item) => item.id === criterion).length !== 1) {
-		return `Unresolved or duplicated criterion ${target}.`;
-	}
-	return undefined;
-}
-function criterionProblems(document: MetadataDocument): readonly Diagnostic[] {
-	const criteria = document.parsed.fields.criteria ?? [];
-	return criteria.flatMap((criterion, index) =>
-		criteria.filter((item) => item.id === criterion.id).length > 1
-			? [{ field: "criteria", line: document.parsed.lines[`criteria.${index}`] ?? 2, message: `Duplicate criterion ID ${criterion.id}.` }]
-			: [],
-	);
-}
-function referenceProblems(document: MetadataDocument, ids: ReadonlyMap<string, readonly MetadataDocument[]>): readonly Diagnostic[] {
-	const { fields, lines } = document.parsed;
-	const references = [
-		...(fields.handoff ? [{ field: "handoff", key: "handoff.item", target: fields.handoff.item }] : []),
-		...(fields.question ? [{ field: "question", key: "question.item", target: fields.question.item }] : []),
-		...(fields.response ? [{ field: "response", key: "response.question", target: fields.response.question }] : []),
-		...(fields.response?.supersedes ? [{ field: "response", key: "response.supersedes", target: fields.response.supersedes }] : []),
-		...(fields.attention?.flatMap((request, index) =>
-			request.unblocks.map((target, targetIndex) => ({ field: "attention", key: `attention.${index}.unblocks.${targetIndex}`, target })),
-		) ?? []),
-		...(fields.relationships?.map((link, index) => ({ field: "relationships", key: `relationships.${index}.target`, target: link.target })) ?? []),
-		...(fields.items?.map((target, index) => ({ field: "items", key: `items.${index}`, target })) ?? []),
-		...(fields.evidence?.flatMap((item, index) =>
-			item.criterion ? [{ field: "evidence", key: `evidence.${index}.criterion`, target: item.criterion }] : [],
-		) ?? []),
-	];
-	return references.flatMap((reference) => {
-		const message = referenceProblem(reference.target, ids);
-		return message ? [{ field: reference.field, line: lines[reference.key] ?? lines[reference.field] ?? 2, message }] : [];
-	});
-}
-export function metadataProblems(document: MetadataDocument, ids: ReadonlyMap<string, readonly MetadataDocument[]>, unavailable: readonly string[]) {
-	const { parsed } = document;
-	const problems = [...parsed.diagnostics, ...criterionProblems(document), ...attentionProblems(document)];
-	const matches = parsed.fields.id ? ids.get(parsed.fields.id) : undefined;
-	if (matches && matches.length > 1) {
-		problems.push({
-			field: "id",
-			line: parsed.lines.id ?? 2,
-			message: `Duplicate ID ${parsed.fields.id}: ${matches.map((item) => item.file).join(", ")}. No source is selected.`,
-		});
-	}
-	if (unavailable.length > 0) {
-		if (parsed.raw !== undefined) {
-			problems.push({
-				line: 1,
-				message: `Workspace index incomplete; could not read ${unavailable.join(", ")}. Identity and references cannot be validated completely.`,
-			});
-		}
-	} else {
-		problems.push(...referenceProblems(document, ids));
-	}
-	return problems;
-}

package/src/page/attentionDetails.ts

@@ -1,19 +0,0 @@
-import { attentionSource } from "#attention/requests.ts";
-import { identityUrl } from "#metadata/links.ts";
-import type { MetadataModel } from "#metadata/model.ts";
-import type { ParsedMetadata } from "#metadata/parse.ts";
-import { escapeHtml } from "./escape.ts";
-import { referenceHtml } from "./metadataLinks.ts";
-
-export function attentionDetails(parsed: ParsedMetadata, file: string, model: MetadataModel): string {
-	const requests = parsed.fields.attention ?? [];
-	if (requests.length === 0) {
-		return "";
-	}
-	return `<h3>Recorded attention requests</h3><p>Open/closed is source state. Closing a request does not establish acceptance or record an answer.</p><ul>${requests
-		.map(
-			(request, index) =>
-				`<li id="${attentionSource({ file, parsed }, index)}" tabindex="-1"><b>${escapeHtml(request.kind)} · ${escapeHtml(request.id)} · ${escapeHtml(request.state)}</b><p>${escapeHtml(request.reason)}</p><p>Response needed from: ${request.responseFrom.map(escapeHtml).join(", ")}</p><p>Recorded to unblock: ${request.unblocks.map((target) => referenceHtml(target, target, model)).join(", ")}</p><p><a href="/_board/respond?item=${encodeURIComponent(parsed.fields.id ?? "")}&amp;request=${encodeURIComponent(request.id)}">Respond to this request</a> · <a href="${identityUrl(parsed.fields.id ?? "")}">Reviewed item</a></p><p>Source: ${escapeHtml(file)}:${parsed.lines[`attention.${index}`] ?? parsed.lines.attention ?? 2}</p></li>`,
-		)
-		.join("")}</ul>`;
-}

package/src/page/backlinksHtml.ts

@@ -1,18 +0,0 @@
-import { backlinksOf } from "#metadata/backlinks.ts";
-import type { MetadataModel } from "#metadata/model.ts";
-import { relationshipLabel } from "#metadata/relationshipLabel.ts";
-import { escapeHtml } from "./escape.ts";
-import { documentReference } from "./metadataLinks.ts";
-
-export function backlinksHtml(file: string, model: MetadataModel): string {
-	const links = backlinksOf(file, model);
-	if (links.length === 0) {
-		return "";
-	}
-	const entries = [...new Map(links.map((link) => [`${link.file}:${link.kind}:${link.line ?? ""}`, link])).values()];
-	const incomplete =
-		model.unavailable.length > 0
-			? "<p>Available source references only; unreadable files prevent complete backlink and identity validation.</p>"
-			: "";
-	return `<section class="work-context" aria-label="Source backlinks"><details data-key="work-backlinks"><summary>Referenced by (${entries.length})</summary>${incomplete}<ul>${entries.map((link) => `<li>${escapeHtml(relationshipLabel(link.kind))}: <a href="${escapeHtml(documentReference(link.file, model))}">${escapeHtml(link.file)}${link.line === undefined ? "" : `:${link.line}`}</a></li>`).join("")}</ul><p>These are explicit source links, not inferred blockers or workflow rules.</p></details></section>`;
-}

package/src/page/board.ts

@@ -1,47 +0,0 @@
-import { Effect } from "effect";
-import { type Board, countsOf, type Section } from "#render/board.ts";
-import { documentHeadings } from "#render/documentHeadings.ts";
-import { renderMarkdown } from "#render/markdown.ts";
-import { escapeHtml } from "./escape.ts";
-import { readingTools } from "./readingTools.ts";
-import { updated } from "./updated.ts";
-
-const counts = (board: Board): string =>
-	countsOf(board)
-		.map(({ count, title }) => `<span><b>${count}</b> ${escapeHtml(title.toLowerCase())}</span>`)
-		.join(" · ");
-
-type Render = (fragment: string) => ReturnType<typeof renderMarkdown>;
-
-const section = Effect.fn("WorkBoard.section")(function* ({ heading, items, notes }: Section, render: Render) {
-	const title = yield* render(heading);
-	const note = notes === "" ? "" : `<div class="notes">${yield* render(notes)}</div>`;
-	const rendered = yield* Effect.forEach(items, (item) => Effect.map(render(item), (html) => `<article class="item">${html}</article>`));
-	return `<section>${title}${note}${rendered.join("")}</section>`;
-});
-
-export const boardHtml = Effect.fn("WorkBoard.boardHtml")(function* (board: Board, fallbackTitle: string, modified: number, metadata = "") {
-	let fragments = 0;
-	const headings = documentHeadings();
-	const render: Render = (fragment) => {
-		fragments += 1;
-		return renderMarkdown(board.definitions === "" ? fragment : `${fragment}\n\n${board.definitions}`, {
-			file: fallbackTitle,
-			headings,
-			idPrefix: `part-${fragments}-`,
-		});
-	};
-	const title = board.title === "" ? `<h1>${escapeHtml(fallbackTitle)}</h1>` : yield* render(board.title);
-	const intro = board.intro === "" ? "" : `<div class="intro">${yield* render(board.intro)}</div>`;
-	const sections = yield* Effect.forEach(board.sections, (each) => section(each, render));
-	const footer = board.footer === "" ? "" : `<footer>${yield* render(board.footer)}</footer>`;
-	return [
-		readingTools(headings.entries),
-		metadata,
-		`<header class="board-head">${title}${intro}`,
-		`<p class="counts">${counts(board)}</p>`,
-		`<p class="meta">${updated(modified)}</p></header>`,
-		`<div class="board">${sections.join("")}</div>`,
-		footer,
-	].join("");
-});