@shivaedev/work-board 0.11.0 → 0.13.0

package/src/server/http/assets.ts

@@ -0,0 +1,99 @@
+import { createRequire } from "node:module";
+import { Effect, FileSystem, Path, Schema } from "effect";
+import type { HttpRouter, HttpServerRequest } from "effect/http";
+import { InternalServerError } from "@shivaedev/platform/errors/taxonomy.ts";
+import { style } from "#server/page/style.ts";
+import { respond } from "./respond.ts";
+
+export const ASSETS: ReadonlyArray<readonly [HttpRouter.PathInput, string, string]> = [["/_board/style.css", style, "text/css"]];
+
+const MERMAID = "/_board/mermaid/";
+
+export class MermaidMissing extends Schema.TaggedError<MermaidMissing>()("MermaidMissing", { cause: Schema.Unknown }) {
+	override get message() {
+		return "The Mermaid assets could not be found. Reinstall Work Board and restart it.";
+	}
+}
+
+export const mermaidRoot = Effect.fn("WorkBoard.mermaidRoot")(function* () {
+	const path = yield* Path.Path;
+	const entry = yield* Effect.try({ catch: (cause) => new MermaidMissing({ cause }), try: () => createRequire(import.meta.url).resolve("mermaid") });
+	return path.dirname(entry);
+});
+
+export function mermaidFile(root: string) {
+	return Effect.fn("WorkBoard.mermaidFile")(function* (request: HttpServerRequest.HttpServerRequest) {
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		const file = path.resolve(root, new URL(request.url, "http://127.0.0.1").pathname.slice(MERMAID.length));
+		if (!(file.startsWith(`${root}${path.sep}`) && file.endsWith(".mjs") && (yield* fs.exists(file)))) {
+			return respond("Not found", "text/plain", 404);
+		}
+		return respond(yield* fs.readFile(file), "text/javascript");
+	});
+}
+
+export const MERMAID_ROUTE: HttpRouter.PathInput = `${MERMAID}*`;
+
+export const NATIVE_ROUTE: HttpRouter.PathInput = "/_board/native.js";
+function missingBundle(file: string) {
+	return `Work Board browser bundle assets/${file} is missing. Run pnpm --filter @shivaedev/work-board build:browser from the repository root to build it.`;
+}
+
+const bundledPath = Effect.fn("WorkBoard.bundledPath")(function* (file: string) {
+	const path = yield* Path.Path;
+	const module = yield* path
+		.fromFileUrl(new URL(import.meta.url))
+		.pipe(Effect.mapError(() => new InternalServerError({ message: "The browser asset location is invalid. Reinstall Work Board and restart it." })));
+	return path.resolve(path.dirname(module), "../../../assets", file);
+});
+
+const checkAssets = Effect.fn("WorkBoard.checkAssets")(function* (files: readonly string[]) {
+	const fs = yield* FileSystem.FileSystem;
+	for (const file of files) {
+		if (!(yield* fs.exists(yield* bundledPath(file)))) {
+			yield* Effect.logWarning(missingBundle(file));
+		}
+	}
+});
+
+export function checkNativeAsset() {
+	return checkAssets(["native.js"]);
+}
+export function checkBrowserAssets() {
+	return checkAssets(["native.js", "react.js", "react.css"]);
+}
+export const nativeAsset = bundledAsset("native.js", "text/javascript");
+
+const BUNDLED_ASSETS: ReadonlyArray<readonly [HttpRouter.PathInput, ReturnType<typeof bundledAsset>]> = [
+	[NATIVE_ROUTE, nativeAsset],
+	["/_board/react.js", bundledAsset("react.js", "text/javascript")],
+	["/_board/react.css", bundledAsset("react.css", "text/css")],
+];
+
+const reactChunk = Effect.fn("WorkBoard.reactChunk")(function* (request: HttpServerRequest.HttpServerRequest) {
+	const name = new URL(request.url, "http://127.0.0.1").pathname.slice("/_board/react-assets/".length);
+	if (!/^[a-zA-Z\d_-]+\.js$/u.test(name)) {
+		return respond("Not found", "text/plain", 404);
+	}
+	return yield* bundledAsset(`react-assets/${name}`, "text/javascript")();
+});
+
+function bundledAsset(file: string, contentType: string) {
+	return Effect.fn("WorkBoard.bundledAsset")(function* () {
+		const fs = yield* FileSystem.FileSystem;
+		return yield* fs.readFile(yield* bundledPath(file)).pipe(
+			Effect.map((body) => respond(body, contentType)),
+			Effect.catchIf(
+				(error) => error.reason._tag === "NotFound",
+				() => Effect.succeed(respond(missingBundle(file), "text/plain", 500)),
+			),
+		);
+	});
+}
+
+export const ASSET_HANDLERS = [
+	...ASSETS.map(([route, body, type]) => [route, () => Effect.succeed(respond(body, type))] as const),
+	...BUNDLED_ASSETS,
+	["/_board/react-assets/*", reactChunk] as const,
+];

package/src/server/http/attachment.ts

@@ -0,0 +1,46 @@
+import { Effect, FileSystem, Path } from "effect";
+import type { HttpServerRequest } from "effect/http";
+import { attachmentType } from "#path/attachment.ts";
+import { within } from "#server/files/list.ts";
+import { respond } from "./respond.ts";
+
+const MAX_BYTES = 16 * 1024 * 1024;
+
+export function attachment(root: string, realRoot: string) {
+	return Effect.fn("WorkBoard.attachment")(function* (request: HttpServerRequest.HttpServerRequest) {
+		function missing() {
+			return respond("Local image unavailable: unsupported type, missing file or workspace boundary.", "text/plain", 404);
+		}
+		let relative: string;
+		try {
+			relative = decodeURIComponent(new URL(request.url, "http://127.0.0.1").pathname.slice("/_board/attachment/".length));
+		} catch {
+			return missing();
+		}
+		const type = attachmentType(relative);
+		if (
+			!type
+			|| relative.includes("\\")
+			|| relative.split("/").some((part) => !part || part === ".." || part.startsWith(".") || part === "node_modules")
+		) {
+			return missing();
+		}
+		const fs = yield* FileSystem.FileSystem;
+		const path = yield* Path.Path;
+		return yield* Effect.gen(function* () {
+			const real = yield* fs.realPath(path.join(root, relative));
+			if (!within(realRoot, path.sep, real)) {
+				return missing();
+			}
+			const info = yield* fs.stat(real);
+			if (info.type !== "File") {
+				return missing();
+			}
+			if (info.size > BigInt(MAX_BYTES)) {
+				return respond("Local image exceeds the 16 MiB limit.", "text/plain", 413);
+			}
+			const body = yield* fs.readFile(real);
+			return body.byteLength > MAX_BYTES ? respond("Local image exceeds the 16 MiB limit.", "text/plain", 413) : respond(body, type);
+		}).pipe(Effect.orElseSucceed(missing));
+	});
+}

package/src/server/http/boardRoutes.ts

@@ -0,0 +1,62 @@
+import { Effect, type FileSystem, type Path, type Scope } from "effect";
+import { HttpRouter, type HttpServerRequest, type HttpServerResponse } from "effect/http";
+import { loopbackOnly } from "@shivaedev/platform/rpc-server/local.ts";
+import type { Diagnostics } from "#diagnostics/source.ts";
+import type { BoardOptions } from "#server/board.ts";
+import type { boardRuntime } from "#server/boardRuntime.ts";
+import type { HandoffsService } from "#server/handoffs/Service.ts";
+import { navHtml } from "#server/page/nav.ts";
+import { shell } from "#server/page/shell.ts";
+import type { Highlighter } from "#server/render/Highlighter.ts";
+import type { Responses } from "#server/responses/service.ts";
+import { ASSET_HANDLERS, MERMAID_ROUTE, mermaidFile } from "./assets.ts";
+import { attachment } from "./attachment.ts";
+import { identity } from "./identity.ts";
+import { inbox } from "./inbox.ts";
+import { overview } from "./overview.ts";
+import { page } from "./page.ts";
+import { respond } from "./respond.ts";
+import { work } from "./work.ts";
+
+type Services = Highlighter | Responses | HandoffsService | Diagnostics | FileSystem.FileSystem | Path.Path;
+type Handler<E> = (request: HttpServerRequest.HttpServerRequest) => Effect.Effect<HttpServerResponse.HttpServerResponse, E, Services | Scope.Scope>;
+
+export function boardRoutes(options: BoardOptions, runtime: Effect.Success<ReturnType<typeof boardRuntime>>) {
+	return HttpRouter.use((router) =>
+		Effect.gen(function* () {
+			const { changes, context, home, index, mermaid } = runtime;
+			function serve<E>(route: HttpRouter.PathInput, handler: Handler<E>) {
+				return router.add(
+					"GET",
+					route,
+					loopbackOnly((request) => Effect.provideContext(handler(request), context)),
+				);
+			}
+			yield* serve("/_board/attachment/*", attachment(options.root, changes.realRoot));
+			const inboxPage = inbox(index, changes, home);
+			yield* serve("/_board/inbox", inboxPage);
+			const workPage = work(index, changes, home);
+			const overviewPage = overview(index, changes, home);
+			yield* serve("/_board/work", workPage);
+			yield* serve("/_board/overview", overviewPage);
+			for (const [route, asset] of ASSET_HANDLERS) {
+				yield* serve(route, asset);
+			}
+			yield* serve(MERMAID_ROUTE, mermaidFile(mermaid));
+			for (const view of ["changes", "diagnostics", "start", "respond", "handoff", "result"] as const) {
+				yield* serve(`/_board/${view}`, () =>
+					Effect.gen(function* () {
+						const snapshot = yield* index;
+						const nav = navHtml(yield* changes.files, "", home, snapshot);
+						return respond(shell(view, nav, "", changes.realRoot, false, undefined, view === "respond" ? "response" : view, snapshot), "text/html");
+					}),
+				);
+			}
+			const pages = page({ home, root: options.root, writable: options.responses === true }, changes, index);
+			const items = identity(index, pages, changes, home);
+			yield* serve("/_board/item/*", items);
+			yield* serve("/", pages);
+			yield* serve("/*", pages);
+		}),
+	);
+}

package/src/server/http/identity.ts

@@ -0,0 +1,71 @@
+import { Effect } from "effect";
+import type { HttpServerRequest } from "effect/http";
+import { escapeHtml } from "#browser/escapeHtml.ts";
+import { fileUrl } from "#files/url.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 type { page } from "./page.ts";
+import { respond } from "./respond.ts";
+
+function requestedIdentity(pathname: string): string {
+	try {
+		return decodeURIComponent(pathname.slice("/_board/item/".length).replace(/\/$/u, ""));
+	} catch {
+		return "";
+	}
+}
+
+export function identity(
+	index: Effect.Success<ReturnType<typeof searchSnapshot>>,
+	pages: ReturnType<typeof page>,
+	changes: Changes,
+	home: string | undefined,
+) {
+	return Effect.fn("WorkBoard.identity")(function* (request: HttpServerRequest.HttpServerRequest) {
+		const pathname = new URL(request.url, "http://127.0.0.1").pathname;
+		const id = requestedIdentity(pathname);
+		if (!pathname.endsWith("/") && /\.md$/iu.exec(id) !== null) {
+			return yield* pages(request);
+		}
+		const snapshot = yield* index;
+		const matches = snapshot.model.ids.get(id) ?? [];
+		if (snapshot.unavailable.length > 0) {
+			return respond(
+				shell(
+					`Item ${id}`,
+					"",
+					`<p class="empty">The workspace index is incomplete. Could not read ${escapeHtml(snapshot.unavailable.join(", "))}; item identity could not be validated. Retry when the files are readable.</p>`,
+					changes.realRoot,
+					false,
+				),
+				"text/html",
+				503,
+			);
+		}
+		if (matches.length === 1 && matches[0]) {
+			return yield* pages(request, matches[0].file, id);
+		}
+		const text =
+			matches.length > 0
+				? `The ID ${id} is duplicated. No document was selected.`
+				: `No item with ID ${id} is available. It may be missing, renamed, or invalid.`;
+		const choices = matches.map((document) => `<li><a href="${escapeHtml(fileUrl(document.file))}">${escapeHtml(document.file)}</a></li>`).join("");
+		const nav = navHtml(yield* changes.files, "", home, snapshot);
+		return respond(
+			shell(
+				`Item ${id}`,
+				nav,
+				`<p class="empty">${escapeHtml(text)}</p>${choices ? `<ul>${choices}</ul>` : ""}`,
+				changes.realRoot,
+				false,
+				undefined,
+				false,
+				snapshot,
+			),
+			"text/html",
+			matches.length > 0 ? 409 : 404,
+		);
+	});
+}

package/src/server/http/inbox.ts

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

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

@@ -0,0 +1,108 @@
+import { Effect, FileSystem, Option } from "effect";
+import type { HttpServerRequest } from "effect/http";
+import { escapeHtml } from "#browser/escapeHtml.ts";
+import { authoredQuestion } from "#server/attention/inbox.ts";
+import { documentBody } from "#server/document/body.ts";
+import type { Changes } from "#server/files/changes.ts";
+import type { MarkdownFile } from "#server/files/list.ts";
+import { markdownPath } from "#server/files/markdownPath.ts";
+import { metadataModel } from "#server/metadata/model.ts";
+import { metadataParse } from "#server/metadata/parse.ts";
+import { boardHtml } from "#server/page/boardHtml.ts";
+import { documentHtml } from "#server/page/documentHtml.ts";
+import { itemIntroduction } from "#server/page/itemIntroduction.ts";
+import { metadataHtml } from "#server/page/metadata.ts";
+import { navHtml } from "#server/page/nav.ts";
+import { shell } from "#server/page/shell.ts";
+import { boardOf } from "#server/render/board.ts";
+import { authoredQuestionHtml } from "#server/responses/authoredQuestionHtml.ts";
+import { readingActions } from "#server/responses/readingActions.ts";
+import type { searchSnapshot } from "#server/search/snapshot.ts";
+import { respond } from "./respond.ts";
+
+export interface PageOptions {
+	readonly home: string | undefined;
+	readonly root: string;
+	readonly writable?: boolean;
+}
+
+function requestedPath(url: string): string {
+	const pathname = new URL(url, "http://127.0.0.1").pathname.replace(/^\/+/u, "");
+	try {
+		return decodeURIComponent(pathname);
+	} catch {
+		return pathname;
+	}
+}
+
+function message(text: string): string {
+	return `<p class="empty">${escapeHtml(text)}</p>`;
+}
+
+export function page(options: PageOptions, changes: Changes, index: Effect.Success<ReturnType<typeof searchSnapshot>>) {
+	const body = Effect.fn("WorkBoard.body")(function* (file: MarkdownFile, expectedIdentity?: string) {
+		const fs = yield* FileSystem.FileSystem;
+		const real = yield* markdownPath(options.root, changes.realRoot, file.path);
+		if (real === undefined) {
+			return Option.none();
+		}
+		const source = yield* fs.readFileString(real);
+		const parsed = metadataParse(source);
+		let identity: string | undefined;
+		const snapshot = yield* index;
+		const model = metadataModel(
+			[...snapshot.documents.filter((document) => document.file !== file.path), { file: file.path, parsed }],
+			snapshot.unavailable,
+			options.home ?? (yield* changes.files)[0]?.path,
+		);
+		const metadata = metadataHtml(parsed, file.path, model, file.path === options.home);
+		if (snapshot.unavailable.length === 0 && parsed.fields.id && model.ids.get(parsed.fields.id)?.length === 1) {
+			identity = parsed.fields.id;
+		}
+		if (expectedIdentity && identity !== expectedIdentity) {
+			return Option.none();
+		}
+		const actions = yield* readingActions({ file: file.path, parsed }, source, options.writable === true, identity);
+		const prose = documentBody({ file: file.path, parsed });
+		const html =
+			file.path === options.home
+				? yield* boardHtml(boardOf(prose), file.path, file.modified, metadata, actions)
+				: yield* documentHtml(prose, file, metadata, itemIntroduction(parsed), actions);
+		const question = identity && authoredQuestion({ file: file.path, parsed });
+		const answer = question ? yield* authoredQuestionHtml({ file: file.path, parsed }, source, options.writable === true) : "";
+		return Option.some({ html: html + answer, identity });
+	});
+	return Effect.fn("WorkBoard.page")(function* (request: HttpServerRequest.HttpServerRequest, resolved?: string, expectedIdentity?: string) {
+		const files = yield* changes.files;
+		const requested = resolved ?? (requestedPath(request.url) || options.home || files[0]?.path || "");
+		const file = files.find((candidate) => candidate.path === requested);
+		const snapshot = yield* index;
+		const nav = navHtml(files, requested, options.home, snapshot);
+		function layout(content: string, identity?: string) {
+			return shell(requested, nav, content, changes.realRoot, requested === options.home, identity, false, snapshot);
+		}
+		function missing() {
+			return respond(
+				layout(
+					message(
+						expectedIdentity
+							? `No item with ID ${expectedIdentity} at ${requested}; its source identity changed or is invalid.`
+							: `No markdown file at ${requested || options.root}.`,
+					),
+				),
+				"text/html",
+				404,
+			);
+		}
+		if (files.length === 0 && requestedPath(request.url) === "" && resolved === undefined && expectedIdentity === undefined) {
+			return respond(layout('<p class="empty">Start your local workspace. Enable JavaScript to read project and report templates.</p>'), "text/html");
+		}
+		if (file === undefined) {
+			return missing();
+		}
+		return yield* body(file, expectedIdentity).pipe(
+			Effect.map(Option.match({ onNone: missing, onSome: (main) => respond(layout(main.html, main.identity), "text/html") })),
+			Effect.catch(() => Effect.succeed(respond(layout(message(`${file.path} could not be read.`)), "text/html", 500))),
+		);
+	});
+}

package/src/server/http/respond.ts

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

package/src/server/http/rpcPolicy.ts

@@ -0,0 +1,16 @@
+import { Effect } from "effect";
+import { HttpRouter, HttpServerRequest, HttpServerResponse } from "effect/http";
+import { HEADERS } from "./respond.ts";
+
+export const RPC_PATH = "/_board/rpc";
+
+export const rpcPolicy = HttpRouter.middleware(
+	(http) =>
+		Effect.gen(function* () {
+			const request = yield* HttpServerRequest.HttpServerRequest;
+			return yield* request.url.split("?")[0] === RPC_PATH
+				? http.pipe(Effect.map((response) => HttpServerResponse.setHeaders(response, HEADERS)))
+				: http;
+		}),
+	{ global: true },
+);

package/src/server/http/work.ts

@@ -0,0 +1,42 @@
+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/integration/attention.ts

@@ -0,0 +1,9 @@
+import { RequestReceipt as RequestReceiptSchema } from "#attention/RequestReceipt.ts";
+import { managedRequestReceipt } from "#server/attention/managedRequestReceipt.ts";
+
+export type RequestReceipt = typeof RequestReceiptSchema.Type;
+
+export const attention = {
+	managedRequestReceipt,
+	RequestReceipt: RequestReceiptSchema,
+} as const;

package/src/server/integration/board.ts

@@ -0,0 +1,36 @@
+import { type Changes as InternalChanges, watchChanges } from "#server/files/changes.ts";
+import { type MarkdownFile as InternalMarkdownFile, listMarkdown } from "#server/files/list.ts";
+import { markdownPath } from "#server/files/markdownPath.ts";
+import {
+	type MetadataDocument as InternalMetadataDocument,
+	type MetadataModel as InternalMetadataModel,
+	metadataModel,
+} from "#server/metadata/model.ts";
+import { type Diagnostic as InternalDiagnostic, type ParsedMetadata as InternalParsedMetadata, metadataParse } from "#server/metadata/parse.ts";
+import { type Snapshot as InternalSnapshot, searchSnapshot } from "#server/search/snapshot.ts";
+
+export type Changes = InternalChanges;
+export type MarkdownFile = InternalMarkdownFile;
+export type MetadataDocument = InternalMetadataDocument;
+export type MetadataModel = InternalMetadataModel;
+export type Diagnostic = InternalDiagnostic;
+export type ParsedMetadata = InternalParsedMetadata;
+export type Snapshot = InternalSnapshot;
+
+const snapshot: (
+	root: string,
+	home: string | undefined,
+	changes: Changes,
+	maintainer?: string,
+) => Effect.Effect<Effect.Effect<Snapshot, PlatformError.PlatformError, FileSystem.FileSystem | Path.Path>> = searchSnapshot;
+
+export const board = {
+	listMarkdown,
+	markdownPath,
+	metadataModel,
+	metadataParse,
+	searchSnapshot: snapshot,
+	watchChanges,
+} as const;
+
+import type { Effect, FileSystem, Path, PlatformError } from "effect";

package/src/server/integration/diagnostics.ts

@@ -0,0 +1,28 @@
+import { DAEMON_PORT, DAEMON_RPC_PATH, DiagnosticsContract } from "#diagnostics/daemonContract.ts";
+import { CapacityRejection as CapacityRejectionSchema, FLEET_HEALTH_NAME, FleetHealth as FleetHealthSchema } from "#diagnostics/health.ts";
+import type { SourceFailure as SourceFailureType } from "#diagnostics/source.ts";
+import { DiagnosticsSources, diagnostics as readDiagnostics, SourceFailure as SourceFailureClass } from "#diagnostics/source.ts";
+import { codexLimits } from "#server/diagnostics/codexLimits.ts";
+import { codexRateLimits } from "#server/diagnostics/codexRateLimits.ts";
+import { fleetHealth } from "#server/diagnostics/fleetHealth.ts";
+import { githubLimits } from "#server/diagnostics/githubLimits.ts";
+
+export type CapacityRejection = typeof CapacityRejectionSchema.Type;
+export type FleetHealth = typeof FleetHealthSchema.Type;
+export type SourceFailure = SourceFailureType;
+
+export const diagnostics = {
+	CapacityRejection: CapacityRejectionSchema,
+	codexLimits,
+	codexRateLimits,
+	DAEMON_PORT,
+	DAEMON_RPC_PATH,
+	DiagnosticsContract,
+	DiagnosticsSources,
+	diagnostics: readDiagnostics,
+	FLEET_HEALTH_NAME,
+	FleetHealth: FleetHealthSchema,
+	fleetHealth,
+	githubLimits,
+	SourceFailure: SourceFailureClass,
+} as const;

package/src/server/integration/publication.ts

@@ -0,0 +1,6 @@
+import { directoryPath, validateDirectory } from "#server/responses/publicationDirectory.ts";
+
+export const publication = {
+	directoryPath,
+	validateDirectory,
+} as const;

package/src/server/integration/responses.ts

@@ -0,0 +1,36 @@
+import {
+	DraftInput as DraftInputSchema,
+	Question as QuestionSchema,
+	Reading as ReadingSchema,
+	RecordedResponse as RecordedResponseSchema,
+} from "#browser/responses/schema.ts";
+import { currentResponses } from "#responses/current.ts";
+import { makeResponse } from "#server/responses/make.ts";
+import { publish } from "#server/responses/publish.ts";
+import { readResponses } from "#server/responses/read.ts";
+import { questionFrom, questionId, questionMarkdown, responseMarkdown, revisionOf } from "#server/responses/records.ts";
+import { type ResponseOptions as InternalResponseOptions, ResponseConfig, Responses } from "#server/responses/service.ts";
+
+export type ResponseOptions = InternalResponseOptions;
+export type DraftInput = typeof DraftInputSchema.Type;
+export type Question = typeof QuestionSchema.Type;
+export type Reading = typeof ReadingSchema.Type;
+export type RecordedResponse = typeof RecordedResponseSchema.Type;
+
+export const responses = {
+	currentResponses,
+	DraftInput: DraftInputSchema,
+	makeResponse,
+	publish,
+	Question: QuestionSchema,
+	questionFrom,
+	questionId,
+	questionMarkdown,
+	Reading: ReadingSchema,
+	RecordedResponse: RecordedResponseSchema,
+	ResponseConfig,
+	Responses,
+	readResponses,
+	responseMarkdown,
+	revisionOf,
+} as const;