@mpgd/adapter-devvit 0.12.1 → 0.13.1

package/dist/server/redis-notification-store.js

@@ -0,0 +1,1058 @@
+import { formatNotificationInstant, notificationSendDueAt, } from '@mpgd/game-services/notifications';
+import { createHash } from 'node:crypto';
+export const defaultDevvitNotificationNamespace = 'mpgd:notifications';
+const defaultTransactionAttempts = 16;
+const maximumTransactionAttempts = 64;
+const defaultPurgeLimit = Number.POSITIVE_INFINITY;
+/** The commit marker's value; its SET replies `OK`, which `@devvit/redis` always maps. */
+const commitMarkerValue = '1';
+/** Sorted-set page size; `@devvit/redis` reads at most 1,000 members per score or lex range. */
+const pageSize = 500;
+export function createDevvitRedisNotificationStore(redis, options = {}) {
+    const namespace = options.namespace ?? defaultDevvitNotificationNamespace;
+    if (namespace.length === 0) {
+        throw new TypeError('The Devvit notification store namespace must not be empty.');
+    }
+    const attempts = options.transactionAttempts ?? defaultTransactionAttempts;
+    if (!Number.isSafeInteger(attempts) || attempts < 1 || attempts > maximumTransactionAttempts) {
+        throw new TypeError(`transactionAttempts must be a safe integer from 1 to ${String(maximumTransactionAttempts)}.`);
+    }
+    const newVersion = options.newVersion ?? (() => globalThis.crypto.randomUUID());
+    const backoff = options.backoff ?? defaultBackoff;
+    const purgeLimit = options.purgeLimit ?? defaultPurgeLimit;
+    if (purgeLimit !== defaultPurgeLimit && (!Number.isSafeInteger(purgeLimit) || purgeLimit < 1)) {
+        throw new TypeError('purgeLimit must be a positive safe integer.');
+    }
+    const enc = encodeURIComponent;
+    const keys = {
+        consent: (player) => `${namespace}:consent:${enc(player)}`,
+        endpoint: (provider, installationId) => `${namespace}:endpoint:${enc(provider)}:${enc(installationId)}`,
+        // The address is hashed: a device token never appears in a key name.
+        endpointAddress: (provider, value) => `${namespace}:endpoint-address:${enc(provider)}:${createHash('sha256').update(value).digest('hex')}`,
+        endpointsByPlayer: (player) => `${namespace}:endpoints-player:${enc(player)}`,
+        endpointsBySession: (sessionId) => `${namespace}:endpoints-session:${enc(sessionId)}`,
+        endpointsByInstallation: (installationId) => `${namespace}:endpoints-installation:${enc(installationId)}`,
+        endpointsRegistered: `${namespace}:endpoints-registered`,
+        endpointsInvalidated: `${namespace}:endpoints-invalidated`,
+        endpointsSessionEnd: `${namespace}:endpoints-session-end`,
+        registrations: `${namespace}:registrations`,
+        notices: (player) => `${namespace}:notices:${enc(player)}`,
+        send: (key) => `${namespace}:send:${enc(key)}`,
+        due: `${namespace}:sends:due`,
+        changed: `${namespace}:sends:changed`,
+        inFlight: (player) => `${namespace}:sends:in-flight:${enc(player)}`,
+        history: (player) => `${namespace}:history:${enc(player)}`,
+        historyAt: (player) => `${namespace}:history-at:${enc(player)}`,
+        historyAll: `${namespace}:history-all`,
+        historyByProvider: (provider) => `${namespace}:history-provider:${enc(provider)}`,
+        schedule: (player, id) => `${namespace}:schedule:${enc(player)}:${enc(id)}`,
+        scheduleDue: `${namespace}:schedule-due`,
+        pendingReminders: (player) => `${namespace}:schedule-pending:${enc(player)}`,
+        commitMarker: `${namespace}:commit`,
+    };
+    /**
+     * Runs one atomic step: watches `watched`, lets `plan` read and decide,
+     * and queues its commands in one MULTI/EXEC. A plan without commands only
+     * unwatches. A transaction that another writer aborted is planned again.
+     *
+     * `@devvit/redis` drops from the EXEC result every reply it cannot map,
+     * which may include a protobuf zero (a ZREM or HSET that changed nothing),
+     * and resolves an aborted transaction as an empty array. So each
+     * transaction ends with a SET of the namespace's commit marker, whose `OK`
+     * always maps: a committed EXEC answers at least that reply, and only an
+     * empty, `null`, or all-nil result is an abort.
+     */
+    async function transact(watched, plan) {
+        return transactPrepared(async () => ({ watched, plan }));
+    }
+    /**
+     * As `transact`, with the watched keys chosen from a read before WATCH:
+     * `prepare` reads what decides them, and a plan that finds that read
+     * outdated once the keys are watched answers `retry`.
+     */
+    async function transactPrepared(prepare) {
+        let lastWatched = [];
+        for (let attempt = 0; attempt < attempts; attempt += 1) {
+            if (attempt > 0) {
+                await backoff(attempt);
+            }
+            const { watched, plan } = await prepare();
+            lastWatched = watched;
+            const transaction = await redis.watch(...watched);
+            let multiStarted = false;
+            try {
+                const planned = await plan();
+                if ('retry' in planned) {
+                    await transaction.unwatch();
+                    continue;
+                }
+                const { commands, result } = planned;
+                if (commands.length === 0) {
+                    await transaction.unwatch();
+                    return result;
+                }
+                await transaction.multi();
+                multiStarted = true;
+                for (const command of commands) {
+                    await command(transaction);
+                }
+                await transaction.set(keys.commitMarker, commitMarkerValue);
+                const results = await transaction.exec();
+                if (results !== null && !Array.isArray(results)) {
+                    throw new Error('Devvit Redis transaction returned an unsupported response.');
+                }
+                // An aborted WATCH transaction (another writer changed a watched
+                // key) answers no reply; one that answers only nil is read the same
+                // way, since no command queued here replies nil when it commits.
+                if (results === null || results.every((reply) => reply === null || reply === undefined)) {
+                    continue;
+                }
+                return result;
+            }
+            catch (error) {
+                await bestEffortReset(transaction, multiStarted);
+                throw error;
+            }
+        }
+        throw new Error(`Devvit Redis notification store: contention exceeded ${String(attempts)} attempts on ${String(lastWatched.length)} watched key(s).`);
+    }
+    /** The members of a sorted set in score order, read in pages, up to `limit`. */
+    async function scoreRange(key, min, max, limit = Number.POSITIVE_INFINITY) {
+        const members = [];
+        for (let offset = 0; members.length < limit; offset += pageSize) {
+            const count = Math.min(pageSize, limit - members.length);
+            const page = await redis.zRange(key, min, max, {
+                by: 'score',
+                limit: { offset, count },
+            });
+            for (const entry of page) {
+                members.push(entry.member);
+            }
+            if (page.length < count) {
+                break;
+            }
+        }
+        return members;
+    }
+    const endpointMember = (provider, installationId) => JSON.stringify([provider, installationId]);
+    async function readEndpoint(provider, installationId) {
+        const key = keys.endpoint(provider, installationId);
+        const value = await redis.get(key);
+        return isMissing(value) ? undefined : parse(value, key);
+    }
+    /**
+     * The commands that move an endpoint from `before` to `after` (either may
+     * be absent) with its address pointer and indexes. `ownsOldAddress` says
+     * whether `before`'s address pointer still names this installation, so a
+     * pointer another installation took is never deleted; `writeAddress`
+     * false keeps the pointer as it is (an update that keeps the address).
+     */
+    function endpointCommands(before, after, ownsOldAddress, writeAddress = true) {
+        const subject = after ?? before;
+        if (subject === undefined) {
+            return [];
+        }
+        const { provider, installationId } = subject;
+        const member = endpointMember(provider, installationId);
+        const commands = [];
+        const valueKey = keys.endpoint(provider, installationId);
+        if (after === undefined) {
+            commands.push((transaction) => transaction.del(valueKey));
+        }
+        else {
+            const value = JSON.stringify(after);
+            commands.push((transaction) => transaction.set(valueKey, value));
+        }
+        if (before !== undefined
+            && ownsOldAddress
+            && (after === undefined || before.address.value !== after.address.value)) {
+            const oldAddress = keys.endpointAddress(provider, before.address.value);
+            commands.push((transaction) => transaction.del(oldAddress));
+        }
+        if (after !== undefined && writeAddress) {
+            const address = keys.endpointAddress(provider, after.address.value);
+            commands.push((transaction) => transaction.set(address, installationId));
+        }
+        const moved = (field, key) => {
+            if (before !== undefined && (after === undefined || before[field] !== after[field])) {
+                const old = key(before[field]);
+                commands.push((transaction) => transaction.zRem(old, [member]));
+            }
+            if (after !== undefined) {
+                const next = key(after[field]);
+                commands.push((transaction) => transaction.zAdd(next, { member, score: 0 }));
+            }
+        };
+        moved('player', keys.endpointsByPlayer);
+        moved('sessionId', keys.endpointsBySession);
+        const byInstallation = keys.endpointsByInstallation(installationId);
+        if (after === undefined) {
+            commands.push((transaction) => transaction.zRem(byInstallation, [provider]));
+        }
+        else {
+            commands.push((transaction) => transaction.zAdd(byInstallation, { member: provider, score: 0 }));
+        }
+        // The purge indexes, one per cutoff, scored by the time it compares.
+        const timed = (key, at) => {
+            if (at === undefined) {
+                commands.push((transaction) => transaction.zRem(key, [member]));
+            }
+            else {
+                const score = Date.parse(at);
+                commands.push((transaction) => transaction.zAdd(key, { member, score }));
+            }
+        };
+        timed(keys.endpointsRegistered, after?.lastRegisteredAt);
+        timed(keys.endpointsInvalidated, after?.status === 'invalid' ? after.invalidatedAt : undefined);
+        timed(keys.endpointsSessionEnd, after?.sessionExpiresAt);
+        return commands;
+    }
+    /**
+     * Removes one endpoint, atomically, while `matches` holds for it; answers
+     * whether it did. An index entry that names an endpoint whose value is
+     * gone is dropped from `prune` (`[key, member]` pairs); one whose endpoint
+     * exists but does not match is rewritten by `reindex` (a time index's
+     * caller rescores a drifted entry).
+     */
+    async function removeEndpointIf(provider, installationId, matches, prune = [], reindex = () => []) {
+        return transactPrepared(async () => {
+            const seen = await readEndpoint(provider, installationId);
+            const valueKey = keys.endpoint(provider, installationId);
+            return {
+                watched: seen === undefined
+                    ? [valueKey]
+                    : [valueKey, keys.endpointAddress(provider, seen.address.value)],
+                plan: async () => {
+                    const endpoint = await readEndpoint(provider, installationId);
+                    if (JSON.stringify(endpoint) !== JSON.stringify(seen)) {
+                        return { retry: true };
+                    }
+                    if (endpoint === undefined) {
+                        return {
+                            commands: prune.map(([key, member]) => (transaction) => transaction.zRem(key, [member])),
+                            result: false,
+                        };
+                    }
+                    if (!matches(endpoint)) {
+                        // An index entry that drifted from its endpoint is rewritten, so a
+                        // purge never reads it again before its time.
+                        return { commands: reindex(endpoint), result: false };
+                    }
+                    const owner = await redis.get(keys.endpointAddress(provider, endpoint.address.value));
+                    return {
+                        commands: endpointCommands(endpoint, undefined, owner === installationId),
+                        result: true,
+                    };
+                },
+            };
+        });
+    }
+    /** Every endpoint an index names, as `[provider, installationId]`. */
+    async function indexedEndpoints(key) {
+        const members = await redis.zRange(key, 0, -1, { by: 'rank' });
+        return members.flatMap((entry) => {
+            const named = tryParse(entry.member);
+            return Array.isArray(named) && typeof named[0] === 'string' && typeof named[1] === 'string'
+                ? [[named[0], named[1]]]
+                : [];
+        });
+    }
+    /** The index commands that follow a send from `before` to `after` (either may be absent). */
+    function sendIndexCommands(key, before, after) {
+        const commands = [];
+        const due = after === undefined ? undefined : notificationSendDueAt(after);
+        if (due === undefined) {
+            if (before !== undefined) {
+                commands.push((transaction) => transaction.zRem(keys.due, [key]));
+            }
+        }
+        else {
+            commands.push((transaction) => transaction.zAdd(keys.due, { member: key, score: Date.parse(due) }));
+        }
+        if (after === undefined) {
+            commands.push((transaction) => transaction.zRem(keys.changed, [key]));
+        }
+        else {
+            commands.push((transaction) => transaction.zAdd(keys.changed, { member: key, score: Date.parse(after.changedAt) }));
+        }
+        const flying = (send) => send !== undefined && send.rows.some((row) => row.state.status === 'in-flight');
+        if (before !== undefined && flying(before) && !flying(after)) {
+            commands.push((transaction) => transaction.zRem(keys.inFlight(before.request.player), [key]));
+        }
+        if (after !== undefined && flying(after)) {
+            commands.push((transaction) => transaction.zAdd(keys.inFlight(after.request.player), { member: key, score: 0 }));
+        }
+        return commands;
+    }
+    /** A stored send value, or `'unreadable'` for one that is not a send. */
+    function readSendValue(raw) {
+        const value = tryParse(raw);
+        const send = typeof value === 'object' && value !== null ? value.send : undefined;
+        return typeof value?.version === 'string'
+            && typeof send === 'object' && send !== null
+            && typeof send.key === 'string'
+            && typeof send.changedAt === 'string'
+            && typeof send.request?.player === 'string'
+            && Array.isArray(send.rows)
+            && send.rows.every((row) => {
+                const candidate = row;
+                return typeof candidate === 'object' && candidate !== null
+                    && typeof candidate.key === 'string'
+                    && typeof candidate.provider === 'string'
+                    && typeof candidate.state?.status === 'string';
+            })
+            ? value
+            : 'unreadable';
+    }
+    async function readSend(key) {
+        const value = await redis.get(keys.send(key));
+        if (isMissing(value)) {
+            return undefined;
+        }
+        const stored = readSendValue(value);
+        if (stored === 'unreadable') {
+            throw new Error(`Devvit Redis notification store: ${keys.send(key)} holds a value that is not a send.`);
+        }
+        return stored;
+    }
+    async function readSchedule(player, id) {
+        const key = keys.schedule(player, id);
+        const value = await redis.get(key);
+        if (isMissing(value)) {
+            return undefined;
+        }
+        const stored = tryParse(value);
+        if (typeof stored !== 'object' || stored === null
+            || typeof stored.version !== 'string'
+            || typeof stored.entry !== 'object' || stored.entry === null
+            || typeof stored.entry.item !== 'object' || stored.entry.item === null) {
+            throw new Error(`Devvit Redis notification store: ${key} holds a value that is not a schedule entry.`);
+        }
+        return stored;
+    }
+    /**
+     * The value and index commands that store `after` under `player` and `id`
+     * (whatever it names) with a new version, or delete the entry.
+     */
+    function scheduleCommands(player, id, after) {
+        const valueKey = keys.schedule(player, id);
+        const member = scheduleMember(player, id);
+        if (after === undefined) {
+            return {
+                commands: [
+                    (transaction) => transaction.del(valueKey),
+                    (transaction) => transaction.zRem(keys.scheduleDue, [member]),
+                    (transaction) => transaction.zRem(keys.pendingReminders(player), [id]),
+                ],
+                version: undefined,
+            };
+        }
+        const { dueAt, ...rest } = after;
+        const entry = {
+            ...rest,
+            player,
+            id,
+            ...(dueAt === undefined ? {} : { dueAt }),
+        };
+        const version = newVersion();
+        const value = JSON.stringify({ entry, version });
+        const score = dueAt === undefined ? undefined : instantOf(dueAt);
+        const pending = id.startsWith('reminder:') && entry.item.kind === 'reminder' && entry.item.firedAt === undefined;
+        return {
+            commands: [
+                (transaction) => transaction.set(valueKey, value),
+                score === undefined
+                    ? (transaction) => transaction.zRem(keys.scheduleDue, [member])
+                    : (transaction) => transaction.zAdd(keys.scheduleDue, { member, score }),
+                pending
+                    ? (transaction) => transaction.zAdd(keys.pendingReminders(player), { member: id, score: 0 })
+                    : (transaction) => transaction.zRem(keys.pendingReminders(player), [id]),
+            ],
+            version,
+        };
+    }
+    /** The rank of the first member at or after `min` (a score bound), the set's size when none is. */
+    async function rankFrom(key, min) {
+        const [first] = await redis.zRange(key, min, '+inf', {
+            by: 'score',
+            limit: { offset: 0, count: 1 },
+        });
+        return first === undefined ? redis.zCard(key) : redis.zRank(key, first.member);
+    }
+    /**
+     * How many members score from `min` to `max`, both inclusive, by rank.
+     * The start rank is read again after the end rank: a write below `min`
+     * between the reads moves both, so differing start ranks, or a member
+     * removed before its rank was read, make the count read again. After a
+     * few tries the members are counted in pages. A write in or above the
+     * range during the reads (a send delivered just now), or two opposite
+     * writes below it, may still be counted or not: pacing is approximate by
+     * contract.
+     */
+    async function countScores(key, min, max) {
+        for (let attempt = 0; attempt < 4; attempt += 1) {
+            const start = await rankFrom(key, String(min));
+            const end = await rankFrom(key, `(${String(max)}`);
+            const again = await rankFrom(key, String(min));
+            if (start !== undefined && end !== undefined && again === start && end >= start) {
+                return end - start;
+            }
+        }
+        return (await scoreRange(key, String(min), String(max))).length;
+    }
+    return {
+        async appendConsent({ player, record, at }) {
+            const key = keys.consent(player);
+            return transact([key], async () => {
+                const [latest] = await redis.zRange(key, -1, -1, { by: 'rank' });
+                let millis = Date.parse(at);
+                if (latest !== undefined) {
+                    millis = Math.max(millis, latest.score + 1);
+                }
+                const stored = { ...record, at: formatNotificationInstant(millis) };
+                const member = JSON.stringify(stored);
+                return {
+                    commands: [(transaction) => transaction.zAdd(key, { member, score: millis })],
+                    result: structuredClone(stored),
+                };
+            });
+        },
+        async listConsent(player) {
+            const key = keys.consent(player);
+            const members = await redis.zRange(key, 0, -1, { by: 'rank' });
+            return members.map((entry) => parse(entry.member, key));
+        },
+        async pruneConsent({ player, at }) {
+            // Every instant parses before anything is read or deleted.
+            const instants = new Set(at.map(instantOf));
+            if (instants.size === 0) {
+                return 0;
+            }
+            const consentKey = keys.consent(player);
+            const noticesKey = keys.notices(player);
+            return transact([consentKey, noticesKey], async () => {
+                const records = (await redis.zRange(consentKey, 0, -1, { by: 'rank' }))
+                    .filter((entry) => instants.has(entry.score))
+                    .map((entry) => entry.member);
+                const notices = Object.entries(await redis.hGetAll(noticesKey))
+                    .filter(([, value]) => {
+                    const notice = tryParse(value);
+                    return typeof notice?.record?.at === 'string' && instants.has(Date.parse(notice.record.at));
+                })
+                    .map(([field]) => field);
+                return {
+                    commands: [
+                        ...(records.length === 0 ? [] : [(transaction) => transaction.zRem(consentKey, records)]),
+                        ...(notices.length === 0 ? [] : [(transaction) => transaction.hDel(noticesKey, notices)]),
+                    ],
+                    result: records.length,
+                };
+            });
+        },
+        async putEndpoint(write) {
+            const { provider, installationId } = write;
+            const valueKey = keys.endpoint(provider, installationId);
+            const addressKey = keys.endpointAddress(provider, write.address.value);
+            return transactPrepared(async () => {
+                // What decides the watched keys: this installation's endpoint, and
+                // the installation the new address points to now.
+                const seen = await readEndpoint(provider, installationId);
+                const seenOwner = await redis.get(addressKey);
+                const watched = [valueKey, addressKey];
+                if (seen !== undefined && seen.address.value !== write.address.value) {
+                    watched.push(keys.endpointAddress(provider, seen.address.value));
+                }
+                if (!isMissing(seenOwner) && seenOwner !== installationId) {
+                    watched.push(keys.endpoint(provider, seenOwner));
+                }
+                return {
+                    watched,
+                    plan: async () => {
+                        const existing = await readEndpoint(provider, installationId);
+                        const owner = await redis.get(addressKey);
+                        if (JSON.stringify(existing) !== JSON.stringify(seen) || owner !== seenOwner) {
+                            return { retry: true };
+                        }
+                        const commands = [];
+                        if (!isMissing(owner) && owner !== installationId) {
+                            // An address is unique per provider: the other installation loses it.
+                            const other = await readEndpoint(provider, owner);
+                            if (other !== undefined) {
+                                commands.push(...endpointCommands(other, undefined, false));
+                            }
+                        }
+                        const dead = existing?.status === 'invalid' && existing.address.value === write.address.value;
+                        const stored = {
+                            ...structuredClone(write),
+                            status: dead ? 'invalid' : 'valid',
+                            ...(dead && existing.invalidatedAt !== undefined ? { invalidatedAt: existing.invalidatedAt } : {}),
+                        };
+                        const ownsOldAddress = existing !== undefined
+                            && (await redis.get(keys.endpointAddress(provider, existing.address.value))) === installationId;
+                        commands.push(...endpointCommands(existing, stored, ownsOldAddress));
+                        return { commands, result: structuredClone(stored) };
+                    },
+                };
+            });
+        },
+        async listEndpoints({ player, provider }) {
+            const named = (await indexedEndpoints(keys.endpointsByPlayer(player)))
+                .filter(([indexed]) => indexed === provider);
+            if (named.length === 0) {
+                return [];
+            }
+            const valueKeys = named.map(([indexed, installation]) => keys.endpoint(indexed, installation));
+            const values = await redis.mGet(valueKeys);
+            return values
+                .flatMap((value, position) => (isMissing(value) ? [] : [parse(value, valueKeys[position] ?? '')]))
+                .filter((endpoint) => endpoint.player === player && endpoint.provider === provider)
+                .sort((left, right) => compareText(left.installationId, right.installationId));
+        },
+        async getEndpoint({ provider, installationId }) {
+            return readEndpoint(provider, installationId);
+        },
+        async invalidateEndpoint({ provider, installationId, value, at }) {
+            await transact([keys.endpoint(provider, installationId)], async () => {
+                const endpoint = await readEndpoint(provider, installationId);
+                if (endpoint === undefined || endpoint.address.value !== value || endpoint.status !== 'valid') {
+                    return { commands: [], result: undefined };
+                }
+                const invalid = { ...endpoint, status: 'invalid', invalidatedAt: at };
+                return { commands: endpointCommands(endpoint, invalid, true, false), result: undefined };
+            });
+        },
+        async removeEndpoints({ installationId, player, provider }) {
+            const providers = provider === undefined
+                ? (await redis.zRange(keys.endpointsByInstallation(installationId), 0, -1, { by: 'rank' }))
+                    .map((entry) => entry.member)
+                : [provider];
+            for (const named of providers) {
+                await removeEndpointIf(named, installationId, (endpoint) => endpoint.player === player, [
+                    [keys.endpointsByInstallation(installationId), named],
+                ]);
+            }
+        },
+        async removeSessionEndpoints({ sessionId }) {
+            let removed = 0;
+            for (const [provider, installationId] of await indexedEndpoints(keys.endpointsBySession(sessionId))) {
+                if (await removeEndpointIf(provider, installationId, (endpoint) => endpoint.sessionId === sessionId)) {
+                    removed += 1;
+                }
+            }
+            return removed;
+        },
+        async extendSessionEndpoints({ sessionId, expiresAt }) {
+            let changed = 0;
+            for (const [provider, installationId] of await indexedEndpoints(keys.endpointsBySession(sessionId))) {
+                const key = keys.endpoint(provider, installationId);
+                const moved = await transact([key], async () => {
+                    const endpoint = await readEndpoint(provider, installationId);
+                    if (endpoint === undefined
+                        || endpoint.sessionId !== sessionId
+                        || endpoint.sessionExpiresAt === undefined
+                        || (expiresAt !== undefined && Date.parse(endpoint.sessionExpiresAt) >= Date.parse(expiresAt))) {
+                        return { commands: [], result: false };
+                    }
+                    const { sessionExpiresAt: _earlier, ...kept } = endpoint;
+                    const extended = expiresAt === undefined ? kept : { ...kept, sessionExpiresAt: expiresAt };
+                    return { commands: endpointCommands(endpoint, extended, true, false), result: true };
+                });
+                if (moved) {
+                    changed += 1;
+                }
+            }
+            return changed;
+        },
+        async putPlatformRegistration(registration) {
+            const field = JSON.stringify([registration.player, registration.provider]);
+            const value = JSON.stringify(registration);
+            // One write that reads nothing: no transaction, so registrations never contend.
+            await redis.hSet(keys.registrations, { [field]: value });
+        },
+        async getPlatformRegistration({ player, provider }) {
+            const value = await redis.hGet(keys.registrations, JSON.stringify([player, provider]));
+            return isMissing(value)
+                ? undefined
+                : parse(value, keys.registrations);
+        },
+        async addNoticeGiven(notice) {
+            const key = keys.notices(notice.player);
+            // Named by the notice, its record's instant to the millisecond, and its date.
+            const field = JSON.stringify([
+                notice.kind,
+                notice.record.kind,
+                Date.parse(notice.record.at),
+                notice.dueBy,
+            ]);
+            await transact([key], async () => {
+                if (!isMissing(await redis.hGet(key, field))) {
+                    return { commands: [], result: undefined };
+                }
+                const value = JSON.stringify(notice);
+                return {
+                    commands: [(transaction) => transaction.hSet(key, { [field]: value })],
+                    result: undefined,
+                };
+            });
+        },
+        async listNoticesGiven(player) {
+            const key = keys.notices(player);
+            return Object.values(await redis.hGetAll(key))
+                .map((value) => parse(value, key))
+                .sort((left, right) => Date.parse(left.at) - Date.parse(right.at));
+        },
+        async getSend(key) {
+            const stored = await readSend(key);
+            return stored === undefined ? undefined : { send: stored.send, version: stored.version };
+        },
+        async createSend(send) {
+            const valueKey = keys.send(send.key);
+            return transact([valueKey], async () => {
+                if (!isMissing(await redis.get(valueKey))) {
+                    return { commands: [], result: undefined };
+                }
+                const version = newVersion();
+                const value = JSON.stringify({ send, version });
+                return {
+                    commands: [
+                        (transaction) => transaction.set(valueKey, value),
+                        ...sendIndexCommands(send.key, undefined, send),
+                    ],
+                    result: version,
+                };
+            });
+        },
+        async updateSend({ key, version, send }) {
+            const valueKey = keys.send(key);
+            return transact([valueKey], async () => {
+                const stored = await readSend(key);
+                if (stored === undefined || stored.version !== version) {
+                    return { commands: [], result: false };
+                }
+                if (send === undefined) {
+                    return {
+                        commands: [
+                            (transaction) => transaction.del(valueKey),
+                            ...sendIndexCommands(key, stored.send, undefined),
+                        ],
+                        result: true,
+                    };
+                }
+                const value = JSON.stringify({ send, version: newVersion() });
+                return {
+                    commands: [
+                        (transaction) => transaction.set(valueKey, value),
+                        ...sendIndexCommands(key, stored.send, send),
+                    ],
+                    result: true,
+                };
+            });
+        },
+        async listInFlightSends(player) {
+            const index = await redis.zRange(keys.inFlight(player), 0, -1, { by: 'rank' });
+            if (index.length === 0) {
+                return [];
+            }
+            const values = await redis.mGet(index.map((entry) => keys.send(entry.member)));
+            const sends = [];
+            for (const value of values) {
+                if (isMissing(value)) {
+                    continue;
+                }
+                const stored = readSendValue(value);
+                if (stored === 'unreadable') {
+                    // An unreadable row is not this player's in-flight send; purge drops it.
+                    continue;
+                }
+                const { send } = stored;
+                if (send.request.player === player && send.rows.some((row) => row.state.status === 'in-flight')) {
+                    sends.push(send);
+                }
+            }
+            return sends;
+        },
+        async listDueSends({ at, limit }) {
+            const now = instantOf(at);
+            const count = Math.max(0, Math.floor(limit));
+            if (count === 0) {
+                return [];
+            }
+            const due = [];
+            const seen = new Set();
+            let offset = 0;
+            while (due.length < count) {
+                const want = Math.min(pageSize, count - due.length);
+                const page = await redis.zRange(keys.due, '-inf', String(now), {
+                    by: 'score',
+                    limit: { offset, count: want },
+                });
+                for (const entry of page) {
+                    // Offsets move while other workers write the index: keep each key once.
+                    if (!seen.has(entry.member)) {
+                        seen.add(entry.member);
+                        due.push(entry.member);
+                    }
+                }
+                if (page.length < want) {
+                    break;
+                }
+                offset += page.length;
+            }
+            return due;
+        },
+        async addHistory(entry) {
+            const score = instantOf(entry.at);
+            const key = keys.history(entry.player);
+            const field = JSON.stringify([entry.sendKey, entry.provider]);
+            await transact([key], async () => {
+                if (!isMissing(await redis.hGet(key, field))) {
+                    return { commands: [], result: undefined };
+                }
+                const value = JSON.stringify(entry);
+                const everywhere = JSON.stringify([entry.player, field]);
+                return {
+                    commands: [
+                        (transaction) => transaction.hSet(key, { [field]: value }),
+                        (transaction) => transaction.zAdd(keys.historyAt(entry.player), { member: field, score }),
+                        (transaction) => transaction.zAdd(keys.historyAll, { member: everywhere, score }),
+                        (transaction) => transaction.zAdd(keys.historyByProvider(entry.provider), { member: everywhere, score }),
+                    ],
+                    result: undefined,
+                };
+            });
+        },
+        async listHistory({ player, since }) {
+            const fields = await scoreRange(keys.historyAt(player), String(instantOf(since)), '+inf');
+            if (fields.length === 0) {
+                return [];
+            }
+            const key = keys.history(player);
+            const values = await redis.hMGet(key, fields);
+            return values
+                .filter((value) => typeof value === 'string')
+                .map((value) => parse(value, key))
+                .sort((left, right) => Date.parse(left.at) - Date.parse(right.at));
+        },
+        async countHistory({ provider, since, until }) {
+            const from = instantOf(since);
+            const to = instantOf(until);
+            return to < from ? 0 : countScores(keys.historyByProvider(provider), from, to);
+        },
+        async getScheduleEntry({ player, id }) {
+            const stored = await readSchedule(player, id);
+            return stored === undefined ? undefined : { entry: stored.entry, version: stored.version };
+        },
+        async createScheduleEntry(entry) {
+            if (entry.dueAt !== undefined) {
+                instantOf(entry.dueAt);
+            }
+            const valueKey = keys.schedule(entry.player, entry.id);
+            return transact([valueKey], async () => {
+                if (!isMissing(await redis.get(valueKey))) {
+                    return { commands: [], result: undefined };
+                }
+                const { commands, version } = scheduleCommands(entry.player, entry.id, entry);
+                return { commands, result: version };
+            });
+        },
+        async updateScheduleEntry({ player, id, version, entry }) {
+            if (entry?.dueAt !== undefined) {
+                instantOf(entry.dueAt);
+            }
+            return transact([keys.schedule(player, id)], async () => {
+                const stored = await readSchedule(player, id);
+                if (stored === undefined || stored.version !== version) {
+                    return { commands: [], result: false };
+                }
+                return { commands: scheduleCommands(player, id, entry).commands, result: true };
+            });
+        },
+        async countPendingReminders(player) {
+            return redis.zCard(keys.pendingReminders(player));
+        },
+        async listDueScheduleEntries({ at, limit }) {
+            const now = instantOf(at);
+            const count = Math.max(0, Math.floor(limit));
+            const due = [];
+            const seen = new Set();
+            let offset = 0;
+            while (due.length < count) {
+                const want = Math.min(pageSize, count - due.length);
+                const page = await redis.zRange(keys.scheduleDue, '-inf', String(now), {
+                    by: 'score',
+                    limit: { offset, count: want },
+                });
+                // Offset paging: an entry removed ahead of the offset during the
+                // listing shifts the rest, so one may be missed until the next run.
+                for (const { member } of page) {
+                    const named = readScheduleMember(member);
+                    // Offsets move while other workers write the index: keep each entry once.
+                    if (named !== undefined && !seen.has(member)) {
+                        seen.add(member);
+                        due.push(named);
+                    }
+                }
+                if (page.length < want) {
+                    break;
+                }
+                offset += page.length;
+            }
+            return due;
+        },
+        async purge(cutoffs) {
+            // Every cutoff parses before anything is read or deleted.
+            for (const cutoff of Object.values(cutoffs)) {
+                instantOf(cutoff);
+            }
+            // Oldest first; with `purgeLimit`, at most that many sends and history
+            // rows per call, and the next scheduled purge continues.
+            let sendCount = 0;
+            const sendsBefore = instantOf(cutoffs.sendsChangedBefore);
+            for (const key of await scoreRange(keys.changed, '-inf', `(${String(sendsBefore)}`, purgeLimit)) {
+                const valueKey = keys.send(key);
+                const deleted = await transact([valueKey], async () => {
+                    // A Redis failure here fails the purge; only a value that does not
+                    // parse as a send is dropped, since nothing can use it.
+                    const raw = await redis.get(valueKey);
+                    const stored = isMissing(raw) ? undefined : readSendValue(raw);
+                    if (stored === 'unreadable') {
+                        // Its in-flight index entry, if any, names a player the value no
+                        // longer tells; listInFlightSends skips the missing value.
+                        return {
+                            commands: [
+                                (transaction) => transaction.del(valueKey),
+                                (transaction) => transaction.zRem(keys.changed, [key]),
+                                (transaction) => transaction.zRem(keys.due, [key]),
+                            ],
+                            result: true,
+                        };
+                    }
+                    if (stored === undefined) {
+                        // A stale index entry: drop it from the indexes that hold it by key.
+                        return {
+                            commands: [
+                                (transaction) => transaction.zRem(keys.changed, [key]),
+                                (transaction) => transaction.zRem(keys.due, [key]),
+                            ],
+                            result: false,
+                        };
+                    }
+                    const changedAt = Date.parse(stored.send.changedAt);
+                    if (!(changedAt < sendsBefore)) {
+                        // Not old after all: rescore the index entry to the value's time so
+                        // it stops coming first in every purge. A time that does not parse
+                        // is never purged (as in the in-memory store), so it leaves the index.
+                        return {
+                            commands: [
+                                Number.isNaN(changedAt)
+                                    ? (transaction) => transaction.zRem(keys.changed, [key])
+                                    : (transaction) => transaction.zAdd(keys.changed, { member: key, score: changedAt }),
+                            ],
+                            result: false,
+                        };
+                    }
+                    return {
+                        commands: [
+                            (transaction) => transaction.del(valueKey),
+                            ...sendIndexCommands(key, stored.send, undefined),
+                        ],
+                        result: true,
+                    };
+                });
+                if (deleted) {
+                    sendCount += 1;
+                }
+            }
+            let historyCount = 0;
+            const historyBefore = instantOf(cutoffs.historyBefore);
+            for (const member of await scoreRange(keys.historyAll, '-inf', `(${String(historyBefore)}`, purgeLimit)) {
+                const named = tryParse(member);
+                if (!Array.isArray(named)
+                    || named.length !== 2
+                    || typeof named[0] !== 'string'
+                    || typeof named[1] !== 'string') {
+                    await transact([keys.historyAll], async () => ({
+                        commands: [(transaction) => transaction.zRem(keys.historyAll, [member])],
+                        result: undefined,
+                    }));
+                    continue;
+                }
+                const [player, field] = named;
+                const key = keys.history(player);
+                // The field names the send and provider; the provider's index holds the same member.
+                const fieldNames = tryParse(field);
+                const byProvider = Array.isArray(fieldNames) && typeof fieldNames[1] === 'string'
+                    ? keys.historyByProvider(fieldNames[1])
+                    : undefined;
+                const removed = await transact([key], async () => {
+                    const value = await redis.hGet(key, field);
+                    const entry = isMissing(value) ? undefined : tryParse(value);
+                    const at = typeof entry?.at === 'string' ? Date.parse(entry.at) : Number.NaN;
+                    if (!isMissing(value) && Number.isFinite(at) && at >= historyBefore) {
+                        // Not old after all (never written so): keep the entry, and rescore
+                        // its indexes to its time so it stops coming first in every purge.
+                        return {
+                            commands: [
+                                (transaction) => transaction.zAdd(keys.historyAt(player), { member: field, score: at }),
+                                (transaction) => transaction.zAdd(keys.historyAll, { member, score: at }),
+                                ...(byProvider === undefined
+                                    ? []
+                                    : [(transaction) => transaction.zAdd(byProvider, { member, score: at })]),
+                            ],
+                            result: false,
+                        };
+                    }
+                    return {
+                        commands: [
+                            ...(isMissing(value)
+                                ? []
+                                : [(transaction) => transaction.hDel(key, [field])]),
+                            (transaction) => transaction.zRem(keys.historyAt(player), [field]),
+                            (transaction) => transaction.zRem(keys.historyAll, [member]),
+                            ...(byProvider === undefined
+                                ? []
+                                : [(transaction) => transaction.zRem(byProvider, [member])]),
+                        ],
+                        result: !isMissing(value),
+                    };
+                });
+                if (removed) {
+                    historyCount += 1;
+                }
+            }
+            const before = (at, cutoff) => at !== undefined && Date.parse(at) < Date.parse(cutoff);
+            // Each cutoff reads only the endpoints past it, from its time index.
+            let endpointCount = 0;
+            const pastCutoff = (endpoint) => (endpoint.status === 'invalid' && before(endpoint.invalidatedAt, cutoffs.invalidEndpointsBefore))
+                || before(endpoint.lastRegisteredAt, cutoffs.staleEndpointsBefore)
+                || before(endpoint.sessionExpiresAt, cutoffs.sessionEndpointsBefore);
+            for (const [index, cutoff, timeOf] of [
+                [
+                    keys.endpointsInvalidated,
+                    cutoffs.invalidEndpointsBefore,
+                    (endpoint) => (endpoint.status === 'invalid' ? endpoint.invalidatedAt : undefined),
+                ],
+                [keys.endpointsRegistered, cutoffs.staleEndpointsBefore, (endpoint) => endpoint.lastRegisteredAt],
+                [keys.endpointsSessionEnd, cutoffs.sessionEndpointsBefore, (endpoint) => endpoint.sessionExpiresAt],
+            ]) {
+                const cutoffMs = instantOf(cutoff);
+                const members = await scoreRange(index, '-inf', `(${String(cutoffMs)}`, purgeLimit);
+                for (const member of members) {
+                    const named = tryParse(member);
+                    if (!Array.isArray(named) || typeof named[0] !== 'string' || typeof named[1] !== 'string') {
+                        await transact([index], async () => ({
+                            commands: [(transaction) => transaction.zRem(index, [member])],
+                            result: undefined,
+                        }));
+                        continue;
+                    }
+                    const reindex = (endpoint) => {
+                        const at = timeOf(endpoint);
+                        if (at === undefined) {
+                            return [(transaction) => transaction.zRem(index, [member])];
+                        }
+                        const score = Date.parse(at);
+                        if (Number.isNaN(score)) {
+                            return [(transaction) => transaction.zRem(index, [member])];
+                        }
+                        return [(transaction) => transaction.zAdd(index, { member, score })];
+                    };
+                    if (await removeEndpointIf(named[0], named[1], pastCutoff, [[index, member]], reindex)) {
+                        endpointCount += 1;
+                    }
+                }
+            }
+            return { sends: sendCount, history: historyCount, endpoints: endpointCount };
+        },
+    };
+}
+/** Epoch milliseconds of a time; one that does not parse is a caller error, as in the in-memory store. */
+function instantOf(at) {
+    const millis = Date.parse(at);
+    if (!Number.isFinite(millis)) {
+        throw new TypeError(`Not a timestamp: ${JSON.stringify(at)}`);
+    }
+    return millis;
+}
+/**
+ * Code points as fixed-width hex, so byte order is code-point order (lone
+ * surrogates included, as `Array.from` iterates them).
+ */
+function encodeCodePoints(value) {
+    return Array.from(value, (char) => (char.codePointAt(0) ?? 0).toString(16).padStart(6, '0')).join('');
+}
+function decodeCodePoints(encoded) {
+    if (encoded.length % 6 !== 0 || !/^[0-9a-f]*$/u.test(encoded)) {
+        return undefined;
+    }
+    let value = '';
+    for (let index = 0; index < encoded.length; index += 6) {
+        const codePoint = Number.parseInt(encoded.slice(index, index + 6), 16);
+        if (codePoint > 0x10ffff) {
+            return undefined;
+        }
+        value += String.fromCodePoint(codePoint);
+    }
+    return value;
+}
+/**
+ * A due-index member: the player, `.`, and the id, each as fixed-width code
+ * points. `.` sorts before every hex digit, so equal scores order by player
+ * (a prefix first), then by id, in code-point order.
+ */
+function scheduleMember(player, id) {
+    return `${encodeCodePoints(player)}.${encodeCodePoints(id)}`;
+}
+function readScheduleMember(member) {
+    const [player, id, ...rest] = member.split('.');
+    const decodedPlayer = player === undefined ? undefined : decodeCodePoints(player);
+    const decodedId = id === undefined ? undefined : decodeCodePoints(id);
+    return rest.length > 0 || decodedPlayer === undefined || decodedId === undefined
+        ? undefined
+        : { player: decodedPlayer, id: decodedId };
+}
+/** Up to about 2 ms per attempt, jittered: enough to break lockstep retries. */
+function defaultBackoff(attempt) {
+    const delayMs = Math.random() * 2 * Math.min(attempt, 8);
+    return new Promise((resolve) => {
+        setTimeout(resolve, delayMs);
+    });
+}
+/** A missing key, field, or member: `@devvit/redis` answers `undefined`, a classic client `null`. */
+function isMissing(value) {
+    return value === undefined || value === null;
+}
+function tryParse(value) {
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parse(value, key) {
+    try {
+        return JSON.parse(value);
+    }
+    catch (error) {
+        throw new Error(`Devvit Redis notification store: ${key} holds a value that is not JSON.`, {
+            cause: error,
+        });
+    }
+}
+function compareText(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+async function bestEffortReset(transaction, multiStarted) {
+    try {
+        if (multiStarted) {
+            await transaction.discard();
+        }
+        else {
+            await transaction.unwatch();
+        }
+    }
+    catch {
+        // Keep the original Redis failure; this cleanup is best-effort.
+    }
+}