narraeon 0.6.0 → 0.6.2

package/README.md

@@ -144,6 +144,13 @@ English is the default interface language. Switching to Simplified Chinese updat
 
 Existing content packages, worlds, imported presets, copied presets, and user-edited prompt files are not translated or rewritten automatically.
 
+## Android
+
+An experimental Android app runs the same backend inside the app process: a
+foreground service starts the embedded Node runtime, and a WebView opens
+`127.0.0.1:4317`. It supports `arm64-v8a` devices only. Build steps and the
+runtime layout are in [android/README.md](android/README.md).
+
 ## Local data and privacy
 
 Narraeon uses the operating system's standard per-user application directories. To isolate an instance or choose explicit locations, set these variables before startup:
@@ -165,6 +172,10 @@ When a provider, response-format, Runtime-tool, or candidate-check error occurs,
 
 Every Runtime request that fails, every play call that ends interrupted, and every failed live conversation sync is also appended to `NARRAEON_LOG_ROOT/runtime-errors/<UTC date>.jsonl` with the request type, its identifiers (world, context, event, and operation IDs), and the error message, code, stack, and cause chain. Player and world text from the request is not recorded. Include the matching line when reporting a bug.
 
+## Upgrading worlds
+
+Worlds written by v0.3.0 through v0.6.0 upgrade automatically the first time a current version opens them. Worlds written by v0.2.0 or earlier are not upgraded directly: open each one once with v0.3.0–v0.6.0, then open it with the current version. A world that cannot be upgraded is shown as unavailable and is not modified.
+
 ## Development
 
 ```bash

package/README.zh-CN.md

@@ -136,6 +136,10 @@ AI 设定完善只作用于内容包候选。在“先生成计划”的路径
 
 已有内容包、世界、导入预设、复制预设和用户编辑过的提示文件不会被自动翻译或重写。
 
+## Android
+
+实验性的 Android 应用在 App 进程内运行同一套后端：前台服务启动内嵌的 Node 运行时，WebView 打开 `127.0.0.1:4317`。目前只支持 `arm64-v8a` 设备。构建步骤与运行时目录结构见 [android/README.md](android/README.md)。
+
 ## 本地数据与隐私
 
 Narraeon 默认使用当前操作系统的标准用户应用目录。如果要隔离一份独立实例，或者自行指定存放位置，可在启动前设置：
@@ -155,6 +159,10 @@ Narraeon 默认使用当前操作系统的标准用户应用目录。如果要
 
 每个失败的 Runtime 请求、每次以中断结束的游玩调用、每次失败的对话实时同步，也会追加到 `NARRAEON_LOG_ROOT/runtime-errors/<UTC 日期>.jsonl`，记录请求类型、请求中的标识（世界、上下文、事件和操作 ID）以及错误信息、错误码、调用栈和 cause 链，不记录请求里的玩家原文和世界内容。反馈问题时附上对应的那一行即可。
 
+## 升级世界
+
+由 v0.3.0 至 v0.6.0 创建的世界会在当前版本第一次打开时自动升级。由 v0.2.0 及更早版本创建的世界不再直接升级：先用 v0.3.0–v0.6.0 各打开一次，再用当前版本打开。无法升级的世界会显示为不可打开，并且不会被修改。
+
 ## 仓库开发
 
 ```bash

package/dist/node/protocol/v1.js

@@ -68,6 +68,11 @@ const requiredFields = {
         continuation: "object",
     },
     "setting-improvement.cancel": { sessionId: "string" },
+    "setting-improvement.resume": {
+        packageId: "string",
+        sessionId: "string",
+        requestId: "string",
+    },
     "play.create": { name: "string" },
     "play.copy": { presetId: "string" },
     "play.save": { presetId: "string", name: "string", files: "object" },
@@ -98,7 +103,6 @@ const requiredFields = {
     "artifacts.read": { worldId: "string" },
     "artifacts.debug": { worldId: "string" },
     "world.creation-outcome": { operationId: "string" },
-    "world.repair-materialization": { worldId: "string" },
     "world.control-draft.save": { worldId: "string", files: "array" },
     "world.control-draft.preview": { worldId: "string" },
     "world.control-draft.apply": { worldId: "string" },
@@ -121,6 +125,11 @@ const requiredFields = {
         continuation: "object",
     },
     "world.revision.cancel": { sessionId: "string" },
+    "world.revision.resume": {
+        worldId: "string",
+        sessionId: "string",
+        requestId: "string",
+    },
     "world.revision.files.replace": {
         worldId: "string",
         epochId: "string",
@@ -423,6 +432,7 @@ const requestTypes = new Set([
     "setting-improvement.rollback",
     "setting-improvement.message",
     "setting-improvement.cancel",
+    "setting-improvement.resume",
     "play.read",
     "play.create",
     "play.copy",
@@ -446,7 +456,6 @@ const requestTypes = new Set([
     "artifacts.read",
     "artifacts.debug",
     "world.creation-outcome",
-    "world.repair-materialization",
     "world.control-draft.save",
     "world.control-draft.preview",
     "world.control-draft.apply",
@@ -458,6 +467,7 @@ const requestTypes = new Set([
     "world.revision.session.delete",
     "world.revision.message",
     "world.revision.cancel",
+    "world.revision.resume",
     "world.revision.files.replace",
     "world.revision.rollback",
     "world.revision.apply",

package/dist/node/runtime/FileNativeExclusiveLink.js

@@ -0,0 +1,39 @@
+import { constants } from "node:fs";
+import { copyFile, link } from "node:fs/promises";
+// Error codes that mean "hard links are unavailable here". Android app directories
+// return EACCES for link(), so that code is included.
+const linkFallbackCodes = new Set(["EPERM", "EACCES", "ENOTSUP", "EXDEV"]);
+/**
+ * Creates target as a new name for source, failing with EEXIST when target already
+ * exists. Uses a hard link where the filesystem allows it. Otherwise falls back to an
+ * exclusive byte copy, which also fails with EEXIST.
+ *
+ * Creation is exclusive in both paths. Content visibility is atomic only on the
+ * hard-link path: on the copy path a concurrent reader could in principle see a
+ * partially written target. This is acceptable under ADR-0044's single-process and
+ * per-world serial assumptions, because callers hold a process-local lock and
+ * readers only open targets after the creating call returns.
+ */
+export async function linkExclusive(source, target) {
+    const injectedErrorCode = process.env.NARRAEON_INTERNAL_TEST_LINK_ERROR_CODE;
+    try {
+        if (injectedErrorCode !== undefined) {
+            const error = new Error(`${injectedErrorCode}: injected hard link failure`);
+            error.code = injectedErrorCode;
+            throw error;
+        }
+        await link(source, target);
+    }
+    catch (error) {
+        if (!isFallbackError(error))
+            throw error;
+        await copyFile(source, target, constants.COPYFILE_EXCL);
+    }
+}
+function isFallbackError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        typeof error.code === "string" &&
+        linkFallbackCodes.has(error.code));
+}

package/dist/node/runtime/V1Runtime.js

@@ -383,6 +383,8 @@ export class V1Runtime {
                 return this.#settingImprovements.send(request);
             case "setting-improvement.cancel":
                 return this.#settingImprovements.cancel(request.sessionId);
+            case "setting-improvement.resume":
+                return this.#settingImprovements.resume(request);
             case "play.read":
                 return this.#playPresets.list();
             case "play.create":
@@ -496,6 +498,7 @@ export class V1Runtime {
             case "world.delete":
                 return playCall(async () => {
                     await this.#worlds.assertWorldRevisionUnlocked(request.worldId);
+                    await this.#playCallChains.abortWorld(request.worldId);
                     this.#playCallChains.forgetWorld(request.worldId);
                     return this.#worlds.deleteWorld(request.worldId);
                 });
@@ -576,11 +579,6 @@ export class V1Runtime {
             case "artifacts.debug":
                 await this.#reconcileArtifacts(request.worldId);
                 return this.#frontendDebug(request.worldId, request.operationId);
-            case "world.repair-materialization": {
-                const result = await this.#worlds.repairMaterialization(request.worldId);
-                await this.#reconcileArtifacts(request.worldId);
-                return result;
-            }
             case "world.control-draft.save":
                 await this.#worlds.assertWorldRevisionUnlocked(request.worldId);
                 return this.#worlds.saveControlDraft(request.worldId, request.files);
@@ -618,6 +616,8 @@ export class V1Runtime {
                 return this.#worldRevisionCall(() => this.#worldRevisions.send(request));
             case "world.revision.cancel":
                 return this.#worldRevisionCall(() => this.#worldRevisions.cancel(request.sessionId));
+            case "world.revision.resume":
+                return this.#worldRevisionCall(() => this.#worldRevisions.resume(request));
             case "world.revision.files.replace":
                 return this.#worldRevisionCall(() => this.#worldRevisions.replaceFiles(request));
             case "world.revision.rollback":

package/dist/node/runtime/archive/WorldArchives.js

@@ -1,12 +1,13 @@
 import { createHash, randomUUID } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { mkdir, open, readFile, readdir, rename, rm, stat, } from "node:fs/promises";
+import { mkdir, readFile, writeFile, readdir, rename, rm, stat, } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
 import { worldArchiveFormat, worldArchiveLimits, } from "../../protocol/worldArchives.js";
 import { FileNativeArtifactStore } from "../artifact/FileNativeArtifactStore.js";
 import { PlayCallChain } from "../play/PlayCallChain.js";
 import { FileNativePromptCompiler } from "../prompt/FileNativePromptCompiler.js";
-import { FileNativeAuthorityV3 } from "../world/FileNativeAuthorityV3.js";
+import { WorldLedgerAuthority } from "../world/WorldLedgerAuthority.js";
+import { forgetLedger } from "../world/WorldTurnLedger.js";
 import { FileNativeWorldStore, } from "../world/FileNativeWorldStore.js";
 import { archivePath, extractArchive, inventory, streamFile, writeArchive, WorldArchiveError, } from "./WorldArchiveZip.js";
 export class WorldArchives {
@@ -43,8 +44,6 @@ export class WorldArchives {
         const path = this.#uploadPath(uploadId);
         try {
             await streamFile(source, path, this.#limits.archiveBytes);
-            await syncFile(path);
-            crashAt("upload");
             return { uploadId };
         }
         catch (error) {
@@ -69,7 +68,6 @@ export class WorldArchives {
                     targetName: source.title,
                     publish: false,
                     targetWorldRoot: join(root, "world"),
-                    requireMaterialized: true,
                     resetPackageScriptPermissions: true,
                     retainCompleteTimeline: true,
                 });
@@ -84,7 +82,7 @@ export class WorldArchives {
                     exportedAt: new Date().toISOString(),
                     worldName: source.title,
                     archivedWorldId: fork.world.worldId,
-                    head: (await new FileNativeAuthorityV3(fork.worldRoot).readHead())
+                    head: (await new WorldLedgerAuthority(fork.worldRoot).readHead())
                         .head,
                     files,
                 };
@@ -152,7 +150,6 @@ export class WorldArchives {
                         published.worldId !== worldId)
                         throw new WorldArchiveError("integrity_failed", "Import publication does not match its operation");
                     await this.#worlds.ensureCurrentStorage(worldId);
-                    await durableJson(join(this.#dataRoot, "operations", `import-${createHash("sha256").update(input.operationId).digest("hex")}.json`), JSON.parse(await readFile(join(targetRoot, "publication.json"), "utf8")));
                     const world = await this.#worlds.readWorldSummary(worldId);
                     return { outcome: "imported", world };
                 }
@@ -166,7 +163,6 @@ export class WorldArchives {
                         });
                 const extracted = join(quarantine, "extracted");
                 await mkdir(extracted, { recursive: true, mode: 0o700 });
-                crashAt("quarantine");
                 let actual;
                 try {
                     actual = await extractArchive(upload, extracted, this.#limits);
@@ -176,7 +172,6 @@ export class WorldArchives {
                         throw new WorldArchiveError("invalid_archive", "Upload is missing; upload the ZIP again");
                     throw error;
                 }
-                crashAt("unpack");
                 if (!actual.has("narraeon-world.json"))
                     throw new WorldArchiveError("invalid_archive", "Archive manifest is missing");
                 let value;
@@ -196,6 +191,7 @@ export class WorldArchives {
                 }
                 const sourceRoot = join(quarantine, "worlds-file-native", manifest.archivedWorldId);
                 await mkdir(dirname(sourceRoot), { recursive: true });
+                forgetLedger(sourceRoot);
                 try {
                     await rename(join(extracted, "world"), sourceRoot);
                 }
@@ -214,18 +210,16 @@ export class WorldArchives {
                     if (publication?.worldId !== manifest.archivedWorldId)
                         throw new Error("Archive world identity mismatch");
                     await sourceWorlds.ensureCurrentStorage(manifest.archivedWorldId);
-                    const authority = new FileNativeAuthorityV3(sourceRoot);
-                    const history = await authority.readHistory();
-                    if (history.head !== manifest.head)
+                    // 结构校验：端点与清单一致，账本能倒推回 genesis；投影在分叉时重建。
+                    const authority = new WorldLedgerAuthority(sourceRoot);
+                    const head = await authority.readHead();
+                    if (head.head !== manifest.head)
                         throw new Error("Archive head mismatch");
-                    await authority.recover("genesis");
-                    for (const commit of history.commits)
-                        await authority.recover(commit.head);
+                    await authority.verifyStructure();
                 }
                 catch (error) {
                     throw new WorldArchiveError("integrity_failed", "Archive Authority failed its complete audit", { cause: error });
                 }
-                crashAt("audit");
                 const sourceChains = new PlayCallChain(sourceWorlds, new FileNativePromptCompiler(), new FileNativeArtifactStore(quarantine));
                 let result;
                 try {
@@ -244,7 +238,6 @@ export class WorldArchives {
                 catch (error) {
                     throw new WorldArchiveError("integrity_failed", "Archive world closure cannot be restored", { cause: error });
                 }
-                crashAt("publish");
                 return { outcome: "imported", world: result.world };
             }
             finally {
@@ -335,34 +328,14 @@ function archiveBaseName(name) {
         .replaceAll(/^[.-]+|[.-]+$/gu, "")
         .slice(0, 80) || "world");
 }
-async function syncFile(path) {
-    const file = await open(path, "r");
-    try {
-        await file.sync();
-    }
-    finally {
-        await file.close();
-    }
-}
 async function durableJson(path, value) {
     await mkdir(dirname(path), { recursive: true, mode: 0o700 });
     const temporary = `${path}.${randomUUID()}.tmp`;
-    const file = await open(temporary, "wx", 0o600);
-    try {
-        await file.writeFile(JSON.stringify(value));
-        await file.sync();
-    }
-    finally {
-        await file.close();
-    }
+    await writeFile(temporary, JSON.stringify(value), {
+        flag: "wx",
+        mode: 0o600,
+    });
     await rename(temporary, path);
-    const directory = await open(dirname(path), "r");
-    try {
-        await directory.sync();
-    }
-    finally {
-        await directory.close();
-    }
 }
 async function appVersion() {
     let directory = import.meta.dirname;
@@ -382,8 +355,3 @@ async function appVersion() {
         directory = parent;
     }
 }
-function crashAt(edge) {
-    if (process.env.NODE_ENV === "test" &&
-        process.env.NARRAEON_INTERNAL_TEST_CRASH_AT_WORLD_ARCHIVE_EDGE === edge)
-        process.exit(89);
-}

package/dist/node/runtime/artifact/ArtifactStoreFiles.js

@@ -0,0 +1,330 @@
+import { isWorldExtensionControl } from "../../protocol/worldExtensions.js";
+import { isFrozenArtifactPresentation } from "../play/FileNativePlayPresetStore.js";
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, open, rename, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+export class ArtifactStoreInvariantError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ArtifactStoreInvariantError";
+    }
+}
+export class ArtifactStoreCorruptionError extends ArtifactStoreInvariantError {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "ArtifactStoreCorruptionError";
+    }
+}
+export function artifactSequenceFileName(sequence) {
+    return `${String(sequence).padStart(12, "0")}.json`;
+}
+export function identityHash(value) {
+    return createHash("sha256").update(value, "utf8").digest("hex");
+}
+export function rawRecordFingerprint(record) {
+    const content = { ...record };
+    delete content.recordFingerprint;
+    return `sha256:${createHash("sha256").update(JSON.stringify(content)).digest("hex")}`;
+}
+export function payloadFingerprint(output, payload) {
+    return `sha256:${createHash("sha256").update(JSON.stringify({ output, payload })).digest("hex")}`;
+}
+export function stableSerialize(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
+    return `{${Object.keys(value)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stableSerialize(value[key])}`)
+        .join(",")}}`;
+}
+/** Heads are linear: genesis is round 0 and commit:N is round N. */
+export function headOrdinal(head) {
+    if (head === "genesis")
+        return 0;
+    const match = /^commit:([1-9][0-9]*)$/u.exec(head);
+    if (match === null)
+        throw new ArtifactStoreInvariantError("Artifact head is invalid");
+    return Number(match[1]);
+}
+/**
+ * Writes a JSON file by temporary file and rename. The temporary name is
+ * unique, so an interrupted write never leaves a partial file under `path`.
+ */
+export async function writeArtifactJson(path, value) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const target = `${path}.${randomUUID()}.tmp`;
+    let handle;
+    let created = false;
+    try {
+        handle = await open(target, "wx", 0o600);
+        created = true;
+        await handle.writeFile(JSON.stringify(value), "utf8");
+        await handle.close();
+        handle = undefined;
+        await rename(target, path);
+    }
+    catch (error) {
+        await handle?.close().catch(() => undefined);
+        if (created)
+            await rm(target, { force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+export function parseArtifactJson(bytes, label) {
+    try {
+        return JSON.parse(bytes);
+    }
+    catch (error) {
+        throw new ArtifactStoreCorruptionError(`${label} JSON is corrupt`, error instanceof Error ? { cause: error } : undefined);
+    }
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function hasExactKeys(value, required, optional = []) {
+    const allowed = new Set([...required, ...optional]);
+    return (required.every((key) => Object.hasOwn(value, key)) &&
+        Object.keys(value).every((key) => allowed.has(key)));
+}
+export function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim() !== "";
+}
+export function isSha256(value) {
+    return typeof value === "string" && /^sha256:[a-f0-9]{64}$/u.test(value);
+}
+export function isMissing(error) {
+    return isRecord(error) && error.code === "ENOENT";
+}
+export function isJsonValue(value) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (Array.isArray(value))
+        return value.every(isJsonValue);
+    if (typeof value !== "object")
+        return false;
+    return Object.values(value).every(isJsonValue);
+}
+export function validAttachment(value) {
+    return (isRecord(value) &&
+        hasExactKeys(value, ["contextId", "eventId", "runId", "head"]) &&
+        isNonEmptyString(value.head) &&
+        isNonEmptyString(value.contextId) &&
+        isNonEmptyString(value.runId) &&
+        typeof value.eventId === "number" &&
+        Number.isSafeInteger(value.eventId) &&
+        value.eventId > 0);
+}
+export function assertRawRecord(record) {
+    if (!isRecord(record) ||
+        !hasExactKeys(record, [
+            "schemaVersion",
+            "recordId",
+            "sequence",
+            "worldId",
+            "parentHead",
+            "head",
+            "operationId",
+            "playPresetId",
+            "playPresetRevision",
+            "playPresetScriptsEnabled",
+            "requestId",
+            "requestAttempt",
+            "output",
+            "channel",
+            "contentType",
+            "payload",
+            "save",
+            "projection",
+            "invalidation",
+            "toolCallId",
+            "toolName",
+            "callFingerprint",
+            "payloadFingerprint",
+            "recordFingerprint",
+            "status",
+        ], [
+            "key",
+            "renderer",
+            "rendererRevision",
+            "frozenPresentation",
+            "extensionControl",
+            "clearedBy",
+        ]) ||
+        (record.clearedBy !== undefined &&
+            !isClearedBy(record.clearedBy, record.status)) ||
+        (record.extensionControl !== undefined &&
+            !isWorldExtensionControl(record.extensionControl)) ||
+        (record.frozenPresentation !== undefined &&
+            !isFrozenArtifactPresentation(record.frozenPresentation)) ||
+        record.schemaVersion !== 1 ||
+        !isNonEmptyString(record.recordId) ||
+        !Number.isSafeInteger(record.sequence) ||
+        record.sequence < 1 ||
+        !isNonEmptyString(record.worldId) ||
+        !isNonEmptyString(record.operationId) ||
+        !isNonEmptyString(record.output) ||
+        !isNonEmptyString(record.channel) ||
+        !isNonEmptyString(record.parentHead) ||
+        !isNonEmptyString(record.playPresetId) ||
+        !isNonEmptyString(record.playPresetRevision) ||
+        !isNonEmptyString(record.requestId) ||
+        !Number.isSafeInteger(record.requestAttempt) ||
+        record.requestAttempt < 1 ||
+        (record.head !== null && !isNonEmptyString(record.head)) ||
+        typeof record.playPresetScriptsEnabled !== "boolean" ||
+        !["text/plain", "text/markdown", "application/json", "text/html"].includes(record.contentType) ||
+        !["none", "operation", "commit"].includes(record.save) ||
+        !["append", "replace", "upsert", "transient", "hidden"].includes(record.projection) ||
+        ![
+            "new_operation",
+            "head_change",
+            "operation_end",
+            "explicit_clear",
+            "never",
+        ].includes(record.invalidation) ||
+        !["pending", "active", "superseded", "cleared"].includes(record.status) ||
+        typeof record.toolCallId !== "string" ||
+        record.toolName !== "artifact_emit" ||
+        !isSha256(record.callFingerprint) ||
+        !isSha256(record.payloadFingerprint) ||
+        !isSha256(record.recordFingerprint) ||
+        (record.renderer === undefined) !==
+            (record.rendererRevision === undefined) ||
+        (record.renderer !== undefined && !isNonEmptyString(record.renderer)) ||
+        (record.rendererRevision !== undefined &&
+            !isNonEmptyString(record.rendererRevision)) ||
+        (record.projection === "upsert"
+            ? !isNonEmptyString(record.key)
+            : record.key !== undefined))
+        throw new ArtifactStoreCorruptionError("Artifact raw record is corrupt");
+    if (!isJsonValue(record.payload))
+        throw new ArtifactStoreCorruptionError("Artifact payload is not a JSON value");
+    if (record.payloadFingerprint !==
+        payloadFingerprint(record.output, record.payload))
+        throw new ArtifactStoreCorruptionError("Artifact payload fingerprint does not match");
+    if (record.recordFingerprint !== rawRecordFingerprint(record))
+        throw new ArtifactStoreCorruptionError("Artifact raw-record fingerprint does not match");
+}
+function isClearedBy(value, status) {
+    return (isRecord(value) &&
+        hasExactKeys(value, [
+            "operationId",
+            "requestId",
+            "requestAttempt",
+            "priorStatus",
+        ]) &&
+        status === "cleared" &&
+        isNonEmptyString(value.operationId) &&
+        isNonEmptyString(value.requestId) &&
+        Number.isSafeInteger(value.requestAttempt) &&
+        value.requestAttempt >= 1 &&
+        (value.priorStatus === "pending" || value.priorStatus === "active"));
+}
+export function assertOperation(operation) {
+    const context = operation.context;
+    if (!isRecord(operation) ||
+        !hasExactKeys(operation, [
+            "schemaVersion",
+            "context",
+            "status",
+            "extensionStatus",
+            "completedRequests",
+            "artifactProjectionStatus",
+            "requestAttempts",
+        ], ["message", "head", "requests"]) ||
+        (operation.requests !== undefined &&
+            (!Array.isArray(operation.requests) ||
+                !operation.requests.every((item) => isRecord(item) &&
+                    hasExactKeys(item, [
+                        "requestId",
+                        "displayName",
+                        "mounts",
+                        "status",
+                    ]) &&
+                    isNonEmptyString(item.requestId) &&
+                    isNonEmptyString(item.displayName) &&
+                    Array.isArray(item.mounts) &&
+                    item.mounts.every((mount) => typeof mount === "string" &&
+                        [
+                            "story",
+                            "sidebar",
+                            "composer_above",
+                            "composer_below",
+                            "overlay",
+                            "debug",
+                        ].includes(mount)) &&
+                    ["running", "completed", "failed"].includes(item.status)))) ||
+        operation.schemaVersion !== 1 ||
+        !isRecord(context) ||
+        !hasExactKeys(context, [
+            "worldId",
+            "parentHead",
+            "operationId",
+            "playPresetId",
+            "playPresetRevision",
+            "playPresetScriptsEnabled",
+        ], ["attachment"]) ||
+        (context.attachment !== undefined &&
+            !validAttachment(context.attachment)) ||
+        !isNonEmptyString(context.worldId) ||
+        !isNonEmptyString(context.parentHead) ||
+        !isNonEmptyString(context.operationId) ||
+        !isNonEmptyString(context.playPresetId) ||
+        !isNonEmptyString(context.playPresetRevision) ||
+        typeof context.playPresetScriptsEnabled !== "boolean" ||
+        !["running", "core_failed", "core_committed", "completed"].includes(operation.status) ||
+        ![
+            "not_started",
+            "running",
+            "completed",
+            "failed",
+            "cancelled",
+            "budget_exceeded",
+            "unknown",
+            "recovery_required",
+            "superseded",
+        ].includes(operation.extensionStatus) ||
+        !Array.isArray(operation.completedRequests) ||
+        !operation.completedRequests.every(isNonEmptyString) ||
+        (operation.message !== undefined &&
+            typeof operation.message !== "string") ||
+        !validArtifactOperationState(operation) ||
+        !["active", "superseded"].includes(operation.artifactProjectionStatus) ||
+        !isRecord(operation.requestAttempts) ||
+        !Object.entries(operation.requestAttempts).every(([request, attempt]) => request.trim() !== "" &&
+            typeof attempt === "number" &&
+            Number.isSafeInteger(attempt) &&
+            attempt >= 1))
+        throw new ArtifactStoreCorruptionError("Artifact operation state is corrupt");
+}
+function validArtifactOperationState(operation) {
+    if (operation.status === "running")
+        return (operation.extensionStatus === "not_started" &&
+            operation.completedRequests.length === 0 &&
+            operation.message === undefined &&
+            operation.head === undefined);
+    if (operation.status === "core_failed")
+        return (operation.extensionStatus === "failed" &&
+            operation.completedRequests.length === 0 &&
+            operation.artifactProjectionStatus === "superseded" &&
+            operation.head === undefined);
+    if (operation.status === "completed")
+        return (operation.extensionStatus === "completed" &&
+            isNonEmptyString(operation.head) &&
+            operation.message === undefined);
+    if (!isNonEmptyString(operation.head))
+        return false;
+    if (operation.extensionStatus === "completed")
+        return false;
+    if (operation.extensionStatus === "not_started" ||
+        operation.extensionStatus === "running")
+        return (operation.completedRequests.length === 0 &&
+            operation.message === undefined);
+    return (isNonEmptyString(operation.message) &&
+        (operation.extensionStatus !== "superseded" ||
+            operation.artifactProjectionStatus === "superseded"));
+}