narraeon 0.6.0 → 0.6.2

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/authoring/ModelToolConversation.js

@@ -119,8 +119,15 @@ export class ModelToolConversation {
                 await input.settleToolResponse(session, session.modelItems.length - 1, toolCalls);
                 input.changed?.(true);
             }
-            throw new Error(input.failure?.exchangeLimit ??
-                `Authoring exceeded ${maximumExchangesPerMessage} model exchanges for one user message`);
+            // The exchange budget only bounds a runaway loop. Every tool response is
+            // already settled, so the conversation pauses and can resume unchanged.
+            session.runStatus = "paused";
+            session.activeRequestId = null;
+            session.completedRequestIds = rememberRequest(session.completedRequestIds, live.requestId);
+            session.lastFailure = null;
+            session.updatedAt = Date.now();
+            await input.save(session);
+            return input.view(session);
         }
         catch (error) {
             session.runStatus = "interrupted";
@@ -154,6 +161,22 @@ export function appendAuthoringUserMessage(session, message, requestId) {
     session.lastFailure = null;
     session.updatedAt = now;
 }
+/**
+ * Starts another exchange budget for a paused conversation without appending a
+ * user message; the next request replays the settled transcript as-is. The run
+ * still belongs to the paused user request, so that request stays active; the
+ * caller's resume request ID only deduplicates the resume itself.
+ */
+export function resumePausedAuthoringConversation(session) {
+    if (session.runStatus !== "paused")
+        throw new Error("Only a paused authoring conversation can be continued");
+    if (session.modelItems.at(-1)?.kind !== "tool")
+        throw new Error("The paused authoring conversation does not end with settled tool results");
+    session.runStatus = "running";
+    session.activeRequestId = session.requests?.at(-1)?.requestId ?? null;
+    session.lastFailure = null;
+    session.updatedAt = Date.now();
+}
 export function requiredAuthoringMessage(message) {
     if (message.trim().length === 0)
         throw new Error("An authoring message cannot be empty");

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

@@ -115,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`,
@@ -633,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,7 +1,8 @@
 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";
@@ -92,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))
@@ -267,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"))
@@ -332,7 +331,6 @@ export class CurrentTreeContentLibrary {
                 schemaVersion: 1,
                 files: normalized,
             }));
-            await crashProcessAtCurrentTreeEdge("after_current_tree_staging");
             signal?.throwIfAborted();
             await this.#beforeCurrentTreeReplace?.();
             signal?.throwIfAborted();
@@ -340,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) {
@@ -354,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;
@@ -394,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);
@@ -435,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);
@@ -458,7 +446,7 @@ export class CurrentTreeContentLibrary {
                 if (!isNodeErrorCode(error, "ENOENT"))
                     throw error;
             });
-            await link(replacementPath, lockPath);
+            await linkExclusive(replacementPath, lockPath);
             return true;
         }
         finally {
@@ -471,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"))
@@ -663,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);
@@ -675,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();
@@ -825,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;
 }

package/dist/node/runtime/extension/PackageScriptPermissions.js

@@ -32,19 +32,11 @@ export class PackageScriptPermissions {
             const file = await open(temporary, "wx", 0o600);
             try {
                 await file.writeFile(JSON.stringify({ schemaVersion: 1, grants }));
-                await file.sync();
             }
             finally {
                 await file.close();
             }
             await rename(temporary, path);
-            const directory = await open(ownerRoot, "r");
-            try {
-                await directory.sync();
-            }
-            finally {
-                await directory.close();
-            }
         }
         finally {
             await rm(temporary, { force: true });

package/dist/node/runtime/extension/WorldExtensionControls.js

@@ -27,19 +27,11 @@ export class WorldExtensionControls {
             const file = await open(temporary, "wx", 0o600);
             try {
                 await file.writeFile(JSON.stringify(state));
-                await file.sync();
             }
             finally {
                 await file.close();
             }
             await rename(temporary, path);
-            const directory = await open(root, "r");
-            try {
-                await directory.sync();
-            }
-            finally {
-                await directory.close();
-            }
         }
         finally {
             await rm(temporary, { force: true });

package/dist/node/runtime/model/ModelConnectionStore.js

@@ -220,7 +220,6 @@ export class ModelConnectionStore {
         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);