@noopolis/daimon 0.1.1 → 0.2.0

package/dist/runtime/wakeAcceptanceStore.js

@@ -0,0 +1,558 @@
+import { sameNamespace, currentProcessIdentity, processIsAlive, WakeTransitionLockBlockedError } from "./wakeAcceptanceProcessIdentity.js";
+import { constants } from "node:fs";
+import { link, lstat, open, readFile, readdir, realpath, rename, unlink } from "node:fs/promises";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+import { MAX_WAKE_ACCEPTANCE_RECORD_BYTES, sanitizeWakeCompletionText, wakeAcceptanceDigest } from "./wakeAcceptanceTypes.js";
+import { sanitizeExecutionError, parseStoredWakeAcceptance, publicStatus } from "./wakeAcceptanceRecord.js";
+import { assertOfflineReconciliationLeaseAvailable } from "./wakeAcceptanceReconciliation.js";
+import { acquireHostRegistration, releaseHostRegistration } from "./storeCoordination.js";
+import { MAX_WAKE_ACCEPTANCE_RECORDS, terminalFilesToCompact } from "./wakeAcceptanceRetention.js";
+const DEFAULT_CLAIM_TTL_MS = 240_000;
+/** Durable, private idempotency authority; callers must pre-create its 0700 root. */
+export class WakeAcceptanceStore {
+    root;
+    directory;
+    identity;
+    registration;
+    claimTtlMs;
+    now;
+    owner;
+    ownerLiveness;
+    afterFinalLockAssertion;
+    mutations = Promise.resolve();
+    acceptanceFiles = new Map();
+    constructor(root, directory, identity, registration, claimTtlMs, now, owner, ownerLiveness, afterFinalLockAssertion) {
+        this.root = root;
+        this.directory = directory;
+        this.identity = identity;
+        this.registration = registration;
+        this.claimTtlMs = claimTtlMs;
+        this.now = now;
+        this.owner = owner;
+        this.ownerLiveness = ownerLiveness;
+        this.afterFinalLockAssertion = afterFinalLockAssertion;
+    }
+    static async open(root, options = {}) {
+        const claimTtlMs = options.claimTtlMs ?? DEFAULT_CLAIM_TTL_MS;
+        if (!Number.isInteger(claimTtlMs) || claimTtlMs < 1 || claimTtlMs > 600_000)
+            throw new Error("wake acceptance claim lease is outside its bound");
+        if (!path.isAbsolute(root))
+            throw new Error("wake acceptance store path must be absolute");
+        const owner = await (options.processIdentity ?? currentProcessIdentity)();
+        await assertNoLinks(root);
+        await assertOfflineReconciliationLeaseAvailable(root).catch(() => { throw new Error("wake acceptance store is reserved for offline reconciliation"); });
+        await options.afterInitialLeaseCheckForTest?.();
+        const before = await lstat(root);
+        if (!before.isDirectory() || before.isSymbolicLink() || before.uid !== process.getuid?.() || (before.mode & 0o777) !== 0o700)
+            throw new Error("wake acceptance store must be a caller-prepared private directory");
+        const directory = await open(root, constants.O_RDONLY | directoryFlag() | noFollow());
+        try {
+            const after = await directory.stat();
+            const real = await realpath(root);
+            if (!same(identity(before), identity(after)))
+                throw new Error("wake acceptance store changed during validation");
+            const registration = await acquireHostRegistration(real, directory, owner);
+            return new WakeAcceptanceStore(real, directory, identity(before), registration, claimTtlMs, options.nowForTest ?? Date.now, owner, options.ownerLiveness ?? processIsAlive, options.afterFinalLockAssertion);
+        }
+        catch (error) {
+            await directory.close().catch(() => undefined);
+            throw error;
+        }
+    }
+    accept(request) {
+        return this.serialize(async () => await this.acceptNow(request));
+    }
+    async acceptNow(request) {
+        await this.verify();
+        const request_digest = wakeAcceptanceDigest(request);
+        const target = this.fileFor(request.agent_id, request.delivery_id);
+        const existing = await this.readOptional(target);
+        if (existing !== undefined) {
+            if (existing.request_digest !== request_digest)
+                throw new WakeAcceptanceConflictError();
+            return { record: existing, created: false };
+        }
+        await this.compactTerminalRecords();
+        if ((await this.files()).length >= MAX_WAKE_ACCEPTANCE_RECORDS)
+            throw new WakeInboxFullError();
+        const now = new Date().toISOString();
+        const record = { acceptance_id: randomUUID(), agent_id: request.agent_id, delivery_id: request.delivery_id, request_digest, event: request.event, state: "accepted", accepted_at: now, updated_at: now };
+        const temporary = path.join(this.root, `.pending-${randomUUID()}`);
+        try {
+            await this.writeNew(temporary, record);
+            try {
+                await link(temporary, target);
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                const winner = await this.read(target);
+                if (winner.request_digest !== request_digest)
+                    throw new WakeAcceptanceConflictError();
+                return { record: winner, created: false };
+            }
+            await this.directory.sync();
+            this.acceptanceFiles.set(record.acceptance_id, target);
+            return { record, created: true };
+        }
+        finally {
+            await unlink(temporary).catch(() => undefined);
+        }
+    }
+    async status(acceptanceId) {
+        const record = await this.findByAcceptanceId(acceptanceId);
+        return record === undefined ? undefined : publicStatus(record);
+    }
+    async activity() { return await this.activityRows(false); }
+    /** Internal availability view; diagnostics never enter the public receipt wire. */
+    async activityWithExecutionErrors() { return await this.activityRows(true); }
+    async activityRows(includeExecutionErrors) {
+        const records = await Promise.all((await this.files()).map(async (file) => await this.read(path.join(this.root, file))));
+        records.sort((left, right) => left.accepted_at.localeCompare(right.accepted_at) || left.acceptance_id.localeCompare(right.acceptance_id));
+        const queued = new Map();
+        const activeExecutions = new Set();
+        return records.map((record) => {
+            const position = record.state === "accepted" ? (queued.get(record.agent_id) ?? 0) + 1 : undefined;
+            if (position !== undefined)
+                queued.set(record.agent_id, position);
+            const active = record.state === "running" && !activeExecutions.has(record.agent_id);
+            if (active)
+                activeExecutions.add(record.agent_id);
+            return { ...publicStatus(record), active, ...(position === undefined ? {} : { queue_position: position }),
+                ...(includeExecutionErrors && record.execution_error !== undefined ? { execution_error: record.execution_error } : {}) };
+        });
+    }
+    async recoverable(agentIds) {
+        const result = [];
+        for (const file of await this.files()) {
+            const record = await this.read(path.join(this.root, file));
+            if (!agentIds.has(record.agent_id))
+                throw new Error("wake acceptance store contains an unknown agent authority");
+            if (record.state === "accepted" || record.state === "running") {
+                const claim = await this.readClaimOptional(this.claimFor(record));
+                result.push(!record.deferred && record.execution_id === undefined && claim?.acceptance_ids?.includes(record.acceptance_id) && claim.execution_id !== undefined ? { ...record, execution_id: claim.execution_id } : record);
+            }
+        }
+        return result.sort((left, right) => left.accepted_at.localeCompare(right.accepted_at) || left.acceptance_id.localeCompare(right.acceptance_id));
+    }
+    transition(acceptanceId, state, code) {
+        return this.serialize(async () => await this.transitionNow(acceptanceId, state, code));
+    }
+    /** Fuse race seam: never stops a record that was claimed after enumeration. */
+    transitionAcceptedToStopped(acceptanceId) {
+        return this.serialize(async () => {
+            const target = await this.pathForAcceptanceId(acceptanceId);
+            const prior = await this.read(target);
+            if (prior.state !== "accepted")
+                return prior;
+            const record = { ...prior, state: "stopped", code: "host_stopping", updated_at: new Date().toISOString() };
+            await this.replace(target, record);
+            return record;
+        });
+    }
+    acquireClaim(acceptanceId, ownerId, acceptanceIds, executionId) {
+        return this.serialize(async () => {
+            if (!uuid(ownerId))
+                throw new Error("wake execution owner is invalid");
+            const record = await this.findByAcceptanceId(acceptanceId);
+            if (record === undefined)
+                throw new Error("wake acceptance receipt is unavailable");
+            if (isTerminal(record.state))
+                return { state: "terminal" };
+            if (acceptanceIds !== undefined) {
+                if (!acceptanceIds.includes(acceptanceId) || acceptanceIds.length > 32 || new Set(acceptanceIds).size !== acceptanceIds.length || !executionId || !uuid(executionId))
+                    throw new Error("invalid execution membership");
+                for (const member of acceptanceIds) {
+                    const candidate = await this.findByAcceptanceId(member);
+                    if (!candidate || candidate.agent_id !== record.agent_id || isTerminal(candidate.state))
+                        throw new Error("invalid execution member");
+                }
+            }
+            const target = this.claimFor(record);
+            const current = await this.readClaimOptional(target);
+            if (current !== undefined && !expired(current, this.now()))
+                return { state: "held", retry_at: current.expires_at };
+            const lock = await this.acquireTransitionLock(record, ownerId);
+            if (lock === undefined)
+                return { state: "held", retry_at: new Date(this.now() + 50).toISOString() };
+            try {
+                const checked = await this.readClaimOptional(target);
+                if (checked !== undefined && !expired(checked, this.now()))
+                    return { state: "held", retry_at: checked.expires_at };
+                if (checked !== undefined) {
+                    await unlink(target);
+                    await this.directory.sync();
+                }
+                const claim = { acceptance_id: record.acceptance_id, owner_id: ownerId, generation: randomUUID(), expires_at: new Date(this.now() + this.claimTtlMs).toISOString(), ...(acceptanceIds === undefined ? {} : { acceptance_ids: acceptanceIds, execution_id: executionId }) };
+                const temporary = path.join(this.root, `.claim-${randomUUID()}`);
+                try {
+                    await this.writeNew(temporary, claim);
+                    try {
+                        await link(temporary, target);
+                    }
+                    catch (error) {
+                        if (error.code === "EEXIST") {
+                            const winner = await this.readClaim(target);
+                            return { state: "held", retry_at: winner.expires_at };
+                        }
+                        throw error;
+                    }
+                    await this.directory.sync();
+                    return { state: "acquired", claim };
+                }
+                finally {
+                    await unlink(temporary).catch(() => undefined);
+                }
+            }
+            finally {
+                await this.releaseTransitionLock(record, lock);
+            }
+        });
+    }
+    claimHeartbeatIntervalMs() { return Math.max(1, Math.floor(this.claimTtlMs / 3)); }
+    renewClaim(acceptanceId, claim) {
+        return this.serialize(async () => {
+            const record = await this.findByAcceptanceId(acceptanceId);
+            if (record === undefined)
+                throw new Error("wake acceptance receipt is unavailable");
+            const lock = await this.acquireTransitionLock(record, claim.owner_id);
+            if (lock === undefined)
+                throw new WakeExecutionClaimLostError();
+            try {
+                const current = await this.readClaim(this.claimFor(record));
+                if (!(current.acceptance_id === acceptanceId || current.acceptance_ids?.includes(acceptanceId)) || current.acceptance_id !== claim.acceptance_id || current.owner_id !== claim.owner_id || current.generation !== claim.generation || current.expires_at !== claim.expires_at || expired(current, this.now()))
+                    throw new WakeExecutionClaimLostError();
+                const renewed = { ...current, expires_at: new Date(this.now() + this.claimTtlMs).toISOString() };
+                await this.replaceValue(this.claimFor(record), renewed);
+                return renewed;
+            }
+            finally {
+                await this.releaseTransitionLock(record, lock);
+            }
+        });
+    }
+    /** `text` carries the completion output on success and the engine failure cause on failure. */
+    transitionClaimed(acceptanceId, claim, state, code, completedText, attention) {
+        return this.serialize(async () => {
+            if (completedText !== undefined && state !== "completed" && state !== "failed")
+                throw new Error("wake text requires completed or failed state");
+            const initial = await this.findByAcceptanceId(acceptanceId);
+            if (initial === undefined)
+                throw new Error("wake acceptance receipt is unavailable");
+            const lock = await this.acquireTransitionLock(initial, claim.owner_id);
+            if (lock === undefined)
+                throw new WakeExecutionClaimLostError();
+            try {
+                let record = await this.transitionNowClaimed(acceptanceId, claim);
+                if (isTerminal(record.state))
+                    return record;
+                if (state !== "running" && record.claim_generation !== claim.generation)
+                    throw new WakeExecutionClaimLostError();
+                await this.assertTransitionLock(record, lock);
+                record = await this.transitionNowClaimed(acceptanceId, claim);
+                if (isTerminal(record.state))
+                    return record;
+                if (state !== "running" && record.claim_generation !== claim.generation)
+                    throw new WakeExecutionClaimLostError();
+                await this.assertTransitionLock(record, lock);
+                await this.afterFinalLockAssertion?.();
+                await this.assertTransitionLock(record, lock);
+                const target = this.fileFor(record.agent_id, record.delivery_id);
+                // The code explains the transition that produced the CURRENT state, so a
+                // transition that names none clears it. While codes existed only on terminal
+                // records this could not matter — a terminal record returns above and is never
+                // rewritten — but a delivery reclaimed to `accepted` with its wake's outcome is
+                // claimed again later, and a carried-over code would describe the wrong state.
+                const { code: _replaced, ...carried } = record;
+                const next = { ...carried, state, updated_at: new Date().toISOString(), claim_generation: claim.generation, ...(code === undefined ? {} : { code }), ...(completedText === undefined ? {} : { text: sanitizeWakeCompletionText(completedText) }), ...(attention === undefined ? {} : { execution_id: attention.clear_execution ? undefined : attention.execution_id ?? record.execution_id, deferred: attention.deferred ?? record.deferred, execution_error: attention.execution_error === null ? undefined : attention.execution_error === undefined ? record.execution_error : sanitizeExecutionError(attention.execution_error) || undefined }) };
+                await this.replace(target, next);
+                if (claim.acceptance_ids === undefined && (isTerminal(state) || state === "accepted")) {
+                    const currentClaim = await this.readClaimOptional(this.claimFor(record));
+                    if (currentClaim?.owner_id === claim.owner_id && currentClaim.generation === claim.generation) {
+                        await unlink(this.claimFor(record));
+                        await this.directory.sync();
+                    }
+                }
+                return next;
+            }
+            finally {
+                await this.releaseTransitionLock(initial, lock);
+            }
+        });
+    }
+    releaseClaim(claim) {
+        return this.serialize(async () => {
+            const record = await this.findByAcceptanceId(claim.acceptance_id);
+            if (!record)
+                throw new WakeExecutionClaimLostError();
+            const lock = await this.acquireTransitionLock(record, claim.owner_id);
+            if (!lock)
+                throw new WakeExecutionClaimLostError();
+            try {
+                const current = await this.readClaimOptional(this.claimFor(record));
+                if (current?.generation !== claim.generation || current.owner_id !== claim.owner_id)
+                    throw new WakeExecutionClaimLostError();
+                await unlink(this.claimFor(record));
+                await this.directory.sync();
+            }
+            finally {
+                await this.releaseTransitionLock(record, lock);
+            }
+        });
+    }
+    releaseClaims(ownerId) {
+        return this.serialize(async () => {
+            for (const file of await this.claimFiles()) {
+                const claim = await this.readClaim(path.join(this.root, file));
+                if (claim.owner_id === ownerId)
+                    await unlink(path.join(this.root, file));
+            }
+            await this.directory.sync();
+        });
+    }
+    async transitionNow(acceptanceId, state, code) {
+        const target = await this.pathForAcceptanceId(acceptanceId);
+        const prior = await this.read(target);
+        if (isTerminal(prior.state))
+            return prior;
+        const record = { ...prior, state, updated_at: new Date().toISOString(), ...(code === undefined ? {} : { code }) };
+        await this.replace(target, record);
+        return record;
+    }
+    async close() { await this.mutations; await releaseHostRegistration(this.root, this.directory, this.registration); await this.directory.close(); }
+    serialize(operation) {
+        const result = this.mutations.catch(() => undefined).then(operation);
+        this.mutations = result.then(() => undefined, () => undefined);
+        return result;
+    }
+    async findByAcceptanceId(acceptanceId) {
+        if (!uuid(acceptanceId))
+            return undefined;
+        const known = this.acceptanceFiles.get(acceptanceId);
+        if (known !== undefined)
+            return await this.readOptional(known);
+        for (const file of await this.files()) {
+            const record = await this.read(path.join(this.root, file));
+            this.acceptanceFiles.set(record.acceptance_id, path.join(this.root, file));
+            if (record.acceptance_id === acceptanceId)
+                return record;
+        }
+        return undefined;
+    }
+    async pathForAcceptanceId(acceptanceId) {
+        const record = await this.findByAcceptanceId(acceptanceId);
+        if (record === undefined)
+            throw new Error("wake acceptance receipt is unavailable");
+        return this.fileFor(record.agent_id, record.delivery_id);
+    }
+    claimFor(record) { return path.join(this.root, `${createHash("sha256").update(record.agent_id).digest("hex")}.agent-claim`); }
+    lockFor(record) { return this.fileFor(record.agent_id, record.delivery_id).replace(/\.json$/u, ".transition-lock"); }
+    async acquireTransitionLock(record, ownerId) {
+        const target = this.lockFor(record);
+        const current = await this.readLockOptional(target);
+        if (current !== undefined && !sameNamespace(current, this.owner))
+            throw new WakeTransitionLockBlockedError();
+        if (current !== undefined && await this.ownerLiveness(current))
+            return undefined;
+        if (current !== undefined) {
+            await unlink(target);
+            await this.directory.sync();
+        }
+        const lock = { owner_id: ownerId, generation: randomUUID(), ...this.owner };
+        const temporary = path.join(this.root, `.lock-${randomUUID()}`);
+        try {
+            await this.writeNew(temporary, lock);
+            try {
+                await link(temporary, target);
+            }
+            catch (error) {
+                if (error.code === "EEXIST")
+                    return undefined;
+                throw error;
+            }
+            await this.directory.sync();
+            return lock;
+        }
+        finally {
+            await unlink(temporary).catch(() => undefined);
+        }
+    }
+    async assertTransitionLock(record, lock) {
+        const current = await this.readLock(this.lockFor(record)).catch(() => { throw new WakeExecutionClaimLostError(); });
+        if (current.owner_id !== lock.owner_id || current.generation !== lock.generation || current.pid !== lock.pid || current.process_start !== lock.process_start || current.boot_id !== lock.boot_id || !sameNamespace(current, lock))
+            throw new WakeExecutionClaimLostError();
+    }
+    async releaseTransitionLock(record, lock) {
+        const target = this.lockFor(record);
+        const current = await this.readLockOptional(target);
+        if (current !== undefined && current.owner_id === lock.owner_id && current.generation === lock.generation && current.pid === lock.pid && current.process_start === lock.process_start && current.boot_id === lock.boot_id && sameNamespace(current, lock)) {
+            await unlink(target);
+            await this.directory.sync();
+        }
+    }
+    fileFor(agentId, deliveryId) {
+        return path.join(this.root, `${createHash("sha256").update(`${agentId}\u0000${deliveryId}`).digest("hex")}.json`);
+    }
+    async files() {
+        await this.verify();
+        const entries = await readdir(this.root);
+        const files = entries.filter((entry) => /^[a-f0-9]{64}\.json$/.test(entry));
+        if (files.length > MAX_WAKE_ACCEPTANCE_RECORDS || entries.length > MAX_WAKE_ACCEPTANCE_RECORDS + 128)
+            throw new Error("wake acceptance store exceeds its bounded record limit");
+        return files;
+    }
+    async claimFiles() { return (await readdir(this.root)).filter((entry) => /^[a-f0-9]{64}\.agent-claim$/.test(entry)); }
+    async readOptional(file) { try {
+        return await this.read(file);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    } }
+    async read(file) {
+        const entry = await lstat(file);
+        if (!entry.isFile() || entry.isSymbolicLink() || entry.uid !== process.getuid?.() || (entry.mode & 0o777) !== 0o600 || entry.size > MAX_WAKE_ACCEPTANCE_RECORD_BYTES)
+            throw new Error("wake acceptance record is unsafe");
+        const bytes = await readFile(file);
+        if (bytes.length > MAX_WAKE_ACCEPTANCE_RECORD_BYTES)
+            throw new Error("wake acceptance record exceeds its bound");
+        return parseStoredWakeAcceptance(JSON.parse(bytes.toString("utf8")));
+    }
+    async readClaimOptional(file) { try {
+        return await this.readClaim(file);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    } }
+    async readClaim(file) {
+        const entry = await lstat(file);
+        if (!entry.isFile() || entry.isSymbolicLink() || entry.uid !== process.getuid?.() || (entry.mode & 0o777) !== 0o600 || entry.size > 4096)
+            throw new Error("wake execution claim is unsafe");
+        const value = JSON.parse((await readFile(file)).toString("utf8"));
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            throw new Error("wake execution claim is invalid");
+        const record = value;
+        if (Object.keys(record).some((key) => !["acceptance_id", "owner_id", "generation", "expires_at", "acceptance_ids", "execution_id"].includes(key)) || !Object.hasOwn(record, "acceptance_id") || !Object.hasOwn(record, "owner_id") || !Object.hasOwn(record, "generation") || !Object.hasOwn(record, "expires_at"))
+            throw new Error("wake execution claim is invalid");
+        const members = record.acceptance_ids;
+        if ((members === undefined) !== (record.execution_id === undefined))
+            throw new Error("wake execution membership is invalid");
+        if (members !== undefined && (!Array.isArray(members) || members.length < 1 || members.length > 32 || members.some((member) => typeof member !== "string" || !uuid(member)) || !members.includes(record.acceptance_id) || new Set(members).size !== members.length || typeof record.execution_id !== "string" || !uuid(record.execution_id)))
+            throw new Error("wake execution membership is invalid");
+        const claim = { ...(members === undefined ? {} : { acceptance_ids: members, execution_id: string(record.execution_id) }), acceptance_id: string(record.acceptance_id), owner_id: string(record.owner_id), generation: string(record.generation), expires_at: timestamp(record.expires_at) };
+        if (!uuid(claim.acceptance_id) || !uuid(claim.owner_id) || !uuid(claim.generation))
+            throw new Error("wake execution claim is invalid");
+        return claim;
+    }
+    async readLockOptional(file) { try {
+        return await this.readLock(file);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    } }
+    async readLock(file) {
+        const entry = await lstat(file);
+        if (!entry.isFile() || entry.isSymbolicLink() || entry.uid !== process.getuid?.() || (entry.mode & 0o777) !== 0o600 || entry.size > 1_024)
+            throw new Error("wake transition lock is unsafe");
+        const value = JSON.parse((await readFile(file)).toString("utf8"));
+        if (value === null || typeof value !== "object" || Array.isArray(value))
+            throw new Error("wake transition lock is invalid");
+        const lock = value;
+        if (Object.keys(lock).length !== 7 || !Object.hasOwn(lock, "owner_id") || !Object.hasOwn(lock, "generation") || !Object.hasOwn(lock, "pid") || !Object.hasOwn(lock, "process_start") || !Object.hasOwn(lock, "boot_id") || !Object.hasOwn(lock, "pid_namespace_dev") || !Object.hasOwn(lock, "pid_namespace_ino"))
+            throw new Error("wake transition lock is invalid");
+        const result = { owner_id: string(lock.owner_id), generation: string(lock.generation), pid: integer(lock.pid), process_start: string(lock.process_start), boot_id: string(lock.boot_id), pid_namespace_dev: integer(lock.pid_namespace_dev), pid_namespace_ino: integer(lock.pid_namespace_ino) };
+        if (!uuid(result.owner_id) || !uuid(result.generation) || result.pid < 1 || !result.process_start || !result.boot_id || result.pid_namespace_dev < 1 || result.pid_namespace_ino < 1)
+            throw new Error("wake transition lock is invalid");
+        return result;
+    }
+    async transitionNowClaimed(acceptanceId, claim) {
+        const record = await this.findByAcceptanceId(acceptanceId);
+        if (record === undefined)
+            throw new Error("wake acceptance receipt is unavailable");
+        const current = await this.readClaim(this.claimFor(record));
+        if (!(current.acceptance_id === acceptanceId || current.acceptance_ids?.includes(acceptanceId)) || current.acceptance_id !== claim.acceptance_id || current.owner_id !== claim.owner_id || current.generation !== claim.generation || current.expires_at !== claim.expires_at || expired(current, this.now()))
+            throw new WakeExecutionClaimLostError();
+        return record;
+    }
+    async compactTerminalRecords() {
+        const files = await this.files();
+        if (files.length < 2_112)
+            return;
+        const records = await Promise.all(files.map(async (file) => ({ file, record: await this.read(path.join(this.root, file)) })));
+        for (const file of terminalFilesToCompact(records.map(({ file, record }) => ({ file, state: record.state, updatedAt: record.updated_at, acceptanceId: record.acceptance_id })))) {
+            const record = records.find((candidate) => candidate.file === file)?.record;
+            if (record !== undefined)
+                this.acceptanceFiles.delete(record.acceptance_id);
+            await unlink(path.join(this.root, file));
+        }
+        await this.directory.sync();
+    }
+    async writeNew(file, record) {
+        const handle = await open(file, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | noFollow(), 0o600);
+        try {
+            await handle.writeFile(JSON.stringify(record));
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async replace(target, record) { await this.replaceValue(target, record); }
+    async replaceValue(target, record) {
+        const temporary = path.join(this.root, `.replace-${randomUUID()}`);
+        try {
+            await this.writeNew(temporary, record);
+            await rename(temporary, target);
+            await this.directory.sync();
+        }
+        finally {
+            await unlink(temporary).catch(() => undefined);
+        }
+    }
+    async verify() {
+        await assertNoLinks(this.root);
+        const entry = await lstat(this.root);
+        const opened = await this.directory.stat();
+        if (!same(identity(entry), this.identity) || !same(identity(opened), this.identity) || (await realpath(this.root)) !== this.root)
+            throw new Error("wake acceptance store changed after validation");
+    }
+}
+export class WakeInboxFullError extends Error {
+    constructor() { super("wake acceptance store has no capacity without deleting active work"); }
+}
+export class WakeAcceptanceConflictError extends Error {
+    constructor() { super("delivery id is already bound to a different request"); }
+}
+export class WakeExecutionClaimLostError extends Error {
+    constructor() { super("wake execution claim was lost"); }
+}
+/** A container boundary requires deployment-authorized offline reconciliation. */
+export { WakeTransitionLockBlockedError } from "./wakeAcceptanceProcessIdentity.js";
+export { publicAcceptance } from "./wakeAcceptanceRecord.js";
+function string(value) { if (typeof value !== "string")
+    throw new Error("wake acceptance record is invalid"); return value; }
+function integer(value) { if (typeof value !== "number" || !Number.isSafeInteger(value))
+    throw new Error("wake transition lock is invalid"); return value; }
+function timestamp(value) { const result = string(value); if (Number.isNaN(Date.parse(result)) || new Date(result).toISOString() !== result)
+    throw new Error("wake acceptance record is invalid"); return result; }
+function uuid(value) { return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/iu.test(value); }
+function isTerminal(state) { return state === "completed" || state === "failed" || state === "stopped"; }
+function expired(claim, now) { return Date.parse(claim.expires_at) <= now; }
+function identity(value) {
+    const numeric = value;
+    return { dev: numeric.dev, ino: numeric.ino, uid: numeric.uid, mode: numeric.mode & 0o7777 };
+}
+function same(left, right) { return left.dev === right.dev && left.ino === right.ino && left.uid === right.uid && left.mode === right.mode; }
+function noFollow() { return constants.O_NOFOLLOW ?? 0; }
+function directoryFlag() { return constants.O_DIRECTORY ?? 0; }
+async function assertNoLinks(target) { let current = path.parse(target).root; for (const part of path.relative(current, target).split(path.sep).filter(Boolean)) {
+    current = path.join(current, part);
+    if ((await lstat(current)).isSymbolicLink() && current !== "/var")
+        throw new Error("wake acceptance store path contains a symlink");
+} }