@promptbook/cli 0.113.0-0 → 0.113.0-10

package/apps/agents-server/src/app/api/auth/shibboleth/login/route.ts

@@ -4,6 +4,7 @@ import {
     getShibbolethRequestDetails,
     recordShibbolethAuthenticationAttempt,
     resolveShibbolethAuthenticationConfiguration,
+    resolveShibbolethPublicRequestUrl,
     sanitizeShibbolethRelayState,
 } from '../../../../../utils/shibbolethAuthentication';
 
@@ -12,11 +13,12 @@ import {
  */
 export async function GET(request: Request) {
     const requestDetails = getShibbolethRequestDetails(request);
+    const publicRequestUrl = resolveShibbolethPublicRequestUrl(request);
     const relayState = sanitizeShibbolethRelayState(new URL(request.url).searchParams.get('returnTo'));
 
     try {
         const configuration = await resolveShibbolethAuthenticationConfiguration({
-            requestUrl: request.url,
+            requestUrl: publicRequestUrl,
             isIdentityProviderMetadataValidationEnabled: true,
         });
 

package/apps/agents-server/src/app/api/auth/shibboleth/metadata/route.ts

@@ -1,11 +1,14 @@
 import { NextResponse } from 'next/server';
-import { createShibbolethServiceProviderMetadataXml } from '../../../../../utils/shibbolethAuthentication';
+import {
+    createShibbolethServiceProviderMetadataXml,
+    resolveShibbolethPublicRequestUrl,
+} from '../../../../../utils/shibbolethAuthentication';
 
 /**
  * Handles get.
  */
 export async function GET(request: Request) {
-    const metadataXml = await createShibbolethServiceProviderMetadataXml(request.url);
+    const metadataXml = await createShibbolethServiceProviderMetadataXml(resolveShibbolethPublicRequestUrl(request));
 
     return new NextResponse(metadataXml, {
         headers: {

package/apps/agents-server/src/app/api/auth/shibboleth/status/route.ts

@@ -1,12 +1,15 @@
 import { NextResponse } from 'next/server';
-import { resolveShibbolethAuthenticationConfiguration } from '../../../../../utils/shibbolethAuthentication';
+import {
+    resolveShibbolethAuthenticationConfiguration,
+    resolveShibbolethPublicRequestUrl,
+} from '../../../../../utils/shibbolethAuthentication';
 
 /**
  * Handles get.
  */
 export async function GET(request: Request) {
     const configuration = await resolveShibbolethAuthenticationConfiguration({
-        requestUrl: request.url,
+        requestUrl: resolveShibbolethPublicRequestUrl(request),
         isIdentityProviderMetadataValidationEnabled: false,
     });
 

package/apps/agents-server/src/app/api/page-preview/input/route.ts

@@ -0,0 +1,161 @@
+import type { NextRequest } from 'next/server';
+import { NextResponse } from 'next/server';
+import { getCurrentUser } from '../../../../utils/getCurrentUser';
+import {
+    findUserPagePreviewBrowserSession,
+    normalizePagePreviewBrowserSessionId,
+} from '../../../../utils/pagePreviewBrowserSessions';
+
+/**
+ * Maximum absolute wheel delta accepted from one preview input event.
+ *
+ * @private route constant of `/api/page-preview/input`
+ */
+const MAX_WHEEL_DELTA = 1600;
+
+/**
+ * Payload accepted by the live page-preview input route.
+ *
+ * @private route type of `/api/page-preview/input`
+ */
+type PagePreviewInputPayload = {
+    readonly sessionId?: unknown;
+    readonly type?: unknown;
+    readonly xRatio?: unknown;
+    readonly yRatio?: unknown;
+    readonly deltaX?: unknown;
+    readonly deltaY?: unknown;
+};
+
+/**
+ * Normalized browser input event.
+ *
+ * @private route type of `/api/page-preview/input`
+ */
+type PagePreviewInputEvent =
+    | {
+          readonly sessionId: string;
+          readonly type: 'click';
+          readonly xRatio: number;
+          readonly yRatio: number;
+      }
+    | {
+          readonly sessionId: string;
+          readonly type: 'wheel';
+          readonly xRatio: number;
+          readonly yRatio: number;
+          readonly deltaX: number;
+          readonly deltaY: number;
+      };
+
+/**
+ * Applies one pointer or wheel event to an active live browser preview session.
+ */
+export async function POST(request: NextRequest): Promise<NextResponse> {
+    const currentUser = await getCurrentUser();
+    if (!currentUser) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const payload = (await request.json().catch(() => null)) as PagePreviewInputPayload | null;
+    const inputEvent = normalizePagePreviewInputEvent(payload);
+    if (!inputEvent) {
+        return NextResponse.json({ error: 'Invalid browser preview input.' }, { status: 400 });
+    }
+
+    const session = findUserPagePreviewBrowserSession(inputEvent.sessionId, currentUser);
+    if (!session?.page || !session.viewport) {
+        return NextResponse.json({ error: 'Browser preview session is not active.' }, { status: 404 });
+    }
+
+    const x = inputEvent.xRatio * session.viewport.width;
+    const y = inputEvent.yRatio * session.viewport.height;
+
+    if (inputEvent.type === 'click') {
+        await session.page.mouse.click(x, y);
+    } else {
+        await session.page.mouse.move(x, y);
+        await session.page.mouse.wheel(inputEvent.deltaX, inputEvent.deltaY);
+    }
+
+    return NextResponse.json({ ok: true });
+}
+
+/**
+ * Normalizes and validates one browser-preview input payload.
+ *
+ * @param payload - Unknown JSON payload.
+ * @returns Normalized input event or `null` when invalid.
+ */
+function normalizePagePreviewInputEvent(payload: PagePreviewInputPayload | null): PagePreviewInputEvent | null {
+    if (!payload) {
+        return null;
+    }
+
+    const sessionId = normalizePagePreviewBrowserSessionId(
+        typeof payload.sessionId === 'string' ? payload.sessionId : null,
+    );
+    const xRatio = normalizeRatio(payload.xRatio);
+    const yRatio = normalizeRatio(payload.yRatio);
+
+    if (!sessionId || xRatio === null || yRatio === null) {
+        return null;
+    }
+
+    if (payload.type === 'click') {
+        return {
+            sessionId,
+            type: 'click',
+            xRatio,
+            yRatio,
+        };
+    }
+
+    if (payload.type !== 'wheel') {
+        return null;
+    }
+
+    const deltaX = normalizeWheelDelta(payload.deltaX);
+    const deltaY = normalizeWheelDelta(payload.deltaY);
+    if (deltaX === null || deltaY === null) {
+        return null;
+    }
+
+    return {
+        sessionId,
+        type: 'wheel',
+        xRatio,
+        yRatio,
+        deltaX,
+        deltaY,
+    };
+}
+
+/**
+ * Normalizes a pointer coordinate ratio.
+ *
+ * @param value - Unknown payload value.
+ * @returns Ratio clamped to the viewport bounds, or `null` when invalid.
+ */
+function normalizeRatio(value: unknown): number | null {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return null;
+    }
+
+    return Math.max(0, Math.min(1, value));
+}
+
+/**
+ * Normalizes one mouse-wheel delta.
+ *
+ * @param value - Unknown payload value.
+ * @returns Clamped wheel delta, or `null` when invalid.
+ */
+function normalizeWheelDelta(value: unknown): number | null {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return null;
+    }
+
+    return Math.max(-MAX_WHEEL_DELTA, Math.min(MAX_WHEEL_DELTA, value));
+}
+

package/apps/agents-server/src/app/api/page-preview/stream/route.ts

@@ -0,0 +1,81 @@
+import { serializeError } from '@promptbook-local/utils';
+import type { NextRequest } from 'next/server';
+import { NextResponse } from 'next/server';
+import { assertsError } from '../../../../../../../src/errors/assertsError';
+import { assertSafeUrl } from '../../../../utils/assertSafeUrl';
+import {
+    createPagePreviewBrowserStream,
+    PAGE_PREVIEW_STREAM_CONTENT_TYPE,
+} from '../../../../utils/createPagePreviewBrowserStream';
+import { getCurrentUser } from '../../../../utils/getCurrentUser';
+import {
+    normalizePagePreviewBrowserSessionId,
+    registerPagePreviewBrowserSession,
+} from '../../../../utils/pagePreviewBrowserSessions';
+
+/**
+ * Forces this route to stream a fresh live browser session for every request.
+ */
+export const dynamic = 'force-dynamic';
+
+/**
+ * Streams a live browser preview of a public URL.
+ *
+ * Query parameters:
+ * - `url` — fully-qualified public HTTP(S) URL to preview
+ * - `sessionId` — client-created browser-preview session id used for interaction events
+ *
+ * Requires authentication to prevent unauthenticated SSRF and browser-process abuse.
+ */
+export async function GET(request: NextRequest): Promise<NextResponse> {
+    const currentUser = await getCurrentUser();
+    if (!currentUser) {
+        return NextResponse.json({ error: 'Unauthorized' }, { status: 401 });
+    }
+
+    const url = request.nextUrl.searchParams.get('url');
+    const sessionId = normalizePagePreviewBrowserSessionId(request.nextUrl.searchParams.get('sessionId'));
+
+    if (!url) {
+        return NextResponse.json({ error: 'Missing required query parameter: url' }, { status: 400 });
+    }
+
+    if (!sessionId) {
+        return NextResponse.json({ error: 'Missing or invalid query parameter: sessionId' }, { status: 400 });
+    }
+
+    try {
+        assertSafeUrl(url);
+    } catch (error) {
+        assertsError(error);
+        return NextResponse.json({ error: error.message }, { status: 400 });
+    }
+
+    try {
+        registerPagePreviewBrowserSession({
+            sessionId,
+            url,
+            user: currentUser,
+        });
+
+        const stream = createPagePreviewBrowserStream({
+            request,
+            sessionId,
+            url,
+        });
+
+        return new NextResponse(stream, {
+            headers: {
+                'Content-Type': PAGE_PREVIEW_STREAM_CONTENT_TYPE,
+                'Cache-Control': 'no-cache, no-store, max-age=0, must-revalidate',
+                Connection: 'keep-alive',
+                'X-Accel-Buffering': 'no',
+            },
+        });
+    } catch (error) {
+        assertsError(error);
+        console.error('[page-preview] failed to start live browser stream', error);
+        return NextResponse.json({ error: serializeError(error) }, { status: 500 });
+    }
+}
+

package/apps/agents-server/src/app/layout.tsx

@@ -32,11 +32,7 @@ import {
     DEFAULT_AGENT_AVATAR_VISUAL_METADATA_KEY,
     resolveDefaultAgentAvatarVisualId,
 } from '../constants/defaultAgentAvatarVisual';
-import {
-    DEFAULT_THEME_METADATA_KEY,
-    THEME_MODE_COOKIE_NAME,
-    resolveThemeMode,
-} from '../constants/themeMode';
+import { DEFAULT_THEME_METADATA_KEY, THEME_MODE_COOKIE_NAME, resolveThemeMode } from '../constants/themeMode';
 import { parseChatFeedbackMode } from '../utils/chatFeedbackMode';
 import { getFederatedServers } from '../utils/getFederatedServers';
 import { isUserAdmin } from '../utils/isUserAdmin';
@@ -53,6 +49,8 @@ import {
     resolveShibbolethAuthenticationMenuStatus,
 } from '../constants/shibbolethAuth';
 import { resolveFileUploadAvailability } from '../utils/upload/fileUploadAvailability';
+import { readServerResourceWarningStatus } from '../utils/resourceMonitor/readServerResourceMonitorSnapshot';
+import { RESOURCE_MONITOR_OK_WARNING_STATUS } from '../utils/resourceMonitor/resourceMonitorTypes';
 import '@prisma/studio-core/ui/index.css';
 import './globals.css';
 
@@ -270,6 +268,18 @@ export default async function RootLayout({
     const currentUserPromise = getCurrentUser();
     const isAdminPromise = isUserAdmin();
     const isGlobalAdminPromise = isUserGlobalAdmin();
+    const resourceMonitorWarningStatusPromise = isGlobalAdminPromise.then(async (isGlobalAdmin) => {
+        if (!isGlobalAdmin) {
+            return RESOURCE_MONITOR_OK_WARNING_STATUS;
+        }
+
+        try {
+            return await readServerResourceWarningStatus();
+        } catch (error) {
+            console.error('Failed to resolve resource monitor warning status:', error);
+            return RESOURCE_MONITOR_OK_WARNING_STATUS;
+        }
+    });
     const providedServerPromise = $provideServer();
     const serverVisibilityPromise = getServerVisibility();
     const agentNamingPromise = getAgentNaming();
@@ -289,10 +299,7 @@ export default async function RootLayout({
         'custom stylesheet CSS',
         getAggregatedCustomStylesheetCss,
     );
-    const customJavascriptPromise = resolveOptionalLayoutText(
-        'custom JavaScript',
-        getCustomJavascriptWithIntegrations,
-    );
+    const customJavascriptPromise = resolveOptionalLayoutText('custom JavaScript', getCustomJavascriptWithIntegrations);
     const cookieStorePromise = cookies();
     const requestHeadersPromise = headers();
     const defaultThemeModePromise = Promise.all([currentUserPromise, cookieStorePromise, layoutMetadataPromise]).then(
@@ -318,23 +325,25 @@ export default async function RootLayout({
                 showFederatedServersPublicly: (layoutMetadata.SHOW_FEDERATED_SERVERS_PUBLICLY ?? 'false') === 'true',
             }),
     );
-    const footerLinksPromise = Promise.all([layoutMetadataPromise, federatedServersPromise, serverVisibilityPromise]).then(
-        ([layoutMetadata, federatedServers, serverVisibility]) => {
-            const footerLinks = [
-                ...parseFooterLinks(layoutMetadata.FOOTER_LINKS),
-                ...federatedServers.map(({ title, url }) => ({ title, url })),
-            ];
+    const footerLinksPromise = Promise.all([
+        layoutMetadataPromise,
+        federatedServersPromise,
+        serverVisibilityPromise,
+    ]).then(([layoutMetadata, federatedServers, serverVisibility]) => {
+        const footerLinks = [
+            ...parseFooterLinks(layoutMetadata.FOOTER_LINKS),
+            ...federatedServers.map(({ title, url }) => ({ title, url })),
+        ];
 
-            if (isPublicServerVisibility(serverVisibility)) {
-                footerLinks.push({
-                    title: 'Sitemap',
-                    url: '/sitemap.xml',
-                });
-            }
+        if (isPublicServerVisibility(serverVisibility)) {
+            footerLinks.push({
+                title: 'Sitemap',
+                url: '/sitemap.xml',
+            });
+        }
 
-            return footerLinks;
-        },
-    );
+        return footerLinks;
+    });
 
     const [
         isAdmin,
@@ -354,6 +363,7 @@ export default async function RootLayout({
         footerLinks,
         serverVisibility,
         fileUploadAvailability,
+        resourceMonitorWarningStatus,
     ] = await Promise.all([
         isAdminPromise,
         isGlobalAdminPromise,
@@ -372,6 +382,7 @@ export default async function RootLayout({
         footerLinksPromise,
         serverVisibilityPromise,
         fileUploadAvailabilityPromise,
+        resourceMonitorWarningStatusPromise,
     ]);
 
     const serverName = layoutMetadata.SERVER_NAME || 'Promptbook Agents Server';
@@ -433,7 +444,9 @@ export default async function RootLayout({
                     agentFolders={JSON.parse(JSON.stringify(agentFolders))}
                     agentNaming={agentNaming}
                     isFooterShown={isFooterShown}
-                    footerLinks={isPublicServer ? footerLinks : footerLinks.filter((link) => link.url !== '/sitemap.xml')}
+                    footerLinks={
+                        isPublicServer ? footerLinks : footerLinks.filter((link) => link.url !== '/sitemap.xml')
+                    }
                     federatedServers={federatedServers}
                     defaultIsSoundsOn={chatPreferences.defaultIsSoundsOn}
                     defaultIsVibrationOn={chatPreferences.defaultIsVibrationOn}
@@ -441,6 +454,7 @@ export default async function RootLayout({
                     isExperimental={isExperimental}
                     feedbackMode={feedbackMode}
                     shibbolethAuthenticationStatus={shibbolethAuthenticationStatus}
+                    resourceMonitorWarningStatus={resourceMonitorWarningStatus}
                     isExperimentalPwaAppEnabled={isExperimentalPwaAppEnabled}
                     controlPanelOptionAvailability={controlPanelOptionAvailability}
                     defaultServerLanguage={serverLanguage}

package/apps/agents-server/src/app/system/utilities/mocked-chats/cloneMockedChatPreset.ts

@@ -0,0 +1,17 @@
+import type { MockedChatPreset } from '@/src/utils/mockedChatsSchema';
+
+/**
+ * Clones one mocked-chat preset so editor state does not mutate saved references.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function cloneMockedChatPreset(preset: MockedChatPreset): MockedChatPreset {
+    return {
+        ...preset,
+        participants: preset.participants.map((participant) => ({ ...participant })),
+        messages: preset.messages.map((message) => ({ ...message })),
+        settings: {
+            ...preset.settings,
+        },
+    };
+}

package/apps/agents-server/src/app/system/utilities/mocked-chats/confirmDeleteMockedChat.ts

@@ -0,0 +1,16 @@
+import { showConfirm } from '@/src/components/AsyncDialogs/asyncDialogs';
+import type { MockedChatPreset } from '@/src/utils/mockedChatsSchema';
+
+/**
+ * Requests confirmation before deleting one mocked chat.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export async function confirmDeleteMockedChat(targetChat: MockedChatPreset): Promise<boolean> {
+    return showConfirm({
+        title: 'Delete mocked chat',
+        message: `Delete "${targetChat.name}"? This cannot be undone.`,
+        confirmLabel: 'Delete mocked chat',
+        cancelLabel: 'Cancel',
+    }).catch(() => false);
+}

package/apps/agents-server/src/app/system/utilities/mocked-chats/createDraftWithUpdatedMessage.ts

@@ -0,0 +1,81 @@
+import {
+    createMockedChatMessageId,
+    type MockedChatParticipant,
+    type MockedChatPreset,
+    type MockedChatScriptedMessage,
+} from '@/src/utils/mockedChatsSchema';
+
+/**
+ * Fallback offset distance when adding new scripted messages.
+ *
+ * @private constant of <MockedChatsEditorClient/>
+ */
+const DEFAULT_NEW_MESSAGE_OFFSET_STEP_MS = 1_200;
+
+/**
+ * Adds one scripted message at the end of the sequence.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithAddedMessage(previousDraft: MockedChatPreset): MockedChatPreset {
+    const previousOffset = previousDraft.messages[previousDraft.messages.length - 1]?.offsetMs || 0;
+
+    const nextMessage: MockedChatScriptedMessage = {
+        id: createMockedChatMessageId(),
+        senderId: resolveDefaultMessageSenderId(previousDraft.participants),
+        content: 'New scripted message',
+        offsetMs: previousOffset + DEFAULT_NEW_MESSAGE_OFFSET_STEP_MS,
+    };
+
+    return {
+        ...previousDraft,
+        messages: [...previousDraft.messages, nextMessage],
+    };
+}
+
+/**
+ * Updates one scripted message field.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithUpdatedMessage<TField extends keyof MockedChatScriptedMessage>(
+    previousDraft: MockedChatPreset,
+    messageId: string,
+    field: TField,
+    value: MockedChatScriptedMessage[TField],
+): MockedChatPreset {
+    return {
+        ...previousDraft,
+        messages: previousDraft.messages.map((message) => {
+            if (message.id !== messageId) {
+                return message;
+            }
+
+            return {
+                ...message,
+                [field]: value,
+            };
+        }),
+    };
+}
+
+/**
+ * Removes one scripted message.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithRemovedMessage(previousDraft: MockedChatPreset, messageId: string): MockedChatPreset {
+    return {
+        ...previousDraft,
+        messages: previousDraft.messages.filter((message) => message.id !== messageId),
+    };
+}
+
+/**
+ * Resolves the participant used for newly added scripted messages.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+function resolveDefaultMessageSenderId(participants: ReadonlyArray<MockedChatParticipant>): string {
+    return participants.find((participant) => participant.isMe)?.id || participants[0]?.id || 'USER';
+}

package/apps/agents-server/src/app/system/utilities/mocked-chats/createDraftWithUpdatedParticipant.ts

@@ -0,0 +1,146 @@
+import {
+    createMockedChatParticipantId,
+    type MockedChatParticipant,
+    type MockedChatPreset,
+    type MockedChatScriptedMessage,
+} from '@/src/utils/mockedChatsSchema';
+
+/**
+ * Adds one participant to the current draft.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithAddedParticipant(previousDraft: MockedChatPreset): MockedChatPreset {
+    const nextParticipants = [...previousDraft.participants, createDraftParticipant(previousDraft.participants.length)];
+
+    return {
+        ...previousDraft,
+        participants: nextParticipants,
+    };
+}
+
+/**
+ * Updates one participant field in the draft.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithUpdatedParticipant<TField extends keyof MockedChatParticipant>(
+    previousDraft: MockedChatPreset,
+    participantId: string,
+    field: TField,
+    value: MockedChatParticipant[TField],
+): MockedChatPreset {
+    const nextParticipants = updateParticipantsAfterFieldChange(previousDraft.participants, participantId, field, value);
+    const fallbackSenderId = nextParticipants[0]?.id || previousDraft.messages[0]?.senderId || 'USER';
+
+    return {
+        ...previousDraft,
+        participants: nextParticipants,
+        messages: reconcileMessageSenderIds(previousDraft.messages, nextParticipants, fallbackSenderId),
+    };
+}
+
+/**
+ * Removes one participant from the draft.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+export function createDraftWithRemovedParticipant(previousDraft: MockedChatPreset, participantId: string): MockedChatPreset {
+    const remainingParticipants = previousDraft.participants.filter((participant) => participant.id !== participantId);
+    if (remainingParticipants.length === 0) {
+        return previousDraft;
+    }
+
+    const nextParticipants = ensureParticipantMarkedAsMe(remainingParticipants);
+    const fallbackSenderId = nextParticipants[0]?.id || 'USER';
+
+    return {
+        ...previousDraft,
+        participants: nextParticipants,
+        messages: reconcileMessageSenderIds(previousDraft.messages, nextParticipants, fallbackSenderId),
+    };
+}
+
+/**
+ * Creates one participant draft with deterministic defaults.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+function createDraftParticipant(participantCount: number): MockedChatParticipant {
+    return {
+        id: createMockedChatParticipantId(),
+        name: `Participant ${participantCount + 1}`,
+        isMe: participantCount === 0,
+        bubbleColor: '#2563eb',
+        avatarUrl: null,
+        typingAvatarUrl: null,
+    };
+}
+
+/**
+ * Ensures at least one participant remains marked as `isMe`.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+function ensureParticipantMarkedAsMe(participants: Array<MockedChatParticipant>): Array<MockedChatParticipant> {
+    if (participants.some((participant) => participant.isMe) || participants.length === 0) {
+        return participants;
+    }
+
+    const nextParticipants = [...participants];
+    nextParticipants[0] = {
+        ...nextParticipants[0],
+        isMe: true,
+    };
+    return nextParticipants;
+}
+
+/**
+ * Reconciles message sender ids after participant changes.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+function reconcileMessageSenderIds(
+    messages: ReadonlyArray<MockedChatScriptedMessage>,
+    participants: ReadonlyArray<MockedChatParticipant>,
+    fallbackSenderId: string,
+): Array<MockedChatScriptedMessage> {
+    return messages.map((message) => ({
+        ...message,
+        senderId: participants.some((participant) => participant.id === message.senderId)
+            ? message.senderId
+            : fallbackSenderId,
+    }));
+}
+
+/**
+ * Applies one participant field update and keeps the "me" invariant.
+ *
+ * @private function of <MockedChatsEditorClient/>
+ */
+function updateParticipantsAfterFieldChange<TField extends keyof MockedChatParticipant>(
+    participants: ReadonlyArray<MockedChatParticipant>,
+    participantId: string,
+    field: TField,
+    value: MockedChatParticipant[TField],
+): Array<MockedChatParticipant> {
+    let nextParticipants = participants.map((participant) => {
+        if (participant.id !== participantId) {
+            return participant;
+        }
+
+        return {
+            ...participant,
+            [field]: value,
+        };
+    });
+
+    if (field === 'isMe' && value === true) {
+        nextParticipants = nextParticipants.map((participant) => ({
+            ...participant,
+            isMe: participant.id === participantId,
+        }));
+    }
+
+    return nextParticipants;
+}