narraeon 0.5.7 → 0.6.1

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

@@ -1,3 +1,4 @@
+import { gameplayPath, readGameplay } from "../../protocol/gameplay.js";
 import { readPackageFollowups } from "./PackageFollowups.js";
 import { parseDocument } from "yaml";
 import { WorldDocumentStore, } from "../world/WorldDocumentStore.js";
@@ -45,7 +46,7 @@ export function inspectContentPackageCurrentTree(files, options = {}) {
     }
     const unsupportedPaths = new Set();
     for (const file of snapshotFiles) {
-        if (/\.json$/iu.test(file.path)) {
+        if (/\.json$/iu.test(file.path) && file.path !== gameplayPath) {
             unsupportedPaths.add(file.path);
             issue(issues, "unsupported_content_file", file.path, "The current content package does not accept manifest, seven-field JSON, schema, record, or revision files");
         }
@@ -116,6 +117,12 @@ export function inspectContentPackageCurrentTree(files, options = {}) {
                 issue(issues, "invalid_player_view", "control/player-views.yaml", `${formatProblems.length - maxReportedPlayerViewProblems} more player-view issues were omitted`);
         }
     }
+    try {
+        readGameplay(snapshotFiles);
+    }
+    catch (error) {
+        issue(issues, "invalid_gameplay", gameplayPath, error instanceof Error ? error.message : "Invalid gameplay");
+    }
     try {
         readPackageFollowups(snapshotFiles);
     }

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);

package/dist/node/runtime/play/FileNativeContinuityCorrection.js

@@ -5,7 +5,6 @@ import { validateMaterialList } from "../prompt/MaterialSelection.js";
 import { FileNativeWorldCreationError, } from "../world/FileNativeWorldStore.js";
 import { WorldOperationBusyError, } from "../world/WorldOperationCoordinator.js";
 import { beginWorldStateRevision, fileNativeStateChanges, reviseWorldState, worldDocumentRevisionFailureMessage, worldStateRevisionChanges, } from "../world/WorldStateRevision.js";
-const claimHeartbeatIntervalMilliseconds = 20_000;
 export class FileNativeContinuityCorrection {
     #worlds;
     #compiler;
@@ -59,16 +58,10 @@ export class FileNativeContinuityCorrection {
         }
         if (revision.snapshot.status !== "usable") {
             this.#worlds.releaseControl(input.worldId, input.operationId);
-            await this.#worlds.failOperation(input.operationId, "failed");
+            await this.#worlds.releaseOperationReservation(input.operationId);
             await this.#worlds.operations.releaseCorrectionWorld(claimed.handle);
             throw new Error("The correction candidate's world-state snapshot is unavailable");
         }
-        const claimHeartbeat = setInterval(() => {
-            void this.#worlds.operations
-                .renewCorrectionWorld(claimed.handle)
-                .catch(() => undefined);
-        }, claimHeartbeatIntervalMilliseconds);
-        claimHeartbeat.unref();
         try {
             const candidate = {
                 ...revision,
@@ -87,7 +80,6 @@ export class FileNativeContinuityCorrection {
                 reads: new Map(),
                 previewedVersion: null,
                 stateOperationClaim: claimed.handle,
-                claimHeartbeat,
             };
             this.#candidates.set(candidate.id, candidate);
             return {
@@ -97,7 +89,6 @@ export class FileNativeContinuityCorrection {
             };
         }
         catch (error) {
-            clearInterval(claimHeartbeat);
             this.#worlds.releaseControl(input.worldId, input.operationId);
             await Promise.allSettled([
                 this.#worlds.releaseOperationReservation(input.operationId),
@@ -200,11 +191,10 @@ export class FileNativeContinuityCorrection {
             });
         }
         catch (error) {
-            await this.#worlds.failOperation(candidate.operationId, "failed");
+            await this.#worlds.releaseOperationReservation(candidate.operationId);
             throw error;
         }
         finally {
-            clearInterval(candidate.claimHeartbeat);
             this.#worlds.releaseControl(candidate.worldId, candidate.operationId);
             this.#candidates.delete(candidate.id);
             await this.#worlds.operations
@@ -214,11 +204,10 @@ export class FileNativeContinuityCorrection {
     }
     async cancel(candidateId, expectedVersion) {
         const candidate = this.#atVersion(candidateId, expectedVersion);
-        clearInterval(candidate.claimHeartbeat);
         this.#candidates.delete(candidateId);
         this.#worlds.releaseControl(candidate.worldId, candidate.operationId);
         try {
-            await this.#worlds.failOperation(candidate.operationId, "cancelled");
+            await this.#worlds.releaseOperationReservation(candidate.operationId);
         }
         finally {
             await this.#worlds.operations.releaseCorrectionWorld(candidate.stateOperationClaim);

package/dist/node/runtime/play/FileNativePlayAdvanceStore.js

@@ -1,14 +1,15 @@
-import { isNarrativeOrigin, isHistoryBackground, } from "../history/HistoryBackground.js";
+import { isNarrativeOrigin, } from "../history/HistoryBackground.js";
 import { createHash, randomUUID } from "node:crypto";
-import { link, mkdir, open, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 /**
- * Durable progress facts for the one play advance currently being settled.
+ * The single in-progress play advance of a call chain, if any.
  *
- * Every stage is immutable. `current.json` is only a small lookup projection;
- * deleting it cannot change Authority and a repeated user operation keeps the
- * same deterministic advance identity.
+ * It exists only between `begin` and `markSettled`. A marker that survives a
+ * restart means the advance was interrupted; the runtime marks the chain
+ * interrupted and the player retries. Legacy records from earlier layouts are
+ * ignored, so they never block a world from opening.
  */
 export class FileNativePlayAdvanceStore {
     #worldsRoot;
@@ -18,94 +19,41 @@ export class FileNativePlayAdvanceStore {
     async begin(base) {
         assertBase(base);
         const current = await this.readCurrent(base.worldId, base.chainId);
-        if (current !== null && current.settled === null) {
-            if (!sameAdvanceBase(current.base, base))
+        if (current !== null) {
+            if (!sameAdvanceBase(current, base))
                 throw new Error("Another play advance is still awaiting settlement");
             return;
         }
-        const basePath = this.#factPath(base, "base.json");
-        const existing = await readOptionalJson(basePath);
-        if (existing === null)
-            await publishImmutableJson(basePath, base);
-        else {
-            assertBase(existing);
-            if (!sameAdvanceBase(existing, base))
-                throw new Error("A play advance identity is bound to different data");
-        }
-        await publishJson(this.#currentPath(base.worldId, base.chainId), {
-            schemaVersion: 1,
-            worldId: base.worldId,
-            chainId: base.chainId,
-            advanceId: base.advanceId,
-        });
-    }
-    async recordProviderCompleted(base, response) {
-        const durableBase = await this.#assertCurrent(base);
-        await publishImmutableJson(this.#factPath(base, "provider-completed.json"), {
-            schemaVersion: 1,
-            stage: "provider_completed",
-            response: structuredClone(response),
-            recordedAt: durableBase.createdAt,
-        });
-    }
-    async recordSettlementPrepared(base, settlement) {
-        const durableBase = await this.#assertCurrent(base);
-        await publishImmutableJson(this.#factPath(base, "settlement-prepared.json"), {
-            schemaVersion: 1,
-            stage: "settlement_prepared",
-            settlement: structuredClone(settlement),
-            recordedAt: durableBase.createdAt,
-        });
-    }
-    async markSettled(base, head) {
-        const durableBase = await this.#assertCurrent(base);
-        await publishImmutableJson(this.#factPath(base, "settled.json"), {
-            schemaVersion: 1,
-            stage: "settled",
-            head,
-            recordedAt: durableBase.createdAt,
-        });
+        await publishJson(this.#markerPath(base.worldId, base.chainId), base);
     }
     async readCurrent(worldId, chainId) {
         assertIdentity(worldId, "World ID");
         assertIdentity(chainId, "Call-chain ID");
-        const pointer = await readOptionalJson(this.#currentPath(worldId, chainId));
-        if (pointer === null)
+        const value = await readOptionalJson(this.#markerPath(worldId, chainId));
+        if (value === null)
             return null;
-        assertPointer(pointer);
-        if (pointer.worldId !== worldId || pointer.chainId !== chainId)
-            throw new Error("Play advance pointer belongs to another context");
-        const recordRoot = this.#recordRoot(worldId, chainId, pointer.advanceId);
-        const [base, providerCompleted, settlementPrepared, settled] = await Promise.all([
-            readJson(join(recordRoot, "base.json")),
-            readOptionalJson(join(recordRoot, "provider-completed.json")),
-            readOptionalJson(join(recordRoot, "settlement-prepared.json")),
-            readOptionalJson(join(recordRoot, "settled.json")),
-        ]);
-        assertBase(base);
-        if (base.worldId !== worldId ||
-            base.chainId !== chainId ||
-            base.advanceId !== pointer.advanceId)
-            throw new Error("Play advance durable identity is inconsistent");
-        assertProviderCompleted(providerCompleted);
-        assertSettlementPrepared(settlementPrepared);
-        assertSettled(settled);
-        return { base, providerCompleted, settlementPrepared, settled };
+        assertBase(value);
+        if (value.worldId !== worldId || value.chainId !== chainId)
+            throw new Error("Play advance marker belongs to another context");
+        return value;
     }
-    async #assertCurrent(base) {
+    async markSettled(base) {
         const current = await this.readCurrent(base.worldId, base.chainId);
-        if (current === null || !sameAdvanceBase(current.base, base))
+        if (current === null)
+            return;
+        if (!sameAdvanceBase(current, base))
             throw new Error("Play advance is no longer current");
-        return current.base;
-    }
-    #currentPath(worldId, chainId) {
-        return join(this.#worldsRoot, worldId, "runtime", "play-advances", digest(chainId), "current.json");
+        await rm(this.#markerPath(base.worldId, base.chainId), { force: true });
     }
-    #recordRoot(worldId, chainId, advanceId) {
-        return join(this.#worldsRoot, worldId, "runtime", "play-advances", digest(chainId), "records", digest(advanceId));
+    /** Remove the in-progress marker and all advance records of a discarded chain. */
+    async discardChain(worldId, chainId) {
+        await rm(dirname(this.#markerPath(worldId, chainId)), {
+            recursive: true,
+            force: true,
+        });
     }
-    #factPath(base, name) {
-        return join(this.#recordRoot(base.worldId, base.chainId, base.advanceId), name);
+    #markerPath(worldId, chainId) {
+        return join(this.#worldsRoot, worldId, "runtime", "play-advances", digest(chainId), "in-progress.json");
     }
 }
 function sameAdvanceBase(left, right) {
@@ -152,40 +100,6 @@ function assertBase(value) {
         Number(value.attempt) < 1)
         throw new Error("Response advance has an invalid shape");
 }
-function assertPointer(value) {
-    if (!isRecord(value) ||
-        value.schemaVersion !== 1 ||
-        typeof value.worldId !== "string" ||
-        typeof value.chainId !== "string" ||
-        typeof value.advanceId !== "string")
-        throw new Error("Play advance pointer has an invalid shape");
-}
-function assertProviderCompleted(value) {
-    if (value !== null &&
-        (value.schemaVersion !== 1 ||
-            value.stage !== "provider_completed" ||
-            !isRecord(value.response) ||
-            typeof value.recordedAt !== "number"))
-        throw new Error("Provider-completed play fact has an invalid shape");
-}
-function assertSettlementPrepared(value) {
-    if (value !== null &&
-        (value.schemaVersion !== 1 ||
-            value.stage !== "settlement_prepared" ||
-            !isRecord(value.settlement) ||
-            (value.settlement.background !== undefined &&
-                !isHistoryBackground(value.settlement.background)) ||
-            typeof value.recordedAt !== "number"))
-        throw new Error("Settlement-prepared play fact has an invalid shape");
-}
-function assertSettled(value) {
-    if (value !== null &&
-        (value.schemaVersion !== 1 ||
-            value.stage !== "settled" ||
-            typeof value.head !== "string" ||
-            typeof value.recordedAt !== "number"))
-        throw new Error("Settled play fact has an invalid shape");
-}
 function digest(value) {
     return createHash("sha256").update(value).digest("hex");
 }
@@ -196,12 +110,9 @@ function assertIdentity(value, label) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-async function readJson(path) {
-    return JSON.parse(await readFile(path, "utf8"));
-}
 async function readOptionalJson(path) {
     try {
-        return await readJson(path);
+        return JSON.parse(await readFile(path, "utf8"));
     }
     catch (error) {
         if (isNodeError(error) && error.code === "ENOENT")
@@ -209,6 +120,7 @@ async function readOptionalJson(path) {
         throw error;
     }
 }
+/** Atomic publish: write a temporary file, then rename over the target. */
 async function publishJson(path, value) {
     await mkdir(dirname(path), { recursive: true, mode: 0o700 });
     const temporary = `${path}.${randomUUID()}.tmp`;
@@ -216,58 +128,7 @@ async function publishJson(path, value) {
         encoding: "utf8",
         mode: 0o600,
     });
-    await syncFile(temporary);
     await rename(temporary, path);
-    await syncDirectory(dirname(path));
-}
-async function publishImmutableJson(path, value) {
-    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
-    const existing = await readOptionalJson(path);
-    if (existing !== null) {
-        if (!isDeepStrictEqual(existing, value))
-            throw new Error("Immutable play-advance fact already has different data");
-        return;
-    }
-    const temporary = `${path}.${randomUUID()}.tmp`;
-    await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, {
-        encoding: "utf8",
-        mode: 0o600,
-    });
-    await syncFile(temporary);
-    try {
-        await link(temporary, path);
-    }
-    catch (error) {
-        if (!isNodeError(error) || error.code !== "EEXIST")
-            throw error;
-        const published = await readJson(path);
-        if (!isDeepStrictEqual(published, value))
-            throw new Error("Concurrent immutable play-advance fact conflicts", {
-                cause: error,
-            });
-    }
-    finally {
-        await rm(temporary, { force: true });
-    }
-    await syncDirectory(dirname(path));
-}
-async function syncFile(path) {
-    const handle = await open(path, "r");
-    try {
-        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();
-    }
 }
 function isNodeError(error) {
     return error instanceof Error && "code" in error;

package/dist/node/runtime/play/FileNativePlayPresetStore.js

@@ -3,7 +3,7 @@ export { validatePlayPresetArtifactPayload } from "../../shared/artifact-payload
 import { defaultFollowupItems, } from "../../shared/ordered-followups.js";
 import { parseFollowupItems } from "./OrderedFollowups.js";
 import { builtinAuthorPrompts, defaultOrderedAuthorPrompts, } from "../../shared/ordered-author-prompts.js";
-import { parseOrderedPlayPrompts, migrateLegacyPlayPrompts, } from "./OrderedPlayPrompts.js";
+import { parseOrderedPlayPrompts, migrateLegacyPlayPrompts, withTabletopPromptBuiltins, } from "./OrderedPlayPrompts.js";
 import { defaultOrderedPlayPrompts, } from "../../shared/ordered-play-prompts.js";
 import { createHash, randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
@@ -203,12 +203,17 @@ export class FileNativePlayPresetStore {
         };
         this.#locale = options.locale ?? (() => defaultAppLocale);
     }
+    /**
+     * Startup is the only place that upgrades stored presets. Reads never write:
+     * list, bind and freeze observe the library as it was last saved.
+     */
     async initialize() {
         await this.#change(async () => {
             const document = await this.#read();
             const migrated = this.#markLegacyBuiltinDefault(document);
             const synchronized = this.#synchronizeBuiltinDefault(document);
-            if (migrated || synchronized)
+            const tabletop = this.#migrateTabletopPromptBuiltins(document);
+            if (migrated || synchronized || tabletop)
                 await this.#write(document);
         });
     }
@@ -452,7 +457,8 @@ export class FileNativePlayPresetStore {
             .map((path) => ({ path, contents: binding.files[path] }));
     }
     async importPortable(input) {
-        const files = toFileMap(input.files, this.#limits);
+        // A released preset gains the tabletop builtins at import, as at upgrade.
+        const files = withTabletopPromptBuiltins(toFileMap(input.files, this.#limits));
         const parsed = parsePlayPresetFiles(files, this.#limits);
         if (parsed.kind === "invalid")
             throw parsed.error;
@@ -561,6 +567,45 @@ export class FileNativePlayPresetStore {
         preset.builtinDefault = true;
         return true;
     }
+    /**
+     * One-time upgrade for ordered presets saved before the tabletop builtins
+     * existed. An affected revision is replaced by a new revision that inserts
+     * them; the old revision stays for frozen requests. A pending draft gets the
+     * same insertion, because a draft that kept the old list would fail the
+     * builtin-retention rule on save. The library is one atomically written file,
+     * so an interrupted upgrade leaves the released bytes and reruns cleanly.
+     */
+    #migrateTabletopPromptBuiltins(document) {
+        let changed = false;
+        for (const stored of document.presets) {
+            const current = stored.revisions[stored.currentRevision];
+            if (current !== undefined) {
+                const migrated = withTabletopPromptBuiltins(current);
+                if (migrated !== current) {
+                    const revision = revisionForFiles(migrated, this.#limits);
+                    stored.revisions[revision] = cloneFiles(migrated);
+                    stored.currentRevision = revision;
+                    changed = true;
+                }
+            }
+            const draft = stored.draftRevision === undefined
+                ? undefined
+                : stored.revisions[stored.draftRevision];
+            if (draft !== undefined) {
+                const migrated = withTabletopPromptBuiltins(draft);
+                if (migrated !== draft) {
+                    const revision = revisionForFiles(migrated, this.#limits);
+                    stored.revisions[revision] = cloneFiles(migrated);
+                    if (revision === stored.currentRevision)
+                        delete stored.draftRevision;
+                    else
+                        stored.draftRevision = revision;
+                    changed = true;
+                }
+            }
+        }
+        return changed;
+    }
     #synchronizeBuiltinDefault(document) {
         const preset = document.presets.find(({ builtinDefault }) => builtinDefault === true);
         if (preset === undefined || preset.draftRevision !== undefined)