semantifold 0.8.0 → 0.9.0

package/build/src/publication.js

@@ -0,0 +1,1643 @@
+// @ts-check
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readFile, readdir, realpath, rename, rm } from "node:fs/promises";
+import path from "node:path";
+import { findPortableArtifactPathConflict, isSafeArtifactPath } from "./artifact-path.js";
+import { createGeneratedArtifactSet } from "./artifacts.js";
+import { finalizeByteMapping } from "./binary-mapping.js";
+import { SemantifoldDiagnostic } from "./diagnostic.js";
+import { finalizeMapping, toSourceMapV3 } from "./mapping.js";
+const activePointerName = "active-generation.json";
+const generationsName = "generations";
+const journalName = ".semantifold-publication-journal";
+const identityPattern = /^[a-z][a-z0-9-]*$/u;
+const generationPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u;
+const buildRolePattern = /^[a-z][a-z0-9-]*$/u;
+const mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+(?:;[\u0020-\u007e]+)?$/u;
+const targetRoles = new Set(["application", "binary", "text"]);
+const publicationBoundaries = new Set([
+    "after-stage",
+    "before-pointer-replace",
+    "after-pointer-replace",
+    "before-cleanup",
+    "before-journal-remove"
+]);
+/** @type {WeakMap<GeneratedArtifactPublisher, {boundary: string, error: Error}>} */
+const injectedPublicationFailures = new WeakMap();
+/** @type {WeakMap<GeneratedArtifactPublisher, (operation: string) => void>} */
+const publicationFilesystemObservers = new WeakMap();
+/**
+ * Installs one internal, one-shot deterministic failure used by real-filesystem interruption specs.
+ * This helper is intentionally not part of the package root API.
+ * @param {GeneratedArtifactPublisher} publisher - Publisher instance.
+ * @param {"after-stage" | "before-pointer-replace" | "after-pointer-replace" | "before-cleanup" | "before-journal-remove"} boundary - Exact lifecycle boundary.
+ * @param {Error} error - Injected failure.
+ * @returns {void}
+ */
+export function injectPublicationFailure(publisher, boundary, error) {
+    if (!(publisher instanceof GeneratedArtifactPublisher) || !publicationBoundaries.has(boundary) || !(error instanceof Error)) {
+        throw new TypeError("Invalid publication failure injection.");
+    }
+    injectedPublicationFailures.set(publisher, { boundary, error });
+}
+/**
+ * Installs an internal deterministic filesystem-operation observer for durability specs.
+ * This helper is intentionally not part of the package root API.
+ * @param {GeneratedArtifactPublisher} publisher - Publisher instance.
+ * @param {(operation: string) => void} observer - Synchronous operation observer.
+ * @returns {void}
+ */
+export function observePublicationFilesystem(publisher, observer) {
+    if (!(publisher instanceof GeneratedArtifactPublisher) || typeof observer != "function") {
+        throw new TypeError("Invalid publication filesystem observer.");
+    }
+    publicationFilesystemObservers.set(publisher, observer);
+}
+/**
+ * Owns transactional publication in one dedicated directory beneath a canonical project root.
+ */
+export class GeneratedArtifactPublisher {
+    /** @type {string} */
+    #projectId;
+    /** @type {string} */
+    #projectRoot;
+    /** @type {string} */
+    #publicationRoot;
+    /** @type {readonly string[]} */
+    #sourceRoots;
+    /** @type {Promise<void>} */
+    #publicationTail = Promise.resolve();
+    /**
+     * Creates a project-scoped publisher without touching the filesystem.
+     * @param {object} options - Publisher identity and owned paths.
+     * @param {string} options.projectId - Stable lowercase project identity.
+     * @param {string} options.projectRoot - Canonical absolute project root.
+     * @param {string} options.publicationRoot - Canonical absolute publisher-owned directory beneath the project root.
+     * @param {readonly string[]} options.sourceRoots - Canonical absolute project source roots kept disjoint from publication.
+     */
+    constructor(options) {
+        if (!isPlainObject(options)) {
+            publicationFailure("INVALID_PUBLICATION_REQUEST", "publication", "Publisher options must be a plain object.");
+        }
+        const { projectId, projectRoot, publicationRoot, sourceRoots } = options;
+        if (!identityPattern.test(projectId ?? "")) {
+            publicationFailure("INVALID_PUBLICATION_REQUEST", "publication", "Project identity must be a stable lowercase ID.");
+        }
+        if (!isCanonicalAbsolutePath(projectRoot) || !isCanonicalAbsolutePath(publicationRoot) ||
+            !isStrictPathDescendant(projectRoot, publicationRoot)) {
+            publicationFailure("INVALID_PUBLICATION_ROOT", projectId, "Project and publication roots must be canonical absolute paths with publication strictly beneath the project root.");
+        }
+        if (!isDenseArray(sourceRoots) || sourceRoots.length == 0) {
+            publicationFailure("INVALID_PUBLICATION_ROOT", projectId, "Source roots must be a non-empty array of canonical absolute paths.");
+        }
+        /** @type {string[]} */
+        const validatedSourceRoots = [];
+        for (let index = 0; index < sourceRoots.length; index += 1) {
+            const sourceRoot = sourceRoots[index];
+            if (!isCanonicalAbsolutePath(sourceRoot)) {
+                publicationFailure("INVALID_PUBLICATION_ROOT", projectId, "Source roots must be a non-empty array of canonical absolute paths.");
+            }
+            if (!isPathWithin(projectRoot, sourceRoot)) {
+                publicationFailure("INVALID_PUBLICATION_ROOT", projectId, "Source roots must remain within the canonical project root.");
+            }
+            if (pathsOverlap(publicationRoot, sourceRoot)) {
+                publicationFailure("PUBLICATION_SOURCE_OVERLAP", projectId, "Publication root and source roots must be disjoint.");
+            }
+            validatedSourceRoots.push(sourceRoot);
+        }
+        this.#projectId = projectId;
+        this.#projectRoot = projectRoot;
+        this.#publicationRoot = publicationRoot;
+        this.#sourceRoots = Object.freeze(validatedSourceRoots);
+    }
+    /**
+     * Stages, validates, and publishes one complete immutable project generation.
+     * Calls on one publisher instance are serialized in invocation order.
+     * @param {import("./semantic/types.js").PublicationRequest} request - Complete publication request.
+     * @returns {Promise<import("./semantic/types.js").PublishedGeneration>} Committed immutable snapshot.
+     */
+    publish(request) {
+        /** @type {(value: import("./semantic/types.js").PublishedGeneration) => void} */
+        let resolveResult;
+        /** @type {(reason?: unknown) => void} */
+        let rejectResult;
+        const result = new Promise((resolve, reject) => {
+            resolveResult = resolve;
+            rejectResult = reject;
+        });
+        const operation = this.#publicationTail.then(async () => {
+            try {
+                resolveResult(await this.#publish(request));
+            }
+            catch (error) {
+                rejectResult(error);
+            }
+        });
+        this.#publicationTail = operation.catch(() => { });
+        return result;
+    }
+    /**
+     * Resolves the active pointer exactly once and verifies the referenced immutable generation.
+     * @returns {Promise<import("./semantic/types.js").PublishedGeneration>} Verified pointer-once snapshot.
+     */
+    async resolveActive() {
+        await this.#prepareRoot();
+        const pointerPath = path.join(this.#publicationRoot, activePointerName);
+        const pointer = await readActivePointer(pointerPath, this.#projectId, false);
+        if (!pointer)
+            publicationFailure("ACTIVE_GENERATION_MISSING", this.#projectId, "No active generation has been published.");
+        const generation = await verifyPublishedGeneration(this.#publicationRoot, this.#projectId, pointer, false);
+        const cleanupPending = await hasCommittedCleanupJournal(this.#publicationRoot, this.#projectId, pointer.generationId);
+        return publishedGeneration(this.#publicationRoot, generation.manifest, cleanupPending);
+    }
+    /**
+     * Performs one serialized publication.
+     * @param {import("./semantic/types.js").PublicationRequest} request - Complete request.
+     * @returns {Promise<import("./semantic/types.js").PublishedGeneration>} Publication result.
+     */
+    async #publish(request) {
+        const validated = validatePublicationRequest(request, this.#projectId);
+        await this.#prepareRoot();
+        await reconcilePublication(this.#publicationRoot, this.#projectId, this);
+        await verifyAtomicReplacement(this.#publicationRoot, this.#projectId);
+        await validateExistingPointer(this.#publicationRoot, this.#projectId);
+        const generationPath = path.join(this.#publicationRoot, generationsName, validated.generationId);
+        const manifestPath = path.join(generationPath, "manifest.json");
+        const tempPointerName = `.active-generation.${validated.generationId}.tmp`;
+        const tempPointerPath = path.join(this.#publicationRoot, tempPointerName);
+        const journalPath = path.join(this.#publicationRoot, journalName, `${validated.generationId}.json`);
+        let committed = false;
+        let journalCreated = false;
+        let generationCreated = false;
+        let tempPointerCreated = false;
+        let failureCode = "PUBLICATION_STAGE_WRITE_FAILED";
+        try {
+            await assertAbsent(generationPath, "PUBLICATION_UNOWNED_CONFLICT", this.#projectId, "Generation identity is already owned or ambiguous.");
+            await assertAbsent(tempPointerPath, "PUBLICATION_UNOWNED_CONFLICT", this.#projectId, "Temporary active pointer path is already owned or ambiguous.");
+            await assertAbsent(journalPath, "PUBLICATION_UNOWNED_CONFLICT", this.#projectId, "Publication journal identity is already owned or ambiguous.");
+            const journal = {
+                generationId: validated.generationId,
+                projectId: this.#projectId,
+                schema: "SemantifoldPublicationJournal",
+                tempPointer: tempPointerName,
+                version: 1
+            };
+            await writeSyncedFile(journalPath, serializeJson(journal), "wx");
+            journalCreated = true;
+            await syncDirectory(path.dirname(journalPath));
+            await mkdir(generationPath, { mode: 0o700 });
+            generationCreated = true;
+            await syncDirectory(path.dirname(generationPath));
+            /** @type {import("./semantic/types.js").GenerationTargetManifest[]} */
+            const targetManifests = [];
+            for (const target of validated.targets) {
+                targetManifests.push(await stageTarget(generationPath, target, this.#projectId));
+            }
+            reachPublicationBoundary(this, "after-stage");
+            const manifestCandidate = /** @type {import("./semantic/types.js").GenerationManifest} */ ({
+                generationId: validated.generationId,
+                projectId: this.#projectId,
+                schema: /** @type {const} */ ("SemantifoldGenerationManifest"),
+                targets: targetManifests,
+                version: /** @type {const} */ (1)
+            });
+            const manifestBytes = serializeJson(manifestCandidate);
+            const manifest = validateGenerationManifest(JSON.parse(manifestBytes.toString("utf8")), this.#projectId, validated.generationId);
+            await writeSyncedFile(manifestPath, manifestBytes, "wx");
+            await syncTreeDirectories(generationPath);
+            await verifyManifestFiles(generationPath, manifest, this.#projectId);
+            failureCode = "PUBLICATION_POINTER_FAILED";
+            const pointer = {
+                generationId: validated.generationId,
+                manifestHash: sha256(manifestBytes),
+                projectId: this.#projectId,
+                schema: "SemantifoldActiveGeneration",
+                version: 1
+            };
+            await writeSyncedFile(tempPointerPath, serializeJson(pointer), "wx", () => {
+                tempPointerCreated = true;
+            });
+            reachPublicationBoundary(this, "before-pointer-replace");
+            await rename(tempPointerPath, path.join(this.#publicationRoot, activePointerName));
+            tempPointerCreated = false;
+            committed = true;
+            reachPublicationBoundary(this, "after-pointer-replace");
+            await syncDirectory(this.#publicationRoot);
+            let cleanupPending = false;
+            try {
+                reachPublicationBoundary(this, "before-cleanup");
+                await removeJournalOwnedState({
+                    journalPath,
+                    projectId: this.#projectId,
+                    publicationRoot: this.#publicationRoot,
+                    publisher: this
+                });
+            }
+            catch (_error) {
+                cleanupPending = true;
+            }
+            return publishedGeneration(this.#publicationRoot, deepFreeze(manifest), cleanupPending);
+        }
+        catch (error) {
+            if (!committed) {
+                try {
+                    await removeJournalOwnedState({
+                        ...(generationCreated ? { candidatePath: generationPath } : {}),
+                        ...(journalCreated ? { journalPath } : {}),
+                        projectId: this.#projectId,
+                        publicationRoot: this.#publicationRoot,
+                        publisher: this,
+                        ...(tempPointerCreated ? { temporaryPointerPath: tempPointerPath } : {})
+                    });
+                }
+                catch (cleanupError) {
+                    if (cleanupError instanceof SemantifoldDiagnostic)
+                        throw cleanupError;
+                    publicationFailure("PUBLICATION_RECOVERY_FAILED", this.#projectId, "Failed publication left state that requires recovery.", cleanupError);
+                }
+            }
+            if (error instanceof SemantifoldDiagnostic)
+                throw error;
+            publicationFailure(failureCode, this.#projectId, committed
+                ? "Active generation changed, but durable pointer publication did not complete."
+                : "Candidate generation could not be staged.", error);
+        }
+    }
+    /**
+     * Creates and validates owned root directories and source-root separation.
+     * @returns {Promise<void>} Completion.
+     */
+    async #prepareRoot() {
+        await ensureDirectoryWithoutSymlinks(this.#projectRoot, false, this.#projectId);
+        await ensureDirectoryWithoutSymlinks(this.#publicationRoot, true, this.#projectId);
+        let exactProject;
+        let exactPublication;
+        try {
+            exactProject = await realpath(this.#projectRoot);
+            exactPublication = await realpath(this.#publicationRoot);
+        }
+        catch (error) {
+            publicationFailure("INVALID_PUBLICATION_ROOT", this.#projectId, "Publication root could not be resolved safely.", error);
+        }
+        if (!isStrictPathDescendant(exactProject, exactPublication)) {
+            publicationFailure("INVALID_PUBLICATION_ROOT", this.#projectId, "Publication root must resolve strictly beneath the project root.");
+        }
+        for (const sourceRoot of this.#sourceRoots) {
+            await ensureDirectoryWithoutSymlinks(sourceRoot, false, this.#projectId);
+            let exactSource;
+            try {
+                exactSource = await realpath(sourceRoot);
+            }
+            catch (error) {
+                publicationFailure("INVALID_PUBLICATION_ROOT", this.#projectId, "Source root could not be resolved safely.", error);
+            }
+            if (!isPathWithin(exactProject, exactSource)) {
+                publicationFailure("INVALID_PUBLICATION_ROOT", this.#projectId, "Source roots must resolve within the project root.");
+            }
+            if (pathsOverlap(exactPublication, exactSource)) {
+                publicationFailure("PUBLICATION_SOURCE_OVERLAP", this.#projectId, "Publication root and source roots resolve to overlapping paths.");
+            }
+        }
+        await ensureOwnedDirectory(path.join(this.#publicationRoot, generationsName), this.#projectId);
+        await ensureOwnedDirectory(path.join(this.#publicationRoot, journalName), this.#projectId);
+    }
+}
+/**
+ * Throws and consumes a configured internal failure at an exact lifecycle boundary.
+ * @param {GeneratedArtifactPublisher} publisher - Active publisher.
+ * @param {string} boundary - Reached boundary.
+ * @returns {void}
+ */
+function reachPublicationBoundary(publisher, boundary) {
+    const injection = injectedPublicationFailures.get(publisher);
+    if (injection?.boundary == boundary) {
+        injectedPublicationFailures.delete(publisher);
+        throw injection.error;
+    }
+}
+/**
+ * Reports one completed filesystem operation to the internal deterministic seam.
+ * @param {GeneratedArtifactPublisher} publisher - Active publisher.
+ * @param {string} operation - Completed operation.
+ * @returns {void}
+ */
+function observePublicationFilesystemOperation(publisher, operation) {
+    publicationFilesystemObservers.get(publisher)?.(operation);
+}
+/**
+ * Reconciles only candidates and temporary pointers whose ownership is proven by a strict journal.
+ * The active pointer remains the sole commit authority.
+ * @param {string} publicationRoot - Publication root.
+ * @param {string} projectId - Project identity.
+ * @param {GeneratedArtifactPublisher} publisher - Active publisher.
+ * @returns {Promise<void>} Completion.
+ */
+async function reconcilePublication(publicationRoot, projectId, publisher) {
+    const journals = await readPublicationJournals(publicationRoot, projectId);
+    if (journals.length == 0)
+        return;
+    const pointer = await readActivePointer(path.join(publicationRoot, activePointerName), projectId, true);
+    if (pointer)
+        await verifyPublishedGeneration(publicationRoot, projectId, pointer, true);
+    for (const { journal, journalPath } of journals) {
+        const candidatePath = ownedPath(path.join(publicationRoot, generationsName), journal.generationId, projectId);
+        const temporaryPointerPath = path.join(publicationRoot, journal.tempPointer);
+        const committed = pointer?.generationId == journal.generationId;
+        if (!committed) {
+            const candidateStatus = await optionalStatus(candidatePath, projectId, "candidate generation");
+            if (candidateStatus) {
+                if (!candidateStatus.isDirectory() || candidateStatus.isSymbolicLink()) {
+                    publicationFailure("PUBLICATION_RECOVERY_FAILED", projectId, "Journal-owned candidate is not a real directory.");
+                }
+            }
+        }
+        const temporaryStatus = await optionalStatus(temporaryPointerPath, projectId, "temporary pointer");
+        if (temporaryStatus) {
+            if (!temporaryStatus.isFile() || temporaryStatus.isSymbolicLink()) {
+                publicationFailure("PUBLICATION_RECOVERY_FAILED", projectId, "Journal-owned temporary pointer is not a regular file.");
+            }
+        }
+        await removeJournalOwnedState({
+            ...(!committed ? { candidatePath } : {}),
+            journalPath,
+            projectId,
+            publicationRoot,
+            publisher,
+            temporaryPointerPath
+        });
+    }
+}
+/**
+ * Reads and validates every recovery journal without changing publication state.
+ * @param {string} publicationRoot - Publication root.
+ * @param {string} projectId - Project identity.
+ * @returns {Promise<readonly {journal: PublicationJournal, journalPath: string}[]>} Ordered journals.
+ */
+async function readPublicationJournals(publicationRoot, projectId) {
+    const journalDirectory = path.join(publicationRoot, journalName);
+    let entries;
+    try {
+        entries = await readdir(journalDirectory);
+    }
+    catch (error) {
+        publicationFailure("PUBLICATION_RECOVERY_FAILED", projectId, "Publication journal directory could not be inspected.", error);
+    }
+    entries.sort(compareStrings);
+    /** @type {{journal: PublicationJournal, journalPath: string}[]} */
+    const journals = [];
+    for (const entry of entries) {
+        if (!entry.endsWith(".json") || !generationPattern.test(entry.slice(0, -5))) {
+            publicationFailure("PUBLICATION_RECOVERY_FAILED", projectId, "Publication journal contains an unrecognized entry.");
+        }
+        const journalPath = path.join(journalDirectory, entry);
+        let journal;
+        try {
+            const status = await lstat(journalPath);
+            if (!status.isFile() || status.isSymbolicLink()) {
+                publicationFailure("PUBLICATION_RECOVERY_FAILED", projectId, "Publication journal entry must be a regular file.");
+            }
+            journal = JSON.parse(await readFile(journalPath, "utf8"));
+        }
+        catch (error) {
+            if (error instanceof SemantifoldDiagnostic)
+                throw error;
+            publicationFailure("PUBLICATION_RECOVERY_FAILED", projectId, "Publication journal entry is not valid JSON.", error);
+        }
+        if (!isPublicationJournal(journal) || journal.projectId != projectId || `${journal.generationId}.json` != entry) {
+            publicationFailure("PUBLICATION_RECOVERY_FAILED", projectId, "Publication journal entry does not match the versioned project contract.");
+        }
+        journals.push({ journal, journalPath });
+    }
+    return Object.freeze(journals);
+}
+/**
+ * Reports committed cleanup state while failing closed on every journal entry.
+ * @param {string} publicationRoot - Publication root.
+ * @param {string} projectId - Project identity.
+ * @param {string} generationId - Pointer-selected generation identity.
+ * @returns {Promise<boolean>} Whether committed cleanup remains.
+ */
+async function hasCommittedCleanupJournal(publicationRoot, projectId, generationId) {
+    const journals = await readPublicationJournals(publicationRoot, projectId);
+    return journals.some(({ journal }) => journal.generationId == generationId);
+}
+/**
+ * Removes proven journal-owned state and durably synchronizes each parent before discarding its ownership proof.
+ * @param {object} options - Exact cleanup state.
+ * @param {string} [options.candidatePath] - Proven candidate generation path.
+ * @param {string} [options.temporaryPointerPath] - Proven temporary pointer path.
+ * @param {string} [options.journalPath] - Ownership journal path.
+ * @param {string} options.projectId - Project identity.
+ * @param {string} options.publicationRoot - Publication root.
+ * @param {GeneratedArtifactPublisher} options.publisher - Active publisher.
+ * @returns {Promise<void>} Completion.
+ */
+async function removeJournalOwnedState({ candidatePath, journalPath, projectId, publicationRoot, publisher, temporaryPointerPath }) {
+    try {
+        if (candidatePath) {
+            await rm(candidatePath, { force: true, recursive: true });
+            observePublicationFilesystemOperation(publisher, "remove-candidate");
+            await syncDirectory(path.join(publicationRoot, generationsName));
+            observePublicationFilesystemOperation(publisher, "sync-candidate-parent");
+        }
+        if (temporaryPointerPath) {
+            await rm(temporaryPointerPath, { force: true });
+            observePublicationFilesystemOperation(publisher, "remove-temporary-pointer");
+            await syncDirectory(publicationRoot);
+            observePublicationFilesystemOperation(publisher, "sync-temporary-pointer-parent");
+        }
+        if (journalPath) {
+            reachPublicationBoundary(publisher, "before-journal-remove");
+            await rm(journalPath);
+            observePublicationFilesystemOperation(publisher, "remove-journal");
+            await syncDirectory(path.dirname(journalPath));
+            observePublicationFilesystemOperation(publisher, "sync-journal-parent");
+        }
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic)
+            throw error;
+        publicationFailure("PUBLICATION_RECOVERY_FAILED", projectId, "Journal-owned publication state could not be durably reconciled.", error);
+    }
+}
+/**
+ * Reads optional metadata without following symbolic links.
+ * @param {string} filename - Exact owned path.
+ * @param {string} projectId - Project identity.
+ * @param {string} subject - Stable subject description.
+ * @returns {Promise<import("node:fs").Stats | null>} Status or absence.
+ */
+async function optionalStatus(filename, projectId, subject) {
+    try {
+        return await lstat(filename);
+    }
+    catch (error) {
+        if (isErrorCode(error, "ENOENT"))
+            return null;
+        publicationFailure("PUBLICATION_RECOVERY_FAILED", projectId, `Journal-owned ${subject} could not be inspected.`, error);
+    }
+}
+/**
+ * Validates and snapshots one publication request before staging.
+ * @param {unknown} request - Request candidate.
+ * @param {string} projectId - Project diagnostic identity.
+ * @returns {{generationId: string, targets: readonly ValidatedPublicationTarget[]}} Validated request.
+ */
+function validatePublicationRequest(request, projectId) {
+    if (!isPlainObject(request)) {
+        publicationFailure("INVALID_PUBLICATION_REQUEST", projectId, "Publication requires a unique generation ID and a non-empty ordered target array.");
+    }
+    const generationId = request.generationId;
+    const requestedTargets = request.targets;
+    if (typeof generationId != "string" || !generationPattern.test(generationId) ||
+        !isDenseArray(requestedTargets) || requestedTargets.length == 0) {
+        publicationFailure("INVALID_PUBLICATION_REQUEST", projectId, "Publication requires a unique generation ID and a non-empty ordered target array.");
+    }
+    /** @type {ValidatedPublicationTarget[]} */
+    const targets = [];
+    const targetIds = new Set();
+    /** @type {string[]} */
+    const projections = [];
+    /** @type {string[]} */
+    const completeArtifactPaths = [];
+    for (let index = 0; index < requestedTargets.length; index += 1) {
+        const target = requestedTargets[index];
+        if (!isPlainObject(target)) {
+            publicationFailure("INVALID_PUBLICATION_REQUEST", projectId, `Target ${index} requires a stable lowercase identity.`);
+        }
+        const targetId = target.id;
+        const role = target.role;
+        const sourceProjection = target.sourceProjection;
+        const buildProjection = target.buildProjection;
+        const artifactSetCandidate = target.artifactSet;
+        const validatorsCandidate = target.validators;
+        if (typeof targetId != "string" || !identityPattern.test(targetId)) {
+            publicationFailure("INVALID_PUBLICATION_REQUEST", projectId, `Target ${index} requires a stable lowercase identity.`);
+        }
+        if (typeof role != "string" || !targetRoles.has(role)) {
+            publicationFailure("INVALID_PUBLICATION_REQUEST", projectId, `Target '${targetId}' requires an explicit language-neutral role.`);
+        }
+        if (targetIds.has(targetId)) {
+            publicationFailure("PUBLICATION_PATH_COLLISION", projectId, `Duplicate target identity '${targetId}'.`);
+        }
+        targetIds.add(targetId);
+        if (!isSafeArtifactPath(sourceProjection) || !isSafeArtifactPath(buildProjection)) {
+            publicationFailure("INVALID_PUBLICATION_PROJECTION", projectId, `Target '${targetId}' requires canonical relative source and build projections.`);
+        }
+        projections.push(sourceProjection, buildProjection);
+        let artifactSet;
+        try {
+            artifactSet = createGeneratedArtifactSet(artifactSetCandidate);
+        }
+        catch (error) {
+            publicationFailure("INVALID_PUBLICATION_REQUEST", projectId, `Target '${targetId}' does not contain a valid generated artifact set.`, error);
+        }
+        const validators = validatorsCandidate === undefined ? [] : validatorsCandidate;
+        if (!isDenseArray(validators)) {
+            publicationFailure("INVALID_PUBLICATION_REQUEST", projectId, `Target '${targetId}' validators must be a dense function array.`);
+        }
+        /** @type {import("./semantic/types.js").PublicationValidator[]} */
+        const validatedValidators = [];
+        for (let validatorIndex = 0; validatorIndex < validators.length; validatorIndex += 1) {
+            const validator = validators[validatorIndex];
+            if (typeof validator != "function") {
+                publicationFailure("INVALID_PUBLICATION_REQUEST", projectId, `Target '${targetId}' validators must be a dense function array.`);
+            }
+            validatedValidators.push(/** @type {import("./semantic/types.js").PublicationValidator} */ (validator));
+        }
+        const artifactConflict = findPortableArtifactPathConflict(artifactSet.artifacts.map(({ path: artifactPath }) => artifactPath));
+        if (artifactConflict) {
+            publicationFailure("PUBLICATION_PATH_COLLISION", projectId, `Target '${targetId}' artifact paths have a portable ${artifactConflict.kind} conflict.`);
+        }
+        for (const artifact of artifactSet.artifacts) {
+            completeArtifactPaths.push(`${sourceProjection}/${artifact.path}`);
+        }
+        targets.push(Object.freeze({
+            artifactSet,
+            buildProjection,
+            id: targetId,
+            role: /** @type {import("./semantic/types.js").PublicationTargetRole} */ (role),
+            sourceProjection,
+            validators: Object.freeze(validatedValidators)
+        }));
+    }
+    const projectionConflict = findPortableArtifactPathConflict(projections);
+    if (projectionConflict) {
+        publicationFailure("PUBLICATION_PROJECTION_OVERLAP", projectId, "Target source/build projections must be distinct and non-nested under portable comparison.");
+    }
+    if (findPortableArtifactPathConflict([...projections, "manifest.json"])) {
+        publicationFailure("INVALID_PUBLICATION_PROJECTION", projectId, "Target source/build projections must not overlap the generation manifest path.");
+    }
+    const artifactConflict = findPortableArtifactPathConflict(completeArtifactPaths);
+    if (artifactConflict) {
+        publicationFailure("PUBLICATION_PATH_COLLISION", projectId, "Projected artifact paths collide under portable comparison.");
+    }
+    return { generationId, targets: Object.freeze(targets) };
+}
+/**
+ * Stages one validated target and invokes its ordered validators.
+ * @param {string} generationPath - Candidate generation path.
+ * @param {ValidatedPublicationTarget} target - Validated target.
+ * @param {string} projectId - Project diagnostic identity.
+ * @returns {Promise<import("./semantic/types.js").GenerationTargetManifest>} Target manifest.
+ */
+async function stageTarget(generationPath, target, projectId) {
+    const sourcePath = ownedPath(generationPath, target.sourceProjection, projectId);
+    const buildPath = ownedPath(generationPath, target.buildProjection, projectId);
+    await mkdir(sourcePath, { mode: 0o700, recursive: true });
+    await mkdir(buildPath, { mode: 0o700, recursive: true });
+    /** @type {import("./semantic/types.js").GenerationArtifactManifest[]} */
+    const artifacts = [];
+    for (const artifact of target.artifactSet.artifacts) {
+        const filename = ownedPath(sourcePath, artifact.path, projectId);
+        const bytes = artifact.contentKind == "text"
+            ? Buffer.from(/** @type {string} */ (artifact.content), "utf8")
+            : Buffer.from(/** @type {Uint8Array} */ (artifact.content));
+        await mkdir(path.dirname(filename), { mode: 0o700, recursive: true });
+        try {
+            await writeSyncedFile(filename, bytes, "wx");
+        }
+        catch (error) {
+            if (error instanceof SemantifoldDiagnostic)
+                throw error;
+            publicationFailure("PUBLICATION_STAGE_WRITE_FAILED", projectId, `Generated artifact '${artifact.path}' could not be staged.`, error);
+        }
+        artifacts.push(Object.freeze({
+            byteLength: bytes.byteLength,
+            contentKind: artifact.contentKind,
+            hash: Object.freeze({ algorithm: /** @type {const} */ ("sha256"), value: sha256(bytes) }),
+            mediaType: artifact.mediaType,
+            path: artifact.path,
+            provenance: artifact.provenance,
+            role: artifact.role
+        }));
+    }
+    /** @type {import("./semantic/types.js").PublicationBuildArtifactInput[]} */
+    const buildDescriptors = [];
+    const context = Object.freeze({ buildPath, sourcePath, targetId: target.id });
+    for (let index = 0; index < target.validators.length; index += 1) {
+        let produced;
+        try {
+            produced = await target.validators[index](context);
+        }
+        catch (error) {
+            publicationFailure("PUBLICATION_VALIDATION_FAILED", projectId, `Validator ${index} failed for target '${target.id}'.`, error);
+        }
+        if (produced === undefined)
+            continue;
+        if (!isDenseArray(produced)) {
+            publicationFailure("PUBLICATION_VALIDATION_FAILED", projectId, `Validator ${index} returned invalid build-artifact metadata for target '${target.id}'.`);
+        }
+        for (const descriptor of produced) {
+            buildDescriptors.push(validateBuildArtifactDescriptor(descriptor, target.id, projectId));
+        }
+    }
+    const descriptorConflict = findPortableArtifactPathConflict(buildDescriptors.map(({ path: artifactPath }) => artifactPath));
+    if (descriptorConflict) {
+        publicationFailure("PUBLICATION_PATH_COLLISION", projectId, `Target '${target.id}' build artifacts have a portable ${descriptorConflict.kind} conflict.`);
+    }
+    const stagedBuildFiles = await listRegularFiles(buildPath, projectId);
+    const declared = new Set(buildDescriptors.map(({ path: artifactPath }) => artifactPath));
+    if (stagedBuildFiles.length != declared.size || stagedBuildFiles.some(filename => !declared.has(filename))) {
+        publicationFailure("PUBLICATION_VALIDATION_FAILED", projectId, `Target '${target.id}' validators must declare every staged build artifact exactly once.`);
+    }
+    /** @type {import("./semantic/types.js").GenerationBuildArtifactManifest[]} */
+    const finalizedBuildArtifacts = [];
+    for (const descriptor of buildDescriptors) {
+        const bytes = await readAndSyncRegularFile(ownedPath(buildPath, descriptor.path, projectId), projectId, "PUBLICATION_STAGE_HASH_MISMATCH", `Build artifact '${descriptor.path}' is not a stable regular file.`);
+        finalizedBuildArtifacts.push(Object.freeze({
+            byteLength: bytes.byteLength,
+            hash: Object.freeze({ algorithm: /** @type {const} */ ("sha256"), value: sha256(bytes) }),
+            mediaType: descriptor.mediaType,
+            path: descriptor.path,
+            role: descriptor.role
+        }));
+    }
+    return Object.freeze({
+        artifacts: Object.freeze(artifacts),
+        buildArtifacts: Object.freeze(finalizedBuildArtifacts),
+        id: target.id,
+        ...(target.artifactSet.metadata === undefined ? {} : { metadata: target.artifactSet.metadata }),
+        projections: Object.freeze({ build: target.buildProjection, source: target.sourceProjection }),
+        role: target.role,
+        target: target.artifactSet.target
+    });
+}
+/**
+ * Validates validator/compiler output metadata.
+ * @param {unknown} descriptor - Metadata candidate.
+ * @param {string} targetId - Target identity.
+ * @param {string} projectId - Project diagnostic identity.
+ * @returns {import("./semantic/types.js").PublicationBuildArtifactInput} Validated metadata.
+ */
+function validateBuildArtifactDescriptor(descriptor, targetId, projectId) {
+    if (!isPlainObject(descriptor) || !hasExactKeys(descriptor, ["mediaType", "path", "role"])) {
+        publicationFailure("PUBLICATION_VALIDATION_FAILED", projectId, `Target '${targetId}' validator returned invalid build-artifact metadata.`);
+    }
+    const descriptorPath = descriptor.path;
+    const mediaType = descriptor.mediaType;
+    const role = descriptor.role;
+    if (!isSafeArtifactPath(descriptorPath) || typeof mediaType != "string" ||
+        !mediaTypePattern.test(mediaType) || /[\r\n]/u.test(mediaType) ||
+        typeof role != "string" || !buildRolePattern.test(role)) {
+        publicationFailure("PUBLICATION_VALIDATION_FAILED", projectId, `Target '${targetId}' validator returned invalid build-artifact metadata.`);
+    }
+    return Object.freeze({ mediaType, path: descriptorPath, role });
+}
+/**
+ * Verifies every manifest reference and staged byte before pointer reachability.
+ * @param {string} generationPath - Candidate generation path.
+ * @param {import("./semantic/types.js").GenerationManifest} manifest - Candidate manifest.
+ * @param {string} projectId - Project diagnostic identity.
+ * @returns {Promise<void>} Completion.
+ */
+async function verifyManifestFiles(generationPath, manifest, projectId) {
+    for (const target of manifest.targets) {
+        const sourcePath = ownedPath(generationPath, target.projections.source, projectId);
+        const buildPath = ownedPath(generationPath, target.projections.build, projectId);
+        const sourceFiles = await listRegularFiles(sourcePath, projectId);
+        if (sourceFiles.length != target.artifacts.length ||
+            sourceFiles.some(filename => !target.artifacts.some(artifact => artifact.path == filename))) {
+            publicationFailure("PUBLICATION_STAGE_HASH_MISMATCH", projectId, `Target '${target.id}' generated-source files do not match its manifest.`);
+        }
+        for (const artifact of target.artifacts) {
+            await verifyManifestFile(sourcePath, artifact, projectId);
+        }
+        const buildFiles = await listRegularFiles(buildPath, projectId);
+        if (buildFiles.length != target.buildArtifacts.length ||
+            buildFiles.some(filename => !target.buildArtifacts.some(artifact => artifact.path == filename))) {
+            publicationFailure("PUBLICATION_STAGE_HASH_MISMATCH", projectId, `Target '${target.id}' build files do not match its manifest.`);
+        }
+        for (const artifact of target.buildArtifacts) {
+            await verifyManifestFile(buildPath, artifact, projectId);
+        }
+        try {
+            const artifacts = [];
+            for (const artifact of target.artifacts) {
+                const bytes = await readAndSyncRegularFile(ownedPath(sourcePath, artifact.path, projectId), projectId, "PUBLICATION_STAGE_HASH_MISMATCH", `Manifest artifact '${artifact.path}' is not a stable regular file.`);
+                let content;
+                if (artifact.contentKind == "text") {
+                    try {
+                        content = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+                    }
+                    catch (error) {
+                        publicationFailure("MALFORMED_GENERATION_MANIFEST", projectId, `Text artifact '${artifact.path}' is not valid UTF-8.`, error);
+                    }
+                }
+                else
+                    content = new Uint8Array(bytes);
+                artifacts.push({
+                    content,
+                    contentKind: artifact.contentKind,
+                    mediaType: artifact.mediaType,
+                    ownership: /** @type {const} */ ("generated"),
+                    path: artifact.path,
+                    provenance: rehydrateProvenance(artifact.provenance, projectId),
+                    role: artifact.role
+                });
+            }
+            createGeneratedArtifactSet({
+                artifacts,
+                ...(target.metadata === undefined ? {} : { metadata: target.metadata }),
+                target: target.target
+            });
+        }
+        catch (error) {
+            if (error instanceof SemantifoldDiagnostic && error.code == "MALFORMED_GENERATION_MANIFEST")
+                throw error;
+            publicationFailure("MALFORMED_GENERATION_MANIFEST", projectId, `Target '${target.id}' artifact provenance does not match its staged bytes.`, error);
+        }
+    }
+    await verifyGenerationInventory(generationPath, manifest, projectId);
+}
+/**
+ * Restores JSON-omitted optional mapping fields and verifies persisted mapping projections.
+ * @param {import("./semantic/types.js").ArtifactProvenance} provenance - Persisted provenance.
+ * @param {string} projectId - Project identity.
+ * @returns {import("./semantic/types.js").ArtifactProvenance} Canonical provenance.
+ */
+function rehydrateProvenance(provenance, projectId) {
+    if (provenance.kind == "text") {
+        const mapping = finalizeMapping(provenance.mapping);
+        const sourceMap = toSourceMapV3(mapping);
+        const jsonSourceMap = JSON.parse(JSON.stringify(sourceMap));
+        if (!sameJsonValue(jsonSourceMap, provenance.sourceMap)) {
+            publicationFailure("MALFORMED_GENERATION_MANIFEST", projectId, "Persisted Source Map projection contradicts its rich mapping.");
+        }
+        return Object.freeze({
+            kind: /** @type {const} */ ("text"),
+            mapping,
+            sourceMap,
+            ...(provenance.sourceMapFilename === undefined ? {} : { sourceMapFilename: provenance.sourceMapFilename })
+        });
+    }
+    if (provenance.kind == "bytes") {
+        return Object.freeze({ kind: /** @type {const} */ ("bytes"), mapping: finalizeByteMapping(provenance.mapping) });
+    }
+    return provenance;
+}
+/**
+ * Verifies one referenced file.
+ * @param {string} projectionPath - Owning projection path.
+ * @param {{byteLength: number, hash: import("./semantic/types.js").GenerationContentHash, path: string}} artifact - Manifest record.
+ * @param {string} projectId - Project diagnostic identity.
+ * @returns {Promise<Buffer>} Exact verified bytes.
+ */
+async function verifyManifestFile(projectionPath, artifact, projectId) {
+    const bytes = await readAndSyncRegularFile(ownedPath(projectionPath, artifact.path, projectId), projectId, "PUBLICATION_STAGE_HASH_MISMATCH", `Manifest artifact '${artifact.path}' is not a stable regular file.`);
+    if (bytes.byteLength != artifact.byteLength || sha256(bytes) != artifact.hash.value) {
+        publicationFailure("PUBLICATION_STAGE_HASH_MISMATCH", projectId, `Manifest artifact '${artifact.path}' bytes do not match its recorded hash.`);
+    }
+    return bytes;
+}
+/**
+ * Validates an existing active pointer before a new candidate is staged.
+ * @param {string} publicationRoot - Publication root.
+ * @param {string} projectId - Project identity.
+ * @returns {Promise<void>} Completion.
+ */
+async function validateExistingPointer(publicationRoot, projectId) {
+    const pointerPath = path.join(publicationRoot, activePointerName);
+    const pointer = await readActivePointer(pointerPath, projectId, true);
+    if (pointer)
+        await verifyPublishedGeneration(publicationRoot, projectId, pointer, false);
+}
+/**
+ * Reads and strictly validates one active pointer.
+ * @param {string} pointerPath - Pointer filename.
+ * @param {string} projectId - Expected project identity.
+ * @param {boolean} optional - Whether absence is allowed.
+ * @returns {Promise<ActivePointer | null>} Pointer or absent value.
+ */
+async function readActivePointer(pointerPath, projectId, optional) {
+    let pointerBytes;
+    try {
+        const status = await lstat(pointerPath);
+        if (!status.isFile() || status.isSymbolicLink()) {
+            publicationFailure("MALFORMED_ACTIVE_GENERATION", projectId, "Active-generation pointer must be a regular file.");
+        }
+        pointerBytes = await readFile(pointerPath);
+    }
+    catch (error) {
+        if (optional && isErrorCode(error, "ENOENT"))
+            return null;
+        if (error instanceof SemantifoldDiagnostic)
+            throw error;
+        publicationFailure(optional ? "MALFORMED_ACTIVE_GENERATION" : "ACTIVE_GENERATION_MISSING", projectId, optional ? "Active-generation pointer could not be read." : "No active generation has been published.", error);
+    }
+    let value;
+    try {
+        value = JSON.parse(pointerBytes.toString("utf8"));
+    }
+    catch (error) {
+        publicationFailure("MALFORMED_ACTIVE_GENERATION", projectId, "Active-generation pointer is not valid JSON.", error);
+    }
+    if (!isActivePointer(value) || value.projectId != projectId) {
+        publicationFailure("MALFORMED_ACTIVE_GENERATION", projectId, "Active-generation pointer does not match the versioned project contract.");
+    }
+    return value;
+}
+/**
+ * Verifies a pointer-selected generation without consulting the pointer again.
+ * @param {string} publicationRoot - Publication root.
+ * @param {string} projectId - Project identity.
+ * @param {ActivePointer} pointer - Pointer snapshot.
+ * @param {boolean} cleanupPending - Recovery state.
+ * @returns {Promise<import("./semantic/types.js").PublishedGeneration>} Verified generation.
+ */
+async function verifyPublishedGeneration(publicationRoot, projectId, pointer, cleanupPending) {
+    const generationPath = ownedPath(path.join(publicationRoot, generationsName), pointer.generationId, projectId);
+    const manifestPath = path.join(generationPath, "manifest.json");
+    let manifestBytes;
+    try {
+        manifestBytes = await readAndSyncRegularFile(manifestPath, projectId, "MALFORMED_GENERATION_MANIFEST", "Generation manifest must be a regular file.");
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic)
+            throw error;
+        publicationFailure("MALFORMED_GENERATION_MANIFEST", projectId, "Generation manifest could not be read.", error);
+    }
+    if (sha256(manifestBytes) != pointer.manifestHash) {
+        publicationFailure("MALFORMED_GENERATION_MANIFEST", projectId, "Generation manifest hash does not match the active pointer.");
+    }
+    let value;
+    try {
+        value = JSON.parse(manifestBytes.toString("utf8"));
+    }
+    catch (error) {
+        publicationFailure("MALFORMED_GENERATION_MANIFEST", projectId, "Generation manifest is not valid JSON.", error);
+    }
+    const manifest = validateGenerationManifest(value, projectId, pointer.generationId);
+    await verifyManifestFiles(generationPath, manifest, projectId);
+    return publishedGeneration(publicationRoot, manifest, cleanupPending);
+}
+/**
+ * Strictly validates a persisted generation manifest.
+ * @param {unknown} value - Parsed manifest value.
+ * @param {string} projectId - Expected project identity.
+ * @param {string} generationId - Expected generation identity.
+ * @returns {import("./semantic/types.js").GenerationManifest} Frozen manifest.
+ */
+function validateGenerationManifest(value, projectId, generationId) {
+    if (!isPlainObject(value) || !hasExactKeys(value, ["generationId", "projectId", "schema", "targets", "version"]) ||
+        value.schema != "SemantifoldGenerationManifest" || value.version != 1 || value.projectId != projectId ||
+        value.generationId != generationId || !isDenseArray(value.targets) || value.targets.length == 0) {
+        publicationFailure("MALFORMED_GENERATION_MANIFEST", projectId, "Generation manifest does not match the versioned project contract.");
+    }
+    /** @type {import("./semantic/types.js").GenerationTargetManifest[]} */
+    const targets = [];
+    /** @type {string[]} */
+    const projections = [];
+    const ids = new Set();
+    for (const target of value.targets) {
+        const targetKeys = target && typeof target == "object" && "metadata" in target
+            ? ["artifacts", "buildArtifacts", "id", "metadata", "projections", "role", "target"]
+            : ["artifacts", "buildArtifacts", "id", "projections", "role", "target"];
+        if (!isPlainObject(target) || !hasExactKeys(target, targetKeys) ||
+            !identityPattern.test(typeof target.id == "string" ? target.id : "") || ids.has(target.id) ||
+            typeof target.role != "string" || !targetRoles.has(target.role) ||
+            typeof target.target != "string" || !identityPattern.test(target.target) ||
+            !isPlainObject(target.projections) || !hasExactKeys(target.projections, ["build", "source"]) ||
+            !isSafeArtifactPath(target.projections.source) || !isSafeArtifactPath(target.projections.build) ||
+            !isDenseArray(target.artifacts) || target.artifacts.length == 0 || !isDenseArray(target.buildArtifacts)) {
+            publicationFailure("MALFORMED_GENERATION_MANIFEST", projectId, "Generation manifest contains an invalid target record.");
+        }
+        const targetId = /** @type {string} */ (target.id);
+        ids.add(targetId);
+        projections.push(target.projections.source, target.projections.build);
+        const artifacts = target.artifacts.map(artifact => validatePersistedArtifact(artifact, true, projectId));
+        const buildArtifacts = target.buildArtifacts.map(artifact => validatePersistedArtifact(artifact, false, projectId));
+        if (findPortableArtifactPathConflict(artifacts.map(({ path: artifactPath }) => artifactPath)) ||
+            findPortableArtifactPathConflict(buildArtifacts.map(({ path: artifactPath }) => artifactPath))) {
+            publicationFailure("MALFORMED_GENERATION_MANIFEST", projectId, "Generation manifest contains colliding artifact paths.");
+        }
+        targets.push(Object.freeze({
+            artifacts: Object.freeze(/** @type {import("./semantic/types.js").GenerationArtifactManifest[]} */ (artifacts)),
+            buildArtifacts: Object.freeze(/** @type {import("./semantic/types.js").GenerationBuildArtifactManifest[]} */ (buildArtifacts)),
+            id: targetId,
+            ...(target.metadata === undefined ? {} : { metadata: deepFreeze(/** @type {Record<string, unknown>} */ (target.metadata)) }),
+            projections: Object.freeze({ build: target.projections.build, source: target.projections.source }),
+            role: /** @type {import("./semantic/types.js").PublicationTargetRole} */ (target.role),
+            target: target.target
+        }));
+    }
+    if (findPortableArtifactPathConflict(projections) ||
+        findPortableArtifactPathConflict([...projections, "manifest.json"])) {
+        publicationFailure("MALFORMED_GENERATION_MANIFEST", projectId, "Generation manifest contains overlapping projections.");
+    }
+    return Object.freeze({
+        generationId,
+        projectId,
+        schema: /** @type {const} */ ("SemantifoldGenerationManifest"),
+        targets: Object.freeze(targets),
+        version: /** @type {const} */ (1)
+    });
+}
+/**
+ * Validates one persisted artifact record.
+ * @param {unknown} value - Record candidate.
+ * @param {boolean} generated - Whether this is a generated-source artifact.
+ * @param {string} projectId - Project identity.
+ * @returns {import("./semantic/types.js").GenerationArtifactManifest | import("./semantic/types.js").GenerationBuildArtifactManifest} Frozen record.
+ */
+function validatePersistedArtifact(value, generated, projectId) {
+    const keys = generated
+        ? ["byteLength", "contentKind", "hash", "mediaType", "path", "provenance", "role"]
+        : ["byteLength", "hash", "mediaType", "path", "role"];
+    if (!isPlainObject(value) || !hasExactKeys(value, keys) || !isSafeArtifactPath(value.path) ||
+        typeof value.byteLength != "number" || !Number.isSafeInteger(value.byteLength) || value.byteLength < 0 || typeof value.mediaType != "string" ||
+        !mediaTypePattern.test(value.mediaType) || typeof value.role != "string" ||
+        !(generated ? ["entry", "source", "manifest", "support", "mapping", "resource", "loader"].includes(value.role) :
+            buildRolePattern.test(value.role)) ||
+        (generated && value.contentKind != "text" && value.contentKind != "binary") ||
+        (generated && !isPlainObject(value.provenance)) ||
+        !isPlainObject(value.hash) || !hasExactKeys(value.hash, ["algorithm", "value"]) || value.hash.algorithm != "sha256" ||
+        typeof value.hash.value != "string" || !/^[a-f0-9]{64}$/u.test(value.hash.value)) {
+        publicationFailure("MALFORMED_GENERATION_MANIFEST", projectId, "Generation manifest contains an invalid artifact record.");
+    }
+    return Object.freeze(/** @type {import("./semantic/types.js").GenerationArtifactManifest | import("./semantic/types.js").GenerationBuildArtifactManifest} */ ({
+        byteLength: value.byteLength,
+        ...(generated ? { contentKind: value.contentKind } : {}),
+        hash: Object.freeze({ algorithm: /** @type {const} */ ("sha256"), value: value.hash.value }),
+        mediaType: value.mediaType,
+        path: value.path,
+        ...(generated ? { provenance: deepFreeze(/** @type {import("./semantic/types.js").ArtifactProvenance} */ (value.provenance)) } : {}),
+        role: value.role
+    }));
+}
+/**
+ * Constructs a frozen resolved-generation result.
+ * @param {string} publicationRoot - Publication root.
+ * @param {import("./semantic/types.js").GenerationManifest} manifest - Verified manifest.
+ * @param {boolean} cleanupPending - Whether cleanup remains.
+ * @returns {import("./semantic/types.js").PublishedGeneration} Frozen result.
+ */
+function publishedGeneration(publicationRoot, manifest, cleanupPending) {
+    const generationPath = path.join(publicationRoot, generationsName, manifest.generationId);
+    const targets = manifest.targets.map(target => Object.freeze({
+        buildPath: path.join(generationPath, target.projections.build),
+        id: target.id,
+        role: target.role,
+        sourcePath: path.join(generationPath, target.projections.source)
+    }));
+    return Object.freeze({
+        cleanupPending,
+        generationId: manifest.generationId,
+        generationPath,
+        manifest,
+        manifestPath: path.join(generationPath, "manifest.json"),
+        targets: Object.freeze(targets)
+    });
+}
+/**
+ * Probes the exact same-directory regular-file replacement primitive used by the active pointer.
+ * @param {string} publicationRoot - Publication root.
+ * @param {string} projectId - Project identity.
+ * @returns {Promise<void>} Completion.
+ */
+async function verifyAtomicReplacement(publicationRoot, projectId) {
+    const identity = randomUUID();
+    const source = path.join(publicationRoot, `.semantifold-atomic-${identity}.source`);
+    const destination = path.join(publicationRoot, `.semantifold-atomic-${identity}.destination`);
+    const expected = Buffer.from("candidate\n");
+    let sourceCreated = false;
+    let destinationCreated = false;
+    try {
+        await writeSyncedFile(source, Buffer.from("candidate\n"), "wx");
+        sourceCreated = true;
+        await writeSyncedFile(destination, Buffer.from("previous\n"), "wx");
+        destinationCreated = true;
+        await rename(source, destination);
+        sourceCreated = false;
+        await syncDirectory(publicationRoot);
+        const destinationStatus = await lstat(destination);
+        const replaced = await readFile(destination);
+        if (!destinationStatus.isFile() || destinationStatus.isSymbolicLink() || !replaced.equals(expected)) {
+            publicationFailure("PUBLICATION_ATOMIC_REPLACE_UNSUPPORTED", projectId, "Filesystem did not provide same-directory regular-file replacement.");
+        }
+        try {
+            await lstat(source);
+            publicationFailure("PUBLICATION_ATOMIC_REPLACE_UNSUPPORTED", projectId, "Filesystem did not remove the replaced temporary name atomically.");
+        }
+        catch (error) {
+            if (!isErrorCode(error, "ENOENT"))
+                throw error;
+        }
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic)
+            throw error;
+        publicationFailure("PUBLICATION_ATOMIC_REPLACE_UNSUPPORTED", projectId, "Filesystem did not provide same-directory regular-file replacement.", error);
+    }
+    finally {
+        await Promise.allSettled([
+            ...(sourceCreated ? [rm(source, { force: true })] : []),
+            ...(destinationCreated ? [rm(destination, { force: true })] : [])
+        ]);
+    }
+}
+/**
+ * Writes and synchronizes one newly owned file.
+ * @param {string} filename - Exact filename.
+ * @param {Uint8Array} bytes - Exact bytes.
+ * @param {"wx"} flag - Exclusive creation mode.
+ * @param {() => void} [onCreated] - Called immediately after exclusive creation succeeds.
+ * @returns {Promise<void>} Completion.
+ */
+async function writeSyncedFile(filename, bytes, flag, onCreated) {
+    const handle = await open(filename, flag, 0o600);
+    onCreated?.();
+    /** @type {unknown} */
+    let failure;
+    try {
+        await handle.writeFile(bytes);
+        await handle.sync();
+    }
+    catch (error) {
+        failure = error;
+    }
+    finally {
+        try {
+            await handle.close();
+        }
+        catch (error) {
+            if (failure === undefined)
+                failure = error;
+        }
+    }
+    if (failure !== undefined) {
+        await rm(filename, { force: true }).catch(() => { });
+        throw failure;
+    }
+}
+/**
+ * Reads and synchronizes one regular non-symlink file.
+ * @param {string} filename - Exact filename.
+ * @param {string} projectId - Project identity.
+ * @param {string} code - Failure code.
+ * @param {string} message - Stable failure detail.
+ * @returns {Promise<Buffer>} Exact bytes.
+ */
+async function readAndSyncRegularFile(filename, projectId, code, message) {
+    try {
+        const status = await lstat(filename);
+        if (!status.isFile() || status.isSymbolicLink())
+            publicationFailure(code, projectId, message);
+        assertRegularFileImmutability(status, new Set(), projectId);
+        const handle = await open(filename, constants.O_RDONLY);
+        try {
+            const bytes = await handle.readFile();
+            await handle.sync();
+            return bytes;
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic)
+            throw error;
+        publicationFailure(code, projectId, message, error);
+    }
+}
+/**
+ * Lists every regular file beneath one projection and rejects symlinks or special nodes.
+ * @param {string} directory - Projection root.
+ * @param {string} projectId - Project identity.
+ * @returns {Promise<string[]>} Sorted relative POSIX paths.
+ */
+async function listRegularFiles(directory, projectId) {
+    /** @type {string[]} */
+    const files = [];
+    const identities = new Set();
+    try {
+        await visit(directory, "");
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic)
+            throw error;
+        publicationFailure("PUBLICATION_GENERATION_VERIFICATION_FAILED", projectId, "Immutable generation filesystem inventory could not be verified.", error);
+    }
+    return files.sort(compareStrings);
+    /**
+     * Visits one owned directory.
+     * @param {string} current - Exact directory.
+     * @param {string} relative - Projection-relative path.
+     * @returns {Promise<void>} Completion.
+     */
+    async function visit(current, relative) {
+        await assertRealInventoryDirectory(current, projectId);
+        const entries = await readdir(current);
+        entries.sort(compareStrings);
+        for (const entry of entries) {
+            const childRelative = relative.length == 0 ? entry : `${relative}/${entry}`;
+            if (!isSafeArtifactPath(childRelative)) {
+                publicationFailure("INVALID_PUBLICATION_PROJECTION", projectId, "Validator output contains a non-canonical relative path.");
+            }
+            const child = path.join(current, entry);
+            const status = await lstat(child);
+            if (status.isSymbolicLink()) {
+                publicationFailure("PUBLICATION_SYMLINK_TRAVERSAL", projectId, "Candidate generation contains a symbolic link.");
+            }
+            if (status.isDirectory())
+                await visit(child, childRelative);
+            else if (status.isFile()) {
+                assertRegularFileImmutability(status, identities, projectId);
+                files.push(childRelative);
+            }
+            else
+                publicationFailure("PUBLICATION_GENERATION_INVENTORY_MISMATCH", projectId, "Immutable generation contains an undeclared filesystem entry.");
+        }
+    }
+}
+/**
+ * Verifies that the manifest describes every directory and regular file in the immutable generation.
+ * @param {string} generationPath - Exact generation root.
+ * @param {import("./semantic/types.js").GenerationManifest} manifest - Verified manifest.
+ * @param {string} projectId - Project identity.
+ * @returns {Promise<void>} Completion.
+ */
+async function verifyGenerationInventory(generationPath, manifest, projectId) {
+    const expectedFiles = new Set(["manifest.json"]);
+    const expectedDirectories = new Set();
+    for (const target of manifest.targets) {
+        addExpectedDirectory(target.projections.source);
+        addExpectedDirectory(target.projections.build);
+        for (const artifact of target.artifacts) {
+            addExpectedFile(`${target.projections.source}/${artifact.path}`);
+        }
+        for (const artifact of target.buildArtifacts) {
+            addExpectedFile(`${target.projections.build}/${artifact.path}`);
+        }
+    }
+    /** @type {Set<string>} */
+    const observedFiles = new Set();
+    /** @type {Set<string>} */
+    const observedDirectories = new Set();
+    const identities = new Set();
+    try {
+        await visit(generationPath, "");
+    }
+    catch (error) {
+        if (error instanceof SemantifoldDiagnostic)
+            throw error;
+        publicationFailure("PUBLICATION_GENERATION_VERIFICATION_FAILED", projectId, "Immutable generation filesystem inventory could not be verified.", error);
+    }
+    if (!sameStringSet(expectedFiles, observedFiles) || !sameStringSet(expectedDirectories, observedDirectories)) {
+        publicationFailure("PUBLICATION_GENERATION_INVENTORY_MISMATCH", projectId, "Immutable generation contains an undeclared filesystem entry.");
+    }
+    /**
+     * Adds one expected directory and each generation-relative parent.
+     * @param {string} relative - POSIX-style generation-relative directory.
+     * @returns {void}
+     */
+    function addExpectedDirectory(relative) {
+        const parts = relative.split("/");
+        for (let index = 1; index <= parts.length; index += 1) {
+            expectedDirectories.add(parts.slice(0, index).join("/"));
+        }
+    }
+    /**
+     * Adds one expected regular file and its parent directories.
+     * @param {string} relative - POSIX-style generation-relative filename.
+     * @returns {void}
+     */
+    function addExpectedFile(relative) {
+        expectedFiles.add(relative);
+        const separator = relative.lastIndexOf("/");
+        if (separator >= 0)
+            addExpectedDirectory(relative.slice(0, separator));
+    }
+    /**
+     * Visits every entry in one generation directory without following links.
+     * @param {string} current - Exact directory.
+     * @param {string} relative - Generation-relative directory.
+     * @returns {Promise<void>} Completion.
+     */
+    async function visit(current, relative) {
+        await assertRealInventoryDirectory(current, projectId);
+        const entries = await readdir(current);
+        entries.sort(compareStrings);
+        for (const entry of entries) {
+            const childRelative = relative.length == 0 ? entry : `${relative}/${entry}`;
+            if (!isSafeArtifactPath(childRelative)) {
+                publicationFailure("PUBLICATION_GENERATION_INVENTORY_MISMATCH", projectId, "Immutable generation contains an undeclared filesystem entry.");
+            }
+            const child = path.join(current, entry);
+            const status = await lstat(child);
+            if (status.isSymbolicLink()) {
+                publicationFailure("PUBLICATION_SYMLINK_TRAVERSAL", projectId, "Candidate generation contains a symbolic link.");
+            }
+            if (status.isDirectory()) {
+                observedDirectories.add(childRelative);
+                await visit(child, childRelative);
+            }
+            else if (status.isFile()) {
+                assertRegularFileImmutability(status, identities, projectId);
+                observedFiles.add(childRelative);
+            }
+            else {
+                publicationFailure("PUBLICATION_GENERATION_INVENTORY_MISMATCH", projectId, "Immutable generation contains an undeclared filesystem entry.");
+            }
+        }
+    }
+}
+/**
+ * Verifies one inventory traversal root without following symbolic links.
+ * @param {string} directory - Exact directory about to be read.
+ * @param {string} projectId - Project identity.
+ * @returns {Promise<void>} Completion.
+ */
+async function assertRealInventoryDirectory(directory, projectId) {
+    const status = await lstat(directory);
+    if (status.isSymbolicLink()) {
+        publicationFailure("PUBLICATION_SYMLINK_TRAVERSAL", projectId, "Candidate generation contains a symbolic link.");
+    }
+    if (!status.isDirectory()) {
+        publicationFailure("PUBLICATION_GENERATION_INVENTORY_MISMATCH", projectId, "Immutable generation contains an undeclared filesystem entry.");
+    }
+}
+/**
+ * Rejects external hard links and duplicate stable file identities.
+ * @param {import("node:fs").Stats} status - Regular-file status.
+ * @param {Set<string>} identities - Previously observed device/inode identities.
+ * @param {string} projectId - Project identity.
+ * @returns {void}
+ */
+function assertRegularFileImmutability(status, identities, projectId) {
+    if (status.nlink > 1) {
+        publicationFailure("PUBLICATION_HARD_LINK", projectId, "Immutable generation files must not have external hard links.");
+    }
+    const identity = stableFileIdentity(status);
+    if (identity !== null) {
+        if (identities.has(identity)) {
+            publicationFailure("PUBLICATION_HARD_LINK", projectId, "Immutable generation files must have unique filesystem identities.");
+        }
+        identities.add(identity);
+    }
+}
+/**
+ * Returns a stable device/inode identity only where the host reports one.
+ * @param {import("node:fs").Stats} status - File status.
+ * @returns {string | null} Identity or unavailable.
+ */
+function stableFileIdentity(status) {
+    if ((typeof status.dev != "number" && typeof status.dev != "bigint") ||
+        (typeof status.ino != "number" && typeof status.ino != "bigint") || status.ino == 0)
+        return null;
+    return `${String(status.dev)}:${String(status.ino)}`;
+}
+/**
+ * Compares two string sets exactly.
+ * @param {Set<string>} left - First set.
+ * @param {Set<string>} right - Second set.
+ * @returns {boolean} Equality.
+ */
+function sameStringSet(left, right) {
+    return left.size == right.size && [...left].every(value => right.has(value));
+}
+/**
+ * Synchronizes every directory in a staged tree from leaves to root.
+ * @param {string} root - Tree root.
+ * @returns {Promise<void>} Completion.
+ */
+async function syncTreeDirectories(root) {
+    const entries = await readdir(root, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isDirectory() && !entry.isSymbolicLink())
+            await syncTreeDirectories(path.join(root, entry.name));
+    }
+    await syncDirectory(root);
+}
+/**
+ * Synchronizes one directory entry set.
+ * @param {string} directory - Directory path.
+ * @returns {Promise<void>} Completion.
+ */
+async function syncDirectory(directory) {
+    const handle = await open(directory, constants.O_RDONLY);
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+}
+/**
+ * Ensures every existing path component is a real directory and optionally creates missing components.
+ * @param {string} directory - Canonical absolute directory.
+ * @param {boolean} create - Whether missing components may be created.
+ * @param {string} projectId - Project identity.
+ * @returns {Promise<void>} Completion.
+ */
+async function ensureDirectoryWithoutSymlinks(directory, create, projectId) {
+    const parsed = path.parse(directory);
+    const relative = directory.slice(parsed.root.length);
+    const parts = relative.split(path.sep).filter(Boolean);
+    let current = parsed.root;
+    for (const part of parts) {
+        current = path.join(current, part);
+        try {
+            const status = await lstat(current);
+            if (status.isSymbolicLink()) {
+                publicationFailure("PUBLICATION_SYMLINK_TRAVERSAL", projectId, "Owned path traversal encountered a symbolic link.");
+            }
+            if (!status.isDirectory()) {
+                publicationFailure("INVALID_PUBLICATION_ROOT", projectId, "Owned root path contains a non-directory component.");
+            }
+        }
+        catch (error) {
+            if (!isErrorCode(error, "ENOENT")) {
+                if (error instanceof SemantifoldDiagnostic)
+                    throw error;
+                publicationFailure("INVALID_PUBLICATION_ROOT", projectId, "Owned root path could not be validated.", error);
+            }
+            if (!create) {
+                publicationFailure("INVALID_PUBLICATION_ROOT", projectId, "Source root must exist as a real directory.", error);
+            }
+            try {
+                await mkdir(current, { mode: 0o700 });
+            }
+            catch (mkdirError) {
+                publicationFailure("INVALID_PUBLICATION_ROOT", projectId, "Publication root could not be created safely.", mkdirError);
+            }
+        }
+    }
+}
+/**
+ * Ensures one reserved publisher directory is neither a symlink nor an unowned file.
+ * @param {string} directory - Reserved directory.
+ * @param {string} projectId - Project identity.
+ * @returns {Promise<void>} Completion.
+ */
+async function ensureOwnedDirectory(directory, projectId) {
+    try {
+        await mkdir(directory, { mode: 0o700 });
+    }
+    catch (error) {
+        if (!isErrorCode(error, "EEXIST")) {
+            publicationFailure("PUBLICATION_STAGE_WRITE_FAILED", projectId, "Publisher-owned directory could not be created.", error);
+        }
+    }
+    let status;
+    try {
+        status = await lstat(directory);
+    }
+    catch (error) {
+        publicationFailure("PUBLICATION_STAGE_WRITE_FAILED", projectId, "Reserved publisher path could not be inspected.", error);
+    }
+    if (!status.isDirectory() || status.isSymbolicLink()) {
+        publicationFailure(status.isSymbolicLink() ? "PUBLICATION_SYMLINK_TRAVERSAL" : "PUBLICATION_UNOWNED_CONFLICT", projectId, "Reserved publisher path is not an owned real directory.");
+    }
+}
+/**
+ * Ensures an owned path has no pre-existing entry.
+ * @param {string} filename - Exact path.
+ * @param {string} code - Diagnostic code.
+ * @param {string} projectId - Project identity.
+ * @param {string} message - Stable failure detail.
+ * @returns {Promise<void>} Completion.
+ */
+async function assertAbsent(filename, code, projectId, message) {
+    try {
+        await lstat(filename);
+        publicationFailure(code, projectId, message);
+    }
+    catch (error) {
+        if (isErrorCode(error, "ENOENT"))
+            return;
+        if (error instanceof SemantifoldDiagnostic)
+            throw error;
+        publicationFailure(code, projectId, message, error);
+    }
+}
+/**
+ * Resolves a validated relative path under an owned root and rejects escape.
+ * @param {string} root - Owned root.
+ * @param {string} relative - Validated relative POSIX path.
+ * @param {string} projectId - Project identity.
+ * @returns {string} Exact owned path.
+ */
+function ownedPath(root, relative, projectId) {
+    const resolved = path.resolve(root, ...relative.split("/"));
+    const child = path.relative(root, resolved);
+    if (child.length == 0 || child == ".." || child.startsWith(`..${path.sep}`) || path.isAbsolute(child)) {
+        publicationFailure("PUBLICATION_PATH_ESCAPE", projectId, "Resolved publication path escaped its owned root.");
+    }
+    return resolved;
+}
+/**
+ * Checks a canonical non-root absolute path without filesystem access.
+ * @param {unknown} value - Path candidate.
+ * @returns {value is string} Whether the path is canonical.
+ */
+function isCanonicalAbsolutePath(value) {
+    return isCanonicalAbsolutePathForPath(value, path);
+}
+/**
+ * Checks one absolute path using the supplied host path semantics.
+ * This helper is intentionally not part of the package root API.
+ * @param {unknown} value - Path candidate.
+ * @param {typeof path.posix | typeof path.win32} hostPath - Host-native path implementation.
+ * @returns {value is string} Whether the path is canonical for that host.
+ */
+export function isCanonicalAbsolutePathForPath(value, hostPath) {
+    const separatorAlias = hostPath.sep == "/" ? "\\" : "/";
+    return typeof value == "string" && value.length > 0 && !value.includes("\0") && !value.includes(separatorAlias) &&
+        hostPath.isAbsolute(value) && value != hostPath.parse(value).root && hostPath.normalize(value) == value &&
+        hostPath.resolve(value) == value;
+}
+/**
+ * Checks conservative portable overlap between absolute paths.
+ * @param {string} left - First path.
+ * @param {string} right - Second path.
+ * @returns {boolean} Whether either contains the other.
+ */
+function pathsOverlap(left, right) {
+    const leftKey = left.toLowerCase();
+    const rightKey = right.toLowerCase();
+    return leftKey == rightKey || leftKey.startsWith(`${rightKey}${path.sep}`) || rightKey.startsWith(`${leftKey}${path.sep}`);
+}
+/**
+ * Checks whether a path is equal to or nested beneath one canonical root.
+ * @param {string} root - Canonical root.
+ * @param {string} candidate - Canonical candidate.
+ * @returns {boolean} Whether the candidate is within the root.
+ */
+function isPathWithin(root, candidate) {
+    const relative = path.relative(root, candidate);
+    return relative.length == 0 || (relative != ".." && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative));
+}
+/**
+ * Checks whether a path is strictly nested beneath one canonical root.
+ * @param {string} root - Canonical root.
+ * @param {string} candidate - Canonical candidate.
+ * @returns {boolean} Whether the candidate is a strict descendant.
+ */
+function isStrictPathDescendant(root, candidate) {
+    return isPathWithin(root, candidate) && path.relative(root, candidate).length > 0;
+}
+/**
+ * Serializes stable generated JSON with one trailing LF.
+ * @param {unknown} value - JSON value.
+ * @returns {Buffer} UTF-8 bytes.
+ */
+function serializeJson(value) {
+    return Buffer.from(`${JSON.stringify(value, null, 2)}\n`, "utf8");
+}
+/**
+ * Hashes exact bytes with SHA-256.
+ * @param {Uint8Array} bytes - Exact bytes.
+ * @returns {string} Lowercase hexadecimal hash.
+ */
+function sha256(bytes) {
+    return createHash("sha256").update(bytes).digest("hex");
+}
+/**
+ * Deeply freezes a parsed JSON value.
+ * @template T
+ * @param {T} value - JSON value.
+ * @returns {T} Frozen value.
+ */
+function deepFreeze(value) {
+    if (typeof value == "object" && value != null) {
+        for (const child of Object.values(value))
+            deepFreeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}
+/**
+ * Compares detached JSON values without depending on object-key order.
+ * @param {unknown} left - First JSON value.
+ * @param {unknown} right - Second JSON value.
+ * @returns {boolean} Whether the values are structurally equal.
+ */
+function sameJsonValue(left, right) {
+    if (left === right)
+        return true;
+    if (Array.isArray(left) || Array.isArray(right)) {
+        return Array.isArray(left) && Array.isArray(right) && left.length == right.length &&
+            left.every((entry, index) => sameJsonValue(entry, right[index]));
+    }
+    if (!isPlainObject(left) || !isPlainObject(right))
+        return false;
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    return leftKeys.length == rightKeys.length &&
+        leftKeys.every(key => Object.hasOwn(right, key) && sameJsonValue(left[key], right[key]));
+}
+/**
+ * Checks an active-pointer value.
+ * @param {unknown} value - Parsed value.
+ * @returns {value is ActivePointer} Whether the value is strict and versioned.
+ */
+function isActivePointer(value) {
+    return isPlainObject(value) && hasExactKeys(value, ["generationId", "manifestHash", "projectId", "schema", "version"]) &&
+        value.schema == "SemantifoldActiveGeneration" && value.version == 1 &&
+        typeof value.projectId == "string" && identityPattern.test(value.projectId) &&
+        typeof value.generationId == "string" && generationPattern.test(value.generationId) &&
+        typeof value.manifestHash == "string" && /^[a-f0-9]{64}$/u.test(value.manifestHash);
+}
+/**
+ * Checks a recovery-journal value.
+ * @param {unknown} value - Parsed value.
+ * @returns {value is PublicationJournal} Whether the value is strict and versioned.
+ */
+function isPublicationJournal(value) {
+    return isPlainObject(value) && hasExactKeys(value, ["generationId", "projectId", "schema", "tempPointer", "version"]) &&
+        value.schema == "SemantifoldPublicationJournal" && value.version == 1 &&
+        typeof value.projectId == "string" && identityPattern.test(value.projectId) &&
+        typeof value.generationId == "string" && generationPattern.test(value.generationId) &&
+        value.tempPointer == `.active-generation.${value.generationId}.tmp`;
+}
+/**
+ * Checks an ordinary object with exactly the expected enumerable string keys.
+ * @param {Record<string, unknown>} value - Object candidate.
+ * @param {readonly string[]} keys - Sorted expected keys.
+ * @returns {boolean} Whether keys match exactly.
+ */
+function hasExactKeys(value, keys) {
+    const actual = Object.keys(value).sort(compareStrings);
+    return actual.length == keys.length && actual.every((key, index) => key == keys[index]);
+}
+/**
+ * Checks for an ordinary string-keyed object.
+ * @param {unknown} value - Candidate value.
+ * @returns {value is Record<string, unknown>} Whether the value is plain.
+ */
+function isPlainObject(value) {
+    return typeof value == "object" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype;
+}
+/**
+ * Checks for a dense ordinary array.
+ * @param {unknown} value - Candidate value.
+ * @returns {value is unknown[]} Whether the value is dense.
+ */
+function isDenseArray(value) {
+    if (!Array.isArray(value))
+        return false;
+    const indexedKeys = Object.keys(value).filter(key => /^(?:0|[1-9][0-9]*)$/u.test(key));
+    return indexedKeys.length == value.length;
+}
+/**
+ * Compares strings by Unicode code unit.
+ * @param {string} left - First string.
+ * @param {string} right - Second string.
+ * @returns {number} Ordering.
+ */
+function compareStrings(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+/**
+ * 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;
+}
+/**
+ * Throws one stable publication diagnostic without embedding host paths or raw filesystem messages.
+ * @param {string} code - Stable diagnostic code.
+ * @param {string} projectId - Project identity.
+ * @param {string} message - Stable detail.
+ * @param {unknown} [error] - Preserved cause.
+ * @returns {never} Always throws.
+ */
+function publicationFailure(code, projectId, message, error) {
+    throw new SemantifoldDiagnostic({
+        cause: error instanceof Error ? error : undefined,
+        code,
+        language: projectId,
+        message
+    });
+}
+/**
+ * @typedef ValidatedPublicationTarget
+ * @property {string} id - Target identity.
+ * @property {import("./semantic/types.js").GeneratedArtifactSet} artifactSet - Detached artifact set.
+ * @property {string} sourceProjection - Source projection.
+ * @property {string} buildProjection - Build projection.
+ * @property {import("./semantic/types.js").PublicationTargetRole} role - Language-neutral target role.
+ * @property {readonly import("./semantic/types.js").PublicationValidator[]} validators - Ordered validators.
+ */
+/**
+ * @typedef ActivePointer
+ * @property {"SemantifoldActiveGeneration"} schema - Schema discriminator.
+ * @property {1} version - Schema version.
+ * @property {string} projectId - Project identity.
+ * @property {string} generationId - Generation identity.
+ * @property {string} manifestHash - SHA-256 generation-manifest hash.
+ */
+/**
+ * @typedef PublicationJournal
+ * @property {"SemantifoldPublicationJournal"} schema - Schema discriminator.
+ * @property {1} version - Schema version.
+ * @property {string} projectId - Project identity.
+ * @property {string} generationId - Candidate generation identity.
+ * @property {string} tempPointer - Owned sibling temporary-pointer filename.
+ */
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"publication.js","sourceRoot":"","sources":["../../src/publication.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {createHash, randomUUID} from \"node:crypto\"\nimport {constants} from \"node:fs\"\nimport {lstat, mkdir, open, readFile, readdir, realpath, rename, rm} from \"node:fs/promises\"\nimport path from \"node:path\"\nimport {findPortableArtifactPathConflict, isSafeArtifactPath} from \"./artifact-path.js\"\nimport {createGeneratedArtifactSet} from \"./artifacts.js\"\nimport {finalizeByteMapping} from \"./binary-mapping.js\"\nimport {SemantifoldDiagnostic} from \"./diagnostic.js\"\nimport {finalizeMapping, toSourceMapV3} from \"./mapping.js\"\n\nconst activePointerName = \"active-generation.json\"\nconst generationsName = \"generations\"\nconst journalName = \".semantifold-publication-journal\"\nconst identityPattern = /^[a-z][a-z0-9-]*$/u\nconst generationPattern = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u\nconst buildRolePattern = /^[a-z][a-z0-9-]*$/u\nconst mediaTypePattern = /^[A-Za-z0-9!#$&^_.+-]+\\/[A-Za-z0-9!#$&^_.+-]+(?:;[\\u0020-\\u007e]+)?$/u\nconst targetRoles = new Set([\"application\", \"binary\", \"text\"])\nconst publicationBoundaries = new Set([\n  \"after-stage\",\n  \"before-pointer-replace\",\n  \"after-pointer-replace\",\n  \"before-cleanup\",\n  \"before-journal-remove\"\n])\n/** @type {WeakMap<GeneratedArtifactPublisher, {boundary: string, error: Error}>} */\nconst injectedPublicationFailures = new WeakMap()\n/** @type {WeakMap<GeneratedArtifactPublisher, (operation: string) => void>} */\nconst publicationFilesystemObservers = new WeakMap()\n\n/**\n * Installs one internal, one-shot deterministic failure used by real-filesystem interruption specs.\n * This helper is intentionally not part of the package root API.\n * @param {GeneratedArtifactPublisher} publisher - Publisher instance.\n * @param {\"after-stage\" | \"before-pointer-replace\" | \"after-pointer-replace\" | \"before-cleanup\" | \"before-journal-remove\"} boundary - Exact lifecycle boundary.\n * @param {Error} error - Injected failure.\n * @returns {void}\n */\nexport function injectPublicationFailure(publisher, boundary, error) {\n  if (!(publisher instanceof GeneratedArtifactPublisher) || !publicationBoundaries.has(boundary) || !(error instanceof Error)) {\n    throw new TypeError(\"Invalid publication failure injection.\")\n  }\n  injectedPublicationFailures.set(publisher, {boundary, error})\n}\n\n/**\n * Installs an internal deterministic filesystem-operation observer for durability specs.\n * This helper is intentionally not part of the package root API.\n * @param {GeneratedArtifactPublisher} publisher - Publisher instance.\n * @param {(operation: string) => void} observer - Synchronous operation observer.\n * @returns {void}\n */\nexport function observePublicationFilesystem(publisher, observer) {\n  if (!(publisher instanceof GeneratedArtifactPublisher) || typeof observer != \"function\") {\n    throw new TypeError(\"Invalid publication filesystem observer.\")\n  }\n  publicationFilesystemObservers.set(publisher, observer)\n}\n\n/**\n * Owns transactional publication in one dedicated directory beneath a canonical project root.\n */\nexport class GeneratedArtifactPublisher {\n  /** @type {string} */\n  #projectId\n  /** @type {string} */\n  #projectRoot\n  /** @type {string} */\n  #publicationRoot\n  /** @type {readonly string[]} */\n  #sourceRoots\n  /** @type {Promise<void>} */\n  #publicationTail = Promise.resolve()\n\n  /**\n   * Creates a project-scoped publisher without touching the filesystem.\n   * @param {object} options - Publisher identity and owned paths.\n   * @param {string} options.projectId - Stable lowercase project identity.\n   * @param {string} options.projectRoot - Canonical absolute project root.\n   * @param {string} options.publicationRoot - Canonical absolute publisher-owned directory beneath the project root.\n   * @param {readonly string[]} options.sourceRoots - Canonical absolute project source roots kept disjoint from publication.\n   */\n  constructor(options) {\n    if (!isPlainObject(options)) {\n      publicationFailure(\"INVALID_PUBLICATION_REQUEST\", \"publication\", \"Publisher options must be a plain object.\")\n    }\n    const {projectId, projectRoot, publicationRoot, sourceRoots} = options\n\n    if (!identityPattern.test(projectId ?? \"\")) {\n      publicationFailure(\"INVALID_PUBLICATION_REQUEST\", \"publication\", \"Project identity must be a stable lowercase ID.\")\n    }\n    if (!isCanonicalAbsolutePath(projectRoot) || !isCanonicalAbsolutePath(publicationRoot) ||\n      !isStrictPathDescendant(projectRoot, publicationRoot)) {\n      publicationFailure(\"INVALID_PUBLICATION_ROOT\", projectId,\n        \"Project and publication roots must be canonical absolute paths with publication strictly beneath the project root.\")\n    }\n    if (!isDenseArray(sourceRoots) || sourceRoots.length == 0) {\n      publicationFailure(\"INVALID_PUBLICATION_ROOT\", projectId, \"Source roots must be a non-empty array of canonical absolute paths.\")\n    }\n    /** @type {string[]} */\n    const validatedSourceRoots = []\n\n    for (let index = 0; index < sourceRoots.length; index += 1) {\n      const sourceRoot = sourceRoots[index]\n\n      if (!isCanonicalAbsolutePath(sourceRoot)) {\n        publicationFailure(\"INVALID_PUBLICATION_ROOT\", projectId,\n          \"Source roots must be a non-empty array of canonical absolute paths.\")\n      }\n      if (!isPathWithin(projectRoot, sourceRoot)) {\n        publicationFailure(\"INVALID_PUBLICATION_ROOT\", projectId,\n          \"Source roots must remain within the canonical project root.\")\n      }\n      if (pathsOverlap(publicationRoot, sourceRoot)) {\n        publicationFailure(\"PUBLICATION_SOURCE_OVERLAP\", projectId,\n          \"Publication root and source roots must be disjoint.\")\n      }\n      validatedSourceRoots.push(sourceRoot)\n    }\n\n    this.#projectId = projectId\n    this.#projectRoot = projectRoot\n    this.#publicationRoot = publicationRoot\n    this.#sourceRoots = Object.freeze(validatedSourceRoots)\n  }\n\n  /**\n   * Stages, validates, and publishes one complete immutable project generation.\n   * Calls on one publisher instance are serialized in invocation order.\n   * @param {import(\"./semantic/types.js\").PublicationRequest} request - Complete publication request.\n   * @returns {Promise<import(\"./semantic/types.js\").PublishedGeneration>} Committed immutable snapshot.\n   */\n  publish(request) {\n    /** @type {(value: import(\"./semantic/types.js\").PublishedGeneration) => void} */\n    let resolveResult\n    /** @type {(reason?: unknown) => void} */\n    let rejectResult\n    const result = new Promise((resolve, reject) => {\n      resolveResult = resolve\n      rejectResult = reject\n    })\n    const operation = this.#publicationTail.then(async () => {\n      try {\n        resolveResult(await this.#publish(request))\n      } catch (error) {\n        rejectResult(error)\n      }\n    })\n\n    this.#publicationTail = operation.catch(() => {})\n\n    return result\n  }\n\n  /**\n   * Resolves the active pointer exactly once and verifies the referenced immutable generation.\n   * @returns {Promise<import(\"./semantic/types.js\").PublishedGeneration>} Verified pointer-once snapshot.\n   */\n  async resolveActive() {\n    await this.#prepareRoot()\n    const pointerPath = path.join(this.#publicationRoot, activePointerName)\n    const pointer = await readActivePointer(pointerPath, this.#projectId, false)\n\n    if (!pointer) publicationFailure(\"ACTIVE_GENERATION_MISSING\", this.#projectId, \"No active generation has been published.\")\n    const generation = await verifyPublishedGeneration(this.#publicationRoot, this.#projectId, pointer, false)\n    const cleanupPending = await hasCommittedCleanupJournal(this.#publicationRoot, this.#projectId, pointer.generationId)\n\n    return publishedGeneration(this.#publicationRoot, generation.manifest, cleanupPending)\n  }\n\n  /**\n   * Performs one serialized publication.\n   * @param {import(\"./semantic/types.js\").PublicationRequest} request - Complete request.\n   * @returns {Promise<import(\"./semantic/types.js\").PublishedGeneration>} Publication result.\n   */\n  async #publish(request) {\n    const validated = validatePublicationRequest(request, this.#projectId)\n\n    await this.#prepareRoot()\n    await reconcilePublication(this.#publicationRoot, this.#projectId, this)\n    await verifyAtomicReplacement(this.#publicationRoot, this.#projectId)\n    await validateExistingPointer(this.#publicationRoot, this.#projectId)\n\n    const generationPath = path.join(this.#publicationRoot, generationsName, validated.generationId)\n    const manifestPath = path.join(generationPath, \"manifest.json\")\n    const tempPointerName = `.active-generation.${validated.generationId}.tmp`\n    const tempPointerPath = path.join(this.#publicationRoot, tempPointerName)\n    const journalPath = path.join(this.#publicationRoot, journalName, `${validated.generationId}.json`)\n    let committed = false\n    let journalCreated = false\n    let generationCreated = false\n    let tempPointerCreated = false\n    let failureCode = \"PUBLICATION_STAGE_WRITE_FAILED\"\n\n    try {\n      await assertAbsent(generationPath, \"PUBLICATION_UNOWNED_CONFLICT\", this.#projectId,\n        \"Generation identity is already owned or ambiguous.\")\n      await assertAbsent(tempPointerPath, \"PUBLICATION_UNOWNED_CONFLICT\", this.#projectId,\n        \"Temporary active pointer path is already owned or ambiguous.\")\n      await assertAbsent(journalPath, \"PUBLICATION_UNOWNED_CONFLICT\", this.#projectId,\n        \"Publication journal identity is already owned or ambiguous.\")\n      const journal = {\n        generationId: validated.generationId,\n        projectId: this.#projectId,\n        schema: \"SemantifoldPublicationJournal\",\n        tempPointer: tempPointerName,\n        version: 1\n      }\n\n      await writeSyncedFile(journalPath, serializeJson(journal), \"wx\")\n      journalCreated = true\n      await syncDirectory(path.dirname(journalPath))\n      await mkdir(generationPath, {mode: 0o700})\n      generationCreated = true\n      await syncDirectory(path.dirname(generationPath))\n\n      /** @type {import(\"./semantic/types.js\").GenerationTargetManifest[]} */\n      const targetManifests = []\n\n      for (const target of validated.targets) {\n        targetManifests.push(await stageTarget(generationPath, target, this.#projectId))\n      }\n      reachPublicationBoundary(this, \"after-stage\")\n      const manifestCandidate = /** @type {import(\"./semantic/types.js\").GenerationManifest} */ ({\n        generationId: validated.generationId,\n        projectId: this.#projectId,\n        schema: /** @type {const} */ (\"SemantifoldGenerationManifest\"),\n        targets: targetManifests,\n        version: /** @type {const} */ (1)\n      })\n      const manifestBytes = serializeJson(manifestCandidate)\n      const manifest = validateGenerationManifest(JSON.parse(manifestBytes.toString(\"utf8\")), this.#projectId,\n        validated.generationId)\n\n      await writeSyncedFile(manifestPath, manifestBytes, \"wx\")\n      await syncTreeDirectories(generationPath)\n      await verifyManifestFiles(generationPath, manifest, this.#projectId)\n      failureCode = \"PUBLICATION_POINTER_FAILED\"\n\n      const pointer = {\n        generationId: validated.generationId,\n        manifestHash: sha256(manifestBytes),\n        projectId: this.#projectId,\n        schema: \"SemantifoldActiveGeneration\",\n        version: 1\n      }\n\n      await writeSyncedFile(tempPointerPath, serializeJson(pointer), \"wx\", () => {\n        tempPointerCreated = true\n      })\n      reachPublicationBoundary(this, \"before-pointer-replace\")\n      await rename(tempPointerPath, path.join(this.#publicationRoot, activePointerName))\n      tempPointerCreated = false\n      committed = true\n      reachPublicationBoundary(this, \"after-pointer-replace\")\n      await syncDirectory(this.#publicationRoot)\n\n      let cleanupPending = false\n\n      try {\n        reachPublicationBoundary(this, \"before-cleanup\")\n        await removeJournalOwnedState({\n          journalPath,\n          projectId: this.#projectId,\n          publicationRoot: this.#publicationRoot,\n          publisher: this\n        })\n      } catch (_error) {\n        cleanupPending = true\n      }\n\n      return publishedGeneration(this.#publicationRoot, deepFreeze(manifest), cleanupPending)\n    } catch (error) {\n      if (!committed) {\n        try {\n          await removeJournalOwnedState({\n            ...(generationCreated ? {candidatePath: generationPath} : {}),\n            ...(journalCreated ? {journalPath} : {}),\n            projectId: this.#projectId,\n            publicationRoot: this.#publicationRoot,\n            publisher: this,\n            ...(tempPointerCreated ? {temporaryPointerPath: tempPointerPath} : {})\n          })\n        } catch (cleanupError) {\n          if (cleanupError instanceof SemantifoldDiagnostic) throw cleanupError\n          publicationFailure(\"PUBLICATION_RECOVERY_FAILED\", this.#projectId,\n            \"Failed publication left state that requires recovery.\", cleanupError)\n        }\n      }\n      if (error instanceof SemantifoldDiagnostic) throw error\n\n      publicationFailure(failureCode, this.#projectId,\n        committed\n          ? \"Active generation changed, but durable pointer publication did not complete.\"\n          : \"Candidate generation could not be staged.\", error)\n    }\n  }\n\n  /**\n   * Creates and validates owned root directories and source-root separation.\n   * @returns {Promise<void>} Completion.\n   */\n  async #prepareRoot() {\n    await ensureDirectoryWithoutSymlinks(this.#projectRoot, false, this.#projectId)\n    await ensureDirectoryWithoutSymlinks(this.#publicationRoot, true, this.#projectId)\n    let exactProject\n    let exactPublication\n\n    try {\n      exactProject = await realpath(this.#projectRoot)\n      exactPublication = await realpath(this.#publicationRoot)\n    } catch (error) {\n      publicationFailure(\"INVALID_PUBLICATION_ROOT\", this.#projectId,\n        \"Publication root could not be resolved safely.\", error)\n    }\n    if (!isStrictPathDescendant(exactProject, exactPublication)) {\n      publicationFailure(\"INVALID_PUBLICATION_ROOT\", this.#projectId,\n        \"Publication root must resolve strictly beneath the project root.\")\n    }\n    for (const sourceRoot of this.#sourceRoots) {\n      await ensureDirectoryWithoutSymlinks(sourceRoot, false, this.#projectId)\n      let exactSource\n\n      try {\n        exactSource = await realpath(sourceRoot)\n      } catch (error) {\n        publicationFailure(\"INVALID_PUBLICATION_ROOT\", this.#projectId,\n          \"Source root could not be resolved safely.\", error)\n      }\n\n      if (!isPathWithin(exactProject, exactSource)) {\n        publicationFailure(\"INVALID_PUBLICATION_ROOT\", this.#projectId,\n          \"Source roots must resolve within the project root.\")\n      }\n      if (pathsOverlap(exactPublication, exactSource)) {\n        publicationFailure(\"PUBLICATION_SOURCE_OVERLAP\", this.#projectId,\n          \"Publication root and source roots resolve to overlapping paths.\")\n      }\n    }\n    await ensureOwnedDirectory(path.join(this.#publicationRoot, generationsName), this.#projectId)\n    await ensureOwnedDirectory(path.join(this.#publicationRoot, journalName), this.#projectId)\n  }\n}\n\n/**\n * Throws and consumes a configured internal failure at an exact lifecycle boundary.\n * @param {GeneratedArtifactPublisher} publisher - Active publisher.\n * @param {string} boundary - Reached boundary.\n * @returns {void}\n */\nfunction reachPublicationBoundary(publisher, boundary) {\n  const injection = injectedPublicationFailures.get(publisher)\n\n  if (injection?.boundary == boundary) {\n    injectedPublicationFailures.delete(publisher)\n    throw injection.error\n  }\n}\n\n/**\n * Reports one completed filesystem operation to the internal deterministic seam.\n * @param {GeneratedArtifactPublisher} publisher - Active publisher.\n * @param {string} operation - Completed operation.\n * @returns {void}\n */\nfunction observePublicationFilesystemOperation(publisher, operation) {\n  publicationFilesystemObservers.get(publisher)?.(operation)\n}\n\n/**\n * Reconciles only candidates and temporary pointers whose ownership is proven by a strict journal.\n * The active pointer remains the sole commit authority.\n * @param {string} publicationRoot - Publication root.\n * @param {string} projectId - Project identity.\n * @param {GeneratedArtifactPublisher} publisher - Active publisher.\n * @returns {Promise<void>} Completion.\n */\nasync function reconcilePublication(publicationRoot, projectId, publisher) {\n  const journals = await readPublicationJournals(publicationRoot, projectId)\n\n  if (journals.length == 0) return\n  const pointer = await readActivePointer(path.join(publicationRoot, activePointerName), projectId, true)\n\n  if (pointer) await verifyPublishedGeneration(publicationRoot, projectId, pointer, true)\n  for (const {journal, journalPath} of journals) {\n    const candidatePath = ownedPath(path.join(publicationRoot, generationsName), journal.generationId, projectId)\n    const temporaryPointerPath = path.join(publicationRoot, journal.tempPointer)\n    const committed = pointer?.generationId == journal.generationId\n\n    if (!committed) {\n      const candidateStatus = await optionalStatus(candidatePath, projectId, \"candidate generation\")\n\n      if (candidateStatus) {\n        if (!candidateStatus.isDirectory() || candidateStatus.isSymbolicLink()) {\n          publicationFailure(\"PUBLICATION_RECOVERY_FAILED\", projectId,\n            \"Journal-owned candidate is not a real directory.\")\n        }\n      }\n    }\n    const temporaryStatus = await optionalStatus(temporaryPointerPath, projectId, \"temporary pointer\")\n\n    if (temporaryStatus) {\n      if (!temporaryStatus.isFile() || temporaryStatus.isSymbolicLink()) {\n        publicationFailure(\"PUBLICATION_RECOVERY_FAILED\", projectId,\n          \"Journal-owned temporary pointer is not a regular file.\")\n      }\n    }\n    await removeJournalOwnedState({\n      ...(!committed ? {candidatePath} : {}),\n      journalPath,\n      projectId,\n      publicationRoot,\n      publisher,\n      temporaryPointerPath\n    })\n  }\n}\n\n/**\n * Reads and validates every recovery journal without changing publication state.\n * @param {string} publicationRoot - Publication root.\n * @param {string} projectId - Project identity.\n * @returns {Promise<readonly {journal: PublicationJournal, journalPath: string}[]>} Ordered journals.\n */\nasync function readPublicationJournals(publicationRoot, projectId) {\n  const journalDirectory = path.join(publicationRoot, journalName)\n  let entries\n\n  try {\n    entries = await readdir(journalDirectory)\n  } catch (error) {\n    publicationFailure(\"PUBLICATION_RECOVERY_FAILED\", projectId,\n      \"Publication journal directory could not be inspected.\", error)\n  }\n  entries.sort(compareStrings)\n  /** @type {{journal: PublicationJournal, journalPath: string}[]} */\n  const journals = []\n\n  for (const entry of entries) {\n    if (!entry.endsWith(\".json\") || !generationPattern.test(entry.slice(0, -5))) {\n      publicationFailure(\"PUBLICATION_RECOVERY_FAILED\", projectId,\n        \"Publication journal contains an unrecognized entry.\")\n    }\n    const journalPath = path.join(journalDirectory, entry)\n    let journal\n\n    try {\n      const status = await lstat(journalPath)\n\n      if (!status.isFile() || status.isSymbolicLink()) {\n        publicationFailure(\"PUBLICATION_RECOVERY_FAILED\", projectId,\n          \"Publication journal entry must be a regular file.\")\n      }\n      journal = JSON.parse(await readFile(journalPath, \"utf8\"))\n    } catch (error) {\n      if (error instanceof SemantifoldDiagnostic) throw error\n      publicationFailure(\"PUBLICATION_RECOVERY_FAILED\", projectId,\n        \"Publication journal entry is not valid JSON.\", error)\n    }\n    if (!isPublicationJournal(journal) || journal.projectId != projectId || `${journal.generationId}.json` != entry) {\n      publicationFailure(\"PUBLICATION_RECOVERY_FAILED\", projectId,\n        \"Publication journal entry does not match the versioned project contract.\")\n    }\n    journals.push({journal, journalPath})\n  }\n\n  return Object.freeze(journals)\n}\n\n/**\n * Reports committed cleanup state while failing closed on every journal entry.\n * @param {string} publicationRoot - Publication root.\n * @param {string} projectId - Project identity.\n * @param {string} generationId - Pointer-selected generation identity.\n * @returns {Promise<boolean>} Whether committed cleanup remains.\n */\nasync function hasCommittedCleanupJournal(publicationRoot, projectId, generationId) {\n  const journals = await readPublicationJournals(publicationRoot, projectId)\n\n  return journals.some(({journal}) => journal.generationId == generationId)\n}\n\n/**\n * Removes proven journal-owned state and durably synchronizes each parent before discarding its ownership proof.\n * @param {object} options - Exact cleanup state.\n * @param {string} [options.candidatePath] - Proven candidate generation path.\n * @param {string} [options.temporaryPointerPath] - Proven temporary pointer path.\n * @param {string} [options.journalPath] - Ownership journal path.\n * @param {string} options.projectId - Project identity.\n * @param {string} options.publicationRoot - Publication root.\n * @param {GeneratedArtifactPublisher} options.publisher - Active publisher.\n * @returns {Promise<void>} Completion.\n */\nasync function removeJournalOwnedState({candidatePath, journalPath, projectId, publicationRoot, publisher, temporaryPointerPath}) {\n  try {\n    if (candidatePath) {\n      await rm(candidatePath, {force: true, recursive: true})\n      observePublicationFilesystemOperation(publisher, \"remove-candidate\")\n      await syncDirectory(path.join(publicationRoot, generationsName))\n      observePublicationFilesystemOperation(publisher, \"sync-candidate-parent\")\n    }\n    if (temporaryPointerPath) {\n      await rm(temporaryPointerPath, {force: true})\n      observePublicationFilesystemOperation(publisher, \"remove-temporary-pointer\")\n      await syncDirectory(publicationRoot)\n      observePublicationFilesystemOperation(publisher, \"sync-temporary-pointer-parent\")\n    }\n    if (journalPath) {\n      reachPublicationBoundary(publisher, \"before-journal-remove\")\n      await rm(journalPath)\n      observePublicationFilesystemOperation(publisher, \"remove-journal\")\n      await syncDirectory(path.dirname(journalPath))\n      observePublicationFilesystemOperation(publisher, \"sync-journal-parent\")\n    }\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic) throw error\n    publicationFailure(\"PUBLICATION_RECOVERY_FAILED\", projectId,\n      \"Journal-owned publication state could not be durably reconciled.\", error)\n  }\n}\n\n/**\n * Reads optional metadata without following symbolic links.\n * @param {string} filename - Exact owned path.\n * @param {string} projectId - Project identity.\n * @param {string} subject - Stable subject description.\n * @returns {Promise<import(\"node:fs\").Stats | null>} Status or absence.\n */\nasync function optionalStatus(filename, projectId, subject) {\n  try {\n    return await lstat(filename)\n  } catch (error) {\n    if (isErrorCode(error, \"ENOENT\")) return null\n    publicationFailure(\"PUBLICATION_RECOVERY_FAILED\", projectId,\n      `Journal-owned ${subject} could not be inspected.`, error)\n  }\n}\n\n/**\n * Validates and snapshots one publication request before staging.\n * @param {unknown} request - Request candidate.\n * @param {string} projectId - Project diagnostic identity.\n * @returns {{generationId: string, targets: readonly ValidatedPublicationTarget[]}} Validated request.\n */\nfunction validatePublicationRequest(request, projectId) {\n  if (!isPlainObject(request)) {\n    publicationFailure(\"INVALID_PUBLICATION_REQUEST\", projectId,\n      \"Publication requires a unique generation ID and a non-empty ordered target array.\")\n  }\n  const generationId = request.generationId\n  const requestedTargets = request.targets\n\n  if (typeof generationId != \"string\" || !generationPattern.test(generationId) ||\n    !isDenseArray(requestedTargets) || requestedTargets.length == 0) {\n    publicationFailure(\"INVALID_PUBLICATION_REQUEST\", projectId,\n      \"Publication requires a unique generation ID and a non-empty ordered target array.\")\n  }\n  /** @type {ValidatedPublicationTarget[]} */\n  const targets = []\n  const targetIds = new Set()\n  /** @type {string[]} */\n  const projections = []\n  /** @type {string[]} */\n  const completeArtifactPaths = []\n\n  for (let index = 0; index < requestedTargets.length; index += 1) {\n    const target = requestedTargets[index]\n\n    if (!isPlainObject(target)) {\n      publicationFailure(\"INVALID_PUBLICATION_REQUEST\", projectId,\n        `Target ${index} requires a stable lowercase identity.`)\n    }\n    const targetId = target.id\n    const role = target.role\n    const sourceProjection = target.sourceProjection\n    const buildProjection = target.buildProjection\n    const artifactSetCandidate = target.artifactSet\n    const validatorsCandidate = target.validators\n\n    if (typeof targetId != \"string\" || !identityPattern.test(targetId)) {\n      publicationFailure(\"INVALID_PUBLICATION_REQUEST\", projectId,\n        `Target ${index} requires a stable lowercase identity.`)\n    }\n    if (typeof role != \"string\" || !targetRoles.has(role)) {\n      publicationFailure(\"INVALID_PUBLICATION_REQUEST\", projectId,\n        `Target '${targetId}' requires an explicit language-neutral role.`)\n    }\n\n    if (targetIds.has(targetId)) {\n      publicationFailure(\"PUBLICATION_PATH_COLLISION\", projectId, `Duplicate target identity '${targetId}'.`)\n    }\n    targetIds.add(targetId)\n    if (!isSafeArtifactPath(sourceProjection) || !isSafeArtifactPath(buildProjection)) {\n      publicationFailure(\"INVALID_PUBLICATION_PROJECTION\", projectId,\n        `Target '${targetId}' requires canonical relative source and build projections.`)\n    }\n    projections.push(sourceProjection, buildProjection)\n    let artifactSet\n\n    try {\n      artifactSet = createGeneratedArtifactSet(artifactSetCandidate)\n    } catch (error) {\n      publicationFailure(\"INVALID_PUBLICATION_REQUEST\", projectId,\n        `Target '${targetId}' does not contain a valid generated artifact set.`, error)\n    }\n    const validators = validatorsCandidate === undefined ? [] : validatorsCandidate\n\n    if (!isDenseArray(validators)) {\n      publicationFailure(\"INVALID_PUBLICATION_REQUEST\", projectId,\n        `Target '${targetId}' validators must be a dense function array.`)\n    }\n    /** @type {import(\"./semantic/types.js\").PublicationValidator[]} */\n    const validatedValidators = []\n\n    for (let validatorIndex = 0; validatorIndex < validators.length; validatorIndex += 1) {\n      const validator = validators[validatorIndex]\n\n      if (typeof validator != \"function\") {\n        publicationFailure(\"INVALID_PUBLICATION_REQUEST\", projectId,\n          `Target '${targetId}' validators must be a dense function array.`)\n      }\n      validatedValidators.push(/** @type {import(\"./semantic/types.js\").PublicationValidator} */ (validator))\n    }\n    const artifactConflict = findPortableArtifactPathConflict(artifactSet.artifacts.map(({path: artifactPath}) => artifactPath))\n\n    if (artifactConflict) {\n      publicationFailure(\"PUBLICATION_PATH_COLLISION\", projectId,\n        `Target '${targetId}' artifact paths have a portable ${artifactConflict.kind} conflict.`)\n    }\n    for (const artifact of artifactSet.artifacts) {\n      completeArtifactPaths.push(`${sourceProjection}/${artifact.path}`)\n    }\n    targets.push(Object.freeze({\n      artifactSet,\n      buildProjection,\n      id: targetId,\n      role: /** @type {import(\"./semantic/types.js\").PublicationTargetRole} */ (role),\n      sourceProjection,\n      validators: Object.freeze(validatedValidators)\n    }))\n  }\n  const projectionConflict = findPortableArtifactPathConflict(projections)\n\n  if (projectionConflict) {\n    publicationFailure(\"PUBLICATION_PROJECTION_OVERLAP\", projectId,\n      \"Target source/build projections must be distinct and non-nested under portable comparison.\")\n  }\n  if (findPortableArtifactPathConflict([...projections, \"manifest.json\"])) {\n    publicationFailure(\"INVALID_PUBLICATION_PROJECTION\", projectId,\n      \"Target source/build projections must not overlap the generation manifest path.\")\n  }\n  const artifactConflict = findPortableArtifactPathConflict(completeArtifactPaths)\n\n  if (artifactConflict) {\n    publicationFailure(\"PUBLICATION_PATH_COLLISION\", projectId,\n      \"Projected artifact paths collide under portable comparison.\")\n  }\n\n  return {generationId, targets: Object.freeze(targets)}\n}\n\n/**\n * Stages one validated target and invokes its ordered validators.\n * @param {string} generationPath - Candidate generation path.\n * @param {ValidatedPublicationTarget} target - Validated target.\n * @param {string} projectId - Project diagnostic identity.\n * @returns {Promise<import(\"./semantic/types.js\").GenerationTargetManifest>} Target manifest.\n */\nasync function stageTarget(generationPath, target, projectId) {\n  const sourcePath = ownedPath(generationPath, target.sourceProjection, projectId)\n  const buildPath = ownedPath(generationPath, target.buildProjection, projectId)\n\n  await mkdir(sourcePath, {mode: 0o700, recursive: true})\n  await mkdir(buildPath, {mode: 0o700, recursive: true})\n  /** @type {import(\"./semantic/types.js\").GenerationArtifactManifest[]} */\n  const artifacts = []\n\n  for (const artifact of target.artifactSet.artifacts) {\n    const filename = ownedPath(sourcePath, artifact.path, projectId)\n    const bytes = artifact.contentKind == \"text\"\n      ? Buffer.from(/** @type {string} */ (artifact.content), \"utf8\")\n      : Buffer.from(/** @type {Uint8Array} */ (artifact.content))\n\n    await mkdir(path.dirname(filename), {mode: 0o700, recursive: true})\n    try {\n      await writeSyncedFile(filename, bytes, \"wx\")\n    } catch (error) {\n      if (error instanceof SemantifoldDiagnostic) throw error\n      publicationFailure(\"PUBLICATION_STAGE_WRITE_FAILED\", projectId,\n        `Generated artifact '${artifact.path}' could not be staged.`, error)\n    }\n    artifacts.push(Object.freeze({\n      byteLength: bytes.byteLength,\n      contentKind: artifact.contentKind,\n      hash: Object.freeze({algorithm: /** @type {const} */ (\"sha256\"), value: sha256(bytes)}),\n      mediaType: artifact.mediaType,\n      path: artifact.path,\n      provenance: artifact.provenance,\n      role: artifact.role\n    }))\n  }\n\n  /** @type {import(\"./semantic/types.js\").PublicationBuildArtifactInput[]} */\n  const buildDescriptors = []\n  const context = Object.freeze({buildPath, sourcePath, targetId: target.id})\n\n  for (let index = 0; index < target.validators.length; index += 1) {\n    let produced\n\n    try {\n      produced = await target.validators[index](context)\n    } catch (error) {\n      publicationFailure(\"PUBLICATION_VALIDATION_FAILED\", projectId,\n        `Validator ${index} failed for target '${target.id}'.`, error)\n    }\n    if (produced === undefined) continue\n    if (!isDenseArray(produced)) {\n      publicationFailure(\"PUBLICATION_VALIDATION_FAILED\", projectId,\n        `Validator ${index} returned invalid build-artifact metadata for target '${target.id}'.`)\n    }\n    for (const descriptor of produced) {\n      buildDescriptors.push(validateBuildArtifactDescriptor(descriptor, target.id, projectId))\n    }\n  }\n\n  const descriptorConflict = findPortableArtifactPathConflict(buildDescriptors.map(({path: artifactPath}) => artifactPath))\n\n  if (descriptorConflict) {\n    publicationFailure(\"PUBLICATION_PATH_COLLISION\", projectId,\n      `Target '${target.id}' build artifacts have a portable ${descriptorConflict.kind} conflict.`)\n  }\n  const stagedBuildFiles = await listRegularFiles(buildPath, projectId)\n  const declared = new Set(buildDescriptors.map(({path: artifactPath}) => artifactPath))\n\n  if (stagedBuildFiles.length != declared.size || stagedBuildFiles.some(filename => !declared.has(filename))) {\n    publicationFailure(\"PUBLICATION_VALIDATION_FAILED\", projectId,\n      `Target '${target.id}' validators must declare every staged build artifact exactly once.`)\n  }\n  /** @type {import(\"./semantic/types.js\").GenerationBuildArtifactManifest[]} */\n  const finalizedBuildArtifacts = []\n\n  for (const descriptor of buildDescriptors) {\n    const bytes = await readAndSyncRegularFile(ownedPath(buildPath, descriptor.path, projectId), projectId,\n      \"PUBLICATION_STAGE_HASH_MISMATCH\", `Build artifact '${descriptor.path}' is not a stable regular file.`)\n\n    finalizedBuildArtifacts.push(Object.freeze({\n      byteLength: bytes.byteLength,\n      hash: Object.freeze({algorithm: /** @type {const} */ (\"sha256\"), value: sha256(bytes)}),\n      mediaType: descriptor.mediaType,\n      path: descriptor.path,\n      role: descriptor.role\n    }))\n  }\n\n  return Object.freeze({\n    artifacts: Object.freeze(artifacts),\n    buildArtifacts: Object.freeze(finalizedBuildArtifacts),\n    id: target.id,\n    ...(target.artifactSet.metadata === undefined ? {} : {metadata: target.artifactSet.metadata}),\n    projections: Object.freeze({build: target.buildProjection, source: target.sourceProjection}),\n    role: target.role,\n    target: target.artifactSet.target\n  })\n}\n\n/**\n * Validates validator/compiler output metadata.\n * @param {unknown} descriptor - Metadata candidate.\n * @param {string} targetId - Target identity.\n * @param {string} projectId - Project diagnostic identity.\n * @returns {import(\"./semantic/types.js\").PublicationBuildArtifactInput} Validated metadata.\n */\nfunction validateBuildArtifactDescriptor(descriptor, targetId, projectId) {\n  if (!isPlainObject(descriptor) || !hasExactKeys(descriptor, [\"mediaType\", \"path\", \"role\"])) {\n    publicationFailure(\"PUBLICATION_VALIDATION_FAILED\", projectId,\n      `Target '${targetId}' validator returned invalid build-artifact metadata.`)\n  }\n  const descriptorPath = descriptor.path\n  const mediaType = descriptor.mediaType\n  const role = descriptor.role\n\n  if (!isSafeArtifactPath(descriptorPath) || typeof mediaType != \"string\" ||\n    !mediaTypePattern.test(mediaType) || /[\\r\\n]/u.test(mediaType) ||\n    typeof role != \"string\" || !buildRolePattern.test(role)) {\n    publicationFailure(\"PUBLICATION_VALIDATION_FAILED\", projectId,\n      `Target '${targetId}' validator returned invalid build-artifact metadata.`)\n  }\n\n  return Object.freeze({mediaType, path: descriptorPath, role})\n}\n\n/**\n * Verifies every manifest reference and staged byte before pointer reachability.\n * @param {string} generationPath - Candidate generation path.\n * @param {import(\"./semantic/types.js\").GenerationManifest} manifest - Candidate manifest.\n * @param {string} projectId - Project diagnostic identity.\n * @returns {Promise<void>} Completion.\n */\nasync function verifyManifestFiles(generationPath, manifest, projectId) {\n  for (const target of manifest.targets) {\n    const sourcePath = ownedPath(generationPath, target.projections.source, projectId)\n    const buildPath = ownedPath(generationPath, target.projections.build, projectId)\n    const sourceFiles = await listRegularFiles(sourcePath, projectId)\n\n    if (sourceFiles.length != target.artifacts.length ||\n      sourceFiles.some(filename => !target.artifacts.some(artifact => artifact.path == filename))) {\n      publicationFailure(\"PUBLICATION_STAGE_HASH_MISMATCH\", projectId,\n        `Target '${target.id}' generated-source files do not match its manifest.`)\n    }\n    for (const artifact of target.artifacts) {\n      await verifyManifestFile(sourcePath, artifact, projectId)\n    }\n    const buildFiles = await listRegularFiles(buildPath, projectId)\n\n    if (buildFiles.length != target.buildArtifacts.length ||\n      buildFiles.some(filename => !target.buildArtifacts.some(artifact => artifact.path == filename))) {\n      publicationFailure(\"PUBLICATION_STAGE_HASH_MISMATCH\", projectId,\n        `Target '${target.id}' build files do not match its manifest.`)\n    }\n    for (const artifact of target.buildArtifacts) {\n      await verifyManifestFile(buildPath, artifact, projectId)\n    }\n    try {\n      const artifacts = []\n\n      for (const artifact of target.artifacts) {\n        const bytes = await readAndSyncRegularFile(ownedPath(sourcePath, artifact.path, projectId), projectId,\n          \"PUBLICATION_STAGE_HASH_MISMATCH\", `Manifest artifact '${artifact.path}' is not a stable regular file.`)\n        let content\n\n        if (artifact.contentKind == \"text\") {\n          try {\n            content = new TextDecoder(\"utf-8\", {fatal: true}).decode(bytes)\n          } catch (error) {\n            publicationFailure(\"MALFORMED_GENERATION_MANIFEST\", projectId,\n              `Text artifact '${artifact.path}' is not valid UTF-8.`, error)\n          }\n        } else content = new Uint8Array(bytes)\n        artifacts.push({\n          content,\n          contentKind: artifact.contentKind,\n          mediaType: artifact.mediaType,\n          ownership: /** @type {const} */ (\"generated\"),\n          path: artifact.path,\n          provenance: rehydrateProvenance(artifact.provenance, projectId),\n          role: artifact.role\n        })\n      }\n      createGeneratedArtifactSet({\n        artifacts,\n        ...(target.metadata === undefined ? {} : {metadata: target.metadata}),\n        target: target.target\n      })\n    } catch (error) {\n      if (error instanceof SemantifoldDiagnostic && error.code == \"MALFORMED_GENERATION_MANIFEST\") throw error\n      publicationFailure(\"MALFORMED_GENERATION_MANIFEST\", projectId,\n        `Target '${target.id}' artifact provenance does not match its staged bytes.`, error)\n    }\n  }\n  await verifyGenerationInventory(generationPath, manifest, projectId)\n}\n\n/**\n * Restores JSON-omitted optional mapping fields and verifies persisted mapping projections.\n * @param {import(\"./semantic/types.js\").ArtifactProvenance} provenance - Persisted provenance.\n * @param {string} projectId - Project identity.\n * @returns {import(\"./semantic/types.js\").ArtifactProvenance} Canonical provenance.\n */\nfunction rehydrateProvenance(provenance, projectId) {\n  if (provenance.kind == \"text\") {\n    const mapping = finalizeMapping(provenance.mapping)\n    const sourceMap = toSourceMapV3(mapping)\n    const jsonSourceMap = JSON.parse(JSON.stringify(sourceMap))\n\n    if (!sameJsonValue(jsonSourceMap, provenance.sourceMap)) {\n      publicationFailure(\"MALFORMED_GENERATION_MANIFEST\", projectId,\n        \"Persisted Source Map projection contradicts its rich mapping.\")\n    }\n\n    return Object.freeze({\n      kind: /** @type {const} */ (\"text\"),\n      mapping,\n      sourceMap,\n      ...(provenance.sourceMapFilename === undefined ? {} : {sourceMapFilename: provenance.sourceMapFilename})\n    })\n  }\n  if (provenance.kind == \"bytes\") {\n    return Object.freeze({kind: /** @type {const} */ (\"bytes\"), mapping: finalizeByteMapping(provenance.mapping)})\n  }\n\n  return provenance\n}\n\n/**\n * Verifies one referenced file.\n * @param {string} projectionPath - Owning projection path.\n * @param {{byteLength: number, hash: import(\"./semantic/types.js\").GenerationContentHash, path: string}} artifact - Manifest record.\n * @param {string} projectId - Project diagnostic identity.\n * @returns {Promise<Buffer>} Exact verified bytes.\n */\nasync function verifyManifestFile(projectionPath, artifact, projectId) {\n  const bytes = await readAndSyncRegularFile(ownedPath(projectionPath, artifact.path, projectId), projectId,\n    \"PUBLICATION_STAGE_HASH_MISMATCH\", `Manifest artifact '${artifact.path}' is not a stable regular file.`)\n\n  if (bytes.byteLength != artifact.byteLength || sha256(bytes) != artifact.hash.value) {\n    publicationFailure(\"PUBLICATION_STAGE_HASH_MISMATCH\", projectId,\n      `Manifest artifact '${artifact.path}' bytes do not match its recorded hash.`)\n  }\n\n  return bytes\n}\n\n/**\n * Validates an existing active pointer before a new candidate is staged.\n * @param {string} publicationRoot - Publication root.\n * @param {string} projectId - Project identity.\n * @returns {Promise<void>} Completion.\n */\nasync function validateExistingPointer(publicationRoot, projectId) {\n  const pointerPath = path.join(publicationRoot, activePointerName)\n  const pointer = await readActivePointer(pointerPath, projectId, true)\n\n  if (pointer) await verifyPublishedGeneration(publicationRoot, projectId, pointer, false)\n}\n\n/**\n * Reads and strictly validates one active pointer.\n * @param {string} pointerPath - Pointer filename.\n * @param {string} projectId - Expected project identity.\n * @param {boolean} optional - Whether absence is allowed.\n * @returns {Promise<ActivePointer | null>} Pointer or absent value.\n */\nasync function readActivePointer(pointerPath, projectId, optional) {\n  let pointerBytes\n\n  try {\n    const status = await lstat(pointerPath)\n\n    if (!status.isFile() || status.isSymbolicLink()) {\n      publicationFailure(\"MALFORMED_ACTIVE_GENERATION\", projectId,\n        \"Active-generation pointer must be a regular file.\")\n    }\n    pointerBytes = await readFile(pointerPath)\n  } catch (error) {\n    if (optional && isErrorCode(error, \"ENOENT\")) return null\n    if (error instanceof SemantifoldDiagnostic) throw error\n    publicationFailure(optional ? \"MALFORMED_ACTIVE_GENERATION\" : \"ACTIVE_GENERATION_MISSING\", projectId,\n      optional ? \"Active-generation pointer could not be read.\" : \"No active generation has been published.\", error)\n  }\n  let value\n\n  try {\n    value = JSON.parse(pointerBytes.toString(\"utf8\"))\n  } catch (error) {\n    publicationFailure(\"MALFORMED_ACTIVE_GENERATION\", projectId,\n      \"Active-generation pointer is not valid JSON.\", error)\n  }\n  if (!isActivePointer(value) || value.projectId != projectId) {\n    publicationFailure(\"MALFORMED_ACTIVE_GENERATION\", projectId,\n      \"Active-generation pointer does not match the versioned project contract.\")\n  }\n\n  return value\n}\n\n/**\n * Verifies a pointer-selected generation without consulting the pointer again.\n * @param {string} publicationRoot - Publication root.\n * @param {string} projectId - Project identity.\n * @param {ActivePointer} pointer - Pointer snapshot.\n * @param {boolean} cleanupPending - Recovery state.\n * @returns {Promise<import(\"./semantic/types.js\").PublishedGeneration>} Verified generation.\n */\nasync function verifyPublishedGeneration(publicationRoot, projectId, pointer, cleanupPending) {\n  const generationPath = ownedPath(path.join(publicationRoot, generationsName), pointer.generationId, projectId)\n  const manifestPath = path.join(generationPath, \"manifest.json\")\n  let manifestBytes\n\n  try {\n    manifestBytes = await readAndSyncRegularFile(manifestPath, projectId, \"MALFORMED_GENERATION_MANIFEST\",\n      \"Generation manifest must be a regular file.\")\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic) throw error\n    publicationFailure(\"MALFORMED_GENERATION_MANIFEST\", projectId,\n      \"Generation manifest could not be read.\", error)\n  }\n  if (sha256(manifestBytes) != pointer.manifestHash) {\n    publicationFailure(\"MALFORMED_GENERATION_MANIFEST\", projectId,\n      \"Generation manifest hash does not match the active pointer.\")\n  }\n  let value\n\n  try {\n    value = JSON.parse(manifestBytes.toString(\"utf8\"))\n  } catch (error) {\n    publicationFailure(\"MALFORMED_GENERATION_MANIFEST\", projectId,\n      \"Generation manifest is not valid JSON.\", error)\n  }\n  const manifest = validateGenerationManifest(value, projectId, pointer.generationId)\n\n  await verifyManifestFiles(generationPath, manifest, projectId)\n\n  return publishedGeneration(publicationRoot, manifest, cleanupPending)\n}\n\n/**\n * Strictly validates a persisted generation manifest.\n * @param {unknown} value - Parsed manifest value.\n * @param {string} projectId - Expected project identity.\n * @param {string} generationId - Expected generation identity.\n * @returns {import(\"./semantic/types.js\").GenerationManifest} Frozen manifest.\n */\nfunction validateGenerationManifest(value, projectId, generationId) {\n  if (!isPlainObject(value) || !hasExactKeys(value, [\"generationId\", \"projectId\", \"schema\", \"targets\", \"version\"]) ||\n    value.schema != \"SemantifoldGenerationManifest\" || value.version != 1 || value.projectId != projectId ||\n    value.generationId != generationId || !isDenseArray(value.targets) || value.targets.length == 0) {\n    publicationFailure(\"MALFORMED_GENERATION_MANIFEST\", projectId,\n      \"Generation manifest does not match the versioned project contract.\")\n  }\n  /** @type {import(\"./semantic/types.js\").GenerationTargetManifest[]} */\n  const targets = []\n  /** @type {string[]} */\n  const projections = []\n  const ids = new Set()\n\n  for (const target of value.targets) {\n    const targetKeys = target && typeof target == \"object\" && \"metadata\" in target\n      ? [\"artifacts\", \"buildArtifacts\", \"id\", \"metadata\", \"projections\", \"role\", \"target\"]\n      : [\"artifacts\", \"buildArtifacts\", \"id\", \"projections\", \"role\", \"target\"]\n\n    if (!isPlainObject(target) || !hasExactKeys(target, targetKeys) ||\n      !identityPattern.test(typeof target.id == \"string\" ? target.id : \"\") || ids.has(target.id) ||\n      typeof target.role != \"string\" || !targetRoles.has(target.role) ||\n      typeof target.target != \"string\" || !identityPattern.test(target.target) ||\n      !isPlainObject(target.projections) || !hasExactKeys(target.projections, [\"build\", \"source\"]) ||\n      !isSafeArtifactPath(target.projections.source) || !isSafeArtifactPath(target.projections.build) ||\n      !isDenseArray(target.artifacts) || target.artifacts.length == 0 || !isDenseArray(target.buildArtifacts)) {\n      publicationFailure(\"MALFORMED_GENERATION_MANIFEST\", projectId,\n        \"Generation manifest contains an invalid target record.\")\n    }\n    const targetId = /** @type {string} */ (target.id)\n\n    ids.add(targetId)\n    projections.push(target.projections.source, target.projections.build)\n    const artifacts = target.artifacts.map(artifact => validatePersistedArtifact(artifact, true, projectId))\n    const buildArtifacts = target.buildArtifacts.map(artifact => validatePersistedArtifact(artifact, false, projectId))\n\n    if (findPortableArtifactPathConflict(artifacts.map(({path: artifactPath}) => artifactPath)) ||\n      findPortableArtifactPathConflict(buildArtifacts.map(({path: artifactPath}) => artifactPath))) {\n      publicationFailure(\"MALFORMED_GENERATION_MANIFEST\", projectId,\n        \"Generation manifest contains colliding artifact paths.\")\n    }\n    targets.push(Object.freeze({\n      artifacts: Object.freeze(/** @type {import(\"./semantic/types.js\").GenerationArtifactManifest[]} */ (artifacts)),\n      buildArtifacts: Object.freeze(/** @type {import(\"./semantic/types.js\").GenerationBuildArtifactManifest[]} */ (buildArtifacts)),\n      id: targetId,\n      ...(target.metadata === undefined ? {} : {metadata: deepFreeze(/** @type {Record<string, unknown>} */ (target.metadata))}),\n      projections: Object.freeze({build: target.projections.build, source: target.projections.source}),\n      role: /** @type {import(\"./semantic/types.js\").PublicationTargetRole} */ (target.role),\n      target: target.target\n    }))\n  }\n  if (findPortableArtifactPathConflict(projections) ||\n    findPortableArtifactPathConflict([...projections, \"manifest.json\"])) {\n    publicationFailure(\"MALFORMED_GENERATION_MANIFEST\", projectId,\n      \"Generation manifest contains overlapping projections.\")\n  }\n\n  return Object.freeze({\n    generationId,\n    projectId,\n    schema: /** @type {const} */ (\"SemantifoldGenerationManifest\"),\n    targets: Object.freeze(targets),\n    version: /** @type {const} */ (1)\n  })\n}\n\n/**\n * Validates one persisted artifact record.\n * @param {unknown} value - Record candidate.\n * @param {boolean} generated - Whether this is a generated-source artifact.\n * @param {string} projectId - Project identity.\n * @returns {import(\"./semantic/types.js\").GenerationArtifactManifest | import(\"./semantic/types.js\").GenerationBuildArtifactManifest} Frozen record.\n */\nfunction validatePersistedArtifact(value, generated, projectId) {\n  const keys = generated\n    ? [\"byteLength\", \"contentKind\", \"hash\", \"mediaType\", \"path\", \"provenance\", \"role\"]\n    : [\"byteLength\", \"hash\", \"mediaType\", \"path\", \"role\"]\n\n  if (!isPlainObject(value) || !hasExactKeys(value, keys) || !isSafeArtifactPath(value.path) ||\n    typeof value.byteLength != \"number\" || !Number.isSafeInteger(value.byteLength) || value.byteLength < 0 || typeof value.mediaType != \"string\" ||\n    !mediaTypePattern.test(value.mediaType) || typeof value.role != \"string\" ||\n    !(generated ? [\"entry\", \"source\", \"manifest\", \"support\", \"mapping\", \"resource\", \"loader\"].includes(value.role) :\n      buildRolePattern.test(value.role)) ||\n    (generated && value.contentKind != \"text\" && value.contentKind != \"binary\") ||\n    (generated && !isPlainObject(value.provenance)) ||\n    !isPlainObject(value.hash) || !hasExactKeys(value.hash, [\"algorithm\", \"value\"]) || value.hash.algorithm != \"sha256\" ||\n    typeof value.hash.value != \"string\" || !/^[a-f0-9]{64}$/u.test(value.hash.value)) {\n    publicationFailure(\"MALFORMED_GENERATION_MANIFEST\", projectId,\n      \"Generation manifest contains an invalid artifact record.\")\n  }\n\n  return Object.freeze(/** @type {import(\"./semantic/types.js\").GenerationArtifactManifest | import(\"./semantic/types.js\").GenerationBuildArtifactManifest} */ ({\n    byteLength: value.byteLength,\n    ...(generated ? {contentKind: value.contentKind} : {}),\n    hash: Object.freeze({algorithm: /** @type {const} */ (\"sha256\"), value: value.hash.value}),\n    mediaType: value.mediaType,\n    path: value.path,\n    ...(generated ? {provenance: deepFreeze(/** @type {import(\"./semantic/types.js\").ArtifactProvenance} */ (value.provenance))} : {}),\n    role: value.role\n  }))\n}\n\n/**\n * Constructs a frozen resolved-generation result.\n * @param {string} publicationRoot - Publication root.\n * @param {import(\"./semantic/types.js\").GenerationManifest} manifest - Verified manifest.\n * @param {boolean} cleanupPending - Whether cleanup remains.\n * @returns {import(\"./semantic/types.js\").PublishedGeneration} Frozen result.\n */\nfunction publishedGeneration(publicationRoot, manifest, cleanupPending) {\n  const generationPath = path.join(publicationRoot, generationsName, manifest.generationId)\n  const targets = manifest.targets.map(target => Object.freeze({\n    buildPath: path.join(generationPath, target.projections.build),\n    id: target.id,\n    role: target.role,\n    sourcePath: path.join(generationPath, target.projections.source)\n  }))\n\n  return Object.freeze({\n    cleanupPending,\n    generationId: manifest.generationId,\n    generationPath,\n    manifest,\n    manifestPath: path.join(generationPath, \"manifest.json\"),\n    targets: Object.freeze(targets)\n  })\n}\n\n/**\n * Probes the exact same-directory regular-file replacement primitive used by the active pointer.\n * @param {string} publicationRoot - Publication root.\n * @param {string} projectId - Project identity.\n * @returns {Promise<void>} Completion.\n */\nasync function verifyAtomicReplacement(publicationRoot, projectId) {\n  const identity = randomUUID()\n  const source = path.join(publicationRoot, `.semantifold-atomic-${identity}.source`)\n  const destination = path.join(publicationRoot, `.semantifold-atomic-${identity}.destination`)\n  const expected = Buffer.from(\"candidate\\n\")\n  let sourceCreated = false\n  let destinationCreated = false\n\n  try {\n    await writeSyncedFile(source, Buffer.from(\"candidate\\n\"), \"wx\")\n    sourceCreated = true\n    await writeSyncedFile(destination, Buffer.from(\"previous\\n\"), \"wx\")\n    destinationCreated = true\n    await rename(source, destination)\n    sourceCreated = false\n    await syncDirectory(publicationRoot)\n    const destinationStatus = await lstat(destination)\n    const replaced = await readFile(destination)\n\n    if (!destinationStatus.isFile() || destinationStatus.isSymbolicLink() || !replaced.equals(expected)) {\n      publicationFailure(\"PUBLICATION_ATOMIC_REPLACE_UNSUPPORTED\", projectId,\n        \"Filesystem did not provide same-directory regular-file replacement.\")\n    }\n    try {\n      await lstat(source)\n      publicationFailure(\"PUBLICATION_ATOMIC_REPLACE_UNSUPPORTED\", projectId,\n        \"Filesystem did not remove the replaced temporary name atomically.\")\n    } catch (error) {\n      if (!isErrorCode(error, \"ENOENT\")) throw error\n    }\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic) throw error\n    publicationFailure(\"PUBLICATION_ATOMIC_REPLACE_UNSUPPORTED\", projectId,\n      \"Filesystem did not provide same-directory regular-file replacement.\", error)\n  } finally {\n    await Promise.allSettled([\n      ...(sourceCreated ? [rm(source, {force: true})] : []),\n      ...(destinationCreated ? [rm(destination, {force: true})] : [])\n    ])\n  }\n}\n\n/**\n * Writes and synchronizes one newly owned file.\n * @param {string} filename - Exact filename.\n * @param {Uint8Array} bytes - Exact bytes.\n * @param {\"wx\"} flag - Exclusive creation mode.\n * @param {() => void} [onCreated] - Called immediately after exclusive creation succeeds.\n * @returns {Promise<void>} Completion.\n */\nasync function writeSyncedFile(filename, bytes, flag, onCreated) {\n  const handle = await open(filename, flag, 0o600)\n\n  onCreated?.()\n  /** @type {unknown} */\n  let failure\n\n  try {\n    await handle.writeFile(bytes)\n    await handle.sync()\n  } catch (error) {\n    failure = error\n  } finally {\n    try {\n      await handle.close()\n    } catch (error) {\n      if (failure === undefined) failure = error\n    }\n  }\n  if (failure !== undefined) {\n    await rm(filename, {force: true}).catch(() => {})\n    throw failure\n  }\n}\n\n/**\n * Reads and synchronizes one regular non-symlink file.\n * @param {string} filename - Exact filename.\n * @param {string} projectId - Project identity.\n * @param {string} code - Failure code.\n * @param {string} message - Stable failure detail.\n * @returns {Promise<Buffer>} Exact bytes.\n */\nasync function readAndSyncRegularFile(filename, projectId, code, message) {\n  try {\n    const status = await lstat(filename)\n\n    if (!status.isFile() || status.isSymbolicLink()) publicationFailure(code, projectId, message)\n    assertRegularFileImmutability(status, new Set(), projectId)\n    const handle = await open(filename, constants.O_RDONLY)\n\n    try {\n      const bytes = await handle.readFile()\n\n      await handle.sync()\n\n      return bytes\n    } finally {\n      await handle.close()\n    }\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic) throw error\n    publicationFailure(code, projectId, message, error)\n  }\n}\n\n/**\n * Lists every regular file beneath one projection and rejects symlinks or special nodes.\n * @param {string} directory - Projection root.\n * @param {string} projectId - Project identity.\n * @returns {Promise<string[]>} Sorted relative POSIX paths.\n */\nasync function listRegularFiles(directory, projectId) {\n  /** @type {string[]} */\n  const files = []\n  const identities = new Set()\n\n  try {\n    await visit(directory, \"\")\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic) throw error\n    publicationFailure(\"PUBLICATION_GENERATION_VERIFICATION_FAILED\", projectId,\n      \"Immutable generation filesystem inventory could not be verified.\", error)\n  }\n\n  return files.sort(compareStrings)\n\n  /**\n   * Visits one owned directory.\n   * @param {string} current - Exact directory.\n   * @param {string} relative - Projection-relative path.\n   * @returns {Promise<void>} Completion.\n   */\n  async function visit(current, relative) {\n    await assertRealInventoryDirectory(current, projectId)\n    const entries = await readdir(current)\n\n    entries.sort(compareStrings)\n    for (const entry of entries) {\n      const childRelative = relative.length == 0 ? entry : `${relative}/${entry}`\n\n      if (!isSafeArtifactPath(childRelative)) {\n        publicationFailure(\"INVALID_PUBLICATION_PROJECTION\", projectId,\n          \"Validator output contains a non-canonical relative path.\")\n      }\n      const child = path.join(current, entry)\n      const status = await lstat(child)\n\n      if (status.isSymbolicLink()) {\n        publicationFailure(\"PUBLICATION_SYMLINK_TRAVERSAL\", projectId,\n          \"Candidate generation contains a symbolic link.\")\n      }\n      if (status.isDirectory()) await visit(child, childRelative)\n      else if (status.isFile()) {\n        assertRegularFileImmutability(status, identities, projectId)\n        files.push(childRelative)\n      } else publicationFailure(\"PUBLICATION_GENERATION_INVENTORY_MISMATCH\", projectId,\n        \"Immutable generation contains an undeclared filesystem entry.\")\n    }\n  }\n}\n\n/**\n * Verifies that the manifest describes every directory and regular file in the immutable generation.\n * @param {string} generationPath - Exact generation root.\n * @param {import(\"./semantic/types.js\").GenerationManifest} manifest - Verified manifest.\n * @param {string} projectId - Project identity.\n * @returns {Promise<void>} Completion.\n */\nasync function verifyGenerationInventory(generationPath, manifest, projectId) {\n  const expectedFiles = new Set([\"manifest.json\"])\n  const expectedDirectories = new Set()\n\n  for (const target of manifest.targets) {\n    addExpectedDirectory(target.projections.source)\n    addExpectedDirectory(target.projections.build)\n    for (const artifact of target.artifacts) {\n      addExpectedFile(`${target.projections.source}/${artifact.path}`)\n    }\n    for (const artifact of target.buildArtifacts) {\n      addExpectedFile(`${target.projections.build}/${artifact.path}`)\n    }\n  }\n  /** @type {Set<string>} */\n  const observedFiles = new Set()\n  /** @type {Set<string>} */\n  const observedDirectories = new Set()\n  const identities = new Set()\n\n  try {\n    await visit(generationPath, \"\")\n  } catch (error) {\n    if (error instanceof SemantifoldDiagnostic) throw error\n    publicationFailure(\"PUBLICATION_GENERATION_VERIFICATION_FAILED\", projectId,\n      \"Immutable generation filesystem inventory could not be verified.\", error)\n  }\n  if (!sameStringSet(expectedFiles, observedFiles) || !sameStringSet(expectedDirectories, observedDirectories)) {\n    publicationFailure(\"PUBLICATION_GENERATION_INVENTORY_MISMATCH\", projectId,\n      \"Immutable generation contains an undeclared filesystem entry.\")\n  }\n\n  /**\n   * Adds one expected directory and each generation-relative parent.\n   * @param {string} relative - POSIX-style generation-relative directory.\n   * @returns {void}\n   */\n  function addExpectedDirectory(relative) {\n    const parts = relative.split(\"/\")\n\n    for (let index = 1; index <= parts.length; index += 1) {\n      expectedDirectories.add(parts.slice(0, index).join(\"/\"))\n    }\n  }\n\n  /**\n   * Adds one expected regular file and its parent directories.\n   * @param {string} relative - POSIX-style generation-relative filename.\n   * @returns {void}\n   */\n  function addExpectedFile(relative) {\n    expectedFiles.add(relative)\n    const separator = relative.lastIndexOf(\"/\")\n\n    if (separator >= 0) addExpectedDirectory(relative.slice(0, separator))\n  }\n\n  /**\n   * Visits every entry in one generation directory without following links.\n   * @param {string} current - Exact directory.\n   * @param {string} relative - Generation-relative directory.\n   * @returns {Promise<void>} Completion.\n   */\n  async function visit(current, relative) {\n    await assertRealInventoryDirectory(current, projectId)\n    const entries = await readdir(current)\n\n    entries.sort(compareStrings)\n    for (const entry of entries) {\n      const childRelative = relative.length == 0 ? entry : `${relative}/${entry}`\n\n      if (!isSafeArtifactPath(childRelative)) {\n        publicationFailure(\"PUBLICATION_GENERATION_INVENTORY_MISMATCH\", projectId,\n          \"Immutable generation contains an undeclared filesystem entry.\")\n      }\n      const child = path.join(current, entry)\n      const status = await lstat(child)\n\n      if (status.isSymbolicLink()) {\n        publicationFailure(\"PUBLICATION_SYMLINK_TRAVERSAL\", projectId,\n          \"Candidate generation contains a symbolic link.\")\n      }\n      if (status.isDirectory()) {\n        observedDirectories.add(childRelative)\n        await visit(child, childRelative)\n      } else if (status.isFile()) {\n        assertRegularFileImmutability(status, identities, projectId)\n        observedFiles.add(childRelative)\n      } else {\n        publicationFailure(\"PUBLICATION_GENERATION_INVENTORY_MISMATCH\", projectId,\n          \"Immutable generation contains an undeclared filesystem entry.\")\n      }\n    }\n  }\n}\n\n/**\n * Verifies one inventory traversal root without following symbolic links.\n * @param {string} directory - Exact directory about to be read.\n * @param {string} projectId - Project identity.\n * @returns {Promise<void>} Completion.\n */\nasync function assertRealInventoryDirectory(directory, projectId) {\n  const status = await lstat(directory)\n\n  if (status.isSymbolicLink()) {\n    publicationFailure(\"PUBLICATION_SYMLINK_TRAVERSAL\", projectId,\n      \"Candidate generation contains a symbolic link.\")\n  }\n  if (!status.isDirectory()) {\n    publicationFailure(\"PUBLICATION_GENERATION_INVENTORY_MISMATCH\", projectId,\n      \"Immutable generation contains an undeclared filesystem entry.\")\n  }\n}\n\n/**\n * Rejects external hard links and duplicate stable file identities.\n * @param {import(\"node:fs\").Stats} status - Regular-file status.\n * @param {Set<string>} identities - Previously observed device/inode identities.\n * @param {string} projectId - Project identity.\n * @returns {void}\n */\nfunction assertRegularFileImmutability(status, identities, projectId) {\n  if (status.nlink > 1) {\n    publicationFailure(\"PUBLICATION_HARD_LINK\", projectId,\n      \"Immutable generation files must not have external hard links.\")\n  }\n  const identity = stableFileIdentity(status)\n\n  if (identity !== null) {\n    if (identities.has(identity)) {\n      publicationFailure(\"PUBLICATION_HARD_LINK\", projectId,\n        \"Immutable generation files must have unique filesystem identities.\")\n    }\n    identities.add(identity)\n  }\n}\n\n/**\n * Returns a stable device/inode identity only where the host reports one.\n * @param {import(\"node:fs\").Stats} status - File status.\n * @returns {string | null} Identity or unavailable.\n */\nfunction stableFileIdentity(status) {\n  if ((typeof status.dev != \"number\" && typeof status.dev != \"bigint\") ||\n    (typeof status.ino != \"number\" && typeof status.ino != \"bigint\") || status.ino == 0) return null\n\n  return `${String(status.dev)}:${String(status.ino)}`\n}\n\n/**\n * Compares two string sets exactly.\n * @param {Set<string>} left - First set.\n * @param {Set<string>} right - Second set.\n * @returns {boolean} Equality.\n */\nfunction sameStringSet(left, right) {\n  return left.size == right.size && [...left].every(value => right.has(value))\n}\n\n/**\n * Synchronizes every directory in a staged tree from leaves to root.\n * @param {string} root - Tree root.\n * @returns {Promise<void>} Completion.\n */\nasync function syncTreeDirectories(root) {\n  const entries = await readdir(root, {withFileTypes: true})\n\n  for (const entry of entries) {\n    if (entry.isDirectory() && !entry.isSymbolicLink()) await syncTreeDirectories(path.join(root, entry.name))\n  }\n  await syncDirectory(root)\n}\n\n/**\n * Synchronizes one directory entry set.\n * @param {string} directory - Directory path.\n * @returns {Promise<void>} Completion.\n */\nasync function syncDirectory(directory) {\n  const handle = await open(directory, constants.O_RDONLY)\n\n  try {\n    await handle.sync()\n  } finally {\n    await handle.close()\n  }\n}\n\n/**\n * Ensures every existing path component is a real directory and optionally creates missing components.\n * @param {string} directory - Canonical absolute directory.\n * @param {boolean} create - Whether missing components may be created.\n * @param {string} projectId - Project identity.\n * @returns {Promise<void>} Completion.\n */\nasync function ensureDirectoryWithoutSymlinks(directory, create, projectId) {\n  const parsed = path.parse(directory)\n  const relative = directory.slice(parsed.root.length)\n  const parts = relative.split(path.sep).filter(Boolean)\n  let current = parsed.root\n\n  for (const part of parts) {\n    current = path.join(current, part)\n    try {\n      const status = await lstat(current)\n\n      if (status.isSymbolicLink()) {\n        publicationFailure(\"PUBLICATION_SYMLINK_TRAVERSAL\", projectId,\n          \"Owned path traversal encountered a symbolic link.\")\n      }\n      if (!status.isDirectory()) {\n        publicationFailure(\"INVALID_PUBLICATION_ROOT\", projectId,\n          \"Owned root path contains a non-directory component.\")\n      }\n    } catch (error) {\n      if (!isErrorCode(error, \"ENOENT\")) {\n        if (error instanceof SemantifoldDiagnostic) throw error\n        publicationFailure(\"INVALID_PUBLICATION_ROOT\", projectId,\n          \"Owned root path could not be validated.\", error)\n      }\n      if (!create) {\n        publicationFailure(\"INVALID_PUBLICATION_ROOT\", projectId,\n          \"Source root must exist as a real directory.\", error)\n      }\n      try {\n        await mkdir(current, {mode: 0o700})\n      } catch (mkdirError) {\n        publicationFailure(\"INVALID_PUBLICATION_ROOT\", projectId,\n          \"Publication root could not be created safely.\", mkdirError)\n      }\n    }\n  }\n}\n\n/**\n * Ensures one reserved publisher directory is neither a symlink nor an unowned file.\n * @param {string} directory - Reserved directory.\n * @param {string} projectId - Project identity.\n * @returns {Promise<void>} Completion.\n */\nasync function ensureOwnedDirectory(directory, projectId) {\n  try {\n    await mkdir(directory, {mode: 0o700})\n  } catch (error) {\n    if (!isErrorCode(error, \"EEXIST\")) {\n      publicationFailure(\"PUBLICATION_STAGE_WRITE_FAILED\", projectId,\n        \"Publisher-owned directory could not be created.\", error)\n    }\n  }\n  let status\n\n  try {\n    status = await lstat(directory)\n  } catch (error) {\n    publicationFailure(\"PUBLICATION_STAGE_WRITE_FAILED\", projectId,\n      \"Reserved publisher path could not be inspected.\", error)\n  }\n\n  if (!status.isDirectory() || status.isSymbolicLink()) {\n    publicationFailure(status.isSymbolicLink() ? \"PUBLICATION_SYMLINK_TRAVERSAL\" : \"PUBLICATION_UNOWNED_CONFLICT\",\n      projectId, \"Reserved publisher path is not an owned real directory.\")\n  }\n}\n\n/**\n * Ensures an owned path has no pre-existing entry.\n * @param {string} filename - Exact path.\n * @param {string} code - Diagnostic code.\n * @param {string} projectId - Project identity.\n * @param {string} message - Stable failure detail.\n * @returns {Promise<void>} Completion.\n */\nasync function assertAbsent(filename, code, projectId, message) {\n  try {\n    await lstat(filename)\n    publicationFailure(code, projectId, message)\n  } catch (error) {\n    if (isErrorCode(error, \"ENOENT\")) return\n    if (error instanceof SemantifoldDiagnostic) throw error\n    publicationFailure(code, projectId, message, error)\n  }\n}\n\n/**\n * Resolves a validated relative path under an owned root and rejects escape.\n * @param {string} root - Owned root.\n * @param {string} relative - Validated relative POSIX path.\n * @param {string} projectId - Project identity.\n * @returns {string} Exact owned path.\n */\nfunction ownedPath(root, relative, projectId) {\n  const resolved = path.resolve(root, ...relative.split(\"/\"))\n  const child = path.relative(root, resolved)\n\n  if (child.length == 0 || child == \"..\" || child.startsWith(`..${path.sep}`) || path.isAbsolute(child)) {\n    publicationFailure(\"PUBLICATION_PATH_ESCAPE\", projectId,\n      \"Resolved publication path escaped its owned root.\")\n  }\n\n  return resolved\n}\n\n/**\n * Checks a canonical non-root absolute path without filesystem access.\n * @param {unknown} value - Path candidate.\n * @returns {value is string} Whether the path is canonical.\n */\nfunction isCanonicalAbsolutePath(value) {\n  return isCanonicalAbsolutePathForPath(value, path)\n}\n\n/**\n * Checks one absolute path using the supplied host path semantics.\n * This helper is intentionally not part of the package root API.\n * @param {unknown} value - Path candidate.\n * @param {typeof path.posix | typeof path.win32} hostPath - Host-native path implementation.\n * @returns {value is string} Whether the path is canonical for that host.\n */\nexport function isCanonicalAbsolutePathForPath(value, hostPath) {\n  const separatorAlias = hostPath.sep == \"/\" ? \"\\\\\" : \"/\"\n\n  return typeof value == \"string\" && value.length > 0 && !value.includes(\"\\0\") && !value.includes(separatorAlias) &&\n    hostPath.isAbsolute(value) && value != hostPath.parse(value).root && hostPath.normalize(value) == value &&\n    hostPath.resolve(value) == value\n}\n\n/**\n * Checks conservative portable overlap between absolute paths.\n * @param {string} left - First path.\n * @param {string} right - Second path.\n * @returns {boolean} Whether either contains the other.\n */\nfunction pathsOverlap(left, right) {\n  const leftKey = left.toLowerCase()\n  const rightKey = right.toLowerCase()\n\n  return leftKey == rightKey || leftKey.startsWith(`${rightKey}${path.sep}`) || rightKey.startsWith(`${leftKey}${path.sep}`)\n}\n\n/**\n * Checks whether a path is equal to or nested beneath one canonical root.\n * @param {string} root - Canonical root.\n * @param {string} candidate - Canonical candidate.\n * @returns {boolean} Whether the candidate is within the root.\n */\nfunction isPathWithin(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 * Checks whether a path is strictly nested beneath one canonical root.\n * @param {string} root - Canonical root.\n * @param {string} candidate - Canonical candidate.\n * @returns {boolean} Whether the candidate is a strict descendant.\n */\nfunction isStrictPathDescendant(root, candidate) {\n  return isPathWithin(root, candidate) && path.relative(root, candidate).length > 0\n}\n\n/**\n * Serializes stable generated JSON with one trailing LF.\n * @param {unknown} value - JSON value.\n * @returns {Buffer} UTF-8 bytes.\n */\nfunction serializeJson(value) {\n  return Buffer.from(`${JSON.stringify(value, null, 2)}\\n`, \"utf8\")\n}\n\n/**\n * Hashes exact bytes with SHA-256.\n * @param {Uint8Array} bytes - Exact bytes.\n * @returns {string} Lowercase hexadecimal hash.\n */\nfunction sha256(bytes) {\n  return createHash(\"sha256\").update(bytes).digest(\"hex\")\n}\n\n/**\n * Deeply freezes a parsed JSON value.\n * @template T\n * @param {T} value - JSON value.\n * @returns {T} Frozen value.\n */\nfunction deepFreeze(value) {\n  if (typeof value == \"object\" && value != null) {\n    for (const child of Object.values(value)) deepFreeze(child)\n    Object.freeze(value)\n  }\n\n  return value\n}\n\n/**\n * Compares detached JSON values without depending on object-key order.\n * @param {unknown} left - First JSON value.\n * @param {unknown} right - Second JSON value.\n * @returns {boolean} Whether the values are structurally equal.\n */\nfunction sameJsonValue(left, right) {\n  if (left === right) return true\n  if (Array.isArray(left) || Array.isArray(right)) {\n    return Array.isArray(left) && Array.isArray(right) && left.length == right.length &&\n      left.every((entry, index) => sameJsonValue(entry, right[index]))\n  }\n  if (!isPlainObject(left) || !isPlainObject(right)) return false\n  const leftKeys = Object.keys(left)\n  const rightKeys = Object.keys(right)\n\n  return leftKeys.length == rightKeys.length &&\n    leftKeys.every(key => Object.hasOwn(right, key) && sameJsonValue(left[key], right[key]))\n}\n\n/**\n * Checks an active-pointer value.\n * @param {unknown} value - Parsed value.\n * @returns {value is ActivePointer} Whether the value is strict and versioned.\n */\nfunction isActivePointer(value) {\n  return isPlainObject(value) && hasExactKeys(value, [\"generationId\", \"manifestHash\", \"projectId\", \"schema\", \"version\"]) &&\n    value.schema == \"SemantifoldActiveGeneration\" && value.version == 1 &&\n    typeof value.projectId == \"string\" && identityPattern.test(value.projectId) &&\n    typeof value.generationId == \"string\" && generationPattern.test(value.generationId) &&\n    typeof value.manifestHash == \"string\" && /^[a-f0-9]{64}$/u.test(value.manifestHash)\n}\n\n/**\n * Checks a recovery-journal value.\n * @param {unknown} value - Parsed value.\n * @returns {value is PublicationJournal} Whether the value is strict and versioned.\n */\nfunction isPublicationJournal(value) {\n  return isPlainObject(value) && hasExactKeys(value, [\"generationId\", \"projectId\", \"schema\", \"tempPointer\", \"version\"]) &&\n    value.schema == \"SemantifoldPublicationJournal\" && value.version == 1 &&\n    typeof value.projectId == \"string\" && identityPattern.test(value.projectId) &&\n    typeof value.generationId == \"string\" && generationPattern.test(value.generationId) &&\n    value.tempPointer == `.active-generation.${value.generationId}.tmp`\n}\n\n/**\n * Checks an ordinary object with exactly the expected enumerable string keys.\n * @param {Record<string, unknown>} value - Object candidate.\n * @param {readonly string[]} keys - Sorted expected keys.\n * @returns {boolean} Whether keys match exactly.\n */\nfunction hasExactKeys(value, keys) {\n  const actual = Object.keys(value).sort(compareStrings)\n\n  return actual.length == keys.length && actual.every((key, index) => key == keys[index])\n}\n\n/**\n * Checks for an ordinary string-keyed object.\n * @param {unknown} value - Candidate value.\n * @returns {value is Record<string, unknown>} Whether the value is plain.\n */\nfunction isPlainObject(value) {\n  return typeof value == \"object\" && value != null && !Array.isArray(value) && Object.getPrototypeOf(value) == Object.prototype\n}\n\n/**\n * Checks for a dense ordinary array.\n * @param {unknown} value - Candidate value.\n * @returns {value is unknown[]} Whether the value is dense.\n */\nfunction isDenseArray(value) {\n  if (!Array.isArray(value)) return false\n  const indexedKeys = Object.keys(value).filter(key => /^(?:0|[1-9][0-9]*)$/u.test(key))\n\n  return indexedKeys.length == value.length\n}\n\n/**\n * Compares strings by Unicode code unit.\n * @param {string} left - First string.\n * @param {string} right - Second string.\n * @returns {number} Ordering.\n */\nfunction compareStrings(left, right) {\n  return left < right ? -1 : left > right ? 1 : 0\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 * Throws one stable publication diagnostic without embedding host paths or raw filesystem messages.\n * @param {string} code - Stable diagnostic code.\n * @param {string} projectId - Project identity.\n * @param {string} message - Stable detail.\n * @param {unknown} [error] - Preserved cause.\n * @returns {never} Always throws.\n */\nfunction publicationFailure(code, projectId, message, error) {\n  throw new SemantifoldDiagnostic({\n    cause: error instanceof Error ? error : undefined,\n    code,\n    language: projectId,\n    message\n  })\n}\n\n/**\n * @typedef ValidatedPublicationTarget\n * @property {string} id - Target identity.\n * @property {import(\"./semantic/types.js\").GeneratedArtifactSet} artifactSet - Detached artifact set.\n * @property {string} sourceProjection - Source projection.\n * @property {string} buildProjection - Build projection.\n * @property {import(\"./semantic/types.js\").PublicationTargetRole} role - Language-neutral target role.\n * @property {readonly import(\"./semantic/types.js\").PublicationValidator[]} validators - Ordered validators.\n */\n\n/**\n * @typedef ActivePointer\n * @property {\"SemantifoldActiveGeneration\"} schema - Schema discriminator.\n * @property {1} version - Schema version.\n * @property {string} projectId - Project identity.\n * @property {string} generationId - Generation identity.\n * @property {string} manifestHash - SHA-256 generation-manifest hash.\n */\n\n/**\n * @typedef PublicationJournal\n * @property {\"SemantifoldPublicationJournal\"} schema - Schema discriminator.\n * @property {1} version - Schema version.\n * @property {string} projectId - Project identity.\n * @property {string} generationId - Candidate generation identity.\n * @property {string} tempPointer - Owned sibling temporary-pointer filename.\n */\n"]}