@dereekb/discord 14.0.1 → 14.2.0

package/index.esm.js

@@ -1,8 +1,9 @@
-import { lastValue, MS_IN_SECOND } from '@dereekb/util';
-import { fetchPageFactory, FetchResponseError, fetchJsonFunction, returnNullHandleFetchJsonParseErrorFunction, fetchApiFetchService } from '@dereekb/util/fetch';
+import { lastValue, MS_IN_SECOND, oidcClientSecretBasicAuthorizationHeader } from '@dereekb/util';
+import { fetchPageFactory, iterateFetchPages, FetchResponseError, fetchJsonFunction, returnNullHandleFetchJsonParseErrorFunction, fetchApiFetchService } from '@dereekb/util/fetch';
+import { revokeToken as revokeToken$1, exchangeAuthorizationCode as exchangeAuthorizationCode$1, refreshAccessToken as refreshAccessToken$1 } from '@dereekb/util/oidc';
 import { BaseError } from 'make-error';
 
-function _define_property$1(obj, key, value) {
+function _define_property$2(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -13,7 +14,7 @@ function _define_property$1(obj, key, value) {
     } else obj[key] = value;
     return obj;
 }
-function _object_spread(target) {
+function _object_spread$1(target) {
     for(var i = 1; i < arguments.length; i++){
         var source = arguments[i] != null ? arguments[i] : {};
         var ownKeys = Object.keys(source);
@@ -23,12 +24,12 @@ function _object_spread(target) {
             }));
         }
         ownKeys.forEach(function(key) {
-            _define_property$1(target, key, source[key]);
+            _define_property$2(target, key, source[key]);
         });
     }
     return target;
 }
-function ownKeys(object, enumerableOnly) {
+function ownKeys$1(object, enumerableOnly) {
     var keys = Object.keys(object);
     if (Object.getOwnPropertySymbols) {
         var symbols = Object.getOwnPropertySymbols(object);
@@ -36,11 +37,11 @@ function ownKeys(object, enumerableOnly) {
     }
     return keys;
 }
-function _object_spread_props(target, source) {
+function _object_spread_props$1(target, source) {
     source = source != null ? source : {};
     if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
     else {
-        ownKeys(Object(source)).forEach(function(key) {
+        ownKeys$1(Object(source)).forEach(function(key) {
             Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
         });
     }
@@ -76,13 +77,16 @@ function _object_spread_props(target, source) {
     var readMessageId = (_ref = config === null || config === void 0 ? void 0 : config.readMessageId) !== null && _ref !== void 0 ? _ref : function(message) {
         return message.id;
     };
-    return fetchPageFactory(_object_spread_props(_object_spread({}, defaults), {
+    return fetchPageFactory(_object_spread_props$1(_object_spread$1({}, defaults), {
         fetch: fetch,
-        readFetchPageResultInfo: function readFetchPageResultInfo(result) {
+        readFetchPageResultInfo: function readFetchPageResultInfo(result, input, options) {
+            var _ref, _options_maxItemsPerPage;
             var count = result.data.length;
             var nextCursor = count > 0 ? readMessageId(lastValue(result.data)) : undefined;
+            // read the effective limit the same way buildInputForNextPage does, so a short page reports hasNext: false
+            var effectiveLimit = (_ref = (_options_maxItemsPerPage = options.maxItemsPerPage) !== null && _options_maxItemsPerPage !== void 0 ? _options_maxItemsPerPage : input.limit) !== null && _ref !== void 0 ? _ref : DEFAULT_DISCORD_MESSAGES_PER_PAGE;
             return {
-                hasNext: count > 0,
+                hasNext: count >= effectiveLimit,
                 nextPageCursor: nextCursor
             };
         },
@@ -97,7 +101,7 @@ function _object_spread_props(target, source) {
             if (!nextCursor || resultCount < effectiveLimit) {
                 nextInput = undefined;
             } else {
-                nextInput = _object_spread_props(_object_spread({}, input), {
+                nextInput = _object_spread_props$1(_object_spread$1({}, input), {
                     before: nextCursor,
                     after: undefined,
                     around: undefined,
@@ -109,6 +113,451 @@ function _object_spread_props(target, source) {
     }));
 }
 
+/**
+ * The Discord epoch, the first second of 2015, expressed as a unix timestamp in milliseconds.
+ *
+ * Every snowflake encodes its creation time as an offset from this value.
+ */ var DISCORD_EPOCH_MS = 1420070400000;
+/**
+ * The number of low bits in a snowflake reserved for the worker id, process id, and increment.
+ *
+ * The timestamp occupies every bit above these.
+ */ var DISCORD_SNOWFLAKE_TIMESTAMP_SHIFT = 22n;
+/**
+ * Returns the creation time encoded in the input snowflake.
+ *
+ * The arithmetic is performed with BigInt: a snowflake exceeds 53 bits, so the naive
+ * `Number(snowflake) >> 22` coerces to a 32-bit integer and returns a time near the Discord
+ * epoch for every modern id.
+ *
+ * @param snowflake - The snowflake id to read the timestamp from.
+ * @returns The Date the snowflake was created at.
+ *
+ * @example
+ * ```ts
+ * discordSnowflakeToDate('1480401620608090182'); // 2026-03-09T03:07:30.885Z
+ * ```
+ */ function discordSnowflakeToDate(snowflake) {
+    var timestamp = (BigInt(snowflake) >> DISCORD_SNOWFLAKE_TIMESTAMP_SHIFT) + BigInt(DISCORD_EPOCH_MS);
+    return new Date(Number(timestamp));
+}
+/**
+ * Returns the lowest snowflake id that could have been created at the input date.
+ *
+ * Useful as a `before`/`after` pagination bound: an id built this way sorts before every real
+ * message created in the same millisecond, so it can bound a scan by time without knowing any
+ * actual message id.
+ *
+ * @param date - The date to build a snowflake bound for.
+ * @returns The lowest snowflake id for that millisecond.
+ *
+ * @example
+ * ```ts
+ * const twoWeeksAgo = discordSnowflakeForDate(addDays(new Date(), -14));
+ * ```
+ */ function discordSnowflakeForDate(date) {
+    var offset = BigInt(date.getTime()) - BigInt(DISCORD_EPOCH_MS);
+    var snowflake = offset > 0n ? offset << DISCORD_SNOWFLAKE_TIMESTAMP_SHIFT : 0n;
+    return snowflake.toString();
+}
+/**
+ * Compares two snowflakes by their numeric value.
+ *
+ * Compared as BigInt values rather than strings: a plain string comparison is only correct for
+ * ids of equal length, and snowflake ids grow a digit over time.
+ *
+ * @param a - The first snowflake.
+ * @param b - The second snowflake.
+ * @returns A negative number when a is older than b, a positive number when a is newer, and 0 when equal.
+ */ function compareDiscordSnowflakes(a, b) {
+    var aValue = BigInt(a);
+    var bValue = BigInt(b);
+    var result;
+    if (aValue < bValue) {
+        result = -1;
+    } else if (aValue > bValue) {
+        result = 1;
+    } else {
+        result = 0;
+    }
+    return result;
+}
+/**
+ * Returns true if snowflake a was created after snowflake b.
+ *
+ * @param a - The snowflake to test.
+ * @param b - The snowflake to test against.
+ * @returns True when a is strictly newer than b.
+ *
+ * @example
+ * ```ts
+ * discordSnowflakeIsAfter('1480401620608090182', '1480401620608090181'); // true
+ * ```
+ */ function discordSnowflakeIsAfter(a, b) {
+    return BigInt(a) > BigInt(b);
+}
+
+function asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator$2(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$2(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _define_property$1(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else obj[key] = value;
+    return obj;
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property$1(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _ts_generator$2(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+/**
+ * Creates a {@link DiscordScanMessagesFunction} that walks a channel's messages backwards in time
+ * and hands each page to a caller-supplied handler.
+ *
+ * The scan is persistence-agnostic: it knows nothing about where a cursor is stored. It walks from
+ * `beforeMessageId` (or the newest message) back towards `afterMessageId` (or the start of the
+ * channel), stops as soon as a budget is exhausted, and reports where it stopped so the caller can
+ * resume from exactly there.
+ *
+ * @param config - The fetch function and scan defaults.
+ * @returns A scan function.
+ *
+ * @example
+ * ```ts
+ * const scan = discordScanMessagesFactory({ fetch: fetchChannelMessages });
+ *
+ * const result = await scan({
+ *   baseInput: { channelId },
+ *   afterMessageId: lastScannedMessageId,
+ *   maxMessages: 1000,
+ *   handleMessages: async ({ messages }) => saveMessages(messages)
+ * });
+ *
+ * if (result.complete) {
+ *   lastScannedMessageId = result.newestMessageId ?? lastScannedMessageId;
+ * }
+ * ```
+ */ function discordScanMessagesFactory(config) {
+    var fetch = config.fetch, inputReadMessageId = config.readMessageId, defaults = config.defaults, inputNowFactory = config.nowFactory;
+    var readMessageId = inputReadMessageId !== null && inputReadMessageId !== void 0 ? inputReadMessageId : function(message) {
+        return message.id;
+    };
+    var nowFactory = inputNowFactory !== null && inputNowFactory !== void 0 ? inputNowFactory : function() {
+        return new Date();
+    };
+    return function(input) {
+        return _async_to_generator$2(function() {
+            var _ref, _input_messagesPerPage, _input_maxPages, _input_maxMessages, _input_maxDuration, _input_waitBetweenPages, baseInput, beforeMessageId, afterMessageId, filterMessages, handleMessages, messagesPerPage, maxPages, maxMessages, maxDuration, waitBetweenPages, fetchPageFactory, startedAt, totalPages, totalMessagesLoaded, totalMessagesHandled, newestMessageId, resumeBeforeMessageId, reachedStopBound, reachedChannelStart, reachedMaxMessages, reachedTimeBudget, pageInput, iterateResult, stopReason, result;
+            return _ts_generator$2(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        baseInput = input.baseInput, beforeMessageId = input.beforeMessageId, afterMessageId = input.afterMessageId, filterMessages = input.filterMessages, handleMessages = input.handleMessages;
+                        messagesPerPage = (_ref = (_input_messagesPerPage = input.messagesPerPage) !== null && _input_messagesPerPage !== void 0 ? _input_messagesPerPage : defaults === null || defaults === void 0 ? void 0 : defaults.messagesPerPage) !== null && _ref !== void 0 ? _ref : DEFAULT_DISCORD_MESSAGES_PER_PAGE;
+                        maxPages = (_input_maxPages = input.maxPages) !== null && _input_maxPages !== void 0 ? _input_maxPages : defaults === null || defaults === void 0 ? void 0 : defaults.maxPages;
+                        maxMessages = (_input_maxMessages = input.maxMessages) !== null && _input_maxMessages !== void 0 ? _input_maxMessages : defaults === null || defaults === void 0 ? void 0 : defaults.maxMessages;
+                        maxDuration = (_input_maxDuration = input.maxDuration) !== null && _input_maxDuration !== void 0 ? _input_maxDuration : defaults === null || defaults === void 0 ? void 0 : defaults.maxDuration;
+                        waitBetweenPages = (_input_waitBetweenPages = input.waitBetweenPages) !== null && _input_waitBetweenPages !== void 0 ? _input_waitBetweenPages : defaults === null || defaults === void 0 ? void 0 : defaults.waitBetweenPages;
+                        // the page factory reads the same messagesPerPage everywhere, so the first page and every page
+                        // after it use one limit and short-page detection stays honest
+                        fetchPageFactory = discordFetchMessagePageFactory({
+                            fetch: fetch,
+                            config: {
+                                readMessageId: readMessageId
+                            },
+                            defaults: {
+                                defaultMaxItemsPerPage: messagesPerPage
+                            }
+                        });
+                        startedAt = nowFactory();
+                        totalPages = 0;
+                        totalMessagesLoaded = 0;
+                        totalMessagesHandled = 0;
+                        reachedStopBound = false;
+                        reachedChannelStart = false;
+                        reachedMaxMessages = false;
+                        reachedTimeBudget = false;
+                        pageInput = _object_spread_props(_object_spread({}, baseInput), {
+                            before: beforeMessageId !== null && beforeMessageId !== void 0 ? beforeMessageId : undefined,
+                            after: undefined,
+                            around: undefined,
+                            limit: messagesPerPage
+                        });
+                        return [
+                            4,
+                            iterateFetchPages({
+                                input: pageInput,
+                                fetchPageFactory: fetchPageFactory,
+                                // maxPage is the max page INDEX, so a page count of N is an index of N - 1
+                                maxPage: maxPages == null ? null : Math.max(0, maxPages - 1),
+                                maxItemsPerPage: messagesPerPage,
+                                maxParallelPages: 1,
+                                waitBetweenPages: waitBetweenPages !== null && waitBetweenPages !== void 0 ? waitBetweenPages : undefined,
+                                iteratePage: function iteratePage(fetchPageResult) {
+                                    return _async_to_generator$2(function() {
+                                        var raw, _ref, bounded, stopBoundIndex, messages;
+                                        return _ts_generator$2(this, function(_state) {
+                                            switch(_state.label){
+                                                case 0:
+                                                    raw = fetchPageResult.result.data;
+                                                    totalPages += 1;
+                                                    totalMessagesLoaded += raw.length;
+                                                    if (raw.length < messagesPerPage) {
+                                                        reachedChannelStart = true; // a short page means there is nothing older to load
+                                                    }
+                                                    if (!(raw.length > 0)) return [
+                                                        3,
+                                                        3
+                                                    ];
+                                                    newestMessageId = newestMessageId !== null && newestMessageId !== void 0 ? newestMessageId : readMessageId(raw[0]);
+                                                    // the OLDEST RAW message, so filtered-out messages are stepped past rather than revisited
+                                                    resumeBeforeMessageId = readMessageId(lastValue(raw));
+                                                    bounded = raw;
+                                                    if (afterMessageId != null) {
+                                                        stopBoundIndex = raw.findIndex(function(message) {
+                                                            return !discordSnowflakeIsAfter(readMessageId(message), afterMessageId);
+                                                        });
+                                                        if (stopBoundIndex >= 0) {
+                                                            reachedStopBound = true;
+                                                            bounded = raw.slice(0, stopBoundIndex);
+                                                        }
+                                                    }
+                                                    return [
+                                                        4,
+                                                        filterMessages === null || filterMessages === void 0 ? void 0 : filterMessages(bounded)
+                                                    ];
+                                                case 1:
+                                                    messages = (_ref = _state.sent()) !== null && _ref !== void 0 ? _ref : bounded;
+                                                    if (!(messages.length > 0)) return [
+                                                        3,
+                                                        3
+                                                    ];
+                                                    totalMessagesHandled += messages.length;
+                                                    return [
+                                                        4,
+                                                        handleMessages({
+                                                            messages: messages,
+                                                            newestMessageId: readMessageId(messages[0]),
+                                                            oldestMessageId: readMessageId(lastValue(messages)),
+                                                            page: fetchPageResult.page,
+                                                            totalMessagesHandled: totalMessagesHandled
+                                                        })
+                                                    ];
+                                                case 2:
+                                                    _state.sent();
+                                                    _state.label = 3;
+                                                case 3:
+                                                    if (maxMessages != null && totalMessagesLoaded >= maxMessages) {
+                                                        reachedMaxMessages = true;
+                                                    }
+                                                    if (maxDuration != null && nowFactory().getTime() - startedAt.getTime() >= maxDuration) {
+                                                        reachedTimeBudget = true;
+                                                    }
+                                                    return [
+                                                        2
+                                                    ];
+                                            }
+                                        });
+                                    })();
+                                },
+                                // ordered by priority so the reported stopReason is deterministic. channel_start is what keeps
+                                // the iteration from asking a cursor-based source for a page that does not exist.
+                                endEarly: function endEarly() {
+                                    return reachedStopBound || reachedChannelStart || reachedMaxMessages || reachedTimeBudget;
+                                }
+                            })
+                        ];
+                    case 1:
+                        iterateResult = _state.sent();
+                        if (reachedStopBound) {
+                            stopReason = 'stop_bound';
+                        } else if (reachedChannelStart) {
+                            stopReason = 'channel_start';
+                        } else if (reachedMaxMessages) {
+                            stopReason = 'max_messages';
+                        } else if (reachedTimeBudget) {
+                            stopReason = 'time_budget';
+                        } else if (iterateResult.totalPagesLimitReached) {
+                            stopReason = 'max_pages';
+                        } else {
+                            stopReason = 'channel_start'; // the page source reported it had no further pages
+                        }
+                        result = {
+                            stopReason: stopReason,
+                            complete: stopReason === 'stop_bound' || stopReason === 'channel_start',
+                            newestMessageId: newestMessageId,
+                            resumeBeforeMessageId: resumeBeforeMessageId,
+                            totalPages: totalPages,
+                            totalMessagesLoaded: totalMessagesLoaded,
+                            totalMessagesHandled: totalMessagesHandled,
+                            startedAt: startedAt,
+                            endedAt: nowFactory()
+                        };
+                        return [
+                            2,
+                            result
+                        ];
+                }
+            });
+        })();
+    };
+}
+
 /**
  * The Discord REST API base, pinned to a version.
  *
@@ -150,46 +599,191 @@ function _object_spread_props(target, source) {
 /**
  * The Discord OAuth2 token revocation endpoint path, relative to {@link DISCORD_API_URL}.
  */ var DISCORD_OAUTH_REVOKE_PATH = '/oauth2/token/revoke';
+/**
+ * How this client authenticates itself at Discord's token and revocation endpoints.
+ *
+ * Discord's discovery document omits `token_endpoint_auth_methods_supported`, whose OIDC Discovery
+ * default is `client_secret_basic` — and Discord does in fact require Basic, rejecting the
+ * credentials-in-body form the OAuth relying-party layer otherwise defaults to.
+ */ var DISCORD_OAUTH_CLIENT_AUTH_METHOD = 'client_secret_basic';
+/**
+ * Discord's OIDC issuer.
+ *
+ * `https://discord.com/.well-known/openid-configuration` resolves against it, though this package
+ * does not perform discovery — the endpoint paths above are stable, so the extra round trip buys
+ * nothing. Exported for consumers that do want to discover.
+ */ var DISCORD_OIDC_ISSUER = 'https://discord.com';
 /**
  * Path of the endpoint returning the user an access token belongs to.
  *
  * Requires the `identify` scope.
  */ var DISCORD_OAUTH_CURRENT_USER_PATH = '/users/@me';
 
+function asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) resolve(value);
+    else Promise.resolve(value).then(_next, _throw);
+}
+function _async_to_generator$1(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep$1(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator$1(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
 /**
  * The `Content-Type` Discord's token endpoint requires.
  *
  * Discord rejects a JSON body outright, unlike Cal.com, which requires one.
  *
- * `@dereekb/util/oidc`'s `postTokenEndpoint` is the in-workspace precedent for this form-encoded
- * shape and is deliberately NOT reused: its `exchangeAuthorizationCode` requires a PKCE
- * `code_verifier`, it authenticates with `client_secret_post` rather than Basic, and it is
- * discovery-driven. Discord is not an OIDC provider — there is no discovery document and no
- * `id_token`.
+ * Discord IS an OIDC provider, contrary to what this file previously claimed. Verified directly:
+ * `https://discord.com/.well-known/openid-configuration` returns 200 with every required discovery
+ * field, `https://discord.com/api/oauth2/keys` serves a JWKS, and the `openid` scope yields an
+ * `id_token` on the authorization-code grant. The relying-party calls below therefore delegate to
+ * `@dereekb/util/oidc`, passing `clientAuth: 'client_secret_basic'` (Discord's discovery document
+ * omits `token_endpoint_auth_methods_supported`, whose OIDC Discovery default is Basic — which is
+ * what Discord in fact requires).
+ *
+ * Discovery itself is not performed: the endpoints are stable, and skipping the extra round trip
+ * keeps the per-request cost the same as before.
  */ var DISCORD_OAUTH_TOKEN_CONTENT_TYPE = 'application/x-www-form-urlencoded';
 /**
  * Builds the HTTP Basic `Authorization` header value that authenticates the OAuth client.
  *
- * Discord accepts the client credentials as Basic auth rather than in the request body, which is why
+ * Discord requires the client credentials as Basic auth rather than in the request body, which is why
  * `client_id` / `client_secret` are absent from the exchange body below.
  *
- * Uses `btoa()` rather than `Buffer`, so this package stays usable outside Node — the same choice
- * `@dereekb/util`'s PKCE helpers make.
+ * A thin alias of the generic {@link oidcClientSecretBasicAuthorizationHeader}, kept because the
+ * configured fetch bakes the header into its `baseRequest` and so needs it as a value, not as a
+ * per-request auth mode.
  *
  * @param config - The client credentials to encode.
  * @returns The `Authorization` header value, including the `Basic ` prefix.
  *
  * @__NO_SIDE_EFFECTS__
  */ function discordOAuthBasicAuthorizationHeader(config) {
-    var credentials = "".concat(config.clientId, ":").concat(config.clientSecret);
-    return "Basic ".concat(btoa(credentials));
+    return oidcClientSecretBasicAuthorizationHeader(config);
 }
 /**
  * Exchanges an OAuth authorization code for access and refresh tokens.
  *
- * Discord requires `application/x-www-form-urlencoded` — a JSON body is rejected — and authenticates
- * the client with HTTP Basic rather than credentials in the body. Both differ from Cal.com, which
- * posts JSON with the credentials inline. The Basic header rides on the context's configured fetch.
+ * Delegates to `@dereekb/util/oidc`'s relying-party `exchangeAuthorizationCode` with
+ * `clientAuth: 'client_secret_basic'`, which produces exactly the form-encoded, Basic-authenticated
+ * request Discord requires. The context's configured fetch supplies the base URL and surfaces
+ * Discord's RFC-6749 error bodies as typed {@link DiscordOAuthError}s.
  *
  * @param context - The Discord OAuth context providing the authenticated fetch.
  * @returns Exchanges an authorization code for access and refresh tokens.
@@ -205,16 +799,33 @@ function _object_spread_props(target, source) {
  * ```
  */ function exchangeAuthorizationCode(context) {
     return function(input) {
-        var body = new URLSearchParams({
-            grant_type: 'authorization_code',
-            code: input.code,
-            redirect_uri: input.redirectUri
-        });
-        var fetchJsonInput = {
-            method: 'POST',
-            body: body.toString()
-        };
-        return context.fetchJson(DISCORD_OAUTH_TOKEN_PATH, fetchJsonInput);
+        return _async_to_generator$1(function() {
+            var response;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            exchangeAuthorizationCode$1({
+                                fetch: context.fetch,
+                                tokenEndpoint: DISCORD_OAUTH_TOKEN_PATH,
+                                clientId: context.config.clientId,
+                                clientSecret: context.config.clientSecret,
+                                clientAuth: DISCORD_OAUTH_CLIENT_AUTH_METHOD,
+                                redirectUri: input.redirectUri,
+                                code: input.code,
+                                codeVerifier: input.codeVerifier
+                            })
+                        ];
+                    case 1:
+                        response = _state.sent();
+                        return [
+                            2,
+                            response
+                        ];
+                }
+            });
+        })();
     };
 }
 /**
@@ -233,15 +844,55 @@ function _object_spread_props(target, source) {
  * @see https://docs.discord.com/developers/topics/oauth2
  */ function refreshAccessToken(context) {
     return function(input) {
-        var body = new URLSearchParams({
-            grant_type: 'refresh_token',
-            refresh_token: input.refreshToken
+        return _async_to_generator$1(function() {
+            var response;
+            return _ts_generator$1(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            refreshAccessToken$1({
+                                fetch: context.fetch,
+                                tokenEndpoint: DISCORD_OAUTH_TOKEN_PATH,
+                                clientId: context.config.clientId,
+                                clientSecret: context.config.clientSecret,
+                                clientAuth: DISCORD_OAUTH_CLIENT_AUTH_METHOD,
+                                refreshToken: input.refreshToken
+                            })
+                        ];
+                    case 1:
+                        response = _state.sent();
+                        return [
+                            2,
+                            response
+                        ];
+                }
+            });
+        })();
+    };
+}
+/**
+ * Revokes an access or refresh token, ending Discord's side of the authorization.
+ *
+ * Called when a user disconnects their Discord account: deleting the stored credentials alone leaves
+ * the grant live on Discord, so the token stays usable by anyone who captured it.
+ *
+ * @param context - The Discord OAuth context providing the authenticated fetch.
+ * @returns Revokes the given token.
+ *
+ * @see https://docs.discord.com/developers/topics/oauth2
+ */ function revokeToken(context) {
+    return function(input) {
+        var _input_tokenTypeHint;
+        return revokeToken$1({
+            fetch: context.fetch,
+            revocationEndpoint: DISCORD_OAUTH_REVOKE_PATH,
+            clientId: context.config.clientId,
+            clientSecret: context.config.clientSecret,
+            clientAuth: DISCORD_OAUTH_CLIENT_AUTH_METHOD,
+            token: input.token,
+            tokenTypeHint: (_input_tokenTypeHint = input.tokenTypeHint) !== null && _input_tokenTypeHint !== void 0 ? _input_tokenTypeHint : undefined
         });
-        var fetchJsonInput = {
-            method: 'POST',
-            body: body.toString()
-        };
-        return context.fetchJson(DISCORD_OAUTH_TOKEN_PATH, fetchJsonInput);
     };
 }
 /**
@@ -274,11 +925,16 @@ function _object_spread_props(target, source) {
  * A runtime list rather than a bare type union, so a configured scope can be validated instead of
  * being passed through to the consent screen and refused there.
  *
- * Deliberately NOT Discord's full ~40-scope surface: only what a per-user account connect can
- * legitimately ask for. Add a scope here when code actually uses it.
+ * Deliberately NOT Discord's full ~40-scope surface: only what a per-user account connect or sign-in
+ * can legitimately ask for. Add a scope here when code actually uses it.
+ *
+ * `openid` is included because Discord is an OIDC provider (its discovery document and JWKS are
+ * live) and requesting it yields an `id_token`. Nothing in this workspace consumes that token —
+ * identity is read server-side from `/users/@me` — but the scope is legal to request.
  *
  * @see https://docs.discord.com/developers/topics/oauth2
  */ var ALL_DISCORD_OAUTH_SCOPES = [
+    'openid',
     'identify',
     'email',
     'guilds',
@@ -301,6 +957,12 @@ function _object_spread_props(target, source) {
 /**
  * The `response_type` used by the authorization-code flow.
  */ var DISCORD_OAUTH_AUTHORIZE_RESPONSE_TYPE = 'code';
+/**
+ * The only PKCE challenge method this package emits.
+ *
+ * `plain` is not offered: it provides no protection against an attacker who can read the
+ * authorization request, which is the threat PKCE exists to address.
+ */ var DISCORD_OAUTH_AUTHORIZE_CODE_CHALLENGE_METHOD = 'S256';
 /**
  * Creates a {@link DiscordOAuthAuthorizeUrlFactory} that composes the Discord authorize URL a user's
  * browser is redirected to in order to begin the authorization-code flow.
@@ -321,7 +983,7 @@ function _object_spread_props(target, source) {
  *   scopes: ['identify']
  * });
  *
- * const url = authorizeUrlFactory({ state: 'signed-state' });
+ * const url = authorizeUrlFactory({ state: 'signed-state', codeChallenge: 's256-challenge' });
  * ```
  *
  * @__NO_SIDE_EFFECTS__
@@ -339,6 +1001,10 @@ function _object_spread_props(target, source) {
         if (state != null) {
             url.searchParams.set('state', state);
         }
+        if ((params === null || params === void 0 ? void 0 : params.codeChallenge) != null) {
+            url.searchParams.set('code_challenge', params.codeChallenge);
+            url.searchParams.set('code_challenge_method', DISCORD_OAUTH_AUTHORIZE_CODE_CHALLENGE_METHOD);
+        }
         return url.toString();
     };
 }
@@ -770,4 +1436,4 @@ var logDiscordOAuthErrorToConsole = logDiscordOAuthErrorFunction('DiscordOAuth')
     };
 }
 
-export { ALL_DISCORD_OAUTH_SCOPES, DEFAULT_DISCORD_MESSAGES_PER_PAGE, DISCORD_API_URL, DISCORD_OAUTH_AUTHORIZE_RESPONSE_TYPE, DISCORD_OAUTH_AUTHORIZE_URL, DISCORD_OAUTH_CURRENT_USER_PATH, DISCORD_OAUTH_INVALID_GRANT_ERROR_CODE, DISCORD_OAUTH_INVALID_SCOPE_ERROR_CODE, DISCORD_OAUTH_REVOKE_PATH, DISCORD_OAUTH_SCOPE_DELIMITER, DISCORD_OAUTH_TOKEN_CONTENT_TYPE, DISCORD_OAUTH_TOKEN_PATH, DiscordOAuthError, DiscordOAuthFetchResponseError, discordAccessTokenFromTokenResponse, discordFetchMessagePageFactory, discordOAuthAuthorizeUrlFactory, discordOAuthBasicAuthorizationHeader, discordOAuthFactory, exchangeAuthorizationCode, handleDiscordOAuthErrorFetch, isDiscordOAuthScope, logDiscordOAuthErrorFunction, logDiscordOAuthErrorToConsole, parseDiscordOAuthError, readCurrentUser, refreshAccessToken };
+export { ALL_DISCORD_OAUTH_SCOPES, DEFAULT_DISCORD_MESSAGES_PER_PAGE, DISCORD_API_URL, DISCORD_EPOCH_MS, DISCORD_OAUTH_AUTHORIZE_CODE_CHALLENGE_METHOD, DISCORD_OAUTH_AUTHORIZE_RESPONSE_TYPE, DISCORD_OAUTH_AUTHORIZE_URL, DISCORD_OAUTH_CLIENT_AUTH_METHOD, DISCORD_OAUTH_CURRENT_USER_PATH, DISCORD_OAUTH_INVALID_GRANT_ERROR_CODE, DISCORD_OAUTH_INVALID_SCOPE_ERROR_CODE, DISCORD_OAUTH_REVOKE_PATH, DISCORD_OAUTH_SCOPE_DELIMITER, DISCORD_OAUTH_TOKEN_CONTENT_TYPE, DISCORD_OAUTH_TOKEN_PATH, DISCORD_OIDC_ISSUER, DISCORD_SNOWFLAKE_TIMESTAMP_SHIFT, DiscordOAuthError, DiscordOAuthFetchResponseError, compareDiscordSnowflakes, discordAccessTokenFromTokenResponse, discordFetchMessagePageFactory, discordOAuthAuthorizeUrlFactory, discordOAuthBasicAuthorizationHeader, discordOAuthFactory, discordScanMessagesFactory, discordSnowflakeForDate, discordSnowflakeIsAfter, discordSnowflakeToDate, exchangeAuthorizationCode, handleDiscordOAuthErrorFetch, isDiscordOAuthScope, logDiscordOAuthErrorFunction, logDiscordOAuthErrorToConsole, parseDiscordOAuthError, readCurrentUser, refreshAccessToken, revokeToken };