semantifold 0.8.0 → 0.10.0

package/build/src/project-watch.js

@@ -0,0 +1,839 @@
+// @ts-check
+import { watch as watchFileSystem } from "node:fs";
+import { lstat } from "node:fs/promises";
+import path from "node:path";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { buildWatchedProject, ProjectBuilder } from "./project-build.js";
+import { ProjectManifestLoader, SemantifoldProject } from "./project-manifest.js";
+import { ProjectSnapshot, ProjectSnapshotBuilder } from "./project-snapshot.js";
+import { ProjectWatchReporter } from "./project-watch-reporter.js";
+const defaultQuietPeriodMs = 50;
+const defaultPollIntervalMs = 1000;
+const maximumQuietPeriodMs = 10_000;
+const maximumPollIntervalMs = 60_000;
+/** @type {WeakMap<ProjectWatchCoordinator, (event: ProjectWatchObservation) => void>} */
+const projectWatchObservers = new WeakMap();
+/** @type {WeakMap<ProjectWatchCoordinator, typeof watchFileSystem>} */
+const projectWatchNativeBackends = new WeakMap();
+/** @type {WeakMap<ProjectWatchCoordinator, ProjectWatchStateReader>} */
+const projectWatchStateReaders = new WeakMap();
+/**
+ * Installs a synchronous lifecycle observer for focused coordination specs.
+ * This helper is intentionally not part of the package root API.
+ * @param {ProjectWatchCoordinator} coordinator - Coordinator instance.
+ * @param {(event: ProjectWatchObservation) => void} observer - Marker observer.
+ * @returns {void}
+ */
+export function observeProjectWatch(coordinator, observer) {
+    if (!(coordinator instanceof ProjectWatchCoordinator) || typeof observer != "function") {
+        throw new TypeError("Invalid project watch observer.");
+    }
+    projectWatchObservers.set(coordinator, observer);
+}
+/**
+ * Creates a coordinator with one instance-owned native event backend for focused fallback specs.
+ * This helper is intentionally not part of the package root API.
+ * @param {{builder?: ProjectBuilder, manifestLoader?: ProjectManifestLoader, nativeWatch: typeof watchFileSystem, pollIntervalMs?: number, quietPeriodMs?: number, snapshotBuilder?: ProjectSnapshotBuilder, watchStateReader?: ProjectWatchStateReader}} options - Coordinator options and backends.
+ * @returns {ProjectWatchCoordinator} Configured coordinator.
+ */
+export function createProjectWatchCoordinator(options) {
+    if (!isPlainObject(options) || typeof options.nativeWatch != "function" ||
+        options.watchStateReader !== undefined && typeof options.watchStateReader != "function") {
+        throw new TypeError("Invalid project watch coordinator dependencies.");
+    }
+    const coordinator = new ProjectWatchCoordinator({
+        ...(options.builder === undefined ? {} : { builder: options.builder }),
+        ...(options.manifestLoader === undefined ? {} : { manifestLoader: options.manifestLoader }),
+        ...(options.pollIntervalMs === undefined ? {} : { pollIntervalMs: options.pollIntervalMs }),
+        ...(options.quietPeriodMs === undefined ? {} : { quietPeriodMs: options.quietPeriodMs }),
+        ...(options.snapshotBuilder === undefined ? {} : { snapshotBuilder: options.snapshotBuilder })
+    });
+    projectWatchNativeBackends.set(coordinator, options.nativeWatch);
+    if (options.watchStateReader !== undefined)
+        projectWatchStateReaders.set(coordinator, options.watchStateReader);
+    return coordinator;
+}
+/**
+ * Turns filesystem hints into serialized complete project build transactions.
+ */
+export class ProjectWatchCoordinator {
+    /** @type {ProjectBuilder} */
+    #builder;
+    /** @type {ProjectManifestLoader} */
+    #manifestLoader;
+    /** @type {ProjectSnapshotBuilder} */
+    #snapshotBuilder;
+    #quietPeriodMs;
+    #pollIntervalMs;
+    /** @type {ProjectWatchReporter | undefined} */
+    #reporter;
+    /** @type {string | undefined} */
+    #manifestPath;
+    /** @type {SemantifoldProject | undefined} */
+    #project;
+    /** @type {string | undefined} */
+    #publicationRoot;
+    /** @type {ProjectSnapshot | undefined} */
+    #lastSnapshot;
+    /** @type {string | undefined} */
+    #suppressedHash;
+    /** @type {string | undefined} */
+    #suppressedInvalidState;
+    /** @type {Map<string, string>} */
+    #watchStates = new Map();
+    /** @type {Set<string>} */
+    #watchedPaths = new Set();
+    /** @type {Map<string, string>} */
+    #displayPaths = new Map();
+    /** @type {import("node:fs").FSWatcher[]} */
+    #subscriptions = [];
+    /** @type {ReturnType<typeof setTimeout> | undefined} */
+    #quietTimer;
+    /** @type {ReturnType<typeof setInterval> | undefined} */
+    #pollTimer;
+    #polling = false;
+    #pollActive = false;
+    #pollFailed = false;
+    #cycle = 0;
+    #hintVersion = 0;
+    #dirty = false;
+    #cycleDirtyReported = false;
+    #commitWindow = false;
+    #hadFailure = false;
+    #running = false;
+    #stopping = false;
+    #finished = false;
+    #initialCycle = true;
+    #stopReason = "watch stopped";
+    /** @type {Set<string>} */
+    #hintPaths = new Set();
+    /** @type {AbortController | undefined} */
+    #activeController;
+    /** @type {AbortController | undefined} */
+    #publicationController;
+    /** @type {Promise<void> | undefined} */
+    #activeCycle;
+    /** @type {Promise<void> | undefined} */
+    #startup;
+    /** @type {Promise<Readonly<ProjectWatchResult>> | undefined} */
+    #completion;
+    /**
+     * Resolves the sole run completion.
+     * @type {(result: Readonly<ProjectWatchResult>) => void}
+     */
+    #resolveCompletion = () => { };
+    /** @type {() => void} */
+    #signalHandler;
+    /**
+     * Creates one idle coordinator without touching the filesystem.
+     * @param {{builder?: ProjectBuilder, manifestLoader?: ProjectManifestLoader, pollIntervalMs?: number, quietPeriodMs?: number, snapshotBuilder?: ProjectSnapshotBuilder}} [options] - Collaborators and bounded timing policy.
+     */
+    constructor(options = {}) {
+        if (!isPlainObject(options) || Object.keys(options).some(key => !["builder", "manifestLoader", "pollIntervalMs", "quietPeriodMs", "snapshotBuilder"].includes(key)) ||
+            options.builder !== undefined && !(options.builder instanceof ProjectBuilder) ||
+            options.manifestLoader !== undefined && !(options.manifestLoader instanceof ProjectManifestLoader) ||
+            options.snapshotBuilder !== undefined && !(options.snapshotBuilder instanceof ProjectSnapshotBuilder)) {
+            throw new TypeError("Invalid project watch coordinator options.");
+        }
+        const quietPeriodMs = options.quietPeriodMs ?? defaultQuietPeriodMs;
+        const pollIntervalMs = options.pollIntervalMs ?? defaultPollIntervalMs;
+        if (!validMilliseconds(quietPeriodMs, maximumQuietPeriodMs) || !validMilliseconds(pollIntervalMs, maximumPollIntervalMs)) {
+            throw new TypeError("Project watch timing values must be bounded positive integer milliseconds.");
+        }
+        this.#builder = options.builder ?? new ProjectBuilder();
+        this.#manifestLoader = options.manifestLoader ?? new ProjectManifestLoader();
+        this.#snapshotBuilder = options.snapshotBuilder ?? new ProjectSnapshotBuilder();
+        this.#quietPeriodMs = quietPeriodMs;
+        this.#pollIntervalMs = pollIntervalMs;
+        this.#signalHandler = () => {
+            void this.stop("termination signal");
+        };
+    }
+    /**
+     * Starts the initial build and remains active until shutdown or startup failure.
+     * @param {string} [projectPath] - Project manifest path.
+     * @param {ProjectWatchReporter} [reporter] - Watch protocol reporter.
+     * @param {{check?: boolean}} [options] - Whether every cycle runs target-owned checks.
+     * @returns {Promise<Readonly<ProjectWatchResult>>} Terminal watcher result.
+     */
+    run(projectPath = "./semantifold.json", reporter = new ProjectWatchReporter(), options = {}) {
+        if (this.#running || this.#completion !== undefined || typeof projectPath != "string" || projectPath.length == 0 ||
+            !(reporter instanceof ProjectWatchReporter) || !isPlainObject(options) ||
+            Object.keys(options).some(key => key != "check") || options.check !== undefined && typeof options.check != "boolean") {
+            throw new TypeError("Invalid or repeated project watch run.");
+        }
+        this.#running = true;
+        this.#reporter = reporter;
+        this.#manifestPath = projectPath;
+        this.#check = options.check === true;
+        this.#completion = new Promise(resolve => {
+            this.#resolveCompletion = resolve;
+        });
+        process.once("SIGINT", this.#signalHandler);
+        process.once("SIGTERM", this.#signalHandler);
+        const startup = this.#start(this.#check);
+        this.#startup = startup;
+        const startupSettled = () => {
+            if (this.#startup === startup)
+                this.#startup = undefined;
+            this.#finishStoppedIfIdle();
+        };
+        void startup.then(startupSettled, startupSettled);
+        return this.#completion;
+    }
+    /**
+     * Stops admitting work, cancels the exact active operation, and waits through child close and staging cleanup.
+     * @param {string} [reason] - Stable shutdown reason.
+     * @returns {Promise<Readonly<ProjectWatchResult>>} Terminal watcher result.
+     */
+    async stop(reason = "shutdown requested") {
+        if (typeof reason != "string" || reason.length == 0)
+            throw new TypeError("Project watch stop reason must be non-empty.");
+        if (this.#completion === undefined)
+            throw new TypeError("Project watch coordinator has not started.");
+        if (!this.#stopping && !this.#finished) {
+            this.#stopping = true;
+            this.#stopReason = reason;
+            this.#closeEventBackends();
+            this.#activeController?.abort(reason);
+            this.#publicationController?.abort(reason);
+            this.#finishStoppedIfIdle();
+        }
+        return this.#completion;
+    }
+    /**
+     * Establishes the validated graph, event backend, and initial cycle.
+     * @param {boolean} check - Cycle check mode.
+     * @returns {Promise<void>} Startup completion.
+     */
+    async #start(check) {
+        try {
+            const project = await this.#manifestLoader.load(this.#manifestPath);
+            if (this.#stopping)
+                return;
+            const snapshot = await this.#snapshotBuilder.build(project);
+            if (this.#stopping)
+                return;
+            this.#project = project;
+            this.#lastSnapshot = snapshot;
+            this.#setWatchTopology(project);
+            this.#watchStates = await this.#readWatchStates();
+            if (this.#stopping)
+                return;
+            this.#reporter?.watchStarted(project.id);
+            if (this.#stopping)
+                return;
+            this.#startEventBackend();
+            if (this.#stopping)
+                return;
+            await this.#admitCycle({ changedPaths: [], check, project, snapshot });
+        }
+        catch (error) {
+            if (!this.#stopping)
+                this.#finishFailed(error);
+        }
+    }
+    /**
+     * Runs exactly one owned cycle.
+     * @param {WatchCycleInput} input - Admitted cycle.
+     * @returns {Promise<void>}
+     */
+    async #admitCycle({ changedPaths, check, failure, project, snapshot }) {
+        if (this.#activeCycle !== undefined || this.#stopping)
+            return;
+        this.#cycle += 1;
+        const cycle = this.#cycle;
+        const activeController = new AbortController();
+        const publicationController = new AbortController();
+        this.#activeController = activeController;
+        this.#publicationController = publicationController;
+        this.#dirty = false;
+        this.#cycleDirtyReported = false;
+        this.#commitWindow = false;
+        this.#hintPaths.clear();
+        this.#reporter?.cycleStarted({
+            changedPaths,
+            cycle,
+            projectId: project?.id ?? this.#project?.id ?? "project",
+            ...(snapshot === undefined ? {} : { snapshotHash: snapshot.hash })
+        });
+        this.#observe({ cycle, status: "started", type: "cycle-start" });
+        let terminalStatus = /** @type {"cancelled" | "failed" | "recovered" | "succeeded" | "superseded"} */ ("failed");
+        /** @type {unknown} */
+        let terminalFailure;
+        /** @type {SemantifoldProject | undefined} */
+        let currentProject;
+        /** @type {ProjectSnapshot | undefined} */
+        let currentSnapshot;
+        const manifestPath = /** @type {string} */ (this.#manifestPath);
+        const reporter = /** @type {ProjectWatchReporter} */ (this.#reporter);
+        const execute = async () => {
+            try {
+                if (snapshot === undefined) {
+                    throw failure ?? new SemantifoldDiagnostic({
+                        code: "WATCH_SNAPSHOT_UNAVAILABLE",
+                        language: project?.id ?? this.#project?.id ?? "project",
+                        message: "The complete watched project graph is unavailable."
+                    });
+                }
+                const result = await buildWatchedProject(this.#builder, manifestPath, reporter, {
+                    check,
+                    expectedSnapshotHash: snapshot.hash,
+                    publicationSignal: publicationController.signal,
+                    signal: activeController.signal,
+                    validateCurrentSnapshot: async () => {
+                        const guardHintVersion = this.#hintVersion;
+                        /** @type {SemantifoldProject} */
+                        let reconciledProject;
+                        /** @type {ProjectSnapshot} */
+                        let reconciledSnapshot;
+                        try {
+                            reconciledProject = await this.#manifestLoader.load(manifestPath);
+                            reconciledSnapshot = await this.#snapshotBuilder.build(reconciledProject);
+                        }
+                        catch (error) {
+                            throw new SemantifoldDiagnostic({
+                                cause: error instanceof Error ? error : new Error(String(error)),
+                                code: "WATCH_CANDIDATE_SUPERSEDED",
+                                language: this.#project?.id ?? "project",
+                                message: "The watched project graph became unavailable before candidate publication."
+                            });
+                        }
+                        if (snapshot === undefined || reconciledSnapshot.hash != snapshot.hash) {
+                            throw new SemantifoldDiagnostic({
+                                code: "WATCH_CANDIDATE_SUPERSEDED",
+                                language: reconciledProject.id,
+                                message: "A newer complete project snapshot superseded the completed watch candidate."
+                            });
+                        }
+                        currentProject = reconciledProject;
+                        currentSnapshot = reconciledSnapshot;
+                        this.#commitWindow = true;
+                        if (this.#hintVersion == guardHintVersion) {
+                            this.#dirty = false;
+                            this.#hintPaths.clear();
+                        }
+                        else {
+                            this.#dirty = true;
+                            publicationController.abort("A filesystem hint arrived during final snapshot reconciliation.");
+                        }
+                    }
+                });
+                this.#commitWindow = false;
+                terminalStatus = this.#hadFailure ? "recovered" : "succeeded";
+                this.#hadFailure = false;
+                this.#suppressedHash = result.snapshotHash;
+                if (currentProject !== undefined && currentSnapshot !== undefined) {
+                    this.#project = currentProject;
+                    this.#lastSnapshot = currentSnapshot;
+                    this.#setWatchTopology(currentProject);
+                    const watchStates = await this.#readWatchStates();
+                    const changedWatchPaths = changedWatchStatePaths(this.#watchStates, watchStates, this.#displayPaths);
+                    if (changedWatchPaths.length == 0)
+                        this.#watchStates = watchStates;
+                    else
+                        for (const changedPath of changedWatchPaths)
+                            this.#hint(changedPath, check);
+                }
+                this.#reporter?.cycleSucceeded(result, terminalStatus == "recovered");
+            }
+            catch (error) {
+                terminalFailure = error;
+                terminalStatus = this.#stopping ? "cancelled" : supersededFailure(error, this.#dirty) ? "superseded" : "failed";
+                if (terminalStatus == "failed") {
+                    this.#hadFailure = true;
+                    if (snapshot !== undefined)
+                        this.#suppressedHash = snapshot.hash;
+                }
+                this.#reporter?.cycleFailed(error, terminalStatus);
+            }
+            finally {
+                this.#commitWindow = false;
+            }
+        };
+        this.#activeCycle = execute();
+        await this.#activeCycle;
+        this.#activeCycle = undefined;
+        this.#activeController = undefined;
+        this.#publicationController = undefined;
+        this.#observe({ cycle, status: terminalStatus, type: "cycle-terminal" });
+        if (this.#stopping) {
+            this.#finishStoppedIfIdle();
+            return;
+        }
+        if (this.#initialCycle && terminalStatus == "failed") {
+            this.#finishFailed(terminalFailure);
+            return;
+        }
+        if (terminalStatus == "succeeded" || terminalStatus == "recovered")
+            this.#initialCycle = false;
+        if (this.#dirty || terminalStatus == "superseded") {
+            queueMicrotask(() => void this.#reconcile(check));
+        }
+        else {
+            this.#observe({ cycle, status: "ready", type: "ready" });
+        }
+    }
+    /**
+     * Re-reads the complete graph after a quiet period or active-cycle dirty marker.
+     * @param {boolean} check - Cycle check mode.
+     * @returns {Promise<void>} Reconciliation completion.
+     */
+    async #reconcile(check) {
+        if (this.#stopping || this.#activeCycle !== undefined)
+            return;
+        if (this.#quietTimer !== undefined) {
+            clearTimeout(this.#quietTimer);
+            this.#quietTimer = undefined;
+        }
+        const hinted = [...this.#hintPaths].sort(compareStrings);
+        this.#hintPaths.clear();
+        this.#dirty = false;
+        let project;
+        let snapshot;
+        let snapshotFailure;
+        try {
+            project = await this.#manifestLoader.load(this.#manifestPath);
+            snapshot = await this.#snapshotBuilder.build(project);
+            this.#suppressedInvalidState = undefined;
+            this.#setWatchTopology(project);
+            this.#watchStates = await this.#readWatchStates();
+        }
+        catch (error) {
+            snapshotFailure = error;
+            try {
+                this.#watchStates = await this.#readWatchStates();
+            }
+            catch {
+                // The build cycle below owns and reports the original complete-graph failure.
+            }
+            const invalidState = watchStateKey(this.#watchStates);
+            if (invalidState == this.#suppressedInvalidState) {
+                this.#reporter?.unchanged(hinted);
+                this.#observe({ status: "unchanged", type: "reconciled" });
+                return;
+            }
+            this.#suppressedInvalidState = invalidState;
+        }
+        if (snapshot !== undefined && snapshot.hash == this.#suppressedHash && !this.#hadFailure) {
+            this.#reporter?.unchanged(hinted);
+            this.#observe({ status: "unchanged", type: "reconciled" });
+            return;
+        }
+        const changedPaths = snapshot === undefined
+            ? hinted
+            : changedSnapshotPaths(this.#lastSnapshot, snapshot, path.basename(project?.manifestPath ?? this.#manifestPath ?? "semantifold.json"));
+        if (snapshot !== undefined)
+            this.#lastSnapshot = snapshot;
+        await this.#admitCycle({ changedPaths, check, failure: snapshotFailure, project, snapshot });
+    }
+    /**
+     * Coalesces one event hint without treating its filename as the build input set.
+     * @param {string | undefined} changedPath - Project-relative changed-path hint.
+     * @param {boolean} check - Check mode.
+     * @returns {void}
+     */
+    #hint(changedPath, check) {
+        if (this.#stopping)
+            return;
+        this.#hintVersion += 1;
+        if (changedPath !== undefined)
+            this.#hintPaths.add(changedPath);
+        if (this.#activeCycle !== undefined) {
+            this.#dirty = true;
+            if (this.#commitWindow)
+                this.#publicationController?.abort("A filesystem hint reached the active-pointer commit window.");
+            if (!this.#cycleDirtyReported) {
+                this.#cycleDirtyReported = true;
+                this.#reporter?.cycleDirty();
+                this.#observe({ cycle: this.#cycle, status: "dirty", type: "dirty" });
+            }
+            return;
+        }
+        if (this.#quietTimer !== undefined)
+            clearTimeout(this.#quietTimer);
+        this.#quietTimer = setTimeout(() => {
+            this.#quietTimer = undefined;
+            void this.#reconcile(check);
+        }, this.#quietPeriodMs);
+    }
+    /**
+     * Updates the exact manifest/source watch topology.
+     * @param {SemantifoldProject} project - Current valid project.
+     * @returns {void}
+     */
+    #setWatchTopology(project) {
+        const watchedPaths = new Set([project.manifestPath, ...project.sources.map(({ absolutePath }) => absolutePath)]);
+        const displayPaths = new Map([[project.manifestPath, path.basename(project.manifestPath)]]);
+        for (const source of project.sources)
+            displayPaths.set(source.absolutePath, source.path);
+        const changed = [...watchedPaths].sort(compareStrings).join("\0") != [...this.#watchedPaths].sort(compareStrings).join("\0");
+        this.#watchedPaths = watchedPaths;
+        this.#displayPaths = displayPaths;
+        this.#publicationRoot = project.publicationRoot;
+        if (changed && this.#subscriptions.length > 0 && !this.#polling && !this.#openNativeSubscriptions()) {
+            this.#switchToPolling();
+        }
+    }
+    /**
+     * Starts native subscriptions or their polling fallback.
+     * @returns {void}
+     */
+    #startEventBackend() {
+        if (this.#openNativeSubscriptions()) {
+            this.#ensurePollingReconciliation();
+            this.#reporter?.watchBackend("native");
+            this.#observe({ status: "native", type: "watch-backend" });
+        }
+        else
+            this.#switchToPolling();
+    }
+    /**
+     * Opens exact file and parent-directory subscriptions.
+     * @returns {boolean} Whether native subscriptions opened completely.
+     */
+    #openNativeSubscriptions() {
+        this.#closeSubscriptions();
+        const nativeWatch = projectWatchNativeBackends.get(this) ?? watchFileSystem;
+        try {
+            for (const filename of this.#watchedPaths) {
+                const subscription = nativeWatch(filename, () => {
+                    this.#hint(this.#displayPaths.get(filename), this.#currentCheckMode());
+                });
+                subscription.once("error", () => this.#switchToPolling());
+                this.#subscriptions.push(subscription);
+            }
+            const parents = new Set([...this.#watchedPaths].map(filename => path.dirname(filename)));
+            for (const directory of parents) {
+                const subscription = nativeWatch(directory, (_, filename) => {
+                    if (filename == null) {
+                        this.#hint(undefined, this.#currentCheckMode());
+                        return;
+                    }
+                    const absolute = path.join(directory, filename.toString());
+                    if (this.#publicationRoot !== undefined && pathsOverlap(this.#publicationRoot, absolute))
+                        return;
+                    this.#hint(this.#displayPaths.get(absolute), this.#currentCheckMode());
+                });
+                subscription.once("error", () => this.#switchToPolling());
+                this.#subscriptions.push(subscription);
+            }
+            return true;
+        }
+        catch {
+            this.#closeSubscriptions();
+            return false;
+        }
+    }
+    /**
+     * Permanently selects bounded polling after native backend failure.
+     * @returns {void}
+     */
+    #switchToPolling() {
+        if (this.#stopping || this.#polling)
+            return;
+        this.#polling = true;
+        this.#closeSubscriptions();
+        this.#ensurePollingReconciliation();
+        this.#reporter?.watchBackend("polling");
+        this.#observe({ status: "polling", type: "watch-backend" });
+    }
+    /**
+     * Compares one bounded polling state observation.
+     * @returns {Promise<void>} Poll completion.
+     */
+    async #poll() {
+        if (this.#pollActive || this.#stopping)
+            return;
+        this.#pollActive = true;
+        try {
+            if (this.#suppressedInvalidState !== undefined) {
+                try {
+                    const project = await this.#manifestLoader.load(this.#manifestPath);
+                    await this.#snapshotBuilder.build(project);
+                    if (this.#quietTimer === undefined)
+                        this.#hint(undefined, this.#currentCheckMode());
+                    return;
+                }
+                catch {
+                    // An unchanged invalid graph remains one failed cycle until it becomes readable and valid.
+                }
+            }
+            const current = await this.#readWatchStates();
+            const changed = changedWatchStatePaths(this.#watchStates, current, this.#displayPaths);
+            this.#pollFailed = false;
+            if (changed.length == 0)
+                return;
+            this.#watchStates = current;
+            for (const changedPath of changed)
+                this.#hint(changedPath, this.#currentCheckMode());
+        }
+        catch {
+            if (!this.#pollFailed) {
+                this.#pollFailed = true;
+                this.#hint(undefined, this.#currentCheckMode());
+            }
+        }
+        finally {
+            this.#pollActive = false;
+        }
+    }
+    /**
+     * Reads the immutable check mode captured by run.
+     * @returns {boolean} Active check mode.
+     */
+    #currentCheckMode() {
+        return this.#check;
+    }
+    /**
+     * Reads one detached mutation-sensitive state observation through the selected backend.
+     * @returns {Promise<Map<string, string>>} Stable ordered path states.
+     */
+    #readWatchStates() {
+        const reader = projectWatchStateReaders.get(this) ?? readWatchStates;
+        return reader(new Set(this.#watchedPaths));
+    }
+    #check = false;
+    /**
+     * Starts one bounded reconciliation interval shared by native and fallback modes.
+     * @returns {void}
+     */
+    #ensurePollingReconciliation() {
+        this.#pollTimer ??= setInterval(() => void this.#poll(), this.#pollIntervalMs);
+    }
+    /**
+     * Closes every native subscription.
+     * @returns {void}
+     */
+    #closeSubscriptions() {
+        for (const subscription of this.#subscriptions)
+            subscription.close();
+        this.#subscriptions = [];
+    }
+    /**
+     * Closes subscriptions and pending reconciliation timers.
+     * @returns {void}
+     */
+    #closeEventBackends() {
+        if (this.#quietTimer !== undefined)
+            clearTimeout(this.#quietTimer);
+        if (this.#pollTimer !== undefined)
+            clearInterval(this.#pollTimer);
+        this.#quietTimer = undefined;
+        this.#pollTimer = undefined;
+        this.#closeSubscriptions();
+    }
+    /**
+     * Resolves shutdown only after startup and the active cycle have both relinquished ownership.
+     * @returns {void}
+     */
+    #finishStoppedIfIdle() {
+        if (this.#stopping && this.#startup === undefined && this.#activeCycle === undefined)
+            this.#finishStopped();
+    }
+    /**
+     * Emits and resolves one clean watcher terminal.
+     * @returns {void}
+     */
+    #finishStopped() {
+        if (this.#finished)
+            return;
+        this.#finished = true;
+        this.#running = false;
+        this.#closeEventBackends();
+        this.#removeSignalHandlers();
+        this.#reporter?.watchStopped(this.#stopReason);
+        const result = Object.freeze({ cycles: this.#cycle, reason: this.#stopReason, status: /** @type {const} */ ("stopped") });
+        this.#observe({ status: "stopped", type: "stopped" });
+        this.#resolveCompletion(result);
+    }
+    /**
+     * Emits and resolves one startup-failure watcher terminal.
+     * @param {unknown} failure - Startup failure.
+     * @returns {void}
+     */
+    #finishFailed(failure) {
+        if (this.#finished)
+            return;
+        this.#finished = true;
+        this.#running = false;
+        this.#closeEventBackends();
+        this.#removeSignalHandlers();
+        this.#reporter?.watchFailed(failure);
+        const result = Object.freeze({ cycles: this.#cycle, reason: "startup failure", status: /** @type {const} */ ("failed") });
+        this.#observe({ status: "failed", type: "stopped" });
+        this.#resolveCompletion(result);
+    }
+    /**
+     * Removes process signal handlers owned by this coordinator.
+     * @returns {void}
+     */
+    #removeSignalHandlers() {
+        process.removeListener("SIGINT", this.#signalHandler);
+        process.removeListener("SIGTERM", this.#signalHandler);
+    }
+    /**
+     * Emits one internal deterministic lifecycle marker.
+     * @param {ProjectWatchObservation} event - Marker.
+     * @returns {void}
+     */
+    #observe(event) {
+        projectWatchObservers.get(this)?.(Object.freeze(event));
+    }
+}
+/**
+ * Reads mutation-sensitive states only as polling/event deduplication hints.
+ * Content hashes remain authoritative for cycle admission.
+ * @param {Readonly<Set<string>>} filenames - Exact watched graph paths.
+ * @returns {Promise<Map<string, string>>} Stable ordered path states.
+ */
+async function readWatchStates(filenames) {
+    const result = new Map();
+    for (const filename of [...filenames].sort(compareStrings)) {
+        try {
+            const status = await lstat(filename, { bigint: true });
+            result.set(filename, [status.dev, status.ino, status.mode, status.size, status.mtimeNs, status.ctimeNs].map(String).join(":"));
+        }
+        catch (error) {
+            if (!isErrorCode(error, "ENOENT"))
+                throw error;
+            result.set(filename, "missing");
+        }
+    }
+    return result;
+}
+/**
+ * @typedef {(filenames: Readonly<Set<string>>) => Promise<Map<string, string>>} ProjectWatchStateReader
+ */
+/**
+ * Locates polling changes without treating metadata as build identity.
+ * @param {Map<string, string>} previous - Previous states.
+ * @param {Map<string, string>} current - Current states.
+ * @param {Map<string, string>} displayPaths - Stable project-relative names.
+ * @returns {string[]} Changed project paths.
+ */
+function changedWatchStatePaths(previous, current, displayPaths) {
+    const filenames = new Set([...previous.keys(), ...current.keys()]);
+    return [...filenames].filter(filename => previous.get(filename) != current.get(filename))
+        .map(filename => displayPaths.get(filename) ?? path.basename(filename)).sort(compareStrings);
+}
+/**
+ * Serializes one ordered polling state only for repeated-invalid reconciliation suppression.
+ * @param {Map<string, string>} states - Current watched path states.
+ * @returns {string} Stable state key.
+ */
+function watchStateKey(states) {
+    return JSON.stringify([...states].sort(([left], [right]) => compareStrings(left, right)));
+}
+/**
+ * Checks whether either absolute path contains the other.
+ * @param {string} left - First absolute path.
+ * @param {string} right - Second absolute path.
+ * @returns {boolean} Whether the paths overlap.
+ */
+function pathsOverlap(left, right) {
+    return pathWithin(left, right) || pathWithin(right, left);
+}
+/**
+ * Checks whether one absolute path is a root or descendant of another.
+ * @param {string} root - Absolute root.
+ * @param {string} candidate - Absolute candidate.
+ * @returns {boolean} Whether the candidate belongs to the root.
+ */
+function pathWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative.length == 0 || relative != ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+/**
+ * Computes exact content/config changes between complete immutable snapshots.
+ * @param {ProjectSnapshot | undefined} previous - Previous admitted snapshot.
+ * @param {ProjectSnapshot} current - Current complete snapshot.
+ * @param {string} manifestPath - Project-root-relative manifest display path.
+ * @returns {string[]} Stable changed paths.
+ */
+function changedSnapshotPaths(previous, current, manifestPath) {
+    if (previous === undefined)
+        return [manifestPath, ...current.sources.map(({ path: sourcePath }) => sourcePath)];
+    const changed = new Set();
+    if (previous.manifestText != current.manifestText)
+        changed.add(manifestPath);
+    const previousSources = new Map(previous.sources.map(source => [source.path, source.source]));
+    const currentSources = new Map(current.sources.map(source => [source.path, source.source]));
+    for (const sourcePath of new Set([...previousSources.keys(), ...currentSources.keys()])) {
+        if (previousSources.get(sourcePath) != currentSources.get(sourcePath))
+            changed.add(sourcePath);
+    }
+    return [...changed].sort(compareStrings);
+}
+/**
+ * Recognizes failures caused only by deterministic supersession.
+ * @param {unknown} failure - Candidate failure.
+ * @param {boolean} dirty - Whether a newer hint exists.
+ * @returns {boolean} Whether the cycle was superseded.
+ */
+function supersededFailure(failure, dirty) {
+    let current = failure;
+    while (current instanceof Error) {
+        if ("code" in current && (current.code == "WATCH_CANDIDATE_SUPERSEDED" || current.code == "WATCH_SNAPSHOT_CHANGED" ||
+            dirty && current.code == "PUBLICATION_CANCELLED"))
+            return true;
+        current = current.cause;
+    }
+    return false;
+}
+/**
+ * Checks one ordinary object.
+ * @param {unknown} value - Candidate.
+ * @returns {value is Record<string, unknown>} Whether the value is a plain object.
+ */
+function isPlainObject(value) {
+    return typeof value == "object" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype;
+}
+/**
+ * Checks one bounded positive integer timing value.
+ * @param {number} value - Candidate milliseconds.
+ * @param {number} maximum - Inclusive maximum.
+ * @returns {boolean} Whether the value is valid.
+ */
+function validMilliseconds(value, maximum) {
+    return typeof value == "number" && Number.isInteger(value) && value > 0 && value <= maximum;
+}
+/**
+ * Checks a narrowed filesystem error code.
+ * @param {unknown} error - Opaque error.
+ * @param {string} code - Expected code.
+ * @returns {boolean} Whether the code matches.
+ */
+function isErrorCode(error, code) {
+    return error instanceof Error && "code" in error && error.code == code;
+}
+/**
+ * Compares stable protocol strings.
+ * @param {string} left - Left string.
+ * @param {string} right - Right string.
+ * @returns {number} Sort order.
+ */
+function compareStrings(left, right) {
+    return left.localeCompare(right, "en");
+}
+/**
+ * @typedef ProjectWatchObservation
+ * @property {"cycle-start" | "cycle-terminal" | "dirty" | "ready" | "reconciled" | "stopped" | "watch-backend"} type - Marker type.
+ * @property {number} [cycle] - Related cycle number.
+ * @property {"cancelled" | "dirty" | "failed" | "native" | "polling" | "ready" | "recovered" | "started" | "stopped" | "succeeded" | "superseded" | "unchanged"} status - Marker status.
+ */
+/**
+ * @typedef ProjectWatchResult
+ * @property {"failed" | "stopped"} status - Watcher terminal state.
+ * @property {number} cycles - Admitted cycle count.
+ * @property {string} reason - Stable terminal reason.
+ */
+/**
+ * @typedef WatchCycleInput
+ * @property {readonly string[]} changedPaths - Stable changed paths.
+ * @property {boolean} check - Whether target checks are enabled.
+ * @property {unknown} [failure] - Preserved reconciliation failure.
+ * @property {SemantifoldProject | undefined} project - Reconciled project, when valid.
+ * @property {ProjectSnapshot | undefined} snapshot - Reconciled snapshot, when valid.
+ */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-watch.js","sourceRoot":"","sources":["../../src/project-watch.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {watch as watchFileSystem} from \"node:fs\"\nimport {lstat} from \"node:fs/promises\"\nimport path from \"node:path\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {buildWatchedProject, ProjectBuilder} from \"./project-build.js\"\nimport {ProjectManifestLoader, SemantifoldProject} from \"./project-manifest.js\"\nimport {ProjectSnapshot, ProjectSnapshotBuilder} from \"./project-snapshot.js\"\nimport {ProjectWatchReporter} from \"./project-watch-reporter.js\"\n\nconst defaultQuietPeriodMs = 50\nconst defaultPollIntervalMs = 1000\nconst maximumQuietPeriodMs = 10_000\nconst maximumPollIntervalMs = 60_000\n/** @type {WeakMap<ProjectWatchCoordinator, (event: ProjectWatchObservation) => void>} */\nconst projectWatchObservers = new WeakMap()\n/** @type {WeakMap<ProjectWatchCoordinator, typeof watchFileSystem>} */\nconst projectWatchNativeBackends = new WeakMap()\n/** @type {WeakMap<ProjectWatchCoordinator, ProjectWatchStateReader>} */\nconst projectWatchStateReaders = new WeakMap()\n\n/**\n * Installs a synchronous lifecycle observer for focused coordination specs.\n * This helper is intentionally not part of the package root API.\n * @param {ProjectWatchCoordinator} coordinator - Coordinator instance.\n * @param {(event: ProjectWatchObservation) => void} observer - Marker observer.\n * @returns {void}\n */\nexport function observeProjectWatch(coordinator, observer) {\n  if (!(coordinator instanceof ProjectWatchCoordinator) || typeof observer != \"function\") {\n    throw new TypeError(\"Invalid project watch observer.\")\n  }\n  projectWatchObservers.set(coordinator, observer)\n}\n\n/**\n * Creates a coordinator with one instance-owned native event backend for focused fallback specs.\n * This helper is intentionally not part of the package root API.\n * @param {{builder?: ProjectBuilder, manifestLoader?: ProjectManifestLoader, nativeWatch: typeof watchFileSystem, pollIntervalMs?: number, quietPeriodMs?: number, snapshotBuilder?: ProjectSnapshotBuilder, watchStateReader?: ProjectWatchStateReader}} options - Coordinator options and backends.\n * @returns {ProjectWatchCoordinator} Configured coordinator.\n */\nexport function createProjectWatchCoordinator(options) {\n  if (!isPlainObject(options) || typeof options.nativeWatch != \"function\" ||\n    options.watchStateReader !== undefined && typeof options.watchStateReader != \"function\") {\n    throw new TypeError(\"Invalid project watch coordinator dependencies.\")\n  }\n  const coordinator = new ProjectWatchCoordinator({\n    ...(options.builder === undefined ? {} : {builder: options.builder}),\n    ...(options.manifestLoader === undefined ? {} : {manifestLoader: options.manifestLoader}),\n    ...(options.pollIntervalMs === undefined ? {} : {pollIntervalMs: options.pollIntervalMs}),\n    ...(options.quietPeriodMs === undefined ? {} : {quietPeriodMs: options.quietPeriodMs}),\n    ...(options.snapshotBuilder === undefined ? {} : {snapshotBuilder: options.snapshotBuilder})\n  })\n\n  projectWatchNativeBackends.set(coordinator, options.nativeWatch)\n  if (options.watchStateReader !== undefined) projectWatchStateReaders.set(coordinator, options.watchStateReader)\n\n  return coordinator\n}\n\n/**\n * Turns filesystem hints into serialized complete project build transactions.\n */\nexport class ProjectWatchCoordinator {\n  /** @type {ProjectBuilder} */\n  #builder\n  /** @type {ProjectManifestLoader} */\n  #manifestLoader\n  /** @type {ProjectSnapshotBuilder} */\n  #snapshotBuilder\n  #quietPeriodMs\n  #pollIntervalMs\n  /** @type {ProjectWatchReporter | undefined} */\n  #reporter\n  /** @type {string | undefined} */\n  #manifestPath\n  /** @type {SemantifoldProject | undefined} */\n  #project\n  /** @type {string | undefined} */\n  #publicationRoot\n  /** @type {ProjectSnapshot | undefined} */\n  #lastSnapshot\n  /** @type {string | undefined} */\n  #suppressedHash\n  /** @type {string | undefined} */\n  #suppressedInvalidState\n  /** @type {Map<string, string>} */\n  #watchStates = new Map()\n  /** @type {Set<string>} */\n  #watchedPaths = new Set()\n  /** @type {Map<string, string>} */\n  #displayPaths = new Map()\n  /** @type {import(\"node:fs\").FSWatcher[]} */\n  #subscriptions = []\n  /** @type {ReturnType<typeof setTimeout> | undefined} */\n  #quietTimer\n  /** @type {ReturnType<typeof setInterval> | undefined} */\n  #pollTimer\n  #polling = false\n  #pollActive = false\n  #pollFailed = false\n  #cycle = 0\n  #hintVersion = 0\n  #dirty = false\n  #cycleDirtyReported = false\n  #commitWindow = false\n  #hadFailure = false\n  #running = false\n  #stopping = false\n  #finished = false\n  #initialCycle = true\n  #stopReason = \"watch stopped\"\n  /** @type {Set<string>} */\n  #hintPaths = new Set()\n  /** @type {AbortController | undefined} */\n  #activeController\n  /** @type {AbortController | undefined} */\n  #publicationController\n  /** @type {Promise<void> | undefined} */\n  #activeCycle\n  /** @type {Promise<void> | undefined} */\n  #startup\n  /** @type {Promise<Readonly<ProjectWatchResult>> | undefined} */\n  #completion\n  /**\n   * Resolves the sole run completion.\n   * @type {(result: Readonly<ProjectWatchResult>) => void}\n   */\n  #resolveCompletion = () => {}\n  /** @type {() => void} */\n  #signalHandler\n\n  /**\n   * Creates one idle coordinator without touching the filesystem.\n   * @param {{builder?: ProjectBuilder, manifestLoader?: ProjectManifestLoader, pollIntervalMs?: number, quietPeriodMs?: number, snapshotBuilder?: ProjectSnapshotBuilder}} [options] - Collaborators and bounded timing policy.\n   */\n  constructor(options = {}) {\n    if (!isPlainObject(options) || Object.keys(options).some(key =>\n      ![\"builder\", \"manifestLoader\", \"pollIntervalMs\", \"quietPeriodMs\", \"snapshotBuilder\"].includes(key)) ||\n      options.builder !== undefined && !(options.builder instanceof ProjectBuilder) ||\n      options.manifestLoader !== undefined && !(options.manifestLoader instanceof ProjectManifestLoader) ||\n      options.snapshotBuilder !== undefined && !(options.snapshotBuilder instanceof ProjectSnapshotBuilder)) {\n      throw new TypeError(\"Invalid project watch coordinator options.\")\n    }\n    const quietPeriodMs = options.quietPeriodMs ?? defaultQuietPeriodMs\n    const pollIntervalMs = options.pollIntervalMs ?? defaultPollIntervalMs\n\n    if (!validMilliseconds(quietPeriodMs, maximumQuietPeriodMs) || !validMilliseconds(pollIntervalMs, maximumPollIntervalMs)) {\n      throw new TypeError(\"Project watch timing values must be bounded positive integer milliseconds.\")\n    }\n    this.#builder = options.builder ?? new ProjectBuilder()\n    this.#manifestLoader = options.manifestLoader ?? new ProjectManifestLoader()\n    this.#snapshotBuilder = options.snapshotBuilder ?? new ProjectSnapshotBuilder()\n    this.#quietPeriodMs = quietPeriodMs\n    this.#pollIntervalMs = pollIntervalMs\n    this.#signalHandler = () => {\n      void this.stop(\"termination signal\")\n    }\n  }\n\n  /**\n   * Starts the initial build and remains active until shutdown or startup failure.\n   * @param {string} [projectPath] - Project manifest path.\n   * @param {ProjectWatchReporter} [reporter] - Watch protocol reporter.\n   * @param {{check?: boolean}} [options] - Whether every cycle runs target-owned checks.\n   * @returns {Promise<Readonly<ProjectWatchResult>>} Terminal watcher result.\n   */\n  run(projectPath = \"./semantifold.json\", reporter = new ProjectWatchReporter(), options = {}) {\n    if (this.#running || this.#completion !== undefined || typeof projectPath != \"string\" || projectPath.length == 0 ||\n      !(reporter instanceof ProjectWatchReporter) || !isPlainObject(options) ||\n      Object.keys(options).some(key => key != \"check\") || options.check !== undefined && typeof options.check != \"boolean\") {\n      throw new TypeError(\"Invalid or repeated project watch run.\")\n    }\n    this.#running = true\n    this.#reporter = reporter\n    this.#manifestPath = projectPath\n    this.#check = options.check === true\n    this.#completion = new Promise(resolve => {\n      this.#resolveCompletion = resolve\n    })\n    process.once(\"SIGINT\", this.#signalHandler)\n    process.once(\"SIGTERM\", this.#signalHandler)\n    const startup = this.#start(this.#check)\n\n    this.#startup = startup\n    const startupSettled = () => {\n      if (this.#startup === startup) this.#startup = undefined\n      this.#finishStoppedIfIdle()\n    }\n\n    void startup.then(startupSettled, startupSettled)\n\n    return this.#completion\n  }\n\n  /**\n   * Stops admitting work, cancels the exact active operation, and waits through child close and staging cleanup.\n   * @param {string} [reason] - Stable shutdown reason.\n   * @returns {Promise<Readonly<ProjectWatchResult>>} Terminal watcher result.\n   */\n  async stop(reason = \"shutdown requested\") {\n    if (typeof reason != \"string\" || reason.length == 0) throw new TypeError(\"Project watch stop reason must be non-empty.\")\n    if (this.#completion === undefined) throw new TypeError(\"Project watch coordinator has not started.\")\n    if (!this.#stopping && !this.#finished) {\n      this.#stopping = true\n      this.#stopReason = reason\n      this.#closeEventBackends()\n      this.#activeController?.abort(reason)\n      this.#publicationController?.abort(reason)\n      this.#finishStoppedIfIdle()\n    }\n\n    return this.#completion\n  }\n\n  /**\n   * Establishes the validated graph, event backend, and initial cycle.\n   * @param {boolean} check - Cycle check mode.\n   * @returns {Promise<void>} Startup completion.\n   */\n  async #start(check) {\n    try {\n      const project = await this.#manifestLoader.load(this.#manifestPath)\n\n      if (this.#stopping) return\n      const snapshot = await this.#snapshotBuilder.build(project)\n\n      if (this.#stopping) return\n      this.#project = project\n      this.#lastSnapshot = snapshot\n      this.#setWatchTopology(project)\n      this.#watchStates = await this.#readWatchStates()\n      if (this.#stopping) return\n      this.#reporter?.watchStarted(project.id)\n      if (this.#stopping) return\n      this.#startEventBackend()\n      if (this.#stopping) return\n      await this.#admitCycle({changedPaths: [], check, project, snapshot})\n    } catch (error) {\n      if (!this.#stopping) this.#finishFailed(error)\n    }\n  }\n\n  /**\n   * Runs exactly one owned cycle.\n   * @param {WatchCycleInput} input - Admitted cycle.\n   * @returns {Promise<void>}\n   */\n  async #admitCycle({changedPaths, check, failure, project, snapshot}) {\n    if (this.#activeCycle !== undefined || this.#stopping) return\n    this.#cycle += 1\n    const cycle = this.#cycle\n    const activeController = new AbortController()\n    const publicationController = new AbortController()\n\n    this.#activeController = activeController\n    this.#publicationController = publicationController\n    this.#dirty = false\n    this.#cycleDirtyReported = false\n    this.#commitWindow = false\n    this.#hintPaths.clear()\n    this.#reporter?.cycleStarted({\n      changedPaths,\n      cycle,\n      projectId: project?.id ?? this.#project?.id ?? \"project\",\n      ...(snapshot === undefined ? {} : {snapshotHash: snapshot.hash})\n    })\n    this.#observe({cycle, status: \"started\", type: \"cycle-start\"})\n    let terminalStatus = /** @type {\"cancelled\" | \"failed\" | \"recovered\" | \"succeeded\" | \"superseded\"} */ (\"failed\")\n    /** @type {unknown} */\n    let terminalFailure\n    /** @type {SemantifoldProject | undefined} */\n    let currentProject\n    /** @type {ProjectSnapshot | undefined} */\n    let currentSnapshot\n    const manifestPath = /** @type {string} */ (this.#manifestPath)\n    const reporter = /** @type {ProjectWatchReporter} */ (this.#reporter)\n    const execute = async () => {\n      try {\n        if (snapshot === undefined) {\n          throw failure ?? new SemantifoldDiagnostic({\n            code: \"WATCH_SNAPSHOT_UNAVAILABLE\",\n            language: project?.id ?? this.#project?.id ?? \"project\",\n            message: \"The complete watched project graph is unavailable.\"\n          })\n        }\n        const result = await buildWatchedProject(this.#builder, manifestPath, reporter, {\n          check,\n          expectedSnapshotHash: snapshot.hash,\n          publicationSignal: publicationController.signal,\n          signal: activeController.signal,\n          validateCurrentSnapshot: async () => {\n            const guardHintVersion = this.#hintVersion\n            /** @type {SemantifoldProject} */\n            let reconciledProject\n            /** @type {ProjectSnapshot} */\n            let reconciledSnapshot\n\n            try {\n              reconciledProject = await this.#manifestLoader.load(manifestPath)\n              reconciledSnapshot = await this.#snapshotBuilder.build(reconciledProject)\n            } catch (error) {\n              throw new SemantifoldDiagnostic({\n                cause: error instanceof Error ? error : new Error(String(error)),\n                code: \"WATCH_CANDIDATE_SUPERSEDED\",\n                language: this.#project?.id ?? \"project\",\n                message: \"The watched project graph became unavailable before candidate publication.\"\n              })\n            }\n\n            if (snapshot === undefined || reconciledSnapshot.hash != snapshot.hash) {\n              throw new SemantifoldDiagnostic({\n                code: \"WATCH_CANDIDATE_SUPERSEDED\",\n                language: reconciledProject.id,\n                message: \"A newer complete project snapshot superseded the completed watch candidate.\"\n              })\n            }\n            currentProject = reconciledProject\n            currentSnapshot = reconciledSnapshot\n            this.#commitWindow = true\n            if (this.#hintVersion == guardHintVersion) {\n              this.#dirty = false\n              this.#hintPaths.clear()\n            } else {\n              this.#dirty = true\n              publicationController.abort(\"A filesystem hint arrived during final snapshot reconciliation.\")\n            }\n          }\n        })\n\n        this.#commitWindow = false\n        terminalStatus = this.#hadFailure ? \"recovered\" : \"succeeded\"\n        this.#hadFailure = false\n        this.#suppressedHash = result.snapshotHash\n        if (currentProject !== undefined && currentSnapshot !== undefined) {\n          this.#project = currentProject\n          this.#lastSnapshot = currentSnapshot\n          this.#setWatchTopology(currentProject)\n          const watchStates = await this.#readWatchStates()\n          const changedWatchPaths = changedWatchStatePaths(this.#watchStates, watchStates, this.#displayPaths)\n\n          if (changedWatchPaths.length == 0) this.#watchStates = watchStates\n          else for (const changedPath of changedWatchPaths) this.#hint(changedPath, check)\n        }\n        this.#reporter?.cycleSucceeded(result, terminalStatus == \"recovered\")\n      } catch (error) {\n        terminalFailure = error\n        terminalStatus = this.#stopping ? \"cancelled\" : supersededFailure(error, this.#dirty) ? \"superseded\" : \"failed\"\n        if (terminalStatus == \"failed\") {\n          this.#hadFailure = true\n          if (snapshot !== undefined) this.#suppressedHash = snapshot.hash\n        }\n        this.#reporter?.cycleFailed(error, terminalStatus)\n      } finally {\n        this.#commitWindow = false\n      }\n    }\n\n    this.#activeCycle = execute()\n    await this.#activeCycle\n    this.#activeCycle = undefined\n    this.#activeController = undefined\n    this.#publicationController = undefined\n    this.#observe({cycle, status: terminalStatus, type: \"cycle-terminal\"})\n    if (this.#stopping) {\n      this.#finishStoppedIfIdle()\n      return\n    }\n    if (this.#initialCycle && terminalStatus == \"failed\") {\n      this.#finishFailed(terminalFailure)\n      return\n    }\n    if (terminalStatus == \"succeeded\" || terminalStatus == \"recovered\") this.#initialCycle = false\n    if (this.#dirty || terminalStatus == \"superseded\") {\n      queueMicrotask(() => void this.#reconcile(check))\n    } else {\n      this.#observe({cycle, status: \"ready\", type: \"ready\"})\n    }\n  }\n\n  /**\n   * Re-reads the complete graph after a quiet period or active-cycle dirty marker.\n   * @param {boolean} check - Cycle check mode.\n   * @returns {Promise<void>} Reconciliation completion.\n   */\n  async #reconcile(check) {\n    if (this.#stopping || this.#activeCycle !== undefined) return\n    if (this.#quietTimer !== undefined) {\n      clearTimeout(this.#quietTimer)\n      this.#quietTimer = undefined\n    }\n    const hinted = [...this.#hintPaths].sort(compareStrings)\n\n    this.#hintPaths.clear()\n    this.#dirty = false\n    let project\n    let snapshot\n    let snapshotFailure\n\n    try {\n      project = await this.#manifestLoader.load(this.#manifestPath)\n      snapshot = await this.#snapshotBuilder.build(project)\n      this.#suppressedInvalidState = undefined\n      this.#setWatchTopology(project)\n      this.#watchStates = await this.#readWatchStates()\n    } catch (error) {\n      snapshotFailure = error\n      try {\n        this.#watchStates = await this.#readWatchStates()\n      } catch {\n        // The build cycle below owns and reports the original complete-graph failure.\n      }\n      const invalidState = watchStateKey(this.#watchStates)\n\n      if (invalidState == this.#suppressedInvalidState) {\n        this.#reporter?.unchanged(hinted)\n        this.#observe({status: \"unchanged\", type: \"reconciled\"})\n        return\n      }\n      this.#suppressedInvalidState = invalidState\n    }\n    if (snapshot !== undefined && snapshot.hash == this.#suppressedHash && !this.#hadFailure) {\n      this.#reporter?.unchanged(hinted)\n      this.#observe({status: \"unchanged\", type: \"reconciled\"})\n      return\n    }\n    const changedPaths = snapshot === undefined\n      ? hinted\n      : changedSnapshotPaths(this.#lastSnapshot, snapshot,\n          path.basename(project?.manifestPath ?? this.#manifestPath ?? \"semantifold.json\"))\n\n    if (snapshot !== undefined) this.#lastSnapshot = snapshot\n    await this.#admitCycle({changedPaths, check, failure: snapshotFailure, project, snapshot})\n  }\n\n  /**\n   * Coalesces one event hint without treating its filename as the build input set.\n   * @param {string | undefined} changedPath - Project-relative changed-path hint.\n   * @param {boolean} check - Check mode.\n   * @returns {void}\n   */\n  #hint(changedPath, check) {\n    if (this.#stopping) return\n    this.#hintVersion += 1\n    if (changedPath !== undefined) this.#hintPaths.add(changedPath)\n    if (this.#activeCycle !== undefined) {\n      this.#dirty = true\n      if (this.#commitWindow) this.#publicationController?.abort(\"A filesystem hint reached the active-pointer commit window.\")\n      if (!this.#cycleDirtyReported) {\n        this.#cycleDirtyReported = true\n        this.#reporter?.cycleDirty()\n        this.#observe({cycle: this.#cycle, status: \"dirty\", type: \"dirty\"})\n      }\n      return\n    }\n    if (this.#quietTimer !== undefined) clearTimeout(this.#quietTimer)\n    this.#quietTimer = setTimeout(() => {\n      this.#quietTimer = undefined\n      void this.#reconcile(check)\n    }, this.#quietPeriodMs)\n  }\n\n  /**\n   * Updates the exact manifest/source watch topology.\n   * @param {SemantifoldProject} project - Current valid project.\n   * @returns {void}\n   */\n  #setWatchTopology(project) {\n    const watchedPaths = new Set([project.manifestPath, ...project.sources.map(({absolutePath}) => absolutePath)])\n    const displayPaths = new Map([[project.manifestPath, path.basename(project.manifestPath)]])\n\n    for (const source of project.sources) displayPaths.set(source.absolutePath, source.path)\n    const changed = [...watchedPaths].sort(compareStrings).join(\"\\0\") != [...this.#watchedPaths].sort(compareStrings).join(\"\\0\")\n\n    this.#watchedPaths = watchedPaths\n    this.#displayPaths = displayPaths\n    this.#publicationRoot = project.publicationRoot\n    if (changed && this.#subscriptions.length > 0 && !this.#polling && !this.#openNativeSubscriptions()) {\n      this.#switchToPolling()\n    }\n  }\n\n  /**\n   * Starts native subscriptions or their polling fallback.\n   * @returns {void}\n   */\n  #startEventBackend() {\n    if (this.#openNativeSubscriptions()) {\n      this.#ensurePollingReconciliation()\n      this.#reporter?.watchBackend(\"native\")\n      this.#observe({status: \"native\", type: \"watch-backend\"})\n    } else this.#switchToPolling()\n  }\n\n  /**\n   * Opens exact file and parent-directory subscriptions.\n   * @returns {boolean} Whether native subscriptions opened completely.\n   */\n  #openNativeSubscriptions() {\n    this.#closeSubscriptions()\n    const nativeWatch = projectWatchNativeBackends.get(this) ?? watchFileSystem\n\n    try {\n      for (const filename of this.#watchedPaths) {\n        const subscription = nativeWatch(filename, () => {\n          this.#hint(this.#displayPaths.get(filename), this.#currentCheckMode())\n        })\n\n        subscription.once(\"error\", () => this.#switchToPolling())\n        this.#subscriptions.push(subscription)\n      }\n      const parents = new Set([...this.#watchedPaths].map(filename => path.dirname(filename)))\n\n      for (const directory of parents) {\n        const subscription = nativeWatch(directory, (_, filename) => {\n          if (filename == null) {\n            this.#hint(undefined, this.#currentCheckMode())\n            return\n          }\n          const absolute = path.join(directory, filename.toString())\n\n          if (this.#publicationRoot !== undefined && pathsOverlap(this.#publicationRoot, absolute)) return\n          this.#hint(this.#displayPaths.get(absolute), this.#currentCheckMode())\n        })\n\n        subscription.once(\"error\", () => this.#switchToPolling())\n        this.#subscriptions.push(subscription)\n      }\n\n      return true\n    } catch {\n      this.#closeSubscriptions()\n      return false\n    }\n  }\n\n  /**\n   * Permanently selects bounded polling after native backend failure.\n   * @returns {void}\n   */\n  #switchToPolling() {\n    if (this.#stopping || this.#polling) return\n    this.#polling = true\n    this.#closeSubscriptions()\n    this.#ensurePollingReconciliation()\n    this.#reporter?.watchBackend(\"polling\")\n    this.#observe({status: \"polling\", type: \"watch-backend\"})\n  }\n\n  /**\n   * Compares one bounded polling state observation.\n   * @returns {Promise<void>} Poll completion.\n   */\n  async #poll() {\n    if (this.#pollActive || this.#stopping) return\n    this.#pollActive = true\n    try {\n      if (this.#suppressedInvalidState !== undefined) {\n        try {\n          const project = await this.#manifestLoader.load(this.#manifestPath)\n\n          await this.#snapshotBuilder.build(project)\n          if (this.#quietTimer === undefined) this.#hint(undefined, this.#currentCheckMode())\n          return\n        } catch {\n          // An unchanged invalid graph remains one failed cycle until it becomes readable and valid.\n        }\n      }\n      const current = await this.#readWatchStates()\n      const changed = changedWatchStatePaths(this.#watchStates, current, this.#displayPaths)\n\n      this.#pollFailed = false\n      if (changed.length == 0) return\n      this.#watchStates = current\n      for (const changedPath of changed) this.#hint(changedPath, this.#currentCheckMode())\n    } catch {\n      if (!this.#pollFailed) {\n        this.#pollFailed = true\n        this.#hint(undefined, this.#currentCheckMode())\n      }\n    } finally {\n      this.#pollActive = false\n    }\n  }\n\n  /**\n   * Reads the immutable check mode captured by run.\n   * @returns {boolean} Active check mode.\n   */\n  #currentCheckMode() {\n    return this.#check\n  }\n\n  /**\n   * Reads one detached mutation-sensitive state observation through the selected backend.\n   * @returns {Promise<Map<string, string>>} Stable ordered path states.\n   */\n  #readWatchStates() {\n    const reader = projectWatchStateReaders.get(this) ?? readWatchStates\n\n    return reader(new Set(this.#watchedPaths))\n  }\n\n  #check = false\n\n  /**\n   * Starts one bounded reconciliation interval shared by native and fallback modes.\n   * @returns {void}\n   */\n  #ensurePollingReconciliation() {\n    this.#pollTimer ??= setInterval(() => void this.#poll(), this.#pollIntervalMs)\n  }\n\n  /**\n   * Closes every native subscription.\n   * @returns {void}\n   */\n  #closeSubscriptions() {\n    for (const subscription of this.#subscriptions) subscription.close()\n    this.#subscriptions = []\n  }\n\n  /**\n   * Closes subscriptions and pending reconciliation timers.\n   * @returns {void}\n   */\n  #closeEventBackends() {\n    if (this.#quietTimer !== undefined) clearTimeout(this.#quietTimer)\n    if (this.#pollTimer !== undefined) clearInterval(this.#pollTimer)\n    this.#quietTimer = undefined\n    this.#pollTimer = undefined\n    this.#closeSubscriptions()\n  }\n\n  /**\n   * Resolves shutdown only after startup and the active cycle have both relinquished ownership.\n   * @returns {void}\n   */\n  #finishStoppedIfIdle() {\n    if (this.#stopping && this.#startup === undefined && this.#activeCycle === undefined) this.#finishStopped()\n  }\n\n  /**\n   * Emits and resolves one clean watcher terminal.\n   * @returns {void}\n   */\n  #finishStopped() {\n    if (this.#finished) return\n    this.#finished = true\n    this.#running = false\n    this.#closeEventBackends()\n    this.#removeSignalHandlers()\n    this.#reporter?.watchStopped(this.#stopReason)\n    const result = Object.freeze({cycles: this.#cycle, reason: this.#stopReason, status: /** @type {const} */ (\"stopped\")})\n\n    this.#observe({status: \"stopped\", type: \"stopped\"})\n    this.#resolveCompletion(result)\n  }\n\n  /**\n   * Emits and resolves one startup-failure watcher terminal.\n   * @param {unknown} failure - Startup failure.\n   * @returns {void}\n   */\n  #finishFailed(failure) {\n    if (this.#finished) return\n    this.#finished = true\n    this.#running = false\n    this.#closeEventBackends()\n    this.#removeSignalHandlers()\n    this.#reporter?.watchFailed(failure)\n    const result = Object.freeze({cycles: this.#cycle, reason: \"startup failure\", status: /** @type {const} */ (\"failed\")})\n\n    this.#observe({status: \"failed\", type: \"stopped\"})\n    this.#resolveCompletion(result)\n  }\n\n  /**\n   * Removes process signal handlers owned by this coordinator.\n   * @returns {void}\n   */\n  #removeSignalHandlers() {\n    process.removeListener(\"SIGINT\", this.#signalHandler)\n    process.removeListener(\"SIGTERM\", this.#signalHandler)\n  }\n\n  /**\n   * Emits one internal deterministic lifecycle marker.\n   * @param {ProjectWatchObservation} event - Marker.\n   * @returns {void}\n   */\n  #observe(event) {\n    projectWatchObservers.get(this)?.(Object.freeze(event))\n  }\n}\n\n/**\n * Reads mutation-sensitive states only as polling/event deduplication hints.\n * Content hashes remain authoritative for cycle admission.\n * @param {Readonly<Set<string>>} filenames - Exact watched graph paths.\n * @returns {Promise<Map<string, string>>} Stable ordered path states.\n */\nasync function readWatchStates(filenames) {\n  const result = new Map()\n\n  for (const filename of [...filenames].sort(compareStrings)) {\n    try {\n      const status = await lstat(filename, {bigint: true})\n\n      result.set(filename, [status.dev, status.ino, status.mode, status.size, status.mtimeNs, status.ctimeNs].map(String).join(\":\"))\n    } catch (error) {\n      if (!isErrorCode(error, \"ENOENT\")) throw error\n      result.set(filename, \"missing\")\n    }\n  }\n\n  return result\n}\n\n/**\n * @typedef {(filenames: Readonly<Set<string>>) => Promise<Map<string, string>>} ProjectWatchStateReader\n */\n\n/**\n * Locates polling changes without treating metadata as build identity.\n * @param {Map<string, string>} previous - Previous states.\n * @param {Map<string, string>} current - Current states.\n * @param {Map<string, string>} displayPaths - Stable project-relative names.\n * @returns {string[]} Changed project paths.\n */\nfunction changedWatchStatePaths(previous, current, displayPaths) {\n  const filenames = new Set([...previous.keys(), ...current.keys()])\n\n  return [...filenames].filter(filename => previous.get(filename) != current.get(filename))\n    .map(filename => displayPaths.get(filename) ?? path.basename(filename)).sort(compareStrings)\n}\n\n/**\n * Serializes one ordered polling state only for repeated-invalid reconciliation suppression.\n * @param {Map<string, string>} states - Current watched path states.\n * @returns {string} Stable state key.\n */\nfunction watchStateKey(states) {\n  return JSON.stringify([...states].sort(([left], [right]) => compareStrings(left, right)))\n}\n\n/**\n * Checks whether either absolute path contains the other.\n * @param {string} left - First absolute path.\n * @param {string} right - Second absolute path.\n * @returns {boolean} Whether the paths overlap.\n */\nfunction pathsOverlap(left, right) {\n  return pathWithin(left, right) || pathWithin(right, left)\n}\n\n/**\n * Checks whether one absolute path is a root or descendant of another.\n * @param {string} root - Absolute root.\n * @param {string} candidate - Absolute candidate.\n * @returns {boolean} Whether the candidate belongs to the root.\n */\nfunction pathWithin(root, candidate) {\n  const relative = path.relative(root, candidate)\n\n  return relative.length == 0 || relative != \"..\" && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)\n}\n\n/**\n * Computes exact content/config changes between complete immutable snapshots.\n * @param {ProjectSnapshot | undefined} previous - Previous admitted snapshot.\n * @param {ProjectSnapshot} current - Current complete snapshot.\n * @param {string} manifestPath - Project-root-relative manifest display path.\n * @returns {string[]} Stable changed paths.\n */\nfunction changedSnapshotPaths(previous, current, manifestPath) {\n  if (previous === undefined) return [manifestPath, ...current.sources.map(({path: sourcePath}) => sourcePath)]\n  const changed = new Set()\n\n  if (previous.manifestText != current.manifestText) changed.add(manifestPath)\n  const previousSources = new Map(previous.sources.map(source => [source.path, source.source]))\n  const currentSources = new Map(current.sources.map(source => [source.path, source.source]))\n\n  for (const sourcePath of new Set([...previousSources.keys(), ...currentSources.keys()])) {\n    if (previousSources.get(sourcePath) != currentSources.get(sourcePath)) changed.add(sourcePath)\n  }\n\n  return [...changed].sort(compareStrings)\n}\n\n/**\n * Recognizes failures caused only by deterministic supersession.\n * @param {unknown} failure - Candidate failure.\n * @param {boolean} dirty - Whether a newer hint exists.\n * @returns {boolean} Whether the cycle was superseded.\n */\nfunction supersededFailure(failure, dirty) {\n  let current = failure\n\n  while (current instanceof Error) {\n    if (\"code\" in current && (current.code == \"WATCH_CANDIDATE_SUPERSEDED\" || current.code == \"WATCH_SNAPSHOT_CHANGED\" ||\n      dirty && current.code == \"PUBLICATION_CANCELLED\")) return true\n    current = current.cause\n  }\n\n  return false\n}\n\n/**\n * Checks one ordinary object.\n * @param {unknown} value - Candidate.\n * @returns {value is Record<string, unknown>} Whether the value is a plain object.\n */\nfunction isPlainObject(value) {\n  return typeof value == \"object\" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype\n}\n\n/**\n * Checks one bounded positive integer timing value.\n * @param {number} value - Candidate milliseconds.\n * @param {number} maximum - Inclusive maximum.\n * @returns {boolean} Whether the value is valid.\n */\nfunction validMilliseconds(value, maximum) {\n  return typeof value == \"number\" && Number.isInteger(value) && value > 0 && value <= maximum\n}\n\n/**\n * Checks a narrowed filesystem error code.\n * @param {unknown} error - Opaque error.\n * @param {string} code - Expected code.\n * @returns {boolean} Whether the code matches.\n */\nfunction isErrorCode(error, code) {\n  return error instanceof Error && \"code\" in error && error.code == code\n}\n\n/**\n * Compares stable protocol strings.\n * @param {string} left - Left string.\n * @param {string} right - Right string.\n * @returns {number} Sort order.\n */\nfunction compareStrings(left, right) {\n  return left.localeCompare(right, \"en\")\n}\n\n/**\n * @typedef ProjectWatchObservation\n * @property {\"cycle-start\" | \"cycle-terminal\" | \"dirty\" | \"ready\" | \"reconciled\" | \"stopped\" | \"watch-backend\"} type - Marker type.\n * @property {number} [cycle] - Related cycle number.\n * @property {\"cancelled\" | \"dirty\" | \"failed\" | \"native\" | \"polling\" | \"ready\" | \"recovered\" | \"started\" | \"stopped\" | \"succeeded\" | \"superseded\" | \"unchanged\"} status - Marker status.\n */\n\n/**\n * @typedef ProjectWatchResult\n * @property {\"failed\" | \"stopped\"} status - Watcher terminal state.\n * @property {number} cycles - Admitted cycle count.\n * @property {string} reason - Stable terminal reason.\n */\n\n/**\n * @typedef WatchCycleInput\n * @property {readonly string[]} changedPaths - Stable changed paths.\n * @property {boolean} check - Whether target checks are enabled.\n * @property {unknown} [failure] - Preserved reconciliation failure.\n * @property {SemantifoldProject | undefined} project - Reconciled project, when valid.\n * @property {ProjectSnapshot | undefined} snapshot - Reconciled snapshot, when valid.\n */\n"]}