semantifold 0.8.0 → 0.10.0

package/build/src/project-snapshot.js

@@ -0,0 +1,362 @@
+// @ts-check
+import { createHash } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, open, realpath } from "node:fs/promises";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { SemantifoldProject } from "./project-manifest.js";
+const snapshotAttempts = 2;
+/** @type {WeakMap<ProjectSnapshotBuilder, (event: Readonly<{attempt: number, pass: number, path: string}>) => Promise<void> | void>} */
+const snapshotReadObservers = new WeakMap();
+/**
+ * Installs an internal deterministic read observer for real-filesystem snapshot specs.
+ * This helper is intentionally not part of the package root API.
+ * @param {ProjectSnapshotBuilder} builder - Snapshot builder instance.
+ * @param {(event: Readonly<{attempt: number, pass: number, path: string}>) => Promise<void> | void} observer - Ordered read observer.
+ * @returns {void}
+ */
+export function observeProjectSnapshotReads(builder, observer) {
+    if (!(builder instanceof ProjectSnapshotBuilder) || typeof observer != "function") {
+        throw new TypeError("Invalid project snapshot read observer.");
+    }
+    snapshotReadObservers.set(builder, observer);
+}
+/**
+ * One complete immutable ordered source snapshot.
+ */
+export class ProjectSnapshot {
+    /**
+     * Constructs a trusted snapshot value.
+     * @param {{hash: string, manifestText: string, projectId: string, sources: SnapshotSource[]}} value - Stable snapshot fields.
+     */
+    constructor(value) {
+        this.hash = value.hash;
+        this.manifestText = value.manifestText;
+        this.projectId = value.projectId;
+        this.sources = Object.freeze(value.sources.map(source => Object.freeze({ ...source })));
+        Object.freeze(this);
+    }
+}
+/**
+ * Reads one complete graph twice before exposing an immutable source snapshot.
+ */
+export class ProjectSnapshotBuilder {
+    /**
+     * Builds a stable snapshot with one bounded retry when the graph changes mid-read.
+     * @param {SemantifoldProject} project - Validated immutable project.
+     * @returns {Promise<ProjectSnapshot>} Stable complete snapshot.
+     */
+    async build(project) {
+        if (!(project instanceof SemantifoldProject)) {
+            snapshotFailure("INVALID_PROJECT_SNAPSHOT", "project", "Snapshot building requires a validated Semantifold project.");
+        }
+        let unstablePath = "semantifold.json";
+        for (let attempt = 0; attempt < snapshotAttempts; attempt += 1) {
+            try {
+                const first = await readProjectGraph(project, this, attempt + 1, 1);
+                const second = await readProjectGraph(project, this, attempt + 1, 2);
+                const difference = graphDifference(first, second, project);
+                if (difference !== null) {
+                    unstablePath = difference;
+                    continue;
+                }
+                const finalDifference = await graphStateDifference(project, second);
+                if (finalDifference !== null) {
+                    unstablePath = finalDifference;
+                    continue;
+                }
+                const manifestText = decodeUtf8(first.manifestBytes, "semantifold.json", project.id);
+                if (manifestText != project.manifestText) {
+                    snapshotFailure("UNSTABLE_PROJECT_SNAPSHOT", project.id, "Project manifest changed after it was validated; restart the build from the new manifest.", manifestLocation());
+                }
+                const sources = project.sources.map((source, index) => ({
+                    id: source.id,
+                    language: source.language,
+                    path: source.path,
+                    source: decodeUtf8(first.sourceBytes[index], source.path, project.id)
+                }));
+                return new ProjectSnapshot({
+                    hash: snapshotHash(first.manifestBytes, sources),
+                    manifestText,
+                    projectId: project.id,
+                    sources
+                });
+            }
+            catch (error) {
+                if (!(error instanceof UnstableSnapshotRead))
+                    throw error;
+                unstablePath = error.path;
+            }
+        }
+        return snapshotFailure("UNSTABLE_PROJECT_SNAPSHOT", project.id, "Project manifest or source files changed repeatedly while the snapshot was loading.", sourceLocation(unstablePath));
+    }
+}
+/**
+ * Reads every declared file in stable manifest order.
+ * @param {SemantifoldProject} project - Validated project.
+ * @param {ProjectSnapshotBuilder} builder - Active builder.
+ * @param {number} attempt - One-based bounded attempt.
+ * @param {number} pass - One-based verification pass.
+ * @returns {Promise<ProjectGraphRead>} Complete graph bytes.
+ */
+async function readProjectGraph(project, builder, attempt, pass) {
+    const manifest = await readStableRegularFile(project.manifestPath, "semantifold.json", project.id, true);
+    await snapshotReadObservers.get(builder)?.(Object.freeze({ attempt, pass, path: "semantifold.json" }));
+    /** @type {Buffer[]} */
+    const sourceBytes = [];
+    /** @type {string[]} */
+    const sourceIdentities = [];
+    /** @type {string[]} */
+    const sourceStates = [];
+    const uniqueSourceIdentities = new Set();
+    for (const source of project.sources) {
+        const read = await readStableRegularFile(source.absolutePath, source.path, project.id, false);
+        if (uniqueSourceIdentities.has(read.identity)) {
+            snapshotFailure("PROJECT_SOURCE_ALIAS", project.id, "Project source paths must not alias the same file.", sourceLocation(source.path));
+        }
+        uniqueSourceIdentities.add(read.identity);
+        sourceBytes.push(read.bytes);
+        sourceIdentities.push(read.identity);
+        sourceStates.push(read.state);
+        await snapshotReadObservers.get(builder)?.(Object.freeze({ attempt, pass, path: source.path }));
+    }
+    return {
+        manifestBytes: manifest.bytes,
+        manifestIdentity: manifest.identity,
+        manifestState: manifest.state,
+        sourceBytes,
+        sourceIdentities,
+        sourceStates
+    };
+}
+/**
+ * Reads exact bytes through one descriptor while detecting replacement or mutation.
+ * @param {string} filename - Canonical absolute path.
+ * @param {string} displayPath - Project-relative diagnostic path.
+ * @param {string} projectId - Project identity.
+ * @param {boolean} manifest - Whether this is the project manifest.
+ * @returns {Promise<StableFileRead>} Stable bytes and filesystem identity.
+ */
+async function readStableRegularFile(filename, displayPath, projectId, manifest) {
+    let handle;
+    try {
+        handle = await open(filename, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+        const beforePath = await realpath(filename);
+        const before = await handle.stat({ bigint: true });
+        const beforeEntry = await lstat(filename, { bigint: true });
+        if (!before.isFile() || !beforeEntry.isFile() || beforePath != filename || !sameFileIdentity(before, beforeEntry)) {
+            throw new UnstableSnapshotRead(displayPath);
+        }
+        const bytes = await handle.readFile();
+        const after = await handle.stat({ bigint: true });
+        const afterPath = await realpath(filename);
+        const afterEntry = await lstat(filename, { bigint: true });
+        if (!after.isFile() || !afterEntry.isFile() || afterPath != filename || !sameFileState(before, after) ||
+            !sameFileIdentity(after, afterEntry) || BigInt(bytes.byteLength) != after.size) {
+            throw new UnstableSnapshotRead(displayPath);
+        }
+        return {
+            bytes,
+            identity: `${String(before.dev)}:${String(before.ino)}`,
+            state: stableFileState(before)
+        };
+    }
+    catch (error) {
+        if (error instanceof UnstableSnapshotRead)
+            throw error;
+        return snapshotFailure(manifest ? "PROJECT_MANIFEST_READ_FAILED" : "PROJECT_SOURCE_READ_FAILED", projectId, manifest ? "Project manifest could not be read into a stable snapshot." : "Declared source could not be read into a stable snapshot.", sourceLocation(displayPath), error);
+    }
+    finally {
+        await handle?.close();
+    }
+}
+/**
+ * Compares descriptor state around one read.
+ * @param {import("node:fs").BigIntStats} left - State before the read.
+ * @param {import("node:fs").BigIntStats} right - State after the read.
+ * @returns {boolean} Whether identity and mutation-sensitive metadata agree.
+ */
+function sameFileState(left, right) {
+    return left.dev == right.dev && left.ino == right.ino && left.size == right.size &&
+        left.mtimeNs == right.mtimeNs && left.ctimeNs == right.ctimeNs;
+}
+/**
+ * Compares the path entry with the opened descriptor identity.
+ * @param {import("node:fs").BigIntStats} left - Open descriptor or path state.
+ * @param {import("node:fs").BigIntStats} right - Open descriptor or path state.
+ * @returns {boolean} Whether both identify the same filesystem node.
+ */
+function sameFileIdentity(left, right) {
+    return left.dev == right.dev && left.ino == right.ino;
+}
+/**
+ * Serializes mutation-sensitive descriptor state for complete-graph comparison.
+ * @param {import("node:fs").BigIntStats} status - Stable descriptor state.
+ * @returns {string} Internal state identity.
+ */
+function stableFileState(status) {
+    return [status.dev, status.ino, status.size, status.mtimeNs, status.ctimeNs].map(String).join(":");
+}
+/**
+ * Locates the first byte difference between two complete graph reads.
+ * @param {ProjectGraphRead} left - First graph.
+ * @param {ProjectGraphRead} right - Second graph.
+ * @param {SemantifoldProject} project - Ordered path authority.
+ * @returns {string | null} Project-relative changed path, or null.
+ */
+function graphDifference(left, right, project) {
+    if (left.manifestIdentity != right.manifestIdentity || left.manifestState != right.manifestState ||
+        !left.manifestBytes.equals(right.manifestBytes)) {
+        return "semantifold.json";
+    }
+    if (left.sourceBytes.length != right.sourceBytes.length)
+        return "semantifold.json";
+    const index = left.sourceBytes.findIndex((bytes, sourceIndex) => left.sourceIdentities[sourceIndex] != right.sourceIdentities[sourceIndex] ||
+        left.sourceStates[sourceIndex] != right.sourceStates[sourceIndex] || !bytes.equals(right.sourceBytes[sourceIndex]));
+    return index == -1 ? null : project.sources[index].path;
+}
+/**
+ * Revalidates every path entry after the final complete graph read.
+ * @param {SemantifoldProject} project - Ordered path authority.
+ * @param {ProjectGraphRead} graph - Final complete graph read.
+ * @returns {Promise<string | null>} First changed project-relative path, or null.
+ */
+async function graphStateDifference(project, graph) {
+    const entries = [{
+            filename: project.manifestPath,
+            identity: graph.manifestIdentity,
+            path: "semantifold.json",
+            state: graph.manifestState
+        }, ...project.sources.map((source, index) => ({
+            filename: source.absolutePath,
+            identity: graph.sourceIdentities[index],
+            path: source.path,
+            state: graph.sourceStates[index]
+        }))];
+    for (const entry of entries) {
+        try {
+            const status = await lstat(entry.filename, { bigint: true });
+            const exact = await realpath(entry.filename);
+            if (!status.isFile() || exact != entry.filename || `${String(status.dev)}:${String(status.ino)}` != entry.identity ||
+                stableFileState(status) != entry.state)
+                return entry.path;
+        }
+        catch (_error) {
+            return entry.path;
+        }
+    }
+    return null;
+}
+/**
+ * Computes a framed deterministic SHA-256 identity over exact manifest and ordered source inputs.
+ * @param {Buffer} manifestBytes - Exact manifest bytes.
+ * @param {readonly SnapshotSource[]} sources - Ordered decoded sources.
+ * @returns {string} Lowercase SHA-256 digest.
+ */
+function snapshotHash(manifestBytes, sources) {
+    const hash = createHash("sha256");
+    updateHash(hash, "SemantifoldProjectSnapshot/1");
+    updateHash(hash, manifestBytes);
+    for (const source of sources) {
+        updateHash(hash, source.id);
+        updateHash(hash, source.path);
+        updateHash(hash, source.language);
+        updateHash(hash, source.source);
+    }
+    return hash.digest("hex");
+}
+/**
+ * Adds one length-framed field to a content hash.
+ * @param {import("node:crypto").Hash} hash - Active hash.
+ * @param {string | Buffer} value - Field bytes.
+ * @returns {void}
+ */
+function updateHash(hash, value) {
+    const bytes = Buffer.isBuffer(value) ? value : Buffer.from(value, "utf8");
+    const length = Buffer.alloc(8);
+    length.writeBigUInt64BE(BigInt(bytes.byteLength));
+    hash.update(length);
+    hash.update(bytes);
+}
+/**
+ * Decodes strict UTF-8 for parser inputs.
+ * @param {Buffer} bytes - Exact file bytes.
+ * @param {string} filename - Project-relative filename.
+ * @param {string} projectId - Project identity.
+ * @returns {string} Decoded source.
+ */
+function decodeUtf8(bytes, filename, projectId) {
+    try {
+        return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    }
+    catch (error) {
+        return snapshotFailure("INVALID_PROJECT_SOURCE_ENCODING", projectId, "Project manifests and sources must be valid UTF-8.", sourceLocation(filename), error);
+    }
+}
+/** Internal marker for a read that may safely use the bounded retry. */
+class UnstableSnapshotRead extends Error {
+    /**
+     * Creates an internal retry marker.
+     * @param {string} path - Project-relative unstable path.
+     */
+    constructor(path) {
+        super("Unstable project snapshot read.");
+        this.path = path;
+    }
+}
+/**
+ * Creates the stable manifest boundary location.
+ * @returns {import("./semantic/types.js").SourceLocation} Manifest location.
+ */
+function manifestLocation() {
+    return sourceLocation("semantifold.json");
+}
+/**
+ * Creates a stable project-relative file location.
+ * @param {string} filename - Project-relative filename.
+ * @returns {import("./semantic/types.js").SourceLocation} Start-of-file location.
+ */
+function sourceLocation(filename) {
+    const point = { column: 1, line: 1, offset: 0 };
+    return { end: point, filename, start: point };
+}
+/**
+ * Throws one stable snapshot diagnostic.
+ * @param {string} code - Stable diagnostic code.
+ * @param {string} projectId - Project identity.
+ * @param {string} message - Stable detail.
+ * @param {import("./semantic/types.js").SourceLocation} [location] - Project-relative location.
+ * @param {unknown} [error] - Preserved cause.
+ * @returns {never} Always throws.
+ */
+function snapshotFailure(code, projectId, message, location, error) {
+    throw new SemantifoldDiagnostic({
+        cause: error instanceof Error ? error : undefined,
+        code,
+        language: projectId,
+        location,
+        message
+    });
+}
+/**
+ * @typedef SnapshotSource
+ * @property {string} id - Stable semantic module identity.
+ * @property {import("./semantic/types.js").SemanticLanguage} language - Registered source language.
+ * @property {string} path - Project-relative source path.
+ * @property {string} source - Exact decoded source text.
+ */
+/**
+ * @typedef ProjectGraphRead
+ * @property {Buffer} manifestBytes - Exact manifest bytes.
+ * @property {string} manifestIdentity - Stable manifest device/inode identity.
+ * @property {string} manifestState - Stable manifest mutation-sensitive state.
+ * @property {Buffer[]} sourceBytes - Exact source bytes in manifest order.
+ * @property {string[]} sourceIdentities - Stable source device/inode identities in manifest order.
+ * @property {string[]} sourceStates - Stable source mutation-sensitive states in manifest order.
+ */
+/**
+ * @typedef StableFileRead
+ * @property {Buffer} bytes - Exact stable file bytes.
+ * @property {string} identity - Stable device/inode identity.
+ * @property {string} state - Stable mutation-sensitive file state.
+ */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"project-snapshot.js","sourceRoot":"","sources":["../../src/project-snapshot.js"],"names":[],"mappings":"AAAA,YAAY;AAEZ,OAAO,EAAC,UAAU,EAAC,MAAM,aAAa,CAAA;AACtC,OAAO,EAAC,SAAS,EAAC,MAAM,SAAS,CAAA;AACjC,OAAO,EAAC,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAC,MAAM,kBAAkB,CAAA;AACtD,OAAO,EAAC,qBAAqB,EAAC,MAAM,iBAAiB,CAAA;AACrD,OAAO,EAAC,kBAAkB,EAAC,MAAM,uBAAuB,CAAA;AAExD,MAAM,gBAAgB,GAAG,CAAC,CAAA;AAC1B,wIAAwI;AACxI,MAAM,qBAAqB,GAAG,IAAI,OAAO,EAAE,CAAA;AAE3C;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B,CAAC,OAAO,EAAE,QAAQ;IAC3D,IAAI,CAAC,CAAC,OAAO,YAAY,sBAAsB,CAAC,IAAI,OAAO,QAAQ,IAAI,UAAU,EAAE,CAAC;QAClF,MAAM,IAAI,SAAS,CAAC,yCAAyC,CAAC,CAAA;IAChE,CAAC;IACD,qBAAqB,CAAC,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,CAAA;AAC9C,CAAC;AAED;;GAEG;AACH,MAAM,OAAO,eAAe;IAC1B;;;OAGG;IACH,YAAY,KAAK;QACf,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAA;QACtB,IAAI,CAAC,YAAY,GAAG,KAAK,CAAC,YAAY,CAAA;QACtC,IAAI,CAAC,SAAS,GAAG,KAAK,CAAC,SAAS,CAAA;QAChC,IAAI,CAAC,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAC,GAAG,MAAM,EAAC,CAAC,CAAC,CAAC,CAAA;QACrF,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAA;IACrB,CAAC;CACF;AAED;;GAEG;AACH,MAAM,OAAO,sBAAsB;IACjC;;;;OAIG;IACH,KAAK,CAAC,KAAK,CAAC,OAAO;QACjB,IAAI,CAAC,CAAC,OAAO,YAAY,kBAAkB,CAAC,EAAE,CAAC;YAC7C,eAAe,CAAC,0BAA0B,EAAE,SAAS,EAAE,6DAA6D,CAAC,CAAA;QACvH,CAAC;QACD,IAAI,YAAY,GAAG,kBAAkB,CAAA;QAErC,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,gBAAgB,EAAE,OAAO,IAAI,CAAC,EAAE,CAAC;YAC/D,IAAI,CAAC;gBACH,MAAM,KAAK,GAAG,MAAM,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,CAAA;gBACnE,MAAM,MAAM,GAAG,MAAM,gBAAgB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,GAAG,CAAC,EAAE,CAAC,CAAC,CAAA;gBACpE,MAAM,UAAU,GAAG,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,CAAA;gBAE1D,IAAI,UAAU,KAAK,IAAI,EAAE,CAAC;oBACxB,YAAY,GAAG,UAAU,CAAA;oBACzB,SAAQ;gBACV,CAAC;gBACD,MAAM,eAAe,GAAG,MAAM,oBAAoB,CAAC,OAAO,EAAE,MAAM,CAAC,CAAA;gBAEnE,IAAI,eAAe,KAAK,IAAI,EAAE,CAAC;oBAC7B,YAAY,GAAG,eAAe,CAAA;oBAC9B,SAAQ;gBACV,CAAC;gBACD,MAAM,YAAY,GAAG,UAAU,CAAC,KAAK,CAAC,aAAa,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,CAAC,CAAA;gBAEpF,IAAI,YAAY,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;oBACzC,eAAe,CAAC,2BAA2B,EAAE,OAAO,CAAC,EAAE,EACrD,2FAA2F,EAAE,gBAAgB,EAAE,CAAC,CAAA;gBACpH,CAAC;gBACD,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;oBACtD,EAAE,EAAE,MAAM,CAAC,EAAE;oBACb,QAAQ,EAAE,MAAM,CAAC,QAAQ;oBACzB,IAAI,EAAE,MAAM,CAAC,IAAI;oBACjB,MAAM,EAAE,UAAU,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,CAAC;iBACtE,CAAC,CAAC,CAAA;gBAEH,OAAO,IAAI,eAAe,CAAC;oBACzB,IAAI,EAAE,YAAY,CAAC,KAAK,CAAC,aAAa,EAAE,OAAO,CAAC;oBAChD,YAAY;oBACZ,SAAS,EAAE,OAAO,CAAC,EAAE;oBACrB,OAAO;iBACR,CAAC,CAAA;YACJ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,CAAC,KAAK,YAAY,oBAAoB,CAAC;oBAAE,MAAM,KAAK,CAAA;gBACzD,YAAY,GAAG,KAAK,CAAC,IAAI,CAAA;YAC3B,CAAC;QACH,CAAC;QAED,OAAO,eAAe,CAAC,2BAA2B,EAAE,OAAO,CAAC,EAAE,EAC5D,qFAAqF,EAAE,cAAc,CAAC,YAAY,CAAC,CAAC,CAAA;IACxH,CAAC;CACF;AAED;;;;;;;GAOG;AACH,KAAK,UAAU,gBAAgB,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,IAAI;IAC7D,MAAM,QAAQ,GAAG,MAAM,qBAAqB,CAAC,OAAO,CAAC,YAAY,EAAE,kBAAkB,EAAE,OAAO,CAAC,EAAE,EAAE,IAAI,CAAC,CAAA;IAExG,MAAM,qBAAqB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,kBAAkB,EAAC,CAAC,CAAC,CAAA;IACpG,uBAAuB;IACvB,MAAM,WAAW,GAAG,EAAE,CAAA;IACtB,uBAAuB;IACvB,MAAM,gBAAgB,GAAG,EAAE,CAAA;IAC3B,uBAAuB;IACvB,MAAM,YAAY,GAAG,EAAE,CAAA;IACvB,MAAM,sBAAsB,GAAG,IAAI,GAAG,EAAE,CAAA;IAExC,KAAK,MAAM,MAAM,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;QACrC,MAAM,IAAI,GAAG,MAAM,qBAAqB,CAAC,MAAM,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,EAAE,EAAE,KAAK,CAAC,CAAA;QAE7F,IAAI,sBAAsB,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC9C,eAAe,CAAC,sBAAsB,EAAE,OAAO,CAAC,EAAE,EAChD,oDAAoD,EAAE,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAA;QACtF,CAAC;QACD,sBAAsB,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACzC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAC5B,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QACpC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAC7B,MAAM,qBAAqB,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAC,CAAC,CAAC,CAAA;IAC/F,CAAC;IAED,OAAO;QACL,aAAa,EAAE,QAAQ,CAAC,KAAK;QAC7B,gBAAgB,EAAE,QAAQ,CAAC,QAAQ;QACnC,aAAa,EAAE,QAAQ,CAAC,KAAK;QAC7B,WAAW;QACX,gBAAgB;QAChB,YAAY;KACb,CAAA;AACH,CAAC;AAED;;;;;;;GAOG;AACH,KAAK,UAAU,qBAAqB,CAAC,QAAQ,EAAE,WAAW,EAAE,SAAS,EAAE,QAAQ;IAC7E,IAAI,MAAM,CAAA;IAEV,IAAI,CAAC;QACH,MAAM,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,SAAS,CAAC,QAAQ,GAAG,CAAC,SAAS,CAAC,UAAU,IAAI,CAAC,CAAC,CAAC,CAAA;QAC/E,MAAM,UAAU,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAA;QAC3C,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC,CAAA;QAChD,MAAM,WAAW,GAAG,MAAM,KAAK,CAAC,QAAQ,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC,CAAA;QAEzD,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,UAAU,IAAI,QAAQ,IAAI,CAAC,gBAAgB,CAAC,MAAM,EAAE,WAAW,CAAC,EAAE,CAAC;YAClH,MAAM,IAAI,oBAAoB,CAAC,WAAW,CAAC,CAAA;QAC7C,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,QAAQ,EAAE,CAAA;QACrC,MAAM,KAAK,GAAG,MAAM,MAAM,CAAC,IAAI,CAAC,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC,CAAA;QAC/C,MAAM,SAAS,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,CAAA;QAC1C,MAAM,UAAU,GAAG,MAAM,KAAK,CAAC,QAAQ,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC,CAAA;QAExD,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC,UAAU,CAAC,MAAM,EAAE,IAAI,SAAS,IAAI,QAAQ,IAAI,CAAC,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC;YACnG,CAAC,gBAAgB,CAAC,KAAK,EAAE,UAAU,CAAC,IAAI,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;YACjF,MAAM,IAAI,oBAAoB,CAAC,WAAW,CAAC,CAAA;QAC7C,CAAC;QAED,OAAO;YACL,KAAK;YACL,QAAQ,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE;YACvD,KAAK,EAAE,eAAe,CAAC,MAAM,CAAC;SAC/B,CAAA;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,KAAK,YAAY,oBAAoB;YAAE,MAAM,KAAK,CAAA;QACtD,OAAO,eAAe,CAAC,QAAQ,CAAC,CAAC,CAAC,8BAA8B,CAAC,CAAC,CAAC,4BAA4B,EAAE,SAAS,EACxG,QAAQ,CAAC,CAAC,CAAC,4DAA4D,CAAC,CAAC,CAAC,2DAA2D,EACrI,cAAc,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC,CAAA;IACvC,CAAC;YAAS,CAAC;QACT,MAAM,MAAM,EAAE,KAAK,EAAE,CAAA;IACvB,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAS,aAAa,CAAC,IAAI,EAAE,KAAK;IAChC,OAAO,IAAI,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI;QAC9E,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,IAAI,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC,OAAO,CAAA;AAClE,CAAC;AAED;;;;;GAKG;AACH,SAAS,gBAAgB,CAAC,IAAI,EAAE,KAAK;IACnC,OAAO,IAAI,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,IAAI,KAAK,CAAC,GAAG,CAAA;AACvD,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CAAC,MAAM;IAC7B,OAAO,CAAC,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAA;AACpG,CAAC;AAED;;;;;;GAMG;AACH,SAAS,eAAe,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO;IAC3C,IAAI,IAAI,CAAC,gBAAgB,IAAI,KAAK,CAAC,gBAAgB,IAAI,IAAI,CAAC,aAAa,IAAI,KAAK,CAAC,aAAa;QAC9F,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,EAAE,CAAC;QAClD,OAAO,kBAAkB,CAAA;IAC3B,CAAC;IACD,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,IAAI,KAAK,CAAC,WAAW,CAAC,MAAM;QAAE,OAAO,kBAAkB,CAAA;IAClF,MAAM,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,WAAW,EAAE,EAAE,CAC9D,IAAI,CAAC,gBAAgB,CAAC,WAAW,CAAC,IAAI,KAAK,CAAC,gBAAgB,CAAC,WAAW,CAAC;QACzE,IAAI,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,KAAK,CAAC,YAAY,CAAC,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC,CAAA;IAErH,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,IAAI,CAAA;AACzD,CAAC;AAED;;;;;GAKG;AACH,KAAK,UAAU,oBAAoB,CAAC,OAAO,EAAE,KAAK;IAChD,MAAM,OAAO,GAAG,CAAC;YACf,QAAQ,EAAE,OAAO,CAAC,YAAY;YAC9B,QAAQ,EAAE,KAAK,CAAC,gBAAgB;YAChC,IAAI,EAAE,kBAAkB;YACxB,KAAK,EAAE,KAAK,CAAC,aAAa;SAC3B,EAAE,GAAG,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC;YAC5C,QAAQ,EAAE,MAAM,CAAC,YAAY;YAC7B,QAAQ,EAAE,KAAK,CAAC,gBAAgB,CAAC,KAAK,CAAC;YACvC,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,KAAK,EAAE,KAAK,CAAC,YAAY,CAAC,KAAK,CAAC;SACjC,CAAC,CAAC,CAAC,CAAA;IAEJ,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,EAAC,MAAM,EAAE,IAAI,EAAC,CAAC,CAAA;YAC1D,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAA;YAE5C,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,KAAK,IAAI,KAAK,CAAC,QAAQ,IAAI,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,IAAI,KAAK,CAAC,QAAQ;gBAChH,eAAe,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,KAAK;gBAAE,OAAO,KAAK,CAAC,IAAI,CAAA;QAC7D,CAAC;QAAC,OAAO,MAAM,EAAE,CAAC;YAChB,OAAO,KAAK,CAAC,IAAI,CAAA;QACnB,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;;;GAKG;AACH,SAAS,YAAY,CAAC,aAAa,EAAE,OAAO;IAC1C,MAAM,IAAI,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAA;IAEjC,UAAU,CAAC,IAAI,EAAE,8BAA8B,CAAC,CAAA;IAChD,UAAU,CAAC,IAAI,EAAE,aAAa,CAAC,CAAA;IAC/B,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,CAAA;QAC3B,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,CAAA;QAC7B,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,QAAQ,CAAC,CAAA;QACjC,UAAU,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,CAAC,CAAA;IACjC,CAAC;IAED,OAAO,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;AAC3B,CAAC;AAED;;;;;GAKG;AACH,SAAS,UAAU,CAAC,IAAI,EAAE,KAAK;IAC7B,MAAM,KAAK,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAA;IACzE,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;IAE9B,MAAM,CAAC,gBAAgB,CAAC,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,CAAA;IACjD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAA;IACnB,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;AACpB,CAAC;AAED;;;;;;GAMG;AACH,SAAS,UAAU,CAAC,KAAK,EAAE,QAAQ,EAAE,SAAS;IAC5C,IAAI,CAAC;QACH,OAAO,IAAI,WAAW,CAAC,OAAO,EAAE,EAAC,KAAK,EAAE,IAAI,EAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;IAC9D,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,eAAe,CAAC,iCAAiC,EAAE,SAAS,EACjE,oDAAoD,EAAE,cAAc,CAAC,QAAQ,CAAC,EAAE,KAAK,CAAC,CAAA;IAC1F,CAAC;AACH,CAAC;AAED,wEAAwE;AACxE,MAAM,oBAAqB,SAAQ,KAAK;IACtC;;;OAGG;IACH,YAAY,IAAI;QACd,KAAK,CAAC,iCAAiC,CAAC,CAAA;QACxC,IAAI,CAAC,IAAI,GAAG,IAAI,CAAA;IAClB,CAAC;CACF;AAED;;;GAGG;AACH,SAAS,gBAAgB;IACvB,OAAO,cAAc,CAAC,kBAAkB,CAAC,CAAA;AAC3C,CAAC;AAED;;;;GAIG;AACH,SAAS,cAAc,CAAC,QAAQ;IAC9B,MAAM,KAAK,GAAG,EAAC,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAC,CAAA;IAE7C,OAAO,EAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAC,CAAA;AAC7C,CAAC;AAED;;;;;;;;GAQG;AACH,SAAS,eAAe,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK;IAChE,MAAM,IAAI,qBAAqB,CAAC;QAC9B,KAAK,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS;QACjD,IAAI;QACJ,QAAQ,EAAE,SAAS;QACnB,QAAQ;QACR,OAAO;KACR,CAAC,CAAA;AACJ,CAAC;AAED;;;;;;GAMG;AAEH;;;;;;;;GAQG;AAEH;;;;;GAKG","sourcesContent":["// @ts-check\n\nimport {createHash} from \"node:crypto\"\nimport {constants} from \"node:fs\"\nimport {lstat, open, realpath} from \"node:fs/promises\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {SemantifoldProject} from \"./project-manifest.js\"\n\nconst snapshotAttempts = 2\n/** @type {WeakMap<ProjectSnapshotBuilder, (event: Readonly<{attempt: number, pass: number, path: string}>) => Promise<void> | void>} */\nconst snapshotReadObservers = new WeakMap()\n\n/**\n * Installs an internal deterministic read observer for real-filesystem snapshot specs.\n * This helper is intentionally not part of the package root API.\n * @param {ProjectSnapshotBuilder} builder - Snapshot builder instance.\n * @param {(event: Readonly<{attempt: number, pass: number, path: string}>) => Promise<void> | void} observer - Ordered read observer.\n * @returns {void}\n */\nexport function observeProjectSnapshotReads(builder, observer) {\n  if (!(builder instanceof ProjectSnapshotBuilder) || typeof observer != \"function\") {\n    throw new TypeError(\"Invalid project snapshot read observer.\")\n  }\n  snapshotReadObservers.set(builder, observer)\n}\n\n/**\n * One complete immutable ordered source snapshot.\n */\nexport class ProjectSnapshot {\n  /**\n   * Constructs a trusted snapshot value.\n   * @param {{hash: string, manifestText: string, projectId: string, sources: SnapshotSource[]}} value - Stable snapshot fields.\n   */\n  constructor(value) {\n    this.hash = value.hash\n    this.manifestText = value.manifestText\n    this.projectId = value.projectId\n    this.sources = Object.freeze(value.sources.map(source => Object.freeze({...source})))\n    Object.freeze(this)\n  }\n}\n\n/**\n * Reads one complete graph twice before exposing an immutable source snapshot.\n */\nexport class ProjectSnapshotBuilder {\n  /**\n   * Builds a stable snapshot with one bounded retry when the graph changes mid-read.\n   * @param {SemantifoldProject} project - Validated immutable project.\n   * @returns {Promise<ProjectSnapshot>} Stable complete snapshot.\n   */\n  async build(project) {\n    if (!(project instanceof SemantifoldProject)) {\n      snapshotFailure(\"INVALID_PROJECT_SNAPSHOT\", \"project\", \"Snapshot building requires a validated Semantifold project.\")\n    }\n    let unstablePath = \"semantifold.json\"\n\n    for (let attempt = 0; attempt < snapshotAttempts; attempt += 1) {\n      try {\n        const first = await readProjectGraph(project, this, attempt + 1, 1)\n        const second = await readProjectGraph(project, this, attempt + 1, 2)\n        const difference = graphDifference(first, second, project)\n\n        if (difference !== null) {\n          unstablePath = difference\n          continue\n        }\n        const finalDifference = await graphStateDifference(project, second)\n\n        if (finalDifference !== null) {\n          unstablePath = finalDifference\n          continue\n        }\n        const manifestText = decodeUtf8(first.manifestBytes, \"semantifold.json\", project.id)\n\n        if (manifestText != project.manifestText) {\n          snapshotFailure(\"UNSTABLE_PROJECT_SNAPSHOT\", project.id,\n            \"Project manifest changed after it was validated; restart the build from the new manifest.\", manifestLocation())\n        }\n        const sources = project.sources.map((source, index) => ({\n          id: source.id,\n          language: source.language,\n          path: source.path,\n          source: decodeUtf8(first.sourceBytes[index], source.path, project.id)\n        }))\n\n        return new ProjectSnapshot({\n          hash: snapshotHash(first.manifestBytes, sources),\n          manifestText,\n          projectId: project.id,\n          sources\n        })\n      } catch (error) {\n        if (!(error instanceof UnstableSnapshotRead)) throw error\n        unstablePath = error.path\n      }\n    }\n\n    return snapshotFailure(\"UNSTABLE_PROJECT_SNAPSHOT\", project.id,\n      \"Project manifest or source files changed repeatedly while the snapshot was loading.\", sourceLocation(unstablePath))\n  }\n}\n\n/**\n * Reads every declared file in stable manifest order.\n * @param {SemantifoldProject} project - Validated project.\n * @param {ProjectSnapshotBuilder} builder - Active builder.\n * @param {number} attempt - One-based bounded attempt.\n * @param {number} pass - One-based verification pass.\n * @returns {Promise<ProjectGraphRead>} Complete graph bytes.\n */\nasync function readProjectGraph(project, builder, attempt, pass) {\n  const manifest = await readStableRegularFile(project.manifestPath, \"semantifold.json\", project.id, true)\n\n  await snapshotReadObservers.get(builder)?.(Object.freeze({attempt, pass, path: \"semantifold.json\"}))\n  /** @type {Buffer[]} */\n  const sourceBytes = []\n  /** @type {string[]} */\n  const sourceIdentities = []\n  /** @type {string[]} */\n  const sourceStates = []\n  const uniqueSourceIdentities = new Set()\n\n  for (const source of project.sources) {\n    const read = await readStableRegularFile(source.absolutePath, source.path, project.id, false)\n\n    if (uniqueSourceIdentities.has(read.identity)) {\n      snapshotFailure(\"PROJECT_SOURCE_ALIAS\", project.id,\n        \"Project source paths must not alias the same file.\", sourceLocation(source.path))\n    }\n    uniqueSourceIdentities.add(read.identity)\n    sourceBytes.push(read.bytes)\n    sourceIdentities.push(read.identity)\n    sourceStates.push(read.state)\n    await snapshotReadObservers.get(builder)?.(Object.freeze({attempt, pass, path: source.path}))\n  }\n\n  return {\n    manifestBytes: manifest.bytes,\n    manifestIdentity: manifest.identity,\n    manifestState: manifest.state,\n    sourceBytes,\n    sourceIdentities,\n    sourceStates\n  }\n}\n\n/**\n * Reads exact bytes through one descriptor while detecting replacement or mutation.\n * @param {string} filename - Canonical absolute path.\n * @param {string} displayPath - Project-relative diagnostic path.\n * @param {string} projectId - Project identity.\n * @param {boolean} manifest - Whether this is the project manifest.\n * @returns {Promise<StableFileRead>} Stable bytes and filesystem identity.\n */\nasync function readStableRegularFile(filename, displayPath, projectId, manifest) {\n  let handle\n\n  try {\n    handle = await open(filename, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0))\n    const beforePath = await realpath(filename)\n    const before = await handle.stat({bigint: true})\n    const beforeEntry = await lstat(filename, {bigint: true})\n\n    if (!before.isFile() || !beforeEntry.isFile() || beforePath != filename || !sameFileIdentity(before, beforeEntry)) {\n      throw new UnstableSnapshotRead(displayPath)\n    }\n    const bytes = await handle.readFile()\n    const after = await handle.stat({bigint: true})\n    const afterPath = await realpath(filename)\n    const afterEntry = await lstat(filename, {bigint: true})\n\n    if (!after.isFile() || !afterEntry.isFile() || afterPath != filename || !sameFileState(before, after) ||\n      !sameFileIdentity(after, afterEntry) || BigInt(bytes.byteLength) != after.size) {\n      throw new UnstableSnapshotRead(displayPath)\n    }\n\n    return {\n      bytes,\n      identity: `${String(before.dev)}:${String(before.ino)}`,\n      state: stableFileState(before)\n    }\n  } catch (error) {\n    if (error instanceof UnstableSnapshotRead) throw error\n    return snapshotFailure(manifest ? \"PROJECT_MANIFEST_READ_FAILED\" : \"PROJECT_SOURCE_READ_FAILED\", projectId,\n      manifest ? \"Project manifest could not be read into a stable snapshot.\" : \"Declared source could not be read into a stable snapshot.\",\n      sourceLocation(displayPath), error)\n  } finally {\n    await handle?.close()\n  }\n}\n\n/**\n * Compares descriptor state around one read.\n * @param {import(\"node:fs\").BigIntStats} left - State before the read.\n * @param {import(\"node:fs\").BigIntStats} right - State after the read.\n * @returns {boolean} Whether identity and mutation-sensitive metadata agree.\n */\nfunction sameFileState(left, right) {\n  return left.dev == right.dev && left.ino == right.ino && left.size == right.size &&\n    left.mtimeNs == right.mtimeNs && left.ctimeNs == right.ctimeNs\n}\n\n/**\n * Compares the path entry with the opened descriptor identity.\n * @param {import(\"node:fs\").BigIntStats} left - Open descriptor or path state.\n * @param {import(\"node:fs\").BigIntStats} right - Open descriptor or path state.\n * @returns {boolean} Whether both identify the same filesystem node.\n */\nfunction sameFileIdentity(left, right) {\n  return left.dev == right.dev && left.ino == right.ino\n}\n\n/**\n * Serializes mutation-sensitive descriptor state for complete-graph comparison.\n * @param {import(\"node:fs\").BigIntStats} status - Stable descriptor state.\n * @returns {string} Internal state identity.\n */\nfunction stableFileState(status) {\n  return [status.dev, status.ino, status.size, status.mtimeNs, status.ctimeNs].map(String).join(\":\")\n}\n\n/**\n * Locates the first byte difference between two complete graph reads.\n * @param {ProjectGraphRead} left - First graph.\n * @param {ProjectGraphRead} right - Second graph.\n * @param {SemantifoldProject} project - Ordered path authority.\n * @returns {string | null} Project-relative changed path, or null.\n */\nfunction graphDifference(left, right, project) {\n  if (left.manifestIdentity != right.manifestIdentity || left.manifestState != right.manifestState ||\n    !left.manifestBytes.equals(right.manifestBytes)) {\n    return \"semantifold.json\"\n  }\n  if (left.sourceBytes.length != right.sourceBytes.length) return \"semantifold.json\"\n  const index = left.sourceBytes.findIndex((bytes, sourceIndex) =>\n    left.sourceIdentities[sourceIndex] != right.sourceIdentities[sourceIndex] ||\n    left.sourceStates[sourceIndex] != right.sourceStates[sourceIndex] || !bytes.equals(right.sourceBytes[sourceIndex]))\n\n  return index == -1 ? null : project.sources[index].path\n}\n\n/**\n * Revalidates every path entry after the final complete graph read.\n * @param {SemantifoldProject} project - Ordered path authority.\n * @param {ProjectGraphRead} graph - Final complete graph read.\n * @returns {Promise<string | null>} First changed project-relative path, or null.\n */\nasync function graphStateDifference(project, graph) {\n  const entries = [{\n    filename: project.manifestPath,\n    identity: graph.manifestIdentity,\n    path: \"semantifold.json\",\n    state: graph.manifestState\n  }, ...project.sources.map((source, index) => ({\n    filename: source.absolutePath,\n    identity: graph.sourceIdentities[index],\n    path: source.path,\n    state: graph.sourceStates[index]\n  }))]\n\n  for (const entry of entries) {\n    try {\n      const status = await lstat(entry.filename, {bigint: true})\n      const exact = await realpath(entry.filename)\n\n      if (!status.isFile() || exact != entry.filename || `${String(status.dev)}:${String(status.ino)}` != entry.identity ||\n        stableFileState(status) != entry.state) return entry.path\n    } catch (_error) {\n      return entry.path\n    }\n  }\n\n  return null\n}\n\n/**\n * Computes a framed deterministic SHA-256 identity over exact manifest and ordered source inputs.\n * @param {Buffer} manifestBytes - Exact manifest bytes.\n * @param {readonly SnapshotSource[]} sources - Ordered decoded sources.\n * @returns {string} Lowercase SHA-256 digest.\n */\nfunction snapshotHash(manifestBytes, sources) {\n  const hash = createHash(\"sha256\")\n\n  updateHash(hash, \"SemantifoldProjectSnapshot/1\")\n  updateHash(hash, manifestBytes)\n  for (const source of sources) {\n    updateHash(hash, source.id)\n    updateHash(hash, source.path)\n    updateHash(hash, source.language)\n    updateHash(hash, source.source)\n  }\n\n  return hash.digest(\"hex\")\n}\n\n/**\n * Adds one length-framed field to a content hash.\n * @param {import(\"node:crypto\").Hash} hash - Active hash.\n * @param {string | Buffer} value - Field bytes.\n * @returns {void}\n */\nfunction updateHash(hash, value) {\n  const bytes = Buffer.isBuffer(value) ? value : Buffer.from(value, \"utf8\")\n  const length = Buffer.alloc(8)\n\n  length.writeBigUInt64BE(BigInt(bytes.byteLength))\n  hash.update(length)\n  hash.update(bytes)\n}\n\n/**\n * Decodes strict UTF-8 for parser inputs.\n * @param {Buffer} bytes - Exact file bytes.\n * @param {string} filename - Project-relative filename.\n * @param {string} projectId - Project identity.\n * @returns {string} Decoded source.\n */\nfunction decodeUtf8(bytes, filename, projectId) {\n  try {\n    return new TextDecoder(\"utf-8\", {fatal: true}).decode(bytes)\n  } catch (error) {\n    return snapshotFailure(\"INVALID_PROJECT_SOURCE_ENCODING\", projectId,\n      \"Project manifests and sources must be valid UTF-8.\", sourceLocation(filename), error)\n  }\n}\n\n/** Internal marker for a read that may safely use the bounded retry. */\nclass UnstableSnapshotRead extends Error {\n  /**\n   * Creates an internal retry marker.\n   * @param {string} path - Project-relative unstable path.\n   */\n  constructor(path) {\n    super(\"Unstable project snapshot read.\")\n    this.path = path\n  }\n}\n\n/**\n * Creates the stable manifest boundary location.\n * @returns {import(\"./semantic/types.js\").SourceLocation} Manifest location.\n */\nfunction manifestLocation() {\n  return sourceLocation(\"semantifold.json\")\n}\n\n/**\n * Creates a stable project-relative file location.\n * @param {string} filename - Project-relative filename.\n * @returns {import(\"./semantic/types.js\").SourceLocation} Start-of-file location.\n */\nfunction sourceLocation(filename) {\n  const point = {column: 1, line: 1, offset: 0}\n\n  return {end: point, filename, start: point}\n}\n\n/**\n * Throws one stable snapshot diagnostic.\n * @param {string} code - Stable diagnostic code.\n * @param {string} projectId - Project identity.\n * @param {string} message - Stable detail.\n * @param {import(\"./semantic/types.js\").SourceLocation} [location] - Project-relative location.\n * @param {unknown} [error] - Preserved cause.\n * @returns {never} Always throws.\n */\nfunction snapshotFailure(code, projectId, message, location, error) {\n  throw new SemantifoldDiagnostic({\n    cause: error instanceof Error ? error : undefined,\n    code,\n    language: projectId,\n    location,\n    message\n  })\n}\n\n/**\n * @typedef SnapshotSource\n * @property {string} id - Stable semantic module identity.\n * @property {import(\"./semantic/types.js\").SemanticLanguage} language - Registered source language.\n * @property {string} path - Project-relative source path.\n * @property {string} source - Exact decoded source text.\n */\n\n/**\n * @typedef ProjectGraphRead\n * @property {Buffer} manifestBytes - Exact manifest bytes.\n * @property {string} manifestIdentity - Stable manifest device/inode identity.\n * @property {string} manifestState - Stable manifest mutation-sensitive state.\n * @property {Buffer[]} sourceBytes - Exact source bytes in manifest order.\n * @property {string[]} sourceIdentities - Stable source device/inode identities in manifest order.\n * @property {string[]} sourceStates - Stable source mutation-sensitive states in manifest order.\n */\n\n/**\n * @typedef StableFileRead\n * @property {Buffer} bytes - Exact stable file bytes.\n * @property {string} identity - Stable device/inode identity.\n * @property {string} state - Stable mutation-sensitive file state.\n */\n"]}

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

@@ -0,0 +1,125 @@
+/**
+ * Emits long-lived watch state with one terminal record for every admitted cycle and one for the watcher.
+ */
+export declare class ProjectWatchReporter {
+    #private;
+    /**
+     * 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?: {
+        format?: "human" | "ndjson";
+        now?: () => number;
+        stderr?: import("./project-reporter.js").WritableOutput;
+        stdout?: import("./project-reporter.js").WritableOutput;
+    });
+    /**
+     * Reports validated watch startup.
+     * @param {string} projectId - Stable initial project identity.
+     * @returns {void}
+     */
+    watchStarted(projectId: string): void;
+    /**
+     * Reports the selected event backend.
+     * @param {"native" | "polling"} backend - Active event backend.
+     * @returns {void}
+     */
+    watchBackend(backend: "native" | "polling"): void;
+    /**
+     * Begins one admitted build cycle.
+     * @param {ProjectWatchCycleContext} cycle - Cycle context.
+     * @returns {void}
+     */
+    cycleStarted(cycle: ProjectWatchCycleContext): void;
+    /**
+     * Reports the cycle's validated project identity.
+     * @param {string} projectId - Validated project identity.
+     * @returns {void}
+     */
+    projectLoaded(projectId: string): void;
+    /**
+     * Reports the cycle's complete source snapshot.
+     * @param {string} snapshotHash - Complete source snapshot hash.
+     * @returns {void}
+     */
+    snapshotLoaded(snapshotHash: string): void;
+    /**
+     * Reports one generated target.
+     * @param {import("./project-build.js").ProjectBuildTargetResult} target - Generated target.
+     * @returns {void}
+     */
+    targetGenerated(target: import("./project-build.js").ProjectBuildTargetResult): void;
+    /**
+     * Reports one completed target-check stage.
+     * @param {{id: string, language: string, stage: import("./semantic/types.js").TargetCheckStageResult}} checked - Check stage.
+     * @returns {void}
+     */
+    targetChecked(checked: {
+        id: string;
+        language: string;
+        stage: import("./semantic/types.js").TargetCheckStageResult;
+    }): void;
+    /**
+     * 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: import("./project-build.js").ProjectBuildSuccess, recovered: boolean): void;
+    /**
+     * 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: unknown, status: "cancelled" | "failed" | "superseded"): void;
+    /**
+     * Reports reconciliation whose complete content hash did not change.
+     * @param {readonly string[]} changedPaths - Coalesced hint paths.
+     * @returns {void}
+     */
+    unchanged(changedPaths: readonly string[]): void;
+    /**
+     * Reports the first filesystem hint admitted while the current cycle remains active.
+     * @returns {void}
+     */
+    cycleDirty(): void;
+    /**
+     * Emits the sole clean watcher terminal.
+     * @param {string} reason - Shutdown reason.
+     * @returns {void}
+     */
+    watchStopped(reason: string): void;
+    /**
+     * Emits the sole startup/configuration watcher terminal.
+     * @param {unknown} failure - Startup/configuration failure.
+     * @returns {void}
+     */
+    watchFailed(failure: unknown): void;
+}
+export type ProjectWatchCycleContext = {
+    /**
+     * - Stable changed paths.
+     */
+    changedPaths: readonly string[];
+    /**
+     * - One-based cycle number.
+     */
+    cycle: number;
+    /**
+     * - Stable project identity.
+     */
+    projectId: string;
+    /**
+     * - Complete snapshot hash when reconciliation succeeded.
+     */
+    snapshotHash?: string;
+};
+/**
+ * @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=project-watch-reporter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"project-watch-reporter.d.ts","sourceRoot":"","sources":["../../src/project-watch-reporter.js"],"names":[],"mappings":"AAIA;;GAEG;AACH,qBAAa,oBAAoB;;IAqB/B;;;OAGG;IACH,YAAY,OAAO,AAFhB,CACF,EADU;QAAC,MAAM,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;QAAC,GAAG,CAAC,EAAE,MAAM,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,uBAAuB,EAAE,cAAc,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,uBAAuB,EAAE,cAAc,CAAA;KAErJ,EAavB;IAED;;;;OAIG;IACH,YAAY,CAAC,SAAS,EAHX,MAGW,GAFT,IAAI,CAKhB;IAED;;;;OAIG;IACH,YAAY,CAAC,OAAO,EAHT,QAAQ,GAAG,SAGF,GAFP,IAAI,CAIhB;IAED;;;;OAIG;IACH,YAAY,CAAC,KAAK,EAHP,wBAGO,GAFL,IAAI,CAWhB;IAED;;;;OAIG;IACH,aAAa,CAAC,SAAS,EAHZ,MAGY,GAFV,IAAI,CAKhB;IAED;;;;OAIG;IACH,cAAc,CAAC,YAAY,EAHhB,MAGgB,GAFd,IAAI,CAKhB;IAED;;;;OAIG;IACH,eAAe,CAAC,MAAM,EAHX,OAAO,oBAAoB,EAAE,wBAGlB,GAFT,IAAI,CAUhB;IAED;;;;OAIG;IACH,aAAa,CAAC,OAAO,EAHV;QAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,OAAO,qBAAqB,EAAE,sBAAsB,CAAA;KAGhF,GAFR,IAAI,CAgBhB;IAED;;;;;OAKG;IACH,cAAc,CAAC,MAAM,EAJV,OAAO,oBAAoB,EAAE,mBAInB,EAAE,SAAS,EAHrB,OAGqB,GAFnB,IAAI,CAyBhB;IAED;;;;;OAKG;IACH,WAAW,CAAC,OAAO,EAJR,OAIQ,EAAE,MAAM,EAHhB,WAAW,GAAG,QAAQ,GAAG,YAGT,GAFd,IAAI,CAoBhB;IAED;;;;OAIG;IACH,SAAS,CAAC,YAAY,EAHX,SAAS,MAAM,EAGJ,GAFT,IAAI,CAIhB;IAED;;;OAGG;IACH,UAAU,IAFG,IAAI,CAKhB;IAED;;;;OAIG;IACH,YAAY,CAAC,MAAM,EAHR,MAGQ,GAFN,IAAI,CAUhB;IAED;;;;OAIG;IACH,WAAW,CAAC,OAAO,EAHR,OAGQ,GAFN,IAAI,CAYhB;CAmDF;AAGE,YAAS,wBAAwB,GACjC;;;;IAA8B,YAAY,EAA/B,SAAS,MAAM,EAAE,CAC5B;;;;IAAmB,KAAK,EAAb,MAAM,CACjB;;;;IAAmB,SAAS,EAAjB,MAAM,CACjB;;;;IAAoB,YAAY,AAAhC,CACF,EADa,MAAM,CACnB;CAAA,CAAA;AAND;;;;;;GAMG"}