packages/room/src/state_resolution/definitions/algorithm/v2.ts (2)

107-108: EventID[] migration here is good; tighten the wrapper’s method signature for safety.

eventIdsToFind as EventID[] aligns with the store API. Consider typing the wrapper to EventStore and the param to readonly EventID[] to prevent accidental string arrays.

- const wrappedStore: typeof store = {
-   async getEvents(eventIds) {
+ const wrappedStore: EventStore = {
+   async getEvents(eventIds: readonly EventID[]) {

---

175-184: Batch fetch conflicted power events instead of N sequential awaits.

Current loop does 1 RPC per ID. Collect and fetch in one call to reduce I/O.

- for (const eventid of fullConflictedSet) {
-   const [event] = await wrappedStore.getEvents([eventid]);
-   if (!event) {
-     console.warn('event not found in eventMap', eventid);
-     continue;
-   }
-   if (isPowerEvent(event)) {
-     powerEvents.set(event.eventId, event);
-   }
- }
+ {
+   const ids = Array.from(fullConflictedSet);
+   const events = await wrappedStore.getEvents(ids);
+   for (const event of events) {
+     if (!event) continue;
+     if (isPowerEvent(event)) {
+       powerEvents.set(event.eventId, event);
+     }
+   }
+ }

packages/federation-sdk/src/repositories/room.repository.ts (1)

15-16: Align types: tombstone_event_id is EventID; accept EventID in markRoomAsDeleted.

Avoid passing plain string to a branded EventID field.

- async markRoomAsDeleted(
-   roomId: string,
-   tombstoneEventId: string,
- ): Promise<void> {
+ async markRoomAsDeleted(
+   roomId: string,
+   tombstoneEventId: EventID,
+ ): Promise<void> {
   await this.collection.updateOne(
     { _id: roomId },
     {
       $set: {
         'room.deleted': true,
         'room.tombstone_event_id': tombstoneEventId,
       },
     },
   );
 }

Also applies to: 73-86

packages/federation-sdk/src/repositories/state.repository.ts (1)

37-41: getLatestStateMapping returns the oldest due to ascending sort.

Use -1 to fetch the latest.

- return this.collection.findOne({ roomId }, { sort: { createdAt: 1 } });
+ return this.collection.findOne({ roomId }, { sort: { createdAt: -1 } });

packages/core/src/events/m.room.guest_access.ts (1)

1-1: Use package alias and type-only import for EventID; param type changes LGTM.

Avoid deep path; keep consistency with other files.

-import { EventID } from 'packages/room/dist';
+import type { EventID } from '@hs/room';

Also applies to: 28-30

packages/federation-sdk/src/services/missing-event.service.ts (1)

3-3: Use package alias and type-only import; name the logger after the service.

Small hygiene tweaks.

-import { EventID } from 'packages/room/dist';
+import type { EventID } from '@hs/room';

-private readonly logger = createLogger('EventService');
+private readonly logger = createLogger('MissingEventService');

Also applies to: 17-17

packages/homeserver/src/controllers/internal/room.controller.ts (1)

4-8: Mark EventID as type-only; parse event_id instead of casting.

This preserves the brand and avoids leaking values imports.

-import {
-  EventID,
-  type PduCreateEventContent,
-  PersistentEventFactory,
-} from '@hs/room';
+import {
+  type EventID,
+  type PduCreateEventContent,
+  PersistentEventFactory,
+} from '@hs/room';

- const room = await stateService.findStateAtEvent(eventId as EventID);
+ import { eventIdSchema } from '@hs/room';
+ const room = await stateService.findStateAtEvent(eventIdSchema.parse(eventId));

Also applies to: 192-193

packages/homeserver/src/controllers/internal/message.controller.ts (1)

119-119: LGTM on EventID casts; make the other call sites consistent.

unsetReaction and redactMessage now pass EventID. Do the same for updateMessage and sendReaction to avoid mixed typing.

Suggested updates elsewhere in this file:

// in updateMessage handler
params.messageId as EventID

// in sendReaction handler
params.messageId as EventID

Please confirm MessageService method signatures now expect EventID. If not, align them or narrow here.

Also applies to: 158-158

packages/core/src/models/event.model.ts (1)

1-1: Great: persisted _id is EventID. Now align adjacent ID fields.

To keep branding consistent and prevent accidental mixing with plain strings, consider updating nearby types:

• missing_dependencies?: EventID[]
• EventStore.nextEventId: EventID
• FetchedEvents.events[].eventId: EventID
• FetchedEvents.missingEventIds: EventID[]

Example (outside selected lines):

interface PersistentEventBase<E = Pdu> {
  _id: EventID;
  // ...
  missing_dependencies?: EventID[];
}

export interface EventStore<E = Pdu> extends PersistentEventBase<E> {
  stateId: string;
  nextEventId: EventID;
}

export interface FetchedEvents {
  events: { eventId: EventID; event: CoreEventBase }[];
  missingEventIds: EventID[];
}

Also applies to: 7-7

packages/federation-sdk/src/services/send-join.service.ts (1)

3-3: Good: public API now takes EventID; tighten local typing and avoid variable shadowing.

• Type authChain as EventID[] to preserve branding end‑to‑end.
• Avoid reusing the identifier event inside the for...of loop (shadows the method param).

Outside the selected lines:

const authChain: EventID[] = [];

for (const ev of state.values()) {
  const authEvents = await getAuthChain(ev, stateService._getStore(roomVersion));
  authChain.push(...authEvents);
}

Also applies to: 24-24

packages/federation-sdk/src/services/staging-area.service.ts (1)

6-6: Remove redundant as EventID casts in emitter payloads.

eventId is already EventID (via EventStagingStore._id). Casting is unnecessary noise.

Apply:

- event_id: eventId as EventID,
+ event_id: eventId,

Repeat for the redaction and membership emitters. The type‑only import on Line 6 is correct.

Also applies to: 166-167, 182-183, 195-196

packages/room/src/manager/v3.ts (1)

19-21: Avoid casts by typing raw_event.prev_events as EventID[] at the source.

The cast works, but updating the PDU type would remove the need for as EventID[].

packages/federation-sdk/src/services/room.service.ts (2)

1040-1049: Auth event map now uses actual IDs; consider enforcing required keys.

Filtering undefined later is good, but tombstone should require create, power_levels, and member. Fail fast if any are missing.

Apply:

 		const authEventsMap: TombstoneAuthEvents = {
 			'm.room.create': authEvents.find(
 				(event) => event.event.type === 'm.room.create',
 			)?._id,
 			'm.room.power_levels': authEvents.find(
 				(event) => event.event.type === 'm.room.power_levels',
 			)?._id,
 			'm.room.member': authEvents.find(
 				(event) => event.event.type === 'm.room.member',
 			)?._id,
 		};
+		const missing = Object.entries(authEventsMap)
+			.filter(([, id]) => !id)
+			.map(([t]) => t);
+		if (missing.length) {
+			throw new HttpException(
+				`Missing auth events for tombstone: ${missing.join(', ')}`,
+				HttpStatus.FORBIDDEN,
+			);
+		}

---

1052-1055: Minor: tighten filtering with a type guard.

Keeps types precise without an assertion.

Apply:

-		const authEventsArray = Object.values(authEventsMap).filter(
-			(event) => event !== undefined,
-		) as EventID[];
+		const authEventsArray = Object.values(authEventsMap).filter(
+			(e): e is EventID => Boolean(e),
+		);

packages/core/src/utils/generateId.ts (2)

2-2: Mark EventID import as type‑only.

-import { EventID } from 'packages/room/dist';
+import type { EventID } from 'packages/room/dist';

---

7-15: Return type change to EventID looks good; casting is acceptable.

Optional: centralize branding to reduce repeated as EventID casts (e.g., a tiny asEventID(s: string): EventID helper).

packages/core/src/events/m.room.tombstone.ts (2)

1-1: Type‑only import for EventID.

-import { EventID } from 'packages/room/dist';
+import type { EventID } from 'packages/room/dist';

---

41-45: isTruthy helper is duplicated across modules.

Consider a shared utility (e.g., utils/predicates.ts) to DRY.

packages/room/src/types/v3-11.ts (1)

556-561: Use eventIdSchema for top‑level redacts to finish the migration.

-	redacts: z
-		.string()
-		.describe(
-			'The ID of the event that this event redacts. This is an optional field.',
-		)
-		.optional(),
+	redacts: eventIdSchema
+		.describe('The ID of the event that this event redacts.')
+		.optional(),

packages/core/src/events/m.room.power_levels.ts (2)

1-1: Type‑only import for EventID.

-import { EventID } from 'packages/room/dist';
+import type { EventID } from 'packages/room/dist';

---

57-60: Make 'm.room.member' optional (matches TODO/tests) and avoid cast with a typed predicate.

-	auth_events: {
-		'm.room.create': EventID;
-		'm.room.power_levels': EventID;
-		'm.room.member': EventID; // TODO: Based on the tests, this is optional, based on the code, this is required check this
-	};
+	auth_events: {
+		'm.room.create': EventID;
+		'm.room.power_levels': EventID;
+		'm.room.member'?: EventID; // optional per tests
+	};
@@
-		auth_events: [
+		auth_events: [
 			auth_events['m.room.create'],
 			auth_events['m.room.power_levels'],
 			auth_events['m.room.member'],
-		].filter(Boolean) as EventID[],
+		].filter((e): e is EventID => Boolean(e)),

If any callers relied on 'm.room.member' being required, CI/type‑check will surface them. Please confirm no regressions.

packages/federation-sdk/src/services/message.service.ts (4)

75-76: Fix typos: “white” → “while”.

Tiny copy edit in error messages.

-`Room version not found for room ${roomId} white trying to send message`,
+`Room version not found for room ${roomId} while trying to send message`,

Also applies to: 117-120

---

379-413: Variable name “redactionEvent” is misleading for an edit event.

This block creates an m.room.message replacement, not a redaction. Rename for clarity.

-const redactionEvent = await this.stateService.buildEvent<'m.room.message'>(
+const replacementEvent = await this.stateService.buildEvent<'m.room.message'>(
 ...
-await this.stateService.persistTimelineEvent(redactionEvent);
-void this.federationService.sendEventToAllServersInRoom(redactionEvent);
-return redactionEvent.eventId;
+await this.stateService.persistTimelineEvent(replacementEvent);
+void this.federationService.sendEventToAllServersInRoom(replacementEvent);
+return replacementEvent.eventId;

---

339-353: Good: unsetReaction now brands the target ID. Also update return type.

Return should be EventID for consistency with the new branding.

-): Promise<string> {
+): Promise<EventID> {

---

417-453: Good: redactMessage now brands the target ID. Also update return type.

Return should be EventID as well.

-): Promise<string> {
+): Promise<EventID> {

packages/federation-sdk/src/repositories/event-staging.repository.ts (1)

3-3: Prefer type-only import for Pdu.

Avoids emitting a runtime import for a type.

-import { type EventID, Pdu } from '@hs/room';
+import { type EventID, type Pdu } from '@hs/room';

packages/federation-sdk/src/utils/event-schemas.ts (1)

13-18: Align prev_events/auth_events with EventID branding.

These still accept string/tuple. If you intend to enforce EventID, update schemas to brand event IDs too while preserving tuple support.

-prev_events: z
-  .array(z.string().or(z.tuple([z.string(), z.string()])))
-  .optional(),
-auth_events: z
-  .array(z.string().or(z.tuple([z.string(), z.string()])))
-  .optional(),
+prev_events: z
+  .array(eventIdSchema.or(z.tuple([eventIdSchema, z.string()])))
+  .optional(),
+auth_events: z
+  .array(eventIdSchema.or(z.tuple([eventIdSchema, z.string()])))
+  .optional(),

If inbound federation must accept legacy strings, keep the union but brand the event_id member as above.

packages/room/src/types/_common.ts (2)

4-8: Branding scaffold is solid; consider not exporting the brand symbol.

Exporting Brand/Branded is fine; exporting the unique symbol is usually unnecessary. Optional.

-export declare const __brand: unique symbol;
+declare const __brand: unique symbol;
+export { __brand as /* internal */ __brand };

Or simply keep it non-exported if not needed by consumers of Brand/Branded.

---

1-1: Minor consistency nit: prefer named import from zod.

Other files import { z }. Standardize if you like.

-import z from 'zod';
+import { z } from 'zod';

packages/core/src/events/m.room.redaction.ts (1)

1-1: Unify import path and make it type-only.

Use the public barrel and avoid value import.

-import { EventID } from 'packages/room/dist';
+import type { EventID } from '@hs/room';

packages/federation-sdk/src/services/state.service.ts (1)

778-779: Drop redundant cast to EventID[].

Pdu.auth_events should already be EventID[]. Remove the cast to keep types honest.

-        const authEventsReferencedInMessage = await store.getEvents(
-            event.event.auth_events as EventID[],
-        );
+        const authEventsReferencedInMessage = await store.getEvents(
+            event.event.auth_events,
+        );

If this fails TS, there’s a lingering string[] somewhere in Pdu; I can help locate and fix.

packages/federation-sdk/src/repositories/event.repository.ts (1)

205-210: Minor: redundant _id != '' filter.

new events are always non-empty ids; this predicate adds noise and no safety.

-      .find({
-        nextEventId: '',
-        'event.room_id': roomId,
-        _id: { $ne: '' as EventID },
-      })
+      .find({
+        nextEventId: '',
+        'event.room_id': roomId,
+      })

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

packages/federation-sdk/src/services/state.service.ts (1)

376-379: Tighten internal cache/key types to EventID.

Minor type hygiene: cache and local arrays can use EventID/PersistentEventBase to avoid any[] widening.

-  const cache = new Map<string, PersistentEventBase>();
+  const cache = new Map<EventID, PersistentEventBase>();
   return {
-    getEvents: async (eventIds: EventID[]): Promise<PersistentEventBase[]> => {
-      const events = [];
-      const toFind = [];
+    getEvents: async (eventIds: EventID[]): Promise<PersistentEventBase[]> => {
+      const events: PersistentEventBase[] = [];
+      const toFind: EventID[] = [];

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Disabled knowledge base sources:

• Jira integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.