allaboard 0.0.0-stage → 0.5.0

package/dist/core/state.js

@@ -0,0 +1,724 @@
+/**
+ * The daemon's only written file: per channel, its bound directory and any pending migration
+ * notice; per thread within it, the folder it was opened in, its session id, bypass switch and
+ * effort level; at its top, the version of the update the owner was last told of and the message
+ * a restart asked from the chat leaves to rewrite. A file names the agent and the chat it was
+ * written for (version 3), since a session id and a thread's name mean nothing to others.
+ */
+import { randomBytes } from "node:crypto";
+import fs from "node:fs";
+import { dirname, join } from "node:path";
+import { getLogger } from "../log.js";
+import { errorName } from "../values.js";
+export const logger = getLogger("allaboard.core.state");
+// A thread with no session id that was opened longer ago than this never finished its first
+// turn: `prune` drops it. When it was opened is the chat's to say (`ChatProvider.openedAt`).
+export const ONE_DAY = 24 * 60 * 60;
+const REQUEST_KINDS = new Set([
+    "question",
+    "approval",
+    "setup",
+    "hold",
+]);
+/** A `ThreadState` with every field but the folder defaulted to "nothing set". */
+export function threadState(directory, fields = {}) {
+    return {
+        directory,
+        sessionId: null,
+        bypass: null,
+        effort: null,
+        openReplies: [],
+        requests: [],
+        requestKinds: {},
+        status: null,
+        ended: null,
+        ...fields,
+    };
+}
+/** A `ChannelRecord` with no pending notice and no threads unless given. */
+export function channelRecord(directory, fields = {}) {
+    return { directory, noticePending: false, threads: new Map(), ...fields };
+}
+/** state.json exists but cannot be read; the daemon refuses to guess. */
+export class StateError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "StateError";
+    }
+}
+/** `openThread` was given a channel that has never been bound. */
+export class UnknownChannel extends Error {
+    constructor(channelId) {
+        super(`unknown channel: ${channelId}`);
+        this.name = "UnknownChannel";
+    }
+}
+/** A part of the file has the wrong shape; the message becomes the detail of a `StateError`. */
+class Malformed extends Error {
+    name = "Malformed";
+}
+function isRaw(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** `value` as an object, or `Malformed` naming `what`. */
+function asRaw(value, what) {
+    if (!isRaw(value))
+        throw new Malformed(`${what} must be an object`);
+    return value;
+}
+/** The key's value; a missing key is `Malformed`, named by the key in quotes. */
+function required(raw, key) {
+    if (!Object.hasOwn(raw, key))
+        throw new Malformed(`'${key}'`);
+    return raw[key];
+}
+function requiredString(raw, key) {
+    const value = required(raw, key);
+    if (typeof value !== "string")
+        throw new Malformed(`'${key}' must be a string`);
+    return value;
+}
+function stringOrNull(value) {
+    return typeof value === "string" ? value : null;
+}
+/** The restart notice a file holds; one that is not whole is read as none, as `update_notice` is. */
+function parseRestartNotice(value) {
+    if (!isRaw(value))
+        return null;
+    const { channel, message, version } = value;
+    if (typeof channel !== "string" || typeof message !== "string")
+        return null;
+    if (version !== null && typeof version !== "string")
+        return null;
+    return { channel, message, version };
+}
+// Files written before the words were stored hold the name of the reaction that showed each
+// status. They are read as the word they stand for; no file is rewritten for it.
+const LEGACY_STATUS = new Map([
+    ["hourglass_flowing_sand", "working"],
+    ["raised_hand", "waiting"],
+    ["white_check_mark", "done"],
+    ["x", "error"],
+]);
+const STATUS_WORDS = new Set([
+    "working",
+    "waiting",
+    "done",
+    "error",
+]);
+/** A stored status as a word: a word as it is, a reaction name of an older file as its word. */
+function statusOrNull(value) {
+    if (typeof value !== "string")
+        return null;
+    if (STATUS_WORDS.has(value))
+        return value;
+    return LEGACY_STATUS.get(value) ?? null;
+}
+function stringList(value) {
+    return Array.isArray(value)
+        ? value.filter((item) => typeof item === "string")
+        : [];
+}
+/** The kinds stored beside `requests`: only a known word for an id that is in the list. */
+function requestKinds(value, requests) {
+    const kinds = {};
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return kinds;
+    for (const id of requests) {
+        const kind = Object.hasOwn(value, id) ? value[id] : undefined;
+        if (REQUEST_KINDS.has(kind))
+            kinds[id] = kind;
+    }
+    return kinds;
+}
+function parseBypass(raw) {
+    if (raw.bypass === true)
+        return true;
+    return raw.bypass_off === true ? false : null;
+}
+/** `bypass` as it always was (`true` on, `false` not on), plus `bypass_off: true` for an
+ * explicit off only: never both set. */
+function dumpBypass(bypass) {
+    if (bypass)
+        return { bypass: true };
+    return bypass === false ? { bypass: false, bypass_off: true } : { bypass: false };
+}
+/**
+ * Tolerant of a v2 file written before the repair fields existed (they default to "nothing
+ * open"), and a v2 file written with them read by code that does not know them yet ignores the
+ * extra keys: both directions of the additive version stay 2 (`bypass_off` is one such key:
+ * a file without it reads its `bypass: false` as never chosen; `ended` is another). A file
+ * written by 1304c5e's single `open_reply` field (never shipped) is read the same as one with
+ * none at all: that key is not looked at.
+ */
+export function parseThread(raw) {
+    const requests = stringList(raw.requests);
+    return {
+        directory: requiredString(raw, "directory"),
+        sessionId: stringOrNull(raw.session_id),
+        bypass: parseBypass(raw),
+        effort: stringOrNull(raw.effort),
+        openReplies: stringList(raw.open_replies),
+        requests,
+        requestKinds: requestKinds(raw.request_kinds, requests),
+        status: statusOrNull(raw.status),
+        ended: statusOrNull(raw.ended),
+    };
+}
+function parseChannels(raw) {
+    const channels = new Map();
+    for (const [channelId, rawEntry] of Object.entries(asRaw(required(raw, "channels"), "'channels'"))) {
+        const entry = asRaw(rawEntry, `channel ${channelId}`);
+        const threads = new Map();
+        const rawThreads = Object.hasOwn(entry, "threads") ? entry.threads : {};
+        for (const [threadId, rawThread] of Object.entries(asRaw(rawThreads, `'threads' of ${channelId}`))) {
+            threads.set(threadId, parseThread(asRaw(rawThread, `thread ${threadId}`)));
+        }
+        channels.set(channelId, {
+            directory: requiredString(entry, "directory"),
+            noticePending: entry.notice_pending === true,
+            threads,
+        });
+    }
+    return channels;
+}
+/**
+ * What the session index (the Home tab) shows of `threads`: a write that leaves this
+ * unchanged is not announced to `StateStore.onSessionsChange`.
+ */
+function shown(threads) {
+    return new Map([...threads].map(([ts, t]) => [ts, JSON.stringify([t.sessionId, t.status, t.ended])]));
+}
+/**
+ * Each channel keeps its directory, gets empty threads and a pending notice; the old session id
+ * and bypass switch belonged to the channel, not to a thread, and are dropped.
+ */
+function migrateV1(raw) {
+    const channels = new Map();
+    for (const [channelId, rawEntry] of Object.entries(asRaw(required(raw, "channels"), "'channels'"))) {
+        const entry = asRaw(rawEntry, `channel ${channelId}`);
+        channels.set(channelId, channelRecord(requiredString(entry, "directory"), { noticePending: true }));
+    }
+    return channels;
+}
+/** The text Python's `json.dump(data, f, indent=2)` writes: ASCII only, no trailing newline. */
+function dumpJson(data) {
+    // `JSON.stringify` differs from `ensure_ascii=True` only in leaving DEL and everything from
+    // U+0080 up as they are; a UTF-16 code unit escaped on its own gives the same `🚀`
+    // pair for an astral character that Python writes.
+    return JSON.stringify(data, null, 2).replace(/[\u007f-￿]/g, (unit) => `\\u${unit.charCodeAt(0).toString(16).padStart(4, "0")}`);
+}
+function threadKey(channelId, threadId) {
+    return `${channelId}\0${threadId}`;
+}
+/** In-memory copy of state.json, written atomically on every change. */
+export class StateStore {
+    path;
+    warn;
+    sync;
+    channelsById;
+    modules;
+    // Called after a write that changed which channels are bound, which threads exist, the
+    // session one holds, or a root's reaction: what the session index is built from. It is
+    // given the (channelId, threadId) of each thread the write touched. Never while loading.
+    onSessionsChange = null;
+    // The version of the update the owner was last told of (issue #361): a top-level key beside
+    // `channels`, absent until one was told. Additive like `bypass_off`, so the file stays at its
+    // version and code that does not know the key ignores it.
+    told = null;
+    // The message the next start rewrites (issue #361), a second top-level key of the same kind:
+    // absent unless the daemon asked its own stop from the chat.
+    restarted = null;
+    constructor(path, options = {}) {
+        this.path = path;
+        this.warn = options.warn ?? ((message) => logger.warning(message));
+        this.modules = options.modules ?? null;
+        this.sync = options.sync ?? fs.fsyncSync;
+        this.channelsById = this.load();
+    }
+    /** The version of the update the owner was last told of; null when none was. */
+    get updateNotice() {
+        return this.told;
+    }
+    /** Remembers that the owner was told of `version`; no session changes, so the index is not told. */
+    setUpdateNotice(version) {
+        if (this.told === version)
+            return;
+        const before = this.told;
+        this.told = version;
+        try {
+            this.save();
+        }
+        catch (error) {
+            this.told = before;
+            throw error;
+        }
+    }
+    /** The message to rewrite on the next start; null when the last stop was not asked from a chat. */
+    get restartNotice() {
+        return this.restarted;
+    }
+    /** Remembers the message the next start rewrites; throws when the file cannot be written. */
+    setRestartNotice(notice) {
+        this.changeRestartNotice(notice);
+    }
+    /**
+     * Forgets `notice`, and only while it is still the one kept: a restart asked since has recorded
+     * its own, which stays. Throws when the file cannot be written.
+     */
+    clearRestartNotice(notice) {
+        const kept = this.restarted;
+        if (kept === null || kept.channel !== notice.channel || kept.message !== notice.message)
+            return;
+        this.changeRestartNotice(null);
+    }
+    /** No session changes, so the index is not told. */
+    changeRestartNotice(notice) {
+        if (this.restarted === null && notice === null)
+            return;
+        const before = this.restarted;
+        this.restarted = notice;
+        try {
+            this.save();
+        }
+        catch (error) {
+            this.restarted = before;
+            throw error;
+        }
+    }
+    channel(channelId) {
+        return this.channelsById.get(channelId) ?? null;
+    }
+    /** The id of every bound channel, in the order they were bound. */
+    channels() {
+        return [...this.channelsById.keys()];
+    }
+    thread(channelId, threadId) {
+        return this.channelsById.get(channelId)?.threads.get(threadId) ?? null;
+    }
+    /** Every (channelId, threadId, thread), across all channels. */
+    threads() {
+        return [...this.channelsById].flatMap(([channelId, channel]) => [...channel.threads].map(([threadId, thread]) => [
+            channelId,
+            threadId,
+            thread,
+        ]));
+    }
+    /**
+     * Bind a channel to a directory; its threads and their own folders stay untouched (each
+     * thread keeps the folder it was created in), and so does its pending notice.
+     */
+    bind(channelId, directory) {
+        const current = this.channelsById.get(channelId);
+        this.channelsById.set(channelId, {
+            directory,
+            noticePending: current?.noticePending ?? false,
+            threads: current?.threads ?? new Map(),
+        });
+        this.save();
+        if (current === undefined)
+            this.announce(); // a new channel in the session index; a rebind changes no row
+    }
+    /** Forget a channel: its binding and every thread in it. A no-op for one that is not bound. */
+    removeChannel(channelId) {
+        const channel = this.channelsById.get(channelId);
+        if (channel === undefined)
+            return;
+        this.channelsById.delete(channelId);
+        this.save();
+        this.announce([...channel.threads.keys()].map((threadId) => ({ channel: channelId, thread: threadId })));
+    }
+    /**
+     * Create a thread's entry with the channel's current folder, or return the existing one
+     * unchanged. Throws `UnknownChannel` for a channel that has never been bound.
+     */
+    openThread(channelId, threadId, sessionId = null) {
+        const channel = this.channelsById.get(channelId);
+        if (channel === undefined)
+            throw new UnknownChannel(channelId);
+        const existing = channel.threads.get(threadId);
+        if (existing !== undefined)
+            return existing;
+        const created = threadState(channel.directory, { sessionId });
+        this.replaceThreads(channelId, new Map([...channel.threads, [threadId, created]]));
+        return created;
+    }
+    /** Record a thread's session id; a no-op for a thread that does not exist. */
+    setSession(channelId, threadId, sessionId) {
+        const current = this.thread(channelId, threadId);
+        if (current !== null && current.sessionId !== sessionId) {
+            this.setThread(channelId, threadId, { ...current, sessionId });
+        }
+    }
+    /**
+     * Record a thread's bypass choice (null: never chosen); a no-op for a thread that does not
+     * exist.
+     */
+    setBypass(channelId, threadId, on) {
+        const current = this.thread(channelId, threadId);
+        if (current !== null && current.bypass !== on) {
+            this.setThread(channelId, threadId, { ...current, bypass: on });
+        }
+    }
+    /** Record the effort level a command set for a thread; a no-op for an unknown thread. */
+    setEffort(channelId, threadId, effort) {
+        const current = this.thread(channelId, threadId);
+        if (current !== null && current.effort !== effort) {
+            this.setThread(channelId, threadId, { ...current, effort });
+        }
+    }
+    /**
+     * One `ReplySink`'s own entry in the open-replies list (crash repair): drop `oldTs` (if it
+     * was there), add `newTs` (if not already there), in one write. A no-op for a thread that
+     * does not exist, and for a call that changes nothing (both ends of a fresh sink's first
+     * message, `oldTs=null, newTs=null`, would otherwise still write).
+     */
+    replaceOpenReply(channelId, threadId, oldTs, newTs) {
+        const current = this.thread(channelId, threadId);
+        if (current === null)
+            return;
+        let replies = current.openReplies;
+        if (oldTs !== null && replies.includes(oldTs))
+            replies = replies.filter((t) => t !== oldTs);
+        if (newTs !== null && !replies.includes(newTs))
+            replies = [...replies, newTs];
+        if (replies.length !== current.openReplies.length ||
+            replies.some((t, i) => t !== current.openReplies[i])) {
+            this.setThread(channelId, threadId, { ...current, openReplies: replies });
+        }
+    }
+    /**
+     * Record a request message still carrying buttons, with its kind (crash repair); a no-op for a
+     * thread that does not exist or already has it.
+     */
+    addRequest(channelId, threadId, messageTs, kind) {
+        const current = this.thread(channelId, threadId);
+        if (current !== null && !current.requests.includes(messageTs)) {
+            this.setThread(channelId, threadId, {
+                ...current,
+                requests: [...current.requests, messageTs],
+                requestKinds: { ...current.requestKinds, [messageTs]: kind },
+            });
+        }
+    }
+    /**
+     * Drop a decided or removed request from the list (crash repair); a no-op if it is not there,
+     * including for a thread that does not exist.
+     */
+    removeRequest(channelId, threadId, messageTs) {
+        const current = this.thread(channelId, threadId);
+        if (current?.requests.includes(messageTs)) {
+            const remaining = current.requests.filter((t) => t !== messageTs);
+            const { [messageTs]: _gone, ...kinds } = current.requestKinds;
+            this.setThread(channelId, threadId, {
+                ...current,
+                requests: remaining,
+                requestKinds: kinds,
+            });
+        }
+    }
+    /**
+     * Record the root's status while it is working or waiting (`status`), or clear it once done or
+     * error is requested (crash repair) and keep that one as `ended`; both null for a root left
+     * bare, both set for an error shown while repair still owes the thread. A no-op for a thread
+     * that does not exist.
+     */
+    setStatusPending(channelId, threadId, status, ended = null) {
+        const current = this.thread(channelId, threadId);
+        if (current !== null && (current.status !== status || current.ended !== ended)) {
+            this.setThread(channelId, threadId, { ...current, status, ended });
+        }
+    }
+    /**
+     * Every (channelId, threadId, thread) whose crash-repair fields are not all empty: what a
+     * crashed daemon left open for startup repair to find.
+     */
+    repairsPending() {
+        return this.threads().filter(([, , thread]) => thread.openReplies.length > 0 || thread.requests.length > 0 || thread.status !== null);
+    }
+    /**
+     * Clear a thread's crash-repair fields together, once it has been repaired (or repair failed
+     * for good and was logged); a no-op if already clear or the thread is gone. With `keepOpen`
+     * the open replies and the root's status stay: an answer never reached Slack, and the next
+     * start's repair still has to close it and say so.
+     */
+    clearRepair(channelId, threadId, { keepOpen = false } = {}) {
+        const current = this.thread(channelId, threadId);
+        if (current === null)
+            return;
+        const replies = keepOpen ? current.openReplies : [];
+        const status = keepOpen ? current.status : null;
+        if (current.requests.length === 0 &&
+            replies.length === current.openReplies.length &&
+            current.status === status) {
+            return;
+        }
+        this.setThread(channelId, threadId, {
+            ...current,
+            openReplies: replies,
+            requests: [],
+            requestKinds: {},
+            status,
+        });
+    }
+    /** Drop a thread's entry; a no-op if it is not there. */
+    removeThread(channelId, threadId) {
+        const channel = this.channelsById.get(channelId);
+        if (channel === undefined || !channel.threads.has(threadId))
+            return;
+        const remaining = new Map(channel.threads);
+        remaining.delete(threadId);
+        this.replaceThreads(channelId, remaining);
+    }
+    /** The (channelId, threadId) whose thread holds this session id, across all channels. */
+    holder(sessionId) {
+        for (const [channelId, channel] of this.channelsById) {
+            for (const [threadId, thread] of channel.threads) {
+                if (thread.sessionId === sessionId)
+                    return { channel: channelId, thread: threadId };
+            }
+        }
+        return null;
+    }
+    /** Channel ids whose v1-to-v2 migration notice has not been posted yet. */
+    pendingNotices() {
+        return [...this.channelsById].filter(([, c]) => c.noticePending).map(([id]) => id);
+    }
+    /** Mark a channel's migration notice as posted; a no-op if already clear or unbound. */
+    clearNotice(channelId) {
+        const channel = this.channelsById.get(channelId);
+        if (channel === undefined || !channel.noticePending)
+            return;
+        this.channelsById.set(channelId, { ...channel, noticePending: false });
+        this.save();
+    }
+    /**
+     * Remove a thread whose session id is gone from its folder's sessions, and a no-session
+     * thread that `openedAt` says was opened more than `ONE_DAY` before `now` (one it cannot date
+     * is kept). Calls `alive` once per distinct folder;
+     * null means it cannot tell, and that folder's threads are kept. `keep` names the
+     * (channelId, threadId) to leave alone whatever they look like: the threads with a live
+     * session, whose id may not be on disk yet. If `alive` throws, nothing is removed or written;
+     * the caller decides what to do next. Returns how many entries were removed.
+     */
+    prune(alive, openedAt, now, keep = []) {
+        const kept = new Set([...keep].map((ref) => threadKey(ref.channel, ref.thread)));
+        const aliveCache = new Map();
+        const updated = new Map();
+        let removed = 0;
+        for (const [channelId, channel] of this.channelsById) {
+            const survivors = new Map();
+            for (const [threadId, thread] of channel.threads) {
+                if (kept.has(threadKey(channelId, threadId))) {
+                    survivors.set(threadId, thread);
+                    continue;
+                }
+                if (thread.sessionId !== null) {
+                    if (!aliveCache.has(thread.directory)) {
+                        const sessions = alive(thread.directory);
+                        aliveCache.set(thread.directory, sessions === null ? null : new Set(sessions));
+                    }
+                    const sessions = aliveCache.get(thread.directory);
+                    if (sessions && !sessions.has(thread.sessionId)) {
+                        removed += 1;
+                        continue;
+                    }
+                }
+                else {
+                    const opened = openedAt({ channel: channelId, thread: threadId });
+                    if (opened !== null && now - opened > ONE_DAY) {
+                        removed += 1;
+                        continue;
+                    }
+                }
+                survivors.set(threadId, thread);
+            }
+            updated.set(channelId, survivors.size === channel.threads.size ? channel : { ...channel, threads: survivors });
+        }
+        if (removed > 0) {
+            const gone = [];
+            for (const [channelId, channel] of this.channelsById) {
+                const after = updated.get(channelId)?.threads;
+                for (const threadId of channel.threads.keys()) {
+                    if (!after?.has(threadId))
+                        gone.push({ channel: channelId, thread: threadId });
+                }
+            }
+            this.channelsById = updated;
+            this.save();
+            this.announce(gone);
+        }
+        return removed;
+    }
+    setThread(channelId, threadId, updated) {
+        const channel = this.channelsById.get(channelId);
+        this.replaceThreads(channelId, new Map([...channel.threads, [threadId, updated]]));
+    }
+    replaceThreads(channelId, threads) {
+        const channel = this.channelsById.get(channelId);
+        this.channelsById.set(channelId, { ...channel, threads });
+        this.save();
+        const before = shown(channel.threads);
+        const after = shown(threads);
+        const changed = [];
+        for (const threadId of new Set([...before.keys(), ...after.keys()])) {
+            if (before.get(threadId) !== after.get(threadId))
+                changed.push({ channel: channelId, thread: threadId });
+        }
+        if (changed.length > 0)
+            this.announce(changed);
+    }
+    /** The write is already on disk: an observer that fails must not fail its caller. */
+    announce(changed = []) {
+        if (this.onSessionsChange === null)
+            return;
+        try {
+            this.onSessionsChange(changed);
+        }
+        catch (error) {
+            this.warn(`the session index was not told of a change: ${errorName(error)}`);
+        }
+    }
+    load() {
+        let bytes;
+        try {
+            bytes = fs.readFileSync(this.path);
+        }
+        catch (error) {
+            if (error instanceof Error && "code" in error && error.code === "ENOENT")
+                return new Map();
+            throw error;
+        }
+        let channels;
+        let migrated = false;
+        try {
+            // Bytes that are not UTF-8 stop the read and a BOM is kept, which the JSON parser then
+            // refuses; `TextDecoder` does both with these two options.
+            const text = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+            const raw = asRaw(JSON.parse(text), "the file");
+            const version = required(raw, "version");
+            if (version === 2 || version === 3) {
+                if (version === 3)
+                    this.checkModules(requiredString(raw, "agent"), requiredString(raw, "chat"));
+                channels = parseChannels(raw);
+                this.told = stringOrNull(raw.update_notice);
+                this.restarted = parseRestartNotice(raw.restart_notice);
+            }
+            else if (version === 1) {
+                channels = migrateV1(raw);
+                migrated = true;
+            }
+            else {
+                throw new StateError(`${this.path} has an unknown version; fix or delete it`);
+            }
+        }
+        catch (error) {
+            const unreadable = error instanceof SyntaxError ||
+                error instanceof Malformed ||
+                (error instanceof TypeError &&
+                    "code" in error &&
+                    error.code === "ERR_ENCODING_INVALID_ENCODED_DATA");
+            if (!unreadable)
+                throw error;
+            throw new StateError(`${this.path} cannot be read (${error.message}); fix or delete it`, {
+                cause: error,
+            });
+        }
+        if (migrated)
+            this.write(channels);
+        return channels;
+    }
+    /**
+     * A version 3 file names the agent and the chat that wrote it: those now running must be the
+     * same. A store given no names takes the file's, so that it writes them back unchanged.
+     */
+    checkModules(agent, chat) {
+        if (this.modules === null) {
+            this.modules = { agent, chat };
+        }
+        else if (this.modules.agent !== agent || this.modules.chat !== chat) {
+            throw new StateError(`${this.path} belongs to other modules: it was written for the agent "${agent}" and the ` +
+                `chat "${chat}", and this start selects the agent "${this.modules.agent}" and the chat ` +
+                `"${this.modules.chat}"; select the modules it was written for, or delete the file`);
+        }
+    }
+    save() {
+        this.write(this.channelsById);
+    }
+    /**
+     * Written synchronously, so two changes never interleave: the next line of the caller runs
+     * with the file already renamed into place.
+     */
+    write(channels) {
+        const data = {
+            ...(this.modules === null
+                ? { version: 2 }
+                : { version: 3, agent: this.modules.agent, chat: this.modules.chat }),
+            ...(this.told === null ? {} : { update_notice: this.told }),
+            ...(this.restarted === null
+                ? {}
+                : {
+                    restart_notice: {
+                        channel: this.restarted.channel,
+                        message: this.restarted.message,
+                        version: this.restarted.version,
+                    },
+                }),
+            channels: Object.fromEntries([...channels].map(([channelId, c]) => [
+                channelId,
+                {
+                    directory: c.directory,
+                    notice_pending: c.noticePending,
+                    threads: Object.fromEntries([...c.threads].map(([threadId, t]) => [
+                        threadId,
+                        {
+                            directory: t.directory,
+                            session_id: t.sessionId,
+                            ...dumpBypass(t.bypass),
+                            effort: t.effort,
+                            open_replies: [...t.openReplies],
+                            requests: [...t.requests],
+                            request_kinds: { ...t.requestKinds },
+                            status: t.status,
+                            ended: t.ended,
+                        },
+                    ])),
+                },
+            ])),
+        };
+        // Write beside the target and rename: a crash leaves the old file or the new one.
+        const tmp = join(dirname(this.path), `.state-${randomBytes(4).toString("hex")}.tmp`);
+        const fd = fs.openSync(tmp, "wx", 0o600);
+        try {
+            try {
+                fs.writeFileSync(fd, dumpJson(data));
+                this.sync(fd);
+            }
+            finally {
+                fs.closeSync(fd);
+            }
+            fs.renameSync(tmp, this.path);
+        }
+        catch (error) {
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch (unlinkError) {
+                if (!(unlinkError instanceof Error && "code" in unlinkError && unlinkError.code === "ENOENT")) {
+                    throw unlinkError;
+                }
+            }
+            throw error;
+        }
+        // The rename is a directory entry: only a sync of the directory makes it survive a power cut.
+        if (process.platform !== "win32") {
+            const dirFd = fs.openSync(dirname(this.path), "r");
+            try {
+                this.sync(dirFd);
+            }
+            finally {
+                fs.closeSync(dirFd);
+            }
+        }
+    }
+}