narraeon 0.6.0 → 0.6.2

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

@@ -4,60 +4,30 @@ 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);
     }
@@ -73,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);
@@ -114,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) {
@@ -156,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
@@ -187,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]));
@@ -203,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,
@@ -228,7 +184,6 @@ export class FileNativePlayTimelineStore {
             eventCount: value.events.length,
             transcriptCount: value.transcript.length,
             completedToolCount: value.completedTools.length,
-            authorizationCheckpointCount: checkpoints.length,
             promptRunCount: promptRuns.length,
         };
     }
@@ -263,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 ||
@@ -335,7 +288,6 @@ export class FileNativePlayTimelineStore {
             transcript,
             events,
             completedTools,
-            documentAuthorizationCheckpoints: checkpoints,
             promptRuns,
             changedDocuments: structuredClone(stateValue.changedDocuments),
             nextMaterials: structuredClone(continuationValue.nextMaterials),
@@ -360,7 +312,6 @@ export class FileNativePlayTimelineStore {
                 eventCount: stateValue.eventCount,
                 transcriptCount: stateValue.transcriptCount,
                 completedToolCount: stateValue.completedToolCount,
-                authorizationCheckpointCount: stateValue.authorizationCheckpointCount,
                 promptRunCount: stateValue.promptRunCount ?? 0,
             },
         };
@@ -547,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()}`;
@@ -761,7 +712,6 @@ function emptyPersistenceCursor() {
         eventCount: 0,
         transcriptCount: 0,
         completedToolCount: 0,
-        authorizationCheckpointCount: 0,
     };
 }
 function numbered(index) {
@@ -830,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) ||
@@ -865,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" ||
@@ -946,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) ||
@@ -1140,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))
@@ -1232,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([
@@ -1279,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`;
@@ -1293,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")
@@ -1311,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();
-    }
-}