narraeon 0.6.0 → 0.6.1

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

@@ -1,8 +1,8 @@
+import { createHash } from "node:crypto";
 import { HistoryQuery, historyInputs } from "../history/HistoryQuery.js";
 import { renderHistoryResult } from "../history/HistoryRendering.js";
 import { stateDirectoryHandle, parseStateDirectoryHandle, } from "../world/StateDirectoryHandles.js";
 import { renderDocumentWritePosition } from "../prompt/WorldMaintenanceReport.js";
-import { createHash } from "node:crypto";
 import { stringify } from "yaml";
 import { renderPlayerViewBindings } from "../world/PlayerViewBindings.js";
 import { PromptCompilationError, } from "../prompt/FileNativePromptCompiler.js";
@@ -56,66 +56,16 @@ export class FileNativePlayDocuments {
     get committedSnapshot() {
         return this.#committedSnapshot;
     }
-    bindBootstrap(bootstrap, previousAuthorization) {
-        const injected = bootstrapAuthorizations(bootstrap, this.#candidate.snapshot);
-        this.#reads = injected;
-        // Refreshing a prefix retains the native conversation. Its exact reads
-        // remain valid only on the identical state tree, including our own writes.
-        if (previousAuthorization?.stateFingerprint ===
-            fingerprintStateFiles(this.#candidate.files)) {
-            this.restoreAuthorizationCheckpoint(previousAuthorization);
-            for (const [ref, locators] of injected.documents) {
-                for (const locator of locators ?? [null])
-                    authorizeRead(this.#reads, this.#candidate.snapshot.id, ref, locator);
-            }
-        }
+    /**
+     * Read authorizations live only in memory (ADR-0044). A fresh binding starts
+     * from the bootstrap's own reads; writes are guarded at commit time by the
+     * previous-content hash of each changed file.
+     */
+    bindBootstrap(bootstrap) {
+        this.#reads = bootstrapAuthorizations(bootstrap, this.#candidate.snapshot);
         // Creation capabilities come from this prefix, not past directory slots.
         this.#declaredDirectories = declaredStateDirectories(bootstrap);
     }
-    authorizationCheckpoint() {
-        return {
-            schemaVersion: 1,
-            kind: "play_document_authorizations",
-            stateFingerprint: fingerprintStateFiles(this.#candidate.files),
-            documents: [...this.#reads.documents.entries()]
-                .sort(([left], [right]) => left.localeCompare(right))
-                .map(([shortRef, locators]) => ({
-                shortRef,
-                locators: locators === null
-                    ? null
-                    : locators
-                        .filter((locator, index, all) => all.findIndex((candidate) => sameLocator(candidate, locator)) === index)
-                        .map((locator) => structuredClone(locator)),
-            })),
-        };
-    }
-    restoreAuthorizationCheckpoint(checkpoint) {
-        if (!isPlayDocumentAuthorizationCheckpoint(checkpoint))
-            throw new TypeError("The play-document authorization checkpoint has an invalid format");
-        if (checkpoint.stateFingerprint !==
-            fingerprintStateFiles(this.#candidate.files))
-            throw new TypeError("The play-document authorization checkpoint does not match the current state");
-        const documents = new Map();
-        for (const { shortRef, locators } of checkpoint.documents) {
-            if (documentDescriptorByRef(this.#candidate.snapshot, shortRef) === null)
-                throw new TypeError(`The play-document authorization checkpoint refers to missing @${shortRef}`);
-            const restoredLocators = locators?.map((locator) => {
-                const selected = this.#candidate.snapshot.query({
-                    kind: "select_node",
-                    document: { shortRef },
-                    locator,
-                });
-                if (selected.kind !== "select_node" || !selected.ok)
-                    throw new TypeError(`The play-document authorization checkpoint refers to a missing node in @${shortRef}`);
-                return structuredClone(selected.node.locator);
-            });
-            documents.set(shortRef, restoredLocators ?? null);
-        }
-        this.#reads = {
-            snapshotId: this.#candidate.snapshot.id,
-            documents,
-        };
-    }
     execute(call, history, options = {}) {
         let historyQuery;
         const query = () => (historyQuery ??= new HistoryQuery(options.historyScope ?? "local-document-context", historyInputs(history)));
@@ -254,15 +204,6 @@ function authorizeToolRead(authorizations, snapshot, result) {
         return;
     authorizeRead(authorizations, snapshot.id, authorization.shortRef, authorization.locator);
 }
-function sameLocator(left, right) {
-    if (left === null || right === null)
-        return left === right;
-    const leftPath = "yaml" in left ? left.yaml : left.markdown;
-    const rightPath = "yaml" in right ? right.yaml : right.markdown;
-    return ("yaml" in left === "yaml" in right &&
-        leftPath.length === rightPath.length &&
-        leftPath.every((segment, index) => segment === rightPath[index]));
-}
 function parseYamlHandleSegment(segment) {
     return /^(?:0|[1-9][0-9]*)$/u.test(segment) ? Number(segment) : segment;
 }
@@ -914,64 +855,6 @@ export function fingerprintControl(files) {
         hash.update(path).update("\0").update(contents).update("\0");
     return `sha256:${hash.digest("hex")}`;
 }
-export function isPlayDocumentAuthorizationCheckpoint(value) {
-    if (!record(value) ||
-        !hasExactKeys(value, [
-            "schemaVersion",
-            "kind",
-            "stateFingerprint",
-            "documents",
-        ]) ||
-        value.schemaVersion !== 1 ||
-        value.kind !== "play_document_authorizations" ||
-        typeof value.stateFingerprint !== "string" ||
-        !/^sha256:[0-9a-f]{64}$/u.test(value.stateFingerprint) ||
-        !Array.isArray(value.documents) ||
-        value.documents.length > 100_000)
-        return false;
-    const refs = new Set();
-    for (const document of value.documents) {
-        if (!record(document) ||
-            !hasExactKeys(document, ["shortRef", "locators"]) ||
-            typeof document.shortRef !== "string" ||
-            !/^[a-z][a-z0-9-]*$/u.test(document.shortRef) ||
-            refs.has(document.shortRef) ||
-            (document.locators !== null &&
-                (!Array.isArray(document.locators) ||
-                    document.locators.length > 100_000 ||
-                    !document.locators.every(isPersistedAuthorizedLocator))))
-            return false;
-        refs.add(document.shortRef);
-    }
-    return true;
-}
-function fingerprintStateFiles(files) {
-    const hash = createHash("sha256");
-    for (const [path, contents] of Object.entries(files)
-        .filter(([path]) => path.startsWith("state/"))
-        .sort(([left], [right]) => left.localeCompare(right)))
-        hash.update(path).update("\0").update(contents).update("\0");
-    return `sha256:${hash.digest("hex")}`;
-}
-function isPersistedAuthorizedLocator(value) {
-    if (!record(value))
-        return false;
-    if (hasExactKeys(value, ["yaml"]))
-        return (Array.isArray(value.yaml) &&
-            value.yaml.length <= 64 &&
-            value.yaml.every((segment) => typeof segment === "string" ||
-                (Number.isSafeInteger(segment) && Number(segment) >= 0)));
-    if (hasExactKeys(value, ["markdown"]))
-        return (Array.isArray(value.markdown) &&
-            value.markdown.length <= 64 &&
-            value.markdown.every((segment) => typeof segment === "string"));
-    return false;
-}
-function hasExactKeys(value, expected) {
-    const keys = Object.keys(value);
-    return (keys.length === expected.length &&
-        expected.every((key) => Object.hasOwn(value, key)));
-}
 function record(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

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

@@ -59,8 +59,8 @@ export async function runPlayFollowupRequests(input) {
             failure ??= outcome.failure;
     }
     const extension = failure === undefined
-        ? await input.artifacts.completeExtension(input.context.operationId, completed)
-        : await input.artifacts.failExtension(input.context.operationId, "recovery_required", failure, completed);
+        ? await input.artifacts.completeExtension(input.context.worldId, input.context.operationId, completed)
+        : await input.artifacts.failExtension(input.context.worldId, input.context.operationId, "recovery_required", failure, completed);
     return { outcomes, extension };
 }
 async function runOne(input, followup, prefix, requestSignal) {

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

@@ -1,18 +1,18 @@
 import { captureNarrativeOrigin } from "../history/HistoryBackground.js";
-import { FileNativePlayDocuments, } from "./PlayDocumentTools.js";
+import { FileNativePlayDocuments } from "./PlayDocumentTools.js";
 import { currentPlayPrompt, playPromptRunsThroughEvents, } from "./PlayPromptRun.js";
 import { isPlayerRoundMarker, playerInputAppend } from "./PlayContinuity.js";
 import { PlayCallChainError } from "./PlayCallChainError.js";
 /**
- * Prepare the selected player's prefix at the existing pre-commit seam.
- * Endpoint reads, revision submission and publication belong to the operation.
+ * Split a context at a selected player message for an edit: the prefix before
+ * it is kept, and the replacement is appended once the world has rewound and
+ * committed it (PlayCallChain.revisePlayer).
  */
 export function preparePlayerRevisionTrace(source, eventIndex) {
     const prefix = structuredClone(source.events.slice(0, eventIndex));
     const transcript = transcriptThroughEvents(source.transcript, prefix);
     const player = source.events[eventIndex];
     return {
-        // This append precedes the operation's materialization check, as before.
         withReplacement(replacement) {
             const events = [
                 ...prefix,
@@ -46,7 +46,7 @@ export function preparePlayerRevisionTrace(source, eventIndex) {
         pagePrefixAtEndpoint(endpoint) {
             if (prefix.length === 0)
                 return null;
-            // Preserve the fresh path's post-commit prefix reconstruction seam.
+            // A fresh context keeps the page before the edit as a detached prefix.
             const prefixTranscript = transcriptThroughEvents(source.transcript, prefix);
             return assembleRetainedTrace(source, endpoint, {
                 events: prefix,
@@ -119,7 +119,6 @@ function assembleRetainedTrace(source, endpoint, selection) {
         completedTools: source.completedTools
             .filter(({ key }) => completedKeys === null || completedKeys.has(key))
             .map((item) => structuredClone(item)),
-        documentAuthorizationCheckpoints: authorizationCheckpointsThroughEvents(source, selection.events, documents.authorizationCheckpoint()),
         changedDocuments: changedDocumentsAtHead(source.changedDocuments, endpoint.baseline.state, endpoint.selected.state),
         nextMaterials: structuredClone(selection.materials),
         nextEventId: Math.max(0, ...selection.events.map(({ id }) => id)) + 1,
@@ -132,29 +131,16 @@ function assembleRetainedTrace(source, endpoint, selection) {
 export function restorePlayDocuments(files, context, events) {
     const documents = new FileNativePlayDocuments(files);
     try {
-        const checkpoint = documentAuthorizationThroughEvents(context, events);
+        // Read authorizations are memory-only: a restored prefix always starts from
+        // its bootstrap, and stale write authority is caught by the commit's hash.
         const runs = playPromptRunsThroughEvents(context, events);
-        if (checkpoint === undefined || runs.length > 0)
-            documents.bindBootstrap(currentPlayPrompt({ ...context, promptRuns: runs }).bootstrap);
-        if (checkpoint !== undefined)
-            documents.restoreAuthorizationCheckpoint(checkpoint.authorization);
+        documents.bindBootstrap(currentPlayPrompt({ ...context, promptRuns: runs }).bootstrap);
     }
     catch (error) {
         throw new PlayCallChainError(`Call-chain document authorization could not be restored: ${error instanceof Error ? error.message : "invalid checkpoint"}。`);
     }
     return documents;
 }
-function documentAuthorizationThroughEvents(context, events) {
-    const checkpoints = context.documentAuthorizationCheckpoints;
-    if (checkpoints === undefined || checkpoints.length === 0)
-        return undefined;
-    const selectedEventIds = new Set(events.map(({ id }) => id));
-    const selected = checkpoints.findLast(({ afterEventId }) => afterEventId === 0 || selectedEventIds.has(afterEventId));
-    // Legacy V1 records had no durable dynamic authorization. If the selected
-    // prefix predates their first lazily-written checkpoint, retain the exact
-    // old recovery behavior and rebuild only bootstrap authorization.
-    return selected === undefined ? undefined : structuredClone(selected);
-}
 export function independentContextCopy(source) {
     const context = structuredClone(source);
     context.continuityContextId ??= source.chainId;
@@ -162,20 +148,6 @@ export function independentContextCopy(source) {
     delete context.branchedBeforePlayer;
     return context;
 }
-function authorizationCheckpointsThroughEvents(context, events, fallback) {
-    const eventIds = new Set(events.map(({ id }) => id));
-    const selected = (context.documentAuthorizationCheckpoints ?? [])
-        .filter(({ afterEventId }) => afterEventId === 0 || eventIds.has(afterEventId))
-        .map((checkpoint) => structuredClone(checkpoint));
-    if (selected.length > 0)
-        return selected;
-    return [
-        {
-            afterEventId: Math.max(0, ...events.map(({ id }) => id)),
-            authorization: structuredClone(fallback),
-        },
-    ];
-}
 function transcriptThroughEvents(transcript, events) {
     const result = [];
     let cursor = 0;

package/dist/node/runtime/setting/FileNativeSettingImprovementStore.js

@@ -1,7 +1,8 @@
 import { validPromptCompilation, validLogicalMessages, validPromptTools, validPlayFollowup, validProviderKind, validCacheStrategy, validToolStrategy, } from "../prompt/PromptCompilationCodec.js";
 import { validAuthoringRequests, } from "../authoring/AuthoringRequestSnapshot.js";
 import { randomUUID } from "node:crypto";
-import { link, mkdir, open, readFile, readdir, rename, rm, stat, } from "node:fs/promises";
+import { mkdir, open, readFile, readdir, rename, rm, stat, } from "node:fs/promises";
+import { linkExclusive } from "../FileNativeExclusiveLink.js";
 import { dirname, join } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { fictionGameplay } from "../../protocol/gameplay.js";
@@ -969,13 +970,11 @@ async function publishJson(path, value) {
         const handle = await open(temporary, "wx", 0o600);
         try {
             await handle.writeFile(`${JSON.stringify(value, null, 2)}\n`, "utf8");
-            await handle.sync();
         }
         finally {
             await handle.close();
         }
         await rename(temporary, path);
-        await syncDirectory(dirname(path));
     }
     finally {
         await rm(temporary, { force: true });
@@ -988,14 +987,12 @@ async function publishImmutableSource(path, contents) {
         const handle = await open(temporary, "wx", 0o600);
         try {
             await handle.writeFile(contents, "utf8");
-            await handle.sync();
         }
         finally {
             await handle.close();
         }
         try {
-            await link(temporary, path);
-            await syncDirectory(dirname(path));
+            await linkExclusive(temporary, path);
         }
         catch (error) {
             if (!isNodeError(error) || error.code !== "EEXIST")
@@ -1008,15 +1005,6 @@ async function publishImmutableSource(path, contents) {
         await rm(temporary, { force: true });
     }
 }
-async function syncDirectory(path) {
-    const handle = await open(path, "r");
-    try {
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
-    }
-}
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }