narraeon 0.7.4 → 0.7.6

package/dist/node/runtime/world-revision/WorldRevisionAuthoringTransaction.js

@@ -1,89 +1,46 @@
 import { isPackageFollowupControlPath } from "../content/PackageFollowups.js";
-import { defaultAppLocale } from "../../protocol/appPreferences.js";
 import { assertSameGameplay, gameplayPath, readGameplay, } from "../../protocol/gameplay.js";
 import { inspectContentPackageCurrentTree } from "../content/FileNativeContentTree.js";
-import { SettingAuthoringTransaction, settingImprovementToolDefinitions, } from "../setting/SettingAuthoringTransaction.js";
+import { authoringToolDefinitions, SettingAuthoringTransaction, worldRevisionAuthoringSurface, } from "../setting/SettingAuthoringTransaction.js";
 import { WorldDocumentStore } from "../world/WorldDocumentStore.js";
-const syntheticOpening = {
-    path: "opening.md",
-    contents: "# Existing world\n\nThe genesis opening is immutable in a world revision.\n",
-};
-const settingToRevisionTool = new Map([
-    ["setting_list", "world_revision_list"],
-    ["setting_search", "world_revision_search"],
-    ["setting_read", "world_revision_read"],
-    ["setting_create", "world_revision_create"],
-    ["setting_write_file", "world_revision_write_file"],
-    ["setting_patch", "world_revision_patch"],
-    ["setting_move", "world_revision_move"],
-    ["setting_delete", "world_revision_delete"],
-]);
-const revisionToSettingTool = new Map([...settingToRevisionTool].map(([setting, revision]) => [revision, setting]));
 /**
- * Adapter that reuses the content-package authoring mechanics while exposing
- * the current world's state/control worktree as its own logical target.
+ * The authoring transaction over a playing world's state/control worktree.
+ * Its namespace, tool names and wording come from the world-revision surface,
+ * so nothing it returns is rewritten after the transaction renders it.
  */
 export class WorldRevisionAuthoringTransaction {
     #inner;
-    #locale;
     constructor(input) {
-        this.#locale = input.locale ?? defaultAppLocale;
         this.#inner = new SettingAuthoringTransaction({
-            baseFiles: toProjectedFiles(input.baseFiles),
-            locale: this.#locale,
+            baseFiles: input.baseFiles,
+            surface: worldRevisionAuthoringSurface,
+            ...(input.locale === undefined ? {} : { locale: input.locale }),
             ...(input.revision === undefined ? {} : { revision: input.revision }),
             ...(input.authorization === undefined
                 ? {}
                 : { authorization: input.authorization }),
-            validateFiles: (files) => {
-                const candidate = fromProjectedFiles(files);
-                assertUsableWorldRevisionFiles(candidate, input.immutableBaseFiles);
-            },
+            validateFiles: (files) => assertUsableWorldRevisionFiles(files, input.immutableBaseFiles),
             preview: (snapshot) => input.preview(WorldDocumentStore.open({
                 layout: "world_state",
-                files: fromProjectedFiles(snapshot.files),
+                files: [...snapshot.files].sort((left, right) => left.path.localeCompare(right.path)),
             })),
         });
     }
     files() {
-        return fromProjectedFiles(this.#inner.files());
+        return this.#inner.files();
     }
     review() {
-        return mapReview(this.#inner.review());
+        return this.#inner.review();
     }
     authorization(revision) {
         return this.#inner.authorization(revision);
     }
     execute(calls) {
-        const mapped = calls.map(mapToolCall);
-        const executed = this.#inner.execute(mapped.flatMap((item) => ("call" in item ? [item.call] : [])));
-        let executedIndex = 0;
-        return mapped.map((item, index) => {
-            if ("error" in item)
-                return rejectedToolResult(calls[index].id, item.error, this.#locale);
-            const result = executed[executedIndex++];
-            if (result === undefined)
-                throw new Error("World-revision authoring returned no tool result");
-            return {
-                ...result,
-                markdown: publicWorldRevisionMarkdown(result.markdown),
-                changes: result.changes.map(mapDiff),
-            };
-        });
+        return this.#inner.execute(calls);
     }
 }
 export function worldRevisionToolDefinitions(locale, gameplay) {
-    return settingImprovementToolDefinitions(locale, gameplay).map((definition) => {
-        const name = settingToRevisionTool.get(definition.name);
-        if (name === undefined)
-            throw new Error(`Unsupported setting authoring tool: ${definition.name}`);
-        return {
-            ...structuredClone(definition),
-            name,
-            description: publicWorldRevisionMarkdown(definition.description),
-            inputSchema: mapSchema(definition.inputSchema),
-        };
-    });
+    return authoringToolDefinitions(worldRevisionAuthoringSurface, locale, gameplay);
 }
 export function worldRevisionRuntimeContract(locale, gameplay) {
     // A world's mode and scheme are fixed, so only tabletop worlds mention the file.
@@ -170,21 +127,17 @@ export function inspectWorldRevisionFiles(files, immutableBaseFiles) {
                 message: "An existing world-state document must keep its document ID and short reference",
             });
     }
-    const projected = files.map((file) => ({
-        ...structuredClone(file),
-        path: file.path.startsWith("state/")
-            ? `world/${file.path.slice("state/".length)}`
-            : file.path,
-    }));
-    const inspection = inspectContentPackageCurrentTree(projected, {
+    const inspection = inspectContentPackageCurrentTree(files, {
         requireOpening: false,
+        worldDocumentSnapshot: WorldDocumentStore.open({
+            layout: "world_revision",
+            files,
+        }),
     });
     if (inspection.status !== "usable")
         diagnostics.push(...inspection.issues.map(({ code, path, message }) => ({
             code,
-            path: path.startsWith("world/")
-                ? `state/${path.slice("world/".length)}`
-                : path,
+            path,
             message,
         })));
     return {
@@ -223,178 +176,6 @@ export function assertUsableWorldRevisionFiles(files, immutableBaseFiles) {
             .map(({ path, message }) => `${path}: ${message}`)
             .join("; "));
 }
-function toProjectedFiles(files) {
-    return [
-        syntheticOpening,
-        ...files.map((file) => ({
-            ...structuredClone(file),
-            path: file.path.startsWith("state/")
-                ? `world/${file.path.slice("state/".length)}`
-                : file.path,
-        })),
-    ];
-}
-function fromProjectedFiles(files) {
-    const opening = files.find(({ path }) => path === "opening.md");
-    if (opening?.contents !== syntheticOpening.contents ||
-        opening.encoding !== undefined)
-        throw new Error("opening.md is immutable in a world revision");
-    return files
-        .filter(({ path }) => path !== "opening.md")
-        .map((file) => ({
-        ...structuredClone(file),
-        path: file.path.startsWith("world/")
-            ? `state/${file.path.slice("world/".length)}`
-            : file.path,
-    }))
-        .sort((left, right) => left.path.localeCompare(right.path));
-}
-function mapToolCall(call) {
-    const name = revisionToSettingTool.get(call.name);
-    if (name === undefined)
-        return {
-            call: { ...structuredClone(call), name: `unsupported:${call.name}` },
-        };
-    const args = isRecord(call.arguments)
-        ? structuredClone(call.arguments)
-        : call.arguments;
-    if (isRecord(args)) {
-        for (const field of [
-            "path",
-            "directory",
-            "within",
-            "from",
-            "to",
-            "document",
-        ])
-            if (typeof args[field] === "string") {
-                if (args[field] === "opening.md")
-                    return { error: "opening" };
-                if (args[field] === "world" || args[field].startsWith("world/"))
-                    return { error: "namespace" };
-                args[field] = toProjectedPath(args[field]);
-            }
-    }
-    return {
-        call: { ...structuredClone(call), name, arguments: args },
-    };
-}
-function toProjectedPath(path) {
-    if (path === "state")
-        return "world";
-    return path.startsWith("state/")
-        ? `world/${path.slice("state/".length)}`
-        : path;
-}
-function mapDiff(diff) {
-    return {
-        ...structuredClone(diff),
-        path: diff.path.startsWith("world/")
-            ? `state/${diff.path.slice("world/".length)}`
-            : diff.path,
-    };
-}
-function mapReview(review) {
-    return {
-        ...structuredClone(review),
-        diff: review.diff.filter(({ path }) => path !== "opening.md").map(mapDiff),
-        diagnostics: review.diagnostics.map((diagnostic) => ({
-            ...diagnostic,
-            path: diagnostic.path.startsWith("world/")
-                ? `state/${diagnostic.path.slice("world/".length)}`
-                : diagnostic.path,
-        })),
-        playCoverage: review.playCoverage === null
-            ? null
-            : {
-                ...structuredClone(review.playCoverage),
-                changed: review.playCoverage.changed
-                    .filter(({ path }) => path !== "opening.md")
-                    .map((item) => ({ ...item, path: mapPublicPath(item.path) })),
-            },
-    };
-}
-function mapPublicPath(path) {
-    return path.startsWith("world/")
-        ? `state/${path.slice("world/".length)}`
-        : path;
-}
-function publicWorldRevisionMarkdown(markdown) {
-    let fenced = false;
-    let documentBody = false;
-    let opaqueBody = false;
-    return markdown
-        .split("\n")
-        .flatMap((line) => {
-        if (line.trim() === "[body]") {
-            documentBody = true;
-            return [line];
-        }
-        if (line.trim() === "[/body]") {
-            documentBody = false;
-            return [line];
-        }
-        if (line.trimStart().startsWith("```")) {
-            fenced = !fenced;
-            return [line];
-        }
-        if (line.startsWith("# Special-file source ") ||
-            line.startsWith("# 专用文件原文 "))
-            opaqueBody = true;
-        else if (opaqueBody && line === "---")
-            opaqueBody = false;
-        if (fenced ||
-            documentBody ||
-            (opaqueBody &&
-                !line.startsWith("# Special-file source ") &&
-                !line.startsWith("# 专用文件原文 ")) ||
-            /^\s+"/u.test(line))
-            return [line];
-        const mapped = line
-            .replaceAll("setting_", "world_revision_")
-            .replaceAll("content package", "world revision")
-            .replaceAll("Content package", "World revision")
-            .replaceAll("内容包当前树", "世界修订工作树")
-            .replaceAll("内容包", "世界修订")
-            .replaceAll("opening and control", "control")
-            .replaceAll("opening/control", "control")
-            .replaceAll("opening.md, ", "")
-            .replaceAll("opening 和 control", "control")
-            .replaceAll("opening.md、", "")
-            .replaceAll("world/", "state/");
-        return /^- \[(?:special|binary)\] opening\.md$/u.test(mapped.trim())
-            ? []
-            : [mapped];
-    })
-        .join("\n");
-}
-function rejectedToolResult(toolCallId, error, locale) {
-    const message = error === "opening"
-        ? locale === "zh-CN"
-            ? "世界创建后 opening.md 已成为不可变创世叙事。请改写 state/* 或 control/*。"
-            : "opening.md is immutable after a world has been created. Edit state/* or control/* instead."
-        : locale === "zh-CN"
-            ? "世界修订只公开 state/* 与 control/* 逻辑路径；不能使用内容包的 world/* 命名空间。"
-            : "World revision exposes only state/* and control/* logical paths; the content-package world/* namespace is unavailable.";
-    return {
-        toolCallId,
-        markdown: `# Runtime tool rejected\n\n${message}`,
-        isError: true,
-        changes: [],
-    };
-}
-function mapSchema(schema) {
-    const map = (value) => {
-        if (typeof value === "string")
-            return value.replaceAll("world", "state");
-        if (Array.isArray(value))
-            return value.map(map);
-        if (!isRecord(value))
-            return value;
-        return Object.fromEntries(Object.entries(value).map(([key, child]) => [key, map(child)]));
-    };
-    return map(schema);
-}
 function isWritableWorldRevisionPath(path) {
     if (/^state\/.+\.(?:ya?ml|md)$/u.test(path))
         return true;
@@ -404,6 +185,3 @@ function isWritableWorldRevisionPath(path) {
         path === "control/player-views.yaml" ||
         /^control\/blocks\/.+\.md$/u.test(path));
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}

package/dist/node/runtime/world-revision/WorldRevisionWorkspace.js

@@ -190,25 +190,18 @@ export class WorldRevisionWorkspace {
                 layout: "world_state",
                 files: epoch.files,
             }));
-            const outcome = await this.#worlds.commitCorrection({
+            // state 与 control 的改动是同一轮 revision_apply：要么整轮成立，要么整轮不存在（#102 的账本恢复）。
+            const outcome = await this.#worlds.commitWorldRevisionApply({
                 ...(worldClock === undefined ? {} : { worldClock }),
                 operationId: epoch.apply.operationId,
                 worldId: epoch.worldId,
                 parentHead: epoch.baseHead,
                 nextMaterials: binding.additionalMaterials,
                 stateChanges: stateChanges(epoch.baseFiles, epoch.files),
+                control: controlFiles(epoch.files),
                 worldRevisionLock: handle,
-                validationControl: controlFiles(epoch.files),
             });
-            epoch = await this.#recordStateCommit(handle, outcome);
-        }
-        if (epoch.apply?.phase === "state_committed") {
-            await this.#worlds.replaceWorldRevisionControl({
-                handle,
-                expectedFingerprint: epoch.baseControlFingerprint,
-                files: controlFiles(epoch.files),
-            });
-            await this.#recordControlPublication(handle);
+            await this.#recordCommit(handle, outcome);
         }
         epoch = await this.#finishApply(handle);
         await this.#worlds.releaseWorldRevisionLock(handle);
@@ -309,7 +302,7 @@ export class WorldRevisionWorkspace {
             if (epoch.lifecycle !== "applying" || epoch.apply === null)
                 throw new WorldRevisionWorkspaceError("Apply recovery state is damaged");
             epoch.lifecycle = "applied";
-            epoch.apply.phase = "control_published";
+            epoch.apply.phase = "committed";
             epoch.apply.committedHead = epoch.baseHead;
             epoch.finishedAt = Date.now();
             epoch.updatedAt = epoch.finishedAt;
@@ -317,34 +310,22 @@ export class WorldRevisionWorkspace {
             return epoch;
         });
     }
-    async #recordStateCommit(handle, outcome) {
+    async #recordCommit(handle, outcome) {
         return this.#withRevisionOwnership(handle, async () => {
             const epoch = await this.#store.readEpoch(handle.epochId);
             if (epoch.lifecycle !== "applying" || epoch.apply === null)
                 throw new WorldRevisionWorkspaceError("Apply recovery state is damaged");
-            epoch.apply.phase = "state_committed";
+            epoch.apply.phase = "committed";
             epoch.apply.committedHead = outcome.head;
             epoch.updatedAt = Date.now();
             await this.#store.saveEpoch(epoch);
             return epoch;
         });
     }
-    async #recordControlPublication(handle) {
-        return this.#withRevisionOwnership(handle, async () => {
-            const epoch = await this.#store.readEpoch(handle.epochId);
-            if (epoch.lifecycle !== "applying" || epoch.apply === null)
-                throw new WorldRevisionWorkspaceError("Apply recovery state is damaged");
-            epoch.apply.phase = "control_published";
-            epoch.updatedAt = Date.now();
-            await this.#store.saveEpoch(epoch);
-            return epoch;
-        });
-    }
     async #finishApply(handle) {
         return this.#withRevisionOwnership(handle, async () => {
             const epoch = await this.#store.readEpoch(handle.epochId);
-            if (epoch.lifecycle !== "applying" ||
-                epoch.apply?.phase !== "control_published")
+            if (epoch.lifecycle !== "applying" || epoch.apply?.phase !== "committed")
                 throw new WorldRevisionWorkspaceError("Apply recovery state is damaged");
             epoch.lifecycle = "applied";
             epoch.finishedAt = Date.now();

package/dist/node/server/createServer.js

@@ -273,8 +273,5 @@ function isPlayCallChainView(value) {
             value.status === "interrupted"));
 }
 function hasPlayCancellation(value) {
-    if (!isRecord(value) || !Array.isArray(value.events))
-        return false;
-    const last = value.events.at(-1);
-    return isRecord(last) && last.kind === "cancellation";
+    return isRecord(value) && value.lastCancelled === true;
 }

package/dist/node/shared/ordered-play-prompts.js

@@ -16,6 +16,11 @@ export function isPromptGroup(value) {
 /** Soft limits for the turn guide; exceeding them warns without rejecting. */
 export const turnGuideLineSoftLimit = 120;
 export const turnGuideLinesSoftLimit = 10;
+/** One turn-guide line: no line breaks, bounded length; empty clears a builtin default. */
+const turnGuideLinePattern = /^[^\r\n\0]{0,1000}$/u;
+export function isTurnGuideLine(value) {
+    return turnGuideLinePattern.test(value);
+}
 /**
  * Unscoped prompts always apply. A scoped prompt applies only when the compiled
  * world or package is tabletop, so fiction requests never see it.

package/dist/node/shared/turn-guide.js

@@ -1,12 +1,37 @@
 import { turnGuideLineSoftLimit, turnGuideLinesSoftLimit, } from "./ordered-play-prompts.js";
+/** The source of the player's one-turn request line. */
+export const turnNoteSource = "player:turn";
 /**
  * The fixed Runtime header. It is mechanical: it tells the model what the
  * suffix is and that the prose, not a reply to the suffix, is wanted.
  */
 export function turnGuideHeader(locale) {
     return locale === "zh-CN"
-        ? "[Runtime 本轮提示]\n以下是本轮写正文时最容易丢的要求，不要回应本提示，直接写正文。"
-        : "[Runtime turn guide]\nThese are the requirements most easily lost while writing this turn's prose. Do not reply to this notice; write the prose.";
+        ? "[Runtime 本轮提示]\n以下是对这一轮正文的提示，来自预设、世界设定和玩家的临时要求。不要回应本提示，直接写正文。"
+        : "[Runtime turn guide]\nThese are notes for this turn's prose, from the preset, the world, and the player's requests for this turn. Do not reply to this notice; write the prose.";
+}
+/**
+ * The player's one-turn request as a turn-guide line. The prefix only names
+ * the source; it adds no constraint of its own.
+ */
+export function turnNoteLine(locale, turnNote) {
+    return {
+        source: turnNoteSource,
+        text: locale === "zh-CN"
+            ? `玩家本轮要求：${turnNote}`
+            : `Player's request for this turn: ${turnNote}`,
+    };
+}
+/**
+ * Appends the player's request line to a compiled turn guide, creating the
+ * suffix when no preset or world line exists. Without a request the guide is
+ * returned unchanged.
+ */
+export function turnGuideWithTurnNote(locale, guide, turnNote) {
+    if (turnNote === undefined)
+        return guide;
+    const lines = [...(guide?.lines ?? []), turnNoteLine(locale, turnNote)];
+    return { text: turnGuideText(locale, lines), lines };
 }
 /** The complete suffix text: header, then one line per enabled entry in list order. */
 export function turnGuideText(locale, lines) {