narraeon 0.2.0 → 0.3.1

package/dist/node/runtime/world/FileNativeHistoryProjection.js

@@ -0,0 +1,39 @@
+import { createHash } from "node:crypto";
+export function fileNativeHistoryMessageIdFromProjectionPath(path) {
+    const match = /^(\d{8})-(\d+)-(player|narrator)-[a-f0-9]{12}\.md$/u.exec(path);
+    if (match === null)
+        return null;
+    const sequence = Number.parseInt(match[1], 10);
+    const index = Number.parseInt(match[2], 10);
+    const role = match[3];
+    return sequence === 0
+        ? index === 1 && role === "narrator"
+            ? "message.genesis.narrator"
+            : `message.genesis.${String(index)}.${role}`
+        : `message.${String(sequence)}.${String(index)}.${role}`;
+}
+export function projectFileNativeHistorySurface(messages, invalidIdentity) {
+    return messages.map((message) => {
+        const genesis = /(?:^|\.)message\.genesis(?:\.([1-9][0-9]*))?\.(player|narrator)$/u.exec(message.messageId);
+        const committed = /(?:^|\.)message\.([1-9][0-9]*)\.([1-9][0-9]*)\.(player|narrator)$/u.exec(message.messageId);
+        const sequence = genesis !== null ? 0 : Number.parseInt(committed?.[1] ?? "", 10);
+        const index = genesis !== null
+            ? Number.parseInt(genesis[1] ?? "1", 10)
+            : Number.parseInt(committed?.[2] ?? "", 10);
+        const role = genesis?.[2] ?? committed?.[3];
+        if (!Number.isSafeInteger(sequence) ||
+            sequence < 0 ||
+            !Number.isSafeInteger(index) ||
+            index < 1 ||
+            role !== message.role)
+            return invalidIdentity(message.messageId);
+        const suffix = createHash("sha256")
+            .update(message.messageId)
+            .digest("hex")
+            .slice(0, 12);
+        return {
+            path: `${String(sequence).padStart(8, "0")}-${String(index).padStart(2, "0")}-${message.role}-${suffix}.md`,
+            contents: message.exactText,
+        };
+    });
+}

package/dist/node/runtime/world/FileNativeWorldStorageMigrator.js

@@ -2,6 +2,8 @@ import { createHash, randomUUID } from "node:crypto";
 import { link, mkdir, open, readFile, readdir, rename, rm, writeFile, } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
+import { authorityV3Directory, continuityHeadFile, FileNativeAuthorityV3, } from "./FileNativeAuthorityV3.js";
+import { projectFileNativeHistorySurface } from "./FileNativeHistoryProjection.js";
 const currentAuthorityHeadFile = "play-authority-head.json";
 const releasedAuthorityFile = "play-authority.json";
 const releasedCallChainFile = "play-call-chain.json";
@@ -25,15 +27,32 @@ export class FileNativeWorldStorageMigrator {
         assertIdentity(worldId, "World ID");
         const worldRoot = join(this.#worldsRoot, worldId);
         const runtimeRoot = join(worldRoot, "runtime");
-        const current = await readOptionalJson(join(runtimeRoot, currentAuthorityHeadFile));
-        if (current !== null) {
-            assertCurrentAuthorityHead(current);
+        const currentAuthority = new FileNativeAuthorityV3(worldRoot);
+        if (await currentAuthority.exists()) {
+            const head = await currentAuthority.readHead();
             return {
                 outcome: "already_current",
-                authorityCommits: current.sequence,
+                authorityCommits: head.sequence,
                 callChainContexts: 0,
             };
         }
+        const current = await readOptionalJson(join(runtimeRoot, currentAuthorityHeadFile));
+        if (current !== null) {
+            assertCurrentAuthorityHead(current);
+            const commits = await readCurrentAuthority(worldRoot, current);
+            if ((commits.at(-1)?.operationId ?? null) !== current.operationId)
+                throw new Error("Current Authority head operation does not match its immutable tip");
+            const contexts = await this.#timeline.readAllContexts(worldId);
+            assertCurrentTimelineAuthorityRefs(contexts, commits);
+            const checkpoint = await migrateMaterializedCheckpoint(runtimeRoot, commits);
+            return this.#migrateCurrentAuthority({
+                worldId,
+                worldRoot,
+                commits,
+                checkpoint,
+                callChainContexts: contexts.length,
+            });
+        }
         const publication = await readJson(join(worldRoot, "publication.json"));
         if (!isRecord(publication) ||
             publication.schemaVersion !== 1 ||
@@ -59,6 +78,10 @@ export class FileNativeWorldStorageMigrator {
             await this.#timeline.migrateReleasedRecord(worldId, value, sha256Hex(callChainSource));
         }
         crashAtStorageMigrationEdge("after_timeline");
+        const migratedContexts = await this.#timeline.readAllContexts(worldId);
+        if (migratedContexts.length !== callChainContexts)
+            throw new Error("Released play timeline migration changed its context closure");
+        assertCurrentTimelineAuthorityRefs(migratedContexts, currentCommits);
         for (const commit of currentCommits)
             await publishImmutableJson(join(runtimeRoot, "play-commits", `${currentCommitDigest(commit)}.json`), commit);
         const checkpoint = await migrateMaterializedCheckpoint(runtimeRoot, currentCommits);
@@ -103,12 +126,327 @@ export class FileNativeWorldStorageMigrator {
             };
         await publishJson(join(runtimeRoot, currentAuthorityHeadFile), head);
         crashAtStorageMigrationEdge("after_current_head");
+        return this.#migrateCurrentAuthority({
+            worldId,
+            worldRoot,
+            commits: currentCommits,
+            checkpoint,
+            callChainContexts,
+        });
+    }
+    async #migrateCurrentAuthority(input) {
+        return migrateCurrentAuthorityToV3({
+            ...input,
+            operationsRoot: this.#operationsRoot,
+        });
+    }
+}
+async function migrateCurrentAuthorityToV3(input) {
+    const runtimeRoot = join(input.worldRoot, "runtime");
+    const genesis = await readCurrentGenesis(input.worldRoot, input.worldId);
+    const normalized = normalizeAuthorityIdentity(genesis.history, input.commits);
+    const stagingWorld = join(runtimeRoot, ".authority-v3-migration");
+    const stagedRuntime = join(stagingWorld, "runtime");
+    const targetAuthority = join(runtimeRoot, authorityV3Directory);
+    await rm(stagingWorld, { recursive: true, force: true });
+    const staged = new FileNativeAuthorityV3(stagingWorld);
+    try {
+        const genesisMaterials = normalizeMaterials(genesis.additionalMaterials, normalized.messageIds, input.worldId);
+        await staged.initialize({
+            operationId: genesis.operationId,
+            state: genesis.state,
+            history: normalized.genesisHistory,
+            additionalMaterials: genesisMaterials,
+        });
+        const expectedEndpoints = new Map([
+            [
+                "genesis",
+                {
+                    state: structuredClone(genesis.state),
+                    history: structuredClone(normalized.genesisHistory),
+                    additionalMaterials: structuredClone(genesisMaterials),
+                },
+            ],
+        ]);
+        const migrated = [];
+        for (const source of input.commits) {
+            const historyAppend = source.historyAppend.map((message) => normalizeHistoryMessage(message, normalized.messageIds));
+            const nextMaterials = normalizeMaterials(source.nextAdditionalMaterials, normalized.messageIds, input.worldId);
+            const basisHead = source.timelineRevision?.restoresHead ?? source.parentHead;
+            const basis = expectedEndpoints.get(basisHead);
+            if (basis === undefined)
+                throw new Error("Released Authority transition references an unknown result basis");
+            if (source.timelineRevision !== undefined) {
+                const restored = await staged.recover(source.timelineRevision.restoresHead);
+                const expectedHistory = source.timelineRevision.replacementHistory.map((message) => normalizeHistoryMessage(message, normalized.messageIds));
+                if (!isDeepStrictEqual(canonicalState(restored.state), canonicalLegacyState(source.timelineRevision.replacementState)) ||
+                    !isDeepStrictEqual(restored.history, expectedHistory) ||
+                    !isDeepStrictEqual(restored.additionalMaterials, nextMaterials))
+                    throw new Error("Released timeline revision does not exactly restore its logical parent");
+            }
+            const prepared = await staged.prepareAppend({
+                operationId: source.operationId,
+                parentHead: source.parentHead,
+                ...(source.timelineRevision === undefined
+                    ? {}
+                    : { timelineParentHead: source.timelineRevision.restoresHead }),
+                mode: source.mode,
+                historyAppend: historyAppend.map(({ role, exactText }) => ({
+                    role,
+                    exactText,
+                })),
+                stateChanges: source.stateChanges,
+                nextMaterials,
+                ...(source.correctionTargets === undefined
+                    ? {}
+                    : { correctionTargets: source.correctionTargets }),
+                ...(source.corrects === undefined ? {} : { corrects: source.corrects }),
+                ...(source.timelineRevision === undefined
+                    ? {}
+                    : {
+                        timelineRevision: {
+                            restoresHead: source.timelineRevision.restoresHead,
+                            replacesHead: source.timelineRevision.replacesHead,
+                            requestFingerprint: source.timelineRevision.requestFingerprint,
+                        },
+                    }),
+            });
+            if (!isDeepStrictEqual(prepared.commit.historyAppend, historyAppend) ||
+                prepared.commit.head !== source.head)
+                throw new Error("Migrated Authority fact changed released semantics");
+            await staged.publishPrepared(prepared);
+            const expected = applyReleasedTransition(basis, source, historyAppend, nextMaterials);
+            const recovered = await staged.recover(source.head);
+            if (!isDeepStrictEqual(canonicalState(recovered.state), canonicalState(expected.state)) ||
+                !isDeepStrictEqual(recovered.history, expected.history) ||
+                !isDeepStrictEqual(recovered.additionalMaterials, expected.additionalMaterials))
+                throw new Error(`Migrated Authority endpoint changed released semantics: ${source.head}`);
+            expectedEndpoints.set(source.head, expected);
+            migrated.push({
+                source,
+                fact: prepared.commit,
+                digest: prepared.commitDigest,
+            });
+        }
+        const finalHead = await staged.readHead();
+        if (finalHead.sequence !== input.commits.length ||
+            finalHead.head !== (input.commits.at(-1)?.head ?? "genesis"))
+            throw new Error("Migrated Authority head does not match released history");
+        await staged.readHistory();
+        const checkpointFact = input.checkpoint.sequence === 0
+            ? null
+            : migrated[input.checkpoint.sequence - 1];
+        if ((input.checkpoint.sequence === 0 &&
+            input.checkpoint.head !== "genesis") ||
+            (input.checkpoint.sequence > 0 &&
+                checkpointFact?.fact.head !== input.checkpoint.head))
+            throw new Error("Released materialized checkpoint is not in migrated Authority");
+        const checkpointEndpoint = await staged.recover(input.checkpoint.head);
+        await rm(targetAuthority, { recursive: true, force: true });
+        await rename(join(stagedRuntime, authorityV3Directory), targetAuthority);
+        await syncDirectory(runtimeRoot);
+        await publishJson(join(runtimeRoot, "play-genesis-timeline.json"), {
+            schemaVersion: 1,
+            worldId: input.worldId,
+            history: normalized.genesisHistory,
+        });
+        // V2 filenames hash world-scoped message IDs. Rebuild this derived surface
+        // from the normalized checkpoint before publishing the V3 checkpoint/head.
+        await replaceMaterializedHistory(join(input.worldRoot, "history"), projectFileNativeHistorySurface(checkpointEndpoint.history, (messageId) => {
+            throw new Error(`Migrated history-message identity cannot form a materialization path: ${messageId}`);
+        }));
+        await publishJson(join(runtimeRoot, "additional-materials.json"), {
+            head: input.checkpoint.head,
+            items: checkpointEndpoint.additionalMaterials,
+        });
+        await publishJson(join(runtimeRoot, "materialized-head.json"), {
+            schemaVersion: 3,
+            head: input.checkpoint.head,
+            sequence: input.checkpoint.sequence,
+            commitDigest: checkpointFact?.digest ?? null,
+        });
+        await mkdir(input.operationsRoot, { recursive: true, mode: 0o700 });
+        for (const { source, fact, digest } of migrated) {
+            await publishJson(operationOutcomePath(input.operationsRoot, source.operationId), {
+                outcome: input.checkpoint.sequence >= fact.sequence
+                    ? "committed"
+                    : "committed_materialization_pending",
+                worldId: input.worldId,
+                parentHead: fact.auditParent.head,
+                head: fact.head,
+                commitDigest: digest,
+                historyAppend: fact.historyAppend.map(({ role, exactText }) => ({
+                    role,
+                    exactText,
+                })),
+                nextAdditionalMaterials: fact.nextAdditionalMaterials,
+                mode: fact.mode,
+            });
+        }
+        await rm(stagingWorld, { recursive: true, force: true });
+        crashAtStorageMigrationEdge("before_authority_v3_head");
+        await publishJson(join(runtimeRoot, continuityHeadFile), finalHead);
+        crashAtStorageMigrationEdge("after_authority_v3_head");
         return {
             outcome: "migrated",
-            authorityCommits: currentCommits.length,
-            callChainContexts,
+            authorityCommits: migrated.length,
+            callChainContexts: input.callChainContexts,
         };
     }
+    finally {
+        await rm(stagingWorld, { recursive: true, force: true }).catch(() => undefined);
+    }
+}
+function applyReleasedTransition(basis, source, historyAppend, nextMaterials) {
+    const state = new Map(basis.state.map(({ path, contents }) => [path, contents]));
+    for (const change of source.stateChanges) {
+        const previous = state.get(change.relativePath);
+        if ((previous === undefined ? null : `sha256:${sha256Hex(previous)}`) !==
+            change.expectedPreviousHash ||
+            `sha256:${sha256Hex(change.canonicalNextBytes)}` !== change.nextHash)
+            throw new Error(`Released state transition hash conflicts: ${change.relativePath}`);
+        state.set(change.relativePath, change.canonicalNextBytes);
+    }
+    return {
+        state: [...state].map(([path, contents]) => ({ path, contents })),
+        history: [
+            ...structuredClone(basis.history),
+            ...structuredClone(historyAppend),
+        ],
+        additionalMaterials: structuredClone([...nextMaterials]),
+    };
+}
+function assertCurrentTimelineAuthorityRefs(contexts, commits) {
+    // Released clone-and-remap forks retained their inherited page/model trace
+    // prefix while absorbing the selected source history into the target
+    // genesis. Older contexts can therefore carry source-world commit aliases
+    // that never belonged to the target Authority. They are immutable display
+    // history; only the current context is a continuation boundary owned by the
+    // target world and must resolve against its Authority.
+    const context = contexts.at(-1);
+    if (context === undefined)
+        return;
+    const heads = new Set(["genesis", ...commits.map(({ head }) => head)]);
+    if (!heads.has(context.baselineHead) || !heads.has(context.parentHead))
+        throw new Error("Released play timeline references an unknown Authority endpoint");
+    for (const event of context.events) {
+        if ("committedHead" in event &&
+            event.committedHead !== undefined &&
+            !heads.has(event.committedHead))
+            throw new Error("Released play event references an unknown Authority endpoint");
+    }
+}
+async function readCurrentAuthority(worldRoot, head) {
+    const reverse = [];
+    let digest = head.commitDigest;
+    let expectedHead = head.head;
+    let expectedSequence = head.sequence;
+    while (digest !== null) {
+        const value = await readJson(join(worldRoot, "runtime", "play-commits", `${digest}.json`));
+        assertCurrentPlayCommit(value);
+        if (currentCommitDigest(value) !== digest ||
+            value.head !== expectedHead ||
+            value.sequence !== expectedSequence)
+            throw new Error("Current Authority endpoint does not match its commit");
+        reverse.push(value);
+        digest = value.parentCommitDigest;
+        expectedHead = value.parentHead;
+        expectedSequence -= 1;
+    }
+    if (expectedHead !== "genesis" || expectedSequence !== 0)
+        throw new Error("Current Authority chain does not terminate at genesis");
+    return reverse.reverse();
+}
+async function readCurrentGenesis(worldRoot, worldId) {
+    const value = await readJson(join(worldRoot, "runtime", "genesis.json"));
+    if (!isRecord(value) ||
+        value.schemaVersion !== 1 ||
+        value.type !== "file_native_genesis" ||
+        value.worldId !== worldId ||
+        (typeof value.operationId !== "string" && value.operationId !== null) ||
+        !Array.isArray(value.state) ||
+        !Array.isArray(value.history) ||
+        !value.history.every(isReleasedHistoryMessage) ||
+        !Array.isArray(value.additionalMaterials) ||
+        !value.additionalMaterials.every(isMaterialSelection))
+        throw new Error("Current world genesis has an invalid shape");
+    const state = value.state.map((file) => {
+        if (!isRecord(file) ||
+            typeof file.path !== "string" ||
+            !validRelativePath(file.path) ||
+            typeof file.sha256 !== "string" ||
+            typeof file.canonicalBytes !== "string" ||
+            `sha256:${sha256Hex(file.canonicalBytes)}` !== file.sha256)
+            throw new Error("Current world genesis state is corrupt");
+        return { path: file.path, contents: file.canonicalBytes };
+    });
+    return {
+        operationId: value.operationId,
+        state,
+        history: structuredClone(value.history),
+        additionalMaterials: structuredClone(value.additionalMaterials),
+    };
+}
+function normalizeAuthorityIdentity(genesis, commits) {
+    const messageIds = new Map();
+    const bind = (source, target) => {
+        if (messageIds.has(source) && messageIds.get(source) !== target)
+            throw new Error("Released Authority reuses one message identity");
+        messageIds.set(source, target);
+        messageIds.set(target, target);
+    };
+    for (const [index, message] of genesis.entries())
+        bind(message.messageId, index === 0 && message.role === "narrator"
+            ? "message.genesis.narrator"
+            : `message.genesis.${index + 1}.${message.role}`);
+    for (const commit of commits)
+        for (const [index, message] of commit.historyAppend.entries())
+            bind(message.messageId, `message.${commit.sequence}.${index + 1}.${message.role}`);
+    return {
+        genesisHistory: genesis.map((message) => normalizeHistoryMessage(message, messageIds)),
+        messageIds,
+    };
+}
+function normalizeHistoryMessage(message, messageIds) {
+    const messageId = messageIds.get(message.messageId);
+    if (messageId === undefined)
+        throw new Error(`Released Authority references an unknown history message: ${message.messageId}`);
+    return { ...structuredClone(message), messageId };
+}
+function normalizeMaterials(materials, messageIds, worldId) {
+    return materials.map((material) => {
+        if (material.kind === "history_message") {
+            const message = messageIds.get(material.message);
+            if (message === undefined)
+                throw new Error(`Released material references an unknown history message: ${material.message}`);
+            return { ...material, message };
+        }
+        if (material.kind === "history_commit") {
+            const prefix = `${worldId}.`;
+            const commit = material.commit.startsWith(prefix)
+                ? material.commit.slice(prefix.length)
+                : material.commit;
+            if (!/^(?:genesis|commit:[1-9][0-9]*)$/u.test(commit))
+                throw new Error(`Released material references a foreign Authority endpoint: ${material.commit}`);
+            return {
+                ...material,
+                commit,
+            };
+        }
+        return structuredClone(material);
+    });
+}
+function canonicalState(files) {
+    return files
+        .map(({ path, contents }) => ({
+        path,
+        sha256: `sha256:${sha256Hex(contents)}`,
+        canonicalBytes: contents,
+    }))
+        .sort((left, right) => left.path.localeCompare(right.path));
+}
+function canonicalLegacyState(files) {
+    return [...structuredClone(files)].sort((left, right) => left.path.localeCompare(right.path));
 }
 async function readReleasedAuthority(worldRoot) {
     const runtimeRoot = join(worldRoot, "runtime");
@@ -193,6 +531,33 @@ async function migrateMaterializedCheckpoint(runtimeRoot, commits) {
             sequence: 0,
             commitDigest: null,
         };
+    if (isRecord(value) &&
+        hasExactKeys(value, [
+            "schemaVersion",
+            "head",
+            "sequence",
+            "commitDigest",
+        ]) &&
+        value.schemaVersion === 3 &&
+        typeof value.head === "string" &&
+        Number.isSafeInteger(value.sequence) &&
+        Number(value.sequence) >= 0 &&
+        (value.commitDigest === null ||
+            (typeof value.commitDigest === "string" &&
+                /^[a-f0-9]{64}$/u.test(value.commitDigest)))) {
+        const sequence = Number(value.sequence);
+        const expected = sequence === 0 ? undefined : commits[sequence - 1];
+        if ((sequence === 0 &&
+            (value.head !== "genesis" || value.commitDigest !== null)) ||
+            (sequence > 0 && expected?.head !== value.head))
+            throw new Error("Unmarked V3 materialized checkpoint is not in released Authority");
+        return {
+            schemaVersion: 2,
+            head: value.head,
+            sequence,
+            commitDigest: expected === undefined ? null : currentCommitDigest(expected),
+        };
+    }
     if (isCurrentMaterializedCheckpoint(value)) {
         const expected = value.sequence === 0 ? undefined : commits[value.sequence - 1];
         if ((value.sequence === 0 &&
@@ -458,6 +823,58 @@ function assertCurrentAuthorityHead(value) {
                 value.operationId === null))
         throw new Error("Current Authority head has an invalid shape");
 }
+function assertCurrentPlayCommit(value) {
+    if (!isRecord(value))
+        throw new Error("Current play commit has an invalid shape");
+    const correction = value.mode === "correction";
+    const timelineRevision = value.mode === "timeline_revision";
+    if (!hasExactKeys(value, [
+        "schemaVersion",
+        "sequence",
+        "operationId",
+        "parentHead",
+        "parentCommitDigest",
+        "head",
+        "mode",
+        "historyAppend",
+        "stateChanges",
+        "nextAdditionalMaterials",
+        ...(correction ? ["correctionTargets", "corrects"] : []),
+        ...(timelineRevision ? ["timelineRevision"] : []),
+    ]) ||
+        value.schemaVersion !== 2 ||
+        !Number.isSafeInteger(value.sequence) ||
+        Number(value.sequence) < 1 ||
+        typeof value.operationId !== "string" ||
+        value.operationId.trim() === "" ||
+        typeof value.parentHead !== "string" ||
+        !/^(?:genesis|commit:[1-9][0-9]*)$/u.test(value.parentHead) ||
+        (value.parentCommitDigest !== null &&
+            (typeof value.parentCommitDigest !== "string" ||
+                !/^[a-f0-9]{64}$/u.test(value.parentCommitDigest))) ||
+        typeof value.head !== "string" ||
+        value.head !== `commit:${String(value.sequence)}` ||
+        (value.mode !== "play" &&
+            value.mode !== "correction" &&
+            value.mode !== "timeline_revision") ||
+        !Array.isArray(value.historyAppend) ||
+        !value.historyAppend.every(isReleasedHistoryMessage) ||
+        !Array.isArray(value.stateChanges) ||
+        !value.stateChanges.every(isReleasedStateChange) ||
+        !Array.isArray(value.nextAdditionalMaterials) ||
+        !value.nextAdditionalMaterials.every(isMaterialSelection))
+        throw new Error("Current play commit has an invalid shape");
+    if (correction &&
+        (!Array.isArray(value.correctionTargets) ||
+            !value.correctionTargets.every((target) => typeof target === "string" && target.trim() !== "") ||
+            typeof value.corrects !== "string" ||
+            value.corrects !== value.parentHead))
+        throw new Error("Current correction commit has an invalid shape");
+    if (timelineRevision &&
+        (value.stateChanges.length !== 0 ||
+            !isReleasedTimelineRevision(value.timelineRevision)))
+        throw new Error("Current timeline revision has an invalid shape");
+}
 function isCurrentMaterializedCheckpoint(value) {
     return (isRecord(value) &&
         hasExactKeys(value, [
@@ -557,6 +974,37 @@ async function readDirectoryFileNames(root) {
         throw error;
     }
 }
+async function replaceMaterializedHistory(root, files) {
+    await mkdir(root, { recursive: true, mode: 0o700 });
+    const entries = await readdir(root, { withFileTypes: true });
+    if (entries.some((entry) => !entry.isFile()))
+        throw new Error("Materialized history projection must be a flat file tree");
+    const current = new Map(await Promise.all(entries.map(async (entry) => [entry.name, await readFile(join(root, entry.name), "utf8")])));
+    const expected = new Set();
+    for (const file of files) {
+        if (!validRelativePath(file.path) || file.path.includes("/"))
+            throw new Error(`Migrated history projection has an invalid path: ${file.path}`);
+        if (expected.has(file.path))
+            throw new Error(`Migrated history projection has a duplicate path: ${file.path}`);
+        expected.add(file.path);
+        if (current.get(file.path) === file.contents)
+            continue;
+        const temporary = join(root, `${file.path}.${randomUUID()}.tmp`);
+        await writeFile(temporary, file.contents, {
+            encoding: "utf8",
+            mode: 0o600,
+        });
+        await syncFile(temporary);
+        await rename(temporary, join(root, file.path));
+        await syncDirectory(root);
+    }
+    for (const entry of entries) {
+        if (expected.has(entry.name))
+            continue;
+        await rm(join(root, entry.name), { force: true });
+        await syncDirectory(root);
+    }
+}
 async function publishJson(path, value) {
     await mkdir(dirname(path), { recursive: true, mode: 0o700 });
     const temporary = `${path}.${randomUUID()}.tmp`;