@noopolis/daimon 0.1.1 → 0.2.0

package/dist/pi/wakeAcceptance.js

@@ -0,0 +1,281 @@
+import { resolveRunId } from "../observability/causalEvents.js";
+import { candidateFromDelivery, WAKE_ACCEPTANCE_FILE_BYTES_MAX, WAKE_ACCEPTANCE_VERSION, WakeAcceptanceError, emptyWakeAcceptanceState, parseWakeAcceptanceState, pruneCompletedRecords, serializeWakeAcceptanceState } from "./wakeAcceptanceSchema.js";
+import { WakeAcceptanceFs } from "./wakeAcceptanceFs.js";
+const UTF8 = "utf8";
+const COMPLETED_STATE = "completed";
+const MAX_SEQUENCE = Number.MAX_SAFE_INTEGER;
+const CAPABILITY_BRAND = Symbol("wake-acceptance-capability");
+export class WakeAcceptanceStore {
+    runtimeHomePath;
+    agentId;
+    fs;
+    runId;
+    capabilities = new WeakMap();
+    constructor(runtimeHomePath, agentId, fs = new WakeAcceptanceFs(runtimeHomePath)) {
+        this.runtimeHomePath = runtimeHomePath;
+        this.agentId = agentId;
+        this.fs = fs;
+        this.runId = resolveRunId();
+    }
+    getAcceptanceFilePath() {
+        return this.fs.stateFilePath;
+    }
+    candidateFromDelivery(event) {
+        return candidateFromDelivery({
+            event,
+            runId: this.runId,
+            trustedAgentId: this.agentId
+        });
+    }
+    candidateFromEvent(event) {
+        return this.candidateFromDelivery(event);
+    }
+    async begin(event) {
+        const attempt = this.candidateFromDelivery(event);
+        return this.beginFromAttempt(attempt);
+    }
+    async beginFromAttempt(attempt) {
+        let capability;
+        const admission = await this.withClaim(async () => {
+            await this.fs.cleanupTemps();
+            const state = await this.loadStateUnsafe();
+            const existing = state.records.find((record) => record.identity === attempt.identity);
+            if (existing !== undefined) {
+                if (existing.digest !== attempt.digest) {
+                    throw this.makeError("wake_delivery_conflict", true);
+                }
+                if (existing.state !== COMPLETED_STATE) {
+                    throw this.makeError("wake_delivery_incomplete", true);
+                }
+                return "replay";
+            }
+            const nextSequence = this.nextSequence(state.next_sequence);
+            const nextState = this.makeRecord(attempt, "accepted", nextSequence);
+            const withAddition = pruneCompletedRecords([...state.records, nextState]);
+            const nextStore = {
+                ...state,
+                next_sequence: nextState.sequence,
+                records: withAddition
+            };
+            await this.persistState(nextStore);
+            return nextState;
+        }, (result) => {
+            if (result === "replay") {
+                return;
+            }
+            capability = this.createCapability({
+                identity: result.identity,
+                digest: result.digest,
+                phase: "accepted",
+                sequence: result.sequence
+            });
+        });
+        if (admission === "replay") {
+            return { mode: "replay" };
+        }
+        if (capability === undefined) {
+            throw this.makeError("wake_acceptance_store_corrupt", false);
+        }
+        return { mode: "run", capability };
+    }
+    async markInvoking(capability) {
+        const issued = this.consumeCapability(capability, "accepted");
+        let replacement;
+        return this.withClaim(async () => {
+            return this.transitionAttempt(issued, "invoking");
+        }, (record) => {
+            this.capabilities.delete(capability);
+            replacement = this.createCapability({
+                identity: record.identity,
+                digest: record.digest,
+                phase: "invoking",
+                sequence: record.sequence
+            });
+        }).then(() => {
+            if (replacement === undefined) {
+                throw this.makeError("wake_acceptance_store_corrupt", false);
+            }
+            return replacement;
+        });
+    }
+    async markCompleted(capability) {
+        const issued = this.consumeCapability(capability, "invoking");
+        await this.withClaim(async () => {
+            await this.transitionAttempt(issued, COMPLETED_STATE);
+        }, () => {
+            this.capabilities.delete(capability);
+        });
+    }
+    async markIncomplete(capability) {
+        const issued = this.consumeCapability(capability, "accepted", "invoking");
+        await this.withClaim(async () => {
+            await this.transitionAttempt(issued, "incomplete");
+        }, () => {
+            this.capabilities.delete(capability);
+        });
+    }
+    async loadState() {
+        const raw = await this.fs.readStateText();
+        if (raw === undefined) {
+            return emptyWakeAcceptanceState({
+                runId: this.runId,
+                agentId: this.agentId
+            });
+        }
+        try {
+            return parseWakeAcceptanceState(JSON.parse(raw), { runId: this.runId, agentId: this.agentId });
+        }
+        catch (error) {
+            if (error instanceof WakeAcceptanceError) {
+                throw this.makeError(error.code, true);
+            }
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+    }
+    async loadStateUnsafe() {
+        return this.loadState();
+    }
+    makeRecord(attempt, state, sequence) {
+        return {
+            body_sha256: attempt.bodySha256,
+            context_id: attempt.contextId,
+            digest: attempt.digest,
+            event_id: attempt.eventId,
+            identity: attempt.identity,
+            kind: attempt.kind,
+            sender: attempt.sender,
+            state,
+            sequence,
+            target: attempt.target
+        };
+    }
+    makeError(code, safeToRelease) {
+        const error = new WakeAcceptanceError(code);
+        error.safeToRelease = safeToRelease;
+        return error;
+    }
+    canRelease(error) {
+        if (!(error instanceof WakeAcceptanceError)) {
+            return false;
+        }
+        const info = error;
+        return info.safeToRelease !== false;
+    }
+    async withClaim(operation, afterRelease) {
+        await this.fs.acquireClaim();
+        let result;
+        try {
+            result = await operation();
+        }
+        catch (error) {
+            if (this.canRelease(error)) {
+                try {
+                    await this.fs.releaseClaim();
+                }
+                catch (releaseError) {
+                    if (releaseError instanceof WakeAcceptanceError) {
+                        throw releaseError;
+                    }
+                    throw this.makeError("wake_acceptance_store_corrupt", false);
+                }
+            }
+            throw error;
+        }
+        try {
+            await this.fs.releaseClaim();
+        }
+        catch (error) {
+            if (error instanceof WakeAcceptanceError) {
+                throw error;
+            }
+            throw this.makeError("wake_acceptance_store_corrupt", false);
+        }
+        if (afterRelease !== undefined) {
+            await afterRelease(result);
+        }
+        return result;
+    }
+    createCapability(record) {
+        const token = {
+            [CAPABILITY_BRAND]: record.phase
+        };
+        this.capabilities.set(token, record);
+        return token;
+    }
+    consumeCapability(capability, ...phases) {
+        const record = this.capabilities.get(capability);
+        if (record === undefined) {
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+        if (!phases.includes(record.phase)) {
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+        return record;
+    }
+    async transitionAttempt(data, nextState) {
+        const state = await this.loadStateUnsafe();
+        const index = state.records.findIndex((record) => record.identity === data.identity);
+        if (index === -1) {
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+        const existing = state.records[index];
+        if (existing.digest !== data.digest) {
+            throw this.makeError("wake_delivery_conflict", true);
+        }
+        if (data.sequence !== existing.sequence) {
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+        if (nextState === "invoking" && existing.state !== "accepted") {
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+        if (nextState === COMPLETED_STATE && existing.state !== "invoking") {
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+        if (nextState === "incomplete" && existing.state !== "accepted" && existing.state !== "invoking") {
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+        if (nextState === existing.state) {
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+        const nextSequence = this.nextSequence(state.next_sequence);
+        const next = {
+            ...existing,
+            sequence: nextSequence,
+            state: nextState
+        };
+        const records = [...state.records];
+        records[index] = next;
+        const nextStore = {
+            ...state,
+            next_sequence: nextSequence,
+            records: pruneCompletedRecords(records)
+        };
+        await this.persistState(nextStore);
+        return next;
+    }
+    async persistState(state) {
+        const body = serializeWakeAcceptanceState(state);
+        if (Buffer.byteLength(body, UTF8) > WAKE_ACCEPTANCE_FILE_BYTES_MAX) {
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+        if (state.version !== WAKE_ACCEPTANCE_VERSION) {
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+        const validated = parseWakeAcceptanceState(JSON.parse(body), {
+            runId: this.runId,
+            agentId: this.agentId
+        });
+        const canonical = serializeWakeAcceptanceState(validated);
+        if (Buffer.byteLength(canonical, UTF8) > WAKE_ACCEPTANCE_FILE_BYTES_MAX) {
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+        await this.fs.writeStateText(canonical);
+    }
+    nextSequence(previous) {
+        if (previous >= MAX_SEQUENCE) {
+            throw this.makeError("wake_acceptance_store_corrupt", true);
+        }
+        return previous + 1;
+    }
+}
+export { WAKE_ACCEPTANCE_VERSION, WakeAcceptanceError } from "./wakeAcceptanceSchema.js";

package/dist/pi/wakeAcceptanceFs.d.ts

@@ -0,0 +1,44 @@
+import { lstat, mkdir, open, readdir, readFile, rename, unlink } from "node:fs/promises";
+export interface WakeAcceptanceFsHooks {
+    preWrite?: (tempPath: string) => void | Promise<void>;
+    preSync?: (tempPath: string) => void | Promise<void>;
+    preClose?: (tempPath: string) => void | Promise<void>;
+    preRename?: (tempPath: string, finalPath: string) => void | Promise<void>;
+    preDirectorySync?: (directoryPath: string) => void | Promise<void>;
+    preClaimAcquire?: () => void | Promise<void>;
+    preClaimRelease?: () => void | Promise<void>;
+}
+export interface WakeAcceptanceFsDependencies {
+    lstat: typeof lstat;
+    mkdir: typeof mkdir;
+    open: typeof open;
+    readdir: typeof readdir;
+    readFile: typeof readFile;
+    rename: typeof rename;
+    unlink: typeof unlink;
+    syncDirectory: (directoryPath: string) => Promise<void>;
+}
+export interface WakeAcceptanceFsOptions {
+    dependencies?: Partial<WakeAcceptanceFsDependencies>;
+    hooks?: WakeAcceptanceFsHooks;
+    randomUUID?: () => string;
+}
+export declare class WakeAcceptanceFs {
+    readonly runtimeHomePath: string;
+    readonly stateDirectoryPath: string;
+    readonly stateFilePath: string;
+    readonly lockPath: string;
+    readonly deps: WakeAcceptanceFsDependencies;
+    private readonly randomId;
+    private readonly hooks;
+    constructor(runtimeHomePath: string, options?: WakeAcceptanceFsOptions);
+    assertRuntimeDirectory(): Promise<void>;
+    assertStoreDirectory(): Promise<void>;
+    acquireClaim(): Promise<void>;
+    releaseClaim(): Promise<void>;
+    readStateText(): Promise<string | undefined>;
+    private removeOwnedTemp;
+    writeStateText(body: string): Promise<void>;
+    cleanupTemps(): Promise<void>;
+}
+//# sourceMappingURL=wakeAcceptanceFs.d.ts.map

package/dist/pi/wakeAcceptanceFs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wakeAcceptanceFs.d.ts","sourceRoot":"","sources":["../../src/pi/wakeAcceptanceFs.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAmB,MAAM,kBAAkB,CAAC;AAwF1G,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,OAAO,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACrD,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,SAAS,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC1E,gBAAgB,CAAC,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACnE,eAAe,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7C,eAAe,CAAC,EAAE,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9C;AAED,MAAM,WAAW,4BAA4B;IAC3C,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,KAAK,EAAE,OAAO,KAAK,CAAC;IACpB,IAAI,EAAE,OAAO,IAAI,CAAC;IAClB,OAAO,EAAE,OAAO,OAAO,CAAC;IACxB,QAAQ,EAAE,OAAO,QAAQ,CAAC;IAC1B,MAAM,EAAE,OAAO,MAAM,CAAC;IACtB,MAAM,EAAE,OAAO,MAAM,CAAC;IACtB,aAAa,EAAE,CAAC,aAAa,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACzD;AAED,MAAM,WAAW,uBAAuB;IACtC,YAAY,CAAC,EAAE,OAAO,CAAC,4BAA4B,CAAC,CAAC;IACrD,KAAK,CAAC,EAAE,qBAAqB,CAAC;IAC9B,UAAU,CAAC,EAAE,MAAM,MAAM,CAAC;CAC3B;AAED,qBAAa,gBAAgB;IAQf,QAAQ,CAAC,eAAe,EAAE,MAAM;IAP5C,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,4BAA4B,CAAC;IAC5C,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAe;IACxC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAwB;gBAEzB,eAAe,EAAE,MAAM,EAAE,OAAO,GAAE,uBAA4B;IAmB7E,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;IAiCvC,oBAAoB,IAAI,OAAO,CAAC,IAAI,CAAC;IAkCrC,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAsC7B,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;IAa7B,aAAa,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC;YAsBpC,eAAe;IAavB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IA6E3C,YAAY,IAAI,OAAO,CAAC,IAAI,CAAC;CAqBpC"}

package/dist/pi/wakeAcceptanceFs.js

@@ -0,0 +1,318 @@
+import { randomUUID } from "node:crypto";
+import { lstat, mkdir, open, readdir, readFile, rename, unlink } from "node:fs/promises";
+import { open as openDirectory } from "node:fs/promises";
+import path from "node:path";
+import { WAKE_ACCEPTANCE_FILE, WAKE_ACCEPTANCE_FILE_BYTES_MAX } from "./wakeAcceptanceSchema.js";
+import { WakeAcceptanceError } from "./wakeAcceptanceSchema.js";
+const UTF8 = "utf8";
+const isNoEnt = (value) => Boolean(value && typeof value === "object" && "code" in value && value.code === "ENOENT");
+const isEEXIST = (value) => Boolean(value && typeof value === "object" && "code" in value && value.code === "EEXIST");
+const isExactMode = (mode, expected) => (mode & 0o777) === expected;
+const hasGroupOrWorldWrite = (mode) => (mode & 0o022) !== 0;
+const isSymbolic = (stats) => stats.isSymbolicLink();
+const safeDirectory = (stats) => {
+    if (!stats.isDirectory() || isSymbolic(stats) || hasGroupOrWorldWrite(stats.mode)) {
+        throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+    }
+};
+const exactDirectory = (stats) => {
+    if (!stats.isDirectory() || isSymbolic(stats) || !isExactMode(stats.mode, 0o700)) {
+        throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+    }
+};
+const exactFile = (stats) => {
+    if (!stats.isFile() || isSymbolic(stats) || !isExactMode(stats.mode, 0o600)) {
+        throw new WakeAcceptanceError("wake_acceptance_store_corrupt");
+    }
+};
+const syncDirectory = async (directoryPath) => {
+    const handle = await openDirectory(directoryPath, "r");
+    try {
+        await handle.sync();
+    }
+    finally {
+        await handle.close();
+    }
+};
+const markSafeToRelease = (error, safeToRelease) => {
+    error.safeToRelease = safeToRelease;
+    return error;
+};
+const noEntAsSafe = (error) => markSafeToRelease(error, true);
+const convertErr = (safeToRelease = true) => markSafeToRelease(new WakeAcceptanceError("wake_acceptance_store_corrupt"), safeToRelease);
+const runHook = async (hook, safeToRelease, ...args) => {
+    if (hook === undefined)
+        return;
+    try {
+        await hook(...args);
+    }
+    catch {
+        throw convertErr(safeToRelease);
+    }
+};
+const stateTempPrefix = `${WAKE_ACCEPTANCE_FILE}.`;
+const stateTempSuffix = ".tmp";
+const isStateTempNamespace = (name) => name.startsWith(stateTempPrefix) && name.endsWith(stateTempSuffix);
+const isOwnedStateTemp = (name) => isStateTempNamespace(name) && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u.test(name.slice(stateTempPrefix.length, -stateTempSuffix.length));
+export class WakeAcceptanceFs {
+    runtimeHomePath;
+    stateDirectoryPath;
+    stateFilePath;
+    lockPath;
+    deps;
+    randomId;
+    hooks;
+    constructor(runtimeHomePath, options = {}) {
+        this.runtimeHomePath = runtimeHomePath;
+        this.stateDirectoryPath = path.join(runtimeHomePath, ".wake-acceptance");
+        this.stateFilePath = path.join(this.stateDirectoryPath, WAKE_ACCEPTANCE_FILE);
+        this.lockPath = path.join(this.stateDirectoryPath, "claim.lock");
+        this.randomId = options.randomUUID ?? randomUUID;
+        this.hooks = options.hooks ?? {};
+        this.deps = {
+            lstat,
+            mkdir,
+            open,
+            readdir,
+            readFile,
+            rename,
+            unlink,
+            syncDirectory,
+            ...options.dependencies
+        };
+    }
+    async assertRuntimeDirectory() {
+        try {
+            const stat = await this.deps.lstat(this.runtimeHomePath);
+            safeDirectory(stat);
+            return;
+        }
+        catch (error) {
+            if (!isNoEnt(error)) {
+                throw convertErr();
+            }
+        }
+        try {
+            await this.deps.mkdir(this.runtimeHomePath, { mode: 0o700 });
+            const stat = await this.deps.lstat(this.runtimeHomePath);
+            safeDirectory(stat);
+            return;
+        }
+        catch (error) {
+            if (isEEXIST(error)) {
+                try {
+                    const stat = await this.deps.lstat(this.runtimeHomePath);
+                    safeDirectory(stat);
+                    return;
+                }
+                catch (statsError) {
+                    if (statsError instanceof WakeAcceptanceError) {
+                        throw statsError;
+                    }
+                    throw convertErr();
+                }
+            }
+            throw convertErr();
+        }
+    }
+    async assertStoreDirectory() {
+        await this.assertRuntimeDirectory();
+        try {
+            const stats = await this.deps.lstat(this.stateDirectoryPath);
+            exactDirectory(stats);
+            return;
+        }
+        catch (error) {
+            if (!isNoEnt(error)) {
+                throw convertErr();
+            }
+        }
+        try {
+            await this.deps.mkdir(this.stateDirectoryPath, { mode: 0o700 });
+            const stat = await this.deps.lstat(this.stateDirectoryPath);
+            exactDirectory(stat);
+        }
+        catch (error) {
+            if (isEEXIST(error)) {
+                try {
+                    const stat = await this.deps.lstat(this.stateDirectoryPath);
+                    exactDirectory(stat);
+                    return;
+                }
+                catch (statsError) {
+                    if (statsError instanceof WakeAcceptanceError) {
+                        throw statsError;
+                    }
+                    throw convertErr();
+                }
+            }
+            throw convertErr();
+        }
+    }
+    async acquireClaim() {
+        await this.assertStoreDirectory();
+        await runHook(this.hooks.preClaimAcquire, true);
+        let acquiredHandle = false;
+        let handle;
+        try {
+            handle = await this.deps.open(this.lockPath, "wx", 0o600);
+            acquiredHandle = true;
+            await handle.chmod(0o600);
+            await handle.sync();
+            await handle.close();
+            handle = undefined;
+            await this.deps.syncDirectory(this.stateDirectoryPath);
+            return;
+        }
+        catch (error) {
+            if (handle !== undefined) {
+                await handle.close().catch(() => undefined);
+                handle = undefined;
+            }
+            if (isEEXIST(error) && !acquiredHandle) {
+                try {
+                    const lockStat = await this.deps.lstat(this.lockPath);
+                    exactFile(lockStat);
+                    throw markSafeToRelease(new WakeAcceptanceError("wake_delivery_incomplete"), false);
+                }
+                catch (statsError) {
+                    if (statsError instanceof WakeAcceptanceError) {
+                        throw statsError;
+                    }
+                    throw convertErr();
+                }
+            }
+            throw convertErr(false);
+        }
+    }
+    async releaseClaim() {
+        try {
+            await runHook(this.hooks.preClaimRelease, false);
+            await this.deps.unlink(this.lockPath);
+            await this.deps.syncDirectory(this.stateDirectoryPath);
+        }
+        catch (error) {
+            if (error instanceof WakeAcceptanceError) {
+                throw error;
+            }
+            throw convertErr(false);
+        }
+    }
+    async readStateText() {
+        await this.assertStoreDirectory();
+        try {
+            const stats = await this.deps.lstat(this.stateFilePath);
+            exactFile(stats);
+            const body = await this.deps.readFile(this.stateFilePath, UTF8);
+            if (Buffer.byteLength(body, UTF8) > WAKE_ACCEPTANCE_FILE_BYTES_MAX) {
+                throw convertErr();
+            }
+            return body;
+        }
+        catch (error) {
+            if (isNoEnt(error)) {
+                return undefined;
+            }
+            if (error instanceof WakeAcceptanceError) {
+                throw error;
+            }
+            throw convertErr();
+        }
+    }
+    async removeOwnedTemp(pathName) {
+        try {
+            const stats = await this.deps.lstat(pathName);
+            exactFile(stats);
+            await this.deps.unlink(pathName);
+        }
+        catch (error) {
+            if (isNoEnt(error)) {
+                return;
+            }
+            throw convertErr(false);
+        }
+    }
+    async writeStateText(body) {
+        if (Buffer.byteLength(body, UTF8) > WAKE_ACCEPTANCE_FILE_BYTES_MAX) {
+            throw convertErr(true);
+        }
+        await this.assertStoreDirectory();
+        const tempPath = `${this.stateFilePath}.${this.randomId()}.tmp`;
+        let handle;
+        let renamed = false;
+        let tempCreated = false;
+        try {
+            handle = await this.deps.open(tempPath, "wx", 0o600);
+            tempCreated = true;
+            await handle.chmod(0o600);
+            await runHook(this.hooks.preWrite, true, tempPath);
+            await handle.writeFile(body, UTF8);
+            await handle.sync();
+            await runHook(this.hooks.preSync, true, tempPath);
+            await runHook(this.hooks.preClose, true, tempPath);
+            await handle.close();
+            handle = undefined;
+            await runHook(this.hooks.preRename, true, tempPath, this.stateFilePath);
+            try {
+                const finalStat = await this.deps.lstat(this.stateFilePath);
+                exactFile(finalStat);
+            }
+            catch (error) {
+                if (!isNoEnt(error)) {
+                    throw convertErr(true);
+                }
+            }
+            await this.deps.rename(tempPath, this.stateFilePath);
+            renamed = true;
+            await runHook(this.hooks.preDirectorySync, true, this.stateDirectoryPath);
+            await this.deps.syncDirectory(this.stateDirectoryPath);
+            const finalStateStat = await this.deps.lstat(this.stateFilePath);
+            exactFile(finalStateStat);
+            return;
+        }
+        catch (error) {
+            if (handle !== undefined) {
+                await handle.close().catch(() => undefined);
+            }
+            let safeToRelease = true;
+            if (!renamed && tempCreated) {
+                try {
+                    await this.removeOwnedTemp(tempPath);
+                }
+                catch (cleanupError) {
+                    safeToRelease = false;
+                    if (cleanupError instanceof WakeAcceptanceError) {
+                        throw markSafeToRelease(cleanupError, false);
+                    }
+                    throw convertErr(false);
+                }
+            }
+            safeToRelease = safeToRelease && !renamed;
+            if (error instanceof WakeAcceptanceError) {
+                throw markSafeToRelease(error, safeToRelease);
+            }
+            throw convertErr(safeToRelease);
+        }
+    }
+    async cleanupTemps() {
+        await this.assertStoreDirectory();
+        let entries = [];
+        try {
+            entries = await this.deps.readdir(this.stateDirectoryPath, { withFileTypes: true });
+        }
+        catch (error) {
+            if (isNoEnt(error)) {
+                return;
+            }
+            throw convertErr();
+        }
+        for (const entry of entries) {
+            if (!isStateTempNamespace(entry.name)) {
+                continue;
+            }
+            if (!isOwnedStateTemp(entry.name))
+                throw convertErr(false);
+            await this.removeOwnedTemp(path.join(this.stateDirectoryPath, entry.name));
+        }
+    }
+}