@undefineds.co/xpod 0.4.18 → 0.4.19

package/dist/api/matrix/PodMatrixStore.js

@@ -7,28 +7,46 @@ const drizzle_solid_1 = require("@undefineds.co/drizzle-solid");
 const models_1 = require("@undefineds.co/models");
 const reconciler_1 = require("../reconciler");
 const protocol_metadata_1 = require("../protocol-metadata");
+const MatrixError_1 = require("./MatrixError");
+const MatrixEventJournal_1 = require("./MatrixEventJournal");
+const WakeAgentQueue_1 = require("../reconciler/WakeAgentQueue");
 const AuthContext_1 = require("../auth/AuthContext");
 const schema = {
     chat: models_1.chatResource,
     thread: models_1.threadResource,
     message: models_1.messageResource,
+    run: models_1.runResource,
+    runStep: models_1.runStepResource,
+    delivery: models_1.deliveryResource,
 };
 class PodMatrixStore {
     constructor(options) {
         this.logger = (0, global_logger_factory_1.getLoggerFor)(this);
         this.serverName = options.serverName;
+        this.podAccess = options.podAccess;
+        this.journal = options.journal ?? new MatrixEventJournal_1.InMemoryMatrixEventJournal();
         this.serverGroupReconcilerService = options.serverGroupReconcilerService;
     }
     async getAccount(context) {
         const matrixUserId = this.getMatrixUserId(context);
         return {
             userId: matrixUserId,
-            deviceId: this.deviceIdFromUserId(context.webId),
+            deviceId: this.deviceId(context),
             displayName: this.displayNameFromUserId(matrixUserId),
         };
     }
     async createRoom(input, context) {
         const db = await this.getDb(context);
+        for (const state of input.initial_state ?? []) {
+            if (['m.room.create', 'm.room.member', 'm.room.encryption'].includes(state.type)) {
+                throw new MatrixError_1.MatrixError(400, 'M_BAD_JSON', 'Unsupported initial state event');
+            }
+            if (state.type === 'co.undefineds.agents')
+                this.validateAgentGrants(state.content ?? {});
+        }
+        if (input.creation_content?.['m.federate'] === true || (input.creation_content?.room_version && input.creation_content.room_version !== '11')) {
+            throw new MatrixError_1.MatrixError(400, 'M_UNSUPPORTED_ROOM_VERSION', 'Only non-federated room version 11 is supported');
+        }
         const sender = this.getMatrixUserId(context);
         const now = Date.now();
         const roomId = this.generateRoomId(context);
@@ -44,6 +62,7 @@ class PodMatrixStore {
             status: 'active',
             participants: [context.webId],
             metadata: (0, protocol_metadata_1.withProtocolMetadata)({
+                '@id': `${this.chatIri(roomId, context)}/metadata`,
                 protocol: 'matrix',
                 ...coordination,
             }, 'matrix', {
@@ -61,10 +80,11 @@ class PodMatrixStore {
         });
         await db.insert(models_1.threadResource).values({
             id: threadId,
-            parent: this.chatParentRefFromRoomId(roomId),
+            parent: this.chatIri(roomId, context),
             title: input.name ?? roomId,
             status: 'active',
             metadata: (0, protocol_metadata_1.withProtocolMetadata)({
+                '@id': `${this.threadIri(roomId, context)}/metadata`,
                 protocol: 'matrix',
                 commandKind: 'chat',
                 surface_id: this.surfaceIdFromRoomId(roomId),
@@ -148,82 +168,134 @@ class PodMatrixStore {
     async joinRoom(roomIdOrAlias, context) {
         const db = await this.getDb(context);
         const roomId = await this.resolveRoomId(db, roomIdOrAlias);
-        await this.ensureRoomExists(db, roomId);
+        const room = await this.roomSource(db, roomId);
         const sender = this.getMatrixUserId(context);
         const existing = await this.findLatestStateEvent(db, roomId, 'm.room.member', sender, context);
-        if (existing?.content.membership !== 'join') {
-            await this.appendMembershipEvent(db, roomId, sender, 'join', context);
+        if (existing?.content.membership === 'join')
+            return { roomId };
+        if (existing?.content.membership !== 'invite' && room.author !== context.webId) {
+            throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'An invitation is required');
         }
+        if (existing?.content.membership === 'ban')
+            throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'Banned from room');
+        await this.appendMembershipEvent(db, roomId, sender, 'join', context);
         return { roomId };
     }
     async inviteUser(roomId, userId, context) {
         const db = await this.getDb(context);
-        await this.ensureRoomExists(db, roomId);
+        await this.requireRoomOwner(db, roomId, context);
+        if (!/^@[^:]+:.+$/u.test(userId))
+            throw new MatrixError_1.MatrixError(400, 'M_BAD_JSON', 'Invalid Matrix user id');
         await this.appendMembershipEvent(db, roomId, userId, 'invite', context);
     }
     async leaveRoom(roomId, context) {
         const db = await this.getDb(context);
-        await this.ensureRoomExists(db, roomId);
+        await this.requireJoined(db, roomId, context);
         await this.appendMembershipEvent(db, roomId, this.getMatrixUserId(context), 'leave', context);
     }
     async sendEvent(roomId, eventType, txnId, content, context) {
         const db = await this.getDb(context);
-        await this.ensureRoomExists(db, roomId);
-        const existing = await this.findEventByTxnId(db, roomId, txnId, context);
-        if (existing) {
+        await this.requireJoined(db, roomId, context);
+        if (eventType !== 'm.room.message')
+            throw new MatrixError_1.MatrixError(400, 'M_UNRECOGNIZED', 'Only m.room.message timeline events are supported');
+        await this.authorizeTargets(db, roomId, content, context);
+        const reservation = await this.journal.reserveTransaction(this.scope(context), JSON.stringify([this.deviceId(context), roomId, eventType, txnId]), {
+            eventId: this.generateEventId(context), createdAt: Date.now(), contentHash: this.hash(this.canonicalJson(['user', context.webId, eventType, content])),
+        });
+        if (reservation.contentHash !== this.hash(this.canonicalJson(['user', context.webId, eventType, content]))) {
+            throw new MatrixError_1.MatrixError(409, 'M_CONFLICT', 'Transaction already reserved with different content');
+        }
+        const source = await db.findById(models_1.messageResource, this.messageResourceIdFromEvent(roomId, reservation.eventId, reservation.createdAt));
+        if (source) {
+            const existing = this.eventSourceToRecord(source, roomId, context);
+            if (reservation.contentHash !== this.hash(this.canonicalJson(['user', existing.senderWebId, existing.type, existing.content]))) {
+                throw new MatrixError_1.MatrixError(409, 'M_CONFLICT', 'Stored event no longer matches its receipt');
+            }
+            existing.depth = await this.journal.registerEvent(this.scope(context), roomId, existing.eventId);
+            await this.reconcileEvent(db, existing, context);
             return existing;
         }
-        const sender = this.getMatrixUserId(context);
-        const event = await this.appendEvent(db, {
-            roomId,
-            type: eventType,
-            sender,
-            txnId,
-            originServerTs: Date.now(),
-            content,
-        }, context);
-        return event;
+        return this.appendEvent(db, { roomId, type: eventType, sender: this.getMatrixUserId(context), txnId,
+            eventId: reservation.eventId, originServerTs: reservation.createdAt, content }, context);
     }
     async setState(roomId, eventType, stateKey, content, context) {
         const db = await this.getDb(context);
-        await this.ensureRoomExists(db, roomId);
-        return this.appendEvent(db, {
-            roomId,
-            type: eventType,
-            sender: this.getMatrixUserId(context),
-            stateKey,
-            originServerTs: Date.now(),
-            content,
-        }, context);
+        await this.requireJoined(db, roomId, context);
+        await this.requireRoomOwner(db, roomId, context);
+        if (['m.room.create', 'm.room.member', 'm.room.encryption'].includes(eventType)) {
+            throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'Use membership operations; immutable/encrypted state is unsupported');
+        }
+        if (eventType === 'co.undefineds.agents')
+            this.validateAgentGrants(content);
+        return this.appendEvent(db, { roomId, type: eventType, sender: this.getMatrixUserId(context), stateKey,
+            originServerTs: Date.now(), content }, context);
     }
     async sync(context, options = {}) {
+        const deadline = Date.now() + Math.min(Math.max(options.timeout ?? 0, 0), 30_000);
+        let result;
+        // First pass indexes native Pod writes; the second reads a committed journal watermark.
+        await this.syncOnce(context, options);
+        do {
+            result = await this.syncOnce(context, options);
+            if (Object.values(result.rooms.join).some(room => room.timeline.events.length)
+                || Object.keys(result.rooms.invite ?? {}).length || Date.now() >= deadline || options.signal?.aborted)
+                return result;
+            await new Promise((resolve) => {
+                const done = () => { clearTimeout(timer); options.signal?.removeEventListener('abort', done); resolve(); };
+                const timer = setTimeout(done, Math.min(500, Math.max(0, deadline - Date.now())));
+                options.signal?.addEventListener('abort', done, { once: true });
+            });
+        } while (!options.signal?.aborted);
+        return result;
+    }
+    async syncOnce(context, options) {
         const db = await this.getDb(context);
-        const rooms = await this.listJoinedRoomRecords(db, context);
-        const sinceTs = this.parseSyncToken(options.since);
-        const limit = options.limit && options.limit > 0 ? options.limit : 50;
+        const since = this.parseSyncToken(options.since);
+        const snapshot = await this.journal.getHighWatermark(this.scope(context));
+        const limit = Math.min(Math.max(options.limit ?? 50, 1), 1000);
         const join = {};
-        for (const room of rooms) {
-            const events = await this.listEvents(db, room.roomId, context, {
-                sinceTs,
-                limit,
-            });
-            join[room.roomId] = {
-                state: {
-                    events: events.filter((event) => event.stateKey !== undefined).map((event) => this.toClientEvent(event)),
-                },
-                timeline: {
-                    events: events.map((event) => this.toClientEvent(event)),
-                    limited: false,
-                },
-                'co.undefineds.coordination': {
-                    reconcilerOwner: room.reconcilerOwner,
-                },
-            };
+        const invite = {};
+        const leave = {};
+        const batches = [];
+        for (const room of await this.listRooms(db)) {
+            const events = (await this.listEvents(db, room.roomId, context)).filter(e => e.depth <= snapshot);
+            const membership = this.latestState(events, 'm.room.member', this.getMatrixUserId(context));
+            if (membership?.content.membership === 'invite') {
+                if ((membership.depth ?? 0) > since)
+                    invite[room.roomId] = { invite_state: { events: [this.toClientEvent(membership)] } };
+                continue;
+            }
+            if (membership?.content.membership === 'leave' || membership?.content.membership === 'ban') {
+                if ((membership.depth ?? 0) > since)
+                    leave[room.roomId] = { timeline: { events: [this.toClientEvent(membership)], limited: false } };
+                continue;
+            }
+            if (membership?.content.membership !== 'join' && room.creator !== context.webId)
+                continue;
+            batches.push({ room, events });
         }
-        return {
-            next_batch: this.encodeSyncToken(Date.now()),
-            rooms: { join },
-        };
+        const candidates = batches.flatMap(b => b.events).filter(e => (e.depth ?? 0) > since)
+            .sort((a, b) => (a.depth ?? 0) - (b.depth ?? 0));
+        const selected = candidates.slice(0, limit);
+        const ids = new Set(selected.map(e => e.eventId));
+        for (const { room, events } of batches) {
+            const page = events.filter(e => ids.has(e.eventId));
+            const state = new Map();
+            const firstSequence = page[0]?.depth ?? since;
+            // State at the start of this timeline; events in the timeline apply after it.
+            for (const event of events)
+                if (event.stateKey !== undefined && (event.depth ?? 0) < firstSequence)
+                    state.set(JSON.stringify([event.type, event.stateKey]), event);
+            join[room.roomId] = { state: { events: [...state.values()].map(e => this.toClientEvent(e)) },
+                timeline: { events: page.map(e => this.toClientEvent(e)), limited: candidates.length > selected.length,
+                    ...(page.length ? { prev_batch: this.encodeSyncToken((page[0].depth ?? 1) - 1) } : {}) },
+                'co.undefineds.coordination': { reconcilerOwner: room.reconcilerOwner } };
+        }
+        const transitionPositions = [...Object.values(invite).flatMap(r => r.invite_state.events), ...Object.values(leave).flatMap(r => r.timeline.events)];
+        // When a joined timeline has backlog, do not advance past its last delivered event.
+        const next = selected.length ? selected[selected.length - 1].depth : since;
+        const high = candidates.length === 0 && transitionPositions.length ? snapshot : next;
+        return { next_batch: this.encodeSyncToken(high), rooms: { join, invite, leave } };
     }
     async listJoinedRooms(context) {
         const db = await this.getDb(context);
@@ -231,7 +303,7 @@ class PodMatrixStore {
     }
     async getMembers(roomId, context) {
         const db = await this.getDb(context);
-        await this.ensureRoomExists(db, roomId);
+        await this.requireJoined(db, roomId, context);
         const events = await this.listEvents(db, roomId, context, { newestFirst: true });
         const latestByStateKey = new Map();
         for (const event of events) {
@@ -246,36 +318,34 @@ class PodMatrixStore {
     }
     async listMessages(roomId, context, options = {}) {
         const db = await this.getDb(context);
-        await this.ensureRoomExists(db, roomId);
-        const limit = options.limit && options.limit > 0 ? options.limit : 50;
-        const fromTs = this.parseSyncToken(options.from);
+        await this.requireJoined(db, roomId, context);
+        await this.listEvents(db, roomId, context);
+        const snapshot = await this.journal.getHighWatermark(this.scope(context));
+        const all = (await this.listEvents(db, roomId, context)).filter(e => e.depth <= snapshot);
         const forward = options.dir === 'f';
-        const events = await this.listEvents(db, roomId, context, {
-            sinceTs: forward && fromTs > 0 ? fromTs : undefined,
-            beforeOrAtTs: !forward && fromTs > 0 ? fromTs : undefined,
-            limit,
-            newestFirst: !forward,
-        });
-        const chunk = events.slice(0, limit).map((event) => this.toClientEvent(event));
-        return {
-            chunk,
-            start: options.from,
-            end: this.encodeSyncToken(chunk.length ? chunk[chunk.length - 1].origin_server_ts : Date.now()),
-        };
+        const from = options.from ? this.parseSyncToken(options.from) : (forward ? 0 : Number.MAX_SAFE_INTEGER);
+        const events = all.filter(e => forward ? e.depth > from : e.depth <= from);
+        if (!forward)
+            events.reverse();
+        const page = events.slice(0, Math.min(Math.max(options.limit ?? 50, 1), 1000));
+        const boundary = page.length ? page[page.length - 1].depth - (forward ? 0 : 1) : (forward ? from : 0);
+        return { chunk: page.map(e => this.toClientEvent(e)), start: options.from, end: this.encodeSyncToken(boundary) };
     }
     async getEvent(roomId, eventId, context) {
         const db = await this.getDb(context);
+        await this.requireJoined(db, roomId, context);
         const event = await this.findEventById(db, roomId, eventId, context);
         if (!event) {
-            throw new Error(`Matrix event not found: ${eventId}`);
+            throw new MatrixError_1.MatrixError(404, 'M_NOT_FOUND', 'Event not found');
         }
         return this.toClientEvent(event);
     }
     async getState(roomId, eventType, stateKey, context) {
         const db = await this.getDb(context);
+        await this.requireJoined(db, roomId, context);
         const event = await this.findLatestStateEvent(db, roomId, eventType, stateKey, context);
         if (!event) {
-            throw new Error(`Matrix state not found: ${eventType}/${stateKey}`);
+            throw new MatrixError_1.MatrixError(404, 'M_NOT_FOUND', 'State not found');
         }
         return event.content;
     }
@@ -284,11 +354,16 @@ class PodMatrixStore {
             return context._matrixDb;
         }
         const auth = context.auth;
-        if (!auth || !(0, AuthContext_1.isSolidAuth)(auth) || !auth.accessToken || !auth.webId) {
-            throw new Error('Matrix API requires Solid access-token authentication');
+        if (!auth || !(0, AuthContext_1.isSolidAuth)(auth) || !auth.webId) {
+            throw new MatrixError_1.MatrixError(401, 'M_UNKNOWN_TOKEN', 'Solid authentication is required');
         }
+        const podFetch = this.podAccess
+            ? await this.podAccess.getPodFetch(context.webId, { auth, podBaseUrl: context.podUrl })
+            : undefined;
+        if (!podFetch)
+            throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'Grant Pod interface access before using Matrix');
         const db = (0, drizzle_solid_1.drizzle)({
-            fetch: this.createAccessTokenFetch(auth.accessToken, auth.tokenType),
+            fetch: podFetch,
             info: {
                 webId: auth.webId,
                 isLoggedIn: true,
@@ -298,29 +373,13 @@ class PodMatrixStore {
             schema,
             podUrl: context.podUrl,
         });
-        await db.init(models_1.chatResource, models_1.threadResource, models_1.messageResource);
+        await db.init(models_1.chatResource, models_1.threadResource, models_1.runResource, models_1.runStepResource, models_1.deliveryResource, models_1.messageResource);
         context._matrixDb = db;
         return db;
     }
-    createAccessTokenFetch(accessToken, tokenType) {
-        const scheme = tokenType ?? 'Bearer';
-        return async (input, init) => {
-            const headers = new Headers(init?.headers);
-            if (!headers.has('Authorization')) {
-                headers.set('Authorization', `${scheme} ${accessToken}`);
-            }
-            return fetch(input, { ...init, headers });
-        };
-    }
-    async ensureRoomExists(db, roomId) {
-        const room = await db.findById(models_1.chatResource, this.chatResourceIdFromRoomId(roomId));
-        if (!room) {
-            throw new Error(`Matrix room not found: ${roomId}`);
-        }
-    }
     async appendEvent(db, input, context) {
-        const eventId = this.generateEventId(context);
-        const depth = await this.nextEventDepth(db, input.roomId, context);
+        const eventId = input.eventId ?? this.generateEventId(context);
+        const depth = 0;
         const originIso = new Date(input.originServerTs).toISOString();
         const needsRoomMetadata = input.reconcilerOwner === undefined
             || (input.type === 'm.room.message' && this.serverGroupReconcilerService !== undefined);
@@ -329,7 +388,7 @@ class PodMatrixStore {
         const reconcilerOwner = input.reconcilerOwner ?? this.reconcilerOwnerFromRoomMetadata(roomMetadata);
         const coordination = (0, reconciler_1.reconcilerCoordinationMetadata)(reconcilerOwner);
         const messageResourceId = this.messageResourceIdFromEvent(input.roomId, eventId, input.originServerTs);
-        const thread = this.resolveDataResourceUriFromId(this.threadResourceIdFromRoomId(input.roomId), context);
+        const thread = this.threadIri(input.roomId, context);
         const contentText = this.messageContentFromMatrixEvent(input.type, input.content);
         const mentions = this.mentionsFromMatrixContent(input.content);
         const routeTargetAgent = this.routeTargetAgentFromMatrixContent(input.content);
@@ -338,9 +397,11 @@ class PodMatrixStore {
             roomId: input.roomId,
             type: input.type,
             sender: input.sender,
-            senderWebId: context.webId,
+            senderWebId: input.maker ?? context.webId,
             originServerTs: input.originServerTs,
             depth,
+            role: input.role ?? (input.type === 'm.room.message' ? models_1.MessageRole.USER : models_1.MessageRole.SYSTEM),
+            resourceId: messageResourceId,
             txnId: input.txnId ?? undefined,
             stateKey: input.stateKey ?? undefined,
             content: input.content,
@@ -348,16 +409,18 @@ class PodMatrixStore {
         };
         await db.insert(models_1.messageResource).values({
             id: messageResourceId,
-            parent: this.resolveDataResourceUriFromId(this.messageParentResourceIdFromRoomId(input.roomId), context),
-            chat: this.chatResourceIdFromRoomId(input.roomId),
+            parent: this.chatIri(input.roomId, context),
+            chat: this.chatIri(input.roomId, context),
             thread,
-            maker: context.webId,
-            role: input.type === 'm.room.message' ? models_1.MessageRole.USER : models_1.MessageRole.SYSTEM,
+            maker: input.maker ?? context.webId,
+            role: input.role ?? (input.type === 'm.room.message' ? models_1.MessageRole.USER : models_1.MessageRole.SYSTEM),
             content: contentText,
             status: models_1.MessageStatus.SENT,
             mentions,
             routeTargetAgent: routeTargetAgent ?? null,
+            replyTo: typeof input.content['co.undefineds.replyTo'] === 'string' ? input.content['co.undefineds.replyTo'] : null,
             metadata: (0, protocol_metadata_1.withProtocolMetadata)({
+                '@id': `${models_1.messageResource.buildIri(this.scope(context), { id: messageResourceId })}/metadata`,
                 protocol: 'matrix',
                 commandKind: 'chat',
                 surface_id: this.surfaceIdFromRoomId(input.roomId),
@@ -367,7 +430,7 @@ class PodMatrixStore {
                 roomId: input.roomId,
                 eventType: input.type,
                 sender: input.sender,
-                senderWebId: context.webId,
+                senderWebId: input.maker ?? context.webId,
                 originServerTs: input.originServerTs,
                 depth,
                 txnId: input.txnId ?? null,
@@ -377,17 +440,9 @@ class PodMatrixStore {
             createdAt: originIso,
             updatedAt: originIso,
         });
-        await this.reconcileGroupUserMessage({
-            thread,
-            triggerMessage: this.resolveDataResourceUriFromId(messageResourceId, context),
-            actor: context.webId,
-            role: input.type === 'm.room.message' ? models_1.MessageRole.USER : models_1.MessageRole.SYSTEM,
-            content: contentText,
-            reconcilerOwner,
-            mentions,
-            routeTargetAgent,
-            participants: roomContext?.participants,
-        });
+        record.depth = await this.journal.registerEvent(this.scope(context), input.roomId, eventId);
+        if (record.role === models_1.MessageRole.USER)
+            await this.reconcileEvent(db, record, context);
         return record;
     }
     async appendMembershipEvent(db, roomId, memberUserId, membership, context, options = {}) {
@@ -417,7 +472,7 @@ class PodMatrixStore {
         const joined = [];
         for (const room of rooms) {
             const membership = await this.findLatestStateEvent(db, room.roomId, 'm.room.member', matrixUserId, context);
-            if (!membership || membership.content.membership === 'join' || membership.content.membership === 'invite') {
+            if (membership?.content.membership === 'join' || (!membership && room.creator === context.webId)) {
                 joined.push(room);
             }
         }
@@ -430,61 +485,51 @@ class PodMatrixStore {
         const rooms = await this.listRooms(db);
         const room = rooms.find((candidate) => candidate.canonicalAlias === roomIdOrAlias);
         if (!room) {
-            throw new Error(`Matrix room alias not found: ${roomIdOrAlias}`);
+            throw new MatrixError_1.MatrixError(404, 'M_NOT_FOUND', 'Room alias not found');
         }
         return room.roomId;
     }
     async listEvents(db, roomId, context, options = {}) {
-        const conditions = [
-            (0, drizzle_solid_1.eq)(models_1.messageResource.thread, this.resolveDataResourceUriFromId(this.threadResourceIdFromRoomId(roomId), context)),
-            options.sinceTs !== undefined ? (0, drizzle_solid_1.gt)(models_1.messageResource.createdAt, new Date(options.sinceTs).toISOString()) : undefined,
-            options.beforeOrAtTs !== undefined ? (0, drizzle_solid_1.lte)(models_1.messageResource.createdAt, new Date(options.beforeOrAtTs).toISOString()) : undefined,
-        ];
-        let query = db.select().from(models_1.messageResource).where((0, drizzle_solid_1.and)(...conditions));
-        query = options.newestFirst
-            ? query.orderBy((0, drizzle_solid_1.desc)(models_1.messageResource.createdAt))
-            : query.orderBy((0, drizzle_solid_1.asc)(models_1.messageResource.createdAt));
-        if (options.limit && options.limit > 0) {
-            query = query.limit(options.limit);
-        }
-        const events = await query;
-        return events.map((event) => this.eventSourceToRecord(event));
-    }
-    async findEventByTxnId(db, roomId, txnId, context) {
-        const records = await this.listEvents(db, roomId, context);
-        return records.find((record) => record.txnId === txnId);
+        const sources = await db.select().from(models_1.messageResource)
+            .where((0, drizzle_solid_1.eq)(models_1.messageResource.thread, this.threadIri(roomId, context)));
+        sources.sort((a, b) => (this.isoToMillis(a.createdAt) ?? 0) - (this.isoToMillis(b.createdAt) ?? 0) || a.id.localeCompare(b.id));
+        const events = [];
+        for (const source of sources) {
+            const event = this.eventSourceToRecord(source, roomId, context);
+            event.depth = await this.journal.registerEvent(this.scope(context), roomId, event.eventId);
+            events.push(event);
+        }
+        events.sort((a, b) => a.depth - b.depth);
+        return options.newestFirst ? events.reverse() : events;
     }
     async findEventById(db, roomId, eventId, context) {
         const records = await this.listEvents(db, roomId, context);
         return records.find((record) => record.eventId === eventId);
     }
-    async nextEventDepth(db, roomId, context) {
-        const records = await this.listEvents(db, roomId, context);
-        return records.reduce((max, record) => Math.max(max, record.depth ?? 0), 0) + 1;
-    }
     async findLatestStateEvent(db, roomId, eventType, stateKey, context) {
         const records = await this.listEvents(db, roomId, context, { newestFirst: true });
         return records.find((record) => record.type === eventType && (record.stateKey ?? '') === stateKey);
     }
-    eventSourceToRecord(source) {
+    eventSourceToRecord(source, roomId, context) {
         const metadata = this.parseJsonObject(source.metadata) ?? {};
         const matrix = (0, protocol_metadata_1.getProtocolMetadata)(metadata, 'matrix') ?? {};
         const content = this.parseJsonObject(matrix.content)
             ?? this.parseJsonObject(metadata.content)
-            ?? this.parseJsonObject(source.content)
-            ?? {};
+            ?? { msgtype: 'm.text', body: typeof source.content === 'string' ? source.content : JSON.stringify(source.content ?? '') };
         const unsigned = this.parseJsonObject(matrix.unsigned)
             ?? this.parseJsonObject(metadata.unsigned);
         const stateKey = this.stringValue(matrix.stateKey ?? matrix.state_key ?? metadata.stateKey);
         const txnId = this.stringValue(matrix.txnId ?? matrix.txn_id ?? metadata.txnId);
         return {
-            eventId: this.stringValue(matrix.eventId ?? matrix.event_id ?? metadata.eventId) ?? source.id,
-            roomId: this.stringValue(matrix.roomId ?? matrix.room_id ?? metadata.roomId) ?? '',
+            eventId: this.stringValue(matrix.eventId ?? matrix.event_id ?? metadata.eventId) ?? `$${this.hash(source.id)}:${this.getServerName(context)}`,
+            roomId: this.stringValue(matrix.roomId ?? matrix.room_id ?? metadata.roomId) ?? roomId,
             type: this.stringValue(matrix.eventType ?? matrix.event_type ?? metadata.eventType) ?? 'm.room.message',
-            sender: this.stringValue(matrix.sender ?? metadata.sender) ?? '',
+            sender: this.stringValue(matrix.sender ?? metadata.sender) ?? this.getMatrixUserId({ ...context, webId: source.maker ?? context.webId }),
             senderWebId: this.stringValue(matrix.senderWebId ?? matrix.sender_web_id ?? metadata.senderWebId) ?? source.maker ?? undefined,
             originServerTs: this.numberValue(matrix.originServerTs ?? matrix.origin_server_ts ?? metadata.originServerTs) ?? this.isoToMillis(source.createdAt) ?? Date.now(),
             depth: this.numberValue(matrix.depth ?? metadata.depth),
+            role: source.role,
+            resourceId: source.id,
             txnId: txnId ?? undefined,
             content,
             stateKey: stateKey ?? undefined,
@@ -525,6 +570,329 @@ class PodMatrixStore {
             ...(event.unsigned ? { unsigned: event.unsigned } : {}),
         };
     }
+    scope(context) {
+        if (!context.podUrl)
+            throw new MatrixError_1.MatrixError(400, 'M_BAD_JSON', 'A resolved Pod URL is required');
+        return context.podUrl;
+    }
+    hash(value) { return (0, node_crypto_1.createHash)('sha256').update(value).digest('hex'); }
+    canonicalJson(value) {
+        if (Array.isArray(value))
+            return `[${value.map(item => this.canonicalJson(item)).join(',')}]`;
+        if (value && typeof value === 'object')
+            return `{${Object.entries(value).filter(([, v]) => v !== undefined).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${JSON.stringify(k)}:${this.canonicalJson(v)}`).join(',')}}`;
+        return JSON.stringify(value) ?? 'null';
+    }
+    chatIri(roomId, context) {
+        return models_1.chatResource.buildIri(this.scope(context), { id: this.surfaceIdFromRoomId(roomId) });
+    }
+    threadIri(roomId, context) {
+        return models_1.threadResource.buildIri(this.scope(context), { id: 'thread', parent: this.chatIri(roomId, context) });
+    }
+    async roomSource(db, roomId) {
+        const room = await db.findById(models_1.chatResource, this.chatResourceIdFromRoomId(roomId));
+        if (!room)
+            throw new MatrixError_1.MatrixError(404, 'M_NOT_FOUND', 'Room not found');
+        return room;
+    }
+    async requireRoomOwner(db, roomId, context) {
+        if ((await this.roomSource(db, roomId)).author !== context.webId)
+            throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'Room owner authority is required');
+    }
+    async requireJoined(db, roomId, context, events) {
+        const room = await this.roomSource(db, roomId);
+        const state = events ? this.latestState(events, 'm.room.member', this.getMatrixUserId(context)) : await this.findLatestStateEvent(db, roomId, 'm.room.member', this.getMatrixUserId(context), context);
+        if (state?.content.membership === 'join' || (!state && room.author === context.webId))
+            return;
+        throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'Join the room before accessing its timeline');
+    }
+    latestState(events, type, key) {
+        return [...events].reverse().find(e => e.type === type && e.stateKey === key);
+    }
+    validateAgentGrants(content) {
+        if (!Array.isArray(content.agents) || content.agents.length > 32)
+            throw new MatrixError_1.MatrixError(400, 'M_BAD_JSON', 'agents must be an array of at most 32 grants');
+        const uri = (value) => {
+            if (typeof value !== 'string')
+                return false;
+            try {
+                const url = new URL(value);
+                return ['http:', 'https:'].includes(url.protocol) && !url.username && !url.password;
+            }
+            catch {
+                return false;
+            }
+        };
+        const grants = [];
+        for (const value of content.agents) {
+            const grant = value;
+            if (!grant || !uri(grant.agent) || !uri(grant.executor) || !uri(grant.workspace)
+                || !Array.isArray(grant.allowedActors) || !grant.allowedActors.every(uri)
+                || !Array.isArray(grant.handoffTo) || !grant.handoffTo.every(uri)
+                || grant.allowedActors.length > 32 || grant.handoffTo.length > 32
+                || grants.some(g => g.agent === grant.agent))
+                throw new MatrixError_1.MatrixError(400, 'M_BAD_JSON', 'Invalid or duplicate agent grant');
+            grants.push(grant);
+        }
+        if (grants.some(g => g.handoffTo.some(target => !grants.some(candidate => candidate.agent === target)))) {
+            throw new MatrixError_1.MatrixError(400, 'M_BAD_JSON', 'Handoff targets must be registered agents');
+        }
+        return grants;
+    }
+    async agentGrants(db, roomId, context, events) {
+        const state = events ? this.latestState(events, 'co.undefineds.agents', '') : await this.findLatestStateEvent(db, roomId, 'co.undefineds.agents', '', context);
+        return state ? this.validateAgentGrants(state.content) : [];
+    }
+    async authorizeTargets(db, roomId, content, context, events) {
+        const target = this.routeTargetAgentFromMatrixContent(content);
+        const targets = target ? [target] : this.mentionsFromMatrixContent(content);
+        if (!targets.length)
+            return [];
+        const grants = await this.agentGrants(db, roomId, context, events);
+        if (targets.some(agent => !grants.some(g => g.agent === agent && g.allowedActors.includes(context.webId)))) {
+            throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'Agent execution is not granted to this actor');
+        }
+        return targets;
+    }
+    async reconcileEvent(db, event, context, events) {
+        if (!this.serverGroupReconcilerService || event.type !== 'm.room.message' || event.role !== models_1.MessageRole.USER)
+            return;
+        const actor = event.senderWebId;
+        if (!actor)
+            return;
+        const receipt = await this.journal.findReservation(this.scope(context), event.eventId);
+        if (!receipt || receipt.contentHash !== this.hash(this.canonicalJson(['user', actor, event.type, event.content])))
+            return;
+        const targets = await this.authorizeTargets(db, event.roomId, event.content, { ...context, webId: actor }, events);
+        const pending = [];
+        for (const target of targets)
+            if (await this.ensureDelivery(db, event, target, context))
+                pending.push(target);
+        if (!pending.length)
+            return;
+        const room = await this.roomSource(db, event.roomId);
+        await this.reconcileGroupUserMessage({ thread: this.threadIri(event.roomId, context),
+            triggerMessage: models_1.messageResource.buildIri(this.scope(context), { id: event.resourceId }), actor, role: 'user',
+            content: typeof event.content.body === 'string' ? event.content.body : '', createdAt: new Date(event.originServerTs).toISOString(),
+            reconcilerOwner: this.reconcilerOwnerFromRoomMetadata(this.parseJsonObject(room.metadata)),
+            mentions: pending, participants: pending });
+    }
+    /** Runtime principals must have both Pod access and an explicit room execution grant. */
+    async authorize(roomId, agent, context) {
+        const db = await this.getDb(context);
+        const events = await this.listEvents(db, roomId, context);
+        await this.requireJoined(db, roomId, context, events);
+        const grant = (await this.agentGrants(db, roomId, context, events)).find(g => g.agent === agent && g.executor === context.webId);
+        if (!grant)
+            throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'No execution grant for this agent');
+        return { thread: this.threadIri(roomId, context) };
+    }
+    /** Rebuild operational work from Pod facts after an interrupted write or queue restart. */
+    async recover(roomId, context) {
+        const db = await this.getDb(context);
+        const events = await this.listEvents(db, roomId, context);
+        await this.requireJoined(db, roomId, context, events);
+        for (const event of events) {
+            if (event.role === models_1.MessageRole.USER) {
+                try {
+                    await this.reconcileEvent(db, event, context, events);
+                }
+                catch (error) {
+                    if (!(error instanceof MatrixError_1.MatrixError && error.status === 403))
+                        throw error;
+                }
+            }
+            if (event.role === models_1.MessageRole.ASSISTANT)
+                await this.reconcileHandoff(db, event, context, events);
+        }
+    }
+    async loadInput(roomId, job, context) {
+        const db = await this.getDb(context);
+        const events = await this.listEvents(db, roomId, context);
+        await this.requireJoined(db, roomId, context, events);
+        if (!(await this.agentGrants(db, roomId, context, events)).some(g => g.agent === job.agent && g.executor === context.webId)) {
+            throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'No execution grant for this agent');
+        }
+        const event = events.find(e => models_1.messageResource.buildIri(this.scope(context), { id: e.resourceId }) === job.triggerMessage);
+        if (!event)
+            throw new MatrixError_1.MatrixError(404, 'M_NOT_FOUND', 'Trigger message not found');
+        const grant = (await this.agentGrants(db, roomId, context, events)).find(g => g.agent === job.agent);
+        await this.validateTrigger(db, event, job, context, events);
+        const values = { id: job.id, thread: job.thread, createdAt: job.createdAt };
+        const delivery = await db.findById(models_1.deliveryResource, models_1.deliveryResource.buildId(values));
+        const previous = await db.findById(models_1.runResource, models_1.runResource.buildId(values));
+        if (['completed', 'failed', 'cancelled'].includes(delivery?.status) || this.runAttempts(previous) >= 3) {
+            throw new MatrixError_1.MatrixError(409, 'M_CONFLICT', 'Execution is terminal or its retry budget is exhausted');
+        }
+        const run = await this.materializeRun(db, roomId, job, context, 'running', undefined, undefined, grant.workspace);
+        return { content: typeof event.content.body === 'string' ? event.content.body : '', thread: job.thread,
+            triggerMessage: job.triggerMessage, agent: job.agent, workspace: grant.workspace, run,
+            history: events.filter(e => e.type === 'm.room.message').slice(-50).map(e => ({ role: e.role, body: e.content.body, eventId: e.eventId })) };
+    }
+    async commitResult(roomId, job, result, context) {
+        const db = await this.getDb(context);
+        const events = await this.listEvents(db, roomId, context);
+        await this.requireJoined(db, roomId, context, events);
+        if (!(await this.agentGrants(db, roomId, context, events)).some(g => g.agent === job.agent && g.executor === context.webId)) {
+            throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'No execution grant for this agent');
+        }
+        const grant = (await this.agentGrants(db, roomId, context, events)).find(g => g.agent === job.agent);
+        const trigger = events.find(e => models_1.messageResource.buildIri(this.scope(context), { id: e.resourceId }) === job.triggerMessage);
+        if (!trigger)
+            throw new MatrixError_1.MatrixError(404, 'M_NOT_FOUND', 'Trigger message not found');
+        await this.validateTrigger(db, trigger, job, context, events);
+        const prior = trigger.role === models_1.MessageRole.ASSISTANT
+            ? this.parseJsonObject(trigger.content['co.undefineds.execution']) : undefined;
+        const hops = typeof prior?.hops === 'number' ? prior.hops + 1 : 1;
+        if (result.handoffTo && (!grant.handoffTo.includes(result.handoffTo) || hops >= 8)) {
+            throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'Handoff is not granted or its hop limit was reached');
+        }
+        const content = { msgtype: 'm.text', body: result.body, 'co.undefineds.replyTo': job.triggerMessage,
+            'm.relates_to': { 'm.in_reply_to': { event_id: trigger.eventId } },
+            'co.undefineds.execution': { jobId: job.id, agent: job.agent, hops, handoffTo: result.handoffTo,
+                root: prior?.root ?? job.triggerMessage, evidence: result.evidence ?? [] } };
+        const contentHash = this.hash(this.canonicalJson(['assistant', job.agent, 'm.room.message', content]));
+        const key = JSON.stringify(['wake-result', job.id]);
+        const reservation = await this.journal.reserveTransaction(this.scope(context), key, {
+            eventId: `$${this.hash(key)}:${this.getServerName(context)}`, createdAt: Date.now(), contentHash
+        });
+        if (reservation.contentHash !== contentHash)
+            throw new MatrixError_1.MatrixError(409, 'M_CONFLICT', 'A different result was already reserved for this wake');
+        let output = events.find(e => e.eventId === reservation.eventId);
+        if (!output) {
+            output = await this.appendEvent(db, { roomId, type: 'm.room.message', sender: this.getMatrixUserId({ ...context, webId: job.agent }),
+                maker: job.agent, role: models_1.MessageRole.ASSISTANT, eventId: reservation.eventId, originServerTs: reservation.createdAt, content }, context);
+        }
+        else if (this.hash(this.canonicalJson(['assistant', job.agent, output.type, output.content])) !== reservation.contentHash) {
+            throw new MatrixError_1.MatrixError(409, 'M_CONFLICT', 'Stored result no longer matches its receipt');
+        }
+        const run = await this.materializeRun(db, roomId, job, context, 'completed', output.eventId, undefined, grant.workspace);
+        const deliveryId = models_1.deliveryResource.buildId({ id: job.id, thread: job.thread, createdAt: job.createdAt });
+        await db.updateById(models_1.deliveryResource, deliveryId, { status: 'completed', completedAt: new Date().toISOString() });
+        await this.reconcileHandoff(db, output, context, events);
+        return { eventId: output.eventId, run };
+    }
+    async validateTrigger(db, event, job, context, events) {
+        const receipt = await this.journal.findReservation(this.scope(context), event.eventId);
+        let valid = false;
+        if (event.role === models_1.MessageRole.USER && event.senderWebId) {
+            valid = receipt?.contentHash === this.hash(this.canonicalJson(['user', event.senderWebId, event.type, event.content]));
+            if (valid)
+                valid = (await this.authorizeTargets(db, event.roomId, event.content, { ...context, webId: event.senderWebId }, events)).includes(job.agent);
+        }
+        else if (event.role === models_1.MessageRole.ASSISTANT) {
+            const execution = this.parseJsonObject(event.content['co.undefineds.execution']);
+            if (execution && typeof execution.agent === 'string' && execution.handoffTo === job.agent &&
+                typeof execution.hops === 'number' && execution.hops < 8) {
+                valid = receipt?.contentHash === this.hash(this.canonicalJson(['assistant', execution.agent, event.type, event.content]));
+                if (valid)
+                    valid = (await this.agentGrants(db, event.roomId, context, events)).some(g => g.agent === execution.agent && g.handoffTo.includes(job.agent));
+            }
+        }
+        if (!valid || job.thread !== this.threadIri(event.roomId, context)) {
+            throw new MatrixError_1.MatrixError(403, 'M_FORBIDDEN', 'Trigger receipt or current execution authorization is invalid');
+        }
+    }
+    async recordFailure(roomId, job, failure, context) {
+        const db = await this.getDb(context);
+        const values = { id: job.id, thread: job.thread, createdAt: job.createdAt };
+        const existing = await db.findById(models_1.runResource, models_1.runResource.buildId(values));
+        const terminal = !failure.retry || this.runAttempts(existing) >= 3;
+        if (existing?.status === 'completed')
+            return;
+        await this.materializeRun(db, roomId, job, context, terminal ? 'failed' : 'queued', undefined, failure.error);
+        await db.updateById(models_1.deliveryResource, models_1.deliveryResource.buildId(values), {
+            status: terminal ? 'failed' : 'pending', updatedAt: new Date().toISOString(),
+            ...(terminal ? { completedAt: new Date().toISOString() } : {}),
+        });
+    }
+    runAttempts(row) {
+        const metadata = this.parseJsonObject(row?.metadata);
+        const protocols = this.parseJsonObject(metadata?.protocols);
+        const matrix = this.parseJsonObject(protocols?.matrix);
+        return typeof matrix?.attempts === 'number' ? matrix.attempts : 0;
+    }
+    async reconcileHandoff(db, event, context, events) {
+        const execution = this.parseJsonObject(event.content['co.undefineds.execution']);
+        if (!execution?.handoffTo || typeof execution.agent !== 'string' || typeof execution.handoffTo !== 'string'
+            || typeof execution.hops !== 'number' || execution.hops >= 8 || !this.serverGroupReconcilerService)
+            return;
+        const receipt = await this.journal.findReservation(this.scope(context), event.eventId);
+        if (!receipt || receipt.contentHash !== this.hash(this.canonicalJson(['assistant', execution.agent, event.type, event.content])))
+            return;
+        const grants = await this.agentGrants(db, event.roomId, context, events);
+        if (!grants.some(g => g.agent === execution.agent && g.handoffTo.includes(execution.handoffTo)))
+            return;
+        if (!await this.ensureDelivery(db, event, execution.handoffTo, context))
+            return;
+        // Only output with an API-issued receipt can trigger a handoff; direct Pod writes cannot.
+        await this.serverGroupReconcilerService.reconcileThreadMessage({ thread: this.threadIri(event.roomId, context),
+            triggerMessage: models_1.messageResource.buildIri(this.scope(context), { id: event.resourceId }), actor: execution.agent,
+            role: 'user', createdAt: new Date(event.originServerTs).toISOString(), reconcilerOwner: 'server', routeTargetAgent: execution.handoffTo, participants: grants.map(g => g.agent) });
+    }
+    async ensureDelivery(db, event, agent, context) {
+        const thread = this.threadIri(event.roomId, context);
+        const triggerMessage = models_1.messageResource.buildIri(this.scope(context), { id: event.resourceId });
+        const jobId = (0, WakeAgentQueue_1.sharedWakeAgentJobId)({ thread, triggerMessage, agent });
+        const createdAt = new Date(event.originServerTs).toISOString();
+        const id = models_1.deliveryResource.buildId({ id: jobId, thread, createdAt });
+        const existing = await db.findById(models_1.deliveryResource, id);
+        if (existing?.status === 'completed' || existing?.status === 'cancelled' || existing?.status === 'failed')
+            return false;
+        // Complete a write interrupted after the result Message but before Run/Delivery ACK.
+        const resultEventId = `$${this.hash(JSON.stringify(['wake-result', jobId]))}:${this.getServerName(context)}`;
+        const receipt = await this.journal.findReservation(this.scope(context), resultEventId);
+        if (receipt) {
+            const source = await db.findById(models_1.messageResource, this.messageResourceIdFromEvent(event.roomId, resultEventId, receipt.createdAt));
+            if (source) {
+                const output = this.eventSourceToRecord(source, event.roomId, context);
+                if (receipt.contentHash === this.hash(this.canonicalJson(['assistant', agent, output.type, output.content]))) {
+                    await this.materializeRun(db, event.roomId, { id: jobId, thread, triggerMessage, agent, createdAt, status: 'completed', reason: 'mention' }, context, 'completed', resultEventId);
+                    await db.updateById(models_1.deliveryResource, id, { status: 'completed', completedAt: new Date().toISOString() });
+                    return false;
+                }
+            }
+        }
+        const run = await db.findById(models_1.runResource, models_1.runResource.buildId({ id: jobId, thread, createdAt }));
+        if (this.runAttempts(run) >= 3) {
+            const active = await this.serverGroupReconcilerService?.getQueue().listQueued(thread, agent);
+            if (active?.some(job => job.id === jobId && job.status === 'leased' && Date.parse(job.leaseExpiresAt ?? '') > Date.now()))
+                return false;
+            if (!run.leaseExpiresAt || Date.parse(run.leaseExpiresAt) <= Date.now()) {
+                await this.recordFailure(event.roomId, { id: jobId, thread, triggerMessage, agent, createdAt, status: 'failed', reason: 'mention' }, { retry: false, error: 'Execution lease exhausted its retry budget' }, context);
+            }
+            return false;
+        }
+        if (!existing)
+            await db.insert(models_1.deliveryResource).values({ id, thread, chat: this.chatIri(event.roomId, context),
+                source: triggerMessage, object: triggerMessage, target: agent, actor: event.senderWebId,
+                kind: event.role === models_1.MessageRole.ASSISTANT ? 'runtime_followup' : 'mention_dispatch', status: 'pending',
+                createdAt, updatedAt: createdAt });
+        return true;
+    }
+    async materializeRun(db, roomId, job, context, status, eventId, error, workspace) {
+        const runWorkspace = workspace ?? (await this.agentGrants(db, roomId, context)).find(g => g.agent === job.agent)?.workspace;
+        const values = { id: job.id, thread: job.thread, createdAt: job.createdAt };
+        const id = models_1.runResource.buildId(values);
+        const iri = models_1.runResource.buildIri(this.scope(context), values);
+        const existing = await db.findById(models_1.runResource, id);
+        if (existing?.status === 'completed')
+            return iri;
+        const now = new Date().toISOString();
+        const row = { id, thread: job.thread, input: job.triggerMessage, delivery: models_1.deliveryResource.buildIri(this.scope(context), values), workspace: runWorkspace, runner: 'external', status,
+            leaseOwner: job.leaseOwner, leaseExpiresAt: job.leaseExpiresAt, createdAt: job.createdAt, updatedAt: now,
+            ...(['completed', 'failed'].includes(status) ? { completedAt: now } : { startedAt: now }),
+            metadata: { '@id': `${iri}/metadata`, protocols: { matrix: { roomId, jobId: job.id, eventId, fencingToken: job.fencingToken, attempts: this.runAttempts(existing) + (status === 'running' ? 1 : 0), error } } } };
+        if (existing)
+            await db.updateById(models_1.runResource, id, row);
+        else
+            await db.insert(models_1.runResource).values(row);
+        const stepId = models_1.runStepResource.buildId({ id: `${job.id}-${status}`, run: iri, createdAt: now });
+        if (!await db.findById(models_1.runStepResource, stepId))
+            await db.insert(models_1.runStepResource).values({ id: stepId, run: iri,
+                stepType: status === 'running' ? 'run.started' : `run.${status}`, createdAt: now, payload: { '@id': `${models_1.runStepResource.buildIri(this.scope(context), { id: stepId })}/payload`, agent: job.agent, eventId } });
+        return iri;
+    }
     parseJsonObject(value) {
         if (!value) {
             return undefined;
@@ -575,6 +943,7 @@ class PodMatrixStore {
                 actor: input.actor,
                 role: 'user',
                 content: input.content,
+                createdAt: input.createdAt,
                 reconcilerOwner: input.reconcilerOwner,
                 mentions: input.mentions,
                 routeTargetAgent: input.routeTargetAgent,
@@ -583,6 +952,7 @@ class PodMatrixStore {
         }
         catch (error) {
             this.logger.warn(`Failed to enqueue Matrix group Reconciler wake: ${error}`);
+            throw new MatrixError_1.MatrixError(503, 'M_UNKNOWN', 'Message stored; wake delivery pending. Retry the same transaction.');
         }
     }
     messageContentFromMatrixEvent(eventType, content) {
@@ -606,7 +976,7 @@ class PodMatrixStore {
     }
     getMatrixUserId(context) {
         const serverName = this.getServerName(context);
-        const localpart = this.localpartFromUserId(context.webId);
+        const localpart = `u_${this.hash(context.webId)}`;
         return `@${localpart}:${serverName}`;
     }
     getServerName(context) {
@@ -620,16 +990,6 @@ class PodMatrixStore {
             return 'localhost';
         }
     }
-    localpartFromUserId(userId) {
-        try {
-            const url = new URL(userId);
-            const withoutHash = `${url.pathname}${url.hash}`.replace(/^\/+/, '');
-            return this.slug(withoutHash || url.host);
-        }
-        catch {
-            return this.slug(userId);
-        }
-    }
     displayNameFromUserId(matrixUserId) {
         return matrixUserId.replace(/^@/, '').split(':')[0] || matrixUserId;
     }
@@ -639,67 +999,26 @@ class PodMatrixStore {
     generateEventId(context) {
         return `$${this.randomId(24)}:${this.getServerName(context)}`;
     }
-    deviceIdFromUserId(userId) {
-        return `XPOD${(0, node_crypto_1.createHash)('sha256').update(userId).digest('hex').slice(0, 12).toUpperCase()}`;
+    deviceId(context) {
+        const auth = context.auth;
+        return `XPOD${this.hash(JSON.stringify([context.webId, auth?.type === 'solid' ? auth.clientId ?? auth.gatewayKeyId ?? 'solid' : 'solid'])).slice(0, 24).toUpperCase()}`;
     }
     randomId(size) {
         return (0, node_crypto_1.randomBytes)(size).toString('base64url');
     }
-    slug(value) {
-        return value.toLowerCase().replace(/[^a-z0-9._=-]+/g, '_').replace(/^_+|_+$/g, '') || 'user';
-    }
     surfaceIdFromRoomId(roomId) {
         return `matrix-${(0, node_crypto_1.createHash)('sha256').update(roomId).digest('hex').slice(0, 16)}`;
     }
     chatResourceIdFromRoomId(roomId) {
-        return `${this.surfaceIdFromRoomId(roomId)}/index.ttl#this`;
-    }
-    messageParentResourceIdFromRoomId(roomId) {
-        return `chat/${this.surfaceIdFromRoomId(roomId)}/index.ttl#this`;
+        return models_1.chatResource.buildId({ id: this.surfaceIdFromRoomId(roomId) });
     }
     threadResourceIdFromRoomId(roomId) {
-        return `chat/${this.surfaceIdFromRoomId(roomId)}/index.ttl#thread`;
-    }
-    chatParentRefFromRoomId(roomId) {
-        return `/.data/chat/${this.chatResourceIdFromRoomId(roomId)}`;
+        return models_1.threadResource.buildId({ id: 'thread', parent: models_1.chatResource.buildIri('https://layout.invalid/', { id: this.surfaceIdFromRoomId(roomId) }) });
     }
     messageResourceIdFromEvent(roomId, eventId, ts) {
-        const { yyyy, MM, dd } = this.dateParts(ts);
-        return `chat/${this.surfaceIdFromRoomId(roomId)}/${yyyy}/${MM}/${dd}/messages.ttl#${this.slug(eventId)}`;
-    }
-    resolveDataResourceUriFromId(resourceId, context) {
-        const podBaseUrl = context.podUrl ?? this.derivePodBaseUrl(context.webId);
-        if (!podBaseUrl) {
-            return resourceId;
-        }
-        return `${podBaseUrl.replace(/\/$/, '')}/.data/${resourceId}`;
-    }
-    derivePodBaseUrl(webId) {
-        if (!webId) {
-            return undefined;
-        }
-        try {
-            const url = new URL(webId);
-            url.hash = '';
-            url.search = '';
-            const normalizedPath = url.pathname.replace(/\/+$/, '');
-            if (!normalizedPath.endsWith('/profile/card')) {
-                return url.origin;
-            }
-            url.pathname = normalizedPath.slice(0, -'/profile/card'.length) || '/';
-            return url.toString().replace(/\/$/, '');
-        }
-        catch {
-            return undefined;
-        }
-    }
-    dateParts(value) {
-        const date = new Date(value);
-        return {
-            yyyy: String(date.getUTCFullYear()),
-            MM: String(date.getUTCMonth() + 1).padStart(2, '0'),
-            dd: String(date.getUTCDate()).padStart(2, '0'),
-        };
+        return models_1.messageResource.buildId({ id: this.hash(eventId),
+            parent: models_1.chatResource.buildIri('https://layout.invalid/', { id: this.surfaceIdFromRoomId(roomId) }),
+            createdAt: new Date(ts).toISOString() });
     }
     isoToMillis(value) {
         if (!value) {
@@ -710,14 +1029,18 @@ class PodMatrixStore {
         return Number.isFinite(time) ? time : undefined;
     }
     encodeSyncToken(ts) {
-        return `s${Math.max(0, Math.floor(ts))}`;
+        return `v2_${Math.max(0, Math.floor(ts))}`;
     }
     parseSyncToken(token) {
         if (!token) {
             return 0;
         }
-        const parsed = Number(token.replace(/^s/, ''));
-        return Number.isFinite(parsed) ? parsed : 0;
+        if (!/^v2_\d+$/u.test(token))
+            throw new MatrixError_1.MatrixError(400, 'M_UNKNOWN_POS', 'Cursor version changed; start a fresh sync');
+        const parsed = Number(token.slice(3));
+        if (!Number.isSafeInteger(parsed))
+            throw new MatrixError_1.MatrixError(400, 'M_UNKNOWN_POS', 'Invalid cursor');
+        return parsed;
     }
 }
 exports.PodMatrixStore = PodMatrixStore;