matrix-js-sdk 42.4.0 → 43.0.0

package/src/matrixrtc/types.ts

@@ -15,8 +15,14 @@ limitations under the License.
 */
 import type { IContent, IMentions } from "../matrix.ts";
 import type { RelationEvent } from "../types.ts";
-import type { CallMembership } from "./CallMembership.ts";
+import type { MatrixEvent } from "../models/event.ts";
+import type { Room } from "../models/room.ts";
+import { EventTimeline } from "../models/event-timeline.ts";
+import { EventType, RelationType } from "../@types/event.ts";
+import { CallMembership } from "./CallMembership.ts";
 import { type CallMembershipIdentityParts } from "./EncryptionManager.ts";
+import { isLeftMembershipContent } from "./membershipData/index.ts";
+import { isSlotOpen, slotIdToDescription } from "./utils.ts";
 
 export type EncryptionKeyMapKey = string;
 
@@ -106,35 +112,323 @@ export type RTCNotificationType = "ring" | "notification";
 export type RTCCallIntent = "audio" | "video" | string;
 
 /**
- * This will check if the content has all the expected fields to be a valid IRTCNotificationContent.
- * It will also cap the lifetime to 90000ms (1.5 min) if a higher value is provided.
- * @param content
- * @throws if the content is invalid
- * @returns a parsed IRTCNotificationContent
+ * The maximum `lifetime` of an RTC notification as per MSC4075. Larger values are capped to this.
+ *
+ * Exported for use within the js-sdk only. Not re-exported from `matrixrtc/index.ts`.
+ * @internal
  */
-export function parseCallNotificationContent(content: IContent): IRTCNotificationContent {
-    if (content["m.mentions"] && typeof content["m.mentions"] !== "object") {
-        throw new Error("malformed m.mentions");
+export const RTC_NOTIFICATION_MAX_LIFETIME_MS = 2 * 60 * 1000; // 2 minutes
+
+/**
+ * The maximum amount by which a notification's `sender_ts` may lie ahead of its `origin_server_ts`
+ * before the `lifetime` is measured from `origin_server_ts` instead, as per MSC4075.
+ *
+ * Exported for use within the js-sdk only. Not re-exported from `matrixrtc/index.ts`.
+ * @internal
+ */
+export const RTC_NOTIFICATION_MAX_SENDER_TS_AHEAD_MS = 20 * 1000; // 20 seconds
+
+/**
+ * The context that is needed to evaluate the MSC4075 rules for receiving notifications.
+ */
+export interface RTCNotificationValidationContext {
+    /** The room in which the notification was received. */
+    room: Pick<
+        Room,
+        "getLiveTimeline" | "getUnfilteredTimelineSet" | "_unstable_getStickyEvents" | "_unstable_getKeyedStickyEvent"
+    >;
+    /** The user ID of the receiving (local) user. */
+    userId: string;
+    /** The current time in milliseconds since the epoch. Defaults to `Date.now()`. */
+    now?: number;
+}
+
+/**
+ * Computes the absolute timestamp at which an RTC notification stops being valid, as per MSC4075.
+ *
+ * The `lifetime` is measured from `sender_ts` unless `sender_ts` lies more than 20 seconds ahead of
+ * `origin_server_ts`, in which case it is measured from `origin_server_ts` instead. Regardless of the basis,
+ * the remaining lifetime is capped at 2 minutes.
+ *
+ * @param content The notification content.
+ * @param originServerTs The `origin_server_ts` of the notification event.
+ * @param now The current time in milliseconds since the epoch. Defaults to `Date.now()`.
+ * @returns The timestamp (in milliseconds since the epoch) at which the notification expires.
+ */
+export function getCallNotificationExpiry(
+    content: Pick<IRTCNotificationContent, "sender_ts" | "lifetime">,
+    originServerTs: number,
+    now: number = Date.now(),
+): number {
+    const basis =
+        content.sender_ts - originServerTs > RTC_NOTIFICATION_MAX_SENDER_TS_AHEAD_MS
+            ? originServerTs
+            : content.sender_ts;
+    return Math.min(basis + content.lifetime, now + RTC_NOTIFICATION_MAX_LIFETIME_MS);
+}
+
+/**
+ * The subset of a notification event that {@link parseCallNotificationContent} needs.
+ */
+type RTCNotificationEvent = Pick<
+    MatrixEvent,
+    "getContent" | "getId" | "getSender" | "getTs" | "getType" | "unstableStickyInfo"
+>;
+
+/**
+ * Whether the content marks a withdrawn sticky event (MSC4354), i.e. it is empty apart from the sticky key.
+ */
+function isWithdrawal(content: IContent): boolean {
+    return Object.keys(content).every((key) => key === "msc4354_sticky_key");
+}
+
+function isNonNegativeInteger(value: unknown): value is number {
+    return Number.isInteger(value) && (value as number) >= 0;
+}
+
+/**
+ * Looks up a legacy `m.call.member` state event by ID in the room's current state.
+ *
+ * @returns The event, or `undefined` if no current membership state event has that ID.
+ */
+function findMembershipStateEvent(
+    room: RTCNotificationValidationContext["room"],
+    eventId: string,
+): MatrixEvent | undefined {
+    const roomState = room.getLiveTimeline().getState(EventTimeline.FORWARDS);
+    return roomState?.getStateEvents(EventType.GroupCallMemberPrefix).find((event) => event.getId() === eventId);
+}
+
+/**
+ * Determines the ID of the slot that a notification invites to.
+ *
+ * Notifications predating the `slot_id` property instead carry an `m.reference` relation to the sender's
+ * membership event.
+ *
+ * @throws if the slot can't be determined.
+ * @returns A promise resolving to the slot ID.
+ */
+async function resolveSlotId(content: IContent, room: RTCNotificationValidationContext["room"]): Promise<string> {
+    if (typeof content["slot_id"] === "string") {
+        // Throws if the ID is malformed, e.g. because it contains more than one "#".
+        slotIdToDescription(content["slot_id"]);
+        return content["slot_id"];
+    }
+    if (content["slot_id"] !== undefined) throw new Error("Invalid slot_id");
+
+    const relation = content["m.relates_to"];
+    const membershipEventId = relation?.rel_type === RelationType.Reference ? relation.event_id : undefined;
+    if (typeof membershipEventId !== "string") {
+        throw new Error("Missing slot_id and no m.reference relation to derive it from");
+    }
+
+    const membershipEvent = findMembershipStateEvent(room, membershipEventId);
+    if (!membershipEvent) {
+        throw new Error(`Missing slot_id and referenced event ${membershipEventId} is not a current membership`);
     }
-    if (typeof content["notification_type"] !== "string") {
-        throw new Error("Missing or invalid notification_type");
+
+    try {
+        return (await CallMembership.parseFromEvent(membershipEvent)).slotId;
+    } catch (cause) {
+        throw new Error(`Missing slot_id and referenced event ${membershipEventId} is not a valid membership`, {
+            cause,
+        });
+    }
+}
+
+/**
+ * Parses the content of a received `org.matrix.msc4075.rtc.notification` event.
+ *
+ * This checks that the content matches the schema of MSC4075, caps `lifetime` to 2 minutes and applies
+ * the rules for receiving invites from MSC4075.
+ * The notification is only considered valid if all of the following hold:
+ * - It wasn't sent by the receiving user.
+ * - It is the current entry in the room's sticky event map for its sender and slot and isn't a withdrawal.
+ * - The slot it refers to exists and is open.
+ * - Its lifetime hasn't elapsed (see {@link getCallNotificationExpiry}).
+ * - Its `m.mentions` target the receiving user, either directly or via a room mention that the sender is
+ *   allowed to trigger.
+ * - The receiving user has no joined `m.rtc.member` event for the slot in the sticky event map.
+ * - Any left `m.rtc.member` event of the receiving user for the slot predates the notification.
+ * - The receiving user has no sticky decline event referencing the notification.
+ *
+ * @param event The notification event.
+ * @param context The context needed to evaluate the receiving rules.
+ * @throws if the content is malformed or the notification isn't valid.
+ * @returns A promise resolving to the parsed content.
+ */
+export async function parseCallNotificationContent(
+    event: RTCNotificationEvent,
+    context: RTCNotificationValidationContext,
+): Promise<IRTCNotificationContent> {
+    if (event.getType() !== EventType.RTCNotification) {
+        throw new Error(`Event ${event.getId()} is not an ${EventType.RTCNotification} event`);
     }
-    if (typeof content["sender_ts"] !== "number") {
+
+    const content = event.getContent();
+    if (isWithdrawal(content)) {
+        throw new Error("Notification was withdrawn");
+    }
+
+    const slotId = await resolveSlotId(content, context.room);
+    // The sticky key is only validated when present. A notification predating it can still be valid, and one
+    // carrying the wrong key is filed under that key in the sticky event map, so the lookup below rejects it.
+    if (content["msc4354_sticky_key"] !== undefined && content["msc4354_sticky_key"] !== slotId) {
+        throw new Error("msc4354_sticky_key must be equal to slot_id");
+    }
+    if (!isNonNegativeInteger(content["sender_ts"])) {
         throw new Error("Missing or invalid sender_ts");
     }
-    if (typeof content["lifetime"] !== "number") {
+    if (!isNonNegativeInteger(content["lifetime"])) {
         throw new Error("Missing or invalid lifetime");
     }
 
-    if (content["relation"] && content["relation"]["rel_type"] !== "m.reference") {
-        throw new Error("Invalid relation");
+    const mentions = content["m.mentions"];
+    if (typeof mentions !== "object" || mentions === null) {
+        throw new Error("Missing or malformed m.mentions");
+    }
+    if (mentions.room !== undefined && typeof mentions.room !== "boolean") {
+        throw new Error("malformed m.mentions.room");
+    }
+    if (
+        mentions.user_ids !== undefined &&
+        (!Array.isArray(mentions.user_ids) || !mentions.user_ids.every((userId) => typeof userId === "string"))
+    ) {
+        throw new Error("malformed m.mentions.user_ids");
     }
-    if (content["m.call.intent"] && typeof content["m.call.intent"] !== "string") {
-        throw new Error("Invalid m.call.intent");
+    if (mentions.room !== true && !mentions.user_ids?.length) {
+        throw new Error("m.mentions must target either the room or at least one user");
     }
 
-    const cappedLifetime = content["lifetime"] >= 90000 ? 90000 : content["lifetime"];
-    return { ...content, lifetime: cappedLifetime } as IRTCNotificationContent;
+    const parsed = {
+        ...content,
+        slot_id: slotId,
+        lifetime: Math.min(content["lifetime"], RTC_NOTIFICATION_MAX_LIFETIME_MS),
+    } as IRTCNotificationContent;
+
+    await checkCallNotificationReceivingRules(parsed, event, context);
+
+    return parsed;
+}
+
+/**
+ * Applies the MSC4075 rules for receiving invites to an already schema-validated notification.
+ * @throws if any of the rules is violated.
+ */
+async function checkCallNotificationReceivingRules(
+    content: IRTCNotificationContent,
+    event: RTCNotificationEvent,
+    { room, userId, now = Date.now() }: RTCNotificationValidationContext,
+): Promise<void> {
+    const eventId = event.getId();
+    const sender = event.getSender();
+    if (eventId === undefined || sender === undefined) {
+        throw new Error("Notification event is missing its event ID or sender");
+    }
+    const originServerTs = event.getTs();
+    const slotId = content.slot_id;
+
+    if (sender === userId) {
+        throw new Error("Notification was sent by the receiving user");
+    }
+
+    // A notification that wasn't delivered as a sticky event can't be superseded or withdrawn, so there is
+    // nothing to check. It isn't in the sticky event map either, which is why this can't be checked blindly.
+    if (event.unstableStickyInfo !== undefined) {
+        if (room._unstable_getKeyedStickyEvent(sender, event.getType(), slotId)?.getId() !== eventId) {
+            throw new Error("Notification is not the current sticky event for its sender and slot");
+        }
+    }
+
+    // `isSlotOpen` returns undefined when no slot event exists at all, which is just as disqualifying.
+    if (!isSlotOpen(room, slotIdToDescription(slotId))) {
+        throw new Error(`Slot ${slotId} does not exist or is closed`);
+    }
+    const roomState = room.getLiveTimeline().getState(EventTimeline.FORWARDS);
+
+    if (now >= getCallNotificationExpiry(content, originServerTs, now)) {
+        throw new Error("Notification has expired");
+    }
+
+    const mentions = content["m.mentions"];
+    const mentionsUser = mentions.user_ids?.includes(userId) ?? false;
+    const mentionsRoom = mentions.room === true && (roomState?.mayTriggerNotifOfType("room", sender) ?? false);
+    if (!mentionsUser && !mentionsRoom) {
+        throw new Error("Notification does not mention the receiving user");
+    }
+
+    for (const membershipEvent of ownMembershipEvents(room, userId)) {
+        const membershipContent = membershipEvent.getContent();
+        if (isLeftMembershipContent(membershipContent)) {
+            if (membershipContent.slot_id === slotId && membershipEvent.getTs() >= originServerTs) {
+                throw new Error(`Receiving user left slot ${slotId} after the notification was sent`);
+            }
+        } else if (await isJoinedToSlot(membershipEvent, slotId, now)) {
+            throw new Error(`Receiving user is already joined to slot ${slotId}`);
+        }
+    }
+
+    if (hasDeclined(room, userId, eventId)) {
+        throw new Error("Receiving user declined the notification");
+    }
+}
+
+/**
+ * Yields the receiving user's own MatrixRTC membership events, from both the sticky event map and the legacy
+ * member state events. Sessions that don't use sticky events keep membership in state, so both have to be
+ * consulted to tell whether the user is in a session.
+ *
+ * @yields the user's own `m.rtc.member` and `m.call.member` events.
+ */
+function* ownMembershipEvents(room: RTCNotificationValidationContext["room"], userId: string): Iterable<MatrixEvent> {
+    for (const stickyEvent of room._unstable_getStickyEvents()) {
+        if (stickyEvent.getType() === EventType.RTCMembership && stickyEvent.getSender() === userId) {
+            yield stickyEvent;
+        }
+    }
+
+    const roomState = room.getLiveTimeline().getState(EventTimeline.FORWARDS);
+    for (const stateEvent of roomState?.getStateEvents(EventType.GroupCallMemberPrefix) ?? []) {
+        if (stateEvent.getSender() === userId) yield stateEvent;
+    }
+}
+
+/**
+ * Whether the given membership event places its sender in the given slot, i.e. it is a valid, unexpired
+ * membership for that slot.
+ */
+async function isJoinedToSlot(membershipEvent: MatrixEvent, slotId: string, now: number): Promise<boolean> {
+    let membership: CallMembership;
+    try {
+        membership = await CallMembership.parseFromEvent(membershipEvent);
+    } catch {
+        // Not a membership we understand, so it doesn't place the user anywhere.
+        return false;
+    }
+    if (membership.slotId !== slotId) return false;
+
+    // Legacy memberships go stale when the client that sent them disappears without leaving. Honouring an
+    // expired one would suppress notifications for hours.
+    const expiry = membership.getAbsoluteExpiry();
+    return expiry === undefined || expiry > now;
+}
+
+/**
+ * Whether the receiving user has declined the given notification.
+ *
+ * Declines are looked up both through their `m.reference` relation and in the sticky event map. Relations
+ * cover declines that couldn't be sent as sticky events, but only see events that reached the timeline. A
+ * sticky decline delivered after a gappy or initial sync arrives via the sticky section instead, so it is
+ * only in the map.
+ */
+function hasDeclined(room: RTCNotificationValidationContext["room"], userId: string, eventId: string): boolean {
+    const declines = room
+        .getUnfilteredTimelineSet()
+        .relations.getChildEventsForEvent(eventId, RelationType.Reference, EventType.RTCDecline);
+    if (declines?.getRelations().some((decline) => decline.getSender() === userId)) return true;
+
+    // Declines are keyed on the event ID of the notification they decline.
+    return room._unstable_getKeyedStickyEvent(userId, EventType.RTCDecline, eventId) !== undefined;
 }
 
 /**
@@ -142,21 +436,55 @@ export function parseCallNotificationContent(content: IContent): IRTCNotificatio
  * Don't cast event content to this directly. Use `parseCallNotificationContent` instead to validate the content first.
  */
 export interface IRTCNotificationContent extends RelationEvent {
-    "m.mentions"?: IMentions;
-    "notification_type": RTCNotificationType;
     /**
-     * The initial intent of the calling user.
+     * The `state_key` of the `m.rtc.slot` event that the notification refers to.
+     *
+     * Notifications predating this property omit it. `parseCallNotificationContent` fills it in from the
+     * referenced membership event, so the parsed content always carries it.
+     */
+    "slot_id": string;
+    /**
+     * The users targeted by the notification. Must either mention the room or at least one user.
+     */
+    "m.mentions": IMentions;
+    /**
+     * @deprecated Not part of MSC4075 anymore. How to present a notification is up to the receiving client.
+     */
+    "notification_type"?: RTCNotificationType;
+    /**
+     * @deprecated Not part of MSC4075 anymore. The initial intent of the calling user.
      */
     "m.call.intent"?: RTCCallIntent;
+    /**
+     * The timestamp (in milliseconds since the epoch) at which the sending client created the event.
+     */
     "sender_ts": number;
+    /**
+     * The time (in milliseconds) that the notification is valid for, measured from `sender_ts`.
+     */
     "lifetime": number;
+    /**
+     * The sticky key as per MSC4354. Must be equal to `slot_id`.
+     *
+     * Optional because notifications predating MSC4354 omit it.
+     */
+    "msc4354_sticky_key"?: string;
 }
 
 /**
  * MSC4310 decline event content for `org.matrix.msc4310.rtc.decline`.
  * Sent as a standard m.reference relation to an `org.matrix.msc4075.rtc.notification` event.
  */
-export interface IRTCDeclineContent extends RelationEvent {}
+export interface IRTCDeclineContent extends RelationEvent {
+    /**
+     * The sticky key as per MSC4354. Must be equal to the event ID of the notification being declined.
+     *
+     * Optional because servers without MSC4354 support can't deliver the decline as a sticky event. Such a
+     * decline still counts, but only for devices that receive it directly, since it isn't re-delivered after
+     * a gappy or initial sync.
+     */
+    msc4354_sticky_key?: string;
+}
 
 export enum Status {
     Disconnected = "Disconnected",

package/src/matrixrtc/utils.ts

@@ -15,7 +15,10 @@ limitations under the License.
 */
 
 import { getEncryptionKeyMapKey, type CallMembershipIdentityParts } from "./EncryptionManager.ts";
-import type { InboundEncryptionSession, EncryptionKeyMapKey, SlotDescription } from "./types.ts";
+import type { InboundEncryptionSession, EncryptionKeyMapKey, RtcSlotEventContent, SlotDescription } from "./types.ts";
+import type { Room } from "../models/room.ts";
+import { EventTimeline } from "../models/event-timeline.ts";
+import { EventType } from "../@types/event.ts";
 
 /**
  * Detects when a key for a given index is outdated.
@@ -67,3 +70,53 @@ export function slotIdToDescription(slotId: string): SlotDescription {
 export function computeSlotId(slotDescription: SlotDescription): string {
     return `${slotDescription.application}#${slotDescription.id}`;
 }
+
+/**
+ * Reads the slot state event's content for the given slot description.
+ *
+ * @returns The slot event's content, or `undefined` if no slot event exists for the given description.
+ */
+export function getSlotEventContent(
+    room: Pick<Room, "getLiveTimeline">,
+    slotDescription: SlotDescription,
+): RtcSlotEventContent | undefined {
+    const slotId = computeSlotId(slotDescription);
+    const slotEvent = room
+        .getLiveTimeline()
+        .getState(EventTimeline.FORWARDS)
+        ?.getStateEvents(EventType.RTCSlot, slotId);
+    if (!slotEvent) return undefined;
+
+    return slotEvent.getContent<RtcSlotEventContent>();
+}
+
+/**
+ * Whether the given slot is closed.
+ *
+ * @returns `true` if the slot is closed, `false` if the slot is open or `undefined`
+ * if no slot exists.
+ */
+export function isSlotClosed(
+    room: Pick<Room, "getLiveTimeline">,
+    slotDescription: SlotDescription,
+): boolean | undefined {
+    const content = getSlotEventContent(room, slotDescription) as Partial<RtcSlotEventContent> | undefined;
+    if (content === undefined) return undefined;
+
+    return (
+        content.status !== "open" ||
+        typeof content.application !== "object" ||
+        content.application?.type !== slotDescription.application
+    );
+}
+
+/**
+ * Whether the given slot is open.
+ *
+ * @returns `true` if the slot is open, `false` if the slot is closed or `undefined`
+ * if no slot exists.
+ */
+export function isSlotOpen(room: Pick<Room, "getLiveTimeline">, slotDescription: SlotDescription): boolean | undefined {
+    const closed = isSlotClosed(room, slotDescription);
+    return closed === undefined ? undefined : !closed;
+}

package/src/models/room-sticky-events.ts

@@ -1,5 +1,5 @@
 import { logger as loggerInstance } from "../logger.ts";
-import { type MatrixEvent } from "./event.ts";
+import { type MatrixEvent, MatrixEventEvent } from "./event.ts";
 import { TypedEventEmitter } from "./typed-event-emitter.ts";
 
 const logger = loggerInstance.getChild("RoomStickyEvents");
@@ -131,6 +131,13 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
      *          and the previous event it may have replaced.
      */
     private addStickyEvent(event: MatrixEvent): { added: true; prevEvent?: StickyMatrixEvent } | { added: false } {
+        // The map is keyed on the event's type and sticky key, both of which are encrypted. Wait for the
+        // event to be decrypted, otherwise it would be filed under `m.room.encrypted` with no sticky key.
+        if (event.isBeingDecrypted() || event.shouldAttemptDecryption()) {
+            this.addStickyEventOnceDecrypted(event);
+            return { added: false };
+        }
+
         const stickyKey = event.getContent().msc4354_sticky_key;
         if (typeof stickyKey !== "string" && stickyKey !== undefined) {
             throw new Error(`${event.getId()} is missing msc4354_sticky_key`);
@@ -189,6 +196,24 @@ export class RoomStickyEventsStore extends TypedEventEmitter<RoomStickyEventsEve
         };
     }
 
+    /**
+     * Adds the event to the map once it has been decrypted, emitting `RoomEvent.StickyEvents` at that point.
+     *
+     * Decryption may fail because the keys haven't arrived yet, in which case we keep waiting. An event that
+     * is never decrypted simply never enters the map.
+     */
+    private addStickyEventOnceDecrypted(event: MatrixEvent): void {
+        const onEventDecrypted = (): void => {
+            if (event.isDecryptionFailure()) {
+                // The event may still be decrypted later, e.g. once the keys arrive. Keep listening.
+                event.once(MatrixEventEvent.Decrypted, onEventDecrypted);
+                return;
+            }
+            this.addStickyEvents([event]); // Safe to call because it sorts events by timestamp when updating a keyed entry.
+        };
+        event.once(MatrixEventEvent.Decrypted, onEventDecrypted);
+    }
+
     /**
      * Add a series of sticky events, emitting `RoomEvent.StickyEvents` if any
      * changes were made.

package/src/models/thread.ts

@@ -369,6 +369,15 @@ export class Thread extends ReadReceipt<ThreadEmittedEvents, ThreadEventHandlerM
         // Modify this event to point at our room's state, and mark its thread
         // as this.
         this.setEventMetadata(event);
+
+        // The bundled `current_user_participated` flag from the server lags behind local activity,
+        // so relying on it alone drops just-sent replies out of "participated" views until the next
+        // root event bundle refresh. Latch it as soon as the current user authors a thread reply,
+        // matching the server's participated semantics: an m.thread relation, not a reaction or edit.
+        if (event.getSender() === this.client.getUserId() && event.isRelation(THREAD_RELATION_TYPE.name)) {
+            this._currentUserParticipated = true;
+        }
+
         const eventId = event.getId();
         if (
             !this.initialEventsFetched &&

package/src/oauth/authorize.ts

@@ -24,7 +24,7 @@ import {
     hasRequiredStringProperty,
     isRecord,
 } from "../@types/type-guards.ts";
-import { Method } from "../http-api/index.ts";
+import { Method } from "../http-api/method.ts";
 import { OAuthGrantType } from "./register.ts";
 import { sleep } from "../utils.ts";
 import { type Logger, logger as rootLogger } from "../logger.ts";

package/src/oauth/index.ts

@@ -34,7 +34,8 @@ import {
 } from "./register.ts";
 import { encodeUnpaddedBase64Url } from "../base64.ts";
 import { sha256 } from "../digest.ts";
-import { HTTPError, isMatrixErrorResponse, MatrixError, Method } from "../http-api/index.ts";
+import { HTTPError, isMatrixErrorResponse, MatrixError } from "../http-api/errors.ts";
+import { Method } from "../http-api/method.ts";
 import { type Logger, logger as rootLogger } from "../logger.ts";
 import { fetchWithLogging } from "./fetch.ts";
 import { isOAuth2ErrorResponse, OAuth2Error, OAuth2HTTPError } from "./error.ts";
@@ -44,7 +45,6 @@ import { type NonEmptyArray } from "../@types/common.ts";
 export * from "./authorize.ts";
 export * from "./error.ts";
 export * from "./register.ts";
-export * from "./tokenRefresher.ts";
 export * from "./discover.ts";
 
 /**
@@ -57,8 +57,6 @@ type Context = {
     deviceId?: string;
     /** The seed used to generate the challenge code */
     codeVerifier?: string;
-    /** The URI to redirect the user to with credentials after auth */
-    redirectUri: string;
 };
 
 export class OAuth2 {
@@ -149,7 +147,6 @@ export class OAuth2 {
     ) {
         this.context = {
             clientId: context.clientId,
-            redirectUri: context.redirectUri,
             deviceId: context.deviceId ?? secureRandomString(10),
             codeVerifier: context.codeVerifier ?? secureRandomString(96),
         };
@@ -162,12 +159,14 @@ export class OAuth2 {
      *     that will allow the client to maintain state between the authorization request and the callback.
      *     The app should use this to key the storage for where the rest of the auth context is saved.
      * @param responseMode - The manner in which the IdP should send the secrets back to the app. Defaults to `fragment` for privacy.
+     * @param redirectUri - The redirect URI this application is registered with the delegated auth server under.
      * @param prompt - Optional prompt parameter to pass to the IdP to signal intent, e.g. `create` for User registration.
      * @param scope - The OAuth2 scope to request, will be generated based on the device ID if omitted.
      * @returns a Promise with the url as a string
      */
     public async generateAuthorizationCodeGrantUrl(
         state: string,
+        redirectUri: string,
         responseMode: "fragment" | "query" = "fragment",
         prompt?: string,
         scope?: string,
@@ -178,7 +177,7 @@ export class OAuth2 {
         url.searchParams.set("response_type", "code");
         url.searchParams.set("response_mode", responseMode);
         url.searchParams.set("client_id", this.context.clientId);
-        url.searchParams.set("redirect_uri", this.context.redirectUri);
+        url.searchParams.set("redirect_uri", redirectUri);
         url.searchParams.set("scope", scope ?? generateScope(this.context.deviceId));
         url.searchParams.set("state", state);
         url.searchParams.set("code_challenge_method", "S256");
@@ -202,12 +201,12 @@ export class OAuth2 {
      * @throws An `Error` with `message` set to an entry in {@link OAuth2Error},
      *      when the request fails, or the returned token response is invalid.
      */
-    public async completeAuthorizationCodeGrant(code: string): Promise<BearerTokenResponse> {
+    public async completeAuthorizationCodeGrant(code: string, redirectUri: string): Promise<BearerTokenResponse> {
         const params = new URLSearchParams();
         params.append("grant_type", "authorization_code");
         params.append("client_id", this.context.clientId);
         params.append("code_verifier", this.context.codeVerifier);
-        params.append("redirect_uri", this.context.redirectUri);
+        params.append("redirect_uri", redirectUri);
         params.append("code", code);
 
         const res = await this.fetch("token", params, OAuth2Error.CodeExchangeFailed);