semantifold 0.9.0 → 0.10.0

package/build/src/project-watch-reporter.js

@@ -0,0 +1,280 @@
+// @ts-check
+import { diagnosticRecord, formatHumanProjectFailure, normalizeDiagnostic } from "./project-reporter.js";
+/**
+ * Emits long-lived watch state with one terminal record for every admitted cycle and one for the watcher.
+ */
+export class ProjectWatchReporter {
+    /** @type {"human" | "ndjson"} */
+    #format;
+    /** @type {import("./project-reporter.js").WritableOutput} */
+    #stdout;
+    /** @type {import("./project-reporter.js").WritableOutput} */
+    #stderr;
+    /** @type {() => number} */
+    #now;
+    /** @type {string | null} */
+    #projectId = null;
+    /** @type {string | null} */
+    #snapshotHash = null;
+    /** @type {number | null} */
+    #cycle = null;
+    /** @type {readonly string[]} */
+    #changedPaths = Object.freeze([]);
+    #cycleStartedAt = 0;
+    #watchTerminal = false;
+    #cycleTerminal = true;
+    /**
+     * Creates a watch reporter.
+     * @param {{format?: "human" | "ndjson", now?: () => number, stderr?: import("./project-reporter.js").WritableOutput, stdout?: import("./project-reporter.js").WritableOutput}} [options] - Output mode, clock, and sinks.
+     */
+    constructor(options = {}) {
+        const format = options.format ?? "human";
+        if (format != "human" && format != "ndjson" || options.now !== undefined && typeof options.now != "function") {
+            throw new TypeError("Invalid project watch reporter options.");
+        }
+        this.#format = format;
+        this.#stdout = options.stdout ?? process.stdout;
+        this.#stderr = options.stderr ?? process.stderr;
+        this.#now = options.now ?? (() => performance.now());
+        if (typeof this.#stdout?.write != "function" || typeof this.#stderr?.write != "function") {
+            throw new TypeError("Project watch reporter requires writable output sinks.");
+        }
+    }
+    /**
+     * Reports validated watch startup.
+     * @param {string} projectId - Stable initial project identity.
+     * @returns {void}
+     */
+    watchStarted(projectId) {
+        this.#projectId = projectId;
+        this.#emit({ state: "watch-started" });
+    }
+    /**
+     * Reports the selected event backend.
+     * @param {"native" | "polling"} backend - Active event backend.
+     * @returns {void}
+     */
+    watchBackend(backend) {
+        this.#emit({ backend, state: "watch-backend" });
+    }
+    /**
+     * Begins one admitted build cycle.
+     * @param {ProjectWatchCycleContext} cycle - Cycle context.
+     * @returns {void}
+     */
+    cycleStarted(cycle) {
+        if (!this.#cycleTerminal || this.#watchTerminal)
+            throw new TypeError("Project watch reporter cycle lifecycle is invalid.");
+        this.#cycle = cycle.cycle;
+        this.#cycleTerminal = false;
+        this.#changedPaths = Object.freeze([...cycle.changedPaths]);
+        this.#projectId = cycle.projectId;
+        this.#snapshotHash = cycle.snapshotHash ?? null;
+        this.#cycleStartedAt = this.#now();
+        this.#emit({ changedPaths: this.#changedPaths, ...(cycle.snapshotHash === undefined ? {} : { snapshotHash: cycle.snapshotHash }), state: "cycle-started" });
+    }
+    /**
+     * Reports the cycle's validated project identity.
+     * @param {string} projectId - Validated project identity.
+     * @returns {void}
+     */
+    projectLoaded(projectId) {
+        this.#projectId = projectId;
+        this.#emit({ state: "project-loaded" });
+    }
+    /**
+     * Reports the cycle's complete source snapshot.
+     * @param {string} snapshotHash - Complete source snapshot hash.
+     * @returns {void}
+     */
+    snapshotLoaded(snapshotHash) {
+        this.#snapshotHash = snapshotHash;
+        this.#emit({ snapshotHash, state: "snapshot-loaded" });
+    }
+    /**
+     * Reports one generated target.
+     * @param {import("./project-build.js").ProjectBuildTargetResult} target - Generated target.
+     * @returns {void}
+     */
+    targetGenerated(target) {
+        this.#emit({
+            artifactCount: target.artifactCount,
+            language: target.language,
+            role: target.role,
+            state: "target-generated",
+            target: target.id
+        });
+    }
+    /**
+     * Reports one completed target-check stage.
+     * @param {{id: string, language: string, stage: import("./semantic/types.js").TargetCheckStageResult}} checked - Check stage.
+     * @returns {void}
+     */
+    targetChecked(checked) {
+        this.#emit({
+            argv: checked.stage.argv,
+            durationMs: checked.stage.durationMs,
+            exitCode: checked.stage.exitCode,
+            language: checked.language,
+            signal: checked.stage.signal,
+            stage: checked.stage.stage,
+            state: "target-checked",
+            stderr: checked.stage.stderr,
+            stdout: checked.stage.stdout,
+            target: checked.id,
+            tool: checked.stage.tool
+        });
+    }
+    /**
+     * Emits one successful or recovered cycle terminal.
+     * @param {import("./project-build.js").ProjectBuildSuccess} result - Published result.
+     * @param {boolean} recovered - Whether the prior ordinary cycle failed.
+     * @returns {void}
+     */
+    cycleSucceeded(result, recovered) {
+        this.#requireCycle();
+        this.#cycleTerminal = true;
+        this.#snapshotHash = result.snapshotHash;
+        const state = recovered ? "cycle-recovered" : "cycle-succeeded";
+        if (this.#format == "human") {
+            const verb = recovered ? "recovered" : "succeeded";
+            this.#stdout.write(`Watch cycle ${this.#cycle} ${verb}: project '${result.projectId}' published generation '${result.generationId}'.\n`);
+            return;
+        }
+        this.#write({
+            changedPaths: this.#changedPaths,
+            checked: result.checked,
+            durationMs: this.#duration(),
+            generationId: result.generationId,
+            snapshotHash: result.snapshotHash,
+            state,
+            targets: result.targets.map(target => ({ id: target.id, language: target.language, role: target.role })),
+            terminal: true,
+            terminalScope: "cycle"
+        });
+    }
+    /**
+     * Emits one failed, cancelled, or superseded cycle terminal.
+     * @param {unknown} failure - Preserved cycle failure.
+     * @param {"cancelled" | "failed" | "superseded"} status - Terminal classification.
+     * @returns {void}
+     */
+    cycleFailed(failure, status) {
+        this.#requireCycle();
+        this.#cycleTerminal = true;
+        const diagnostic = normalizeDiagnostic(failure);
+        if (this.#format == "human") {
+            this.#stderr.write(formatHumanProjectFailure(diagnostic, `Watch cycle ${this.#cycle} ${status}`));
+            return;
+        }
+        this.#write({
+            changedPaths: this.#changedPaths,
+            diagnostic: diagnosticRecord(diagnostic),
+            durationMs: this.#duration(),
+            ...(this.#snapshotHash === null ? {} : { snapshotHash: this.#snapshotHash }),
+            state: `cycle-${status}`,
+            terminal: true,
+            terminalScope: "cycle"
+        });
+    }
+    /**
+     * Reports reconciliation whose complete content hash did not change.
+     * @param {readonly string[]} changedPaths - Coalesced hint paths.
+     * @returns {void}
+     */
+    unchanged(changedPaths) {
+        this.#emit({ changedPaths, state: "reconciled-unchanged" });
+    }
+    /**
+     * Reports the first filesystem hint admitted while the current cycle remains active.
+     * @returns {void}
+     */
+    cycleDirty() {
+        this.#requireCycle();
+        this.#emit({ state: "cycle-dirty" });
+    }
+    /**
+     * Emits the sole clean watcher terminal.
+     * @param {string} reason - Shutdown reason.
+     * @returns {void}
+     */
+    watchStopped(reason) {
+        this.#requireWatchTerminal();
+        this.#watchTerminal = true;
+        if (this.#format == "human") {
+            this.#stdout.write(`Watch stopped: ${reason}\n`);
+            return;
+        }
+        this.#write({ reason, state: "watch-stopped", terminal: true, terminalScope: "watch" });
+    }
+    /**
+     * Emits the sole startup/configuration watcher terminal.
+     * @param {unknown} failure - Startup/configuration failure.
+     * @returns {void}
+     */
+    watchFailed(failure) {
+        this.#requireWatchTerminal();
+        this.#watchTerminal = true;
+        const diagnostic = normalizeDiagnostic(failure);
+        if (this.#format == "human") {
+            this.#stderr.write(formatHumanProjectFailure(diagnostic, "Watch failed"));
+            return;
+        }
+        this.#write({ diagnostic: diagnosticRecord(diagnostic), state: "watch-failed", terminal: true, terminalScope: "watch" });
+    }
+    /**
+     * Computes a stable non-negative cycle duration.
+     * @returns {number} Cycle duration.
+     */
+    #duration() {
+        const value = this.#now() - this.#cycleStartedAt;
+        return Number.isFinite(value) && value >= 0 ? value : 0;
+    }
+    /**
+     * Emits a non-terminal machine state when selected.
+     * @param {Record<string, unknown>} fields - State fields.
+     * @returns {void}
+     */
+    #emit(fields) {
+        if (this.#format == "ndjson")
+            this.#write(fields);
+    }
+    /**
+     * Writes one complete NDJSON record.
+     * @param {Record<string, unknown>} fields - Protocol fields.
+     * @returns {void}
+     */
+    #write(fields) {
+        this.#stdout.write(`${JSON.stringify({
+            cycle: this.#cycle,
+            project: this.#projectId,
+            schema: "SemantifoldWatchEvent",
+            version: 1,
+            ...fields
+        })}\n`);
+    }
+    /**
+     * Requires one open cycle terminal slot.
+     * @returns {void}
+     */
+    #requireCycle() {
+        if (this.#cycleTerminal || this.#watchTerminal)
+            throw new TypeError("Project watch reporter has no open cycle.");
+    }
+    /**
+     * Requires one open watcher terminal slot.
+     * @returns {void}
+     */
+    #requireWatchTerminal() {
+        if (this.#watchTerminal || !this.#cycleTerminal)
+            throw new TypeError("Project watch reporter watcher lifecycle is invalid.");
+    }
+}
+/**
+ * @typedef ProjectWatchCycleContext
+ * @property {readonly string[]} changedPaths - Stable changed paths.
+ * @property {number} cycle - One-based cycle number.
+ * @property {string} projectId - Stable project identity.
+ * @property {string} [snapshotHash] - Complete snapshot hash when reconciliation succeeded.
+ */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-watch-reporter.js","sourceRoot":"","sources":["../../src/project-watch-reporter.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {diagnosticRecord, formatHumanProjectFailure, normalizeDiagnostic} from \"./project-reporter.js\"\n\n/**\n * Emits long-lived watch state with one terminal record for every admitted cycle and one for the watcher.\n */\nexport class ProjectWatchReporter {\n  /** @type {\"human\" | \"ndjson\"} */\n  #format\n  /** @type {import(\"./project-reporter.js\").WritableOutput} */\n  #stdout\n  /** @type {import(\"./project-reporter.js\").WritableOutput} */\n  #stderr\n  /** @type {() => number} */\n  #now\n  /** @type {string | null} */\n  #projectId = null\n  /** @type {string | null} */\n  #snapshotHash = null\n  /** @type {number | null} */\n  #cycle = null\n  /** @type {readonly string[]} */\n  #changedPaths = Object.freeze([])\n  #cycleStartedAt = 0\n  #watchTerminal = false\n  #cycleTerminal = true\n\n  /**\n   * Creates a watch reporter.\n   * @param {{format?: \"human\" | \"ndjson\", now?: () => number, stderr?: import(\"./project-reporter.js\").WritableOutput, stdout?: import(\"./project-reporter.js\").WritableOutput}} [options] - Output mode, clock, and sinks.\n   */\n  constructor(options = {}) {\n    const format = options.format ?? \"human\"\n\n    if (format != \"human\" && format != \"ndjson\" || options.now !== undefined && typeof options.now != \"function\") {\n      throw new TypeError(\"Invalid project watch reporter options.\")\n    }\n    this.#format = format\n    this.#stdout = options.stdout ?? process.stdout\n    this.#stderr = options.stderr ?? process.stderr\n    this.#now = options.now ?? (() => performance.now())\n    if (typeof this.#stdout?.write != \"function\" || typeof this.#stderr?.write != \"function\") {\n      throw new TypeError(\"Project watch reporter requires writable output sinks.\")\n    }\n  }\n\n  /**\n   * Reports validated watch startup.\n   * @param {string} projectId - Stable initial project identity.\n   * @returns {void}\n   */\n  watchStarted(projectId) {\n    this.#projectId = projectId\n    this.#emit({state: \"watch-started\"})\n  }\n\n  /**\n   * Reports the selected event backend.\n   * @param {\"native\" | \"polling\"} backend - Active event backend.\n   * @returns {void}\n   */\n  watchBackend(backend) {\n    this.#emit({backend, state: \"watch-backend\"})\n  }\n\n  /**\n   * Begins one admitted build cycle.\n   * @param {ProjectWatchCycleContext} cycle - Cycle context.\n   * @returns {void}\n   */\n  cycleStarted(cycle) {\n    if (!this.#cycleTerminal || this.#watchTerminal) throw new TypeError(\"Project watch reporter cycle lifecycle is invalid.\")\n    this.#cycle = cycle.cycle\n    this.#cycleTerminal = false\n    this.#changedPaths = Object.freeze([...cycle.changedPaths])\n    this.#projectId = cycle.projectId\n    this.#snapshotHash = cycle.snapshotHash ?? null\n    this.#cycleStartedAt = this.#now()\n    this.#emit({changedPaths: this.#changedPaths, ...(cycle.snapshotHash === undefined ? {} : {snapshotHash: cycle.snapshotHash}), state: \"cycle-started\"})\n  }\n\n  /**\n   * Reports the cycle's validated project identity.\n   * @param {string} projectId - Validated project identity.\n   * @returns {void}\n   */\n  projectLoaded(projectId) {\n    this.#projectId = projectId\n    this.#emit({state: \"project-loaded\"})\n  }\n\n  /**\n   * Reports the cycle's complete source snapshot.\n   * @param {string} snapshotHash - Complete source snapshot hash.\n   * @returns {void}\n   */\n  snapshotLoaded(snapshotHash) {\n    this.#snapshotHash = snapshotHash\n    this.#emit({snapshotHash, state: \"snapshot-loaded\"})\n  }\n\n  /**\n   * Reports one generated target.\n   * @param {import(\"./project-build.js\").ProjectBuildTargetResult} target - Generated target.\n   * @returns {void}\n   */\n  targetGenerated(target) {\n    this.#emit({\n      artifactCount: target.artifactCount,\n      language: target.language,\n      role: target.role,\n      state: \"target-generated\",\n      target: target.id\n    })\n  }\n\n  /**\n   * Reports one completed target-check stage.\n   * @param {{id: string, language: string, stage: import(\"./semantic/types.js\").TargetCheckStageResult}} checked - Check stage.\n   * @returns {void}\n   */\n  targetChecked(checked) {\n    this.#emit({\n      argv: checked.stage.argv,\n      durationMs: checked.stage.durationMs,\n      exitCode: checked.stage.exitCode,\n      language: checked.language,\n      signal: checked.stage.signal,\n      stage: checked.stage.stage,\n      state: \"target-checked\",\n      stderr: checked.stage.stderr,\n      stdout: checked.stage.stdout,\n      target: checked.id,\n      tool: checked.stage.tool\n    })\n  }\n\n  /**\n   * Emits one successful or recovered cycle terminal.\n   * @param {import(\"./project-build.js\").ProjectBuildSuccess} result - Published result.\n   * @param {boolean} recovered - Whether the prior ordinary cycle failed.\n   * @returns {void}\n   */\n  cycleSucceeded(result, recovered) {\n    this.#requireCycle()\n    this.#cycleTerminal = true\n    this.#snapshotHash = result.snapshotHash\n    const state = recovered ? \"cycle-recovered\" : \"cycle-succeeded\"\n\n    if (this.#format == \"human\") {\n      const verb = recovered ? \"recovered\" : \"succeeded\"\n\n      this.#stdout.write(`Watch cycle ${this.#cycle} ${verb}: project '${result.projectId}' published generation '${result.generationId}'.\\n`)\n      return\n    }\n    this.#write({\n      changedPaths: this.#changedPaths,\n      checked: result.checked,\n      durationMs: this.#duration(),\n      generationId: result.generationId,\n      snapshotHash: result.snapshotHash,\n      state,\n      targets: result.targets.map(target => ({id: target.id, language: target.language, role: target.role})),\n      terminal: true,\n      terminalScope: \"cycle\"\n    })\n  }\n\n  /**\n   * Emits one failed, cancelled, or superseded cycle terminal.\n   * @param {unknown} failure - Preserved cycle failure.\n   * @param {\"cancelled\" | \"failed\" | \"superseded\"} status - Terminal classification.\n   * @returns {void}\n   */\n  cycleFailed(failure, status) {\n    this.#requireCycle()\n    this.#cycleTerminal = true\n    const diagnostic = normalizeDiagnostic(failure)\n\n    if (this.#format == \"human\") {\n      this.#stderr.write(formatHumanProjectFailure(diagnostic, `Watch cycle ${this.#cycle} ${status}`))\n      return\n    }\n    this.#write({\n      changedPaths: this.#changedPaths,\n      diagnostic: diagnosticRecord(diagnostic),\n      durationMs: this.#duration(),\n      ...(this.#snapshotHash === null ? {} : {snapshotHash: this.#snapshotHash}),\n      state: `cycle-${status}`,\n      terminal: true,\n      terminalScope: \"cycle\"\n    })\n  }\n\n  /**\n   * Reports reconciliation whose complete content hash did not change.\n   * @param {readonly string[]} changedPaths - Coalesced hint paths.\n   * @returns {void}\n   */\n  unchanged(changedPaths) {\n    this.#emit({changedPaths, state: \"reconciled-unchanged\"})\n  }\n\n  /**\n   * Reports the first filesystem hint admitted while the current cycle remains active.\n   * @returns {void}\n   */\n  cycleDirty() {\n    this.#requireCycle()\n    this.#emit({state: \"cycle-dirty\"})\n  }\n\n  /**\n   * Emits the sole clean watcher terminal.\n   * @param {string} reason - Shutdown reason.\n   * @returns {void}\n   */\n  watchStopped(reason) {\n    this.#requireWatchTerminal()\n    this.#watchTerminal = true\n    if (this.#format == \"human\") {\n      this.#stdout.write(`Watch stopped: ${reason}\\n`)\n      return\n    }\n    this.#write({reason, state: \"watch-stopped\", terminal: true, terminalScope: \"watch\"})\n  }\n\n  /**\n   * Emits the sole startup/configuration watcher terminal.\n   * @param {unknown} failure - Startup/configuration failure.\n   * @returns {void}\n   */\n  watchFailed(failure) {\n    this.#requireWatchTerminal()\n    this.#watchTerminal = true\n    const diagnostic = normalizeDiagnostic(failure)\n\n    if (this.#format == \"human\") {\n      this.#stderr.write(formatHumanProjectFailure(diagnostic, \"Watch failed\"))\n      return\n    }\n    this.#write({diagnostic: diagnosticRecord(diagnostic), state: \"watch-failed\", terminal: true, terminalScope: \"watch\"})\n  }\n\n  /**\n   * Computes a stable non-negative cycle duration.\n   * @returns {number} Cycle duration.\n   */\n  #duration() {\n    const value = this.#now() - this.#cycleStartedAt\n\n    return Number.isFinite(value) && value >= 0 ? value : 0\n  }\n\n  /**\n   * Emits a non-terminal machine state when selected.\n   * @param {Record<string, unknown>} fields - State fields.\n   * @returns {void}\n   */\n  #emit(fields) {\n    if (this.#format == \"ndjson\") this.#write(fields)\n  }\n\n  /**\n   * Writes one complete NDJSON record.\n   * @param {Record<string, unknown>} fields - Protocol fields.\n   * @returns {void}\n   */\n  #write(fields) {\n    this.#stdout.write(`${JSON.stringify({\n      cycle: this.#cycle,\n      project: this.#projectId,\n      schema: \"SemantifoldWatchEvent\",\n      version: 1,\n      ...fields\n    })}\\n`)\n  }\n\n  /**\n   * Requires one open cycle terminal slot.\n   * @returns {void}\n   */\n  #requireCycle() {\n    if (this.#cycleTerminal || this.#watchTerminal) throw new TypeError(\"Project watch reporter has no open cycle.\")\n  }\n\n  /**\n   * Requires one open watcher terminal slot.\n   * @returns {void}\n   */\n  #requireWatchTerminal() {\n    if (this.#watchTerminal || !this.#cycleTerminal) throw new TypeError(\"Project watch reporter watcher lifecycle is invalid.\")\n  }\n}\n\n/**\n * @typedef ProjectWatchCycleContext\n * @property {readonly string[]} changedPaths - Stable changed paths.\n * @property {number} cycle - One-based cycle number.\n * @property {string} projectId - Stable project identity.\n * @property {string} [snapshotHash] - Complete snapshot hash when reconciliation succeeded.\n */\n"]}

package/build/src/project-watch.d.ts

@@ -0,0 +1,133 @@
+import { watch as watchFileSystem } from "node:fs";
+import { 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";
+/**
+ * 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 declare function observeProjectWatch(coordinator: ProjectWatchCoordinator, observer: (event: ProjectWatchObservation) => void): void;
+/**
+ * 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 declare function createProjectWatchCoordinator(options: {
+    builder?: ProjectBuilder;
+    manifestLoader?: ProjectManifestLoader;
+    nativeWatch: typeof watchFileSystem;
+    pollIntervalMs?: number;
+    quietPeriodMs?: number;
+    snapshotBuilder?: ProjectSnapshotBuilder;
+    watchStateReader?: ProjectWatchStateReader;
+}): ProjectWatchCoordinator;
+/**
+ * Turns filesystem hints into serialized complete project build transactions.
+ */
+export declare class ProjectWatchCoordinator {
+    #private;
+    /**
+     * 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?: {
+        builder?: ProjectBuilder;
+        manifestLoader?: ProjectManifestLoader;
+        pollIntervalMs?: number;
+        quietPeriodMs?: number;
+        snapshotBuilder?: ProjectSnapshotBuilder;
+    });
+    /**
+     * 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?: string, reporter?: ProjectWatchReporter, options?: {
+        check?: boolean;
+    }): Promise<Readonly<ProjectWatchResult>>;
+    /**
+     * 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.
+     */
+    stop(reason?: string): Promise<Readonly<ProjectWatchResult>>;
+}
+export type ProjectWatchStateReader = (filenames: Readonly<Set<string>>) => Promise<Map<string, string>>;
+export type ProjectWatchObservation = {
+    /**
+     * - Marker type.
+     */
+    type: "cycle-start" | "cycle-terminal" | "dirty" | "ready" | "reconciled" | "stopped" | "watch-backend";
+    /**
+     * - Related cycle number.
+     */
+    cycle?: number;
+    /**
+     * - Marker status.
+     */
+    status: "cancelled" | "dirty" | "failed" | "native" | "polling" | "ready" | "recovered" | "started" | "stopped" | "succeeded" | "superseded" | "unchanged";
+};
+export type ProjectWatchResult = {
+    /**
+     * - Watcher terminal state.
+     */
+    status: "failed" | "stopped";
+    /**
+     * - Admitted cycle count.
+     */
+    cycles: number;
+    /**
+     * - Stable terminal reason.
+     */
+    reason: string;
+};
+export type WatchCycleInput = {
+    /**
+     * - Stable changed paths.
+     */
+    changedPaths: readonly string[];
+    /**
+     * - Whether target checks are enabled.
+     */
+    check: boolean;
+    /**
+     * - Preserved reconciliation failure.
+     */
+    failure?: unknown;
+    /**
+     * - Reconciled project, when valid.
+     */
+    project: SemantifoldProject | undefined;
+    /**
+     * - Reconciled snapshot, when valid.
+     */
+    snapshot: ProjectSnapshot | undefined;
+};
+/**
+ * @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=project-watch.d.ts.map

package/build/src/project-watch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-watch.d.ts","sourceRoot":"","sources":["../../src/project-watch.js"],"names":[],"mappings":"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"}