narraeon 0.5.7 → 0.6.1

package/dist/node/runtime/V1Runtime.js

@@ -27,6 +27,7 @@ import { SettingImprovementRollbackError, SettingImprovementSession, } from "./s
 import { FileNativeWorldStore } from "./world/FileNativeWorldStore.js";
 import { WorldDocumentStore } from "./world/WorldDocumentStore.js";
 import { FileNativeAiFailureLog } from "./model/AiFailureLog.js";
+import { FileNativeRuntimeErrorLog } from "./RuntimeErrorLog.js";
 import { ProtagonistTemplateStore } from "./config/ProtagonistTemplateStore.js";
 import { AppPreferencesStore } from "./config/AppPreferencesStore.js";
 import { FileNativeWorldRevisionStore } from "./world-revision/FileNativeWorldRevisionStore.js";
@@ -44,6 +45,7 @@ export class V1Runtime {
     #corrections;
     #playCallChains;
     #failureLog;
+    #errorLog;
     #preferences;
     #protagonistTemplates;
     #settingImprovements;
@@ -65,6 +67,10 @@ export class V1Runtime {
             input.logRoot === undefined
                 ? undefined
                 : new FileNativeAiFailureLog(join(input.logRoot, "ai-failures"));
+        this.#errorLog =
+            input.logRoot === undefined
+                ? undefined
+                : new FileNativeRuntimeErrorLog(join(input.logRoot, "runtime-errors"));
         this.#playCallChains = new PlayCallChain(this.#worlds, this.#compiler, this.#artifacts, this.#failureLog, (id) => this.#conversationChanges.publish(`play:${id}`));
         this.worldArchives = new WorldArchives({
             dataRoot: input.dataRoot,
@@ -150,9 +156,11 @@ export class V1Runtime {
     async handle(request, playCallChainObserver) {
         try {
             const result = await this.#dispatch(request, playCallChainObserver);
+            await this.#recordPlayInterruption(request, result);
             return { protocol: v1Protocol, result };
         }
         catch (error) {
+            await this.#errorLog?.recordRequestFailure(request, error);
             if (error instanceof WorldArchiveError)
                 throw new V1ProtocolError(error.code, error.message, { cause: error });
             if (request.type === "world.archive.export" &&
@@ -176,6 +184,32 @@ export class V1Runtime {
             }
         }
     }
+    async #recordPlayInterruption(request, result) {
+        if (this.#errorLog === undefined ||
+            (request.type !== "play.chain.start" &&
+                request.type !== "play.chain.append"))
+            return;
+        const chain = result;
+        if (chain?.status !== "interrupted" ||
+            typeof chain.lastFailure !== "string" ||
+            chain.events?.at(-1)?.kind === "cancellation")
+            return;
+        await this.#errorLog.recordPlayInterruption(request, {
+            message: chain.lastFailure,
+            ...(chain.lastFailureKind === undefined
+                ? {}
+                : { kind: chain.lastFailureKind }),
+        });
+    }
+    async recordConversationFailure(target, error) {
+        await this.#errorLog?.recordRequestFailure({
+            type: `${target.kind}.observe`,
+            targetId: target.id,
+            ...("sessionId" in target && target.sessionId !== undefined
+                ? { sessionId: target.sessionId }
+                : {}),
+        }, error);
+    }
     subscribeConversation(target, changed) {
         return this.#conversationChanges.subscribe(`${target.kind}:${target.id}`, changed);
     }
@@ -258,7 +292,19 @@ export class V1Runtime {
             case "model.models":
                 return this.#models.listModels(request);
             case "content.create":
-                return this.#content.createCurrentTreeContentPackage();
+                return this.#content.createCurrentTreeContentPackage(request.gameplay);
+            case "content.gameplay.set": {
+                try {
+                    return await this.#content.setCurrentTreeContentGameplayScheme(request.packageId, request.scheme);
+                }
+                catch (error) {
+                    if (error instanceof InvalidContentTreeError)
+                        throw new V1ProtocolError("invalid_request", error.message, {
+                            cause: error,
+                        });
+                    throw error;
+                }
+            }
             case "content.create-sample":
                 return this.#content.createSampleContentPackage(request.locale);
             case "content.scripts.read":
@@ -272,7 +318,16 @@ export class V1Runtime {
             case "content.read":
                 return this.#content.readCurrentTreeContentPackage(request.packageId);
             case "content.replace":
-                return this.#content.replaceCurrentTreeContentPackage(request.packageId, request.files);
+                try {
+                    return await this.#content.replaceCurrentTreeContentPackage(request.packageId, request.files);
+                }
+                catch (error) {
+                    if (error instanceof InvalidContentTreeError)
+                        throw new V1ProtocolError("invalid_request", error.message, {
+                            cause: error,
+                        });
+                    throw error;
+                }
             case "content.copy":
                 return this.#content.copyCurrentTreeContentPackage(request.packageId);
             case "content.delete":
@@ -441,6 +496,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);
                 });
@@ -521,11 +577,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);

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"));
+}