@shivaedev/work-board 0.10.0 → 0.12.0

package/src/server/document/read.ts

@@ -0,0 +1,89 @@
+import { Effect, FileSystem } from "effect";
+import { Conflict, NotFound, ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { Document } from "#browser/document/schema.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 { readingActions } from "#server/responses/readingActions.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+import { documentBody } from "./body.ts";
+import { readingContext } from "./readingContext.ts";
+import { documentRequests } from "./requests.ts";
+import { documentTargets } from "./targets.ts";
+
+export interface DocumentOptions {
+	readonly changes: Changes;
+	readonly home: string | undefined;
+	readonly index: Effect.Effect<Snapshot, unknown>;
+	readonly root: string;
+	readonly writable: boolean;
+}
+
+const selected = Effect.fn("WorkBoard.selected")(function* (
+	url: string,
+	snapshot: Snapshot,
+	files: readonly MarkdownFile[],
+	home: string | undefined,
+) {
+	const pathname = new URL(url, "http://127.0.0.1").pathname;
+	const requested = decodeURIComponent(pathname.slice(1));
+	const item = /^_board\/item\/(?<id>[^/]+)\/$/u.exec(requested)?.groups?.id;
+	if (item && snapshot.unavailable.length > 0) {
+		return yield* Effect.fail(new ServiceUnavailable({ message: "Document sources are unavailable." }));
+	}
+	const matches = item ? snapshot.model.ids.get(item) : undefined;
+	if (matches && matches.length > 1) {
+		return yield* Effect.fail(new Conflict({ message: "The document identity is ambiguous." }));
+	}
+	const path = item ? matches?.[0]?.file : requested || home || files[0]?.path;
+	const file = files.find((candidate) => candidate.path === path);
+	if (!file) {
+		return yield* Effect.fail(new NotFound({ message: "The document is missing." }));
+	}
+	return { file, item };
+});
+
+export function readDocument({ changes, home, index, root, writable }: DocumentOptions) {
+	return Effect.fn("WorkBoard.document")(function* (url: string) {
+		const snapshot = yield* index;
+		const files = yield* changes.files;
+		const { file, item } = yield* selected(url, snapshot, files, home);
+		const real = yield* markdownPath(root, changes.realRoot, file.path);
+		if (!real) {
+			return yield* Effect.fail(new NotFound({ message: "The document is missing." }));
+		}
+		const fs = yield* FileSystem.FileSystem;
+		const source = yield* fs.readFileString(real);
+		const parsed = metadataParse(source);
+		const document = { file: file.path, parsed };
+		const documents = [...snapshot.documents.filter((entry) => entry.file !== file.path), document];
+		const model = metadataModel(documents, snapshot.unavailable, home ?? files[0]?.path);
+		const id = parsed.fields.id;
+		const identity = id && snapshot.unavailable.length === 0 && model.ids.get(id)?.length === 1 ? id : undefined;
+		if (item && identity !== item) {
+			return yield* Effect.fail(new NotFound({ message: "The document is missing." }));
+		}
+		const questionActions = yield* readingActions(document, source, writable, identity);
+		const reading = readingContext(document, model, file.path === home);
+		return {
+			...documentTargets(
+				document,
+				model,
+				Object.values(reading.receipts).map((receipt) => receipt.question),
+			),
+			diagnostics: model.diagnostics.get(file.path) ?? parsed.diagnostics,
+			file: file.path,
+			...(identity ? { identity } : {}),
+			metadata: parsed.fields,
+			modified: file.modified,
+			questionActions: Object.fromEntries(questionActions ?? []),
+			reading,
+			requests: documentRequests(document, source, { ...snapshot, documents, model }),
+			source: documentBody(document),
+			unavailable: snapshot.unavailable,
+			writable,
+		} satisfies Document;
+	});
+}

package/src/server/document/readingContext.ts

@@ -0,0 +1,61 @@
+import { managedRequestReceipt } from "#server/attention/managedRequestReceipt.ts";
+import { backlinksOf } from "#server/metadata/backlinks.ts";
+import { referenceTarget } from "#server/metadata/links.ts";
+import type { MetadataDocument, MetadataModel } from "#server/metadata/model.ts";
+import { relationshipLabel } from "#server/metadata/relationshipLabel.ts";
+import { sourceFile, sourceHref } from "#server/metadata/sourceLinks.ts";
+import { documentReference } from "#server/page/metadataLinks.ts";
+
+export function readingContext(document: MetadataDocument, model: MetadataModel, board: boolean) {
+	const { fields, lines, raw, bodyLine } = document.parsed;
+	const backlinks = [...new Map(backlinksOf(document.file, model).map((link) => [`${link.file}:${link.kind}:${link.line ?? ""}`, link])).values()];
+	return {
+		backlinks: backlinks.map((link) => ({
+			href: documentReference(link.file, model),
+			kind: relationshipLabel(link.kind),
+			label: link.file + (link.line === undefined ? "" : `:${link.line}`),
+		})),
+		board,
+		claims: criterionClaims(document, model),
+		evidenceSources: (fields.evidence ?? []).map((entry) => {
+			const href = sourceHref(entry.source, document.file);
+			const target = sourceFile(entry.source, document.file, model);
+			const missing = target && !model.documents.some((candidate) => candidate.file === target);
+			return {
+				...(href ? { href } : {}),
+				problem: sourceProblem(target, Boolean(missing), model),
+			};
+		}),
+		lines,
+		proseLine: bodyLine,
+		...(raw === undefined ? {} : { raw }),
+		receipts: Object.fromEntries(
+			(fields.attention ?? []).flatMap((request) => {
+				const receipt = managedRequestReceipt(document, request, model);
+				return receipt && referenceTarget(receipt.question, model) ? [[request.id, receipt]] : [];
+			}),
+		),
+	};
+}
+
+function sourceProblem(target: string | undefined, missing: boolean, model: MetadataModel): string {
+	if (!(missing && target)) {
+		return "";
+	}
+	return model.unavailable.includes(target) ? " (source unavailable)" : " (missing Markdown source)";
+}
+function criterionClaims(document: MetadataDocument, model: MetadataModel) {
+	const claims = model.documents.flatMap((entry) =>
+		(entry.parsed.fields.evidence ?? []).map((claim, index) => ({
+			criterion: claim.criterion,
+			href: documentReference(entry.file, model, `#recorded-evidence-${index}`),
+			label: entry.file + (entry.parsed.lines[`evidence.${index}.source`] === undefined ? "" : `:${entry.parsed.lines[`evidence.${index}.source`]}`),
+		})),
+	);
+	return Object.fromEntries(
+		(document.parsed.fields.criteria ?? []).map((criterion) => [
+			criterion.id,
+			claims.filter((claim) => claim.criterion === `${document.parsed.fields.id}#${criterion.id}`).map(({ href, label }) => ({ href, label })),
+		]),
+	);
+}

package/src/server/document/requests.ts

@@ -0,0 +1,46 @@
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import type { DocumentRequest } from "#browser/document/schema.ts";
+import { authoredQuestion } from "#server/attention/inbox.ts";
+import type { MetadataDocument } from "#server/metadata/model.ts";
+import { responseHistory } from "#server/responses/history.ts";
+import { questionId, revisionOf } from "#server/responses/records.ts";
+import { requestSource } from "#server/responses/requestSource.ts";
+import { questionTemplate } from "#server/responses/template.ts";
+import type { Snapshot } from "#server/search/snapshot.ts";
+
+export function documentRequests(document: MetadataDocument, source: string, snapshot: Snapshot): readonly DocumentRequest[] {
+	const item = document.parsed.fields.id;
+	if (!item) {
+		return [];
+	}
+	const ids = [
+		...new Set([...(document.parsed.fields.attention?.map((request) => request.id) ?? []), ...(authoredQuestion(document) ? ["answer"] : [])]),
+	];
+	const reviewedRevision = revisionOf(source);
+	return ids.map((id) => {
+		const active = requestSource(snapshot, item, id);
+		const preview = {
+			context: source,
+			id: questionId(item, id, reviewedRevision, document.file),
+			item,
+			reason: active?.reason ?? document.parsed.fields.attention?.find((entry) => entry.id === id)?.reason ?? "A question needs your answer",
+			request: id,
+			reviewedRevision,
+			source: document.file,
+		};
+		const request = { id, open: active !== undefined, ...(active ? { preview } : {}) };
+		try {
+			if (snapshot.model.ids.get(item)?.length !== 1) {
+				throw new ServiceUnavailable({ message: "Item identity is ambiguous; response history is unknown. Give each item a unique ID, then retry." });
+			}
+			const responses = responseHistory(snapshot, preview);
+			try {
+				return { ...request, prompts: questionTemplate(source, id, document.file).prompts, responses };
+			} catch (error) {
+				return { ...request, promptUnavailable: error instanceof Error ? error.message : String(error), responses };
+			}
+		} catch (error) {
+			return { ...request, unavailable: error instanceof Error ? error.message : String(error) };
+		}
+	});
+}

package/src/server/document/targets.ts

@@ -0,0 +1,29 @@
+import type { Root } from "mdast";
+import remarkDirective from "remark-directive";
+import remarkGfm from "remark-gfm";
+import remarkParse from "remark-parse";
+import { unified } from "unified";
+import { visit } from "unist-util-visit";
+import { resolveDocumentLink } from "#render/documentLinks.ts";
+import { referenceTarget } from "#server/metadata/links.ts";
+import type { MetadataDocument, MetadataModel } from "#server/metadata/model.ts";
+import { referencesOf } from "#server/metadata/referencesOf.ts";
+
+export function documentTargets(document: MetadataDocument, model: MetadataModel, additional: readonly string[] = []) {
+	const urls = new Set(document.links);
+	const tree: Root = unified().use(remarkParse).use(remarkGfm).use(remarkDirective).parse(document.parsed.body);
+	visit(tree, (node) => {
+		if (node.type === "link" || node.type === "image" || node.type === "definition") {
+			urls.add(node.url);
+		}
+	});
+	return {
+		links: Object.fromEntries([...urls].map((url) => [url, resolveDocumentLink(url, document.file)])),
+		references: Object.fromEntries(
+			[...referencesOf(document).map(({ target }) => target), ...additional].flatMap((target) => {
+				const href = referenceTarget(target, model);
+				return href ? [[target, href]] : [];
+			}),
+		),
+	};
+}

package/src/server/files/changes.ts

@@ -0,0 +1,110 @@
+import { Deferred, Effect, FileSystem, Option, Path, type PlatformError, PubSub, Ref, Schedule } from "effect";
+import { registerInvalidations, trackInvalidations } from "./invalidations.ts";
+import type { MarkdownFile } from "./list.ts";
+import { updateFiles } from "./update.ts";
+import { watchDirectories } from "./watchDirectories.ts";
+
+export type Change = ({ readonly _tag: "Changed"; readonly paths: readonly string[] } | { readonly _tag: "Watching"; readonly watching: boolean }) & {
+	readonly sequence?: number;
+};
+
+export interface Changes {
+	readonly events: PubSub.PubSub<Change>;
+	readonly files: Effect.Effect<readonly MarkdownFile[], PlatformError.PlatformError>;
+	readonly realRoot: string;
+	readonly refresh?: Effect.Effect<void>;
+	readonly revision: Effect.Effect<number>;
+	readonly sequence?: Effect.Effect<number>;
+	readonly watching: Ref.Ref<boolean>;
+}
+
+interface Cached {
+	readonly files: readonly MarkdownFile[];
+	readonly generation: number;
+}
+
+const BACKLOG = 16;
+const RETRY = Schedule.min([Schedule.exponential("100 millis"), Schedule.spaced("5 seconds")]);
+
+export const watchChanges = Effect.fn("WorkBoard.watchChanges")(function* (root: string) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const realRoot = yield* fs.realPath(root);
+	const events = yield* Effect.acquireRelease(PubSub.sliding<Change>(BACKLOG), PubSub.shutdown);
+	const watching = yield* Ref.make(false);
+	const generation = yield* Ref.make(0);
+	const sequence = yield* Ref.make(0);
+	function publish(change: Change) {
+		return Effect.flatMap(
+			Ref.updateAndGet(sequence, (value) => value + 1),
+			(value) => PubSub.publish(events, { ...change, sequence: value }),
+		);
+	}
+	const cached = yield* Ref.make(Option.none<Cached>());
+	const settled = yield* Deferred.make<void>();
+	let pending: Deferred.Deferred<void> | undefined;
+	const observed = Effect.gen(function* () {
+		if (pending === undefined) {
+			pending = yield* Deferred.make<void>();
+		}
+	});
+	const finishPending = Effect.suspend(() => {
+		const done = pending;
+		pending = undefined;
+		return done ? Deferred.succeed(done, undefined) : Effect.void;
+	});
+	const invalidations = trackInvalidations();
+	function invalidate(paths?: readonly string[]) {
+		return Ref.update(generation, (count) => {
+			invalidations.record(count + 1, paths);
+			return count + 1;
+		});
+	}
+	const stale = invalidate();
+	function setWatching(now: boolean) {
+		return Effect.andThen(
+			Effect.flatMap(Ref.getAndSet(watching, now), (was) =>
+				was === now ? Effect.void : Effect.andThen(stale, publish({ _tag: "Watching", watching: now })),
+			),
+			Effect.andThen(finishPending, Deferred.succeed(settled, undefined)),
+		);
+	}
+	const attempt = watchDirectories(
+		root,
+		realRoot,
+		stale,
+		setWatching,
+		(paths) => Effect.andThen(invalidate(paths), Effect.andThen(finishPending, publish({ _tag: "Changed", paths }))),
+		observed,
+	);
+	yield* attempt.pipe(
+		Effect.sandbox,
+		Effect.tapError((cause) => Effect.andThen(setWatching(false), Effect.logWarning("Watching the folder failed; retrying", cause))),
+		Effect.retry(RETRY),
+		Effect.forkScoped,
+	);
+	yield* Deferred.await(settled);
+	const files = Effect.gen(function* () {
+		let waiting = pending;
+		while (waiting) {
+			yield* Deferred.await(waiting);
+			waiting = pending;
+		}
+		const now = yield* Ref.get(generation);
+		const hit = Option.filter(yield* Ref.get(cached), (entry) => entry.generation === now);
+		if ((yield* Ref.get(watching)) && Option.isSome(hit)) {
+			return hit.value.files;
+		}
+		const previous = yield* Ref.get(cached);
+		const dirty = Option.isSome(previous) && (yield* Ref.get(watching)) ? invalidations.since(previous.value.generation) : undefined;
+		const listed = yield* updateFiles(root, realRoot, Option.isSome(previous) ? previous.value.files : [], dirty).pipe(
+			Effect.provideService(FileSystem.FileSystem, fs),
+			Effect.provideService(Path.Path, path),
+		);
+		yield* Ref.set(cached, Option.some({ files: listed, generation: now }));
+		return listed;
+	});
+	const changes: Changes = { events, files, realRoot, refresh: stale, revision: Ref.get(generation), sequence: Ref.get(sequence), watching };
+	registerInvalidations(changes, invalidations);
+	return changes;
+});

package/src/server/files/home.ts

@@ -0,0 +1,46 @@
+import { Effect, FileSystem, Option, Path, Schema } from "effect";
+import { listMarkdown } from "./list.ts";
+
+export class HomeMissing extends Schema.TaggedError<HomeMissing>()("HomeMissing", { message: Schema.String }) {}
+
+export const homeIn = Effect.fn("WorkBoard.homeIn")(function* (root: string, home: string | undefined) {
+	if (home === undefined) {
+		return undefined;
+	}
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const missing = new HomeMissing({
+		message: `The home file ${home} is not a markdown file in ${root}. Choose an existing Markdown file with --home.`,
+	});
+	const realRoot = yield* fs.realPath(root);
+	const real = yield* Effect.option(fs.realPath(path.resolve(root, home)));
+	if (Option.isNone(real)) {
+		return yield* missing;
+	}
+	const target = yield* Effect.option(fs.stat(real.value));
+	if (Option.isNone(target)) {
+		return yield* missing;
+	}
+	const files = yield* listMarkdown(root, realRoot);
+	const logical = path.relative(root, path.resolve(root, home)).split(path.sep).join("/");
+	if (files.some((file) => file.path === logical)) {
+		return logical;
+	}
+	const relative = path.relative(realRoot, real.value).split(path.sep).join("/");
+	if (files.some((file) => file.path === relative)) {
+		return relative;
+	}
+	const info = target.value;
+	const inode = Option.getOrUndefined(info.ino);
+	function same(candidate: FileSystem.File.Info) {
+		return inode !== undefined && candidate.dev === info.dev && Option.getOrUndefined(candidate.ino) === inode;
+	}
+	const matches = yield* Effect.filter(files, (file) =>
+		Effect.map(Effect.option(fs.stat(path.join(realRoot, file.path))), (status) => Option.isSome(status) && same(status.value)),
+	);
+	const direct = yield* Effect.filter(matches, (file) =>
+		Effect.map(Effect.option(fs.realPath(path.join(realRoot, file.path))), (resolved) => Option.contains(resolved, path.join(realRoot, file.path))),
+	);
+	const chosen = matches.find((file) => file.path.toLowerCase() === relative.toLowerCase()) ?? direct[0] ?? matches[0];
+	return chosen === undefined ? yield* missing : chosen.path;
+});

package/src/server/files/invalidations.ts

@@ -0,0 +1,32 @@
+import type { Changes } from "./changes.ts";
+
+const trackers = new WeakMap<Changes, ReturnType<typeof trackInvalidations>>();
+const LIMIT = 4096;
+
+export function trackInvalidations() {
+	let uncertain = 0;
+	const paths = new Map<string, number>();
+	return {
+		record(revision: number, changed?: readonly string[]) {
+			if (changed === undefined || paths.size + changed.length > LIMIT) {
+				uncertain = revision;
+				paths.clear();
+			} else {
+				for (const path of changed) {
+					paths.set(path, revision);
+				}
+			}
+		},
+		since(revision: number): ReadonlySet<string> | undefined {
+			return revision < uncertain ? undefined : new Set([...paths].filter(([, changed]) => changed > revision).map(([path]) => path));
+		},
+	};
+}
+
+export function registerInvalidations(changes: Changes, tracker: ReturnType<typeof trackInvalidations>) {
+	trackers.set(changes, tracker);
+}
+
+export function invalidationsSince(changes: Changes, revision: number): ReadonlySet<string> | undefined {
+	return trackers.get(changes)?.since(revision);
+}

package/src/server/files/list.ts

@@ -0,0 +1,75 @@
+import { Effect, FileSystem, Option, Path, type PlatformError } from "effect";
+import { isMarkdown as markdown } from "#path/isMarkdown.ts";
+
+export interface MarkdownFile {
+	readonly modified: number;
+	readonly path: string;
+}
+
+export function isMarkdown(path: string): boolean {
+	return markdown(path);
+}
+
+export function within(realRoot: string, separator: string, real: string): boolean {
+	return real === realRoot || real.startsWith(`${realRoot}${separator}`);
+}
+
+function folderOf(path: string): string {
+	return path.slice(0, Math.max(0, path.lastIndexOf("/")));
+}
+
+export function byFolder(left: string, right: string): number {
+	return folderOf(left).localeCompare(folderOf(right)) || left.localeCompare(right);
+}
+
+type Listing = Effect.Effect<readonly MarkdownFile[], PlatformError.PlatformError>;
+
+export const scanMarkdown = Effect.fn("WorkBoard.scanMarkdown")(function* (root: string, realRoot: string) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const roots: Array<{ readonly real: string; readonly relative: string }> = [{ real: realRoot, relative: "" }];
+	function entry(relative: string, boundary: string, ancestors: ReadonlySet<string>, parent: string): Listing {
+		return Effect.gen(function* () {
+			const real = yield* Effect.option(fs.realPath(path.join(root, relative)));
+			if (Option.isNone(real)) {
+				return [];
+			}
+			const info = yield* Effect.option(fs.stat(real.value));
+			if (Option.isNone(info)) {
+				return [];
+			}
+			if (info.value.type === "Directory") {
+				return yield* directory(relative, real.value, boundary, ancestors, real.value !== path.join(parent, path.basename(relative)));
+			}
+			const modified = Option.match(info.value.mtime, { onNone: () => 0, onSome: (date) => date.getTime() });
+			return info.value.type === "File" && relative.endsWith(".md") && within(boundary, path.sep, real.value) ? [{ modified, path: relative }] : [];
+		});
+	}
+	function directory(relative: string, real: string, boundary: string, ancestors: ReadonlySet<string>, alias: boolean): Listing {
+		if (ancestors.has(real) || within(real, path.sep, realRoot)) {
+			return Effect.succeed([]);
+		}
+		const linked = !within(boundary, path.sep, real);
+		if (alias) {
+			roots.push({ real, relative });
+		}
+		return Effect.orElseSucceed(folder(relative, real, linked ? real : boundary, ancestors), () => []);
+	}
+	function folder(relative: string, real: string, boundary: string, ancestors: ReadonlySet<string>): Listing {
+		return Effect.gen(function* () {
+			const branch = new Set([...ancestors, real]);
+			const names = yield* fs.readDirectory(real);
+			const found = yield* Effect.forEach(
+				names.filter((name) => !name.startsWith(".") && name !== "node_modules"),
+				(name) => entry(relative === "" ? name : `${relative}/${name}`, boundary, branch, real),
+			);
+			return found.flat();
+		});
+	}
+	const files = yield* folder("", realRoot, realRoot, new Set());
+	return { files: files.toSorted((left, right) => byFolder(left.path, right.path)), roots };
+});
+
+export const listMarkdown = Effect.fn("WorkBoard.listMarkdown")(function* (root: string, realRoot: string) {
+	return (yield* scanMarkdown(root, realRoot)).files;
+});

package/src/server/files/update.ts

@@ -0,0 +1,52 @@
+import { Effect, FileSystem, Option } from "effect";
+import { attachmentType } from "#path/attachment.ts";
+import { byFolder, isMarkdown, listMarkdown, type MarkdownFile } from "./list.ts";
+import { markdownPath } from "./markdownPath.ts";
+
+export const updateFiles = Effect.fn("WorkBoard.updateFiles")(function* (
+	root: string,
+	realRoot: string,
+	previous: readonly MarkdownFile[],
+	paths: ReadonlySet<string> | undefined,
+) {
+	const fs = yield* FileSystem.FileSystem;
+	// Root disappearance must reach callers as a filesystem failure.
+	yield* fs.stat(realRoot);
+	if (
+		paths === undefined
+		|| [...paths].some(
+			(path) => (!isMarkdown(path) && attachmentType(path) === undefined) || previous.some((file) => file.path.startsWith(`${path}/`)),
+		)
+	) {
+		return yield* listMarkdown(root, realRoot);
+	}
+	const files = new Map(previous.map((file) => [file.path, file]));
+	for (const file of paths) {
+		if (!isMarkdown(file)) {
+			continue;
+		}
+		const found = yield* Effect.option(
+			Effect.gen(function* () {
+				const real = yield* markdownPath(root, realRoot, file);
+				if (!real) {
+					return undefined;
+				}
+				const info = yield* fs.stat(real);
+				if (info.type === "Directory") {
+					return "directory";
+				}
+				return info.type === "File"
+					? { modified: Option.match(info.mtime, { onNone: () => 0, onSome: (date) => date.getTime() }), path: file }
+					: undefined;
+			}),
+		);
+		files.delete(file);
+		if (Option.isSome(found) && found.value === "directory") {
+			return yield* listMarkdown(root, realRoot);
+		}
+		if (Option.isSome(found) && found.value && typeof found.value !== "string") {
+			files.set(file, found.value);
+		}
+	}
+	return [...files.values()].toSorted((left, right) => byFolder(left.path, right.path));
+});

package/src/server/files/watchDirectories.ts

@@ -0,0 +1,79 @@
+import { Deferred, Effect, FileSystem, Option, Path, Stream } from "effect";
+import { ServiceUnavailable } from "@shivaedev/platform/errors/taxonomy.ts";
+import { attachmentType } from "#path/attachment.ts";
+import { isMarkdown, scanMarkdown } from "./list.ts";
+
+const SETTLE = "100 millis";
+
+export const watchDirectories = Effect.fn("WorkBoard.watchDirectories")(function* (
+	root: string,
+	realRoot: string,
+	stale: Effect.Effect<void>,
+	setWatching: (watching: boolean) => Effect.Effect<unknown>,
+	publish: (paths: readonly string[]) => Effect.Effect<unknown>,
+	observed: Effect.Effect<void> = Effect.void,
+) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = yield* Path.Path;
+	const cycle = Effect.scoped(
+		Effect.gen(function* () {
+			const { roots } = yield* scanMarkdown(root, realRoot);
+			const topology = yield* Deferred.make<void>();
+			// Node's recursive watcher can miss replacement of directory symlinks.
+			const parents = yield* Effect.forEach(
+				roots.filter((folder) => folder.relative !== ""),
+				(folder) =>
+					Effect.map(fs.realPath(path.dirname(path.join(root, folder.relative))), (real) => ({ real, relative: path.dirname(folder.relative) })),
+			);
+			const watched = [...roots.map((folder) => ({ ...folder, recursive: true })), ...parents.map((folder) => ({ ...folder, recursive: false }))];
+			const streams = watched.map((folder) =>
+				fs.watch(folder.real, { recursive: folder.recursive }).pipe(
+					Stream.map((event) => {
+						const local = path.isAbsolute(event.path) ? path.relative(folder.real, event.path) : event.path;
+						return path.join(folder.relative, local).split(path.sep).join("/");
+					}),
+				),
+			);
+			const pending = new Set<string>();
+			const watch = Stream.mergeAll(streams, { concurrency: "unbounded" }).pipe(
+				Stream.tap((relative) => (isMarkdown(relative) || attachmentType(relative) !== undefined ? observed : Effect.void)),
+				Stream.tap((relative) =>
+					Effect.gen(function* () {
+						const info = yield* Effect.option(fs.stat(path.join(root, relative)));
+						const removedLink = roots.some((folder) => folder.relative === relative || folder.relative.startsWith(`${relative}/`));
+						if (Option.match(info, { onNone: () => removedLink, onSome: (value) => value.type === "Directory" })) {
+							yield* stale;
+							yield* Effect.forkScoped(Effect.delay(Deferred.succeed(topology, undefined), SETTLE));
+						}
+					}),
+				),
+				Stream.filter((relative) => isMarkdown(relative) || attachmentType(relative) !== undefined),
+				Stream.tap((relative) =>
+					Effect.sync(() => {
+						pending.add(relative);
+					}),
+				),
+				Stream.interruptWhen(Deferred.await(topology)),
+				Stream.debounce(SETTLE),
+				Stream.runForEach(() =>
+					Effect.suspend(() => {
+						const paths = [...pending];
+						pending.clear();
+						return publish(paths);
+					}),
+				),
+				Effect.andThen(
+					Effect.flatMap(Deferred.isDone(topology), (changed) =>
+						changed
+							? Effect.void
+							: Effect.fail(new ServiceUnavailable({ message: "The workspace watcher ended. Retrying the watch automatically." })),
+					),
+				),
+			);
+			yield* Effect.forkScoped(Effect.delay(setWatching(true), SETTLE));
+			yield* watch;
+			yield* setWatching(false);
+		}),
+	);
+	yield* Effect.forever(cycle);
+});