narraeon 0.5.7 → 0.6.1

package/dist/node/runtime/artifact/LegacyArtifactStoreMigration.js

@@ -0,0 +1,260 @@
+import { readdir, readFile, rm, stat, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { ArtifactStoreCorruptionError, artifactSequenceFileName, assertOperation, assertRawRecord, identityHash, isMissing, isNonEmptyString, isRecord, parseArtifactJson, payloadFingerprint, rawRecordFingerprint, writeArtifactJson, } from "./ArtifactStoreFiles.js";
+/** Whether this world still has artifact state in the released layout. */
+export async function hasLegacyArtifactState(dataRoot, worldId) {
+    if (await exists(legacyWorldRoot(dataRoot, worldId)))
+        return true;
+    return ((await exists(forkSnapshotPath(dataRoot, worldId))) &&
+        !(await exists(forkRestoredMarker(dataRoot, worldId))));
+}
+/** Folds one world's released artifact state into `artifacts/`, then deletes the released copies. */
+export async function migrateLegacyArtifactStore(dataRoot, worldId) {
+    if (!(await hasLegacyArtifactState(dataRoot, worldId)))
+        return;
+    const source = await readLegacySource(dataRoot, worldId);
+    const folded = foldLegacy(source);
+    await writeFolded(dataRoot, worldId, folded);
+    await rm(forkSnapshotPath(dataRoot, worldId), { force: true });
+    await rm(forkRestoredMarker(dataRoot, worldId), { force: true });
+    await rm(legacyWorldRoot(dataRoot, worldId), {
+        recursive: true,
+        force: true,
+    });
+    for (const path of source.legacyOperationPaths)
+        await rm(path, { force: true });
+    await removeEmptyLegacyRoot(dataRoot);
+}
+async function readLegacySource(dataRoot, worldId) {
+    const legacyOperationPaths = await legacyOperationPathsFor(dataRoot, worldId);
+    const pending = await readPendingFork(dataRoot, worldId);
+    if (pending !== null)
+        return {
+            records: pending.records,
+            events: pending.events,
+            operations: pending.operations,
+            legacyOperationPaths,
+        };
+    const worldRoot = legacyWorldRoot(dataRoot, worldId);
+    const operations = [];
+    for (const path of legacyOperationPaths)
+        operations.push(parseArtifactJson(await readFile(path, "utf8"), "legacy artifact operation"));
+    return {
+        records: await readJsonDirectory(join(worldRoot, "records"), "legacy artifact raw record"),
+        events: await readJsonDirectory(join(worldRoot, "events"), "legacy artifact projection event"),
+        operations,
+        legacyOperationPaths,
+    };
+}
+async function readPendingFork(dataRoot, worldId) {
+    if (await exists(forkRestoredMarker(dataRoot, worldId)))
+        return null;
+    let bytes;
+    try {
+        bytes = await readFile(forkSnapshotPath(dataRoot, worldId), "utf8");
+    }
+    catch (error) {
+        if (isMissing(error))
+            return null;
+        throw error;
+    }
+    const snapshot = parseArtifactJson(bytes, "legacy artifact fork");
+    if (!isRecord(snapshot) ||
+        snapshot.schemaVersion !== 1 ||
+        snapshot.worldId !== worldId ||
+        !Array.isArray(snapshot.operations) ||
+        !Array.isArray(snapshot.records) ||
+        !Array.isArray(snapshot.events))
+        throw new ArtifactStoreCorruptionError("Artifact fork snapshot is invalid");
+    for (const operation of snapshot.operations) {
+        assertLegacyOperation(operation);
+        if (operation.context.worldId !== worldId)
+            throw new ArtifactStoreCorruptionError("Artifact fork world mismatch");
+    }
+    return snapshot;
+}
+function assertLegacyOperation(operation) {
+    if (operation.status === "core_materialization_pending")
+        throw new ArtifactStoreCorruptionError("Artifact operation awaits a materialization that no longer exists");
+    assertOperation(operation);
+}
+/**
+ * Replays the released event log exactly as the released reader did, then
+ * writes each record's resulting status and head. A record's own fingerprint
+ * must still match its released content, so a damaged source is rejected.
+ */
+function foldLegacy(source) {
+    const operations = new Map(source.operations.map((operation) => {
+        assertLegacyOperation(operation);
+        return [operation.context.operationId, operation];
+    }));
+    const raw = [...source.records].sort((a, b) => a.sequence - b.sequence);
+    const sequences = new Set();
+    const recordIds = new Set();
+    for (const record of raw) {
+        if (record.newHead !== null ||
+            record.status !== "pending" ||
+            record.recordFingerprint !== rawRecordFingerprint(record) ||
+            record.payloadFingerprint !==
+                payloadFingerprint(record.output, record.payload) ||
+            recordIds.has(record.recordId) ||
+            sequences.has(record.sequence) ||
+            !isNonEmptyString(record.recordId))
+            throw new ArtifactStoreCorruptionError("Legacy artifact raw record is corrupt");
+        recordIds.add(record.recordId);
+        sequences.add(record.sequence);
+        const operation = operations.get(record.operationId);
+        if (operation?.context.worldId !== record.worldId ||
+            operation.context.parentHead !== record.parentHead ||
+            operation.context.playPresetId !== record.playPresetId ||
+            operation.context.playPresetRevision !== record.playPresetRevision ||
+            operation.context.playPresetScriptsEnabled !==
+                record.playPresetScriptsEnabled)
+            throw new ArtifactStoreCorruptionError("Legacy artifact raw record does not match the operation identity");
+    }
+    const events = [...source.events].sort((a, b) => a.sequence - b.sequence);
+    for (const event of events) {
+        if (sequences.has(event.sequence))
+            throw new ArtifactStoreCorruptionError("Artifact world sequence is duplicated");
+        sequences.add(event.sequence);
+    }
+    const state = new Map();
+    for (const record of raw)
+        state.set(record.recordId, { status: "pending", head: null });
+    for (const event of events) {
+        const eventOperation = operations.get(event.operationId);
+        if (eventOperation === undefined)
+            throw new ArtifactStoreCorruptionError("Artifact projection-event operation does not exist");
+        if (event.kind === "ignored_call")
+            continue;
+        if (event.kind === "clear") {
+            if (eventOperation.artifactProjectionStatus === "superseded" ||
+                (eventOperation.requestAttempts[event.requestId] !== undefined &&
+                    eventOperation.requestAttempts[event.requestId] !==
+                        event.requestAttempt))
+                continue;
+            for (const record of raw) {
+                const current = state.get(record.recordId);
+                if (current.status !== "superseded" &&
+                    current.status !== "cleared" &&
+                    record.sequence < event.sequence &&
+                    record.channel === event.channel &&
+                    record.output === event.output &&
+                    (event.key === undefined || record.key === event.key))
+                    current.status = "cleared";
+            }
+            continue;
+        }
+        const record = raw.find(({ recordId }) => recordId === event.recordId);
+        if (record?.operationId !== event.operationId)
+            throw new ArtifactStoreCorruptionError("Artifact projection event does not match the record identity");
+        const current = state.get(record.recordId);
+        if (event.kind === "activate") {
+            if (current.status === "pending")
+                current.status = "active";
+        }
+        else if (event.kind === "supersede") {
+            current.status = "superseded";
+        }
+        else {
+            if ((eventOperation.status !== "core_committed" &&
+                eventOperation.status !== "completed") ||
+                eventOperation.head !== event.head)
+                throw new ArtifactStoreCorruptionError("Artifact bind_head event does not match the operation core head");
+            current.head = event.head;
+        }
+    }
+    const records = raw.map((record) => {
+        const current = state.get(record.recordId);
+        const operation = operations.get(record.operationId);
+        const currentAttempt = operation?.requestAttempts[record.requestId];
+        const superseded = (currentAttempt !== undefined &&
+            currentAttempt !== record.requestAttempt) ||
+            operation?.artifactProjectionStatus === "superseded";
+        const next = {
+            ...record,
+            status: superseded ? "superseded" : current.status,
+            head: current.head,
+        };
+        delete next.newHead;
+        const folded = { ...next, recordFingerprint: rawRecordFingerprint(next) };
+        assertRawRecord(folded);
+        return folded;
+    });
+    return {
+        records,
+        operations: [...operations.values()],
+    };
+}
+async function writeFolded(dataRoot, worldId, folded) {
+    const artifacts = join(worldsRoot(dataRoot), worldId, "artifacts");
+    await rm(join(artifacts, "records"), { recursive: true, force: true });
+    await rm(join(artifacts, "operations"), { recursive: true, force: true });
+    await mkdir(artifacts, { recursive: true, mode: 0o700 });
+    for (const record of folded.records)
+        await writeArtifactJson(join(artifacts, "records", artifactSequenceFileName(record.sequence)), record);
+    for (const operation of folded.operations) {
+        assertOperation(operation);
+        await writeArtifactJson(join(artifacts, "operations", `${identityHash(operation.context.operationId)}.json`), operation);
+    }
+}
+async function removeEmptyLegacyRoot(dataRoot) {
+    const root = join(dataRoot, "artifact-store");
+    if ((await entries(join(root, "worlds"))).length === 0 &&
+        (await entries(join(root, "operations"))).length === 0)
+        await rm(root, { recursive: true, force: true });
+}
+async function legacyOperationPathsFor(dataRoot, worldId) {
+    const directory = join(dataRoot, "artifact-store", "operations");
+    const paths = [];
+    for (const name of await entries(directory)) {
+        if (!name.endsWith(".json"))
+            continue;
+        const path = join(directory, name);
+        const operation = parseArtifactJson(await readFile(path, "utf8"), "legacy artifact operation");
+        if (operation.context?.worldId === worldId)
+            paths.push(path);
+    }
+    return paths;
+}
+async function readJsonDirectory(directory, label) {
+    const values = [];
+    for (const name of (await entries(directory))
+        .filter((item) => item.endsWith(".json"))
+        .sort())
+        values.push(parseArtifactJson(await readFile(join(directory, name), "utf8"), label));
+    return values;
+}
+async function entries(directory) {
+    try {
+        return await readdir(directory);
+    }
+    catch (error) {
+        if (isMissing(error))
+            return [];
+        throw error;
+    }
+}
+async function exists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch (error) {
+        if (isMissing(error))
+            return false;
+        throw error;
+    }
+}
+function worldsRoot(dataRoot) {
+    return join(dataRoot, "worlds-file-native");
+}
+function legacyWorldRoot(dataRoot, worldId) {
+    return join(dataRoot, "artifact-store", "worlds", identityHash(worldId));
+}
+function forkSnapshotPath(dataRoot, worldId) {
+    return join(worldsRoot(dataRoot), worldId, "runtime", "artifact-fork.json");
+}
+function forkRestoredMarker(dataRoot, worldId) {
+    return join(worldsRoot(dataRoot), worldId, "fork-restored.json");
+}

package/dist/node/runtime/config/AppPreferencesStore.js

@@ -71,7 +71,6 @@ export class AppPreferencesStore {
         try {
             handle = await open(temporary, "wx", 0o600);
             await handle.writeFile(`${JSON.stringify(document, null, 2)}\n`, "utf8");
-            await handle.sync();
             await handle.close();
             handle = undefined;
             await chmod(temporary, 0o600);

package/dist/node/runtime/config/ProtagonistTemplateStore.js

@@ -86,7 +86,6 @@ export class ProtagonistTemplateStore {
         try {
             handle = await open(temporary, "wx", 0o600);
             await handle.writeFile(`${JSON.stringify({ schemaVersion: 1, ...view }, null, 2)}\n`, "utf8");
-            await handle.sync();
             await handle.close();
             handle = undefined;
             await rename(temporary, this.#path);

package/dist/node/runtime/config/dataRootLock.js

@@ -0,0 +1,108 @@
+import { mkdir, open, readdir, readFile, rm, rmdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+/**
+ * One service process owns a data directory (ADR-0044). The lock is a pid
+ * file: a live owner refuses startup, and a dead owner's file is replaced.
+ */
+const lockFileName = "server.pid";
+/** Persistent lock directories left by the retired cross-process world locks. */
+const legacyLockPaths = [
+    "runtime-locks",
+    join("operations", "world-locks"),
+    join("operations", "authority-locks"),
+    join("operations", "correction-claims"),
+];
+export class DataRootBusyError extends Error {
+    ownerPid;
+    constructor(ownerPid) {
+        super(`Another Narraeon server (pid ${ownerPid}) is already using this data directory`);
+        this.name = "DataRootBusyError";
+        this.ownerPid = ownerPid;
+    }
+}
+export async function acquireDataRootLock(dataRoot) {
+    const root = resolve(dataRoot);
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    const path = join(root, lockFileName);
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+        try {
+            const handle = await open(path, "wx", 0o600);
+            try {
+                await handle.writeFile(`${process.pid}\n`, "utf8");
+            }
+            finally {
+                await handle.close();
+            }
+            await removeLegacyLocks(root);
+            return {
+                release: async () => {
+                    if ((await readOwnerPid(path)) === process.pid)
+                        await rm(path, { force: true });
+                },
+            };
+        }
+        catch (error) {
+            if (!isNodeError(error) || error.code !== "EEXIST")
+                throw error;
+            const owner = await readOwnerPid(path);
+            if (owner !== null && processIsAlive(owner))
+                throw new DataRootBusyError(owner);
+            await rm(path, { force: true });
+        }
+    }
+    throw new Error("Could not acquire the data-directory startup lock");
+}
+async function readOwnerPid(path) {
+    let text;
+    try {
+        text = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT")
+            return null;
+        throw error;
+    }
+    const pid = Number(text.trim());
+    return Number.isSafeInteger(pid) && pid > 0 ? pid : null;
+}
+function processIsAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return !(isNodeError(error) && error.code === "ESRCH");
+    }
+}
+async function removeLegacyLocks(root) {
+    for (const relative of legacyLockPaths)
+        await rm(join(root, relative), { recursive: true, force: true });
+    await removeLegacyOperationReceipts(root);
+}
+/**
+ * Operation receipts written before #76 (including archive import receipts) have
+ * no readers. The world-revision epoch markers in the same directory are kept.
+ */
+async function removeLegacyOperationReceipts(root) {
+    const directory = join(root, "operations");
+    const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
+        if (isNodeError(error) && error.code === "ENOENT")
+            return null;
+        throw error;
+    });
+    if (entries === null)
+        return;
+    for (const entry of entries)
+        if (entry.isFile() && entry.name.endsWith(".json"))
+            await rm(join(directory, entry.name), { force: true });
+    try {
+        await rmdir(directory);
+    }
+    catch (error) {
+        if (!isNodeError(error) || error.code !== "ENOTEMPTY")
+            throw error;
+    }
+}
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}

package/dist/node/runtime/content/ContentWorkspace.js

@@ -1,6 +1,7 @@
 import { isAbsolute, win32 } from "node:path";
 import { inflateRawSync } from "node:zlib";
 import { portableContentTreePathKey } from "../../protocol/contentTree.js";
+import { fictionGameplay, gameplayFile, parseGameplay, } from "../../protocol/gameplay.js";
 import { defaultAppLocale, } from "../../protocol/appPreferences.js";
 import { defaultContentWorkspaceLimits, maximumPortableContentArchiveBytes, } from "./ContentLimits.js";
 import { CurrentTreeContentLibrary, InvalidContentTreeError, normalizeCurrentContentTreeFiles, } from "./CurrentTreeContentLibrary.js";
@@ -36,11 +37,15 @@ export class ContentWorkspace {
             ...options.currentTree,
         });
     }
-    createCurrentTreeContentPackage() {
+    createCurrentTreeContentPackage(gameplay = fictionGameplay) {
         const locale = this.#locale();
+        const chosen = parseGameplay(gameplay);
         return this.#currentTreeLibrary.createPackage({
             title: defaultContentPackageTitle(locale, "new"),
-            files: minimalFileNativeContentScaffold(locale),
+            files: [
+                ...minimalFileNativeContentScaffold(locale),
+                ...(chosen.mode === "tabletop" ? [gameplayFile(chosen)] : []),
+            ],
         });
     }
     createSampleContentPackage(locale) {
@@ -76,6 +81,9 @@ export class ContentWorkspace {
     replaceCurrentTreeContentPackage(localId, files, options = {}) {
         return this.#currentTreeLibrary.replaceCurrentTree(localId, files, options);
     }
+    setCurrentTreeContentGameplayScheme(localId, scheme, options = {}) {
+        return this.#currentTreeLibrary.setGameplayScheme(localId, scheme, options);
+    }
     importPortableContentPackageArchive(archive, options = {}) {
         return this.#mutate(async () => {
             const files = readPortableContentArchive(archive, this.#limits, options.signal);
@@ -107,7 +115,6 @@ export class ContentWorkspace {
             await this.#beforePortableContentExport?.();
             options.signal?.throwIfAborted();
             const archive = createPortableContentArchive(package_.files);
-            await crashProcessAtPortableContentExportEdge("after_archive_created");
             options.signal?.throwIfAborted();
             return {
                 fileName: `${portableArchiveBaseName(package_.title)}.zip`,
@@ -625,12 +632,3 @@ function isAbortError(error) {
 function compareStrings(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
-async function crashProcessAtPortableContentExportEdge(edge) {
-    if (process.env.NODE_ENV !== "test" ||
-        process.env.NARRAEON_INTERNAL_TEST_CRASH_AT_PORTABLE_CONTENT_EXPORT_EDGE !==
-            edge) {
-        return;
-    }
-    process.kill(process.pid, "SIGKILL");
-    await new Promise(() => undefined);
-}

package/dist/node/runtime/content/CurrentTreeContentLibrary.js

@@ -1,9 +1,11 @@
 import { PackageScriptPermissions } from "../extension/PackageScriptPermissions.js";
 import { randomUUID } from "node:crypto";
 import { readFileSync, unlinkSync } from "node:fs";
-import { link, open, mkdir, readFile, readdir, rename, rm, stat, unlink, } from "node:fs/promises";
+import { open, mkdir, readFile, readdir, rename, rm, stat, unlink, } from "node:fs/promises";
+import { linkExclusive } from "../FileNativeExclusiveLink.js";
 import { basename, dirname, isAbsolute, join, posix, win32 } from "node:path";
 import { portableContentTreePathKey } from "../../protocol/contentTree.js";
+import { assertSameGameplayMode, gameplayFile, gameplayPath, readGameplay, } from "../../protocol/gameplay.js";
 import { defaultContentWorkspaceLimits, } from "./ContentLimits.js";
 import { inspectContentPackageCurrentTree, isContentPackageWorldDocumentPath, worldDocumentTextRequirement, } from "./FileNativeContentTree.js";
 const localIdPattern = /^package-[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
@@ -91,7 +93,6 @@ export class CurrentTreeContentLibrary {
                 try {
                     options.signal?.throwIfAborted();
                     await rename(this.#packageRoot(localId), tombstonePath);
-                    await syncDirectory(this.#packagesRoot);
                 }
                 catch (error) {
                     if (isAbortError(error))
@@ -228,6 +229,29 @@ export class CurrentTreeContentLibrary {
             }
         });
     }
+    /**
+     * Change only the resolution scheme of a tabletop package. The edit reads the
+     * tree under the same lease as ordinary saves, so it publishes atomically and
+     * follows the same conflict rules.
+     */
+    setGameplayScheme(localId, scheme, options = {}) {
+        return this.#mutate(async () => {
+            const lease = await this.acquireOperationLease(localId, {
+                wait: options.waitForLease !== false,
+            });
+            try {
+                options.signal?.throwIfAborted();
+                const current = lease.package;
+                if (current.gameplay.mode !== "tabletop")
+                    throw new InvalidContentTreeError("Only a tabletop content package has a resolution scheme / 只有跑团内容包有判定方案");
+                const replacement = gameplayFile({ mode: "tabletop", scheme });
+                return await lease.replace(current.files.map((file) => file.path === gameplayPath ? replacement : file), options);
+            }
+            finally {
+                lease.release();
+            }
+        });
+    }
     async acquireOperationLease(localId, options = {}) {
         this.#packageRoot(localId);
         await mkdir(this.#locksRoot, { recursive: true, mode: 0o700 });
@@ -243,11 +267,10 @@ export class CurrentTreeContentLibrary {
         try {
             handle = await open(temporaryPath, "wx", 0o600);
             await handle.writeFile(`${JSON.stringify(marker)}\n`, "utf8");
-            await handle.sync();
             await handle.close();
             handle = undefined;
             try {
-                await link(temporaryPath, lockPath);
+                await linkExclusive(temporaryPath, lockPath);
             }
             catch (error) {
                 if (!isNodeErrorCode(error, "EEXIST"))
@@ -281,6 +304,7 @@ export class CurrentTreeContentLibrary {
                         throw new CurrentTreeContentPackageBusyError();
                     options.signal?.throwIfAborted();
                     const normalized = normalizeCurrentContentTreeFiles(files, this.#limits);
+                    assertGameplayModeUnchanged(package_.files, normalized);
                     return this.#replaceNormalizedCurrentTree(localId, package_.title, normalized, options.signal);
                 },
                 release: () => {
@@ -307,7 +331,6 @@ export class CurrentTreeContentLibrary {
                 schemaVersion: 1,
                 files: normalized,
             }));
-            await crashProcessAtCurrentTreeEdge("after_current_tree_staging");
             signal?.throwIfAborted();
             await this.#beforeCurrentTreeReplace?.();
             signal?.throwIfAborted();
@@ -315,12 +338,8 @@ export class CurrentTreeContentLibrary {
                 if (!isNodeErrorCode(error, "ENOENT"))
                     throw error;
             });
-            await link(join(packageRoot, currentTreeFileName), previousPath);
-            await syncDirectory(packageRoot);
+            await linkExclusive(join(packageRoot, currentTreeFileName), previousPath);
             await rename(temporaryPath, join(packageRoot, currentTreeFileName));
-            await syncDirectory(packageRoot);
-            await crashProcessAtCurrentTreeEdge("after_current_tree_replace");
-            failCurrentTreeAfterReplaceForTest();
             await unlink(previousPath).catch(() => undefined);
         }
         catch (error) {
@@ -329,7 +348,6 @@ export class CurrentTreeContentLibrary {
             if (await pathExists(previousPath).catch(() => false)) {
                 try {
                     await rename(previousPath, join(packageRoot, currentTreeFileName));
-                    await syncDirectory(packageRoot);
                 }
                 catch (rollbackError) {
                     rollbackFailure = rollbackError;
@@ -369,14 +387,10 @@ export class CurrentTreeContentLibrary {
                 schemaVersion: 1,
                 files: normalized,
             }));
-            await syncDirectory(stagingPath);
-            await crashProcessAtCurrentTreeEdge("after_package_staging");
             signal?.throwIfAborted();
             await this.#beforePackagePublish?.();
             signal?.throwIfAborted();
             await rename(stagingPath, finalPath);
-            await syncDirectory(this.#packagesRoot);
-            await crashProcessAtCurrentTreeEdge("after_package_publish");
         }
         catch (error) {
             await rm(stagingPath, { force: true, recursive: true }).catch(() => undefined);
@@ -410,10 +424,9 @@ export class CurrentTreeContentLibrary {
         try {
             handle = await open(temporaryPath, "wx", 0o600);
             await handle.writeFile(`${JSON.stringify(reclaim)}\n`, "utf8");
-            await handle.sync();
             await handle.close();
             handle = undefined;
-            await link(temporaryPath, reclaimPath);
+            await linkExclusive(temporaryPath, reclaimPath);
         }
         catch (error) {
             await handle?.close().catch(() => undefined);
@@ -433,7 +446,7 @@ export class CurrentTreeContentLibrary {
                 if (!isNodeErrorCode(error, "ENOENT"))
                     throw error;
             });
-            await link(replacementPath, lockPath);
+            await linkExclusive(replacementPath, lockPath);
             return true;
         }
         finally {
@@ -446,7 +459,7 @@ export class CurrentTreeContentLibrary {
     async #waitForPackageLock(lockPath, reclaimPath, replacementPath) {
         for (let attempt = 0; attempt < 2_000; attempt += 1) {
             if ((await this.#tryReplaceDeadPackageLock(lockPath, reclaimPath, replacementPath)) ||
-                (await link(replacementPath, lockPath)
+                (await linkExclusive(replacementPath, lockPath)
                     .then(() => true)
                     .catch((error) => {
                     if (isNodeErrorCode(error, "EEXIST"))
@@ -476,7 +489,7 @@ export class CurrentTreeContentLibrary {
 }
 function detail(localId, title, files, inspection) {
     return {
-        ...summary(localId, title, inspection),
+        ...summary(localId, title, readGameplay(files), inspection),
         files: files.map((file) => ({ ...file })),
         documents: structuredClone(inspection.documents),
         issues: structuredClone(inspection.issues),
@@ -484,8 +497,9 @@ function detail(localId, title, files, inspection) {
         control: structuredClone(inspection.control),
     };
 }
-function summary(localId, title, inspection) {
+function summary(localId, title, gameplay, inspection) {
     return {
+        gameplay: { ...gameplay },
         localId,
         title,
         status: inspection.status,
@@ -495,6 +509,7 @@ function summary(localId, title, inspection) {
 }
 function packageSummary(package_) {
     return {
+        gameplay: { ...package_.gameplay },
         localId: package_.localId,
         title: package_.title,
         status: package_.status,
@@ -547,8 +562,22 @@ export function normalizeCurrentContentTreeFiles(files, limits = defaultLimits)
             ...(file.encoding === undefined ? {} : { encoding: file.encoding }),
         });
     }
+    try {
+        readGameplay(normalized);
+    }
+    catch (error) {
+        throw new InvalidContentTreeError(error instanceof Error ? error.message : "Invalid gameplay identity");
+    }
     return normalized.sort((left, right) => compareStrings(left.path, right.path));
 }
+function assertGameplayModeUnchanged(before, after) {
+    try {
+        assertSameGameplayMode(before, after);
+    }
+    catch (error) {
+        throw new InvalidContentTreeError(error instanceof Error ? error.message : "Gameplay mode is fixed");
+    }
+}
 function decodeCanonicalBase64(contents, path) {
     if (contents.length % 4 !== 0 ||
         !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u.test(contents)) {
@@ -622,7 +651,6 @@ async function writeStoredLocalMetadata(packageRoot, metadata) {
     try {
         await writeDurableNewFile(temporaryPath, serialize(metadata));
         await rename(temporaryPath, join(packageRoot, localMetadataFileName));
-        await syncDirectory(packageRoot);
     }
     catch (error) {
         await rm(temporaryPath, { force: true }).catch(() => undefined);
@@ -634,16 +662,6 @@ async function writeDurableNewFile(path, contents) {
     const handle = await open(path, "wx", 0o600);
     try {
         await handle.writeFile(contents, "utf8");
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-}
-async function syncDirectory(path) {
-    const handle = await open(path, "r");
-    try {
-        await handle.sync();
     }
     finally {
         await handle.close();
@@ -784,20 +802,6 @@ function isNodeErrorCode(error, code) {
 function isAbortError(error) {
     return error instanceof Error && error.name === "AbortError";
 }
-async function crashProcessAtCurrentTreeEdge(edge) {
-    if (process.env.NODE_ENV !== "test" ||
-        process.env.NARRAEON_INTERNAL_TEST_CRASH_AT_CURRENT_TREE_EDGE !== edge) {
-        return;
-    }
-    process.kill(process.pid, "SIGKILL");
-    await new Promise(() => undefined);
-}
-function failCurrentTreeAfterReplaceForTest() {
-    if (process.env.NODE_ENV === "test" &&
-        process.env.NARRAEON_INTERNAL_TEST_FAIL_AFTER_CURRENT_TREE_REPLACE === "1") {
-        throw new Error("simulated failure after current tree replace");
-    }
-}
 function compareStrings(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }