narraeon 0.5.7 → 0.6.1

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

@@ -1,62 +1,33 @@
+import { isResolutionReceipt } from "../../protocol/resolution.js";
 import { legacyModelBindingFailure, projectLegacyModelBindingFailure, } from "./LegacyModelBindingFailure.js";
 import { isPlayFailureKind, } from "../../protocol/playFailure.js";
 import { isNarrativeOrigin, } from "../history/HistoryBackground.js";
 import { encodePlayPromptRun, decodePlayPromptRun, } from "./PlayPromptRun.js";
 import { createHash, randomUUID } from "node:crypto";
-import { link, mkdir, open, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { constants } from "node:fs";
+import { chmod, copyFile, mkdir, readFile, rename, rm, writeFile, } from "node:fs/promises";
+import { linkExclusive } from "../FileNativeExclusiveLink.js";
 import { dirname, join, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
-import { cloneFilePhysically } from "../FileNativePhysicalClone.js";
 export class FileNativePlayTimelineStore {
     #worldsRoot;
     constructor(dataRoot) {
         this.#worldsRoot = join(resolve(dataRoot), "worlds-file-native");
     }
-    /**
-     * Convert the cumulative call-chain record written by every released
-     * Narraeon version through v0.1.1 into immutable context segments. The
-     * source digest makes interrupted retries reproduce the same generation and
-     * identities; callers publish the world-wide storage marker only after this
-     * method has completed.
-     */
-    async migrateReleasedRecord(worldId, value, sourceDigest) {
-        assertIdentity(worldId, "World ID");
-        if (!/^[a-f0-9]{64}$/u.test(sourceDigest))
-            throw new TypeError("Released call-chain source digest is invalid");
-        assertReleasedPersistedPlayCallChain(value, worldId);
-        const contexts = [
-            ...(value.previousContexts ?? []).map((context) => structuredClone(context)),
-            releasedCurrentContext(value),
-        ];
-        const seen = new Set();
-        const generation = `released:${sourceDigest}`;
-        let previousChainId = null;
-        for (const context of contexts) {
-            assertIdentity(context.chainId, "Call-chain ID");
-            if (seen.has(context.chainId))
-                throw new Error("Released play-call-chain contexts contain a duplicate identity");
-            seen.add(context.chainId);
-            await this.persist({
-                ...structuredClone(context),
-                events: context.events.map(normalizePlayEvent),
-                schemaVersion: 3,
-                kind: "play_call_chain",
-                worldId,
-                previousChainId,
-                timelineGeneration: generation,
-                documentAuthorizationCheckpoints: structuredClone(context.documentAuthorizationCheckpoints ?? []),
-            });
-            previousChainId = context.chainId;
-        }
-        const migrated = await this.readAllContexts(worldId);
-        if (migrated.length !== contexts.length ||
-            migrated.some((context, index) => context.chainId !== contexts[index]?.chainId))
-            throw new Error("Released play-call-chain migration did not reproduce its context chain");
-    }
     async persist(value, cursor) {
         return this.#persistAtRuntimeRoot(this.#worldRuntimeRoot(value.worldId), value, cursor);
     }
     /** Write a sealed context segment without making it the active timeline. */
+    /** Physically remove the segments of contexts a rewind discarded. */
+    async discardContexts(worldId, chainIds) {
+        for (const chainId of chainIds) {
+            assertIdentity(chainId, "Call-chain ID");
+            await rm(this.#contextRoot(worldId, chainId), {
+                recursive: true,
+                force: true,
+            });
+        }
+    }
     async persistDetached(value, cursor) {
         return this.#persistAtRuntimeRoot(this.#worldRuntimeRoot(value.worldId), value, cursor, false);
     }
@@ -72,7 +43,6 @@ export class FileNativePlayTimelineStore {
         const transcriptCount = prefixLength(input.source.transcript, input.target.transcript);
         const eventCount = prefixLength(input.source.events, input.target.events);
         const completedToolCount = prefixLength(input.source.completedTools, input.target.completedTools);
-        const authorizationCheckpointCount = prefixLength(input.source.documentAuthorizationCheckpoints ?? [], input.target.documentAuthorizationCheckpoints ?? []);
         if (input.retainCompleteContext ||
             input.target.events.some((event) => event.kind === "assistant" && event.status === "completed")) {
             const encoding = await this.readInitialEncoding(input.sourceWorldId, input.source.chainId).catch(() => null);
@@ -113,19 +83,11 @@ export class FileNativePlayTimelineStore {
                 count: completedToolCount,
                 immutable: true,
             }),
-            cloneNumberedPrefix({
-                sourceRoot,
-                targetRoot,
-                directory: "authorization",
-                count: authorizationCheckpointCount,
-                immutable: true,
-            }),
         ]);
         return this.persistStaged(input.targetWorldRoot, input.target, {
             transcriptCount,
             eventCount,
             completedToolCount,
-            authorizationCheckpointCount,
         });
     }
     async #persistAtRuntimeRoot(runtimeRoot, value, cursor, publishHead = true) {
@@ -155,7 +117,6 @@ export class FileNativePlayTimelineStore {
             eventCount: Math.min(supplied.eventCount, value.events.length),
             transcriptCount: Math.min(supplied.transcriptCount, value.transcript.length),
             completedToolCount: Math.min(supplied.completedToolCount, value.completedTools.length),
-            authorizationCheckpointCount: Math.min(supplied.authorizationCheckpointCount, value.documentAuthorizationCheckpoints?.length ?? 0),
         };
         const lastRequestDigest = value.lastRequest === null
             ? null
@@ -186,9 +147,6 @@ export class FileNativePlayTimelineStore {
         }
         for (let index = previous.completedToolCount; index < value.completedTools.length; index += 1)
             await publishImmutableJson(join(root, "completed-tools", numbered(index + 1)), value.completedTools[index]);
-        const checkpoints = value.documentAuthorizationCheckpoints ?? [];
-        for (let index = previous.authorizationCheckpointCount; index < checkpoints.length; index += 1)
-            await publishImmutableJson(join(root, "authorization", numbered(index + 1)), checkpoints[index]);
         const promptRuns = value.promptRuns ?? [];
         for (let index = supplied.promptRunCount ?? 0; index < promptRuns.length; index += 1) {
             await publishImmutableJson(join(root, "prompt-runs", numbered(index + 1)), encodePlayPromptRun(promptRuns[index]));
@@ -202,7 +160,6 @@ export class FileNativePlayTimelineStore {
             eventCount: value.events.length,
             transcriptCount: value.transcript.length,
             completedToolCount: value.completedTools.length,
-            authorizationCheckpointCount: checkpoints.length,
             promptRunCount: promptRuns.length,
             changedDocuments: structuredClone(value.changedDocuments),
             nextEventId: value.nextEventId,
@@ -227,7 +184,6 @@ export class FileNativePlayTimelineStore {
             eventCount: value.events.length,
             transcriptCount: value.transcript.length,
             completedToolCount: value.completedTools.length,
-            authorizationCheckpointCount: checkpoints.length,
             promptRunCount: promptRuns.length,
         };
     }
@@ -262,16 +218,14 @@ export class FileNativePlayTimelineStore {
         if (metadata === null)
             return null;
         const { index: indexValue, state: stateValue, root } = metadata;
-        const [baseValue, continuationValue, transcript, rawEvents, completedTools, checkpoints, promptRuns,] = await Promise.all([
+        const [baseValue, continuationValue, transcript, events, completedTools, promptRuns,] = await Promise.all([
             readJson(join(root, "base.json")),
             readJson(join(root, "continuations", `${stateValue.continuationDigest}.json`)),
             readNumbered(join(root, "transcript"), stateValue.transcriptCount),
             readNumberedValidated(join(root, "events"), stateValue.eventCount, assertPlayEvent),
             readNumbered(join(root, "completed-tools"), stateValue.completedToolCount),
-            readNumbered(join(root, "authorization"), stateValue.authorizationCheckpointCount),
             readNumbered(join(root, "prompt-runs"), stateValue.promptRunCount ?? 0).then((records) => records.map(decodePlayPromptRun)),
         ]);
-        const events = rawEvents.map(normalizePlayEvent);
         assertContextBase(baseValue);
         assertContextContinuation(continuationValue);
         if (baseValue.worldId !== worldId ||
@@ -334,7 +288,6 @@ export class FileNativePlayTimelineStore {
             transcript,
             events,
             completedTools,
-            documentAuthorizationCheckpoints: checkpoints,
             promptRuns,
             changedDocuments: structuredClone(stateValue.changedDocuments),
             nextMaterials: structuredClone(continuationValue.nextMaterials),
@@ -359,7 +312,6 @@ export class FileNativePlayTimelineStore {
                 eventCount: stateValue.eventCount,
                 transcriptCount: stateValue.transcriptCount,
                 completedToolCount: stateValue.completedToolCount,
-                authorizationCheckpointCount: stateValue.authorizationCheckpointCount,
                 promptRunCount: stateValue.promptRunCount ?? 0,
             },
         };
@@ -546,7 +498,7 @@ export class FileNativePlayTimelineStore {
         assertPlayEvent(event);
         if (event.id !== eventId)
             throw new Error("Play timeline event identity is inconsistent");
-        return projectLegacyModelBindingFailure(normalizePlayEvent(event));
+        return projectLegacyModelBindingFailure(event);
     }
     newGeneration() {
         return `timeline:${randomUUID()}`;
@@ -760,7 +712,6 @@ function emptyPersistenceCursor() {
         eventCount: 0,
         transcriptCount: 0,
         completedToolCount: 0,
-        authorizationCheckpointCount: 0,
     };
 }
 function numbered(index) {
@@ -829,7 +780,6 @@ function assertContextState(value) {
         !validCount(value.eventCount) ||
         !validCount(value.transcriptCount) ||
         !validCount(value.completedToolCount) ||
-        !validCount(value.authorizationCheckpointCount) ||
         (value.promptRunCount !== undefined && !validCount(value.promptRunCount)) ||
         !Array.isArray(value.changedDocuments) ||
         !validCount(value.nextEventId) ||
@@ -864,65 +814,6 @@ function assertTimelineHead(value) {
         typeof value.generation !== "string")
         throw new Error("Play timeline head has an invalid shape");
 }
-function assertReleasedPersistedPlayCallChain(value, worldId) {
-    if (!isRecord(value) ||
-        (value.schemaVersion !== 1 && value.schemaVersion !== 2) ||
-        value.kind !== "play_call_chain" ||
-        value.worldId !== worldId ||
-        !isReleasedPlayContext(value) ||
-        (value.previousContexts !== undefined &&
-            (!Array.isArray(value.previousContexts) ||
-                value.previousContexts.some((context) => !isReleasedPlayContext(context)))))
-        throw new Error("Released play-call-chain durable data has an invalid shape");
-}
-function isReleasedPlayContext(value) {
-    if (!isRecord(value))
-        return false;
-    if (typeof value.chainId !== "string" ||
-        typeof value.baselineHead !== "string" ||
-        (value.continuityContextId !== undefined &&
-            (typeof value.continuityContextId !== "string" ||
-                value.continuityContextId.length === 0)) ||
-        (value.baselineHistoryLength !== undefined &&
-            !validCount(value.baselineHistoryLength)) ||
-        typeof value.parentHead !== "string" ||
-        !validReleasedDerivedFrom(value.derivedFrom) ||
-        !validReleasedBranchedBeforePlayer(value.branchedBeforePlayer) ||
-        !isRecord(value.playPreset) ||
-        (value.followups !== undefined && !Array.isArray(value.followups)) ||
-        (value.playPresetScriptsEnabled !== undefined &&
-            typeof value.playPresetScriptsEnabled !== "boolean") ||
-        (value.modelBinding !== undefined &&
-            !validModelHostBinding(value.modelBinding)) ||
-        (value.status !== "ready" &&
-            value.status !== "running" &&
-            value.status !== "interrupted") ||
-        typeof value.canRetry !== "boolean" ||
-        !isRecord(value.bootstrap) ||
-        !Array.isArray(value.tools) ||
-        !Array.isArray(value.transcript) ||
-        !Array.isArray(value.events) ||
-        !Array.isArray(value.completedTools) ||
-        !Array.isArray(value.changedDocuments) ||
-        !Array.isArray(value.nextMaterials) ||
-        !validCount(value.nextEventId) ||
-        !validCount(value.exchange) ||
-        (value.lastRequest !== null && !isRecord(value.lastRequest)) ||
-        !validCount(value.lastRequestAttempt) ||
-        (value.lastFailure !== null && typeof value.lastFailure !== "string") ||
-        (value.lastFailureKind !== undefined &&
-            !isPlayFailureKind(value.lastFailureKind)) ||
-        typeof value.updatedAt !== "number")
-        return false;
-    try {
-        for (const event of value.events)
-            assertPlayEvent(event);
-    }
-    catch {
-        return false;
-    }
-    return validReleasedAuthorizationCheckpoints(value.documentAuthorizationCheckpoints, value.events);
-}
 function validModelHostBinding(value) {
     return (isRecord(value) &&
         (value.provider === "chat_completions" ||
@@ -945,54 +836,6 @@ function validModelHostBinding(value) {
             value.cacheStrategy === "explicit_cliproxyapi_message" ||
             value.cacheStrategy === "provider_managed"));
 }
-function validReleasedDerivedFrom(value) {
-    return (value === undefined ||
-        (isRecord(value) &&
-            typeof value.worldId === "string" &&
-            typeof value.chainId === "string" &&
-            typeof value.head === "string"));
-}
-function validReleasedBranchedBeforePlayer(value) {
-    return (value === undefined ||
-        (isRecord(value) &&
-            typeof value.worldId === "string" &&
-            typeof value.chainId === "string" &&
-            Number.isSafeInteger(value.eventId) &&
-            Number(value.eventId) > 0));
-}
-function validReleasedAuthorizationCheckpoints(value, events) {
-    if (value === undefined)
-        return true;
-    if (!Array.isArray(value) || value.length > 100_000)
-        return false;
-    const eventIds = new Set(events.flatMap((event) => isRecord(event) && Number.isSafeInteger(event.id) && Number(event.id) > 0
-        ? [Number(event.id)]
-        : []));
-    let previousEventId = -1;
-    for (const checkpoint of value) {
-        if (!isRecord(checkpoint) ||
-            Object.keys(checkpoint).length !== 2 ||
-            !Object.hasOwn(checkpoint, "afterEventId") ||
-            !Object.hasOwn(checkpoint, "authorization") ||
-            !Number.isSafeInteger(checkpoint.afterEventId) ||
-            Number(checkpoint.afterEventId) < 0 ||
-            Number(checkpoint.afterEventId) <= previousEventId ||
-            (Number(checkpoint.afterEventId) !== 0 &&
-                !eventIds.has(Number(checkpoint.afterEventId))) ||
-            !isRecord(checkpoint.authorization))
-            return false;
-        previousEventId = Number(checkpoint.afterEventId);
-    }
-    return true;
-}
-function releasedCurrentContext(value) {
-    const { schemaVersion: _schemaVersion, kind: _kind, worldId: _worldId, previousContexts: _previousContexts, ...context } = value;
-    void _schemaVersion;
-    void _kind;
-    void _worldId;
-    void _previousContexts;
-    return structuredClone(context);
-}
 function assertPlayEvent(value) {
     if (!isRecord(value) ||
         !Number.isSafeInteger(value.id) ||
@@ -1028,6 +871,9 @@ function assertPlayEvent(value) {
         return;
     }
     if (value.kind === "tool_result") {
+        if (value.resolution !== undefined &&
+            !isResolutionReceipt(value.resolution))
+            throw new Error("Invalid resolution receipt");
         if (typeof value.callId !== "string" ||
             typeof value.name !== "string" ||
             typeof value.ok !== "boolean" ||
@@ -1091,6 +937,9 @@ function assertTimelineEventSummary(value) {
         return;
     }
     if (value.kind === "tool_result") {
+        if (value.resolution !== undefined &&
+            !isResolutionReceipt(value.resolution))
+            throw new Error("Invalid resolution receipt");
         if (typeof value.callId !== "string" ||
             typeof value.name !== "string" ||
             typeof value.ok !== "boolean" ||
@@ -1133,43 +982,7 @@ function validOptionalString(value) {
     return value === undefined || typeof value === "string";
 }
 function validOptionalUsage(value) {
-    return (value === undefined ||
-        (isRecord(value) &&
-            validUsageToken(value.inputTokens) &&
-            validUsageToken(value.outputTokens) &&
-            (value.provenance === undefined || validFullUsage(value))));
-}
-/**
- * v0.1.1 stored only input/output usage. Keep that released shape readable,
- * but expose one current protocol projection with honest unavailable fields.
- */
-function normalizePlayEvent(event) {
-    if ((event.kind !== "assistant" && event.kind !== "followup") ||
-        event.usage === undefined ||
-        validFullUsage(event.usage))
-        return structuredClone(event);
-    const legacy = event.usage;
-    const unavailable = "unavailable";
-    const provider = (value) => value === null ? unavailable : "provider";
-    const usage = {
-        inputTokens: legacy.inputTokens,
-        uncachedInputTokens: null,
-        cacheReadTokens: null,
-        cacheWriteTokens: null,
-        reasoningTokens: null,
-        outputTokens: legacy.outputTokens,
-        totalTokens: null,
-        provenance: {
-            inputTokens: provider(legacy.inputTokens),
-            uncachedInputTokens: unavailable,
-            cacheReadTokens: unavailable,
-            cacheWriteTokens: unavailable,
-            reasoningTokens: unavailable,
-            outputTokens: provider(legacy.outputTokens),
-            totalTokens: unavailable,
-        },
-    };
-    return { ...structuredClone(event), usage };
+    return value === undefined || validFullUsage(value);
 }
 function validFullUsage(value) {
     if (!isRecord(value) || !isRecord(value.provenance))
@@ -1225,12 +1038,18 @@ async function cloneNumberedPrefix(input) {
         await cloneTimelineFile(join(input.sourceRoot, input.directory, numbered(index)), join(input.targetRoot, input.directory, numbered(index)), input.immutable);
 }
 async function cloneTimelineFile(source, target, immutable) {
-    await cloneFilePhysically({
-        source,
-        target,
-        immutable,
-        onTargetExists: assertSameFileBytes,
-    });
+    await mkdir(dirname(target), { recursive: true });
+    try {
+        await copyFile(source, target, constants.COPYFILE_EXCL);
+    }
+    catch (error) {
+        if (!isNodeError(error) || error.code !== "EEXIST")
+            throw error;
+        await assertSameFileBytes(source, target);
+        return;
+    }
+    if (immutable)
+        await chmod(target, 0o444);
 }
 async function assertSameFileBytes(source, target) {
     const [sourceBytes, targetBytes] = await Promise.all([
@@ -1272,9 +1091,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) {
     const contents = `${JSON.stringify(value, null, 2)}\n`;
@@ -1286,10 +1103,8 @@ async function publishImmutableJson(path, value) {
             flag: "wx",
             mode: 0o600,
         });
-        await syncFile(temporary);
         try {
-            await link(temporary, path);
-            await syncDirectory(dirname(path));
+            await linkExclusive(temporary, path);
         }
         catch (error) {
             if (!isNodeError(error) || error.code !== "EEXIST")
@@ -1304,21 +1119,3 @@ async function publishImmutableJson(path, value) {
         await rm(temporary, { force: true });
     }
 }
-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();
-    }
-}

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

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { parseDocument } from "yaml";
+import { isMap, isSeq, parseDocument } from "yaml";
 import { builtinPlayPrompts, isPromptMessageRole, } from "../../shared/ordered-play-prompts.js";
 /** The same strict permission gate is used by portable imports and structured saves. */
 export function parseOrderedPlayPrompts(value, catalog = builtinPlayPrompts("en"), worldRequired = true) {
@@ -24,20 +24,23 @@ export function parseOrderedPlayPrompts(value, catalog = builtinPlayPrompts("en"
             !isPromptMessageRole(item.messageRole))
             return fail();
         const messageRole = item.messageRole === undefined ? {} : { messageRole: item.messageRole };
-        const exact = (keys) => Object.keys(item).length ===
-            keys.length + (item.messageRole === undefined ? 0 : 1) &&
-            keys.every((key) => Object.hasOwn(item, key));
+        const exact = (keys, optional = []) => Object.keys(item).every((key) => keys.includes(key) ||
+            optional.includes(key) ||
+            key === "messageRole" ||
+            key === "id" ||
+            key === "kind") && keys.every((key) => Object.hasOwn(item, key));
         if (item.kind === "world" && exact(["id", "kind"])) {
             worlds++;
             return { id: item.id, kind: "world", ...messageRole };
         }
         if (item.kind === "user" &&
-            exact(["id", "kind", "name", "enabled", "body"]) &&
+            exact(["id", "kind", "name", "enabled", "body"], ["gameplay"]) &&
             typeof item.name === "string" &&
             item.name.trim().length > 0 &&
             /^[^\r\n\0]{1,160}$/u.test(item.name) &&
             typeof item.body === "string" &&
-            typeof item.enabled === "boolean")
+            typeof item.enabled === "boolean" &&
+            (item.gameplay === undefined || item.gameplay === "tabletop"))
             return {
                 id: item.id,
                 kind: "user",
@@ -45,6 +48,9 @@ export function parseOrderedPlayPrompts(value, catalog = builtinPlayPrompts("en"
                 enabled: item.enabled,
                 body: item.body,
                 ...messageRole,
+                ...(item.gameplay === "tabletop"
+                    ? { gameplay: "tabletop" }
+                    : {}),
             };
         const builtin = catalog.find((entry) => entry.id === item.builtin);
         if (item.kind !== "builtin" ||
@@ -70,6 +76,54 @@ export function parseOrderedPlayPrompts(value, catalog = builtinPlayPrompts("en"
         return fail();
     return entries;
 }
+/**
+ * Insert the tabletop builtins that an ordered preset does not list yet.
+ * play.tabletop goes just before the world placeholder and author.tabletop just
+ * after author.guidance. Files that are not ordered v2 or do not parse come back
+ * unchanged, and nothing else in them is rewritten. The same object is returned
+ * when nothing needs inserting, so callers can detect a change by identity.
+ */
+export function withTabletopPromptBuiltins(files) {
+    const source = files["preset.yaml"];
+    if (source === undefined)
+        return files;
+    const document = parseDocument(source, { uniqueKeys: true });
+    if (document.errors.length > 0 ||
+        document.warnings.length > 0 ||
+        !isMap(document.contents) ||
+        document.get("format") !== "narraeon.play-preset/v2")
+        return files;
+    let changed = false;
+    const playPrompts = document.get("playPrompts", true);
+    if (isSeq(playPrompts) && !hasEntry(playPrompts, "play.tabletop")) {
+        const world = playPrompts.items.findIndex((item) => entryField(item, "kind") === "world");
+        playPrompts.items.splice(world < 0 ? playPrompts.items.length : world, 0, document.createNode({
+            id: "play.tabletop",
+            kind: "builtin",
+            builtin: "play.tabletop",
+            enabled: true,
+        }));
+        changed = true;
+    }
+    const authorPrompts = document.get("authorPrompts", true);
+    if (isSeq(authorPrompts) && !hasEntry(authorPrompts, "author.tabletop")) {
+        const guidance = authorPrompts.items.findIndex((item) => entryField(item, "id") === "author.guidance");
+        authorPrompts.items.splice(guidance < 0 ? authorPrompts.items.length : guidance + 1, 0, document.createNode({
+            id: "author.tabletop",
+            kind: "builtin",
+            builtin: "author.tabletop",
+            enabled: true,
+        }));
+        changed = true;
+    }
+    return changed ? { ...files, "preset.yaml": document.toString() } : files;
+}
+function hasEntry(sequence, id) {
+    return sequence.items.some((item) => entryField(item, "id") === id);
+}
+function entryField(item, key) {
+    return isMap(item) ? item.get(key) : undefined;
+}
 /** Recognized v1 content becomes user text, never a locked builtin inferred from a path. */
 export function migrateLegacyPlayPrompts(files, narrative, excludedPaths = []) {
     const document = parseDocument(files["frame.yaml"] ?? "", {
@@ -185,5 +239,13 @@ export function migrateLegacyPlayPrompts(files, narrative, excludedPaths = []) {
         if ((path.startsWith("blocks/") || path.startsWith("prompts/")) &&
             path.endsWith(".md"))
             add(path, false);
+    // The tabletop builtin joins converted presets just before the world placeholder.
+    const worldIndex = entries.findIndex((entry) => entry.kind === "world");
+    entries.splice(worldIndex, 0, {
+        id: "play.tabletop",
+        kind: "builtin",
+        builtin: "play.tabletop",
+        enabled: true,
+    });
     return entries;
 }