@shivaedev/work-board 0.11.0 → 0.13.0

package/src/responses/templateNodes.ts

@@ -1,55 +0,0 @@
-import { Schema } from "effect";
-import type { RootContent } from "mdast";
-import type { ContainerDirective } from "mdast-util-directive";
-import type { Prompt } from "#browser/responses/Prompt.ts";
-import { Identity } from "#path/Identity.ts";
-
-const Id = Identity.check(Schema.isMaxLength(128));
-const PromptFields = Schema.Struct({ id: Id, request: Schema.optional(Identity), select: Schema.optional(Schema.Literals(["one", "many", "text"])) });
-const OptionFields = Schema.Struct({ id: Id });
-
-export function sliceNode(source: string, node: RootContent) {
-	return source.slice(node.position?.start.offset, node.position?.end.offset);
-}
-export function isContainer(node: RootContent): node is ContainerDirective {
-	return node.type === "containerDirective";
-}
-function hasControl(node: RootContent): boolean {
-	return (
-		((node.type === "containerDirective" || node.type === "leafDirective" || node.type === "textDirective")
-			&& ["question", "option"].includes(node.name))
-		|| ("children" in node && node.children.some(hasControl))
-	);
-}
-export function promptFrom(node: ContainerDirective, source: string) {
-	const attrs = Schema.decodeUnknownSync(PromptFields, { onExcessProperty: "error" })(node.attributes ?? {});
-	const options = node.children.filter((child) => isContainer(child) && child.name === "option");
-	const description = node.children.filter((child) => !(isContainer(child) && child.name === "option"));
-	if (
-		description.some(hasControl)
-		|| description.length === 0
-		|| options.length > 32
-		|| (attrs.select === "text" ? options.length > 0 : options.length === 0)
-	) {
-		throw new Error("A question needs Markdown context and 1–32 direct options (or select=text without options), without nested questions.");
-	}
-	const choices = options.map((option) => {
-		if (!isContainer(option) || option.children.some(hasControl) || option.children.length === 0) {
-			throw new Error("Options need Markdown descriptions and cannot nest response controls.");
-		}
-		const fields = Schema.decodeUnknownSync(OptionFields, { onExcessProperty: "error" })(option.attributes ?? {});
-		return { id: fields.id, source: option.children.map((child) => sliceNode(source, child)).join("\n\n") };
-	});
-	if (new Set(choices.map((option) => option.id)).size !== choices.length) {
-		throw new Error("Option IDs must be unique within each question.");
-	}
-	return {
-		prompt: {
-			id: attrs.id,
-			mode: attrs.select ?? "one",
-			options: choices,
-			source: description.map((child) => sliceNode(source, child)).join("\n\n"),
-		} satisfies Prompt,
-		request: attrs.request,
-	};
-}

package/src/responses/validateSupersedes.ts

@@ -1,24 +0,0 @@
-import { Effect } from "effect";
-import { type DraftInput, type Question, ResponseFailed } from "#browser/responses/schema.ts";
-import type { Snapshot } from "#search/snapshot.ts";
-import { questionFrom, responseFrom } from "./records.ts";
-
-export function validateSupersedes(input: DraftInput, question: Question, data: Snapshot) {
-	if (input.supersedes === undefined) {
-		return Effect.void;
-	}
-	const matches = data.model.ids.get(input.supersedes);
-	const previous = matches?.length === 1 && matches[0] ? responseFrom(matches[0]) : undefined;
-	const context = previous && data.model.ids.get(previous.response.question);
-	const old = context?.length === 1 && context[0] ? questionFrom(context[0]) : undefined;
-	return old
-		&& previous
-		&& previous.response.reviewedRevision === old.question.reviewedRevision
-		&& old.question.item === question.question.item
-		&& old.question.request === question.question.request
-		&& input.supersedes !== input.id
-		? Effect.void
-		: Effect.fail(
-				new ResponseFailed({ code: "Conflict", message: "Supersedes must identify one recorded response to this item's attention request." }),
-			);
-}

package/src/responses/validatedInput.ts

@@ -1,45 +0,0 @@
-import { answerBody } from "#browser/responses/answerBody.ts";
-import type { Prompt } from "#browser/responses/Prompt.ts";
-import type { DraftInput, PromptAnswer } from "#browser/responses/schema.ts";
-import { questionTemplate } from "./template.ts";
-
-function answerFor(prompt: Prompt, answer: PromptAnswer | undefined, required: boolean) {
-	if (!answer || answer.prompt !== prompt.id) {
-		throw new Error("Submit one answer per question, in template order.");
-	}
-	if (new Set(answer.selected).size !== answer.selected.length || (prompt.mode === "one" && answer.selected.length > 1)) {
-		throw new Error("The selected options do not match the question's selection mode.");
-	}
-	if (answer.selected.some((id) => !prompt.options.some((option) => option.id === id))) {
-		throw new Error("A selected option is not in the reviewed template.");
-	}
-	if (required && answer.selected.length === 0 && !answer.text.trim()) {
-		throw new Error("Answer every question with a selection or additional text, or use Clarify / Not now.");
-	}
-}
-export function validatedInput(input: DraftInput, context: string, request: string, file?: string): DraftInput {
-	const template = questionTemplate(context, request, file);
-	if (input.answers === undefined) {
-		if (template.prompts.length > 0 && input.type === "answer") {
-			throw new Error("This question packet requires answers for all prompts.");
-		}
-		if (!input.body.trim()) {
-			throw new Error("A response needs text or answers to the question packet.");
-		}
-		return input;
-	}
-	if (input.answers.length !== template.prompts.length || template.prompts.length === 0) {
-		throw new Error("The answer packet does not match the reviewed questions.");
-	}
-	template.prompts.forEach((prompt, index) => {
-		answerFor(prompt, input.answers?.[index], input.type === "answer");
-	});
-	if (input.type !== "answer" && !input.body.trim() && !input.answers.some((answer) => answer.text.trim())) {
-		throw new Error("Clarify / Not now needs explanatory text.");
-	}
-	const body = answerBody(template.prompts, input.answers, input.body);
-	if (body.length > 32_768) {
-		throw new Error("The complete recorded response exceeds 32768 characters. Shorten the response or split the source request.");
-	}
-	return { ...input, body };
-}

package/src/responses/waitFor.ts

@@ -1,58 +0,0 @@
-import * as Clock from "effect/Clock";
-import * as Effect from "effect/Effect";
-import type { RpcClientError } from "effect/unstable/rpc/RpcClientError";
-import { ResponseFailed, type WaitReading } from "#browser/responses/schema.ts";
-
-function resultFor(reading: WaitReading) {
-	if (reading.response) {
-		return Effect.succeed({ kind: "response", question: reading.question, response: reading.response } as const);
-	}
-	if (reading.expired) {
-		return Effect.fail(
-			new ResponseFailed({
-				code: "Unanswered",
-				message:
-					"The human left this unanswered for 48 hours. Check in with them; they may have forgotten or want to postpone. The request and late replies remain available.",
-			}),
-		);
-	}
-	return Effect.succeed(undefined);
-}
-
-function retryable(error: ResponseFailed | RpcClientError) {
-	return error._tag !== "ResponseFailed" || error.code === "Unavailable";
-}
-
-export const waitForResponse = Effect.fn("WorkBoard.waitForResponse")(function* (
-	read: () => Effect.Effect<WaitReading, ResponseFailed | RpcClientError>,
-	diagnostic: (text: string) => void,
-) {
-	let known: WaitReading | undefined;
-	const leaseEnd = (yield* Clock.currentTimeMillis) + 48 * 60 * 60 * 1000;
-	let unavailable = false;
-	while (true) {
-		const result = yield* read().pipe(Effect.result);
-		if (result._tag === "Failure") {
-			if (!retryable(result.failure)) {
-				return yield* Effect.fail(result.failure);
-			}
-			if ((yield* Clock.currentTimeMillis) >= (known?.question.question.deadline ?? leaseEnd)) {
-				return yield* Effect.fail(
-					new Error("The service is unavailable at the deadline; unanswered status could not be verified. Re-read this question when it returns."),
-				);
-			}
-			if (!unavailable) {
-				diagnostic("Local service unavailable; reconnecting to the same question.");
-			}
-			unavailable = true;
-			yield* Effect.sleep("2 seconds");
-			continue;
-		}
-		known = result.success;
-		unavailable = false;
-		const complete = yield* resultFor(known);
-		if (complete) {
-			return complete;
-		}
-	}
-});

package/src/results/criteria.ts

@@ -1,37 +0,0 @@
-import { referenceTarget } from "#metadata/links.ts";
-import type { MetadataDocument, MetadataModel } from "#metadata/model.ts";
-import { escapeHtml } from "#page/escape.ts";
-import { referenceHtml, sourceHtml, valueHtml } from "#page/metadataLinks.ts";
-
-function criterionRow(reference: string, text: string, result: MetadataDocument, model: MetadataModel): string {
-	if (!referenceTarget(reference, model)) {
-		return `<li>${escapeHtml(text)} — criterion identity is ambiguous; evidence association unavailable.</li>`;
-	}
-	const claims = result.parsed.fields.evidence?.filter((claim) => claim.criterion === reference) ?? [];
-	const evidence =
-		claims.length > 0
-			? `<p>${claims.length} recorded claim(s) in this result; not verified acceptance.</p><ul>${claims.map((claim) => `<li>${sourceHtml(claim.source, result.file, model)}<dl><dt>Checked Git revision (reported)</dt><dd>${valueHtml(claim.checkedRevision)}</dd><dt>Method</dt><dd>${valueHtml(claim.method)}</dd><dt>Outcome (reported)</dt><dd>${valueHtml(claim.outcome)}</dd><dt>Observed time</dt><dd>${valueHtml(claim.observedAt)}</dd></dl></li>`).join("")}</ul>`
-			: "<p>No recorded evidence in this result naming this criterion. Acceptance is not established.</p>";
-	return `<li>${referenceHtml(text, reference, model)}${evidence}</li>`;
-}
-function targetRow(target: string, result: MetadataDocument, model: MetadataModel): string {
-	const [id, criterion] = target.split("#");
-	const document = model.ids.get(id ?? "")?.[0];
-	if (!(document && referenceTarget(target, model))) {
-		return `<li>${referenceHtml(target, target, model)} — criteria unavailable.</li>`;
-	}
-	const criteria = (document.parsed.fields.criteria ?? []).filter((item) => !criterion || item.id === criterion);
-	const rows =
-		criteria.length > 0
-			? `<ul>${criteria.map((item) => criterionRow(`${id}#${item.id}`, item.text, result, model)).join("")}</ul>`
-			: "<p>No criteria declared in this source.</p>";
-	return `<li>${referenceHtml(target, target, model)} · source status: ${valueHtml(document.parsed.fields.status)}${rows}</li>`;
-}
-export function resultCriteria(result: MetadataDocument, model: MetadataModel): string {
-	const targets = new Set(result.parsed.fields.relationships?.map((link) => link.target));
-	if (result.parsed.fields.id) {
-		targets.add(result.parsed.fields.id);
-	}
-	const rows = [...targets].map((target) => targetRow(target, result, model));
-	return `<section id="result-criteria"><h2>Criteria and this result’s claims</h2><p>Only explicit relationships and criterion references are associated. Missing provenance stays missing. Git revisions are authored records; Work Board does not compare them with the current checkout. Evidence freshness is unknown.</p>${rows.length > 0 ? `<ul>${rows.join("")}</ul>` : "<p>No explicitly linked work or criteria.</p>"}<p>${escapeHtml(result.file)} does not change the linked work’s status.</p></section>`;
-}

package/src/results/feedback.ts

@@ -1,44 +0,0 @@
-import { Effect } from "effect";
-import { fileUrl } from "#files/url.ts";
-import type { MetadataDocument } from "#metadata/model.ts";
-import { escapeHtml } from "#page/escape.ts";
-import type { RenderFailed } from "#render/failed.ts";
-import type { Highlighter } from "#render/highlighter.ts";
-import { renderMarkdown } from "#render/markdown.ts";
-import { readResponses } from "#responses/read.ts";
-import { malformedResponse, questionFrom, revisionOf } from "#responses/records.ts";
-import type { Snapshot } from "#search/snapshot.ts";
-
-export const resultFeedback = Effect.fn("WorkBoard.resultFeedback")(function* (
-	result: MetadataDocument,
-	data: Snapshot,
-): Effect.fn.Return<string, RenderFailed, Highlighter> {
-	const unknown =
-		data.unavailable.length > 0
-		|| data.documents.some((document) => malformedResponse(document) || (document.parsed.fields.kind === "question" && !questionFrom(document)));
-	const questions = data.documents.flatMap((document) => {
-		const question = questionFrom(document);
-		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)));
-	if (unknown || readings.some((reading) => reading._tag === "Failure")) {
-		return '<section id="result-feedback"><h2>Recorded human feedback</h2><p role="status">Response history is unknown or ambiguous. Unreadable records do not establish that no feedback exists. Read the source files before relying on it.</p></section>';
-	}
-	const current = revisionOf((result.parsed.raw ?? "") + result.parsed.body);
-	const records = readings.flatMap((reading) =>
-		reading._tag === "Success" ? reading.success.responses.map((response) => ({ question: reading.success.question, response })) : [],
-	);
-	records.sort((a, b) => b.response.response.recordedAt - a.response.response.recordedAt || a.response.id.localeCompare(b.response.id));
-	const bodies = yield* Effect.forEach(records, ({ question, response }) =>
-		Effect.gen(function* () {
-			const matching = question.question.reviewedRevision === current && question.question.source === result.file;
-			const responseFile = data.model.ids.get(response.id)?.[0]?.file ?? `responses/${response.id}.md`;
-			const questionFile = data.model.ids.get(question.id)?.[0]?.file ?? `responses/${question.id}.md`;
-			const body = yield* renderMarkdown(response.body, { file: responseFile, safe: true });
-			const selected = response.response.answers?.map((answer) => `${answer.prompt}: ${answer.selected.join(", ") || "text only"}`).join("; ");
-			return `<article id="${escapeHtml(response.id)}"><h3>${escapeHtml(response.response.author)} · ${escapeHtml(response.response.type)}</h3><p><b>${matching ? "Feedback on this exact result revision" : "Earlier or moved result context — does not apply automatically to this revision"}</b></p><p>Reviewed source: ${escapeHtml(question.question.source)} · SHA-256 <code>${question.question.reviewedRevision}</code></p>${selected ? `<p>Recorded option IDs: ${escapeHtml(selected)}. Labels and reasoning are recorded below.</p>` : ""}${response.response.supersedes ? `<p>Explicitly supersedes <a href="${fileUrl(data.model.ids.get(response.response.supersedes)?.[0]?.file ?? `responses/${response.response.supersedes}.md`)}">${escapeHtml(response.response.supersedes)}</a>.</p>` : ""}${body}<p><a href="${fileUrl(responseFile)}">Response source</a> · <a href="${fileUrl(questionFile)}">Registered reviewed context</a></p><details><summary>Exact reviewed result source</summary><pre>${escapeHtml(question.context)}</pre></details></article>`;
-		}),
-	);
-	return `<section id="result-feedback"><h2>Recorded human feedback</h2><p>Human direction is pinned to its reviewed report. Option IDs and authored acceptance text are not a computed verified-acceptance state. Completing a run or receiving feedback does not change work status.</p>${bodies.join("") || "<p>No readable response is recorded for this result.</p>"}</section>`;
-});

package/src/results/page.ts

@@ -1,58 +0,0 @@
-import { Effect, type FileSystem, type Path, type PlatformError } from "effect";
-import type { HttpServerRequest, HttpServerResponse } from "effect/unstable/http";
-import type { Changes } from "#files/changes.ts";
-import { fileUrl } from "#files/url.ts";
-import { respond } from "#http/respond.ts";
-import type { MetadataDocument } from "#metadata/model.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 type { Highlighter } from "#render/highlighter.ts";
-import { renderMarkdown } from "#render/markdown.ts";
-import { revisionOf } from "#responses/records.ts";
-import { resultCriteria } from "#results/criteria.ts";
-import { resultFeedback } from "#results/feedback.ts";
-import type { Snapshot } from "#search/snapshot.ts";
-
-function reviewActions(result: MetadataDocument) {
-	const requests = result.parsed.fields.attention ?? [];
-	const actions = requests
-		.filter(
-			(attention) => attention.kind === "review" && attention.state === "open" && requests.filter((other) => other.id === attention.id).length === 1,
-		)
-		.map(
-			(attention) =>
-				`<li><a href="/_board/respond?item=${encodeURIComponent(result.parsed.fields.id ?? "")}&amp;request=${encodeURIComponent(attention.id)}">Review ${escapeHtml(attention.id)}</a> — ${escapeHtml(attention.reason)}</li>`,
-		);
-	return `<section id="result-actions"><h2>Respond to this report</h2>${actions.length > 0 ? `<ul>${actions.join("")}</ul>` : "<p>No unique open review request is declared. The agent can add an explicit attention review and Markdown question packet with ordinary file editing. Work Board does not infer one from status.</p>"}</section>`;
-}
-
-export function resultPage(index: Effect.Effect<Snapshot, unknown, FileSystem.FileSystem | Path.Path>, changes: Changes, home: string | undefined) {
-	return Effect.fn("WorkBoard.resultPage")(function* (
-		request: HttpServerRequest.HttpServerRequest,
-	): Effect.fn.Return<HttpServerResponse.HttpServerResponse, PlatformError.PlatformError, FileSystem.FileSystem | Path.Path | Highlighter> {
-		const item = new URL(request.url, "http://127.0.0.1").searchParams.get("item") ?? "";
-		const files = yield* changes.files;
-		function layout(body: string, status = 200) {
-			return respond(shell("Result review", navHtml(files, "", home), body, changes.realRoot, false, undefined, "result"), "text/html", status);
-		}
-		return yield* Effect.gen(function* () {
-			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 layout(
-					'<h1>Result unavailable</h1><p role="status">Choose one uniquely identified, readable result. Missing or ambiguous work is not accepted.</p>',
-					409,
-				);
-			}
-			const report = yield* renderMarkdown(result.parsed.body, { file: result.file, safe: true });
-			const feedback = yield* resultFeedback(result, data);
-			const revision = revisionOf((result.parsed.raw ?? "") + result.parsed.body);
-			return layout(
-				`<section class="response-panel"><h1>Review returned result · ${escapeHtml(item)}</h1><p>Result status (source): <b>${escapeHtml(result.parsed.fields.status ?? "Not recorded")}</b>. This is a supplied claim, not an execution receipt or work acceptance.</p><p>Current report SHA-256: <code>${revision}</code> · <a href="${fileUrl(result.file)}">Read source</a></p>${metadataHtml(result.parsed, result.file, data.model)}${reviewActions(result)}${resultCriteria(result, data.model)}<section id="result-report"><h2>Report, evidence and limitations</h2>${report}</section>${feedback}</section>`,
-			);
-		}).pipe(Effect.catch((error) => Effect.succeed(layout(`<h1>Result review unavailable</h1><p>${escapeHtml(String(error))}</p>`, 409))));
-	});
-}

package/src/rpc/affected.ts

@@ -1,77 +0,0 @@
-import type { Key } from "@shivaedev/effect-contract/keys.ts";
-import { backlinksOf } from "#metadata/backlinks.ts";
-import type { MetadataModel } from "#metadata/model.ts";
-import { documents, identities, index, navigation } from "./keys.ts";
-
-function uncertain(previous: MetadataModel, current: MetadataModel, paths: readonly string[]) {
-	if (previous.unavailable.length > 0 || current.unavailable.length > 0) {
-		return true;
-	}
-	const before = new Map(previous.documents.map((doc) => [doc.file, doc.parsed]));
-	const after = new Map(current.documents.map((doc) => [doc.file, doc.parsed]));
-	const known = new Set([...before.keys(), ...after.keys()]);
-	if (paths.some((path) => !known.has(path))) {
-		return true;
-	}
-	const announced = new Set(paths);
-	return [...known].some((file) => {
-		const old = before.get(file);
-		const next = after.get(file);
-		return !announced.has(file) && (old?.body !== next?.body || old?.raw !== next?.raw || old?.bodyLine !== next?.bodyLine);
-	});
-}
-function connectIdentities(model: MetadataModel, connect: (from: string, to: string) => void) {
-	for (const duplicates of model.ids.values()) {
-		const first = duplicates[0];
-		if (first === undefined) {
-			continue;
-		}
-		for (const duplicate of duplicates.slice(1)) {
-			connect(first.file, duplicate.file);
-			connect(duplicate.file, first.file);
-		}
-	}
-}
-function linkedFiles(models: readonly MetadataModel[], paths: readonly string[]) {
-	const edges = new Map<string, Set<string>>();
-	function connect(from: string, to: string) {
-		const targets = edges.get(from) ?? new Set();
-		targets.add(to);
-		edges.set(from, targets);
-	}
-	for (const model of models) {
-		connectIdentities(model, connect);
-		for (const document of model.documents) {
-			for (const link of backlinksOf(document.file, model)) {
-				connect(document.file, link.file);
-				connect(link.file, document.file);
-			}
-		}
-	}
-	const files = new Set(paths);
-	for (const file of files) {
-		for (const linked of edges.get(file) ?? []) {
-			files.add(linked);
-		}
-	}
-	return files;
-}
-export function affected(previous: MetadataModel, current: MetadataModel, paths: readonly string[]): readonly Key[] | undefined {
-	if (uncertain(previous, current, paths)) {
-		return undefined;
-	}
-	const models = [previous, current];
-	const files = linkedFiles(models, paths);
-	const keys: Key[] = [index.list, navigation.list, ...[...files].map((file) => documents.item(file))];
-	for (const model of models) {
-		if (model.rootFile && files.has(model.rootFile)) {
-			keys.push(documents.item(""));
-		}
-		for (const document of model.documents) {
-			if (files.has(document.file) && document.parsed.fields.id) {
-				keys.push(identities.item(document.parsed.fields.id));
-			}
-		}
-	}
-	return keys;
-}

package/src/rpc/hints.ts

@@ -1,34 +0,0 @@
-import { Effect, PubSub, Stream } from "effect";
-import type { LiveHint } from "@shivaedev/effect-contract/live.ts";
-import type { Change, Changes } from "#files/changes.ts";
-import type { Snapshot } from "#search/snapshot.ts";
-import { affected } from "./affected.ts";
-
-export function hints(changes: Changes, index: Effect.Effect<Snapshot, unknown>) {
-	return Stream.unwrap(
-		Effect.gen(function* () {
-			const subscription = yield* PubSub.subscribe(changes.events);
-			let sequence = changes.sequence ? yield* changes.sequence : undefined;
-			let previous = yield* Effect.option(index);
-			function nextHint(change: Change) {
-				return Effect.gen(function* () {
-					const current = yield* Effect.option(index);
-					const contiguous = sequence !== undefined && change.sequence === sequence + 1;
-					sequence = change.sequence;
-					let hint: LiveHint = { _tag: "Resync" };
-					if (contiguous && change._tag === "Changed" && previous._tag === "Some" && current._tag === "Some") {
-						const keys = affected(previous.value.model, current.value.model, change.paths);
-						if (keys !== undefined) {
-							hint = { _tag: "Changed", keys };
-						}
-					}
-					previous = current;
-					return hint;
-				});
-			}
-
-			const changesStream = Stream.fromSubscription(subscription).pipe(Stream.mapEffect(nextHint));
-			return Stream.concat(Stream.succeed<LiveHint>({ _tag: "Resync" }), changesStream);
-		}),
-	);
-}

package/src/rpc/server.ts

@@ -1,67 +0,0 @@
-import { Clock, Effect, Layer, Ref } from "effect";
-import { HttpIncomingMessage, HttpServerResponse } from "effect/unstable/http";
-import { RpcSerialization, RpcServer } from "effect/unstable/rpc";
-import type { Changes } from "#files/changes.ts";
-import type { handoffService } from "#handoffs/service.ts";
-import { MAX_BYTES } from "#history/limits.ts";
-import { historyResponse } from "#history/response.ts";
-import { HEADERS } from "#http/respond.ts";
-import { navHtml } from "#page/nav.ts";
-import type { responseService } from "#responses/service.ts";
-import { searchMatch } from "#search/match.ts";
-import type { Snapshot } from "#search/snapshot.ts";
-import { ReadFailed, workRpcs } from "./contract.ts";
-import { hints } from "./hints.ts";
-
-export interface ServerOptions {
-	readonly changes: Changes;
-	readonly handoffs: Effect.Success<ReturnType<typeof handoffService>>;
-	readonly home: string | undefined;
-	readonly index: Effect.Effect<Snapshot, unknown>;
-	readonly page: (url: string) => Effect.Effect<HttpServerResponse.HttpServerResponse, unknown>;
-	readonly responses: Effect.Success<ReturnType<typeof responseService>>;
-}
-
-export const server = Effect.fn("WorkBoard.server")(function* ({ changes, handoffs, home, index, page, responses }: ServerOptions) {
-	const handlers = workRpcs.toLayer({
-		"work-board.awaitResponse": responses.awaitResponse,
-		"work-board.handoffSource": ({ item }) => handoffs.locate(item),
-		"work-board.handoffs": ({ item }) => handoffs.read(item),
-		"work-board.history": ({ action, baseline }) =>
-			Effect.gen(function* () {
-				const now = yield* Clock.currentTimeMillis;
-				const snapshot = action === "check" ? undefined : yield* index;
-				return historyResponse(baseline, now, snapshot);
-			}).pipe(Effect.catch(() => Effect.fail(new ReadFailed({ operation: "history", status: 500 })))),
-		"work-board.navigation": () =>
-			Effect.map(changes.files, (files) => navHtml(files, "", home)).pipe(
-				Effect.catch(() => Effect.fail(new ReadFailed({ operation: "navigation", status: 500 }))),
-			),
-		"work-board.page": ({ url }) =>
-			page(url).pipe(
-				Effect.flatMap((response) => {
-					if (response.status >= 500 || response.body._tag !== "Uint8Array") {
-						return Effect.fail(new ReadFailed({ operation: "page", status: response.status }));
-					}
-					return Effect.succeed({ html: new TextDecoder().decode(response.body.body), status: response.status });
-				}),
-				Effect.catch((error) => Effect.fail(error instanceof ReadFailed ? error : new ReadFailed({ operation: "page", status: 500 }))),
-			),
-		"work-board.prepareHandoff": handoffs.prepare,
-		"work-board.question": ({ item, request }) => responses.locate(item, request),
-		"work-board.recordResponse": responses.record,
-		"work-board.registerQuestion": responses.register,
-		"work-board.responses": ({ question }) => responses.read(question),
-		"work-board.search": ({ query }) =>
-			Effect.map(index, (snapshot) => ({ ...searchMatch(snapshot.entries, query), unavailable: snapshot.unavailable })).pipe(
-				Effect.catch(() => Effect.fail(new ReadFailed({ operation: "search", status: 500 }))),
-			),
-		"work-board.subscribe": () => hints(changes, index),
-		"work-board.watcher": () => Effect.map(Ref.get(changes.watching), (watching) => ({ watching })),
-	});
-	const handler = yield* RpcServer.toHttpEffect(workRpcs).pipe(Effect.provide(Layer.merge(handlers, RpcSerialization.layerNdjson)));
-	return handler.pipe(
-		Effect.provideService(HttpIncomingMessage.MaxBodySize, BigInt(4 * MAX_BYTES + 4096)),
-		Effect.map((response) => HttpServerResponse.setHeaders(response, HEADERS)),
-	);
-});

package/src/search/attentionEntries.ts

@@ -1,22 +0,0 @@
-import type { MetadataDocument } from "#metadata/model.ts";
-import type { Entry } from "./entries.ts";
-
-export function attentionEntries(document: MetadataDocument, href: string): readonly Entry[] {
-	const requests = document.parsed.fields.attention ?? [];
-	return requests.flatMap((request, index) => {
-		if (requests.filter((other) => other.id === request.id).length !== 1) {
-			return [];
-		}
-		const line = document.parsed.lines[`attention.${index}`] ?? document.parsed.lines.attention;
-		return [
-			{
-				file: document.file,
-				href: `${href}#attention-request-${encodeURIComponent(request.id)}`,
-				kind: "passage",
-				...(line === undefined ? {} : { line }),
-				text: [request.reason, request.id, request.kind, request.state, ...request.responseFrom, ...request.unblocks].join(" "),
-				title: request.reason,
-			},
-		];
-	});
-}

package/src/search/entries.ts

@@ -1,58 +0,0 @@
-import { MarkdownAsync } from "react-markdown";
-import rehypeRaw from "rehype-raw";
-import remarkDirective from "remark-directive";
-import remarkGfm from "remark-gfm";
-import { fileUrl } from "#files/url.ts";
-import { boardOf } from "#render/board.ts";
-import { callouts } from "#render/callouts.ts";
-import { documentHeadings } from "#render/documentHeadings.ts";
-import { visualDocuments } from "#render/visualDocuments.ts";
-import { searchCollector } from "./collector.ts";
-import { linkCollector } from "./linkCollector.ts";
-
-export interface Entry {
-	readonly file: string;
-	readonly href: string;
-	readonly kind: "document" | "heading" | "passage";
-	readonly line?: number;
-	readonly text: string;
-	readonly title: string;
-}
-
-function fragmentLocation(source: string, fragment: string, bodyLine: number, seen: Map<string, number>): number | undefined {
-	const start = source.indexOf(fragment, seen.get(fragment) ?? 0);
-	if (start < 0) {
-		return undefined;
-	}
-	seen.set(fragment, start + fragment.length);
-	return bodyLine + source.slice(0, start).split("\n").length - 1;
-}
-
-export async function entriesOf(source: string, file: string, home: boolean, bodyLine = 1, links = new Set<string>()): Promise<readonly Entry[]> {
-	const headings = documentHeadings();
-	let fragmentLine: number | undefined = bodyLine;
-	let fragmentLength = 0;
-	const seenFragments = new Map<string, number>();
-	const { entries, plugin } = searchCollector(
-		file,
-		() => fragmentLine,
-		() => fragmentLength,
-	);
-	const board = home ? boardOf(source) : undefined;
-	const fragments = board
-		? [board.title, board.intro, ...board.sections.flatMap((section) => [section.heading, section.notes, ...section.items]), board.footer]
-		: [source];
-	for (const fragment of fragments) {
-		if (fragment) {
-			fragmentLength = fragment.split("\n").length;
-			fragmentLine = board ? fragmentLocation(source, fragment, bodyLine, seenFragments) : bodyLine;
-			await MarkdownAsync({
-				children: board?.definitions ? `${fragment}\n\n${board.definitions}` : fragment,
-				rehypePlugins: [rehypeRaw, headings.plugin, plugin, linkCollector(links)],
-				remarkPlugins: [remarkGfm, remarkDirective, visualDocuments, callouts],
-			});
-		}
-	}
-	const title = headings.entries.find((heading) => heading.depth === 1)?.title || file;
-	return [{ file, href: fileUrl(file), kind: "document", line: bodyLine, text: `${file} ${title}`, title }, ...entries];
-}

package/src/search/metadataEntries.ts

@@ -1,44 +0,0 @@
-import { fileUrl } from "#files/url.ts";
-import { identityUrl } from "#metadata/links.ts";
-import type { MetadataDocument, MetadataModel } from "#metadata/model.ts";
-import { attentionEntries } from "./attentionEntries.ts";
-import type { Entry } from "./entries.ts";
-
-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[] {
-	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) {
-			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(" "),
-		};
-	});
-	for (const document of documents) {
-		enriched.push(...attentionEntries(document, itemUrl(document, model)));
-		const criteria = document.parsed.fields.criteria ?? [];
-		for (const [index, criterion] of criteria.entries()) {
-			if (criteria.filter((item) => item.id === criterion.id).length !== 1) {
-				continue;
-			}
-			const line = document.parsed.lines[`criteria.${index}`] ?? document.parsed.lines.criteria;
-			enriched.push({
-				file: document.file,
-				href: `${itemUrl(document, model)}#criterion-${encodeURIComponent(criterion.id)}`,
-				kind: "passage",
-				...(line === undefined ? {} : { line }),
-				text: criterion.text,
-				title: criterion.text,
-			});
-		}
-	}
-	return enriched;
-}