narraeon 0.1.1 → 0.2.0

package/dist/node/runtime/world/FileNativeWorldStore.js

@@ -6,9 +6,13 @@ import { inspectContentPackageCurrentTree, isContentPackageWorldDocumentPath, }
 import { FileNativePromptCompiler, } from "../prompt/FileNativePromptCompiler.js";
 import { PlayerViewRenderer } from "./PlayerViewRenderer.js";
 import { WorldDocumentStore } from "./WorldDocumentStore.js";
+import { FileNativePlayTimelineStore } from "../play/FileNativePlayTimelineStore.js";
+import { FileNativePlayAdvanceStore } from "../play/FileNativePlayAdvanceStore.js";
+import { FileNativeWorldStorageMigrator } from "./FileNativeWorldStorageMigrator.js";
 import { FileNativeWorldOperationCoordinator, WorldOperationBusyError, } from "./WorldOperationCoordinator.js";
 const publicationFile = "publication.json";
 const localMetadataFile = "local.json";
+const playAuthorityHeadFile = "play-authority-head.json";
 export class FileNativeWorldCreationError extends Error {
     code;
     constructor(code, message, options) {
@@ -29,6 +33,11 @@ export class FileNativeWorldStore {
     #promptCompiler;
     #activeControlUsers = new Map();
     operations;
+    playTimeline;
+    playAdvances;
+    #storageMigrator;
+    #storageMigrations = new Map();
+    #currentStorage = new Set();
     constructor(dataRoot, options = {}) {
         const root = resolve(dataRoot);
         this.#worldsRoot = join(root, "worlds-file-native");
@@ -36,6 +45,64 @@ export class FileNativeWorldStore {
         this.#promptCompiler =
             options.promptCompiler ?? new FileNativePromptCompiler();
         this.operations = new FileNativeWorldOperationCoordinator(root);
+        this.playTimeline = new FileNativePlayTimelineStore(root);
+        this.playAdvances = new FileNativePlayAdvanceStore(root);
+        this.#storageMigrator = new FileNativeWorldStorageMigrator(root, this.playTimeline);
+    }
+    /**
+     * Upgrade a formally released cumulative layout before current Authority or
+     * play-timeline behavior crosses its seam. Concurrent callers share one
+     * in-process promise; the durable world lock serializes processes.
+     */
+    async ensureCurrentStorage(worldId) {
+        assertIdentity(worldId, "World ID");
+        if (this.#currentStorage.has(worldId))
+            return;
+        const existing = this.#storageMigrations.get(worldId);
+        if (existing !== undefined)
+            return existing;
+        const migration = this.#ensureCurrentStorageSerialized(worldId);
+        this.#storageMigrations.set(worldId, migration);
+        try {
+            await migration;
+        }
+        finally {
+            if (this.#storageMigrations.get(worldId) === migration)
+                this.#storageMigrations.delete(worldId);
+        }
+    }
+    async #ensureCurrentStorageSerialized(worldId) {
+        try {
+            try {
+                await readAuthorityHead(join(this.#worldsRoot, worldId));
+                this.#currentStorage.add(worldId);
+                return;
+            }
+            catch (error) {
+                if (!isNodeError(error) || error.code !== "ENOENT")
+                    throw error;
+            }
+            await this.operations.withWorldAuthorityLock(worldId, async () => {
+                await this.#storageMigrator.migrate(worldId);
+            });
+            this.#currentStorage.add(worldId);
+        }
+        catch (error) {
+            if (error instanceof FileNativeWorldCreationError)
+                throw error;
+            if (isNodeError(error) && error.code === "ENOENT") {
+                const root = await stat(join(this.#worldsRoot, worldId)).catch((statError) => {
+                    if (isNodeError(statError) && statError.code === "ENOENT")
+                        return null;
+                    throw statError;
+                });
+                if (root === null)
+                    throw new FileNativeWorldNotFoundError({ cause: error });
+            }
+            if (error instanceof WorldOperationBusyError)
+                throw new FileNativeWorldCreationError("operation_conflict", "World storage is being upgraded by another durable operation", { cause: error });
+            throw new FileNativeWorldCreationError("world_corrupt", "Released world storage could not be migrated to the current format", error instanceof Error ? { cause: error } : undefined);
+        }
     }
     async listWorlds() {
         await mkdir(this.#worldsRoot, { recursive: true, mode: 0o700 });
@@ -90,6 +157,7 @@ export class FileNativeWorldStore {
         }
         return this.operations.withExclusiveWorldStateMutation(worldId, async () => {
             await rm(root, { recursive: true, force: true });
+            this.#currentStorage.delete(worldId);
             return { deleted: true };
         });
     }
@@ -169,8 +237,17 @@ export class FileNativeWorldStore {
                 additionalMaterials: initialMaterials,
             };
             await writeJson(join(stagingRoot, "runtime", "genesis.json"), genesis);
+            await writeJson(join(stagingRoot, "runtime", "play-genesis-timeline.json"), {
+                schemaVersion: 1,
+                worldId,
+                history: genesis.history,
+            });
+            await writeJson(join(stagingRoot, "runtime", playAuthorityHeadFile), genesisAuthorityHead());
             await writeJson(join(stagingRoot, "runtime", "materialized-head.json"), {
+                schemaVersion: 2,
                 head: "genesis",
+                sequence: 0,
+                commitDigest: null,
             });
             await writeJson(join(stagingRoot, "runtime", "additional-materials.json"), { head: "genesis", items: initialMaterials });
             const publication = {
@@ -215,6 +292,7 @@ export class FileNativeWorldStore {
     }
     async readSurface(worldId, surface) {
         assertIdentity(worldId, "World ID");
+        await this.ensureCurrentStorage(worldId);
         const root = join(this.#worldsRoot, worldId);
         await readPublicationAt(root);
         if (surface === "runtime") {
@@ -236,28 +314,37 @@ export class FileNativeWorldStore {
      * must never pair a mutable state tree with a different response head.
      */
     async renderPlayerViewsAtHead(worldId, head) {
-        const endpoint = await this.recoverEndpoint(worldId, head);
-        const control = await this.readSurface(worldId, "control");
+        const root = join(this.#worldsRoot, worldId);
+        const materialized = await readOptionalJson(join(root, "runtime", "materialized-head.json"));
+        const [state, control] = await Promise.all([
+            materialized?.head === head
+                ? readTree(join(root, "state"))
+                : this.recoverEndpoint(worldId, head).then(({ state }) => state),
+            this.readSurface(worldId, "control"),
+        ]);
         const source = control.find(({ path }) => path === "player-views.yaml");
         return new PlayerViewRenderer().render({
-            snapshot: openWorldDocumentSnapshot(endpoint.state),
+            snapshot: openWorldDocumentSnapshot(state),
             control: source?.contents ?? "",
         });
     }
     async currentHead(worldId) {
         assertIdentity(worldId, "World ID");
+        await this.ensureCurrentStorage(worldId);
         const root = join(this.#worldsRoot, worldId);
         await readPublicationAt(root);
-        return (await readAcceptedAuthority(root))?.head ?? "genesis";
+        return (await readAuthorityHead(root)).head;
     }
     async currentHeadOperationId(worldId) {
         assertIdentity(worldId, "World ID");
+        await this.ensureCurrentStorage(worldId);
         const root = join(this.#worldsRoot, worldId);
         await readPublicationAt(root);
-        return ((await readAcceptedAuthority(root))?.commits.at(-1)?.operationId ?? null);
+        return (await readAuthorityHead(root)).operationId;
     }
     async saveControlDraft(worldId, files) {
         assertIdentity(worldId, "World ID");
+        await this.ensureCurrentStorage(worldId);
         const root = join(this.#worldsRoot, worldId);
         await readPublicationAt(root);
         for (const file of files)
@@ -350,6 +437,7 @@ export class FileNativeWorldStore {
     }
     async #readControlDraft(worldId) {
         assertIdentity(worldId, "World ID");
+        await this.ensureCurrentStorage(worldId);
         const root = join(this.#worldsRoot, worldId);
         await readPublicationAt(root);
         const [state, draft] = await Promise.all([
@@ -363,6 +451,7 @@ export class FileNativeWorldStore {
     /** Bind the current Authority endpoint for a model-directed play call chain. */
     async bindPlayCallChain(worldId) {
         assertIdentity(worldId, "World ID");
+        await this.ensureCurrentStorage(worldId);
         const root = join(this.#worldsRoot, worldId);
         try {
             await readPublicationAt(root);
@@ -384,23 +473,16 @@ export class FileNativeWorldStore {
         }
         try {
             return await this.operations.withWorldAuthorityLock(worldId, async () => {
-                const publishedAuthority = await readAcceptedAuthority(root);
-                if (publishedAuthority !== null) {
-                    const materialized = await readOptionalJson(join(root, "runtime", "materialized-head.json"));
-                    let materializedIndex = 0;
-                    if (materialized !== null && materialized.head !== "genesis") {
-                        const found = publishedAuthority.commits.findIndex(({ head }) => head === materialized.head);
-                        if (found < 0)
-                            throw new FileNativeWorldCreationError("world_corrupt", "World materialized head does not belong to the authority commit chain");
-                        materializedIndex = found + 1;
-                    }
-                    for (let index = materializedIndex; index < publishedAuthority.commits.length; index += 1) {
-                        const commit = publishedAuthority.commits[index];
-                        await materializePlayCommit(root, index + 1, {
+                const authority = await readAuthorityHead(root);
+                const checkpoint = await readMaterializedCheckpoint(root);
+                if (!sameMaterializedEndpoint(checkpoint, authority)) {
+                    const missing = await readAuthorityTail(root, authority, checkpoint);
+                    for (const commit of missing) {
+                        await materializePlayCommit(root, commit.sequence, {
                             mode: commit.mode,
                             historyAppend: commit.historyAppend,
                             nextMaterials: commit.nextAdditionalMaterials,
-                            stateChanges: commit.stateChanges ?? [],
+                            stateChanges: commit.stateChanges,
                             ...(commit.timelineRevision === undefined
                                 ? {}
                                 : { timelineRevision: commit.timelineRevision }),
@@ -410,35 +492,37 @@ export class FileNativeWorldStore {
                             worldId,
                             parentHead: commit.parentHead,
                             head: commit.head,
+                            commitDigest: playCommitDigest(commit),
                             historyAppend: commit.historyAppend.map(({ role, exactText }) => ({ role, exactText })),
                             nextAdditionalMaterials: commit.nextAdditionalMaterials,
                             mode: commit.mode,
                         });
                     }
                     await publishJson(join(root, "runtime", "materialized-head.json"), {
-                        head: publishedAuthority.head,
+                        schemaVersion: 2,
+                        head: authority.head,
+                        sequence: authority.sequence,
+                        commitDigest: authority.commitDigest,
                     });
                 }
-                const [state, control, authority, materials, recovered] = await Promise.all([
+                const [state, control, history, materials] = await Promise.all([
                     readTree(join(root, "state")),
                     readTree(join(root, "control")),
-                    readAcceptedAuthority(root),
+                    readTree(join(root, "history")),
                     readOptionalJson(join(root, "runtime", "additional-materials.json")),
-                    this.recoverEndpoint(worldId),
                 ]);
+                if ((materials?.head ?? "genesis") !== authority.head)
+                    throw new FileNativeWorldCreationError("inconsistent_materialization", "Materialized additional materials do not match the current Authority endpoint");
                 return {
                     worldId,
-                    parentHead: authority?.head ?? "genesis",
+                    parentHead: authority.head,
                     files: [...state, ...control].reduce((files, { path, contents }, index) => {
                         files[`${index < state.length ? "state" : "control"}/${path}`] =
                             contents;
                         return files;
                     }, {}),
                     additionalMaterials: materials?.items ?? [],
-                    history: Object.fromEntries(recovered.history.map(({ messageId, exactText }) => [
-                        messageId,
-                        exactText,
-                    ])),
+                    history: materializedHistoryRecord(worldId, history),
                 };
             });
         }
@@ -479,6 +563,7 @@ export class FileNativeWorldStore {
     }
     async recoverEndpoint(worldId, head) {
         assertIdentity(worldId, "World ID");
+        await this.ensureCurrentStorage(worldId);
         const root = join(this.#worldsRoot, worldId);
         await readPublicationAt(root);
         const genesis = await readJson(join(root, "runtime", "genesis.json"));
@@ -540,6 +625,7 @@ export class FileNativeWorldStore {
     }
     async repairMaterialization(worldId) {
         assertIdentity(worldId, "World ID");
+        await this.ensureCurrentStorage(worldId);
         try {
             const operationId = await this.operations.withExclusiveWorldStateMutation(worldId, async () => {
                 await this.bindPlayCallChain(worldId);
@@ -572,6 +658,7 @@ export class FileNativeWorldStore {
         const finalRoot = join(this.#worldsRoot, worldId);
         const previous = await readOptionalJson(operationPath);
         if (previous !== null) {
+            await this.ensureCurrentStorage(previous.worldId);
             if (!(await derivationPublicationMatches(join(this.#worldsRoot, previous.worldId), previous, input, requestFingerprint)))
                 throw new FileNativeWorldCreationError("operation_conflict", "The same fork operation ID is bound to a different fork payload");
             return {
@@ -581,6 +668,7 @@ export class FileNativeWorldStore {
         }
         const alreadyPublished = await readOptionalJson(join(finalRoot, publicationFile));
         if (alreadyPublished !== null) {
+            await this.ensureCurrentStorage(alreadyPublished.worldId);
             if (!(await derivationPublicationMatches(finalRoot, alreadyPublished, input, requestFingerprint)))
                 throw new FileNativeWorldCreationError("operation_conflict", "Published fork world does not match the operation payload");
             await mkdir(this.#operationsRoot, { recursive: true, mode: 0o700 });
@@ -590,6 +678,7 @@ export class FileNativeWorldStore {
                 world: await this.#currentSummary(alreadyPublished),
             };
         }
+        await this.ensureCurrentStorage(input.sourceWorldId);
         const sourceRoot = join(this.#worldsRoot, input.sourceWorldId);
         const sourcePublication = await readPublicationAt(sourceRoot);
         const sourceSummary = await readWorldSummaryAt(sourceRoot, sourcePublication);
@@ -628,12 +717,18 @@ export class FileNativeWorldStore {
                 additionalMaterials: cloned.genesisMaterials,
             };
             await writeJson(join(staging, "runtime", "genesis.json"), genesis);
+            await writeJson(join(staging, "runtime", "play-genesis-timeline.json"), {
+                schemaVersion: 1,
+                worldId,
+                history: genesis.history,
+            });
             await writeJson(join(staging, "runtime", "additional-materials.json"), {
                 head: "genesis",
                 items: cloned.genesisMaterials,
             });
             for (const [index, commit] of cloned.commits.entries()) {
-                await publishImmutableJson(join(staging, "runtime", "play-commits", `${createHash("sha256").update(JSON.stringify(commit)).digest("hex")}.json`), commit);
+                const digest = playCommitDigest(commit);
+                await publishImmutableJson(join(staging, "runtime", "play-commits", `${digest}.json`), commit);
                 await materializePlayCommit(staging, index + 1, {
                     mode: commit.mode,
                     historyAppend: commit.historyAppend,
@@ -644,14 +739,21 @@ export class FileNativeWorldStore {
                         : { timelineRevision: commit.timelineRevision }),
                 });
             }
-            if (cloned.commits.length > 0)
-                await writeJson(join(staging, "runtime", "play-authority.json"), {
-                    schemaVersion: 1,
-                    head: input.sourceHead,
-                    commits: cloned.commits,
+            const clonedHead = cloned.commits.at(-1);
+            await writeJson(join(staging, "runtime", playAuthorityHeadFile), clonedHead === undefined
+                ? genesisAuthorityHead()
+                : {
+                    schemaVersion: 2,
+                    head: clonedHead.head,
+                    sequence: clonedHead.sequence,
+                    commitDigest: playCommitDigest(clonedHead),
+                    operationId: clonedHead.operationId,
                 });
             await writeJson(join(staging, "runtime", "materialized-head.json"), {
+                schemaVersion: 2,
                 head: input.sourceHead,
+                sequence: clonedHead?.sequence ?? 0,
+                commitDigest: clonedHead === undefined ? null : playCommitDigest(clonedHead),
             });
             const materializedState = await readTree(join(staging, "state"));
             if (!isDeepStrictEqual(materializedState, selected.state))
@@ -698,7 +800,11 @@ export class FileNativeWorldStore {
         assertIdentity(operationId, "operation ID");
         let directRecord;
         try {
-            const value = await readOptionalJson(this.#operationOutcomePath(operationId));
+            let value = await readOptionalJson(this.#operationOutcomePath(operationId));
+            if (isReleasedCommittedOperationOutcome(value)) {
+                await this.ensureCurrentStorage(value.worldId);
+                value = await readOptionalJson(this.#operationOutcomePath(operationId));
+            }
             if (value === null)
                 directRecord = null;
             else {
@@ -711,46 +817,18 @@ export class FileNativeWorldStore {
                 throw error;
             throw new FileNativeWorldCreationError("world_corrupt", "Authority operation outcome has an invalid structure", error instanceof Error ? { cause: error } : undefined);
         }
+        if (directRecord?.outcome === "acceptance_prepared")
+            return resolvePreparedOperationOutcome(this.#worldsRoot, operationId, directRecord);
         const direct = directRecord === null ? null : projectOperationOutcome(directRecord);
         if (direct?.outcome === "committed" ||
             direct?.outcome === "committed_materialization_pending") {
-            if (direct.outcome === "committed") {
-                await assertCommittedAuthorityOutcomeMatches(join(this.#worldsRoot, direct.worldId), operationId, direct);
-                const materialized = await readOptionalJson(join(this.#worldsRoot, direct.worldId, "runtime", "materialized-head.json"));
-                if (materialized?.head !== direct.head)
-                    return { ...direct, outcome: "committed_materialization_pending" };
-            }
-            else {
-                await assertCommittedAuthorityOutcomeMatches(join(this.#worldsRoot, direct.worldId), operationId, direct);
-                await assertPendingMaterializationCompatible(join(this.#worldsRoot, direct.worldId), operationId);
-            }
-            return direct;
-        }
-        const worlds = await readDirectoryNames(this.#worldsRoot);
-        for (const worldId of worlds) {
-            const authority = await readAcceptedAuthority(join(this.#worldsRoot, worldId));
-            const commitIndex = authority?.commits.findIndex((candidate) => candidate.operationId === operationId) ?? -1;
-            const commit = authority?.commits[commitIndex];
-            if (commit !== undefined) {
-                const materialized = await readOptionalJson(join(this.#worldsRoot, worldId, "runtime", "materialized-head.json"));
-                const materializedIndex = materialized?.head === "genesis"
-                    ? -1
-                    : (authority?.commits.findIndex(({ head }) => head === materialized?.head) ?? -1);
-                return {
-                    outcome: materializedIndex >= commitIndex
-                        ? "committed"
-                        : "committed_materialization_pending",
-                    worldId,
-                    parentHead: commit.parentHead,
-                    head: commit.head,
-                    historyAppend: commit.historyAppend.map(({ role, exactText }) => ({
-                        role,
-                        exactText,
-                    })),
-                    nextAdditionalMaterials: commit.nextAdditionalMaterials,
-                    mode: commit.mode,
-                };
-            }
+            const worldRoot = join(this.#worldsRoot, direct.worldId);
+            const commit = await assertCommittedAuthorityOutcomeMatches(worldRoot, operationId, direct);
+            const materialized = await readMaterializedCheckpoint(worldRoot);
+            if (materialized !== null && materialized.sequence >= commit.sequence)
+                return { ...direct, outcome: "committed" };
+            await assertPendingMaterializationCompatible(worldRoot, operationId, direct.commitDigest);
+            return { ...direct, outcome: "committed_materialization_pending" };
         }
         return direct?.outcome === "in_progress"
             ? { outcome: "in_progress" }
@@ -773,6 +851,7 @@ export class FileNativeWorldStore {
             throw new TypeError("Edited player message cannot be empty");
         if (!/^sha256:[a-f0-9]{64}$/u.test(input.requestFingerprint))
             throw new TypeError("Timeline-revision request fingerprint is invalid");
+        await this.ensureCurrentStorage(input.worldId);
         const existing = await this.getOperationOutcome(input.operationId);
         if (isCommittedOutcome(existing)) {
             const authority = await readAcceptedAuthority(join(this.#worldsRoot, existing.worldId));
@@ -821,6 +900,7 @@ export class FileNativeWorldStore {
         });
     }
     async commitCorrection(input) {
+        await this.ensureCurrentStorage(input.worldId);
         try {
             const commit = async () => {
                 let operationReserved = input.stateOperationClaim !== undefined;
@@ -856,6 +936,7 @@ export class FileNativeWorldStore {
      * separate commits; there is no synthetic call-chain-wide settlement boundary.
      */
     async commitPlayStep(input) {
+        await this.ensureCurrentStorage(input.worldId);
         if (input.historyAppend.length === 0 && input.stateChanges.length === 0)
             throw new TypeError("A call-chain commit cannot omit both narrative and state changes");
         return this.#commitHistoryChange({
@@ -863,24 +944,11 @@ export class FileNativeWorldStore {
             mode: "play",
         });
     }
-    async readPlayCallChain(worldId) {
-        assertIdentity(worldId, "World ID");
-        return readOptionalJson(join(this.#worldsRoot, worldId, "runtime", "play-call-chain.json"));
-    }
-    async writePlayCallChain(worldId, value) {
-        assertIdentity(worldId, "World ID");
-        await publishJson(join(this.#worldsRoot, worldId, "runtime", "play-call-chain.json"), value);
-    }
-    async removePlayCallChain(worldId) {
-        assertIdentity(worldId, "World ID");
-        await rm(join(this.#worldsRoot, worldId, "runtime", "play-call-chain.json"), { force: true });
-    }
     async #commitHistoryChange(input) {
         const existing = await this.getOperationOutcome(input.operationId);
         if (isCommittedOutcome(existing)) {
             assertSameOperationOutcome(existing, input);
-            const accepted = await readAcceptedAuthority(join(this.#worldsRoot, existing.worldId));
-            const commit = accepted?.commits.find(({ operationId }) => operationId === input.operationId);
+            const commit = await readPlayCommitByDigest(join(this.#worldsRoot, existing.worldId), existing.commitDigest);
             if (commit?.mode !== input.mode ||
                 JSON.stringify(commit?.stateChanges) !==
                     JSON.stringify(input.stateChanges) ||
@@ -888,8 +956,14 @@ export class FileNativeWorldStore {
                 throw new FileNativeWorldCreationError("operation_conflict", "The same play operation ID is bound to a different complete commit payload");
             return existing;
         }
+        const prepared = existing.outcome === "in_progress"
+            ? await readAcceptancePreparedOutcome(this.#operationOutcomePath(input.operationId))
+            : null;
+        if (prepared !== null)
+            await assertPreparedOperationMatches(this.#worldsRoot, input.operationId, prepared, input);
         if (existing.outcome !== "not_started" &&
-            !(input.operationReserved === true && existing.outcome === "in_progress"))
+            !(existing.outcome === "in_progress" &&
+                (input.operationReserved === true || prepared !== null)))
             throw new FileNativeWorldCreationError("operation_conflict", "The same play operation ID is occupied by another durable operation");
         const root = join(this.#worldsRoot, input.worldId);
         try {
@@ -897,20 +971,23 @@ export class FileNativeWorldStore {
                 const concurrent = await this.#readOperationOutcome(input.operationId);
                 if (isCommittedOutcome(concurrent)) {
                     assertSameOperationOutcome(concurrent, input);
-                    const accepted = await readAcceptedAuthority(join(this.#worldsRoot, concurrent.worldId));
-                    const knownCommit = accepted?.commits.find(({ operationId }) => operationId === input.operationId);
+                    const knownCommit = await readPlayCommitByDigest(join(this.#worldsRoot, concurrent.worldId), concurrent.commitDigest);
                     if (knownCommit?.mode !== input.mode ||
                         !isDeepStrictEqual(knownCommit.stateChanges, input.stateChanges) ||
                         !isDeepStrictEqual(knownCommit.timelineRevision, input.timelineRevision))
                         throw new FileNativeWorldCreationError("operation_conflict", "The same play operation ID is bound to a different complete commit payload");
                     return concurrent;
                 }
-                const authorityPath = join(root, "runtime", "play-authority.json");
-                const authority = (await readAcceptedAuthority(root)) ?? {
-                    schemaVersion: 1,
-                    head: "genesis",
-                    commits: [],
-                };
+                const concurrentPrepared = concurrent.outcome === "in_progress"
+                    ? await readAcceptancePreparedOutcome(this.#operationOutcomePath(input.operationId))
+                    : null;
+                if (concurrentPrepared !== null)
+                    await assertPreparedOperationMatches(this.#worldsRoot, input.operationId, concurrentPrepared, input);
+                else if (concurrent.outcome === "in_progress" &&
+                    input.operationReserved !== true)
+                    throw new FileNativeWorldCreationError("operation_conflict", "The same play operation ID is occupied by another durable operation");
+                const authorityPath = join(root, "runtime", playAuthorityHeadFile);
+                const authority = await readAuthorityHead(root);
                 if (authority.head !== input.parentHead) {
                     throw new FileNativeWorldCreationError("operation_conflict", "The parent endpoint of the play operation has changed");
                 }
@@ -959,12 +1036,14 @@ export class FileNativeWorldStore {
                 ], { requireOpening: false });
                 if (inspection.status !== "usable")
                     throw new FileNativeWorldCreationError("candidate_validation_failed", `Candidate world failed mechanical validation: ${inspection.issues.map(({ message }) => message).join("; ")}`);
-                const sequence = authority.commits.length + 1;
+                const sequence = authority.sequence + 1;
                 const head = `commit:${sequence}`;
                 const commit = {
-                    schemaVersion: 1,
+                    schemaVersion: 2,
+                    sequence,
                     operationId: input.operationId,
                     parentHead: input.parentHead,
+                    parentCommitDigest: authority.commitDigest,
                     head,
                     mode: input.mode,
                     historyAppend: input.historyAppend.map((message, index) => ({
@@ -985,23 +1064,32 @@ export class FileNativeWorldStore {
                         }
                         : {}),
                 };
+                const digest = playCommitDigest(commit);
                 crashAtFileNativeAuthorityEdge("before_commit_acceptance");
-                await publishImmutableJson(join(root, "runtime", "play-commits", `${createHash("sha256").update(JSON.stringify(commit)).digest("hex")}.json`), commit);
-                await publishJson(authorityPath, {
-                    schemaVersion: 1,
-                    head,
-                    commits: [...authority.commits, commit],
-                });
-                crashAtFileNativeAuthorityEdge("after_commit_acceptance");
+                await publishImmutableJson(join(root, "runtime", "play-commits", `${digest}.json`), commit);
                 const pending = {
                     outcome: "committed_materialization_pending",
                     worldId: input.worldId,
                     parentHead: input.parentHead,
                     head,
+                    commitDigest: digest,
                     historyAppend: structuredClone(input.historyAppend),
                     nextAdditionalMaterials: structuredClone(input.nextMaterials),
                     mode: input.mode,
                 };
+                await publishJson(this.#operationOutcomePath(input.operationId), {
+                    ...pending,
+                    outcome: "acceptance_prepared",
+                });
+                crashAtFileNativeAuthorityEdge("after_acceptance_prepared");
+                await publishJson(authorityPath, {
+                    schemaVersion: 2,
+                    head,
+                    sequence,
+                    commitDigest: digest,
+                    operationId: input.operationId,
+                });
+                crashAtFileNativeAuthorityEdge("after_commit_acceptance");
                 await publishJson(this.#operationOutcomePath(input.operationId), pending);
                 try {
                     await materializePlayCommit(root, sequence, {
@@ -1015,7 +1103,10 @@ export class FileNativeWorldStore {
                     });
                     crashAtFileNativeAuthorityEdge("after_materialization");
                     await publishJson(join(root, "runtime", "materialized-head.json"), {
+                        schemaVersion: 2,
                         head,
+                        sequence,
+                        commitDigest: digest,
                     });
                     const outcome = { ...pending, outcome: "committed" };
                     await publishJson(this.#operationOutcomePath(input.operationId), outcome);
@@ -1038,6 +1129,7 @@ export class FileNativeWorldStore {
     }
     async readAuthorityHistory(worldId) {
         assertIdentity(worldId, "World ID");
+        await this.ensureCurrentStorage(worldId);
         const root = join(this.#worldsRoot, worldId);
         await readPublicationAt(root);
         const authority = await readAcceptedAuthority(root);
@@ -1222,19 +1314,6 @@ async function readTree(root, prefix = "") {
     }
     return files;
 }
-async function readDirectoryNames(root) {
-    try {
-        return (await readdir(root, { withFileTypes: true }))
-            .filter((entry) => entry.isDirectory() && !entry.name.startsWith("."))
-            .map((entry) => entry.name)
-            .sort();
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-}
 function immutableFiles(files) {
     return files.map(({ path, contents }) => ({
         path,
@@ -1286,13 +1365,15 @@ function assertOperationOutcomeIntegrity(value) {
             throw corruptOperationOutcome();
         return;
     }
-    if (value.outcome === "committed" ||
+    if (value.outcome === "acceptance_prepared" ||
+        value.outcome === "committed" ||
         value.outcome === "committed_materialization_pending") {
         if (!hasExactKeys(value, [
             "outcome",
             "worldId",
             "parentHead",
             "head",
+            "commitDigest",
             "historyAppend",
             "nextAdditionalMaterials",
             "mode",
@@ -1303,6 +1384,8 @@ function assertOperationOutcomeIntegrity(value) {
             !/^(?:genesis|commit:[1-9][0-9]*)$/u.test(value.parentHead) ||
             typeof value.head !== "string" ||
             !/^commit:[1-9][0-9]*$/u.test(value.head) ||
+            typeof value.commitDigest !== "string" ||
+            !/^[a-f0-9]{64}$/u.test(value.commitDigest) ||
             !Array.isArray(value.historyAppend) ||
             !value.historyAppend.every(isPlayHistoryAppendInput) ||
             !Array.isArray(value.nextAdditionalMaterials) ||
@@ -1315,28 +1398,85 @@ function assertOperationOutcomeIntegrity(value) {
     }
     throw corruptOperationOutcome();
 }
+function isReleasedCommittedOperationOutcome(value) {
+    return (isRecord(value) &&
+        (value.outcome === "committed" ||
+            value.outcome === "committed_materialization_pending") &&
+        !Object.hasOwn(value, "commitDigest") &&
+        typeof value.worldId === "string");
+}
 function projectOperationOutcome(value) {
     return structuredClone(value);
 }
+async function readAcceptancePreparedOutcome(path) {
+    const value = await readOptionalJson(path);
+    if (value === null)
+        return null;
+    assertOperationOutcomeIntegrity(value);
+    if (value.outcome !== "acceptance_prepared")
+        return null;
+    return structuredClone(value);
+}
+async function assertPreparedOperationMatches(worldsRoot, operationId, prepared, input) {
+    const comparable = {
+        ...structuredClone(prepared),
+        outcome: "committed_materialization_pending",
+    };
+    assertSameOperationOutcome(comparable, input);
+    const commit = await readPlayCommitByDigest(join(worldsRoot, prepared.worldId), prepared.commitDigest);
+    if (commit.operationId !== operationId ||
+        commit.mode !== input.mode ||
+        !isDeepStrictEqual(commit.stateChanges, input.stateChanges) ||
+        !isDeepStrictEqual(commit.timelineRevision, input.timelineRevision))
+        throw new FileNativeWorldCreationError("operation_conflict", "The same play operation ID is bound to a different prepared commit payload");
+}
+async function resolvePreparedOperationOutcome(worldsRoot, operationId, value) {
+    const prepared = value;
+    const worldRoot = join(worldsRoot, prepared.worldId);
+    const authority = await readAuthorityHead(worldRoot);
+    if (authority.head === prepared.parentHead)
+        return { outcome: "in_progress" };
+    const commit = await assertCommittedAuthorityOutcomeMatches(worldRoot, operationId, prepared);
+    if (authority.sequence < commit.sequence)
+        throw corruptOperationOutcome();
+    await readAuthorityTail(worldRoot, authority, {
+        schemaVersion: 2,
+        head: commit.head,
+        sequence: commit.sequence,
+        commitDigest: prepared.commitDigest,
+    }).catch(() => {
+        throw corruptOperationOutcome();
+    });
+    const materialized = await readMaterializedCheckpoint(worldRoot);
+    const outcome = materialized !== null && materialized.sequence >= commit.sequence
+        ? "committed"
+        : "committed_materialization_pending";
+    const resolved = { ...structuredClone(prepared), outcome };
+    if (outcome === "committed_materialization_pending")
+        await assertPendingMaterializationCompatible(worldRoot, operationId, prepared.commitDigest);
+    return resolved;
+}
 function corruptOperationOutcome() {
     return new FileNativeWorldCreationError("world_corrupt", "Authority operation outcome structure or operation identity is invalid");
 }
 async function assertCommittedAuthorityOutcomeMatches(worldRoot, operationId, outcome) {
-    const authority = await readAcceptedAuthority(worldRoot);
-    const commit = authority?.commits.find((candidate) => candidate.operationId === operationId);
-    if (commit?.parentHead !== outcome.parentHead ||
+    const commit = await readPlayCommitByDigest(worldRoot, outcome.commitDigest);
+    if (commit.operationId !== operationId ||
+        commit?.parentHead !== outcome.parentHead ||
         commit?.head !== outcome.head ||
         commit?.mode !== outcome.mode ||
         !isDeepStrictEqual(commit?.historyAppend.map(({ role, exactText }) => ({ role, exactText })), outcome.historyAppend) ||
         !isDeepStrictEqual(commit?.nextAdditionalMaterials, outcome.nextAdditionalMaterials))
         throw corruptOperationOutcome();
+    return commit;
 }
-async function assertPendingMaterializationCompatible(worldRoot, operationId) {
-    const authority = await readAcceptedAuthority(worldRoot);
-    const sequence = authority?.commits.findIndex((candidate) => candidate.operationId === operationId) ?? -1;
-    const commit = sequence < 0 ? undefined : authority?.commits[sequence];
-    if (commit === undefined)
+async function assertPendingMaterializationCompatible(worldRoot, operationId, commitDigest) {
+    const commit = commitDigest === undefined
+        ? (await readAcceptedAuthority(worldRoot))?.commits.find((candidate) => candidate.operationId === operationId)
+        : await readPlayCommitByDigest(worldRoot, commitDigest);
+    if (commit?.operationId !== operationId)
         throw corruptOperationOutcome();
+    const sequence = commit.sequence - 1;
     for (const change of commit.stateChanges) {
         const path = join(worldRoot, "state", change.relativePath);
         const existing = await readOptionalText(path);
@@ -1430,55 +1570,36 @@ async function publishImmutableJson(path, value) {
 }
 async function readAcceptedAuthority(root) {
     try {
-        const published = await readOptionalJson(join(root, "runtime", "play-authority.json"));
-        if (published === null) {
-            const commitRoot = join(root, "runtime", "play-commits");
-            const names = await readDirectoryFileNames(commitRoot);
-            if (names.length === 0)
-                return null;
-            const remaining = await Promise.all(names.map(async (name) => {
-                const commit = await readJson(join(commitRoot, name));
-                assertFileNativePlayCommit(commit);
-                const canonicalName = `${createHash("sha256")
-                    .update(JSON.stringify(commit))
-                    .digest("hex")}.json`;
-                if (name !== canonicalName)
-                    throw new FileNativeWorldCreationError("world_corrupt", "Immutable commit does not match the durable path identity");
-                return commit;
-            }));
-            const commits = [];
-            let parent = "genesis";
-            while (remaining.length > 0) {
-                const matches = remaining.filter((commit) => commit.parentHead === parent);
-                if (matches.length !== 1)
-                    throw new FileNativeWorldCreationError("world_corrupt", "Immutable commits cannot rebuild one unique authority chain");
-                const next = matches[0];
-                commits.push(next);
-                remaining.splice(remaining.indexOf(next), 1);
-                parent = next.head;
-            }
-            assertFileNativePlayAuthority({
-                schemaVersion: 1,
-                head: parent,
-                commits,
-            });
-            return { schemaVersion: 1, head: parent, commits };
-        }
-        assertFileNativePlayAuthority(published);
-        const commits = [];
-        for (const recorded of published.commits) {
-            const digest = createHash("sha256")
-                .update(JSON.stringify(recorded))
-                .digest("hex");
+        const published = await readAuthorityHead(root);
+        if (published.sequence === 0)
+            return null;
+        const reverse = [];
+        let digest = published.commitDigest;
+        let expectedHead = published.head;
+        let expectedSequence = published.sequence;
+        while (digest !== null) {
             const immutable = await readJson(join(root, "runtime", "play-commits", `${digest}.json`)).catch((error) => {
-                throw new FileNativeWorldCreationError("world_corrupt", `Accepted endpoint is missing an immutable commit: ${recorded.head}`, { cause: error });
+                throw new FileNativeWorldCreationError("world_corrupt", `Accepted endpoint is missing an immutable commit: ${expectedHead}`, { cause: error });
             });
             assertFileNativePlayCommit(immutable);
-            if (JSON.stringify(immutable) !== JSON.stringify(recorded))
-                throw new FileNativeWorldCreationError("world_corrupt", `Accepted endpoint does not match its immutable commit: ${recorded.head}`);
-            commits.push(immutable);
+            if (playCommitDigest(immutable) !== digest ||
+                immutable.head !== expectedHead ||
+                immutable.sequence !== expectedSequence)
+                throw new FileNativeWorldCreationError("world_corrupt", `Accepted endpoint does not match its immutable commit: ${expectedHead}`);
+            reverse.push(immutable);
+            digest = immutable.parentCommitDigest;
+            expectedHead = immutable.parentHead;
+            expectedSequence -= 1;
         }
-        return { ...published, commits };
+        if (expectedSequence !== 0 || expectedHead !== "genesis")
+            throw new FileNativeWorldCreationError("world_corrupt", "Accepted Authority chain does not terminate at genesis");
+        const authority = {
+            schemaVersion: 2,
+            head: published.head,
+            commits: reverse.reverse(),
+        };
+        assertFileNativePlayAuthority(authority);
+        return authority;
     }
     catch (error) {
         if (error instanceof FileNativeWorldCreationError)
@@ -1486,10 +1607,118 @@ async function readAcceptedAuthority(root) {
         throw new FileNativeWorldCreationError("world_corrupt", "Play Authority durable data is corrupt", { cause: error });
     }
 }
+async function readMaterializedCheckpoint(root) {
+    const value = await readOptionalJson(join(root, "runtime", "materialized-head.json"));
+    if (value === null)
+        return null;
+    if (!isRecord(value) ||
+        !hasExactKeys(value, [
+            "schemaVersion",
+            "head",
+            "sequence",
+            "commitDigest",
+        ]) ||
+        value.schemaVersion !== 2 ||
+        typeof value.head !== "string" ||
+        !Number.isSafeInteger(value.sequence) ||
+        Number(value.sequence) < 0 ||
+        (value.commitDigest !== null &&
+            (typeof value.commitDigest !== "string" ||
+                !/^[a-f0-9]{64}$/u.test(value.commitDigest))) ||
+        (Number(value.sequence) === 0
+            ? value.head !== "genesis" || value.commitDigest !== null
+            : value.head !== `commit:${String(value.sequence)}` ||
+                value.commitDigest === null))
+        throw new FileNativeWorldCreationError("world_corrupt", "Materialized world checkpoint has an invalid shape");
+    return value;
+}
+function sameMaterializedEndpoint(checkpoint, authority) {
+    return (checkpoint !== null &&
+        checkpoint.head === authority.head &&
+        checkpoint.sequence === authority.sequence &&
+        checkpoint.commitDigest === authority.commitDigest);
+}
+async function readAuthorityTail(root, authority, checkpoint) {
+    const targetDigest = checkpoint?.commitDigest ?? null;
+    const targetHead = checkpoint?.head ?? "genesis";
+    const targetSequence = checkpoint?.sequence ?? 0;
+    if (targetSequence > authority.sequence)
+        throw new FileNativeWorldCreationError("world_corrupt", "Materialized checkpoint is ahead of Authority");
+    const reverse = [];
+    let digest = authority.commitDigest;
+    let expectedHead = authority.head;
+    let expectedSequence = authority.sequence;
+    while (digest !== targetDigest) {
+        if (digest === null)
+            throw new FileNativeWorldCreationError("world_corrupt", "Materialized checkpoint is not an ancestor of Authority");
+        const commit = await readPlayCommitByDigest(root, digest);
+        if (commit.head !== expectedHead || commit.sequence !== expectedSequence)
+            throw new FileNativeWorldCreationError("world_corrupt", "Authority tail does not match its immutable commit chain");
+        reverse.push(commit);
+        digest = commit.parentCommitDigest;
+        expectedHead = commit.parentHead;
+        expectedSequence -= 1;
+    }
+    if (expectedHead !== targetHead || expectedSequence !== targetSequence)
+        throw new FileNativeWorldCreationError("world_corrupt", "Materialized checkpoint identity does not match Authority ancestry");
+    return reverse.reverse();
+}
+function genesisAuthorityHead() {
+    return {
+        schemaVersion: 2,
+        head: "genesis",
+        sequence: 0,
+        commitDigest: null,
+        operationId: null,
+    };
+}
+async function readAuthorityHead(root) {
+    const value = await readJson(join(root, "runtime", playAuthorityHeadFile));
+    assertFileNativePlayAuthorityHead(value);
+    return value;
+}
+function assertFileNativePlayAuthorityHead(value) {
+    if (!isRecord(value) ||
+        !hasExactKeys(value, [
+            "schemaVersion",
+            "head",
+            "sequence",
+            "commitDigest",
+            "operationId",
+        ]) ||
+        value.schemaVersion !== 2 ||
+        typeof value.head !== "string" ||
+        !Number.isSafeInteger(value.sequence) ||
+        Number(value.sequence) < 0 ||
+        (value.commitDigest !== null &&
+            (typeof value.commitDigest !== "string" ||
+                !/^[a-f0-9]{64}$/u.test(value.commitDigest))) ||
+        (value.operationId !== null && typeof value.operationId !== "string") ||
+        (Number(value.sequence) === 0
+            ? value.head !== "genesis" ||
+                value.commitDigest !== null ||
+                value.operationId !== null
+            : value.head !== `commit:${String(value.sequence)}` ||
+                value.commitDigest === null ||
+                value.operationId === null))
+        throw new Error("Play Authority head has an invalid shape");
+}
+function playCommitDigest(commit) {
+    return createHash("sha256").update(JSON.stringify(commit)).digest("hex");
+}
+async function readPlayCommitByDigest(root, digest) {
+    if (!/^[a-f0-9]{64}$/u.test(digest))
+        throw corruptOperationOutcome();
+    const value = await readJson(join(root, "runtime", "play-commits", `${digest}.json`));
+    assertFileNativePlayCommit(value);
+    if (playCommitDigest(value) !== digest)
+        throw new FileNativeWorldCreationError("world_corrupt", "Immutable play commit does not match its durable identity");
+    return value;
+}
 function assertFileNativePlayAuthority(value) {
     if (!isRecord(value) ||
         !hasExactKeys(value, ["schemaVersion", "head", "commits"]) ||
-        value.schemaVersion !== 1 ||
+        value.schemaVersion !== 2 ||
         typeof value.head !== "string" ||
         !Array.isArray(value.commits))
         throw new Error("Play Authority has an invalid shape");
@@ -1497,6 +1726,7 @@ function assertFileNativePlayAuthority(value) {
     const heads = new Set();
     const commitsByHead = new Map();
     let parent = "genesis";
+    let parentDigest = null;
     for (const [index, commit] of value.commits.entries()) {
         assertFileNativePlayCommit(commit);
         const revision = commit.timelineRevision;
@@ -1507,6 +1737,8 @@ function assertFileNativePlayAuthority(value) {
             ? replaced.timelineRevision.restoresHead
             : replaced?.parentHead;
         if (commit.parentHead !== parent ||
+            commit.parentCommitDigest !== parentDigest ||
+            commit.sequence !== index + 1 ||
             commit.head !== `commit:${index + 1}` ||
             operationIds.has(commit.operationId) ||
             heads.has(commit.head) ||
@@ -1521,6 +1753,7 @@ function assertFileNativePlayAuthority(value) {
         heads.add(commit.head);
         commitsByHead.set(commit.head, commit);
         parent = commit.head;
+        parentDigest = playCommitDigest(commit);
     }
     if (value.head !== parent)
         throw new Error("Play Authority head is invalid");
@@ -1532,8 +1765,10 @@ function assertFileNativePlayCommit(value) {
     const timelineRevision = value.mode === "timeline_revision";
     if (!hasExactKeys(value, [
         "schemaVersion",
+        "sequence",
         "operationId",
         "parentHead",
+        "parentCommitDigest",
         "head",
         "mode",
         "historyAppend",
@@ -1542,13 +1777,20 @@ function assertFileNativePlayCommit(value) {
         ...(correction ? ["correctionTargets", "corrects"] : []),
         ...(timelineRevision ? ["timelineRevision"] : []),
     ]) ||
-        value.schemaVersion !== 1 ||
+        value.schemaVersion !== 2 ||
+        !Number.isSafeInteger(value.sequence) ||
+        Number(value.sequence) < 1 ||
         typeof value.operationId !== "string" ||
         value.operationId.trim() === "" ||
         typeof value.parentHead !== "string" ||
         !/^(?:genesis|commit:[1-9][0-9]*)$/u.test(value.parentHead) ||
+        (value.parentCommitDigest !== null &&
+            (typeof value.parentCommitDigest !== "string" ||
+                !/^[a-f0-9]{64}$/u.test(value.parentCommitDigest))) ||
+        (value.parentHead === "genesis") !== (value.parentCommitDigest === null) ||
         typeof value.head !== "string" ||
         !/^commit:[1-9][0-9]*$/u.test(value.head) ||
+        value.head !== `commit:${String(value.sequence)}` ||
         (value.mode !== "play" &&
             value.mode !== "correction" &&
             value.mode !== "timeline_revision") ||
@@ -1666,19 +1908,6 @@ function isFileNativeStateChange(value) {
     }
     return true;
 }
-async function readDirectoryFileNames(root) {
-    try {
-        return (await readdir(root, { withFileTypes: true }))
-            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
-            .map((entry) => entry.name)
-            .sort();
-    }
-    catch (error) {
-        if (isNodeError(error) && error.code === "ENOENT")
-            return [];
-        throw error;
-    }
-}
 async function materializePlayCommit(root, sequence, input) {
     if (input.mode === "timeline_revision") {
         if (input.timelineRevision === undefined)
@@ -1782,6 +2011,26 @@ function historySurfaceFiles(messages) {
         };
     });
 }
+function materializedHistoryRecord(worldId, files) {
+    const result = {};
+    for (const file of files) {
+        const match = /^(\d{8})-(\d+)-(player|narrator)-[a-f0-9]{12}\.md$/u.exec(file.path);
+        if (match === null)
+            throw new FileNativeWorldCreationError("world_corrupt", `Materialized history path is invalid: ${file.path}`);
+        const sequence = Number.parseInt(match[1], 10);
+        const index = Number.parseInt(match[2], 10);
+        const role = match[3];
+        const messageId = sequence === 0
+            ? index === 1 && role === "narrator"
+                ? `${worldId}.message.genesis.narrator`
+                : `${worldId}.message.genesis.${index}.${role}`
+            : `${worldId}.message.${sequence}.${index}.${role}`;
+        if (messageId in result)
+            throw new FileNativeWorldCreationError("world_corrupt", `Materialized history contains a duplicate message: ${messageId}`);
+        result[messageId] = file.contents;
+    }
+    return result;
+}
 async function writeIdempotentText(path, contents) {
     try {
         const existing = await readFile(path, "utf8");
@@ -1825,11 +2074,13 @@ function cloneAuthorityPrefix(input) {
         ...structuredClone(message),
         messageId: messageIds.get(message.messageId),
     }));
-    return {
-        genesisHistory: rewriteHistory(input.sourceGenesis.history),
-        genesisMaterials: rewriteMaterials(input.sourceGenesis.additionalMaterials, messageIds, input.sourceWorldId, input.targetWorldId),
-        commits: sourceCommits.map((commit) => ({
+    const clonedCommits = [];
+    let parentCommitDigest = null;
+    for (const commit of sourceCommits) {
+        const cloned = {
             ...structuredClone(commit),
+            schemaVersion: 2,
+            parentCommitDigest,
             operationId: `clone-${operationDigest(`${input.targetWorldId}\0${commit.head}`).slice(0, 56)}`,
             historyAppend: rewriteHistory(commit.historyAppend),
             nextAdditionalMaterials: rewriteMaterials(commit.nextAdditionalMaterials, messageIds, input.sourceWorldId, input.targetWorldId),
@@ -1841,7 +2092,14 @@ function cloneAuthorityPrefix(input) {
                         replacementHistory: rewriteHistory(commit.timelineRevision.replacementHistory),
                     },
                 }),
-        })),
+        };
+        clonedCommits.push(cloned);
+        parentCommitDigest = playCommitDigest(cloned);
+    }
+    return {
+        genesisHistory: rewriteHistory(input.sourceGenesis.history),
+        genesisMaterials: rewriteMaterials(input.sourceGenesis.additionalMaterials, messageIds, input.sourceWorldId, input.targetWorldId),
+        commits: clonedCommits,
     };
 }
 function rewriteMaterials(materials, messageIds, sourceWorldId, targetWorldId) {