matrix-nodejs-homeserver 0.0.0-stage → 0.3.1

package/dist/core/m.js

@@ -0,0 +1,182 @@
+//#region src/core/m.ts
+function deepFreeze(o) {
+	for (const v of Object.values(o)) if (typeof v === "object" && v !== null) deepFreeze(v);
+	return Object.freeze(o);
+}
+const M = deepFreeze({
+	BEACON_INFO: "m.beacon_info",
+	CALL: { INVITE: "m.call.invite" },
+	CHANGE_PASSWORD: "m.change_password",
+	DEVICE_LIST_UPDATE: "m.device_list_update",
+	DIRECT: "m.direct",
+	DIRECT_TO_DEVICE: "m.direct_to_device",
+	FEDERATE: "m.federate",
+	FULLY_READ: "m.fully_read",
+	GET_LOGIN_TOKEN: "m.get_login_token",
+	HEROES: "m.heroes",
+	HOMESERVER: "m.homeserver",
+	ID: {
+		PHONE: "m.id.phone",
+		THIRDPARTY: "m.id.thirdparty",
+		USER: "m.id.user"
+	},
+	IGNORED_USER_LIST: "m.ignored_user_list",
+	IN_REPLY_TO: "m.in_reply_to",
+	INVITED_MEMBER_COUNT: "m.invited_member_count",
+	JOINED_MEMBER_COUNT: "m.joined_member_count",
+	LOGIN: {
+		APPLICATION_SERVICE: "m.login.application_service",
+		DUMMY: "m.login.dummy",
+		EMAIL: { IDENTITY: "m.login.email.identity" },
+		MSISDN: "m.login.msisdn",
+		PASSWORD: "m.login.password",
+		REGISTRATION_TOKEN: "m.login.registration_token",
+		SSO: "m.login.sso",
+		TOKEN: "m.login.token"
+	},
+	NOTICE: "m.notice",
+	OAUTH: "m.oauth",
+	POLL: { START: "m.poll.start" },
+	PRESENCE: "m.presence",
+	PROFILE_FIELDS: "m.profile_fields",
+	PUSH_RULES: "m.push_rules",
+	REACTION: "m.reaction",
+	READ: {
+		_: "m.read",
+		PRIVATE: "m.read.private"
+	},
+	RECEIPT: "m.receipt",
+	RELATES_TO: "m.relates_to",
+	RELATIONS: "m.relations",
+	RELATIONSHIP: "m.relationship",
+	REPLACE: "m.replace",
+	ROLE: {
+		ADMIN: "m.role.admin",
+		SECURITY: "m.role.security"
+	},
+	ROOM: {
+		ALIASES: "m.room.aliases",
+		AVATAR: "m.room.avatar",
+		CANONICAL_ALIAS: "m.room.canonical_alias",
+		CREATE: "m.room.create",
+		ENCRYPTED: "m.room.encrypted",
+		ENCRYPTION: "m.room.encryption",
+		GUEST_ACCESS: "m.room.guest_access",
+		HISTORY_VISIBILITY: "m.room.history_visibility",
+		JOIN_RULES: "m.room.join_rules",
+		MEMBER: "m.room.member",
+		MESSAGE: "m.room.message",
+		NAME: "m.room.name",
+		POLICY: "m.room.policy",
+		POWER_LEVELS: "m.room.power_levels",
+		REDACTION: "m.room.redaction",
+		SERVER_ACL: "m.room.server_acl",
+		THIRD_PARTY_INVITE: "m.room.third_party_invite",
+		TOMBSTONE: "m.room.tombstone",
+		TOPIC: "m.room.topic"
+	},
+	ROOM_MEMBERSHIP: "m.room_membership",
+	ROOM_VERSIONS: "m.room_versions",
+	RULE: {
+		CALL: ".m.rule.call",
+		CONTAINS_DISPLAY_NAME: ".m.rule.contains_display_name",
+		CONTAINS_USER_NAME: ".m.rule.contains_user_name",
+		ENCRYPTED: ".m.rule.encrypted",
+		ENCRYPTED_ROOM_ONE_TO_ONE: ".m.rule.encrypted_room_one_to_one",
+		INVITE_FOR_ME: ".m.rule.invite_for_me",
+		IS_ROOM_MENTION: ".m.rule.is_room_mention",
+		IS_USER_MENTION: ".m.rule.is_user_mention",
+		MASTER: ".m.rule.master",
+		MEMBER_EVENT: ".m.rule.member_event",
+		MESSAGE: ".m.rule.message",
+		REACTION: ".m.rule.reaction",
+		ROOM: { SERVER_ACL: ".m.rule.room.server_acl" },
+		ROOM_ONE_TO_ONE: ".m.rule.room_one_to_one",
+		ROOMNOTIF: ".m.rule.roomnotif",
+		SUPPRESS_EDITS: ".m.rule.suppress_edits",
+		SUPPRESS_NOTICES: ".m.rule.suppress_notices",
+		TOMBSTONE: ".m.rule.tombstone"
+	},
+	SERVER: "m.server",
+	SERVER_NOTICE: "m.server_notice",
+	SET_AVATAR_URL: "m.set_avatar_url",
+	SET_DISPLAYNAME: "m.set_displayname",
+	SIGNING_KEY_UPDATE: "m.signing_key_update",
+	SPACE: {
+		_: "m.space",
+		CHILD: "m.space.child"
+	},
+	STICKER: "m.sticker",
+	TAG: "m.tag",
+	TEXT: "m.text",
+	THREAD: "m.thread",
+	THREEPID_CHANGES: "m.3pid_changes",
+	TOPIC: "m.topic",
+	TYPING: "m.typing",
+	UPLOAD: { SIZE: "m.upload.size" }
+});
+const UNSTABLE = deepFreeze({
+	DE: { SORUNOME: { MSC2409: {
+		EPHEMERAL: "de.sorunome.msc2409.ephemeral",
+		PUSH_EPHEMERAL: "de.sorunome.msc2409.push_ephemeral"
+	} } },
+	IO: { ELEMENT: {
+		MSC4306: {
+			RULE: {
+				SUBSCRIBED_THREAD: ".io.element.msc4306.rule.subscribed_thread",
+				UNSUBSCRIBED_THREAD: ".io.element.msc4306.rule.unsubscribed_thread"
+			},
+			THREAD_SUBSCRIPTION: "io.element.msc4306.thread_subscription"
+		},
+		MSC4308: { THREAD_SUBSCRIPTIONS: "io.element.msc4308.thread_subscriptions" }
+	} },
+	ORG: { MATRIX: {
+		CROSS_SIGNING_RESET: "org.matrix.cross_signing_reset",
+		CUSTOM: { HTML: "org.matrix.custom.html" },
+		MSC2732: { FALLBACK_KEYS: "org.matrix.msc2732.fallback_keys" },
+		MSC3202: { DEVICE_ID: "org.matrix.msc3202.device_id" },
+		MSC3381: { POLL: {
+			END: "org.matrix.msc3381.poll.end",
+			RESPONSE: "org.matrix.msc3381.poll.response",
+			START: "org.matrix.msc3381.poll.start"
+		} },
+		MSC3874: {
+			NOT_REL_TYPES: "org.matrix.msc3874.not_rel_types",
+			REL_TYPES: "org.matrix.msc3874.rel_types"
+		},
+		MSC3916: { STABLE: "org.matrix.msc3916.stable" },
+		MSC3930: { RULE: {
+			POLL_END: ".org.matrix.msc3930.rule.poll_end",
+			POLL_END_ONE_TO_ONE: ".org.matrix.msc3930.rule.poll_end_one_to_one",
+			POLL_RESPONSE: ".org.matrix.msc3930.rule.poll_response",
+			POLL_START: ".org.matrix.msc3930.rule.poll_start",
+			POLL_START_ONE_TO_ONE: ".org.matrix.msc3930.rule.poll_start_one_to_one"
+		} },
+		MSC4140: {
+			_: "org.matrix.msc4140",
+			DELAY: "org.matrix.msc4140.delay",
+			MAX_DELAY: "org.matrix.msc4140.max_delay"
+		},
+		MSC4143: {
+			_: "org.matrix.msc4143",
+			RTC_FOCI: "org.matrix.msc4143.rtc_foci"
+		},
+		MSC4155: {
+			ERRCODE: "org.matrix.msc4155.errcode",
+			INVITE_PERMISSION_CONFIG: "org.matrix.msc4155.invite_permission_config"
+		},
+		MSC4222: {
+			_: "org.matrix.msc4222",
+			STATE_AFTER: "org.matrix.msc4222.state_after",
+			USE_STATE_AFTER: "org.matrix.msc4222.use_state_after"
+		},
+		MSC4306: "org.matrix.msc4306",
+		MSC4429: {
+			PROFILE_FIELDS: "org.matrix.msc4429.profile_fields",
+			USERS: "org.matrix.msc4429.users"
+		},
+		SIMPLIFIED_MSC3575: "org.matrix.simplified_msc3575"
+	} }
+});
+//#endregion
+export { M, UNSTABLE };

package/dist/core/notifier.d.ts

@@ -0,0 +1,17 @@
+import { ClusterAdapter } from "./cluster.js";
+//#region src/core/notifier.d.ts
+/**
+ * Wakes long-polling `/sync` requests when something relevant happens. Notifications
+ * are broadcast through the cluster adapter so waiters on other instances wake too.
+ */
+export declare class Notifier {
+  private waiters;
+  private cluster;
+  private instanceId;
+  constructor(cluster: ClusterAdapter, instanceId: string);
+  notify(userIds: Iterable<string>): void;
+  private wakeLocal;
+  notifyAll(): void;
+  wait(userId: string, timeoutMs: number, signal?: AbortSignal): Promise<void>;
+}
+//#endregion

package/dist/core/notifier.js

@@ -0,0 +1,54 @@
+//#region src/core/notifier.ts
+/**
+* Wakes long-polling `/sync` requests when something relevant happens. Notifications
+* are broadcast through the cluster adapter so waiters on other instances wake too.
+*/
+var Notifier = class {
+	waiters = /* @__PURE__ */ new Map();
+	cluster;
+	instanceId;
+	constructor(cluster, instanceId) {
+		this.cluster = cluster;
+		this.instanceId = instanceId;
+		cluster.subscribe("notify", (msg) => {
+			if (msg?.from !== this.instanceId && Array.isArray(msg?.users)) this.wakeLocal(msg.users);
+		});
+	}
+	notify(userIds) {
+		const users = [...userIds];
+		if (!users.length) return;
+		this.wakeLocal(users);
+		this.cluster.publish("notify", {
+			from: this.instanceId,
+			users
+		}).catch(() => {});
+	}
+	wakeLocal(userIds) {
+		for (const u of userIds) {
+			const set = this.waiters.get(u);
+			if (!set) continue;
+			this.waiters.delete(u);
+			for (const wake of set) wake();
+		}
+	}
+	notifyAll() {
+		this.wakeLocal([...this.waiters.keys()]);
+	}
+	wait(userId, timeoutMs, signal) {
+		return new Promise((resolve) => {
+			let set = this.waiters.get(userId);
+			if (!set) this.waiters.set(userId, set = /* @__PURE__ */ new Set());
+			const done = () => {
+				clearTimeout(timer);
+				set.delete(done);
+				signal?.removeEventListener("abort", done);
+				resolve();
+			};
+			const timer = setTimeout(done, timeoutMs);
+			signal?.addEventListener("abort", done, { once: true });
+			set.add(done);
+		});
+	}
+};
+//#endregion
+export { Notifier };

package/dist/core/oauth.d.ts

@@ -0,0 +1,38 @@
+import { Session } from "./auth.js";
+import { Homeserver } from "../homeserver.js";
+//#region src/core/oauth.d.ts
+/**
+ * Delegate authentication to an external OAuth 2.0 / OpenID Connect provider
+ * (Matrix "OAuth 2.0 API", e.g. matrix-authentication-service, Keycloak, Authentik).
+ */
+export interface OAuthDelegationOptions {
+  /** Issuer URL of the authorization server. */
+  issuer: string;
+  /** Client credentials the homeserver uses for token introspection. */
+  clientId: string;
+  clientSecret: string;
+  /** Override the introspection endpoint instead of discovering it. */
+  introspectionEndpoint?: string;
+  /** Where users manage their account (advertised to clients). */
+  accountManagementUrl?: string;
+  /** Map introspection claims to a Matrix localpart. Default: `username`, then `sub`. */
+  localpartFromClaims?: (claims: Record<string, any>) => string | null;
+  /** Scope granting server admin rights. Default: "urn:synapse:admin:*". */
+  adminScope?: string;
+  /** How long successful introspections are cached, in ms. Default: 60 000. */
+  cacheTtlMs?: number;
+}
+export declare class OAuthDelegation {
+  private hs;
+  readonly options: OAuthDelegationOptions;
+  private metadata;
+  private metadataFetched;
+  private cache;
+  constructor(hs: Homeserver, options: OAuthDelegationOptions);
+  /** Authorization server metadata (RFC 8414 / OIDC discovery), cached for an hour. */
+  serverMetadata(): Promise<Record<string, any>>;
+  /** Validate an access token by introspection, provisioning the user and device on first use. */
+  authenticate(token: string): Promise<Session>;
+  forget(token: string): void;
+}
+//#endregion

package/dist/core/oauth.js

@@ -0,0 +1,108 @@
+import { errors } from "./errors.js";
+import { LOCALPART_RE } from "./ids.js";
+//#region src/core/oauth.ts
+const API_SCOPES = ["urn:matrix:client:api:*", "urn:matrix:org.matrix.msc2967.client:api:*"];
+const DEVICE_SCOPE_PREFIXES = ["urn:matrix:client:device:", "urn:matrix:org.matrix.msc2967.client:device:"];
+var OAuthDelegation = class {
+	hs;
+	options;
+	metadata = null;
+	metadataFetched = 0;
+	cache = /* @__PURE__ */ new Map();
+	constructor(hs, options) {
+		this.hs = hs;
+		this.options = options;
+	}
+	/** Authorization server metadata (RFC 8414 / OIDC discovery), cached for an hour. */
+	async serverMetadata() {
+		if (this.metadata && Date.now() - this.metadataFetched < 36e5) return this.metadata;
+		const base = this.options.issuer.replace(/\/$/, "");
+		let res = await this.hs.fetch(`${base}/.well-known/openid-configuration`, { signal: AbortSignal.timeout(1e4) });
+		if (!res.ok) res = await this.hs.fetch(`${base}/.well-known/oauth-authorization-server`, { signal: AbortSignal.timeout(1e4) });
+		if (!res.ok) throw new Error(`OAuth discovery failed with ${res.status}`);
+		const meta = await res.json();
+		if (this.options.accountManagementUrl) meta.account_management_uri = this.options.accountManagementUrl;
+		this.metadata = meta;
+		this.metadataFetched = Date.now();
+		return meta;
+	}
+	/** Validate an access token by introspection, provisioning the user and device on first use. */
+	async authenticate(token) {
+		const cached = this.cache.get(token);
+		if (cached && cached.expires > Date.now()) return cached.session;
+		const endpoint = this.options.introspectionEndpoint ?? (await this.serverMetadata()).introspection_endpoint;
+		if (!endpoint) throw new Error("Authorization server has no introspection endpoint");
+		const res = await this.hs.fetch(endpoint, {
+			method: "POST",
+			headers: {
+				"content-type": "application/x-www-form-urlencoded",
+				authorization: `Basic ${Buffer.from(`${encodeURIComponent(this.options.clientId)}:${encodeURIComponent(this.options.clientSecret)}`).toString("base64")}`
+			},
+			body: new URLSearchParams({
+				token,
+				token_type_hint: "access_token"
+			}),
+			signal: AbortSignal.timeout(1e4)
+		});
+		if (!res.ok) throw errors.unknownToken("Token introspection failed");
+		const claims = await res.json();
+		if (!claims.active) throw errors.unknownToken();
+		const scopes = String(claims.scope ?? "").split(" ");
+		if (!scopes.some((s) => API_SCOPES.includes(s))) throw errors.unknownToken("Token lacks the Matrix API scope");
+		let deviceId = null;
+		for (const s of scopes) for (const p of DEVICE_SCOPE_PREFIXES) if (s.startsWith(p)) deviceId = s.slice(p.length);
+		if (!deviceId) throw errors.unknownToken("Token lacks a device scope");
+		const localpart = (this.options.localpartFromClaims?.(claims) ?? claims.username ?? claims.sub ?? "").toLowerCase();
+		if (!LOCALPART_RE.test(localpart)) throw errors.unknownToken("Token subject cannot be mapped to a Matrix user");
+		const userId = `@${localpart}:${this.hs.serverName}`;
+		let user = await this.hs.db.findOne("users", [{
+			field: "user_id",
+			value: userId
+		}]);
+		if (!user) {
+			await this.hs.admin.createUser(localpart, { displayname: claims.name ?? localpart });
+			user = await this.hs.db.findOne("users", [{
+				field: "user_id",
+				value: userId
+			}]);
+		}
+		if (user.deactivated) throw errors.userDeactivated();
+		const deviceWhere = [{
+			field: "user_id",
+			value: userId
+		}, {
+			field: "device_id",
+			value: deviceId
+		}];
+		if (!await this.hs.db.findOne("devices", deviceWhere)) {
+			await this.hs.db.create("devices", {
+				user_id: userId,
+				device_id: deviceId,
+				display_name: null,
+				last_seen_ts: Date.now(),
+				last_seen_ip: null
+			});
+			await this.hs.keys.markDeviceListChanged(userId);
+		}
+		const session = {
+			userId,
+			deviceId,
+			accessToken: token,
+			isGuest: false,
+			isAdmin: !!user.is_admin || scopes.includes(this.options.adminScope ?? "urn:synapse:admin:*")
+		};
+		const ttl = this.options.cacheTtlMs ?? 6e4;
+		const exp = typeof claims.exp === "number" ? claims.exp * 1e3 : Infinity;
+		if (this.cache.size > 5e4) this.cache.clear();
+		this.cache.set(token, {
+			session,
+			expires: Math.min(Date.now() + ttl, exp)
+		});
+		return session;
+	}
+	forget(token) {
+		this.cache.delete(token);
+	}
+};
+//#endregion
+export { OAuthDelegation };

package/dist/core/partialstate.d.ts

@@ -0,0 +1,32 @@
+import { Homeserver } from "../homeserver.js";
+//#region src/core/partialstate.d.ts
+export declare class PartialStateService {
+  private readonly hs;
+  private readonly partial;
+  private readonly completed;
+  private readonly running;
+  private readonly completedStreams;
+  private stopped;
+  constructor(hs: Homeserver);
+  isPartial(roomId: string): Promise<boolean>;
+  /** Servers the joining server told us were in the room (used as destinations and resync sources). */
+  servers(roomId: string): Promise<string[]>;
+  /** Stream position at which the room got its full state (null if it never was partial). */
+  completedAt(roomId: string): Promise<number | null>;
+  /**
+   * A device list update for a user we do not share a (known) room with: if they may be a member
+   * of a partial-state room hosted by the sender, remember them for when the state is complete.
+   */
+  notePendingDeviceUpdate(userId: string, origin: string): Promise<void>;
+  markPartial(roomId: string, joinEventId: string, origin: string, servers: string[]): Promise<void>;
+  /** Resolve once the room has its full state (or the signal aborts / the server closes). */
+  waitForFullState(roomId: string, signal?: AbortSignal): Promise<void>;
+  /** Resume resyncs of rooms left partial (e.g. by a restart). */
+  resume(): Promise<void>;
+  stop(): void;
+  startResync(roomId: string): void;
+  private resync;
+  private tryResync;
+  private finish;
+}
+//#endregion

package/dist/core/partialstate.js

@@ -0,0 +1,198 @@
+import { M } from "./m.js";
+import { eventIdOf, roomVersionFeatures, stateKey } from "./events.js";
+import { EventEmitter } from "node:events";
+//#region src/core/partialstate.ts
+const RESYNC_CLAIM_MS = 6e5;
+var PartialStateService = class {
+	hs;
+	partial = /* @__PURE__ */ new Map();
+	completed = new EventEmitter();
+	running = /* @__PURE__ */ new Set();
+	completedStreams = /* @__PURE__ */ new Map();
+	stopped = false;
+	constructor(hs) {
+		this.hs = hs;
+		this.completed.setMaxListeners(0);
+		hs.cluster.subscribe("partial-state", (msg) => {
+			if (typeof msg?.roomId !== "string") return;
+			this.partial.delete(msg.roomId);
+			this.completedStreams.delete(msg.roomId);
+			this.completed.emit(msg.roomId);
+		});
+	}
+	async isPartial(roomId) {
+		const cached = this.partial.get(roomId);
+		if (cached !== void 0) return cached;
+		const row = await this.hs.db.findOne("partial_state_rooms", [{
+			field: "room_id",
+			value: roomId
+		}]);
+		const partial = !!row && row.completed_stream === null;
+		if (this.partial.size > 1e4) this.partial.clear();
+		this.partial.set(roomId, partial);
+		return partial;
+	}
+	/** Servers the joining server told us were in the room (used as destinations and resync sources). */
+	async servers(roomId) {
+		if (!await this.isPartial(roomId)) return [];
+		const row = await this.hs.db.findOne("partial_state_rooms", [{
+			field: "room_id",
+			value: roomId
+		}]);
+		return Array.isArray(row?.servers) ? row.servers : [];
+	}
+	/** Stream position at which the room got its full state (null if it never was partial). */
+	async completedAt(roomId) {
+		if (this.partial.get(roomId) === false && this.completedStreams.has(roomId)) return this.completedStreams.get(roomId);
+		const at = (await this.hs.db.findOne("partial_state_rooms", [{
+			field: "room_id",
+			value: roomId
+		}]))?.completed_stream ?? null;
+		if (this.completedStreams.size > 1e4) this.completedStreams.clear();
+		this.completedStreams.set(roomId, at);
+		return at;
+	}
+	/**
+	* A device list update for a user we do not share a (known) room with: if they may be a member
+	* of a partial-state room hosted by the sender, remember them for when the state is complete.
+	*/
+	async notePendingDeviceUpdate(userId, origin) {
+		const rows = (await this.hs.db.findMany("partial_state_rooms", {})).filter((r) => r.completed_stream === null && (r.servers ?? []).includes(origin));
+		for (const row of rows) {
+			const pending = Array.isArray(row.pending_device_users) ? row.pending_device_users : [];
+			if (pending.includes(userId)) continue;
+			await this.hs.db.update("partial_state_rooms", [{
+				field: "room_id",
+				value: row.room_id
+			}], { pending_device_users: [...pending, userId] });
+		}
+	}
+	async markPartial(roomId, joinEventId, origin, servers) {
+		await this.hs.db.upsert("partial_state_rooms", {
+			room_id: roomId,
+			join_event_id: joinEventId,
+			origin,
+			servers: [.../* @__PURE__ */ new Set([origin, ...servers])],
+			created_ts: Date.now(),
+			completed_stream: null,
+			pending_device_users: []
+		});
+		this.partial.set(roomId, true);
+		this.completedStreams.delete(roomId);
+		this.hs.cluster.publish("partial-state", { roomId }).catch(() => {});
+		this.startResync(roomId);
+	}
+	/** Resolve once the room has its full state (or the signal aborts / the server closes). */
+	async waitForFullState(roomId, signal) {
+		if (!await this.isPartial(roomId)) return;
+		await new Promise((resolve) => {
+			const done = () => {
+				clearInterval(poll);
+				this.completed.off(roomId, check);
+				signal?.removeEventListener("abort", done);
+				this.hs.off?.("close", done);
+				resolve();
+			};
+			const check = () => void this.isPartial(roomId).then((p) => {
+				if (!p) done();
+			}).catch(() => {});
+			this.completed.on(roomId, check);
+			signal?.addEventListener("abort", done);
+			this.hs.once?.("close", done);
+			const poll = setInterval(() => {
+				this.partial.delete(roomId);
+				check();
+			}, 5e3);
+			poll.unref?.();
+		});
+	}
+	/** Resume resyncs of rooms left partial (e.g. by a restart). */
+	async resume() {
+		const rows = (await this.hs.db.findMany("partial_state_rooms", {})).filter((r) => r.completed_stream === null);
+		this.hs.logger.debug("Resuming partial state resyncs", rows.map((r) => r.room_id));
+		for (const row of rows) this.startResync(row.room_id);
+	}
+	stop() {
+		this.stopped = true;
+	}
+	startResync(roomId) {
+		if (this.running.has(roomId)) return;
+		this.running.add(roomId);
+		this.resync(roomId).catch((err) => this.hs.logger.warn("Partial state resync failed", roomId, err)).finally(() => this.running.delete(roomId));
+	}
+	async resync(roomId) {
+		const claim = `partial-resync:${roomId}`;
+		if (!await this.hs.cluster.setIfAbsent(claim, this.hs.instanceId, RESYNC_CLAIM_MS)) {
+			this.hs.logger.debug("Partial state resync of", roomId, "is claimed elsewhere");
+			return;
+		}
+		this.hs.logger.debug("Partial state resync of", roomId, "started");
+		try {
+			let delay = 1e3;
+			for (let attempt = 0; !this.stopped && !this.hs.isClosed; attempt++) {
+				const row = await this.hs.db.findOne("partial_state_rooms", [{
+					field: "room_id",
+					value: roomId
+				}]);
+				if (!row || row.completed_stream !== null) return;
+				if (await this.tryResync(roomId, row)) return;
+				if (this.stopped || this.hs.isClosed) return;
+				if (!await this.hs.rooms.serverIsJoined(roomId)) {
+					await this.finish(roomId);
+					return;
+				}
+				await new Promise((r) => setTimeout(r, delay).unref?.());
+				delay = Math.min(delay * 2, 6e4);
+				await this.hs.cluster.set(claim, this.hs.instanceId, RESYNC_CLAIM_MS);
+			}
+		} finally {
+			await this.hs.cluster.delete(claim).catch(() => {});
+		}
+	}
+	async tryResync(roomId, row) {
+		const version = await this.hs.rooms.roomVersion(roomId);
+		const join = await this.hs.rooms.getEvent(row.join_event_id);
+		if (!version || !join) {
+			await this.finish(roomId);
+			return true;
+		}
+		const prevIds = (join.pdu.prev_events ?? []).map(eventIdOf);
+		const servers = [.../* @__PURE__ */ new Set([row.origin, ...row.servers ?? []])].filter((s) => s && s !== this.hs.serverName);
+		for (const server of servers) {
+			if (this.stopped || this.hs.isClosed) return true;
+			try {
+				const fullBefore = await this.hs.federation.stateFromPrevs(server, roomId, version, prevIds, { remote: true });
+				if (this.stopped || this.hs.isClosed) return true;
+				if (!fullBefore[stateKey(M.ROOM.CREATE, "")] && !roomVersionFeatures(version).v12) throw new Error("Resynced state lacks the create event");
+				const notified = /* @__PURE__ */ new Set([...row.servers ?? [], ...this.hs.federation.serversInRoom(await this.hs.rooms.currentState(roomId), false)]);
+				const missed = await this.hs.rooms.withLock(roomId, () => this.hs.rooms.completePartialState(roomId, version, row.join_event_id, fullBefore, notified));
+				await this.finish(roomId);
+				if (missed.length) for (const userId of (await this.hs.rooms.joinedMembers(roomId)).filter((u) => this.hs.isLocalUser(u))) await this.hs.federation.onDeviceListChange(userId, void 0, new Set(missed)).catch(() => {});
+				return true;
+			} catch (err) {
+				this.hs.logger.debug("Partial state resync from", server, "failed", err);
+			}
+		}
+		return false;
+	}
+	async finish(roomId) {
+		await this.hs.streams.write((stream) => this.hs.db.update("partial_state_rooms", [{
+			field: "room_id",
+			value: roomId
+		}], { completed_stream: stream }));
+		this.partial.set(roomId, false);
+		this.completedStreams.delete(roomId);
+		this.completed.emit(roomId);
+		this.hs.cluster.publish("partial-state", { roomId }).catch(() => {});
+		const members = await this.hs.rooms.joinedMembers(roomId);
+		this.hs.notifier.notify(members.filter((u) => this.hs.isLocalUser(u)));
+		const row = await this.hs.db.findOne("partial_state_rooms", [{
+			field: "room_id",
+			value: roomId
+		}]);
+		const pending = Array.isArray(row?.pending_device_users) ? row.pending_device_users : [];
+		await this.hs.keys.onPartialStateComplete(roomId, pending).catch((err) => this.hs.logger.warn("Device list refresh failed", err));
+	}
+};
+//#endregion
+export { PartialStateService };