narraeon 0.6.0 → 0.6.2

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

@@ -3,201 +3,62 @@ import { isWorldExtensionControl, } from "../../protocol/worldExtensions.js";
 import { Buffer } from "node:buffer";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { createHash, randomUUID } from "node:crypto";
-import { mkdir, open, readdir, readFile, readlink, rename, rm, stat, } from "node:fs/promises";
-import { dirname, join, resolve } from "node:path";
+import { readdir, readFile, rm } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { tmpdir } from "node:os";
-import { validatePlayPresetArtifactPayload, isFrozenArtifactPresentation, } from "../play/FileNativePlayPresetStore.js";
-export class ArtifactStoreInvariantError extends Error {
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ArtifactStoreInvariantError";
-    }
-}
-export class ArtifactStoreCorruptionError extends ArtifactStoreInvariantError {
-    constructor(message, options) {
-        super(message, options);
-        this.name = "ArtifactStoreCorruptionError";
-    }
-}
+import { worldQueueFor } from "../world/WorldQueue.js";
+import { validatePlayPresetArtifactPayload, } from "../play/FileNativePlayPresetStore.js";
+import { ArtifactStoreCorruptionError, ArtifactStoreInvariantError, artifactSequenceFileName, assertOperation, assertRawRecord, hasExactKeys, identityHash, isJsonValue, isMissing, isRecord, parseArtifactJson, payloadFingerprint, rawRecordFingerprint, stableSerialize, validAttachment, headOrdinal, writeArtifactJson, } from "./ArtifactStoreFiles.js";
+import { hasLegacyArtifactState, migrateLegacyArtifactStore, } from "./LegacyArtifactStoreMigration.js";
+export { ArtifactStoreCorruptionError, ArtifactStoreInvariantError };
 const maxPayloadBytes = 4 * 1024 * 1024;
 /**
- * File-native artifact module. Raw records never change after publication;
- * projection events and operation state are the only mutable layers. The
- * public interface deliberately exposes no filesystem paths or provider
- * transcript and is the seam used by the play-call-chain coordinator and tests.
+ * File-native artifact module. Artifacts live in the world directory as
+ * `artifacts/records/<sequence>.json` and `artifacts/operations/<hash>.json`.
+ * A record carries its own status and head and is updated in place; there is
+ * no event log. Forks and archives copy the world directory and then rewrite
+ * identities with {@link forkArtifactClosure}.
  */
 export class FileNativeArtifactStore {
-    #root;
-    #extensionControls;
+    #dataRoot;
     #worldsRoot;
+    #extensionControls;
+    /** Records with `save: "none"` are never written to disk. */
     #memoryRecords = new Map();
-    #memoryEvents = new Map();
     #mutationContext = new AsyncLocalStorage();
     constructor(dataRoot) {
-        this.#root = join(resolve(dataRoot), "artifact-store");
-        this.#extensionControls = new WorldExtensionRequests(join(resolve(dataRoot), "worlds-file-native"));
-        this.#worldsRoot = join(resolve(dataRoot), "worlds-file-native");
+        this.#dataRoot = resolve(dataRoot);
+        this.#worldsRoot = join(this.#dataRoot, "worlds-file-native");
+        this.#extensionControls = new WorldExtensionRequests(this.#worldsRoot);
     }
-    /** Control acceptance and artifact publication share one persistent lock.
-     * Callers holding the Authority lock always acquire it before this lock. */
+    /** Control acceptance and artifact publication share the in-process world queue. */
     static withWorldControlsMutation(dataRoot, worldId, action) {
-        return withArtifactWorldLock(artifactWorldLockPath(dataRoot, worldId), action);
-    }
-    /** The immutable closure publishes atomically with the derived world. */
-    async stageFork(input) {
-        await this.#withWorldMutation(input.sourceWorldId, async () => {
-            const projection = await this.readActiveProjection(input.sourceWorldId, undefined, input.timeline);
-            const retained = new Set(projection
-                .filter((item) => item.save === "commit" && item.attachment !== undefined)
-                .map((item) => item.recordId));
-            const effective = (await this.#effectiveRecords(input.sourceWorldId)).filter(({ record }) => retained.has(record.recordId));
-            const operations = [];
-            const records = [];
-            const events = [];
-            let sequence = Math.max(0, ...effective.map(({ record }) => record.sequence));
-            for (const { record, head } of effective) {
-                const source = (await this.#readOperation(record.operationId));
-                const operationId = `artifact-fork:${input.targetWorldId}:${identityHash(record.operationId)}`;
-                if (!operations.some((operation) => operation.context.operationId === operationId)) {
-                    operations.push({
-                        ...source,
-                        context: {
-                            ...source.context,
-                            worldId: input.targetWorldId,
-                            operationId,
-                        },
-                    });
-                }
-                const copy = {
-                    ...record,
-                    worldId: input.targetWorldId,
-                    operationId,
-                    sequence: record.sequence,
-                };
-                copy.recordFingerprint = rawRecordFingerprint(copy);
-                records.push(copy);
-                events.push({
-                    schemaVersion: 1,
-                    kind: "activate",
-                    sequence: ++sequence,
-                    operationId,
-                    recordId: copy.recordId,
-                });
-                events.push({
-                    schemaVersion: 1,
-                    kind: "bind_head",
-                    sequence: ++sequence,
-                    operationId,
-                    recordId: copy.recordId,
-                    head: head,
-                });
-            }
-            const snapshot = {
-                schemaVersion: 1,
-                worldId: input.targetWorldId,
-                operations,
-                records,
-                events,
-            };
-            await mkdir(join(input.targetWorldRoot, "runtime"), { recursive: true });
-            await writeDurableJson(join(input.targetWorldRoot, "runtime", "artifact-fork.json"), snapshot, true);
-        });
+        return worldQueueFor(resolve(dataRoot)).run(worldId, action);
     }
-    async #ensureForkRestored(worldId) {
-        if (dirname(resolve(this.#worldsRoot, worldId)) !== this.#worldsRoot)
-            return;
-        try {
-            await stat(join(this.#worldRoot(worldId), "fork-restored.json"));
-            return;
-        }
-        catch (error) {
-            if (!isMissing(error))
-                throw error;
-        }
-        try {
-            await stat(join(this.#worldsRoot, worldId, "runtime", "artifact-fork.json"));
-        }
-        catch (error) {
-            if (isMissing(error))
-                return;
-            throw error;
-        }
-        await this.#withWorldMutation(worldId, () => Promise.resolve());
-    }
-    async #restoreFork(worldId) {
-        if (dirname(resolve(this.#worldsRoot, worldId)) !== this.#worldsRoot)
-            return;
-        const marker = join(this.#worldRoot(worldId), "fork-restored.json");
-        try {
-            await readFile(marker);
-            return;
-        }
-        catch (error) {
-            if (!isMissing(error))
-                throw error;
-        }
-        let snapshot;
-        try {
-            snapshot = parseArtifactJson(await readFile(join(this.#worldsRoot, worldId, "runtime", "artifact-fork.json"), "utf8"), "artifact fork");
-        }
-        catch (error) {
-            if (isMissing(error))
+    async finishRequest(context, failed) {
+        await this.#withWorldMutation(context.worldId, async () => {
+            const operation = await this.#readOperation(context.worldId, context.operationId);
+            if (operation?.requestAttempts[context.requestId] !== context.requestAttempt)
                 return;
-            throw error;
-        }
-        if (!isRecord(snapshot) ||
-            !hasExactKeys(snapshot, [
-                "schemaVersion",
-                "worldId",
-                "operations",
-                "records",
-                "events",
-            ]) ||
-            snapshot.schemaVersion !== 1 ||
-            snapshot.worldId !== worldId ||
-            !Array.isArray(snapshot.operations) ||
-            !Array.isArray(snapshot.records) ||
-            !Array.isArray(snapshot.events))
-            throw new ArtifactStoreCorruptionError("Artifact fork snapshot is invalid");
-        for (const operation of snapshot.operations) {
-            assertOperation(operation);
-            if (operation.context.worldId !== worldId)
-                throw new ArtifactStoreCorruptionError("Artifact fork world mismatch");
-        }
-        for (const record of snapshot.records) {
-            assertRawRecord(record);
-            if (record.worldId !== worldId ||
-                !snapshot.operations.some((operation) => operation.context.operationId === record.operationId))
-                throw new ArtifactStoreCorruptionError("Artifact fork record mismatch");
-        }
-        for (const event of snapshot.events) {
-            assertEvent(event);
-            if (!snapshot.records.some((record) => record.recordId === event.recordId &&
-                record.operationId === event.operationId))
-                throw new ArtifactStoreCorruptionError("Artifact fork event mismatch");
-        }
-        // No mutation can start until this idempotent restore finishes under the world lock.
-        for (const operation of snapshot.operations)
-            await this.#writeOperation(operation);
-        for (const record of snapshot.records)
-            await writeDurableJson(join(this.#worldRoot(worldId), "records", artifactSequenceFileName(record.sequence)), record, false);
-        for (const event of snapshot.events)
-            await writeDurableJson(join(this.#worldRoot(worldId), "events", artifactSequenceFileName(event.sequence)), event, false);
-        await mkdir(this.#worldRoot(worldId), { recursive: true });
-        await writeDurableJson(marker, { schemaVersion: 1 }, false);
+            await this.#writeOperation({
+                ...operation,
+                requests: (operation.requests ?? []).map((item) => item.requestId === context.requestId
+                    ? { ...item, status: failed ? "failed" : "completed" }
+                    : item),
+            });
+        });
     }
     async beginOperation(context) {
         return this.#withWorldMutation(context.worldId, () => this.#beginOperation(context));
     }
     async #beginOperation(context) {
         assertContext(context);
-        const existing = await this.#readOperation(context.operationId);
+        const existing = await this.#readOperation(context.worldId, context.operationId);
         if (existing !== null && !sameContext(existing.context, context))
             throw new ArtifactStoreInvariantError("Artifact operation is bound to a different frozen payload");
         // A direct orchestrator/store caller must not rely on a later UI read to
-        // invalidate artifacts bound to the parent head. This call is safe on a
-        // retry because projection events are appended idempotently below.
-        await this.reconcileHead(context.worldId, context.parentHead, context.operationId);
+        // invalidate artifacts bound to the parent head.
+        await this.#reconcileHead(context.worldId, context.parentHead, context.operationId);
         const priorOperations = await this.#operationsForWorld(context.worldId);
         if (existing === null)
             await this.#writeOperation({
@@ -209,31 +70,24 @@ export class FileNativeArtifactStore {
                 artifactProjectionStatus: "active",
                 requestAttempts: {},
             });
-        // Operation state is indexed independently of raw records. This closes the
-        // no-artifact gap: a running/unknown extension is superseded even when it
-        // has not emitted anything yet. Its execution status is retained unless it
-        // is an actually open extension, while projection invalidation is tracked
-        // separately for late raw results.
-        const prior = await this.#effectiveRecords(context.worldId);
+        // An open extension is superseded even when it has not emitted anything
+        // yet; its execution status is kept unless it is actually open.
+        const records = await this.#records(context.worldId);
         for (const priorOperation of priorOperations) {
             if (priorOperation.context.operationId === context.operationId)
                 continue;
             const openExtension = isOpenExtension(priorOperation);
             const operationAlreadySuperseded = priorOperation.artifactProjectionStatus === "superseded";
-            const priorRecords = prior.filter(({ record, status }) => record.operationId === priorOperation.context.operationId &&
-                status === "active");
-            const invalidatedRecords = priorRecords.filter(({ record }) => openExtension ||
-                operationAlreadySuperseded ||
-                record.invalidation === "new_operation");
-            for (const item of invalidatedRecords)
-                await this.#appendEventOnce({
-                    schemaVersion: 1,
-                    kind: "supersede",
-                    operationId: item.record.operationId,
-                    recordId: item.record.recordId,
-                    reason: "new_operation",
-                    sequence: await this.#nextSequence(context.worldId),
-                });
+            for (const record of records) {
+                if (record.operationId !== priorOperation.context.operationId ||
+                    record.status !== "active")
+                    continue;
+                if (!(openExtension ||
+                    operationAlreadySuperseded ||
+                    record.invalidation === "new_operation"))
+                    continue;
+                await this.#putRecord({ ...record, status: "superseded" });
+            }
             if (openExtension) {
                 const next = {
                     ...priorOperation,
@@ -241,8 +95,7 @@ export class FileNativeArtifactStore {
                     extensionStatus: "superseded",
                     message: "This extension was superseded by a newer operation",
                 };
-                if (JSON.stringify(next) !== JSON.stringify(priorOperation))
-                    await this.#writeOperation(next);
+                await this.#writeOperation(next);
             }
         }
     }
@@ -251,7 +104,7 @@ export class FileNativeArtifactStore {
     }
     async #beginRequestAttempt(context) {
         assertRequestContext(context);
-        const operation = await this.#readOperation(context.operationId);
+        const operation = await this.#readOperation(context.worldId, context.operationId);
         if (operation === null)
             throw new ArtifactStoreInvariantError("Artifact request attempt is missing an operation checkpoint");
         if (!sameContext(operation.context, context))
@@ -267,7 +120,7 @@ export class FileNativeArtifactStore {
                 ? []
                 : [context.frozenResources.mount])),
         ];
-        operation.requests = [
+        const requests = [
             ...(operation.requests ?? []).filter((item) => item.requestId !== context.requestId),
             {
                 requestId: context.requestId,
@@ -279,48 +132,63 @@ export class FileNativeArtifactStore {
         const current = operation.requestAttempts[context.requestId];
         if (current !== undefined && context.requestAttempt < current)
             return;
-        // Persist the monotonic marker before projection events. If a process dies
-        // between these writes, cold rebuild still treats the old attempt as
-        // stale, and a retry below completes the missing supersede events.
-        if (current === undefined || context.requestAttempt > current) {
+        if (current === undefined || context.requestAttempt > current)
             await this.#writeOperation({
                 ...operation,
+                requests,
                 requestAttempts: {
                     ...operation.requestAttempts,
                     [context.requestId]: context.requestAttempt,
                 },
             });
+        // A clear made by an earlier attempt of this request is rolled back: that
+        // attempt did not finish, and its retry decides again.
+        const records = await this.#records(context.worldId);
+        for (const record of records) {
+            if (record.status === "cleared" &&
+                record.clearedBy?.operationId === context.operationId &&
+                record.clearedBy.requestId === context.requestId &&
+                record.clearedBy.requestAttempt < context.requestAttempt) {
+                await this.#putRecord({
+                    ...record,
+                    status: record.clearedBy.priorStatus,
+                });
+            }
         }
-        const records = await this.#recordsForOperation(context.operationId);
         for (const record of records) {
-            if (record.requestId !== context.requestId ||
-                record.requestAttempt >= context.requestAttempt)
+            if (record.operationId !== context.operationId ||
+                record.requestId !== context.requestId ||
+                record.requestAttempt >= context.requestAttempt ||
+                record.status === "superseded")
                 continue;
-            const event = {
-                schemaVersion: 1,
-                kind: "supersede",
-                operationId: context.operationId,
-                recordId: record.recordId,
-                requestId: record.requestId,
-                requestAttempt: record.requestAttempt,
-                reason: "request_attempt_superseded",
-                sequence: await this.#nextSequence(context.worldId),
-            };
-            await this.#appendRecordEvent(record, event);
+            await this.#putRecord({ ...record, status: "superseded" });
         }
     }
-    async finishRequest(context, failed) {
-        await this.#withWorldMutation(context.worldId, async () => {
-            const operation = await this.#readOperation(context.operationId);
-            if (operation?.requestAttempts[context.requestId] !== context.requestAttempt)
-                return;
-            await this.#writeOperation({
-                ...operation,
-                requests: (operation.requests ?? []).map((item) => item.requestId === context.requestId
-                    ? { ...item, status: failed ? "failed" : "completed" }
-                    : item),
-            });
-        });
+    /**
+     * Remove the operations and records whose head is after restoredHead. A
+     * rewind discards those rounds, and their replies, attachments and extension
+     * results must not survive on disk (ADR-0045). Each artifact is one file, so
+     * the discard deletes files.
+     */
+    async discardAfterHead(worldId, restoredHead) {
+        return this.#withWorldMutation(worldId, () => this.#discardAfterHead(worldId, restoredHead));
+    }
+    async #discardAfterHead(worldId, restoredHead) {
+        const limit = headOrdinal(restoredHead);
+        const operations = await this.#operationsForWorld(worldId);
+        const discardedOperations = new Set(operations
+            .filter((operation) => headOrdinal(operation.head ?? operation.context.parentHead) > limit)
+            .map(({ context }) => context.operationId));
+        for (const record of await this.#records(worldId)) {
+            if (!discardedOperations.has(record.operationId) &&
+                headOrdinal(record.head ?? record.parentHead) <= limit)
+                continue;
+            await this.#removeRecord(record);
+        }
+        for (const operationId of discardedOperations) {
+            await rm(this.#operationPath(worldId, operationId), { force: true });
+            this.#memoryRecords.delete(operationId);
+        }
     }
     async reconcileHead(worldId, head, exceptOperationId) {
         return this.#withWorldMutation(worldId, () => this.#reconcileHead(worldId, head, exceptOperationId));
@@ -329,26 +197,18 @@ export class FileNativeArtifactStore {
         if (worldId.trim() === "" || head.trim() === "")
             throw new ArtifactStoreInvariantError("Artifact head-reconciliation arguments are invalid");
         const operations = await this.#operationsForWorld(worldId);
-        const effective = await this.#effectiveRecords(worldId);
+        const records = await this.#records(worldId);
         const affected = new Set();
-        for (const item of effective) {
-            const operationId = item.record.operationId;
-            if (operationId === exceptOperationId || item.status !== "active")
+        for (const record of records) {
+            if (record.operationId === exceptOperationId ||
+                record.status !== "active")
                 continue;
-            if (item.record.invalidation !== "head_change")
+            if (record.invalidation !== "head_change")
                 continue;
-            const boundHead = item.head ?? item.record.parentHead;
-            if (boundHead === head)
+            if ((record.head ?? record.parentHead) === head)
                 continue;
-            await this.#appendEventOnce({
-                schemaVersion: 1,
-                kind: "supersede",
-                operationId,
-                recordId: item.record.recordId,
-                reason: "head_change",
-                sequence: await this.#nextSequence(worldId),
-            });
-            affected.add(operationId);
+            await this.#putRecord({ ...record, status: "superseded" });
+            affected.add(record.operationId);
         }
         for (const operation of operations) {
             const operationId = operation.context.operationId;
@@ -357,10 +217,10 @@ export class FileNativeArtifactStore {
             const boundHead = operation.head ?? operation.context.parentHead;
             if (boundHead === head)
                 continue;
-            const hasActiveHeadBoundRecord = effective.some(({ record, status, head: recordHead }) => record.operationId === operationId &&
-                status === "active" &&
+            const hasActiveHeadBoundRecord = records.some((record) => record.operationId === operationId &&
+                record.status === "active" &&
                 record.invalidation === "head_change" &&
-                (recordHead ?? record.parentHead) !== head);
+                (record.head ?? record.parentHead) !== head);
             if (!hasActiveHeadBoundRecord && !isOpenProjectionOperation(operation))
                 continue;
             affected.add(operationId);
@@ -397,7 +257,7 @@ export class FileNativeArtifactStore {
             return artifactFailure(payload.message);
         if (input.toolCallId.trim() === "")
             return artifactFailure("Tool-call ID cannot be empty");
-        const operation = await this.#readOperation(input.context.operationId);
+        const operation = await this.#readOperation(input.context.worldId, input.context.operationId);
         if (operation === null)
             throw new ArtifactStoreInvariantError("Artifact emit is missing an operation checkpoint");
         if (!sameContext(operation.context, input.context))
@@ -407,12 +267,13 @@ export class FileNativeArtifactStore {
             throw new ArtifactStoreInvariantError("Artifact emit request attempt is not registered");
         const fingerprint = payloadFingerprint(input.output, payload.value);
         const callFingerprint = artifactCallFingerprint("artifact_emit", input.context, { output: declaration.name, payload: payload.value });
-        const prior = await this.#recordsForOperation(input.context.operationId);
+        const prior = await this.#recordsForOperation(input.context.worldId, input.context.operationId);
+        // A tool-call ID is an identity only within one operation. A cold retry
+        // re-calls the model and gets new IDs (ADR-0044), so no wider ledger exists.
         const previousByCall = prior.find((record) => record.toolCallId === input.toolCallId);
         if (previousByCall !== undefined) {
             if (previousByCall.callFingerprint !== callFingerprint)
                 return artifactFailure("The same artifact tool-call ID is bound to different arguments");
-            await this.#repairRecordPublication(previousByCall, operation, currentAttempt);
             return {
                 ok: true,
                 idempotent: true,
@@ -420,10 +281,6 @@ export class FileNativeArtifactStore {
                 markdown: `# Runtime artifact already exists\n\noutput=${input.output}`,
             };
         }
-        const previousEvent = (await this.#events(input.context.worldId)).find((event) => event.operationId === input.context.operationId &&
-            event.toolCallId === input.toolCallId);
-        if (previousEvent !== undefined)
-            return artifactFailure("The same artifact tool-call ID is bound to a different tool call");
         const staleAttempt = currentAttempt !== input.context.requestAttempt;
         const sameOutput = prior.filter((record) => record.requestId === input.context.requestId &&
             record.requestAttempt === input.context.requestAttempt &&
@@ -439,135 +296,38 @@ export class FileNativeArtifactStore {
             .reduce((total, record) => total + byteLength(record.payload, record.contentType), 0);
         if (totalBytes + payloadBytes > input.context.maxArtifactBytes)
             return artifactFailure("Follow-up request artifacts exceed maxArtifactBytes");
-        const record = await this.#newRecord(input, declaration, payload.value, fingerprint, callFingerprint);
+        const sequence = await this.#nextSequence(input.context.worldId);
+        const base = newRecord(input, declaration, payload.value, {
+            sequence,
+            fingerprint,
+            callFingerprint,
+        });
         const stale = isStaleOperation(operation) ||
             staleAttempt ||
-            !(await this.#extensionControls.visible(record.worldId, record));
-        if (declaration.save === "none") {
-            const records = this.#memoryRecords.get(input.context.operationId) ?? [];
-            records.push(record);
-            this.#memoryRecords.set(input.context.operationId, records);
-            await this.#appendRecordEvent(record, {
-                schemaVersion: 1,
-                kind: stale ? "supersede" : "activate",
-                sequence: await this.#nextSequence(input.context.worldId),
-                operationId: input.context.operationId,
-                recordId: record.recordId,
-                requestId: record.requestId,
-                requestAttempt: record.requestAttempt,
-                ...(stale ? { reason: "late_superseded_operation_result" } : {}),
-            });
-            if (!stale &&
-                operation?.status === "core_committed" &&
-                operation.head !== undefined) {
-                await this.#appendRecordEvent(record, {
-                    schemaVersion: 1,
-                    kind: "bind_head",
-                    sequence: await this.#nextSequence(input.context.worldId),
-                    operationId: input.context.operationId,
-                    recordId: record.recordId,
-                    head: operation.head,
-                });
-            }
-        }
-        else {
-            await this.#appendRaw(record);
-            if (stale)
-                await this.#appendRecordEvent(record, {
-                    schemaVersion: 1,
-                    kind: "supersede",
-                    sequence: await this.#nextSequence(input.context.worldId),
-                    operationId: input.context.operationId,
-                    recordId: record.recordId,
-                    requestId: record.requestId,
-                    requestAttempt: record.requestAttempt,
-                    reason: "late_superseded_operation_result",
-                });
-            else if (operation?.status === "core_committed" &&
-                operation.head !== undefined) {
-                await this.#appendRecordEvent(record, {
-                    schemaVersion: 1,
-                    kind: "bind_head",
-                    sequence: await this.#nextSequence(input.context.worldId),
-                    operationId: input.context.operationId,
-                    recordId: record.recordId,
-                    head: operation.head,
-                });
-                await this.#appendRecordEvent(record, {
-                    schemaVersion: 1,
-                    kind: "activate",
-                    sequence: await this.#nextSequence(input.context.worldId),
-                    operationId: input.context.operationId,
-                    recordId: record.recordId,
-                });
-            }
-            else if (declaration.save === "operation")
-                await this.#appendRecordEvent(record, {
-                    schemaVersion: 1,
-                    kind: "activate",
-                    sequence: await this.#nextSequence(input.context.worldId),
-                    operationId: input.context.operationId,
-                    recordId: record.recordId,
-                });
-        }
+            !(await this.#extensionControls.visible(base.worldId, base));
+        const committed = !stale &&
+            operation.status === "core_committed" &&
+            operation.head !== undefined;
+        // A stale result is kept as superseded. A live result is active when its
+        // core committed or when it does not wait for the core; a commit-saved
+        // result waits as pending until markCoreCommitted binds it.
+        const status = stale
+            ? "superseded"
+            : committed || declaration.save !== "commit"
+                ? "active"
+                : "pending";
+        const record = {
+            ...base,
+            status,
+            head: committed ? (operation.head ?? null) : null,
+        };
+        await this.#putRecord(record);
         return {
             ok: true,
             recordId: record.recordId,
             markdown: `# Runtime artifact accepted\n\noutput=${input.output}`,
         };
     }
-    async #repairRecordPublication(record, operation, currentAttempt) {
-        const events = await this.#events(record.worldId);
-        const hasEvent = (kind, head) => events.some((event) => event.kind === kind &&
-            event.operationId === record.operationId &&
-            event.recordId === record.recordId &&
-            (head === undefined || event.head === head));
-        const stale = isStaleOperation(operation) ||
-            currentAttempt !== record.requestAttempt ||
-            !(await this.#extensionControls.visible(record.worldId, record));
-        if (stale) {
-            if (!hasEvent("supersede"))
-                await this.#appendRecordEvent(record, {
-                    schemaVersion: 1,
-                    kind: "supersede",
-                    sequence: await this.#nextSequence(record.worldId),
-                    operationId: record.operationId,
-                    recordId: record.recordId,
-                    requestId: record.requestId,
-                    requestAttempt: record.requestAttempt,
-                    reason: "late_superseded_operation_result",
-                });
-            return;
-        }
-        if (operation.status === "core_committed" && operation.head !== undefined) {
-            if (!hasEvent("bind_head", operation.head))
-                await this.#appendRecordEvent(record, {
-                    schemaVersion: 1,
-                    kind: "bind_head",
-                    sequence: await this.#nextSequence(record.worldId),
-                    operationId: record.operationId,
-                    recordId: record.recordId,
-                    head: operation.head,
-                });
-            if (!hasEvent("activate"))
-                await this.#appendRecordEvent(record, {
-                    schemaVersion: 1,
-                    kind: "activate",
-                    sequence: await this.#nextSequence(record.worldId),
-                    operationId: record.operationId,
-                    recordId: record.recordId,
-                });
-            return;
-        }
-        if (record.save === "operation" && !hasEvent("activate"))
-            await this.#appendRecordEvent(record, {
-                schemaVersion: 1,
-                kind: "activate",
-                sequence: await this.#nextSequence(record.worldId),
-                operationId: record.operationId,
-                recordId: record.recordId,
-            });
-    }
     async clear(input) {
         return this.#withWorldMutation(input.context.worldId, () => this.#clear(input));
     }
@@ -578,7 +338,7 @@ export class FileNativeArtifactStore {
             return artifactFailure(`Undeclared artifact output: ${input.output}`);
         if (input.toolCallId.trim() === "")
             return artifactFailure("Tool-call ID cannot be empty");
-        const operation = await this.#readOperation(input.context.operationId);
+        const operation = await this.#readOperation(input.context.worldId, input.context.operationId);
         if (operation === null)
             throw new ArtifactStoreInvariantError("Artifact clear is missing an operation checkpoint");
         if (!sameContext(operation.context, input.context))
@@ -586,68 +346,37 @@ export class FileNativeArtifactStore {
         const currentAttempt = operation.requestAttempts[input.context.requestId];
         if (currentAttempt === undefined)
             throw new ArtifactStoreInvariantError("Artifact clear request attempt is not registered");
-        const clearFingerprint = artifactCallFingerprint("artifact_clear", input.context, { output: declaration.name });
-        const records = await this.#recordsForOperation(input.context.operationId);
-        const prior = records.find((record) => record.toolCallId === input.toolCallId);
-        if (prior !== undefined)
+        const prior = await this.#recordsForOperation(input.context.worldId, input.context.operationId);
+        if (prior.some((record) => record.toolCallId === input.toolCallId))
             return artifactFailure("The same artifact tool-call ID is bound to a different tool call");
-        const priorCall = (await this.#events(input.context.worldId)).find((event) => event.operationId === input.context.operationId &&
-            event.toolCallId === input.toolCallId);
-        if (priorCall !== undefined) {
-            if (priorCall.callFingerprint !== clearFingerprint)
-                return artifactFailure("The same artifact tool-call ID is bound to different arguments");
-            return {
-                ok: true,
-                idempotent: true,
-                markdown: `# Runtime artifact clear confirmed\n\noutput=${input.output}`,
-            };
-        }
         const staleAttempt = currentAttempt !== input.context.requestAttempt;
         if (isStaleOperation(operation) ||
             staleAttempt ||
-            !(await this.#extensionControls.visible(input.context.worldId, input.context))) {
-            const event = {
-                schemaVersion: 1,
-                kind: "ignored_call",
-                operationId: input.context.operationId,
-                output: declaration.name,
-                channel: declaration.channel,
-                ...(declaration.key === undefined ? {} : { key: declaration.key }),
-                reason: "stale_clear_ignored",
-                sequence: await this.#nextSequence(input.context.worldId),
-                toolCallId: input.toolCallId,
-                toolName: "artifact_clear",
-                callFingerprint: clearFingerprint,
-                requestId: input.context.requestId,
-                requestAttempt: input.context.requestAttempt,
-            };
-            // An ignored stale call is a durable identity ledger even for save:none:
-            // no raw payload is persisted, but a cold retry must distinguish the
-            // exact same call from a changed request/attempt/parameter.
-            await this.#appendEventOnce(event);
+            !(await this.#extensionControls.visible(input.context.worldId, input.context)))
             return {
                 ok: true,
                 markdown: `# Runtime artifact clear ignored\n\noutput=${input.output}`,
             };
+        // Projection clears are durable even for save:none records. Only the raw
+        // payload is ephemeral, so a cold restart cannot resurrect an old panel.
+        for (const record of await this.#records(input.context.worldId)) {
+            if (record.status === "superseded" ||
+                record.status === "cleared" ||
+                record.channel !== declaration.channel ||
+                record.output !== declaration.name ||
+                (declaration.key !== undefined && record.key !== declaration.key))
+                continue;
+            await this.#putRecord({
+                ...record,
+                status: "cleared",
+                clearedBy: {
+                    operationId: input.context.operationId,
+                    requestId: input.context.requestId,
+                    requestAttempt: input.context.requestAttempt,
+                    priorStatus: record.status,
+                },
+            });
         }
-        const event = {
-            schemaVersion: 1,
-            kind: "clear",
-            operationId: input.context.operationId,
-            output: declaration.name,
-            channel: declaration.channel,
-            ...(declaration.key === undefined ? {} : { key: declaration.key }),
-            reason: "explicit_clear",
-            sequence: await this.#nextSequence(input.context.worldId),
-            toolCallId: input.toolCallId,
-            toolName: "artifact_clear",
-            callFingerprint: clearFingerprint,
-            requestId: input.context.requestId,
-            requestAttempt: input.context.requestAttempt,
-        };
-        // Projection clears are durable even for save:none. Only the raw payload
-        // is ephemeral; otherwise a cold restart would resurrect an old panel.
-        await this.#appendEventOnce(event);
         return {
             ok: true,
             markdown: `# Runtime artifact clear confirmed\n\noutput=${input.output}`,
@@ -660,7 +389,7 @@ export class FileNativeArtifactStore {
         assertContext(context);
         if (head.trim() === "")
             throw new ArtifactStoreInvariantError("Core commit head is invalid");
-        const operation = await this.#readOperation(context.operationId);
+        const operation = await this.#readOperation(context.worldId, context.operationId);
         if (operation === null)
             throw new ArtifactStoreInvariantError("Core commit is missing an artifact-operation checkpoint");
         if (!sameContext(operation.context, context))
@@ -675,112 +404,50 @@ export class FileNativeArtifactStore {
         if (operation.status === "core_committed") {
             if (operation.head !== head)
                 throw new ArtifactStoreInvariantError("Committed artifact operation has a conflicting core head");
-            await this.#activateCommittedRecords(operation, context, head);
+            await this.#activateCommittedRecords(operation, head);
             return;
         }
-        const recoveredFromMaterializationPending = operation.status === "core_materialization_pending";
-        if (recoveredFromMaterializationPending && operation.head !== head)
-            throw new ArtifactStoreInvariantError("Artifact operation awaiting materialization has a conflicting core head");
-        await this.reconcileHead(context.worldId, head, context.operationId);
+        await this.#reconcileHead(context.worldId, head, context.operationId);
         const committed = {
             ...operation,
             status: "core_committed",
-            extensionStatus: recoveredFromMaterializationPending
-                ? "not_started"
-                : operation.extensionStatus,
-            ...(recoveredFromMaterializationPending ? { completedRequests: [] } : {}),
             head,
         };
-        if (recoveredFromMaterializationPending)
-            delete committed.message;
-        // Persist the receipt/head before projection events. A crash after this
+        // The head is persisted before records bind to it. A crash after this
         // write is repaired by the idempotent same-head path above.
         await this.#writeOperation(committed);
-        await this.#activateCommittedRecords(committed, context, head);
-    }
-    async markCoreMaterializationPending(context, head, message) {
-        return this.#withWorldMutation(context.worldId, () => this.#markCoreMaterializationPending(context, head, message));
-    }
-    async #markCoreMaterializationPending(context, head, message) {
-        const operation = await this.#readOperation(context.operationId);
-        if (operation === null)
-            throw new ArtifactStoreInvariantError("Artifact operation awaiting materialization does not exist");
-        if (!sameContext(operation.context, context))
-            throw new ArtifactStoreInvariantError("Artifact operation awaiting materialization does not match the frozen operation");
-        if (operation.status === "core_failed")
-            throw new ArtifactStoreInvariantError("An artifact operation whose core failed cannot await materialization");
-        if (operation.status === "core_committed" ||
-            operation.status === "completed")
-            return summary(operation);
-        if (operation.status === "core_materialization_pending" &&
-            operation.head !== head)
-            throw new ArtifactStoreInvariantError("Artifact operation awaiting materialization has a conflicting core head");
-        const pending = {
-            ...operation,
-            status: "core_materialization_pending",
-            extensionStatus: "recovery_required",
-            message,
-            completedRequests: [],
-            head,
-        };
-        await this.#writeOperation(pending);
-        return summary(pending);
+        await this.#activateCommittedRecords(committed, head);
     }
-    async #activateCommittedRecords(operation, context, head) {
+    async #activateCommittedRecords(operation, head) {
         if (operation.artifactProjectionStatus === "superseded")
             return;
-        const effective = await this.#effectiveRecords(context.worldId);
-        for (const item of effective) {
-            const { record, status, head: boundHead } = item;
-            if (record.operationId !== context.operationId)
-                continue;
-            if (status === "superseded" ||
-                status === "cleared" ||
-                status === "failed")
+        const records = await this.#recordsForOperation(operation.context.worldId, operation.context.operationId);
+        for (const record of records) {
+            if (record.status === "superseded" || record.status === "cleared")
                 continue;
-            if (boundHead !== null && boundHead !== head)
+            if (record.head !== null && record.head !== head)
                 throw new ArtifactStoreInvariantError("Artifact record is bound to a different core head");
-            if (boundHead !== head)
-                await this.#appendRecordEvent(record, {
-                    schemaVersion: 1,
-                    kind: "bind_head",
-                    operationId: context.operationId,
-                    recordId: record.recordId,
-                    head,
-                    sequence: await this.#nextSequence(context.worldId),
-                });
-            if (status === "pending")
-                await this.#appendRecordEvent(record, {
-                    schemaVersion: 1,
-                    kind: "activate",
-                    operationId: context.operationId,
-                    recordId: record.recordId,
-                    sequence: await this.#nextSequence(context.worldId),
-                });
+            if (record.head === head && record.status !== "pending")
+                continue;
+            await this.#putRecord({
+                ...record,
+                head,
+                status: record.status === "pending" ? "active" : record.status,
+            });
         }
     }
-    async markCoreFailed(operationId, message) {
-        const worldId = await this.#worldForOperation(operationId);
-        if (worldId === null)
-            return;
-        return this.#withWorldMutation(worldId, () => this.#markCoreFailed(operationId, message));
+    async markCoreFailed(worldId, operationId, message) {
+        return this.#withWorldMutation(worldId, () => this.#markCoreFailed(worldId, operationId, message));
     }
-    async #markCoreFailed(operationId, message) {
-        const operation = await this.#readOperation(operationId);
+    async #markCoreFailed(worldId, operationId, message) {
+        const operation = await this.#readOperation(worldId, operationId);
         if (operation === null)
             return;
         if (operation.status !== "running")
             return;
-        const records = await this.#recordsForOperation(operationId);
-        for (const record of records)
-            await this.#appendEventOnce({
-                schemaVersion: 1,
-                kind: "supersede",
-                operationId,
-                recordId: record.recordId,
-                reason: "core_failed",
-                sequence: await this.#nextSequence(operation.context.worldId),
-            });
+        for (const record of await this.#recordsForOperation(worldId, operationId))
+            if (record.status !== "superseded")
+                await this.#putRecord({ ...record, status: "superseded" });
         await this.#writeOperation({
             ...operation,
             status: "core_failed",
@@ -793,7 +460,7 @@ export class FileNativeArtifactStore {
         return this.#withWorldMutation(context.worldId, () => this.#beginExtension(context));
     }
     async #beginExtension(context) {
-        const operation = await this.#readOperation(context.operationId);
+        const operation = await this.#readOperation(context.worldId, context.operationId);
         if (operation === null)
             throw new ArtifactStoreInvariantError("Artifact extension is missing an operation checkpoint");
         if (!sameContext(operation.context, context))
@@ -805,21 +472,13 @@ export class FileNativeArtifactStore {
             return;
         await this.#writeOperation({ ...operation, extensionStatus: "running" });
     }
-    async completeExtension(operationId, requests) {
-        const worldId = await this.#worldForOperation(operationId);
-        if (worldId === null)
-            return this.#completeExtension(operationId, requests);
-        return this.#withWorldMutation(worldId, () => this.#completeExtension(operationId, requests));
+    async completeExtension(worldId, operationId, requests) {
+        return this.#withWorldMutation(worldId, () => this.#completeExtension(worldId, operationId, requests));
     }
-    async #completeExtension(operationId, requests) {
-        const operation = await this.#readOperation(operationId);
+    async #completeExtension(worldId, operationId, requests) {
+        const operation = await this.#readOperation(worldId, operationId);
         if (operation === null)
-            return {
-                operationId,
-                status: "recovery_required",
-                completedRequests: [],
-                coreCommitted: false,
-            };
+            return recoveryRequired(operationId, [], undefined);
         if (operation.status === "running")
             return summary(operation);
         if (isTerminalExtensionStatus(operation.extensionStatus) ||
@@ -828,17 +487,7 @@ export class FileNativeArtifactStore {
             return summary(operation);
         if (operation.status !== "core_committed")
             throw new ArtifactStoreInvariantError("Artifact extension cannot complete before the core is committed");
-        const records = await this.#recordsForOperation(operationId);
-        for (const record of records)
-            if (record.save === "none" || record.invalidation === "operation_end")
-                await this.#appendRecordEvent(record, {
-                    schemaVersion: 1,
-                    kind: "supersede",
-                    operationId,
-                    recordId: record.recordId,
-                    reason: "operation_end",
-                    sequence: await this.#nextSequence(operation.context.worldId),
-                });
+        await this.#endOperationRecords(worldId, operationId);
         const next = {
             ...operation,
             status: "completed",
@@ -849,39 +498,20 @@ export class FileNativeArtifactStore {
         await this.#writeOperation(next);
         return summary(next);
     }
-    async failExtension(operationId, status, message, requests = []) {
-        const worldId = await this.#worldForOperation(operationId);
-        if (worldId === null)
-            return this.#failExtension(operationId, status, message, requests);
-        return this.#withWorldMutation(worldId, () => this.#failExtension(operationId, status, message, requests));
+    async failExtension(worldId, operationId, status, message, requests = []) {
+        return this.#withWorldMutation(worldId, () => this.#failExtension(worldId, operationId, status, message, requests));
     }
-    async #failExtension(operationId, status, message, requests = []) {
-        const operation = await this.#readOperation(operationId);
+    async #failExtension(worldId, operationId, status, message, requests) {
+        const operation = await this.#readOperation(worldId, operationId);
         if (operation === null)
-            return {
-                operationId,
-                status: "recovery_required",
-                completedRequests: requests,
-                message,
-                coreCommitted: false,
-            };
+            return recoveryRequired(operationId, requests, message);
         if (isTerminalExtensionStatus(operation.extensionStatus) ||
             operation.extensionStatus === "unknown" ||
             operation.extensionStatus === "recovery_required")
             return summary(operation);
         if (operation.status !== "core_committed")
             throw new ArtifactStoreInvariantError("Artifact extension cannot fail before the core is committed");
-        const records = await this.#recordsForOperation(operationId);
-        for (const record of records)
-            if (record.save === "none" || record.invalidation === "operation_end")
-                await this.#appendRecordEvent(record, {
-                    schemaVersion: 1,
-                    kind: "supersede",
-                    operationId,
-                    recordId: record.recordId,
-                    reason: "extension_failed",
-                    sequence: await this.#nextSequence(operation.context.worldId),
-                });
+        await this.#endOperationRecords(worldId, operationId);
         const next = {
             ...operation,
             extensionStatus: status,
@@ -891,12 +521,20 @@ export class FileNativeArtifactStore {
         await this.#writeOperation(next);
         return summary(next);
     }
-    async readExtension(operationId) {
-        const operation = await this.#readOperation(operationId);
+    /** Save-none and operation-end records do not survive the extension that produced them. */
+    async #endOperationRecords(worldId, operationId) {
+        for (const record of await this.#recordsForOperation(worldId, operationId))
+            if ((record.save === "none" || record.invalidation === "operation_end") &&
+                record.status !== "superseded")
+                await this.#putRecord({ ...record, status: "superseded" });
+    }
+    async readExtension(worldId, operationId) {
+        await this.#ensureReadable(worldId);
+        const operation = await this.#readOperation(worldId, operationId);
         return operation === null ? null : summary(operation);
     }
     async readExtensionSummaries(worldId) {
-        await this.#ensureForkRestored(worldId);
+        await this.#ensureReadable(worldId);
         return (await this.#operationsForWorld(worldId))
             .filter((operation) => operation.status !== "core_failed" &&
             !(operation.status === "completed" &&
@@ -905,51 +543,43 @@ export class FileNativeArtifactStore {
             .sort((left, right) => left.context.operationId.localeCompare(right.context.operationId))
             .map(summary);
     }
-    async resumeExtension(operationId) {
-        const worldId = await this.#worldForOperation(operationId);
-        if (worldId === null)
-            return this.#resumeExtension(operationId);
-        return this.#withWorldMutation(worldId, () => this.#resumeExtension(operationId));
-    }
-    async #resumeExtension(operationId) {
-        const operation = await this.#readOperation(operationId);
-        if (operation === null)
-            return {
-                operationId,
-                status: "recovery_required",
-                completedRequests: [],
-                message: "No recoverable extension checkpoint was found",
-                coreCommitted: false,
+    async resumeExtension(worldId, operationId) {
+        return this.#withWorldMutation(worldId, async () => {
+            const operation = await this.#readOperation(worldId, operationId);
+            if (operation === null)
+                return {
+                    operationId,
+                    status: "recovery_required",
+                    completedRequests: [],
+                    message: "No recoverable extension checkpoint was found",
+                    coreCommitted: false,
+                };
+            if (operation.status === "running")
+                return summary(operation);
+            if (isTerminalExtensionStatus(operation.extensionStatus) ||
+                operation.extensionStatus === "recovery_required")
+                return summary(operation);
+            const next = {
+                ...operation,
+                extensionStatus: "recovery_required",
+                message: "Extension dispatch state cannot be replayed safely; the original request attempt requires explicit manual recovery",
             };
-        if (operation.status === "running")
-            return summary(operation);
-        if (isTerminalExtensionStatus(operation.extensionStatus) ||
-            operation.extensionStatus === "recovery_required")
-            return summary(operation);
-        const next = {
-            ...operation,
-            extensionStatus: "recovery_required",
-            message: "Extension dispatch state cannot be replayed safely; the original request attempt requires explicit manual recovery",
-        };
-        await this.#writeOperation(next);
-        return summary(next);
+            await this.#writeOperation(next);
+            return summary(next);
+        });
     }
     async readActiveProjection(worldId, channel, timeline) {
-        await this.#ensureForkRestored(worldId);
-        const effective = await this.#effectiveRecords(worldId);
-        const operationStates = new Map();
-        for (const item of effective)
-            if (!operationStates.has(item.record.operationId)) {
-                const operation = await this.#readOperation(item.record.operationId);
-                if (operation !== null)
-                    operationStates.set(item.record.operationId, operation);
-            }
-        const active = effective.filter(({ record, status, head }) => {
-            if (status !== "active" || record.projection === "hidden")
+        await this.#ensureReadable(worldId);
+        const operations = new Map((await this.#operationsForWorld(worldId)).map((operation) => [
+            operation.context.operationId,
+            operation,
+        ]));
+        const active = (await this.#records(worldId)).filter((record) => {
+            if (record.status !== "active" || record.projection === "hidden")
                 return false;
             if (channel !== undefined && record.channel !== channel)
                 return false;
-            const operation = operationStates.get(record.operationId);
+            const operation = operations.get(record.operationId);
             if (operation === undefined ||
                 operation.artifactProjectionStatus === "superseded")
                 return false;
@@ -961,22 +591,21 @@ export class FileNativeArtifactStore {
                 return false;
             if (record.projection === "transient" && !isActiveInteraction(operation))
                 return false;
-            if (record.save === "operation" && operation?.status === "completed")
+            if (record.save === "operation" && operation.status === "completed")
                 return false;
-            if (record.save === "commit" && head === null)
+            if (record.save === "commit" && record.head === null)
                 return false;
             return true;
         });
-        const visible = await Promise.all(active.map(async (item) => (await this.#extensionControls.visible(worldId, item.record))
-            ? item
+        const visible = await Promise.all(active.map(async (record) => (await this.#extensionControls.visible(worldId, record))
+            ? record
             : null));
         const selected = selectProjection(visible.filter((item) => item !== null));
-        return selected.map(({ record, head }) => ({
-            ...(operationStates.get(record.operationId)?.context.attachment ===
-                undefined
+        return selected.map((record) => ({
+            ...(operations.get(record.operationId)?.context.attachment === undefined
                 ? {}
                 : {
-                    attachment: structuredClone(operationStates.get(record.operationId).context.attachment),
+                    attachment: structuredClone(operations.get(record.operationId).context.attachment),
                 }),
             recordId: record.recordId,
             worldId: record.worldId,
@@ -1004,20 +633,19 @@ export class FileNativeArtifactStore {
             projection: record.projection,
             save: record.save,
             sequence: record.sequence,
-            head: head ?? record.parentHead,
+            head: record.head ?? record.parentHead,
         }));
     }
     async readDebug(worldId, operationId) {
-        await this.#ensureForkRestored(worldId);
-        const effective = await this.#effectiveRecords(worldId);
+        await this.#ensureReadable(worldId);
         const operations = new Map((await this.#operationsForWorld(worldId)).map((operation) => [
             operation.context.operationId,
             operation,
         ]));
-        return effective
-            .filter(({ record }) => operationId === undefined || record.operationId === operationId)
-            .sort((left, right) => left.record.sequence - right.record.sequence)
-            .map(({ record, status, head }) => ({
+        return (await this.#records(worldId))
+            .filter((record) => operationId === undefined || record.operationId === operationId)
+            .sort((left, right) => left.sequence - right.sequence)
+            .map((record) => ({
             ...(operations.get(record.operationId)?.context.attachment === undefined
                 ? {}
                 : {
@@ -1031,7 +659,7 @@ export class FileNativeArtifactStore {
             playPresetRevision: record.playPresetRevision,
             playPresetScriptsEnabled: record.playPresetScriptsEnabled,
             parentHead: record.parentHead,
-            newHead: head,
+            newHead: record.head,
             requestId: record.requestId,
             requestAttempt: record.requestAttempt,
             output: record.output,
@@ -1053,155 +681,24 @@ export class FileNativeArtifactStore {
                 : { frozenPresentation: structuredClone(record.frozenPresentation) }),
             payload: structuredClone(record.payload),
             payloadFingerprint: record.payloadFingerprint,
-            status,
+            status: record.status,
         }));
     }
-    async #newRecord(input, declaration, payload, fingerprint, callFingerprint) {
-        const sequence = await this.#nextSequence(input.context.worldId);
-        const recordId = `artifact:${sequence}:${fingerprint.slice(7, 23)}`;
-        const record = {
-            schemaVersion: 1,
-            recordId,
-            sequence,
-            worldId: input.context.worldId,
-            parentHead: input.context.parentHead,
-            newHead: null,
-            operationId: input.context.operationId,
-            playPresetId: input.context.playPresetId,
-            playPresetRevision: input.context.playPresetRevision,
-            playPresetScriptsEnabled: input.context.playPresetScriptsEnabled,
-            requestId: input.context.requestId,
-            requestAttempt: input.context.requestAttempt,
-            output: declaration.name,
-            channel: declaration.channel,
-            ...(declaration.key === undefined ? {} : { key: declaration.key }),
-            contentType: declaration.contentType,
-            ...(declaration.renderer === undefined
-                ? {}
-                : { renderer: declaration.renderer }),
-            ...(declaration.rendererRevision === undefined
-                ? {}
-                : { rendererRevision: declaration.rendererRevision }),
-            ...(input.context.extensionControl === undefined
-                ? {}
-                : {
-                    extensionControl: structuredClone(input.context.extensionControl),
-                }),
-            ...(input.context.frozenPresentations?.[declaration.name] !== undefined
-                ? {
-                    frozenPresentation: structuredClone(input.context.frozenPresentations[declaration.name]),
-                }
-                : input.context.frozenResources === undefined
-                    ? {}
-                    : {
-                        frozenPresentation: {
-                            ...structuredClone(input.context.frozenResources),
-                            declaration: structuredClone(declaration),
-                        },
-                    }),
-            payload: structuredClone(payload),
-            save: declaration.save,
-            projection: declaration.strategy,
-            invalidation: declaration.invalidation,
-            toolCallId: input.toolCallId,
-            toolName: "artifact_emit",
-            callFingerprint,
-            payloadFingerprint: fingerprint,
-            status: "pending",
-        };
-        return {
-            ...record,
-            recordFingerprint: rawRecordFingerprint(record),
-        };
-    }
-    async #appendRaw(record) {
-        const directory = join(this.#worldRoot(record.worldId), "records");
-        await mkdir(directory, { recursive: true, mode: 0o700 });
-        await writeDurableJson(join(directory, `${String(record.sequence).padStart(12, "0")}.json`), record, true);
-    }
-    async #appendRecordEvent(record, event) {
-        await this.#appendCallEvent({
-            worldId: record.worldId,
-            parentHead: record.parentHead,
-            operationId: record.operationId,
-            playPresetId: record.playPresetId,
-            playPresetRevision: record.playPresetRevision,
-            playPresetScriptsEnabled: record.playPresetScriptsEnabled,
-            requestId: record.requestId,
-            requestAttempt: record.requestAttempt,
-            maxArtifactBytes: maxPayloadBytes,
-            declarations: [],
-        }, record.save, event);
-    }
-    async #appendCallEvent(context, save, event) {
-        if (save === "none") {
-            const events = this.#memoryEvents.get(context.operationId) ?? [];
-            if (!events.some((candidate) => sameEventIdentity(candidate, event))) {
-                events.push(event);
-                this.#memoryEvents.set(context.operationId, events);
-            }
-            return;
-        }
-        await this.#appendEventOnce(event);
-    }
-    async #appendEvent(event) {
-        const worldId = await this.#worldForOperation(event.operationId);
-        if (worldId === null) {
-            const memory = this.#memoryEvents.get(event.operationId) ?? [];
-            memory.push(event);
-            this.#memoryEvents.set(event.operationId, memory);
-            return;
-        }
-        const path = join(this.#worldRoot(worldId), "events", `${String(event.sequence).padStart(12, "0")}.json`);
-        await mkdir(join(this.#worldRoot(worldId), "events"), {
-            recursive: true,
-            mode: 0o700,
-        });
-        await writeDurableJson(path, event, true);
-    }
-    async #appendEventOnce(event) {
-        const worldId = await this.#worldForOperation(event.operationId);
-        if (worldId !== null) {
-            const existing = await this.#events(worldId);
-            if (existing.some((candidate) => sameEventIdentity(candidate, event)))
-                return;
-        }
-        else {
-            const existing = this.#memoryEvents.get(event.operationId) ?? [];
-            if (existing.some((candidate) => sameEventIdentity(candidate, event)))
-                return;
-        }
-        await this.#appendEvent(event);
-    }
-    async #effectiveRecords(worldId) {
-        const raw = [];
-        const memory = this.#memoryRecords;
-        const recordsDirectory = join(this.#worldRoot(worldId), "records");
-        try {
-            const names = (await readdir(recordsDirectory))
-                .filter((name) => name.endsWith(".json"))
-                .sort();
-            for (const name of names) {
-                const parsed = parseArtifactJson(await readFile(join(recordsDirectory, name), "utf8"), "artifact raw record");
-                assertRawRecord(parsed);
-                if (name !== artifactSequenceFileName(parsed.sequence))
-                    throw new ArtifactStoreCorruptionError("Artifact raw-record file name does not match its sequence");
-                if (parsed.worldId !== worldId)
-                    throw new ArtifactStoreCorruptionError("Artifact raw record does not match the world path");
-                raw.push(parsed);
-            }
-        }
-        catch (error) {
-            if (!isMissing(error))
-                throw error;
-        }
-        for (const records of memory.values())
-            for (const record of records)
-                if (record.worldId === worldId)
-                    raw.push(record);
+    /** Records and operations of a world, read from its directory; memory-only records are included. */
+    async #records(worldId) {
+        const raw = [
+            ...(await readRecordFiles(this.#artifactsRoot(worldId))),
+            ...[...this.#memoryRecords.values()]
+                .flat()
+                .filter((record) => record.worldId === worldId),
+        ];
         raw.sort((left, right) => left.sequence - right.sequence);
         const recordIds = new Set();
         const sequences = new Set();
+        const operations = new Map((await this.#operationsForWorld(worldId)).map((operation) => [
+            operation.context.operationId,
+            operation,
+        ]));
         for (const record of raw) {
             if (recordIds.has(record.recordId))
                 throw new ArtifactStoreCorruptionError("Artifact raw-record ID is duplicated");
@@ -1209,15 +706,7 @@ export class FileNativeArtifactStore {
                 throw new ArtifactStoreCorruptionError("Artifact world sequence is duplicated");
             recordIds.add(record.recordId);
             sequences.add(record.sequence);
-        }
-        const state = new Map();
-        for (const record of raw)
-            state.set(record.recordId, { status: "pending", head: null });
-        const operationStates = new Map();
-        for (const operation of await this.#operationsForWorld(worldId))
-            operationStates.set(operation.context.operationId, operation);
-        for (const record of raw) {
-            const operation = operationStates.get(record.operationId);
+            const operation = operations.get(record.operationId);
             if (operation?.context.worldId !== record.worldId ||
                 operation.context.parentHead !== record.parentHead ||
                 operation.context.playPresetId !== record.playPresetId ||
@@ -1226,177 +715,72 @@ export class FileNativeArtifactStore {
                     record.playPresetScriptsEnabled)
                 throw new ArtifactStoreCorruptionError("Artifact raw record does not match the operation identity");
         }
-        const events = await this.#events(worldId);
-        for (const event of events) {
-            if (sequences.has(event.sequence))
-                throw new ArtifactStoreCorruptionError("Artifact world sequence is duplicated");
-            sequences.add(event.sequence);
-            const eventOperation = operationStates.get(event.operationId);
-            if (eventOperation === undefined)
-                throw new ArtifactStoreCorruptionError("Artifact projection-event operation does not exist");
-            if (event.recordId !== undefined) {
-                const record = raw.find(({ recordId }) => recordId === event.recordId);
-                if (record?.operationId !== event.operationId)
-                    throw new ArtifactStoreCorruptionError("Artifact projection event does not match the record identity");
-            }
-            if (event.kind === "activate" && event.recordId !== undefined) {
-                const current = state.get(event.recordId);
-                if (current?.status === "pending")
-                    current.status = "active";
-            }
-            else if (event.kind === "supersede" && event.recordId !== undefined) {
-                const current = state.get(event.recordId);
-                if (current !== undefined)
-                    current.status = "superseded";
-            }
-            else if (event.kind === "bind_head" && event.recordId !== undefined) {
-                if ((eventOperation.status !== "core_committed" &&
-                    eventOperation.status !== "completed") ||
-                    eventOperation.head !== event.head)
-                    throw new ArtifactStoreCorruptionError("Artifact bind_head event does not match the operation core head");
-                const current = state.get(event.recordId);
-                if (current !== undefined)
-                    current.head = event.head ?? null;
-            }
-            else if (event.kind === "clear") {
-                const initiator = operationStates.get(event.operationId);
-                if (initiator === undefined ||
-                    initiator.artifactProjectionStatus === "superseded" ||
-                    (initiator.requestAttempts[event.requestId] !== undefined &&
-                        initiator.requestAttempts[event.requestId] !==
-                            event.requestAttempt))
-                    continue;
-                for (const record of raw) {
-                    const current = state.get(record.recordId);
-                    if (current !== undefined &&
-                        current.status !== "superseded" &&
-                        current.status !== "cleared" &&
-                        record.sequence < event.sequence &&
-                        record.channel === event.channel &&
-                        record.output === event.output &&
-                        (event.key === undefined || record.key === event.key))
-                        current.status = "cleared";
-                }
-            }
-        }
-        return raw.map((record) => {
-            const current = state.get(record.recordId);
-            let status = current?.status ?? "failed";
-            const operation = operationStates.get(record.operationId);
-            const currentAttempt = operation?.requestAttempts[record.requestId];
-            if (currentAttempt !== undefined &&
-                currentAttempt !== record.requestAttempt &&
-                status !== "failed")
-                status = "superseded";
-            if (operation?.artifactProjectionStatus === "superseded" &&
-                status !== "failed")
-                status = "superseded";
-            return {
-                record,
-                status,
-                head: current?.head ?? null,
-            };
-        });
+        return raw;
     }
-    async #events(worldId) {
-        const result = [];
-        const directory = join(this.#worldRoot(worldId), "events");
-        try {
-            const names = (await readdir(directory))
-                .filter((name) => name.endsWith(".json"))
-                .sort();
-            for (const name of names) {
-                const event = parseArtifactJson(await readFile(join(directory, name), "utf8"), "artifact projection event");
-                assertEvent(event);
-                if (name !== artifactSequenceFileName(event.sequence))
-                    throw new ArtifactStoreCorruptionError("Artifact projection-event file name does not match its sequence");
-                result.push(event);
-            }
-        }
-        catch (error) {
-            if (!isMissing(error))
-                throw error;
-        }
-        for (const [operationId, events] of this.#memoryEvents) {
-            const operation = await this.#readOperation(operationId);
-            if (operation?.context.worldId === worldId)
-                result.push(...events);
+    async #recordsForOperation(worldId, operationId) {
+        return (await this.#records(worldId)).filter((record) => record.operationId === operationId);
+    }
+    /** Writes or replaces one record; save:none records stay in memory only. */
+    async #putRecord(input) {
+        // Only a cleared record keeps the clear that made it so.
+        const record = input.status === "cleared" ? input : withoutClearedBy(input);
+        const finalized = {
+            ...record,
+            recordFingerprint: rawRecordFingerprint(record),
+        };
+        assertRawRecord(finalized);
+        if (record.save === "none") {
+            const records = this.#memoryRecords.get(record.operationId) ?? [];
+            const index = records.findIndex((candidate) => candidate.recordId === record.recordId);
+            if (index < 0)
+                records.push(finalized);
+            else
+                records[index] = finalized;
+            this.#memoryRecords.set(record.operationId, records);
+            return;
         }
-        return result.sort((left, right) => left.sequence - right.sequence);
+        await writeArtifactJson(join(this.#artifactsRoot(record.worldId), "records", artifactSequenceFileName(record.sequence)), finalized);
     }
-    async #recordsForOperation(operationId) {
-        const operation = await this.#readOperation(operationId);
-        if (operation === null)
-            return this.#memoryRecords.get(operationId) ?? [];
-        const records = await this.#effectiveRecords(operation.context.worldId);
-        return records
-            .filter(({ record }) => record.operationId === operationId)
-            .map(({ record }) => record);
+    async #removeRecord(record) {
+        if (record.save === "none") {
+            const records = (this.#memoryRecords.get(record.operationId) ?? []).filter((candidate) => candidate.recordId !== record.recordId);
+            this.#memoryRecords.set(record.operationId, records);
+            return;
+        }
+        await rm(join(this.#artifactsRoot(record.worldId), "records", artifactSequenceFileName(record.sequence)), { force: true });
     }
     async #operationsForWorld(worldId) {
-        const byId = new Map();
-        const directory = join(this.#root, "operations");
+        return [
+            ...(await readOperationFiles(this.#artifactsRoot(worldId))).values(),
+        ].filter((operation) => operation.context.worldId === worldId);
+    }
+    async #nextSequence(worldId) {
+        let maximum = 0;
         try {
-            const names = (await readdir(directory))
-                .filter((name) => name.endsWith(".json"))
-                .sort();
-            for (const name of names) {
-                const operation = parseArtifactJson(await readFile(join(directory, name), "utf8"), "artifact operation");
-                assertOperation(operation);
-                if (name !== `${identityHash(operation.context.operationId)}.json`)
-                    throw new ArtifactStoreCorruptionError("Artifact operation does not match the file-path identity");
-                if (byId.has(operation.context.operationId))
-                    throw new ArtifactStoreCorruptionError("Artifact operation ID is duplicated");
-                if (operation.context.worldId === worldId)
-                    byId.set(operation.context.operationId, structuredClone(operation));
+            for (const name of await readdir(join(this.#artifactsRoot(worldId), "records"))) {
+                if (!name.endsWith(".json"))
+                    continue;
+                const value = Number.parseInt(name.slice(0, -5), 10);
+                if (!Number.isSafeInteger(value) ||
+                    value < 1 ||
+                    name !== artifactSequenceFileName(value))
+                    throw new ArtifactStoreCorruptionError("Artifact sequence file name is invalid");
+                maximum = Math.max(maximum, value);
             }
         }
         catch (error) {
             if (!isMissing(error))
                 throw error;
         }
-        return [...byId.values()];
-    }
-    async #nextSequence(worldId) {
-        let maximum = 0;
-        const directories = [
-            join(this.#worldRoot(worldId), "records"),
-            join(this.#worldRoot(worldId), "events"),
-        ];
-        for (const directory of directories) {
-            try {
-                const names = (await readdir(directory)).filter((name) => name.endsWith(".json"));
-                for (const name of names) {
-                    const value = Number.parseInt(name.slice(0, -5), 10);
-                    if (!Number.isSafeInteger(value) ||
-                        value < 1 ||
-                        name !== artifactSequenceFileName(value))
-                        throw new ArtifactStoreCorruptionError("Artifact sequence file name is invalid");
-                    maximum = Math.max(maximum, value);
-                }
-            }
-            catch (error) {
-                if (!isMissing(error))
-                    throw error;
-            }
-        }
         for (const records of this.#memoryRecords.values())
             for (const record of records)
                 if (record.worldId === worldId)
                     maximum = Math.max(maximum, record.sequence);
-        for (const [operationId, events] of this.#memoryEvents) {
-            const operation = await this.#readOperation(operationId);
-            if (operation?.context.worldId !== worldId)
-                continue;
-            for (const event of events)
-                maximum = Math.max(maximum, event.sequence);
-        }
         return maximum + 1;
     }
-    async #readOperation(operationId) {
-        const path = join(this.#root, "operations", `${identityHash(operationId)}.json`);
+    async #readOperation(worldId, operationId) {
         try {
-            const operation = parseArtifactJson(await readFile(path, "utf8"), "artifact operation");
+            const operation = parseArtifactJson(await readFile(this.#operationPath(worldId, operationId), "utf8"), "artifact operation");
             assertOperation(operation);
             if (operation.context.operationId !== operationId)
                 throw new ArtifactStoreCorruptionError("Artifact operation does not match the request identity");
@@ -1410,276 +794,208 @@ export class FileNativeArtifactStore {
     }
     async #writeOperation(operation) {
         assertOperation(operation);
-        const directory = join(this.#root, "operations");
-        await mkdir(directory, { recursive: true, mode: 0o700 });
-        const path = join(directory, `${identityHash(operation.context.operationId)}.json`);
-        await writeDurableJson(path, operation, false);
+        await writeArtifactJson(this.#operationPath(operation.context.worldId, operation.context.operationId), operation);
     }
-    async #worldForOperation(operationId) {
-        const operation = await this.#readOperation(operationId);
-        return operation?.context.worldId ?? null;
+    /** Reads of a world whose artifacts are still in the legacy layout migrate it first. */
+    async #ensureReadable(worldId) {
+        if (await hasLegacyArtifactState(this.#dataRoot, worldId))
+            await this.#withWorldMutation(worldId, () => Promise.resolve());
     }
     async #withWorldMutation(worldId, action) {
         const active = this.#mutationContext.getStore();
         if (active?.has(worldId) === true)
             return action();
-        return withArtifactWorldLock(artifactWorldLockPath(dirname(this.#root), worldId), () => this.#mutationContext.run(new Set([...(active ?? []), worldId]), async () => {
-            await this.#restoreFork(worldId);
+        return worldQueueFor(this.#dataRoot).run(worldId, () => this.#mutationContext.run(new Set([...(active ?? []), worldId]), async () => {
+            await migrateLegacyArtifactStore(this.#dataRoot, worldId);
             return action();
         }));
     }
-    #worldRoot(worldId) {
-        return join(this.#root, "worlds", identityHash(worldId));
+    #artifactsRoot(worldId) {
+        assertWorldDirectoryId(worldId);
+        return join(this.#worldsRoot, worldId, "artifacts");
     }
-}
-function artifactWorldLockPath(dataRoot, worldId) {
-    return join(resolve(dataRoot), "runtime-locks", "artifacts", identityHash(worldId));
-}
-const artifactWorldLockStaleMilliseconds = 30_000;
-const artifactWorldLockWaitMilliseconds = 30_000;
-async function withArtifactWorldLock(path, action) {
-    const token = randomUUID();
-    const processIdentity = await artifactLocalProcessIdentity();
-    const parent = dirname(path);
-    await mkdir(parent, { recursive: true, mode: 0o700 });
-    const deadline = Date.now() + artifactWorldLockWaitMilliseconds;
-    while (true) {
-        try {
-            await mkdir(path, { mode: 0o700 });
-            break;
-        }
-        catch (error) {
-            if (!isAlreadyExists(error))
-                throw error;
-            const owner = await readArtifactLockOwner(path);
-            if (owner !== null && (await artifactLockOwnerIsAlive(owner, path))) {
-                if (Date.now() >= deadline)
-                    throw new Error("artifact world mutation lock is busy", {
-                        cause: error,
-                    });
-                await artifactLockDelay(5);
-                continue;
-            }
-            const metadata = await stat(path).catch(() => null);
-            if (owner !== null ||
-                (metadata !== null &&
-                    Date.now() - metadata.mtimeMs > artifactWorldLockStaleMilliseconds))
-                await retireArtifactWorldLock(path, owner, metadata, parent);
-            if (Date.now() >= deadline)
-                throw new Error("artifact world mutation lock is busy", {
-                    cause: error,
-                });
-            await artifactLockDelay(5);
-        }
+    #operationPath(worldId, operationId) {
+        return join(this.#artifactsRoot(worldId), "operations", `${identityHash(operationId)}.json`);
     }
-    const ownerPath = join(path, "owner.json");
-    const heartbeatPath = join(path, "heartbeat");
-    let heartbeatHandle;
-    let stopped = false;
-    let timer;
-    let heartbeat = Promise.resolve();
-    const schedule = () => {
-        const handle = heartbeatHandle;
-        if (handle === undefined)
-            throw new ArtifactStoreInvariantError("Artifact world-lock heartbeat is not initialized");
-        timer = setTimeout(() => {
-            const now = new Date();
-            heartbeat = handle
-                .utimes(now, now)
-                .catch(() => undefined)
-                .finally(() => {
-                if (!stopped)
-                    schedule();
+}
+/**
+ * Rewrites a copied world directory into a fork target: records and operations
+ * are kept only when they are committed, active, attached to a reply and bound
+ * at or before the restored head. Everything else is deleted file by file, and
+ * the survivors take the target identity. Runs on an unpublished staging copy.
+ */
+export async function forkArtifactClosure(worldRoot, input) {
+    const artifactsRoot = join(worldRoot, "artifacts");
+    const limit = headOrdinal(input.restoredHead);
+    const records = await readRecordFiles(artifactsRoot);
+    const operations = await readOperationFiles(artifactsRoot);
+    for (const record of records)
+        if (record.worldId !== input.sourceWorldId)
+            throw new ArtifactStoreCorruptionError("Artifact fork record belongs to another world");
+    // A fork keeps what the source's projection would show at that head: the
+    // committed, attached, selected records. Superseded or unselected records
+    // stay behind with the source.
+    const candidates = records.filter((record) => {
+        const operation = operations.get(record.operationId);
+        return (record.save === "commit" &&
+            record.status === "active" &&
+            record.projection !== "hidden" &&
+            (record.projection !== "transient" || isActiveInteraction(operation)) &&
+            operation !== undefined &&
+            operation.artifactProjectionStatus !== "superseded" &&
+            operation.context.attachment !== undefined &&
+            headOrdinal(record.head ?? record.parentHead) <= limit);
+    });
+    const retained = selectProjection(candidates);
+    const retainedRecordIds = new Set(retained.map((record) => record.recordId));
+    for (const record of records)
+        if (!retainedRecordIds.has(record.recordId))
+            await rm(join(artifactsRoot, "records", artifactSequenceFileName(record.sequence)), { force: true });
+    const retainedOperations = new Set(retained.map((record) => record.operationId));
+    for (const operationId of operations.keys())
+        if (!retainedOperations.has(operationId))
+            await rm(join(artifactsRoot, "operations", `${identityHash(operationId)}.json`), {
+                force: true,
             });
-        }, 5_000);
-    };
-    try {
-        await writeDurableJson(ownerPath, { token, pid: process.pid, processIdentity }, true);
-        if (process.env.NARRAEON_INTERNAL_TEST_FAIL_AT_ARTIFACT_LOCK_EDGE ===
-            "after_owner" &&
-            process.env.NODE_ENV === "test")
-            throw new Error("simulated artifact lock setup failure");
-        await writeDurableJson(heartbeatPath, { token }, true);
-        heartbeatHandle = await open(heartbeatPath, "r+");
-        schedule();
-        return await action();
+    for (const record of retained) {
+        const next = {
+            ...record,
+            worldId: input.targetWorldId,
+            operationId: forkOperationId(input.targetWorldId, record.operationId),
+        };
+        await writeArtifactJson(join(artifactsRoot, "records", artifactSequenceFileName(record.sequence)), { ...next, recordFingerprint: rawRecordFingerprint(next) });
     }
-    finally {
-        stopped = true;
-        if (timer !== undefined)
-            clearTimeout(timer);
-        await heartbeat;
-        await heartbeatHandle?.close();
-        await releaseArtifactWorldLock(path, token, parent);
+    for (const operationId of retainedOperations) {
+        const operation = operations.get(operationId);
+        const nextId = forkOperationId(input.targetWorldId, operationId);
+        const next = {
+            ...operation,
+            context: {
+                ...operation.context,
+                worldId: input.targetWorldId,
+                operationId: nextId,
+            },
+        };
+        await writeArtifactJson(join(artifactsRoot, "operations", `${identityHash(nextId)}.json`), next);
+        await rm(join(artifactsRoot, "operations", `${identityHash(operationId)}.json`), {
+            force: true,
+        });
     }
 }
-async function readArtifactLockOwner(path) {
-    let value;
-    try {
-        value = JSON.parse(await readFile(join(path, "owner.json"), "utf8"));
-    }
-    catch (error) {
-        if (isMissing(error))
-            return null;
-        throw error;
-    }
-    if (!isRecord(value) ||
-        !hasExactKeys(value, ["token", "pid", "processIdentity"]) ||
-        !isNonEmptyString(value.token) ||
-        !Number.isSafeInteger(value.pid) ||
-        Number(value.pid) < 1 ||
-        !isNonEmptyString(value.processIdentity))
-        throw new ArtifactStoreCorruptionError("Artifact world-mutation lock owner is corrupt");
-    return value;
+function withoutClearedBy(record) {
+    const copy = { ...record };
+    delete copy.clearedBy;
+    return copy;
 }
-async function retireArtifactWorldLock(path, observedOwner, observedMetadata, locksRoot) {
-    if (observedOwner === null && observedMetadata === null)
-        return;
-    const currentOwner = await readArtifactLockOwner(path);
-    const currentMetadata = await stat(path).catch(() => null);
-    const sameGeneration = observedOwner === null
-        ? currentOwner === null &&
-            observedMetadata !== null &&
-            currentMetadata !== null &&
-            observedMetadata.dev === currentMetadata.dev &&
-            observedMetadata.ino === currentMetadata.ino
-        : currentOwner?.token === observedOwner.token;
-    if (!sameGeneration)
-        return;
-    if (currentOwner !== null &&
-        (await artifactLockOwnerIsAlive(currentOwner, path)))
-        return;
-    if (currentOwner === null &&
-        (currentMetadata === null ||
-            Date.now() - currentMetadata.mtimeMs <=
-                artifactWorldLockStaleMilliseconds))
-        return;
-    const generation = currentOwner?.token ??
-        `inode-${currentMetadata?.dev ?? "missing"}-${currentMetadata?.ino ?? "missing"}`;
-    const retired = `${path}.${identityHash(generation)}.${randomUUID()}.retired`;
-    try {
-        await rename(path, retired);
-        await syncArtifactDirectory(locksRoot);
-        await rm(retired, { recursive: true, force: true });
-    }
-    catch (error) {
-        if (isMissing(error) || isAlreadyExists(error))
-            return;
-        throw error;
-    }
+function forkOperationId(targetWorldId, operationId) {
+    return `artifact-fork:${targetWorldId}:${identityHash(operationId)}`;
 }
-async function releaseArtifactWorldLock(path, token, locksRoot) {
-    const owner = await readArtifactLockOwner(path);
-    if (owner?.token !== token)
-        return;
-    const retired = `${path}.${identityHash(token)}.${randomUUID()}.retired`;
+async function readRecordFiles(artifactsRoot) {
+    const directory = join(artifactsRoot, "records");
+    let names;
     try {
-        await rename(path, retired);
-        await syncArtifactDirectory(locksRoot);
-        await rm(retired, { recursive: true, force: true });
+        names = (await readdir(directory)).filter((name) => name.endsWith(".json"));
     }
     catch (error) {
-        if (isMissing(error) || isAlreadyExists(error))
-            return;
+        if (isMissing(error))
+            return [];
         throw error;
     }
-}
-let cachedArtifactProcessIdentity;
-function artifactLocalProcessIdentity() {
-    cachedArtifactProcessIdentity ??= artifactProcessIdentity(process.pid).then((identity) => identity ?? `fallback:${process.pid}:${randomUUID()}`);
-    return cachedArtifactProcessIdentity;
-}
-async function artifactLockOwnerIsAlive(owner, path) {
-    const identity = await artifactProcessIdentity(owner.pid);
-    if (identity === owner.processIdentity)
-        return true;
-    if (identity === null) {
-        try {
-            process.kill(owner.pid, 0);
-            return true;
-        }
-        catch (error) {
-            if (isRecord(error) && error.code === "ESRCH")
-                return false;
-            // Fall through to the heartbeat for non-Linux or inaccessible processes.
-        }
-    }
-    const heartbeat = await stat(join(path, "heartbeat")).catch(() => null);
-    return (heartbeat !== null &&
-        Date.now() - heartbeat.mtimeMs <= artifactWorldLockStaleMilliseconds);
-}
-async function artifactProcessIdentity(pid) {
-    try {
-        const [bootId, namespace, processStat] = await Promise.all([
-            readFile("/proc/sys/kernel/random/boot_id", "utf8"),
-            readlink(`/proc/${pid}/ns/pid`),
-            readFile(`/proc/${pid}/stat`, "utf8"),
-        ]);
-        const commandEnd = processStat.lastIndexOf(") ");
-        if (commandEnd < 0)
-            return null;
-        const fields = processStat
-            .slice(commandEnd + 2)
-            .trim()
-            .split(/\s+/u);
-        const startTicks = fields[19];
-        if (startTicks === undefined || !/^\d+$/u.test(startTicks))
-            return null;
-        return `linux:${bootId.trim()}:${namespace}:${startTicks}`;
-    }
-    catch {
-        return null;
+    const records = [];
+    for (const name of names.sort()) {
+        const parsed = parseArtifactJson(await readFile(join(directory, name), "utf8"), "artifact raw record");
+        assertRawRecord(parsed);
+        if (name !== artifactSequenceFileName(parsed.sequence))
+            throw new ArtifactStoreCorruptionError("Artifact raw-record file name does not match its sequence");
+        records.push(parsed);
     }
+    return records.sort((left, right) => left.sequence - right.sequence);
 }
-async function writeDurableJson(path, value, exclusive) {
-    const directory = dirname(path);
-    await mkdir(directory, { recursive: true, mode: 0o700 });
-    const target = exclusive ? path : `${path}.${randomUUID()}.tmp`;
-    let handle;
-    let created = false;
+async function readOperationFiles(artifactsRoot) {
+    const directory = join(artifactsRoot, "operations");
+    const byId = new Map();
+    let names;
     try {
-        handle = await open(target, "wx", 0o600);
-        created = true;
-        await handle.writeFile(JSON.stringify(value), "utf8");
-        await handle.sync();
-        await handle.close();
-        handle = undefined;
-        if (!exclusive)
-            await rename(target, path);
-        await syncArtifactDirectory(directory);
+        names = (await readdir(directory)).filter((name) => name.endsWith(".json"));
     }
     catch (error) {
-        await handle?.close().catch(() => undefined);
-        if (created)
-            await rm(target, { force: true }).catch(() => undefined);
+        if (isMissing(error))
+            return byId;
         throw error;
     }
-}
-function parseArtifactJson(bytes, label) {
-    try {
-        return JSON.parse(bytes);
-    }
-    catch (error) {
-        throw new ArtifactStoreCorruptionError(`${label} JSON is corrupt`, error instanceof Error ? { cause: error } : undefined);
-    }
-}
-async function syncArtifactDirectory(path) {
-    const handle = await open(path, "r");
-    try {
-        await handle.sync();
-    }
-    finally {
-        await handle.close();
+    for (const name of names.sort()) {
+        const operation = parseArtifactJson(await readFile(join(directory, name), "utf8"), "artifact operation");
+        assertOperation(operation);
+        if (name !== `${identityHash(operation.context.operationId)}.json`)
+            throw new ArtifactStoreCorruptionError("Artifact operation does not match the file-path identity");
+        byId.set(operation.context.operationId, operation);
     }
+    return byId;
 }
-function artifactLockDelay(milliseconds) {
-    return new Promise((resolve) => setTimeout(resolve, milliseconds));
+function assertWorldDirectoryId(worldId) {
+    if (worldId === "" ||
+        worldId === "." ||
+        worldId === ".." ||
+        worldId.includes("/") ||
+        worldId.includes("\\"))
+        throw new ArtifactStoreInvariantError("Artifact world ID is not a path");
 }
 export class InMemoryArtifactStore extends FileNativeArtifactStore {
     constructor() {
         super(join(tmpdir(), "narraeon-ephemeral-artifacts", randomUUID()));
     }
 }
+function newRecord(input, declaration, payload, identity) {
+    const record = {
+        schemaVersion: 1,
+        recordId: `artifact:${identity.sequence}:${identity.fingerprint.slice(7, 23)}`,
+        sequence: identity.sequence,
+        worldId: input.context.worldId,
+        parentHead: input.context.parentHead,
+        operationId: input.context.operationId,
+        playPresetId: input.context.playPresetId,
+        playPresetRevision: input.context.playPresetRevision,
+        playPresetScriptsEnabled: input.context.playPresetScriptsEnabled,
+        requestId: input.context.requestId,
+        requestAttempt: input.context.requestAttempt,
+        output: declaration.name,
+        channel: declaration.channel,
+        ...(declaration.key === undefined ? {} : { key: declaration.key }),
+        contentType: declaration.contentType,
+        ...(declaration.renderer === undefined
+            ? {}
+            : { renderer: declaration.renderer }),
+        ...(declaration.rendererRevision === undefined
+            ? {}
+            : { rendererRevision: declaration.rendererRevision }),
+        ...(input.context.extensionControl === undefined
+            ? {}
+            : {
+                extensionControl: structuredClone(input.context.extensionControl),
+            }),
+        ...(input.context.frozenPresentations?.[declaration.name] !== undefined
+            ? {
+                frozenPresentation: structuredClone(input.context.frozenPresentations[declaration.name]),
+            }
+            : input.context.frozenResources === undefined
+                ? {}
+                : {
+                    frozenPresentation: {
+                        ...structuredClone(input.context.frozenResources),
+                        declaration: structuredClone(declaration),
+                    },
+                }),
+        payload: structuredClone(payload),
+        save: declaration.save,
+        projection: declaration.strategy,
+        invalidation: declaration.invalidation,
+        toolCallId: input.toolCallId,
+        toolName: "artifact_emit",
+        callFingerprint: identity.callFingerprint,
+        payloadFingerprint: identity.fingerprint,
+    };
+    return record;
+}
 function findDeclaration(context, output) {
     return context.declarations.find(({ name }) => name === output) ?? null;
 }
@@ -1708,17 +1024,6 @@ function normalizePayload(declaration, input) {
         return contract;
     return { ok: true, value: structuredClone(input) };
 }
-function isJsonValue(value) {
-    if (value === null || typeof value === "string" || typeof value === "boolean")
-        return true;
-    if (typeof value === "number")
-        return Number.isFinite(value);
-    if (Array.isArray(value))
-        return value.every(isJsonValue);
-    if (typeof value !== "object")
-        return false;
-    return Object.values(value).every(isJsonValue);
-}
 function byteLength(payload, contentType) {
     return Buffer.byteLength(payloadText(payload, contentType), "utf8");
 }
@@ -1727,9 +1032,6 @@ function payloadText(payload, contentType) {
         return JSON.stringify(payload);
     return typeof payload === "string" ? payload : JSON.stringify(payload);
 }
-function payloadFingerprint(output, payload) {
-    return `sha256:${createHash("sha256").update(JSON.stringify({ output, payload })).digest("hex")}`;
-}
 function artifactCallFingerprint(toolName, context, parameters) {
     return `sha256:${createHash("sha256")
         .update(stableSerialize({
@@ -1749,39 +1051,18 @@ function artifactCallFingerprint(toolName, context, parameters) {
     }))
         .digest("hex")}`;
 }
-function stableSerialize(value) {
-    if (value === null || typeof value !== "object")
-        return JSON.stringify(value);
-    if (Array.isArray(value))
-        return `[${value.map((item) => stableSerialize(item)).join(",")}]`;
-    return `{${Object.keys(value)
-        .sort()
-        .map((key) => `${JSON.stringify(key)}:${stableSerialize(value[key])}`)
-        .join(",")}}`;
-}
-function rawRecordFingerprint(record) {
-    const content = { ...record };
-    delete content.recordFingerprint;
-    return `sha256:${createHash("sha256").update(JSON.stringify(content)).digest("hex")}`;
-}
-function sameEventIdentity(left, right) {
-    return (left.kind === right.kind &&
-        left.operationId === right.operationId &&
-        left.recordId === right.recordId &&
-        left.output === right.output &&
-        left.channel === right.channel &&
-        left.key === right.key &&
-        left.head === right.head &&
-        left.requestId === right.requestId &&
-        left.requestAttempt === right.requestAttempt &&
-        left.reason === right.reason &&
-        left.toolCallId === right.toolCallId &&
-        left.toolName === right.toolName &&
-        left.callFingerprint === right.callFingerprint);
-}
 function artifactFailure(message) {
     return { ok: false, markdown: `# Runtime artifact rejected\n\n${message}` };
 }
+function recoveryRequired(operationId, completedRequests, message) {
+    return {
+        operationId,
+        status: "recovery_required",
+        completedRequests,
+        ...(message === undefined ? {} : { message }),
+        coreCommitted: false,
+    };
+}
 function isOpenExtension(operation) {
     return (operation.status === "core_committed" &&
         ["not_started", "running", "unknown", "recovery_required"].includes(operation.extensionStatus));
@@ -1816,12 +1097,6 @@ function isActiveInteraction(operation) {
             (operation.status === "core_committed" &&
                 operation.extensionStatus === "running")));
 }
-function identityHash(value) {
-    return createHash("sha256").update(value, "utf8").digest("hex");
-}
-function artifactSequenceFileName(sequence) {
-    return `${String(sequence).padStart(12, "0")}.json`;
-}
 function summary(operation) {
     return {
         ...(operation.context.attachment === undefined
@@ -1834,9 +1109,7 @@ function summary(operation) {
         status: operation.extensionStatus,
         ...(operation.message === undefined ? {} : { message: operation.message }),
         completedRequests: [...operation.completedRequests],
-        coreCommitted: operation.status === "core_materialization_pending" ||
-            operation.status === "core_committed" ||
-            operation.status === "completed",
+        coreCommitted: operation.status === "core_committed" || operation.status === "completed",
         ...(operation.head === undefined ? {} : { head: operation.head }),
     };
 }
@@ -1844,16 +1117,15 @@ function selectProjection(active) {
     const append = [];
     const replace = new Map();
     const upsert = new Map();
-    for (const item of active.sort((left, right) => left.record.sequence - right.record.sequence)) {
-        if (item.record.projection === "append" ||
-            item.record.projection === "transient")
-            append.push(item);
-        else if (item.record.projection === "replace")
-            replace.set(item.record.channel, item);
-        else if (item.record.projection === "upsert")
-            upsert.set(`${item.record.channel}\0${item.record.key ?? ""}`, item);
-    }
-    return [...append, ...replace.values(), ...upsert.values()].sort((left, right) => left.record.sequence - right.record.sequence);
+    for (const record of [...active].sort((left, right) => left.sequence - right.sequence)) {
+        if (record.projection === "append" || record.projection === "transient")
+            append.push(record);
+        else if (record.projection === "replace")
+            replace.set(record.channel, record);
+        else if (record.projection === "upsert")
+            upsert.set(`${record.channel}\0${record.key ?? ""}`, record);
+    }
+    return [...append, ...replace.values(), ...upsert.values()].sort((left, right) => left.sequence - right.sequence);
 }
 function assertContext(context) {
     if (!isRecord(context) ||
@@ -1914,315 +1186,3 @@ function sameContext(left, right) {
         left.playPresetRevision === right.playPresetRevision &&
         left.playPresetScriptsEnabled === right.playPresetScriptsEnabled);
 }
-function assertRawRecord(record) {
-    if (!isRecord(record) ||
-        !hasExactKeys(record, [
-            "schemaVersion",
-            "recordId",
-            "sequence",
-            "worldId",
-            "parentHead",
-            "newHead",
-            "operationId",
-            "playPresetId",
-            "playPresetRevision",
-            "playPresetScriptsEnabled",
-            "requestId",
-            "requestAttempt",
-            "output",
-            "channel",
-            "contentType",
-            "payload",
-            "save",
-            "projection",
-            "invalidation",
-            "toolCallId",
-            "toolName",
-            "callFingerprint",
-            "payloadFingerprint",
-            "recordFingerprint",
-            "status",
-        ], [
-            "key",
-            "renderer",
-            "rendererRevision",
-            "frozenPresentation",
-            "extensionControl",
-        ]) ||
-        (record.extensionControl !== undefined &&
-            !isWorldExtensionControl(record.extensionControl)) ||
-        (record.frozenPresentation !== undefined &&
-            !isFrozenArtifactPresentation(record.frozenPresentation)) ||
-        record.schemaVersion !== 1 ||
-        !isNonEmptyString(record.recordId) ||
-        !Number.isSafeInteger(record.sequence) ||
-        record.sequence < 1 ||
-        !isNonEmptyString(record.worldId) ||
-        !isNonEmptyString(record.operationId) ||
-        !isNonEmptyString(record.output) ||
-        !isNonEmptyString(record.channel) ||
-        !isNonEmptyString(record.parentHead) ||
-        !isNonEmptyString(record.playPresetId) ||
-        !isNonEmptyString(record.playPresetRevision) ||
-        !isNonEmptyString(record.requestId) ||
-        !Number.isSafeInteger(record.requestAttempt) ||
-        record.requestAttempt < 1 ||
-        record.newHead !== null ||
-        typeof record.playPresetScriptsEnabled !== "boolean" ||
-        !["text/plain", "text/markdown", "application/json", "text/html"].includes(record.contentType) ||
-        !["none", "operation", "commit"].includes(record.save) ||
-        !["append", "replace", "upsert", "transient", "hidden"].includes(record.projection) ||
-        ![
-            "new_operation",
-            "head_change",
-            "operation_end",
-            "explicit_clear",
-            "never",
-        ].includes(record.invalidation) ||
-        typeof record.toolCallId !== "string" ||
-        record.toolName !== "artifact_emit" ||
-        !isSha256(record.callFingerprint) ||
-        !isSha256(record.payloadFingerprint) ||
-        !isSha256(record.recordFingerprint) ||
-        (record.renderer === undefined) !==
-            (record.rendererRevision === undefined) ||
-        (record.renderer !== undefined && !isNonEmptyString(record.renderer)) ||
-        (record.rendererRevision !== undefined &&
-            !isNonEmptyString(record.rendererRevision)) ||
-        (record.projection === "upsert"
-            ? !isNonEmptyString(record.key)
-            : record.key !== undefined) ||
-        record.status !== "pending")
-        throw new ArtifactStoreCorruptionError("Artifact raw record is corrupt");
-    if (!isJsonValue(record.payload))
-        throw new ArtifactStoreCorruptionError("Artifact payload is not a JSON value");
-    if (record.payloadFingerprint !==
-        payloadFingerprint(record.output, record.payload))
-        throw new ArtifactStoreCorruptionError("Artifact payload fingerprint does not match");
-    if (record.recordFingerprint !== rawRecordFingerprint(record))
-        throw new ArtifactStoreCorruptionError("Artifact raw-record fingerprint does not match");
-}
-function assertOperation(operation) {
-    const context = operation.context;
-    if (!isRecord(operation) ||
-        !hasExactKeys(operation, [
-            "schemaVersion",
-            "context",
-            "status",
-            "extensionStatus",
-            "completedRequests",
-            "artifactProjectionStatus",
-            "requestAttempts",
-        ], ["message", "head", "requests"]) ||
-        (operation.requests !== undefined &&
-            (!Array.isArray(operation.requests) ||
-                !operation.requests.every((item) => isRecord(item) &&
-                    hasExactKeys(item, [
-                        "requestId",
-                        "displayName",
-                        "mounts",
-                        "status",
-                    ]) &&
-                    isNonEmptyString(item.requestId) &&
-                    isNonEmptyString(item.displayName) &&
-                    Array.isArray(item.mounts) &&
-                    item.mounts.every((mount) => typeof mount === "string" &&
-                        [
-                            "story",
-                            "sidebar",
-                            "composer_above",
-                            "composer_below",
-                            "overlay",
-                            "debug",
-                        ].includes(mount)) &&
-                    ["running", "completed", "failed"].includes(item.status)))) ||
-        operation.schemaVersion !== 1 ||
-        !isRecord(context) ||
-        !hasExactKeys(context, [
-            "worldId",
-            "parentHead",
-            "operationId",
-            "playPresetId",
-            "playPresetRevision",
-            "playPresetScriptsEnabled",
-        ], ["attachment"]) ||
-        (context.attachment !== undefined &&
-            !validAttachment(context.attachment)) ||
-        !isNonEmptyString(context.worldId) ||
-        !isNonEmptyString(context.parentHead) ||
-        !isNonEmptyString(context.operationId) ||
-        !isNonEmptyString(context.playPresetId) ||
-        !isNonEmptyString(context.playPresetRevision) ||
-        typeof context.playPresetScriptsEnabled !== "boolean" ||
-        ![
-            "running",
-            "core_failed",
-            "core_materialization_pending",
-            "core_committed",
-            "completed",
-        ].includes(operation.status) ||
-        ![
-            "not_started",
-            "running",
-            "completed",
-            "failed",
-            "cancelled",
-            "budget_exceeded",
-            "unknown",
-            "recovery_required",
-            "superseded",
-        ].includes(operation.extensionStatus) ||
-        !Array.isArray(operation.completedRequests) ||
-        !operation.completedRequests.every(isNonEmptyString) ||
-        (operation.message !== undefined &&
-            typeof operation.message !== "string") ||
-        !validArtifactOperationState(operation) ||
-        !["active", "superseded"].includes(operation.artifactProjectionStatus) ||
-        !isRecord(operation.requestAttempts) ||
-        !Object.entries(operation.requestAttempts).every(([request, attempt]) => request.trim() !== "" &&
-            typeof attempt === "number" &&
-            Number.isSafeInteger(attempt) &&
-            attempt >= 1))
-        throw new ArtifactStoreCorruptionError("Artifact operation state is corrupt");
-}
-function validArtifactOperationState(operation) {
-    if (operation.status === "running")
-        return (operation.extensionStatus === "not_started" &&
-            operation.completedRequests.length === 0 &&
-            operation.message === undefined &&
-            operation.head === undefined);
-    if (operation.status === "core_failed")
-        return (operation.extensionStatus === "failed" &&
-            operation.completedRequests.length === 0 &&
-            operation.artifactProjectionStatus === "superseded" &&
-            operation.head === undefined);
-    if (operation.status === "core_materialization_pending")
-        return (operation.extensionStatus === "recovery_required" &&
-            operation.completedRequests.length === 0 &&
-            operation.artifactProjectionStatus === "active" &&
-            isNonEmptyString(operation.head) &&
-            isNonEmptyString(operation.message));
-    if (operation.status === "completed")
-        return (operation.extensionStatus === "completed" &&
-            isNonEmptyString(operation.head) &&
-            operation.message === undefined);
-    if (!isNonEmptyString(operation.head))
-        return false;
-    if (operation.extensionStatus === "completed")
-        return false;
-    if (operation.extensionStatus === "not_started" ||
-        operation.extensionStatus === "running")
-        return (operation.completedRequests.length === 0 &&
-            operation.message === undefined);
-    return (isNonEmptyString(operation.message) &&
-        (operation.extensionStatus !== "superseded" ||
-            operation.artifactProjectionStatus === "superseded"));
-}
-function assertEvent(event) {
-    if (!isRecord(event) ||
-        event.schemaVersion !== 1 ||
-        !Number.isSafeInteger(event.sequence) ||
-        event.sequence < 1 ||
-        !isNonEmptyString(event.operationId))
-        throw new ArtifactStoreCorruptionError("Artifact projection event is corrupt");
-    const requestPair = event.requestId === undefined && event.requestAttempt === undefined
-        ? true
-        : isNonEmptyString(event.requestId) &&
-            Number.isSafeInteger(event.requestAttempt) &&
-            Number(event.requestAttempt) >= 1;
-    if (event.kind === "activate") {
-        if (!hasExactKeys(event, ["schemaVersion", "kind", "sequence", "operationId", "recordId"], ["requestId", "requestAttempt"]) ||
-            !isNonEmptyString(event.recordId) ||
-            !requestPair)
-            throw new ArtifactStoreCorruptionError("Artifact projection event is corrupt");
-        return;
-    }
-    if (event.kind === "bind_head") {
-        if (!hasExactKeys(event, [
-            "schemaVersion",
-            "kind",
-            "sequence",
-            "operationId",
-            "recordId",
-            "head",
-        ]) ||
-            !isNonEmptyString(event.recordId) ||
-            !isNonEmptyString(event.head))
-            throw new ArtifactStoreCorruptionError("Artifact projection event is corrupt");
-        return;
-    }
-    if (event.kind === "supersede") {
-        if (!hasExactKeys(event, [
-            "schemaVersion",
-            "kind",
-            "sequence",
-            "operationId",
-            "recordId",
-            "reason",
-        ], ["requestId", "requestAttempt"]) ||
-            !isNonEmptyString(event.recordId) ||
-            !isNonEmptyString(event.reason) ||
-            !requestPair)
-            throw new ArtifactStoreCorruptionError("Artifact projection event is corrupt");
-        return;
-    }
-    if (event.kind === "clear" || event.kind === "ignored_call") {
-        if (!hasExactKeys(event, [
-            "schemaVersion",
-            "kind",
-            "sequence",
-            "operationId",
-            "output",
-            "channel",
-            "reason",
-            "toolCallId",
-            "toolName",
-            "callFingerprint",
-            "requestId",
-            "requestAttempt",
-        ], ["key"]) ||
-            !isNonEmptyString(event.output) ||
-            !isNonEmptyString(event.channel) ||
-            !isNonEmptyString(event.reason) ||
-            !isNonEmptyString(event.toolCallId) ||
-            event.toolName !== "artifact_clear" ||
-            !isSha256(event.callFingerprint) ||
-            !isNonEmptyString(event.requestId) ||
-            !Number.isSafeInteger(event.requestAttempt) ||
-            Number(event.requestAttempt) < 1 ||
-            (event.key !== undefined && !isNonEmptyString(event.key)))
-            throw new ArtifactStoreCorruptionError("Artifact projection event is corrupt");
-        return;
-    }
-    throw new ArtifactStoreCorruptionError("Artifact projection event is corrupt");
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function hasExactKeys(value, required, optional = []) {
-    const allowed = new Set([...required, ...optional]);
-    return (required.every((key) => Object.hasOwn(value, key)) &&
-        Object.keys(value).every((key) => allowed.has(key)));
-}
-function isNonEmptyString(value) {
-    return typeof value === "string" && value.trim() !== "";
-}
-function isSha256(value) {
-    return typeof value === "string" && /^sha256:[a-f0-9]{64}$/u.test(value);
-}
-function isMissing(error) {
-    return isRecord(error) && error.code === "ENOENT";
-}
-function isAlreadyExists(error) {
-    return isRecord(error) && error.code === "EEXIST";
-}
-function validAttachment(value) {
-    return (isRecord(value) &&
-        hasExactKeys(value, ["contextId", "eventId", "runId", "head"]) &&
-        isNonEmptyString(value.head) &&
-        isNonEmptyString(value.contextId) &&
-        isNonEmptyString(value.runId) &&
-        typeof value.eventId === "number" &&
-        Number.isSafeInteger(value.eventId) &&
-        value.eventId > 0);
-}