@openclaw/crabline 0.1.11 → 0.1.13

package/dist/src/servers/matrix.js

@@ -1,96 +1,25 @@
 import { createHash, randomBytes } from "node:crypto";
-import { isIP } from "node:net";
 import path from "node:path";
-import { adminAuthError, hasAdminToken, InvalidJsonBodyError, isJsonObject, jsonResponse, parseUnknownRequestBody, queryRecord, readInteger, readTrimmedString, RequestBodyTooLargeError, startHttpJsonServer, } from "./http.js";
+import { isHistoricalMatrixUserId, isMatrixEventId, isMatrixRoomId, isMatrixUserId, } from "../matrix-ids.js";
+import { adminAuthError, constantTimeTokenEqual, DEFAULT_MAX_RESPONSE_BODY_BYTES, hasAdminToken, InvalidJsonBodyError, isJsonObject, jsonResponse, parseUnknownRequestBody, queryRecord, readInteger, readTrimmedString, RequestBodyTooLargeError, startHttpJsonServer, } from "./http.js";
 import { recordCommittedServerEvent, recordServerEvent, } from "./recorder.js";
 const MAX_MATRIX_FILTER_BYTES = 1024 * 1024;
 const MAX_MATRIX_FILTERS = 100;
-const MAX_MATRIX_IDENTIFIER_BYTES = 255;
 const MAX_MATRIX_TIMELINE_EVENTS = 1_000;
 const MAX_MATRIX_TRANSACTION_RESPONSES = 1_000;
 const MATRIX_TRANSACTION_RETENTION_MS = 10 * 60_000;
 const MAX_NODE_TIMER_DELAY_MS = 2_147_483_647;
+const DEFAULT_MAX_MATRIX_COMMITTED_ROOMS = 1_000;
+const DEFAULT_MAX_MATRIX_COMMITTED_USERS = 1_000;
+const DEFAULT_MAX_MATRIX_SYNC_RESPONSE_BYTES = 4 * 1024 * 1024;
 class InvalidMatrixPathEncodingError extends Error {
     constructor() {
         super("Matrix request path contains invalid percent encoding.");
         this.name = "InvalidMatrixPathEncodingError";
     }
 }
-function matrixId(prefix, value, serverName) {
-    return `${prefix}${createHash("sha256").update(value).digest("hex").slice(0, 16)}:${serverName}`;
-}
-function isMatrixIpv4Address(value) {
-    const octets = value.split(".");
-    return (octets.length === 4 && octets.every((octet) => /^\d{1,3}$/u.test(octet) && Number(octet) <= 255));
-}
-function isMatrixServerName(value) {
-    const ipv6 = /^\[([^\]]+)\](?::(\d{1,5}))?$/u.exec(value);
-    if (ipv6) {
-        return isIP(ipv6[1]) === 6;
-    }
-    const hostAndPort = /^([^:]+?)(?::(\d{1,5}))?$/u.exec(value);
-    if (!hostAndPort) {
-        return false;
-    }
-    const hostname = hostAndPort[1];
-    if (isMatrixIpv4Address(hostname)) {
-        return true;
-    }
-    if (/^\d+\.\d+\.\d+\.\d+$/u.test(hostname)) {
-        return false;
-    }
-    return hostname.length <= 255 && /^[A-Za-z0-9.-]+$/u.test(hostname);
-}
-function hasLoneSurrogate(value) {
-    for (let index = 0; index < value.length; index += 1) {
-        const code = value.charCodeAt(index);
-        if (code >= 0xd800 && code <= 0xdbff) {
-            const next = value.charCodeAt(index + 1);
-            if (next < 0xdc00 || next > 0xdfff) {
-                return true;
-            }
-            index += 1;
-        }
-        else if (code >= 0xdc00 && code <= 0xdfff) {
-            return true;
-        }
-    }
-    return false;
-}
-function isMatrixScopedIdentifier(value, sigil) {
-    const separator = value.indexOf(":");
-    const localpart = value.slice(1, separator);
-    return (value.startsWith(sigil) &&
-        Buffer.byteLength(value, "utf8") <= MAX_MATRIX_IDENTIFIER_BYTES &&
-        separator >= (sigil === "@" ? 1 : 2) &&
-        !localpart.includes("\0") &&
-        !hasLoneSurrogate(localpart) &&
-        isMatrixServerName(value.slice(separator + 1)));
-}
-function isMatrixHashIdentifier(value, sigil, allowLegacyBase64) {
-    if (!value.startsWith(sigil) || Buffer.byteLength(value, "utf8") > MAX_MATRIX_IDENTIFIER_BYTES) {
-        return false;
-    }
-    const opaqueId = value.slice(1);
-    const encoding = allowLegacyBase64 && /^[A-Za-z0-9+/]{43}$/u.test(opaqueId)
-        ? "base64"
-        : /^[A-Za-z0-9_-]{43}$/u.test(opaqueId)
-            ? "base64url"
-            : undefined;
-    if (!encoding) {
-        return false;
-    }
-    const decoded = Buffer.from(opaqueId, encoding);
-    return decoded.length === 32 && decoded.toString(encoding).replace(/=+$/u, "") === opaqueId;
-}
-function isMatrixRoomId(value) {
-    return isMatrixScopedIdentifier(value, "!") || isMatrixHashIdentifier(value, "!", false);
-}
-function isMatrixEventId(value) {
-    return isMatrixScopedIdentifier(value, "$") || isMatrixHashIdentifier(value, "$", true);
-}
-function isMatrixUserId(value) {
-    return isMatrixScopedIdentifier(value, "@");
+function matrixRoomId(value, serverName) {
+    return `!${createHash("sha256").update(value).digest("hex").slice(0, 16)}:${serverName}`;
 }
 async function appendEvent(state, event, committed = false) {
     const params = { event, onEvent: state.onEvent, recorderPath: state.recorderPath };
@@ -98,7 +27,8 @@ async function appendEvent(state, event, committed = false) {
 }
 function authorized(request, token) {
     const match = /^Bearer\s+(\S+)$/iu.exec(request.headers.authorization ?? "");
-    return match?.[1] === token;
+    const providedToken = match?.[1];
+    return providedToken ? constantTimeTokenEqual(providedToken, token) : false;
 }
 function matrixError(errcode, error, status) {
     return jsonResponse({ errcode, error }, status);
@@ -110,6 +40,15 @@ function matrixResourceLimitError(error) {
         error,
     }, 503);
 }
+function resolvePositiveLimit(value, name, fallback) {
+    if (value === undefined) {
+        return fallback;
+    }
+    if (!Number.isSafeInteger(value) || value < 1) {
+        throw new Error(`${name} must be a positive safe integer.`);
+    }
+    return value;
+}
 function decodeMatrixPathSegment(value) {
     try {
         return decodeURIComponent(value);
@@ -119,7 +58,11 @@ function decodeMatrixPathSegment(value) {
     }
 }
 function eventId(state) {
-    return matrixId("$", `event-${state.nextEvent++}`, state.serverName);
+    return `$${createHash("sha256")
+        .update(state.serverName)
+        .update("\0")
+        .update(`event-${state.nextEvent++}`)
+        .digest("base64url")}`;
 }
 function notifySyncWaiters(state) {
     for (const resolve of state.syncWaiters) {
@@ -225,6 +168,46 @@ function publishTypingState(state, room) {
     });
     notifySyncWaiters(state);
 }
+function publishDirectRoom(state, userId, roomId) {
+    const roomIds = state.directRooms.get(userId) ?? new Set();
+    if (roomIds.has(roomId)) {
+        return;
+    }
+    roomIds.add(roomId);
+    state.directRooms.set(userId, roomIds);
+    state.directRoomsSequence = state.nextSequence++;
+}
+function serializeSyncAccountData(state, since, maxBytes) {
+    const sequence = state.directRoomsSequence;
+    if (sequence === undefined || (since !== undefined && sequence <= since)) {
+        return '{"events":[]}';
+    }
+    const prefix = '{"events":[{"content":{';
+    const suffix = '},"type":"m.direct"}]}';
+    const parts = [];
+    let bytes = Buffer.byteLength(prefix, "utf8") + Buffer.byteLength(suffix, "utf8");
+    for (const [userId, roomIds] of state.directRooms) {
+        const roomParts = [];
+        let roomBytes = 2;
+        for (const roomId of roomIds) {
+            const separator = roomParts.length === 0 ? "" : ",";
+            const roomPart = `${separator}${JSON.stringify(roomId)}`;
+            roomBytes += Buffer.byteLength(roomPart, "utf8");
+            if (bytes + roomBytes > maxBytes) {
+                return undefined;
+            }
+            roomParts.push(roomPart);
+        }
+        const separator = parts.length === 0 ? "" : ",";
+        const part = `${separator}${JSON.stringify(userId)}:[${roomParts.join("")}]`;
+        bytes += Buffer.byteLength(part, "utf8");
+        if (bytes > maxBytes) {
+            return undefined;
+        }
+        parts.push(part);
+    }
+    return `${prefix}${parts.join("")}${suffix}`;
+}
 function rememberTransaction(state, key, response) {
     state.transactions.set(key, response);
 }
@@ -250,9 +233,26 @@ function transactionResponse(state, key) {
 }
 function readTimelineLimit(filter) {
     const room = filter?.room;
-    const timeline = isJsonObject(room) ? room.timeline : undefined;
-    const limit = isJsonObject(timeline) ? readInteger(timeline.limit) : undefined;
-    return limit === undefined ? undefined : Math.max(0, limit);
+    if (room === undefined) {
+        return undefined;
+    }
+    if (!isJsonObject(room)) {
+        return matrixError("M_INVALID_PARAM", "Invalid room filter", 400);
+    }
+    const timeline = room.timeline;
+    if (timeline === undefined) {
+        return undefined;
+    }
+    if (!isJsonObject(timeline)) {
+        return matrixError("M_INVALID_PARAM", "Invalid timeline filter", 400);
+    }
+    if (!Object.hasOwn(timeline, "limit")) {
+        return undefined;
+    }
+    const limit = timeline.limit;
+    return typeof limit === "number" && Number.isSafeInteger(limit) && limit > 0
+        ? limit
+        : matrixError("M_INVALID_PARAM", "Invalid timeline limit", 400);
 }
 function resolveSyncFilter(url, state) {
     const value = url.searchParams.get("filter");
@@ -271,11 +271,7 @@ function resolveSyncFilter(url, state) {
         return matrixError("M_INVALID_PARAM", "Unknown filter", 400);
     }
 }
-function syncRoom(room, since, timelineLimit) {
-    const available = room.timeline.filter((entry) => since === undefined || entry.sequence > since);
-    const timeline = timelineLimit === undefined
-        ? available
-        : available.slice(Math.max(0, available.length - timelineLimit));
+function createSyncRoom(room, since, available, timeline) {
     const firstSequence = timeline[0]?.sequence;
     const historyWasTrimmed = room.lastDroppedTimelineSequence !== undefined &&
         (since === undefined || since < room.lastDroppedTimelineSequence);
@@ -310,6 +306,82 @@ function syncRoom(room, since, timelineLimit) {
         unread_notifications: { highlight_count: 0, notification_count: 0 },
     };
 }
+function jsonItemsByteLength(items, maxBytes) {
+    let bytes = 0;
+    for (const item of items) {
+        const serialized = JSON.stringify(item);
+        if (serialized === undefined) {
+            return undefined;
+        }
+        bytes += Buffer.byteLength(serialized, "utf8");
+        if (bytes > maxBytes) {
+            return undefined;
+        }
+    }
+    return bytes;
+}
+function boundedSyncRoom(room, since, timelineLimit, maxBytes, maxTimelineEvents = Number.POSITIVE_INFINITY) {
+    const available = room.timeline.filter((entry) => since === undefined || entry.sequence > since);
+    const requestedTimeline = timelineLimit === undefined
+        ? available
+        : available.slice(Math.max(0, available.length - timelineLimit));
+    const ephemeral = room.ephemeral
+        .filter((entry) => since === undefined || entry.sequence > since)
+        .map((entry) => entry.event);
+    const ephemeralBytes = jsonItemsByteLength(ephemeral, maxBytes);
+    if (ephemeralBytes === undefined) {
+        return undefined;
+    }
+    const timeline = [];
+    let timelineBytes = 0;
+    for (let index = requestedTimeline.length - 1; index >= 0; index -= 1) {
+        if (timeline.length >= maxTimelineEvents) {
+            break;
+        }
+        const entry = requestedTimeline[index];
+        const serializedEvent = JSON.stringify(entry.event);
+        if (serializedEvent === undefined) {
+            return undefined;
+        }
+        const eventBytes = Buffer.byteLength(serializedEvent, "utf8");
+        if (timelineBytes + ephemeralBytes + eventBytes > maxBytes) {
+            break;
+        }
+        timeline.unshift(entry);
+        timelineBytes += eventBytes;
+    }
+    if (requestedTimeline.length > 0 && timelineLimit !== 0 && timeline.length === 0) {
+        return undefined;
+    }
+    while (true) {
+        const body = createSyncRoom(room, since, available, timeline);
+        const stateBytes = jsonItemsByteLength(body.state.events, maxBytes);
+        if (stateBytes !== undefined && stateBytes + ephemeralBytes + timelineBytes <= maxBytes) {
+            const serialized = JSON.stringify(body);
+            if (Buffer.byteLength(serialized, "utf8") <= maxBytes) {
+                return serialized;
+            }
+        }
+        if (timeline.length === 1 && requestedTimeline.length > 0 && timelineLimit !== 0) {
+            return undefined;
+        }
+        const dropped = timeline.shift();
+        if (!dropped) {
+            return undefined;
+        }
+        const serializedDropped = JSON.stringify(dropped.event);
+        if (serializedDropped === undefined) {
+            return undefined;
+        }
+        timelineBytes -= Buffer.byteLength(serializedDropped, "utf8");
+    }
+}
+function roomHasSyncUpdates(room, since) {
+    return (since === undefined ||
+        room.createdSequence > since ||
+        room.timeline.some((entry) => entry.sequence > since) ||
+        room.ephemeral.some((entry) => entry.sequence > since));
+}
 function parseSyncToken(value) {
     if (value === null) {
         return undefined;
@@ -331,20 +403,62 @@ async function handleSync(url, state) {
         return filter;
     }
     const timelineLimit = readTimelineLimit(filter);
+    if (timelineLimit instanceof Response) {
+        return timelineLimit;
+    }
     const timeout = Math.min(readInteger(url.searchParams.get("timeout")) ?? 0, 1_000);
-    const hasNewEvents = [...state.rooms.values()].some((room) => [...room.timeline, ...room.ephemeral].some((entry) => since === undefined || entry.sequence > since));
+    const hasNewEvents = (state.directRoomsSequence !== undefined &&
+        (since === undefined || state.directRoomsSequence > since)) ||
+        [...state.rooms.values()].some((room) => roomHasSyncUpdates(room, since));
     if (since !== undefined && !hasNewEvents && timeout > 0) {
         await waitForSyncEvent(state, timeout);
     }
-    const join = Object.fromEntries([...state.rooms.values()].map((room) => [room.id, syncRoom(room, since, timelineLimit)]));
-    return jsonResponse({
-        account_data: { events: [] },
-        device_lists: { changed: [], left: [] },
-        device_one_time_keys_count: {},
-        next_batch: `s${state.nextSequence - 1}`,
-        presence: { events: [] },
-        rooms: { invite: {}, join, knock: {}, leave: {} },
-        to_device: { events: [] },
+    const accountData = serializeSyncAccountData(state, since, state.maxSyncResponseBytes);
+    if (!accountData) {
+        return matrixResourceLimitError("Sync response exceeds the configured byte limit");
+    }
+    const prefix = `{"account_data":${accountData},"device_lists":{"changed":[],"left":[]},"device_one_time_keys_count":{},"next_batch":${JSON.stringify(`s${state.nextSequence - 1}`)},"presence":{"events":[]},"rooms":{"invite":{},"join":{`;
+    const suffix = '},"knock":{},"leave":{}},"to_device":{"events":[]}}';
+    let responseBytes = Buffer.byteLength(prefix, "utf8") + Buffer.byteLength(suffix, "utf8");
+    const rooms = [...state.rooms.values()].filter((room) => roomHasSyncUpdates(room, since));
+    const minimumEntries = [];
+    for (const [index, room] of rooms.entries()) {
+        const separator = index === 0 ? "" : ",";
+        const roomKey = JSON.stringify(room.id);
+        const framingBytes = Buffer.byteLength(`${separator}${roomKey}:`, "utf8");
+        const roomBody = boundedSyncRoom(room, since, timelineLimit, state.maxSyncResponseBytes, 1);
+        if (!roomBody) {
+            return matrixResourceLimitError("Sync response exceeds the configured byte limit");
+        }
+        minimumEntries.push({
+            framingBytes,
+            minimumBytes: framingBytes + Buffer.byteLength(roomBody, "utf8"),
+            room,
+            roomKey,
+            separator,
+        });
+    }
+    let reservedBytes = minimumEntries.reduce((total, entry) => total + entry.minimumBytes, 0);
+    if (responseBytes + reservedBytes > state.maxSyncResponseBytes) {
+        return matrixResourceLimitError("Sync response exceeds the configured byte limit");
+    }
+    const parts = [];
+    for (const entry of minimumEntries) {
+        reservedBytes -= entry.minimumBytes;
+        const roomBody = boundedSyncRoom(entry.room, since, timelineLimit, state.maxSyncResponseBytes - responseBytes - entry.framingBytes - reservedBytes);
+        if (!roomBody) {
+            return matrixResourceLimitError("Sync response exceeds the configured byte limit");
+        }
+        parts.push(`${entry.separator}${entry.roomKey}:${roomBody}`);
+        responseBytes += entry.framingBytes + Buffer.byteLength(roomBody, "utf8");
+    }
+    const body = `${prefix}${parts.join("")}${suffix}`;
+    if (Buffer.byteLength(body, "utf8") > state.maxSyncResponseBytes) {
+        return matrixResourceLimitError("Sync response exceeds the configured byte limit");
+    }
+    return new Response(body, {
+        headers: { "content-type": "application/json" },
+        status: 200,
     });
 }
 function findRoom(state, encodedRoomId) {
@@ -353,18 +467,33 @@ function findRoom(state, encodedRoomId) {
 async function handleAdminInbound(params) {
     const roomId = readTrimmedString(params.body.roomId);
     const sender = readTrimmedString(params.body.sender ?? params.body.senderId);
-    const text = readTrimmedString(params.body.text);
-    if (!roomId || !sender || !text) {
+    const text = typeof params.body.text === "string" ? params.body.text : undefined;
+    if (!roomId || !sender || text === undefined || text.length === 0) {
         return jsonResponse({ error: "roomId, senderId, and text are required", ok: false }, 400);
     }
     const threadId = readTrimmedString(params.body.threadId);
     if (!isMatrixRoomId(roomId) ||
-        !isMatrixUserId(sender) ||
+        !isHistoricalMatrixUserId(sender) ||
         (threadId !== undefined && !isMatrixEventId(threadId))) {
         return jsonResponse({ error: "Invalid Matrix identifier", ok: false }, 400);
     }
     const direct = params.body.direct === true;
-    const room = params.state.rooms.get(roomId) ??
+    const existingRoom = params.state.rooms.get(roomId);
+    if (!existingRoom && params.state.rooms.size >= params.state.maxCommittedRooms) {
+        return jsonResponse({ error: "Committed Matrix rooms limit reached", ok: false }, 503);
+    }
+    if (!params.state.profiles.has(sender) &&
+        params.state.profiles.size >= params.state.maxCommittedUsers) {
+        return jsonResponse({ error: "Committed Matrix users limit reached", ok: false }, 503);
+    }
+    const roomHasSender = existingRoom
+        ? existingRoom.users.has(sender)
+        : sender === params.state.botUserId;
+    const roomUserCount = existingRoom?.users.size ?? 1;
+    if (!roomHasSender && roomUserCount >= params.state.maxCommittedUsers) {
+        return jsonResponse({ error: "Committed Matrix users limit reached", ok: false }, 503);
+    }
+    const room = existingRoom ??
         createRoom({
             botUserId: params.state.botUserId,
             createdSequence: params.state.nextSequence++,
@@ -375,7 +504,19 @@ async function handleAdminInbound(params) {
             state: params.state,
         });
     params.state.rooms.set(roomId, room);
+    if (direct) {
+        publishDirectRoom(params.state, sender, roomId);
+    }
     const senderName = readTrimmedString(params.body.senderName);
+    if (senderName) {
+        params.state.profiles.set(sender, {
+            ...params.state.profiles.get(sender),
+            display_name: senderName,
+        });
+    }
+    else if (!params.state.profiles.has(sender)) {
+        params.state.profiles.set(sender, {});
+    }
     const existingProfile = room.users.get(sender);
     if (existingProfile === undefined) {
         room.users.set(sender, senderName ? { display_name: senderName } : {});
@@ -415,6 +556,13 @@ async function handleAdminInbound(params) {
             sequence: params.state.nextSequence++,
         });
     }
+    const roomAvatarUrl = room.users.get(sender)?.avatar_url;
+    if (roomAvatarUrl) {
+        params.state.profiles.set(sender, {
+            ...params.state.profiles.get(sender),
+            avatar_url: roomAvatarUrl,
+        });
+    }
     const content = { body: text, msgtype: "m.text" };
     if (threadId) {
         content["m.relates_to"] = {
@@ -453,13 +601,11 @@ async function handleMatrixApi(params) {
     let match = /^\/profile\/([^/]+)$/u.exec(relativePath);
     if (params.method === "GET" && match) {
         const userId = decodeMatrixPathSegment(match[1]);
-        const member = [...params.state.rooms.values()]
-            .map((room) => room.users.get(userId))
-            .find((profile) => profile !== undefined);
-        return member
+        const profile = params.state.profiles.get(userId);
+        return profile
             ? jsonResponse({
-                ...(member.avatar_url ? { avatar_url: member.avatar_url } : {}),
-                ...(member.display_name ? { displayname: member.display_name } : {}),
+                ...(profile.avatar_url ? { avatar_url: profile.avatar_url } : {}),
+                ...(profile.display_name ? { displayname: profile.display_name } : {}),
             })
             : matrixError("M_NOT_FOUND", "Unknown user", 404);
     }
@@ -654,24 +800,34 @@ async function handleMatrixApi(params) {
 export async function startMatrixServer(params = {}) {
     const host = params.host ?? "127.0.0.1";
     const serverName = params.serverName ?? "matrix.test";
+    const botUserId = params.botUserId ?? `@openclaw:${serverName}`;
+    if (!isMatrixUserId(botUserId)) {
+        throw new Error("botUserId must be a canonical Matrix user ID.");
+    }
     const state = {
         accessToken: params.accessToken ?? `syt_crabline_${randomBytes(12).toString("hex")}`,
         adminToken: params.adminToken ?? randomBytes(24).toString("hex"),
-        botUserId: params.botUserId ?? `@openclaw:${serverName}`,
+        botUserId,
         deviceId: params.deviceId ?? "CRABLINE",
+        directRooms: new Map(),
+        directRoomsSequence: undefined,
         filterBytes: 0,
         filters: new Map(),
+        maxCommittedRooms: resolvePositiveLimit(params.maxCommittedRooms, "maxCommittedRooms", DEFAULT_MAX_MATRIX_COMMITTED_ROOMS),
+        maxCommittedUsers: resolvePositiveLimit(params.maxCommittedUsers, "maxCommittedUsers", DEFAULT_MAX_MATRIX_COMMITTED_USERS),
+        maxSyncResponseBytes: resolvePositiveLimit(params.maxSyncResponseBytes, "maxSyncResponseBytes", DEFAULT_MAX_MATRIX_SYNC_RESPONSE_BYTES),
         nextEvent: 1,
         nextFilter: 1,
         nextSequence: 1,
         onEvent: params.onEvent,
+        profiles: new Map([[botUserId, { display_name: "OpenClaw QA" }]]),
         recorderPath: params.recorderPath ?? path.resolve("artifacts/crabline/matrix.jsonl"),
         rooms: new Map(),
         serverName,
         syncWaiters: new Set(),
         transactions: new Map(),
     };
-    const roomId = params.roomId ?? matrixId("!", "default-room", serverName);
+    const roomId = params.roomId ?? matrixRoomId("default-room", serverName);
     state.rooms.set(roomId, createRoom({
         botUserId: state.botUserId,
         createdSequence: 0,
@@ -694,6 +850,7 @@ export async function startMatrixServer(params = {}) {
             return matrixError("M_UNKNOWN", "Internal server error", 500);
         },
         host,
+        maxResponseBodyBytes: Math.max(DEFAULT_MAX_RESPONSE_BODY_BYTES, state.maxSyncResponseBytes),
         port: params.port ?? 0,
         serverName: "Matrix",
         async handle(request) {
@@ -761,6 +918,7 @@ export async function startMatrixServer(params = {}) {
                 state,
                 url,
             });
+            event.accepted ??= response.ok;
             await appendEvent(state, event, response.ok && ["DELETE", "POST", "PUT"].includes(method));
             return response;
         },