@shivaedev/work-board 0.13.0 → 0.14.1

package/src/server/attention/overviewHtml.ts

@@ -1,46 +0,0 @@
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { fileUrl } from "#files/url.ts";
-import { referenceHtml } from "#server/page/metadataLinks.ts";
-import type { Snapshot } from "#server/search/snapshot.ts";
-import { inboxItems } from "./inbox.ts";
-import { inboxHtml } from "./inboxHtml.ts";
-import { type AttentionEntry, attentionRequests } from "./requests.ts";
-
-function card(entry: AttentionEntry, snapshot: Snapshot): string {
-	const { request } = entry;
-	return `<article class="attention-card" data-key="attention:${escapeHtml(entry.itemId)}:${escapeHtml(request.id)}" data-attention-item="${escapeHtml(entry.itemId)}" data-request="${escapeHtml(request.id)}">
-<p class="work-kind">${escapeHtml(request.kind)} request</p><h3><a href="${escapeHtml(entry.href)}">${escapeHtml(entry.title)}</a></h3>
-<p class="work-id">${escapeHtml(entry.itemId)} / ${escapeHtml(request.id)}</p><p class="attention-reason">${escapeHtml(request.reason)}</p>
-<dl><dt>Response needed from</dt><dd>${request.responseFrom.map(escapeHtml).join(", ")}</dd><dt>Recorded to unblock</dt><dd>${request.unblocks.map((target) => referenceHtml(target, target, snapshot.model)).join(", ")}</dd></dl>
-<a class="attention-source" href="${escapeHtml(fileUrl(entry.document.file))}#attention-request-${encodeURIComponent(request.id)}">Source: ${escapeHtml(entry.document.file)}:${entry.line}</a></article>`;
-}
-
-export function overviewHtml(snapshot: Snapshot): string {
-	const projection = attentionRequests(snapshot);
-	const header =
-		'<header class="work-head"><p class="work-eyebrow">WORKSPACE · OVERVIEW</p><h1>What needs a response?</h1><p>Choose a recorded request to read its context, reasoning and evidence.</p><a href="/_board/work?view=board">Browse all work</a></header>';
-	const issues =
-		projection.issues.length > 0
-			? `<details class="view-issues" data-key="attention-issues"><summary>Unclassified requests and source issues (${projection.issues.length})</summary><p>Ambiguous or invalid requests stay outside the queues. Read their original sources.</p><ul>${projection.issues.map((issue) => `<li><a href="${escapeHtml(fileUrl(issue.file))}">${escapeHtml(issue.file)}:${issue.line}</a> — ${escapeHtml(issue.message)}</li>`).join("")}</ul></details>`
-			: "";
-	if (!projection.complete) {
-		return `${header}<p class="attention-incomplete" role="status">Workspace incomplete. Could not read ${snapshot.unavailable.map(escapeHtml).join(", ")}. Requests are not counted or classified until the index is complete.</p>${issues}`;
-	}
-	let summary = inboxItems(snapshot).length > 0 ? "No explicit open attention requests recorded." : "All quiet — no explicit open requests recorded.";
-	if (projection.entries.length > 0) {
-		summary = `${projection.entries.length} validated open request${projection.entries.length === 1 ? "" : "s"}`;
-	} else if (projection.issues.length > 0) {
-		summary = "No validated open requests. Check unresolved source issues before treating this workspace as quiet.";
-	}
-	const groups = [
-		{ empty: "No open decision requests.", kind: "decision", title: "Decisions" },
-		{ empty: "No open review requests.", kind: "review", title: "Reviews" },
-		{ empty: "No open blocker requests.", kind: "blocker", title: "Blockers" },
-	]
-		.map((group) => {
-			const entries = projection.entries.filter((entry) => entry.request.kind === group.kind);
-			return `<section class="attention-group" aria-labelledby="attention-${group.kind}"><h2 id="attention-${group.kind}" tabindex="-1">${group.title}<span>${entries.length}</span></h2>${entries.length > 0 ? entries.map((entry) => card(entry, snapshot)).join("") : `<p class="empty">${group.empty}</p>`}</section>`;
-		})
-		.join("");
-	return `${header}${inboxHtml(snapshot, true)}<p class="attention-total" role="status">${summary}</p><p class="attention-order">Decisions, reviews, then blockers. Within each group: source title, item ID, request ID. Recipients are recorded labels.</p>${issues}<div class="attention-groups">${groups}</div><p class="attention-footnote">These are authored requests. Closing one does not verify evidence or record an answer. The Inbox also shows human-owned next actions and questions; file activity and finished runs do not create requests.</p>`;
-}

package/src/server/attention/style.ts

@@ -1,9 +0,0 @@
-export function attentionStyle(): string {
-	return `
-.attention-total{margin:24px 0 8px;font-weight:600}.attention-order,.attention-footnote{font-size:13px;color:var(--muted);margin:0 0 24px;overflow-wrap:anywhere}
-.attention-groups{display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:20px;align-items:start}.attention-group{min-width:0}.attention-group>h2{display:flex;justify-content:space-between;gap:12px;font-size:16px;margin:0 0 16px}.attention-group>h2>span{font:12px var(--mono);color:var(--muted)}
-.attention-card{border:1px solid var(--border);border-radius:10px;padding:var(--card-space);background:var(--card);margin:0 0 16px;overflow-wrap:anywhere}.attention-card h3{font-size:1rem;margin:6px 0}.attention-card h3 a{text-decoration:none}.attention-card dl{font-size:13px;margin:16px 0}.attention-card dt{color:var(--muted);margin-top:12px}.attention-card dd{margin:4px 0}.attention-source{font-size:12px}.attention-reason{font-size:14px;margin:0}.attention-footnote{margin-top:24px}.attention-incomplete{padding:16px;border:1px solid var(--danger);border-radius:8px;margin:24px 0;overflow-wrap:anywhere}
-[id^="attention-request-"],[id^="attention-record-"]{scroll-margin-top:20px}
-@media(max-width:1100px){.attention-groups{grid-template-columns:minmax(0,1fr)}}
-`;
-}

package/src/server/diagnostics/style.ts

@@ -1,19 +0,0 @@
-export function diagnosticsStyle(): string {
-	return `
-.diagnostics { max-width: 1200px; margin: auto; padding: clamp(1rem, 3vw, 2rem); }
-.diagnostics-grid { display: grid; grid-template-columns: repeat(auto-fit, minmax(min(100%, 320px), 1fr)); gap: 1rem; align-items: start; }
-.diagnostics-card { min-width: 0; border: 1px solid var(--border); border-radius: 12px; padding: 1.25rem; background: var(--surface); overflow-wrap: anywhere; }
-.diagnostics-card header { display: flex; align-items: baseline; flex-wrap: wrap; gap: .5rem 1rem; justify-content: space-between; }
-.diagnostics-card h2 { margin: 0; }
-.diagnostics-status { font-size: .85rem; border: 1px solid var(--border); border-radius: 1rem; padding: .2rem .6rem; }
-.diagnostics-card[data-state=attention], .diagnostics-card[data-state=error] { border-color: var(--link); }
-.diagnostics-card[data-state=stale] .diagnostics-metrics strong { opacity: .55; }
-.diagnostics-freshness { font-size: .85rem; color: var(--muted); }
-.diagnostics-windows { list-style: none; padding: 0; }
-.diagnostics-windows li + li, .diagnostics-metrics > div + div { border-top: 1px solid var(--border); padding-top: .75rem; margin-top: .75rem; }
-.diagnostics-windows h3 { margin-bottom: .25rem; }
-.diagnostics-windows meter { width: 100%; height: .75rem; accent-color: var(--link); }
-.diagnostics-metrics dt { color: var(--muted); }
-.diagnostics-metrics dd { margin: .25rem 0 0; }
-`;
-}

package/src/server/history/baseline.ts

@@ -1,43 +0,0 @@
-import { Option, Schema } from "effect";
-import { Baseline } from "#history/schema.ts";
-import type { Snapshot } from "#server/search/snapshot.ts";
-import { MAX_AGE, MAX_BYTES } from "./limits.ts";
-
-const JsonBaseline = Schema.fromJsonString(Baseline);
-function byteLength(text: string): number {
-	return new TextEncoder().encode(text).length;
-}
-
-export function readBaseline(raw: string | null, now: number) {
-	if (raw === null) {
-		return { baseline: undefined, discard: false, reason: "No previous snapshot. Start remembering changes to compare future source observations." };
-	}
-	if (byteLength(raw) > MAX_BYTES) {
-		return { baseline: undefined, discard: true, reason: "Remembered snapshot exceeds 2 MiB; history is unavailable." };
-	}
-	const decoded = Schema.decodeUnknownOption(JsonBaseline, { onExcessProperty: "error" })(raw);
-	if (Option.isNone(decoded)) {
-		return { baseline: undefined, discard: true, reason: "Remembered snapshot is invalid or unsupported; history is unavailable." };
-	}
-	const elapsed = now - Date.parse(decoded.value.recordedAt);
-	if (elapsed < 0) {
-		return { baseline: undefined, discard: true, reason: "Remembered observation is in the future; history is unavailable." };
-	}
-	if (elapsed >= MAX_AGE) {
-		return { baseline: undefined, discard: true, reason: "Remembered snapshot expired after 30 days; start again to establish a new baseline." };
-	}
-	return { baseline: decoded.value, discard: false, reason: "" };
-}
-
-export function observeBaseline(snapshot: Snapshot, now: number): string | undefined {
-	if (snapshot.unavailable.length > 0) {
-		return undefined;
-	}
-	const baseline: Baseline = {
-		documents: snapshot.documents.map((document) => ({ file: document.file, source: (document.parsed.raw ?? "") + document.parsed.body })),
-		recordedAt: new Date(now).toISOString(),
-		version: 1,
-	};
-	const raw = Schema.encodeSync(JsonBaseline)(baseline);
-	return byteLength(raw) <= MAX_BYTES ? raw : undefined;
-}

package/src/server/history/compare.ts

@@ -1,54 +0,0 @@
-import type { Baseline } from "#history/schema.ts";
-import { type HistoryDocument, historyDocuments, historyIdentities } from "./documents.ts";
-import { historyFields } from "./fields.ts";
-
-export interface SourceChange {
-	readonly after?: HistoryDocument;
-	readonly before?: HistoryDocument;
-	readonly kind: "added" | "removed" | "changed";
-	readonly reasons: readonly string[];
-}
-
-export function compareHistory(baseline: Baseline, current: Baseline) {
-	const before = historyDocuments(baseline);
-	const after = historyDocuments(current);
-	const oldIds = historyIdentities(before);
-	const newIds = historyIdentities(after);
-	const paired = new Set<HistoryDocument>();
-	const remaining = new Set(after);
-	const changes: SourceChange[] = [];
-	function pair(old: HistoryDocument, next: HistoryDocument) {
-		paired.add(old);
-		remaining.delete(next);
-		if (old.source !== next.source || old.file !== next.file) {
-			changes.push({ after: next, before: old, kind: "changed", reasons: historyFields(old, next) });
-		}
-	}
-	for (const [id, old] of oldIds) {
-		const next = newIds.get(id);
-		if (old && next) {
-			pair(old, next);
-		}
-	}
-	const byFile = new Map([...remaining].map((document) => [document.file, document]));
-	for (const old of before) {
-		if (paired.has(old)) {
-			continue;
-		}
-		const next = byFile.get(old.file);
-		if (next) {
-			pair(old, next);
-		} else {
-			changes.push({ before: old, kind: "removed", reasons: ["Source absent from the complete current observation"] });
-		}
-	}
-	for (const next of remaining) {
-		changes.push({ after: next, kind: "added", reasons: ["Source added since the remembered observation"] });
-	}
-	const issues = [
-		...[...oldIds].filter(([, document]) => !document).map(([id]) => `Duplicate ID ${id} in remembered sources; no identity winner selected.`),
-		...[...newIds].filter(([, document]) => !document).map(([id]) => `Duplicate ID ${id} in current sources; no identity winner selected.`),
-	];
-	changes.sort((a, b) => (a.after?.file ?? a.before?.file ?? "").localeCompare(b.after?.file ?? b.before?.file ?? "", "en"));
-	return { changes, issues, newIds };
-}

package/src/server/history/documents.ts

@@ -1,21 +0,0 @@
-import type { Baseline } from "#history/schema.ts";
-import { metadataParse, type ParsedMetadata } from "#server/metadata/parse.ts";
-
-export interface HistoryDocument {
-	readonly file: string;
-	readonly parsed: ParsedMetadata;
-	readonly source: string;
-}
-export function historyDocuments(baseline: Baseline): readonly HistoryDocument[] {
-	return baseline.documents.map((document) => ({ ...document, parsed: metadataParse(document.source) }));
-}
-export function historyIdentities(documents: readonly HistoryDocument[]): ReadonlyMap<string, HistoryDocument | undefined> {
-	const ids = new Map<string, HistoryDocument | undefined>();
-	for (const document of documents) {
-		const id = document.parsed.fields.id;
-		if (id) {
-			ids.set(id, ids.has(id) ? undefined : document);
-		}
-	}
-	return ids;
-}

package/src/server/history/fields.ts

@@ -1,32 +0,0 @@
-import type { Metadata } from "#metadata/schema.ts";
-import type { HistoryDocument } from "./documents.ts";
-
-const labels: ReadonlyArray<readonly [keyof Metadata, string]> = [
-	["attention", "Recorded attention requests changed"],
-	["criteria", "Criteria changed"],
-	["evidence", "Recorded evidence changed (not verified acceptance)"],
-	["id", "Item ID changed"],
-	["items", "Declared board membership changed"],
-	["kind", "Item kind changed"],
-	["nextAction", "Next action changed"],
-	["owner", "Recorded owner changed (not authorship)"],
-	["relationships", "Explicit relationships changed"],
-	["status", "Recorded status changed (not acceptance)"],
-];
-
-export function historyFields(before: HistoryDocument, after: HistoryDocument): readonly string[] {
-	const changes = labels.flatMap(([field, label]) =>
-		JSON.stringify(before.parsed.fields[field]) === JSON.stringify(after.parsed.fields[field]) ? [] : [label],
-	);
-	if (before.parsed.body !== after.parsed.body) {
-		const decision = before.parsed.fields.kind === "decision" || after.parsed.fields.kind === "decision";
-		changes.push(decision ? "Decision Markdown changed" : "Markdown body changed");
-	}
-	if (changes.length === 0 && before.source !== after.source) {
-		changes.push("Other frontmatter content or source formatting changed; no further interpretation");
-	}
-	if (before.file !== after.file) {
-		changes.unshift("Source path changed for the same unique item ID");
-	}
-	return changes;
-}

package/src/server/history/html.ts

@@ -1,20 +0,0 @@
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { fileUrl } from "#files/url.ts";
-import type { Baseline } from "#history/schema.ts";
-import { compareHistory, type SourceChange } from "./compare.ts";
-
-function source(label: string, text: string, key: string): string {
-	return `<details data-key="${escapeHtml(key)}:${label}" data-history-source="${label.toLowerCase()}"><summary>${label} source (plain text)</summary><pre class="history-source">${escapeHtml(text)}</pre></details>`;
-}
-function changeHtml(change: SourceChange): string {
-	const file = change.after?.file ?? change.before?.file ?? "";
-	const key = change.before ? `before:${change.before.file}` : `added:${file}`;
-	return `<article class="history-change" data-key="${escapeHtml(key)}"><h2>${change.kind}: ${escapeHtml(file)}</h2>${change.before && change.after && change.before.file !== file ? `<p>Previously ${escapeHtml(change.before.file)}</p>` : ""}<ul>${change.reasons.map((reason) => `<li>${escapeHtml(reason)}</li>`).join("")}</ul>${change.after ? `<a href="${escapeHtml(fileUrl(change.after.file))}">Read current source</a>` : "<p>Removed source; no current document link.</p>"}${change.before ? source("Remembered", change.before.source, key) : ""}${change.after ? source("Current", change.after.source, key) : ""}</article>`;
-}
-export function historyHtml(before: Baseline, current: Baseline): string {
-	const result = compareHistory(before, current);
-	const counts = ["added", "removed", "changed"]
-		.map((kind) => `${result.changes.filter((change) => change.kind === kind).length} ${kind}`)
-		.join(" · ");
-	return `<p>Compared with your observation at <time>${escapeHtml(before.recordedAt)}</time>.</p><p role="status">${counts}</p>${result.changes.length === 0 ? "<p>No source changes since that observation.</p>" : ""}${result.issues.length > 0 ? `<aside aria-label="Identity limitations"><ul>${result.issues.map((issue) => `<li>${escapeHtml(issue)}</li>`).join("")}</ul><p>Ambiguous identities are compared by source path only.</p></aside>` : ""}${result.changes.map(changeHtml).join("")}`;
-}

package/src/server/history/limits.ts

@@ -1,2 +0,0 @@
-export const MAX_BYTES = 2 * 1024 * 1024;
-export const MAX_AGE = 30 * 24 * 60 * 60 * 1000;

package/src/server/history/response.ts

@@ -1,37 +0,0 @@
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import type { HistoryOutput } from "#history/schema.ts";
-import type { Snapshot } from "#server/search/snapshot.ts";
-import { observeBaseline, readBaseline } from "./baseline.ts";
-import { compareHistory } from "./compare.ts";
-import { historyHtml } from "./html.ts";
-
-export function historyResponse(raw: string | null, now: number, snapshot?: Snapshot): HistoryOutput {
-	const prior = readBaseline(raw, now);
-	const output: HistoryOutput = { discardBaseline: prior.discard, html: `<p>${escapeHtml(prior.reason)}</p>`, reason: prior.reason, snapshot: null };
-	if (snapshot === undefined) {
-		return output;
-	}
-	const currentRaw = observeBaseline(snapshot, now);
-	if (currentRaw === undefined) {
-		const reason =
-			snapshot.unavailable.length > 0
-				? "Current workspace observation is incomplete; no comparison or removals are inferred. Your valid remembered snapshot is preserved."
-				: "Complete current snapshot exceeds 2 MiB; no comparison or partial history is retained.";
-		return { ...output, html: `<p role="status">${escapeHtml(reason)}</p>`, reason };
-	}
-	const current = readBaseline(currentRaw, now).baseline;
-	const compared = prior.baseline && current ? compareHistory(prior.baseline, current) : undefined;
-	const comparison =
-		compared && prior.baseline
-			? {
-					changes: compared.changes.map(({ before, after, ...change }) => ({
-						...change,
-						after: after ? { file: after.file, source: after.source } : undefined,
-						before: before ? { file: before.file, source: before.source } : undefined,
-					})),
-					issues: compared.issues,
-					recordedAt: prior.baseline.recordedAt,
-				}
-			: undefined;
-	return { ...output, comparison, html: prior.baseline && current ? historyHtml(prior.baseline, current) : output.html, snapshot: currentRaw };
-}

package/src/server/http/inbox.ts

@@ -1,27 +0,0 @@
-import { Clock, Effect } from "effect";
-import { inboxHtml } from "#server/attention/inboxHtml.ts";
-import type { Changes } from "#server/files/changes.ts";
-import { navHtml } from "#server/page/nav.ts";
-import { shell } from "#server/page/shell.ts";
-import type { searchSnapshot } from "#server/search/snapshot.ts";
-import { respond } from "./respond.ts";
-
-export function inbox(index: Effect.Success<ReturnType<typeof searchSnapshot>>, changes: Changes, home: string | undefined) {
-	return Effect.fn("WorkBoard.inbox")(function* () {
-		const snapshot = yield* index;
-		return respond(
-			shell(
-				"Inbox",
-				navHtml(yield* changes.files, "", home, snapshot),
-				inboxHtml(snapshot, false, yield* Clock.currentTimeMillis),
-				changes.realRoot,
-				true,
-				undefined,
-				"inbox",
-				snapshot,
-			),
-			"text/html",
-			snapshot.unavailable.length > 0 ? 503 : 200,
-		);
-	});
-}

package/src/server/http/overview.ts

@@ -1,19 +0,0 @@
-import { Effect } from "effect";
-import { overviewHtml } from "#server/attention/overviewHtml.ts";
-import type { Changes } from "#server/files/changes.ts";
-import { navHtml } from "#server/page/nav.ts";
-import { shell } from "#server/page/shell.ts";
-import type { searchSnapshot } from "#server/search/snapshot.ts";
-import { respond } from "./respond.ts";
-
-export function overview(index: Effect.Success<ReturnType<typeof searchSnapshot>>, changes: Changes, home: string | undefined) {
-	return Effect.fn("WorkBoard.overview")(function* () {
-		const snapshot = yield* index;
-		const nav = navHtml(yield* changes.files, "", home, snapshot);
-		return respond(
-			shell("Overview", nav, overviewHtml(snapshot), changes.realRoot, true, undefined, "overview", snapshot),
-			"text/html",
-			snapshot.unavailable.length > 0 ? 503 : 200,
-		);
-	});
-}

package/src/server/http/work.ts

@@ -1,42 +0,0 @@
-import { Effect } from "effect";
-import type { HttpServerRequest } from "effect/http";
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import type { Changes } from "#server/files/changes.ts";
-import { navHtml } from "#server/page/nav.ts";
-import { shell } from "#server/page/shell.ts";
-import type { searchSnapshot } from "#server/search/snapshot.ts";
-import { stateOf } from "#server/views/state.ts";
-import { workHtml } from "#server/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, snapshot);
-		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,
-					snapshot,
-				),
-				"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, snapshot), "text/html", result.status);
-	});
-}

package/src/server/page/attentionDetails.ts

@@ -1,26 +0,0 @@
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { managedRequestReceipt } from "#server/attention/managedRequestReceipt.ts";
-import { attentionSource } from "#server/attention/requests.ts";
-import { identityUrl } from "#server/metadata/links.ts";
-import type { MetadataModel } from "#server/metadata/model.ts";
-import type { ParsedMetadata } from "#server/metadata/parse.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) => {
-			const receipt = managedRequestReceipt({ file, parsed }, request, model);
-			const acknowledged = receipt
-				? `<p>Managed request acknowledged: ${receipt.disposition}. Source state remains ${escapeHtml(request.state)}. This receipt does not establish acceptance.</p><p>Reviewed question: ${referenceHtml(receipt.question, receipt.question, model)}</p>`
-				: "";
-			const respond = receipt
-				? ""
-				: `<a href="/_board/respond?item=${encodeURIComponent(parsed.fields.id ?? "")}&amp;request=${encodeURIComponent(request.id)}">Respond to this request</a> · `;
-			return `<li id="${attentionSource({ file, parsed }, index)}" tabindex="-1"><b>${escapeHtml(request.kind)} · ${escapeHtml(request.id)} · ${escapeHtml(request.state)}</b>${acknowledged}<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>${respond}<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/server/page/backlinksHtml.ts

@@ -1,18 +0,0 @@
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { backlinksOf } from "#server/metadata/backlinks.ts";
-import type { MetadataModel } from "#server/metadata/model.ts";
-import { relationshipLabel } from "#server/metadata/relationshipLabel.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/server/page/boardHtml.ts

@@ -1,55 +0,0 @@
-import { Effect } from "effect";
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { documentHeadings } from "#render/documentHeadings.ts";
-import { type Board, countsOf, type Section } from "#server/render/board.ts";
-import { renderMarkdown } from "#server/render/markdown.ts";
-import { readingTools } from "./readingTools.ts";
-import { updated } from "./updated.ts";
-
-function counts(board: Board): string {
-	return 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 = "",
-	questionActions?: ReadonlyMap<string, string>,
-) {
-	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}-`,
-			...(questionActions ? { questionActions } : {}),
-		});
-	};
-	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("");
-});

package/src/server/page/criteriaEvidence.ts

@@ -1,36 +0,0 @@
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { referenceTarget } from "#server/metadata/links.ts";
-import type { MetadataModel } from "#server/metadata/model.ts";
-import type { ParsedMetadata } from "#server/metadata/parse.ts";
-import { documentReference } from "./metadataLinks.ts";
-
-function evidenceFor(reference: string, model: MetadataModel): string {
-	const records = model.documents.flatMap(
-		(document) =>
-			document.parsed.fields.evidence?.flatMap((evidence, index) =>
-				evidence.criterion === reference ? [{ file: document.file, index, line: document.parsed.lines[`evidence.${index}.source`] }] : [],
-			) ?? [],
-	);
-	if (records.length === 0) {
-		return "<p>No recorded evidence naming this criterion. Acceptance is not established.</p>";
-	}
-	return `<p>${records.length} recorded ${records.length === 1 ? "claim" : "claims"}, not verified acceptance:</p><ul>${records.map((record) => `<li><a href="${escapeHtml(documentReference(record.file, model, `#recorded-evidence-${record.index}`))}">${escapeHtml(record.file)}${record.line === undefined ? "" : `:${record.line}`} — open recorded evidence</a></li>`).join("")}</ul>`;
-}
-
-export function criteriaEvidence(parsed: ParsedMetadata, model: MetadataModel): string {
-	const criteria = parsed.fields.criteria ?? [];
-	if (criteria.length === 0) {
-		return "";
-	}
-	return `<h3>Criteria and recorded evidence</h3><ul>${criteria
-		.map((criterion) => {
-			const unique = criteria.filter((candidate) => candidate.id === criterion.id).length === 1;
-			const reference = parsed.fields.id ? `${parsed.fields.id}#${criterion.id}` : "";
-			const evidence =
-				reference && referenceTarget(reference, model)
-					? evidenceFor(reference, model)
-					: "<p>Evidence association requires unique item/criterion IDs and a readable workspace. Acceptance is not established.</p>";
-			return `<li${unique ? ` id="criterion-${escapeHtml(criterion.id)}" tabindex="-1"` : ""}><b>${escapeHtml(criterion.id)}</b>: ${escapeHtml(criterion.text)}${evidence}</li>`;
-		})
-		.join("")}</ul>`;
-}

package/src/server/page/documentHtml.ts

@@ -1,23 +0,0 @@
-import { Effect } from "effect";
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import { documentHeadings } from "#render/documentHeadings.ts";
-import type { MarkdownFile } from "#server/files/list.ts";
-import { renderMarkdown } from "#server/render/markdown.ts";
-import { readingTools } from "./readingTools.ts";
-import { updated } from "./updated.ts";
-
-export const documentHtml = Effect.fn("WorkBoard.documentHtml")(function* (
-	source: string,
-	file: MarkdownFile,
-	metadata = "",
-	introduction = "",
-	questionActions?: ReadonlyMap<string, string>,
-) {
-	const headings = documentHeadings(true);
-	const html = yield* renderMarkdown(source, { file: file.path, headings, ...(questionActions ? { questionActions } : {}) });
-	const title = /^<h1\b[^>]*>[\s\S]*?<\/h1>/u.exec(html)?.[0] ?? "";
-	return `<div class="document-layout"><header class="item-introduction">${title || `<h1>${escapeHtml(file.path)}</h1>`}${introduction}</header>
- <details class="item-context" data-key="item-context"><summary>Context and tools</summary><div class="context-content">
- <p class="meta">Source: ${escapeHtml(file.path)} · ${updated(file.modified)}</p>${metadata}${readingTools(headings.entries)}</div></details>
- <article class="doc">${html.slice(title.length)}</article></div>`;
-});

package/src/server/page/itemIntroduction.ts

@@ -1,10 +0,0 @@
-import { escapeHtml } from "#browser/escapeHtml.ts";
-import type { ParsedMetadata } from "#server/metadata/parse.ts";
-
-export function itemIntroduction(parsed: ParsedMetadata): string {
-	if (parsed.raw === undefined) {
-		return "";
-	}
-	const fields = parsed.fields;
-	return `<div class="item-summary" aria-label="Authored work"><p>Status (source): <b>${escapeHtml(fields.status ?? "Not recorded")}</b>${fields.owner ? ` · Owner: ${escapeHtml(fields.owner)}` : ""}</p><p>Next action: ${escapeHtml(fields.nextAction ?? "Not recorded")}</p></div>`;
-}

package/src/server/page/itemStyles.ts

@@ -1,29 +0,0 @@
-export function itemStyles(): string {
-	return `
-.document-view:has(.document-layout) { max-width: 1220px; }
-.page:has(.document-layout) > .bar,
-.page:has(.document-layout) > .preferences { max-height: 25vh; overflow: auto; }
-.document-view:has(.document-layout) > .response-panel { max-width: 72ch; margin-inline: 0; }
-.document-layout { display: grid; gap: 20px; grid-template-columns: minmax(0, 1fr); }
-.document-layout > * { min-width: 0; }
-.item-introduction h1 { margin: 0 0 .6em; }
-.item-summary { padding: 12px 16px; background: var(--surface); border-left: 3px solid var(--link); border-radius: 4px; overflow-wrap: anywhere; }
-.item-summary p { margin: 0; }
-.item-summary p + p { margin-top: 8px; }
-.item-context { align-self: start; margin: 0; padding: 12px 16px; border: 1px solid var(--border); border-radius: 8px; font-size: .9rem; overflow-wrap: anywhere; }
-.item-context > summary { color: var(--text); font-weight: 600; }
-.item-context .work-meta, .item-context .work-context { margin: 16px 0; padding: 0; border: 0; background: transparent; }
-.item-context .reading-tools { margin: 16px 0 0; }
-.document-layout > .doc > :first-child { margin-top: 0; }
-@media (min-width: 1100px) {
-  .document-layout { grid-template-columns: minmax(0, 72ch) minmax(240px, 280px); grid-template-rows: auto 1fr; gap: 24px 32px; }
-  .item-introduction { grid-column: 1; grid-row: 1; }
-  .item-context { grid-column: 2; grid-row: 1 / span 2; }
-  .document-layout > .doc { grid-column: 1; grid-row: 2; }
-}
-@media print {
-  .document-layout { display: block; }
-  .item-context { display: none; }
-}
-`;
-}