@shivaedev/work-board 0.7.2 → 0.9.0

package/src/responses/locate.ts

@@ -0,0 +1,60 @@
+import { Effect, type FileSystem } from "effect";
+import { attentionRequests } from "#attention/requests.ts";
+import { type QuestionPreview, ResponseFailed } from "#browser/responses/schema.ts";
+import { markdownPath } from "#files/markdownPath.ts";
+import { metadataModel } from "#metadata/model.ts";
+import { metadataParse } from "#metadata/parse.ts";
+import type { Snapshot } from "#search/snapshot.ts";
+import { questionId, revisionOf } from "./records.ts";
+import { questionTemplate } from "./template.ts";
+
+function reject(code: ResponseFailed["code"], message: string) {
+	return Effect.fail(new ResponseFailed({ code, message }));
+}
+export function locate(root: string, realRoot: string, snapshot: Effect.Effect<Snapshot, ResponseFailed>, fs: FileSystem.FileSystem) {
+	return Effect.fn("WorkBoard.locate")(function* (item: string, request: string) {
+		const data = yield* snapshot;
+		const entry = attentionRequests(data).entries.find((candidate) => candidate.itemId === item && candidate.request.id === request);
+		if (!entry) {
+			return yield* reject("Missing", "The exact open attention request is missing, ambiguous or unavailable.");
+		}
+		const real = yield* markdownPath(root, realRoot, entry.document.file);
+		if (!real) {
+			return yield* reject("Missing", "The reviewed source moved or disappeared.");
+		}
+		const source = yield* fs.readFileString(real).pipe(Effect.catch(() => reject("Unavailable", "The source could not be read.")));
+		if (new TextEncoder().encode(source).length > 256 * 1024) {
+			return yield* reject("Unsupported", "Question context is limited to 256 KiB; use a focused source document.");
+		}
+		const parsed = metadataParse(source);
+		if (
+			parsed.fields.id !== item
+			|| parsed.fields.attention?.filter((candidate) => candidate.id === request && candidate.state === "open").length !== 1
+		) {
+			return yield* reject("Stale", "The source request changed. Re-read the question before proceeding.");
+		}
+		const documents = [...data.documents.filter((document) => document.file !== entry.document.file), { file: entry.document.file, parsed }];
+		const model = metadataModel(documents, data.unavailable, data.model.rootFile);
+		const fresh = attentionRequests({ ...data, documents, model }).entries.find(
+			(candidate) => candidate.itemId === item && candidate.request.id === request,
+		)?.request;
+		if (!fresh) {
+			return yield* reject("Stale", "The current request or its references are invalid. Review the source diagnostics before registering it.");
+		}
+		const revision = revisionOf(source);
+		yield* Effect.try({
+			catch: (cause) => new ResponseFailed({ code: "Unsupported", message: `Invalid response template: ${String(cause)}` }),
+			try: () => questionTemplate(source, request),
+		});
+		const question: QuestionPreview = {
+			context: source,
+			id: questionId(item, request, revision, entry.document.file),
+			item,
+			reason: fresh.reason,
+			request,
+			reviewedRevision: revision,
+			source: entry.document.file,
+		};
+		return question;
+	});
+}

package/src/responses/make.ts

@@ -0,0 +1,17 @@
+import type { DraftInput, Question, RecordedResponse } from "#browser/responses/schema.ts";
+
+export function makeResponse(input: DraftInput, question: Question, recordedAt: number): RecordedResponse {
+	return {
+		body: input.body,
+		id: input.id,
+		response: {
+			...(input.answers === undefined ? {} : { answers: input.answers }),
+			...(input.supersedes === undefined ? {} : { supersedes: input.supersedes }),
+			author: input.author,
+			question: input.question,
+			recordedAt,
+			reviewedRevision: question.question.reviewedRevision,
+			type: input.type,
+		},
+	};
+}

package/src/responses/outcome.ts

@@ -0,0 +1,15 @@
+import type { Reading } from "#browser/responses/schema.ts";
+
+export function outcome(reading: Reading, after: string | undefined, now: number) {
+	const at = after === undefined ? -1 : reading.responses.findIndex((candidate) => candidate.id === after);
+	if (after !== undefined && at < 0) {
+		return { kind: "missing_cursor" } as const;
+	}
+	const response = reading.responses[at + 1];
+	if (response) {
+		return { kind: "response", question: reading.question, response } as const;
+	}
+	return now >= reading.question.question.deadline
+		? ({ kind: "unanswered", question: reading.question } as const)
+		: ({ kind: "pending", question: reading.question } as const);
+}

package/src/responses/page.ts

@@ -0,0 +1,30 @@
+import { Effect } from "effect";
+import type { HttpServerRequest } from "effect/unstable/http";
+import type { Changes } from "#files/changes.ts";
+import { respond } from "#http/respond.ts";
+import { escapeHtml } from "#page/escape.ts";
+import { navHtml } from "#page/nav.ts";
+import { shell } from "#page/shell.ts";
+import { composerHtml } from "./composerHtml.ts";
+import type { responseService } from "./service.ts";
+
+export function responsePage(
+	service: Effect.Success<ReturnType<typeof responseService>>,
+	changes: Changes,
+	home: string | undefined,
+	enabled: boolean,
+) {
+	return Effect.fn("WorkBoard.responsePage")(function* (request: HttpServerRequest.HttpServerRequest) {
+		const params = new URL(request.url, "http://127.0.0.1").searchParams;
+		const files = yield* changes.files;
+		function layout(body: string, status = 200) {
+			return respond(shell("Respond", navHtml(files, "", home), body, changes.realRoot, false, undefined, "response"), "text/html", status);
+		}
+		return yield* Effect.gen(function* () {
+			const question = yield* service.locate(params.get("item") ?? "", params.get("request") ?? "");
+			yield* service.read(question.id).pipe(Effect.catch((error) => (error.code === "Missing" ? Effect.void : Effect.fail(error))));
+			const records = yield* service.history(question);
+			return layout(yield* composerHtml(question, records, enabled));
+		}).pipe(Effect.catch((error) => Effect.succeed(layout(`<h1>Response unavailable</h1><p>${escapeHtml(String(error))}</p>`, 409))));
+	});
+}

package/src/responses/publish.ts

@@ -0,0 +1,53 @@
+import { constants } from "node:fs";
+import { mkdir, open, realpath } from "node:fs/promises";
+import { Effect } from "effect";
+import { ResponseFailed } from "#browser/responses/schema.ts";
+import { publishIn } from "./publishIn.ts";
+
+function failure(cause: unknown): ResponseFailed {
+	return cause instanceof ResponseFailed
+		? cause
+		: new ResponseFailed({
+				code: "Unavailable",
+				message: "The response could not be recorded. Keep the draft and retry after checking local filesystem access.",
+			});
+}
+export function publish(root: string, realRoot: string, id: string, content: string) {
+	return Effect.tryPromise({
+		catch: failure,
+		try: async () => {
+			if (/^[a-zA-Z\d][a-zA-Z\d._-]*$/u.exec(id) === null) {
+				throw new ResponseFailed({ code: "Conflict", message: "Invalid response identity." });
+			}
+			if (process.platform !== "linux") {
+				throw new ResponseFailed({
+					code: "Unsupported",
+					message: "Safe response publication currently requires Linux directory descriptors. Reading remains available.",
+				});
+			}
+			const directory = await open(root, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+			try {
+				const base = `/proc/self/fd/${directory.fd}`;
+				if ((await realpath(base)) !== realRoot || (await realpath(root)) !== realRoot) {
+					throw new ResponseFailed({ code: "Conflict", message: "The workspace root changed. Restart against the intended root." });
+				}
+				try {
+					await mkdir(`${base}/responses`);
+				} catch (cause) {
+					if (!(cause instanceof Error && "code" in cause && cause.code === "EEXIST")) {
+						throw cause;
+					}
+				}
+				await directory.sync();
+				const target = await open(`${base}/responses`, constants.O_RDONLY | constants.O_DIRECTORY | constants.O_NOFOLLOW);
+				try {
+					await publishIn(target, root, realRoot, id, content);
+				} finally {
+					await target.close();
+				}
+			} finally {
+				await directory.close();
+			}
+		},
+	});
+}

package/src/responses/publishIn.ts

@@ -0,0 +1,64 @@
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { type FileHandle, link, open, readFile, realpath, unlink } from "node:fs/promises";
+import { ResponseFailed } from "#browser/responses/schema.ts";
+
+function uncertain(cause: unknown) {
+	return new ResponseFailed({ cause, code: "Uncertain", message: "Publication may have completed. Re-read the response identity before retrying." });
+}
+function exists(cause: unknown) {
+	return cause instanceof Error && "code" in cause && cause.code === "EEXIST";
+}
+async function linkOrReconcile(temporary: string, name: string, content: string): Promise<boolean> {
+	try {
+		await link(temporary, name);
+		return true;
+	} catch (cause) {
+		if (!exists(cause)) {
+			throw cause;
+		}
+	}
+	const existing = await open(name, constants.O_RDONLY | constants.O_NOFOLLOW);
+	try {
+		if ((await readFile(existing, "utf8")) !== content) {
+			throw new ResponseFailed({ code: "Conflict", message: "This identity already records different content; no file was replaced." });
+		}
+	} finally {
+		await existing.close();
+	}
+	return false;
+}
+export async function publishIn(target: FileHandle, root: string, realRoot: string, id: string, content: string) {
+	const folder = `/proc/self/fd/${target.fd}`;
+	const expected = `${realRoot}/responses`;
+	async function validate() {
+		if ((await realpath(folder)) !== expected || (await realpath(root)) !== realRoot) {
+			throw new ResponseFailed({ code: "Conflict", message: "The write boundary changed." });
+		}
+	}
+	await validate();
+	const name = `${folder}/${id}.md`;
+	const temporary = `${folder}/.${randomUUID()}.tmp`;
+	let published = false;
+	try {
+		const file = await open(temporary, "wx", 0o600);
+		try {
+			await file.writeFile(content, "utf8");
+			await file.sync();
+		} finally {
+			await file.close();
+		}
+		await validate();
+		await linkOrReconcile(temporary, name, content);
+		published = true;
+		await target.sync();
+		await validate();
+	} catch (cause) {
+		if (published) {
+			throw uncertain(cause);
+		}
+		throw cause;
+	} finally {
+		await unlink(temporary).catch(() => undefined);
+	}
+}

package/src/responses/read.ts

@@ -0,0 +1,45 @@
+import { Effect } from "effect";
+import { ResponseFailed } from "#browser/responses/schema.ts";
+import type { MetadataDocument } from "#metadata/model.ts";
+import type { Snapshot } from "#search/snapshot.ts";
+import { malformedResponse, questionFrom, responsesFor } from "./records.ts";
+
+function reject(code: ResponseFailed["code"], message: string) {
+	return Effect.fail(new ResponseFailed({ code, message }));
+}
+const registeredQuestion = Effect.fn("WorkBoard.registeredQuestion")(function* (matches: readonly MetadataDocument[] | undefined) {
+	if (!matches?.length) {
+		return yield* reject("Missing", "The registered question is missing.");
+	}
+	if (matches.length !== 1) {
+		return yield* reject("Conflict", "The registered question identity is ambiguous; response history is unknown.");
+	}
+	const question = matches[0] && questionFrom(matches[0]);
+	if (!question) {
+		return yield* reject("Conflict", "This identity is not a valid registered question; response history is unknown.");
+	}
+	return question;
+});
+export function readResponses(snapshot: Effect.Effect<Snapshot, ResponseFailed>) {
+	return Effect.fn("WorkBoard.read")(function* (id: string) {
+		const data = yield* snapshot;
+		if (data.unavailable.length > 0) {
+			return yield* reject("Unavailable", "The workspace index is incomplete; no response can be selected safely.");
+		}
+		const question = yield* registeredQuestion(data.model.ids.get(id));
+		if (new TextEncoder().encode(question.context).length > 256 * 1024) {
+			return yield* reject("Unsupported", "The registered context exceeds the 256 KiB limit.");
+		}
+		if (data.documents.some(malformedResponse)) {
+			return yield* reject("Unavailable", "A response record is malformed; response history cannot be established safely.");
+		}
+		const result = responsesFor(data.documents, question);
+		if (result.responses.some((candidate) => candidate.body.length > 32_768)) {
+			return yield* reject("Unsupported", "A recorded response exceeds the supported text limit; read its source file directly.");
+		}
+		if (result.responses.some((candidate) => data.model.ids.get(candidate.id)?.length !== 1)) {
+			return yield* reject("Conflict", "A response identity is duplicated; no answer is selected.");
+		}
+		return result;
+	});
+}

package/src/responses/records.ts

@@ -0,0 +1,55 @@
+import { createHash } from "node:crypto";
+import { stringify } from "yaml";
+import type { DraftInput, Question, Reading, RecordedResponse } from "#browser/responses/schema.ts";
+import type { MetadataDocument } from "#metadata/model.ts";
+
+export function revisionOf(source: string) {
+	return createHash("sha256").update(source).digest("hex");
+}
+export function questionId(item: string, request: string, revision: string, source: string) {
+	return `question.${revisionOf(JSON.stringify([item, request, revision, source]))}`;
+}
+export function questionMarkdown(record: Question): string {
+	return `---\n${stringify({ id: record.id, kind: "question", question: record.question })}---\n${record.context}`;
+}
+export function responseMarkdown(record: RecordedResponse): string {
+	return `---\n${stringify({ id: record.id, kind: "response", response: record.response })}---\n${record.body}`;
+}
+export function questionFrom(document: MetadataDocument): Question | undefined {
+	const { id, kind, question } = document.parsed.fields;
+	return id
+		&& kind === "question"
+		&& question
+		&& question.reviewedRevision === revisionOf(document.parsed.body)
+		&& id === questionId(question.item, question.request, question.reviewedRevision, question.source)
+		? { context: document.parsed.body, id, question }
+		: undefined;
+}
+export function responseFrom(document: MetadataDocument): RecordedResponse | undefined {
+	const { id, kind, response } = document.parsed.fields;
+	return id && kind === "response" && response ? { body: document.parsed.body, id, response } : undefined;
+}
+export function responsesFor(documents: readonly MetadataDocument[], question: Question): Reading {
+	const responses = documents.flatMap((document) => {
+		const record = responseFrom(document);
+		return record?.response.question === question.id && record.response.reviewedRevision === question.question.reviewedRevision ? [record] : [];
+	});
+	responses.sort((a, b) => a.response.recordedAt - b.response.recordedAt || a.id.localeCompare(b.id));
+	return { question, responses };
+}
+
+export function matchesResponse(record: RecordedResponse, input: DraftInput) {
+	return (
+		record.body === input.body
+		&& JSON.stringify(record.response.answers) === JSON.stringify(input.answers)
+		&& record.response.supersedes === input.supersedes
+		&& record.response.author === input.author
+		&& record.response.type === input.type
+		&& record.response.question === input.question
+	);
+}
+
+export function malformedResponse(document: MetadataDocument) {
+	const fields = document.parsed.fields;
+	return fields.kind === "response" && !(fields.id && fields.response);
+}

package/src/responses/retry.ts

@@ -0,0 +1,23 @@
+import { Effect } from "effect";
+import { type DraftInput, type RecordedResponse, ResponseFailed } from "#browser/responses/schema.ts";
+import type { Snapshot } from "#search/snapshot.ts";
+import { publish } from "./publish.ts";
+import { matchesResponse, responseMarkdown } from "./records.ts";
+import type { ResponseOptions } from "./service.ts";
+
+export const retryResponse = Effect.fn("WorkBoard.retryResponse")(function* (
+	existing: RecordedResponse,
+	input: DraftInput,
+	snapshot: Effect.Effect<Snapshot, ResponseFailed>,
+	options: ResponseOptions,
+) {
+	if (!matchesResponse(existing, input)) {
+		return yield* Effect.fail(new ResponseFailed({ code: "Conflict", message: "The response identity already records different content." }));
+	}
+	if ((yield* snapshot).model.ids.get(input.id)?.[0]?.file !== `responses/${input.id}.md`) {
+		return yield* Effect.fail(
+			new ResponseFailed({ code: "Conflict", message: "The saved response moved. Read its existing record instead of retrying a write." }),
+		);
+	}
+	yield* publish(options.root, options.changes.realRoot, existing.id, responseMarkdown(existing));
+});

package/src/responses/service.ts

@@ -0,0 +1,117 @@
+import { Clock, Effect, FileSystem, Semaphore } from "effect";
+import { type DraftInput, type Question, ResponseFailed } from "#browser/responses/schema.ts";
+import type { Changes } from "#files/changes.ts";
+import type { Snapshot } from "#search/snapshot.ts";
+import { awaitResponse } from "./await.ts";
+import { responseHistory } from "./history.ts";
+import { locate as locateQuestion } from "./locate.ts";
+import { makeResponse } from "./make.ts";
+import { publish } from "./publish.ts";
+import { readResponses } from "./read.ts";
+import { questionMarkdown, responseMarkdown } from "./records.ts";
+import { retryResponse } from "./retry.ts";
+import { validatedInput } from "./validatedInput.ts";
+import { validateSupersedes } from "./validateSupersedes.ts";
+
+export interface ResponseOptions {
+	readonly changes: Changes;
+	readonly enabled: boolean;
+	readonly index: Effect.Effect<Snapshot, unknown>;
+	readonly root: string;
+}
+function reject(code: ResponseFailed["code"], message: string) {
+	return Effect.fail(new ResponseFailed({ code, message }));
+}
+const HOURS_48 = 48 * 60 * 60 * 1000;
+export const responseService = Effect.fn("WorkBoard.responseService")(function* (options: ResponseOptions) {
+	const fs = yield* FileSystem.FileSystem;
+	const lock = yield* Semaphore.make(1);
+	const snapshot = options.index.pipe(Effect.catch(() => reject("Unavailable", "The workspace could not be indexed.")));
+	const enabled = options.enabled ? Effect.void : reject("Disabled", "Start with --responses to explicitly enable local question/response writes.");
+	const locate = locateQuestion(options.root, options.changes.realRoot, snapshot, fs);
+	const read = readResponses(snapshot);
+	function register(input: { readonly item: string; readonly request: string; readonly revision: string }) {
+		return lock.withPermit(
+			Effect.gen(function* () {
+				yield* enabled;
+				const preview = yield* locate(input.item, input.request);
+				if (preview.reviewedRevision !== input.revision) {
+					return yield* reject("Stale", "Source changed since review. Read it again before registering this question.");
+				}
+				const data = yield* snapshot;
+				const matches = data.model.ids.get(preview.id);
+				if (matches?.length) {
+					if (matches.length !== 1 || matches[0]?.file !== `responses/${preview.id}.md`) {
+						return yield* reject("Conflict", "The registered identity moved or is duplicated. Read the existing record instead of retrying a write.");
+					}
+					const saved = (yield* read(preview.id)).question;
+					yield* publish(options.root, options.changes.realRoot, saved.id, questionMarkdown(saved));
+					return saved;
+				}
+				const now = yield* Clock.currentTimeMillis;
+				const question: Question = {
+					context: preview.context,
+					id: preview.id,
+					question: {
+						deadline: now + HOURS_48,
+						item: preview.item,
+						reason: preview.reason,
+						registeredAt: now,
+						request: preview.request,
+						reviewedRevision: preview.reviewedRevision,
+						source: preview.source,
+					},
+				};
+				yield* publish(options.root, options.changes.realRoot, question.id, questionMarkdown(question)).pipe(
+					Effect.ensuring(options.changes.refresh ?? Effect.void),
+				);
+				return question;
+			}),
+		);
+	}
+	function record(draft: DraftInput) {
+		return lock.withPermit(
+			Effect.gen(function* () {
+				yield* enabled;
+				const result = yield* read(draft.question);
+				const input = yield* Effect.try({
+					catch: (cause) => new ResponseFailed({ code: "Conflict", message: String(cause) }),
+					try: () => validatedInput(draft, result.question.context, result.question.question.request, result.question.question.source),
+				});
+				const existing = result.responses.find((candidate) => candidate.id === input.id);
+				if (existing) {
+					yield* retryResponse(existing, input, snapshot, options);
+					return existing;
+				}
+				const { question } = result;
+				const current = yield* locate(question.question.item, question.question.request);
+				if (current.reviewedRevision !== question.question.reviewedRevision || current.source !== question.question.source) {
+					return yield* reject("Stale", "Source changed or moved. Keep the draft and review the new revision before responding.");
+				}
+				const data = yield* snapshot;
+				yield* validateSupersedes(input, question, data);
+				if (data.model.ids.has(input.id)) {
+					return yield* reject("Conflict", "This response identity is already used.");
+				}
+				const response = makeResponse(
+					input,
+					question,
+					result.responses.reduce((time, saved) => Math.max(time, saved.response.recordedAt + 1), yield* Clock.currentTimeMillis),
+				);
+				yield* publish(options.root, options.changes.realRoot, response.id, responseMarkdown(response)).pipe(
+					Effect.ensuring(options.changes.refresh ?? Effect.void),
+				);
+				return response;
+			}),
+		);
+	}
+	function history(preview: Parameters<typeof responseHistory>[1]) {
+		return Effect.flatMap(snapshot, (data) =>
+			Effect.try({
+				catch: (cause) => new ResponseFailed({ code: "Unavailable", message: String(cause) }),
+				try: () => responseHistory(data, preview),
+			}),
+		);
+	}
+	return { awaitResponse: awaitResponse(read), history, locate, read, record, register };
+});

package/src/responses/template.ts

@@ -0,0 +1,72 @@
+import type { RootContent } from "mdast";
+import type { ContainerDirective } from "mdast-util-directive";
+import remarkDirective from "remark-directive";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import type { Prompt } from "#browser/responses/Prompt.ts";
+import { metadataParse } from "#metadata/parse.ts";
+import { templateLinks } from "./templateLinks.ts";
+import { isContainer, promptFrom, sliceNode } from "./templateNodes.ts";
+
+export interface Template {
+	readonly context: string;
+	readonly prompts: readonly Prompt[];
+}
+function nestedControl(node: RootContent): boolean {
+	return (
+		((node.type === "leafDirective" || node.type === "textDirective" || node.type === "containerDirective")
+			&& ["question", "option"].includes(node.name))
+		|| ("children" in node && node.children.some(nestedControl))
+	);
+}
+function scopedPrompt(
+	node: ContainerDirective,
+	source: string,
+	requests: readonly { readonly id: string; readonly state: string }[],
+	request: string,
+) {
+	const result = promptFrom(node, source);
+	if (result.request !== undefined && !requests.some((entry) => entry.id === result.request)) {
+		throw new Error("A question's request= must name an attention request in this document.");
+	}
+	if (result.request === undefined && requests.filter((entry) => entry.state === "open").length > 1) {
+		throw new Error("Use request= on question directives when a document has several open attention requests.");
+	}
+	return result.request === undefined || result.request === request ? result.prompt : undefined;
+}
+export function questionTemplate(context: string, request: string, file?: string): Template {
+	const parsed = metadataParse(context);
+	const parser = unified().use(remarkParse).use(remarkDirective);
+	const body = parsed.body.replace(/\r\n?/gu, "\n");
+	const original = parser.parse(body);
+	const source = file === undefined ? body : templateLinks(body, original.children, file);
+	const tree = parser.parse(source);
+	const definitions = tree.children
+		.filter((node) => node.type === "definition")
+		.map((node) => sliceNode(source, node))
+		.join("\n\n");
+	const prompts: Prompt[] = [];
+	const plain: string[] = [];
+
+	for (const node of tree.children) {
+		if (isContainer(node) && node.name === "question") {
+			const prompt = scopedPrompt(node, source, parsed.fields.attention ?? [], request);
+			if (prompt) {
+				prompts.push({
+					...prompt,
+					options: prompt.options.map((option) => ({ ...option, source: `${option.source}\n\n${definitions}`.trim() })),
+					source: `${prompt.source}\n\n${definitions}`.trim(),
+				});
+			}
+		} else {
+			if (nestedControl(node)) {
+				throw new Error("Use top-level question containers with direct option children.");
+			}
+			plain.push(sliceNode(source, node));
+		}
+	}
+	if (prompts.length > 32 || new Set(prompts.map((prompt) => prompt.id)).size !== prompts.length) {
+		throw new Error("Use at most 32 questions with unique IDs per attention request.");
+	}
+	return { context: plain.join("\n\n"), prompts };
+}

package/src/responses/templateHtml.ts

@@ -0,0 +1,26 @@
+import { Effect } from "effect";
+import { escapeHtml } from "#page/escape.ts";
+import { renderMarkdown } from "#render/markdown.ts";
+import { questionTemplate } from "./template.ts";
+
+export const templateHtml = Effect.fn("WorkBoard.templateHtml")(function* (context: string, request: string, file: string) {
+	const template = questionTemplate(context, request, file);
+	function render(source: string) {
+		return renderMarkdown(source, { file, safe: true });
+	}
+	const background = yield* render(template.context);
+	const controls = yield* Effect.forEach(template.prompts, (prompt, index) =>
+		Effect.gen(function* () {
+			const description = yield* render(prompt.source);
+			const options = yield* Effect.forEach(prompt.options, (option, choice) =>
+				Effect.map(
+					render(option.source),
+					(html) =>
+						`<div class="question-option"><input id="question-${index}-${choice}" type="${prompt.mode === "one" ? "radio" : "checkbox"}" name="choice-${escapeHtml(prompt.id)}" value="${escapeHtml(option.id)}" data-option-source="${escapeHtml(option.source)}"><div><label for="question-${index}-${choice}">Option ${escapeHtml(option.id)}</label>${html}</div></div>`,
+				),
+			);
+			return `<fieldset data-prompt="${escapeHtml(prompt.id)}" data-mode="${prompt.mode}" data-source="${escapeHtml(prompt.source)}"><legend>Question ${index + 1} · ${escapeHtml(prompt.id)}</legend>${description}<p>${prompt.mode === "text" ? "Answer in your own words" : `${prompt.mode === "one" ? "Choose one option" : "Choose any combination"}, or answer in your own words`}. Nothing is selected for you.</p>${options.join("")}${prompt.mode === "text" ? "" : '<button type="button" data-clear-choices>Clear selections</button>'}<label>Additional text / another answer<textarea data-answer-text maxlength="8192" rows="3"></textarea></label></fieldset>`;
+		}),
+	);
+	return { background, controls: controls.join(""), hasPrompts: template.prompts.length > 0 };
+});

package/src/responses/templateLinks.ts

@@ -0,0 +1,43 @@
+import type { RootContent } from "mdast";
+import { fileUrl } from "#files/url.ts";
+
+function destination(url: string, file: string) {
+	if (url.startsWith("//") || url.search(/^[a-z][a-z\d+.-]*:/iu) === 0) {
+		return url;
+	}
+	const resolved = new URL(url, `http://work-board.local${fileUrl(file)}`);
+	return resolved.pathname + resolved.search + resolved.hash;
+}
+function titleSuffix(title: string | null | undefined) {
+	return title ? ` "${title.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"` : "";
+}
+export function templateLinks(source: string, nodes: readonly RootContent[], file: string) {
+	const edits: { readonly start: number; readonly end: number; readonly text: string }[] = [];
+	function visit(node: RootContent) {
+		const start = node.position?.start.offset;
+		const end = node.position?.end.offset;
+		if (start === undefined || end === undefined) {
+			return;
+		}
+		if (node.type === "link") {
+			const label = source.slice(node.children.at(0)?.position?.start.offset, node.children.at(-1)?.position?.end.offset);
+			edits.push({ end, start, text: `[${label}](<${destination(node.url, file)}>${titleSuffix(node.title)})` });
+		} else if (node.type === "image") {
+			edits.push({
+				end,
+				start,
+				text: `![${(node.alt ?? "").replaceAll("[", "\\[").replaceAll("]", "\\]")}](<${destination(node.url, file)}>${titleSuffix(node.title)})`,
+			});
+		} else if (node.type === "definition") {
+			edits.push({ end, start, text: `[${node.label ?? node.identifier}]: <${destination(node.url, file)}>${titleSuffix(node.title)}` });
+		} else if ("children" in node) {
+			node.children.forEach(visit);
+		}
+	}
+	nodes.forEach(visit);
+	let result = source;
+	for (const edit of edits.sort((a, b) => b.start - a.start)) {
+		result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+	}
+	return result;
+}