@okostream/mcp 0.12.2 → 0.12.4

package/dist/tools/sessions.js

@@ -1,313 +0,0 @@
-// Сессии аналитики и отчёты по ним.
-//
-// Start и End управляют ЗАМЕРОМ, а не эфиром: видео идёт из плеера
-// организатора независимо от них. Отчёт завершённой сессии неизменяем —
-// его считает CF49 один раз и больше не пересчитывает.
-import { z } from "zod";
-import { requireConfirm, safeString, textResult } from "../utils.js";
-import { authed, eventLinks, sessionReportUrl } from "./context.js";
-import { ANALYTICS_DEFAULT_LIMIT, ANALYTICS_TIMELINE_DEFAULT_LIMIT, analyticsOutputSchema, basicEventOutputSchema, cursorField, destructiveTool, eventIdField, limitField, readOnlyTool, sessionReportOutputSchema, toolDescription, writeTool } from "./schemas.js";
-import { collection, deleteDoc, deleteField, doc, getDoc, getDocs, limit, orderBy, query, startAfter, updateDoc } from "firebase/firestore";
-import { summarizeSessionRepair } from "../sessionRepair.js";
-import { compactAnalyticsSession, cursorMeta, parseTimestampCursor, pickPage, sessionReportMarkdown, timestampCursorFrom } from "./formatting.js";
-import { firestore, functions, rtdb } from "../firebase.js";
-import { get, ref, remove } from "firebase/database";
-import { httpsCallable } from "firebase/functions";
-import { readEvent } from "./eventAccess.js";
-export function registerSessionTools(server) {
-    server.registerTool("oko_start_session", {
-        title: "Start analytics session",
-        description: toolDescription({
-            summary: "Start an analytics session using the same Firestore/RTDB pointers as the dashboard.",
-            args: ["eventId: event whose analytics session should start.", "confirm: must be true."],
-            returns: "eventId, new sessionId, and started=true.",
-            examples: ["Use when the organizer wants analytics tracking to begin; it does not start the video stream."],
-            notes: ["OKO Start/End controls analytics sessions only, not stream publishing."],
-        }),
-        inputSchema: { eventId: eventIdField, confirm: z.boolean().optional().describe("Required true to start analytics collection session.") },
-        outputSchema: basicEventOutputSchema,
-        annotations: writeTool,
-    }, async ({ eventId, confirm }) => {
-        const { uid } = await authed(["analytics:write", "live:control"]);
-        const event = await readEvent(eventId, uid, "session");
-        requireConfirm(confirm, "oko_start_session", { eventId, title: event.title ?? null });
-        if (event.activeAnalyticsSessionId)
-            throw new Error("An analytics session is already active.");
-        const start = httpsCallable(functions, "startAnalyticsSessionV3");
-        const result = await start({ eventId });
-        // 🔴 `eventId` обязателен по `basicEventOutputSchema`. Без него SDK
-        // отвергал ответ ПОСЛЕ того, как сессия уже стартовала: клиент видел
-        // ошибку схемы и считал, что запуска не было, — Pattern 18.
-        return textResult({ eventId, started: true, ...result.data });
-    });
-    server.registerTool("oko_end_session", {
-        title: "End analytics session",
-        description: toolDescription({
-            summary: "End the active analytics session and persist the session snapshot.",
-            args: ["eventId: event with an active analytics session.", "confirm: must be true."],
-            returns: "eventId, sessionId, and ended=true.",
-            examples: ["Use after the webinar analytics window is over and the user confirms the exact event."],
-            notes: ["Destructive for the active session pointer, but it does not stop the video stream."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            confirm: z.boolean().optional().describe("Required true for ending the active session."),
-            reportLocale: z.enum(["en", "ru", "es", "pt-BR", "fr", "de"]).optional()
-                .describe("Language of the session report PDF, pre-rendered right after the session ends. Server defaults to ru; the choice is permanent for this session."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, confirm, reportLocale }) => {
-        const { uid } = await authed(["analytics:write", "live:control"]);
-        const event = await readEvent(eventId, uid, "session");
-        const sessionId = safeString(event.activeAnalyticsSessionId);
-        if (!sessionId)
-            throw new Error("No active analytics session.");
-        requireConfirm(confirm, "oko_end_session", { eventId, sessionId, reportLocale: reportLocale ?? null });
-        const end = httpsCallable(functions, "endAnalyticsSessionV3");
-        // 🔴 Язык отчёта задаётся ЗДЕСЬ и больше нигде: CF55 рендерит PDF сразу
-        // после эфира, организатора в этот момент нет, а в профиле языка не
-        // хранится. Локаль входит в путь готового файла, и сессия неизменяема —
-        // русский PDF у англоязычного организатора исправить уже нельзя. Веб
-        // передаёт `locale` именно поэтому (ревью 02.09, Б3).
-        const result = await end({ eventId, sessionId, ...(reportLocale ? { locale: reportLocale } : {}) });
-        // Тот же случай, что у запуска: сессия уже завершена и отчёт сохранён,
-        // а ответ без `eventId` не проходил собственную схему.
-        return textResult({ eventId, ...result.data });
-    });
-    server.registerTool("oko_fix_orphan_session", {
-        title: "Fix orphan analytics session",
-        description: toolDescription({
-            summary: "Clear stuck active-session pointers when an analytics session cannot be ended normally.",
-            args: [
-                "eventId: event with stuck session pointers.",
-                "deleteRtdbSessionData: optional, also delete events/{eventId}/sessions/{sessionId}; default false.",
-                "confirm: must be true.",
-            ],
-            returns: "eventId, cleared sessionId if found, and cleaned paths.",
-            examples: ["Use when oko_end_session says the baseline is missing or dashboard shows a stuck/orphan session."],
-            notes: ["This does not stop the video stream; OKO Start/End controls analytics sessions only."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            deleteRtdbSessionData: z.boolean().default(false).describe("Also delete RTDB session data for the stuck session."),
-            confirm: z.boolean().optional().describe("Required true for clearing session pointers."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, deleteRtdbSessionData, confirm }) => {
-        const { uid } = await authed(["analytics:write", "live:control"]);
-        const event = await readEvent(eventId, uid, "session");
-        const ctrlSnap = await get(ref(rtdb, `events/${eventId}/ctrl/activeSessionId`));
-        const sessionId = safeString(event.activeAnalyticsSessionId) || safeString(ctrlSnap.val());
-        requireConfirm(confirm, "oko_fix_orphan_session", { eventId, sessionId: sessionId || null, deleteRtdbSessionData });
-        const cleanup = [
-            {
-                path: "events.activeAnalyticsSessionId",
-                promise: updateDoc(doc(firestore, "events", eventId), { activeAnalyticsSessionId: deleteField() }),
-            },
-            {
-                path: "ctrl/activeSessionId",
-                promise: remove(ref(rtdb, `events/${eventId}/ctrl/activeSessionId`)),
-            },
-        ];
-        if (sessionId) {
-            cleanup.push({
-                path: `activeSessions/${sessionId}`,
-                promise: remove(ref(rtdb, `activeSessions/${sessionId}`)),
-            });
-        }
-        if (sessionId && deleteRtdbSessionData) {
-            cleanup.push({
-                path: `events/${eventId}/sessions/${sessionId}`,
-                promise: remove(ref(rtdb, `events/${eventId}/sessions/${sessionId}`)),
-            });
-        }
-        const settled = await Promise.allSettled(cleanup.map((operation) => operation.promise));
-        const attempts = settled.map((result, index) => {
-            const operation = cleanup[index];
-            if (!operation)
-                throw new Error("Session repair result has no matching cleanup operation.");
-            return {
-                path: operation.path,
-                status: result.status,
-                ...(result.status === "rejected" ? {
-                    error: result.reason instanceof Error ? result.reason.message : String(result.reason),
-                } : {}),
-            };
-        });
-        let firestorePointer = null;
-        let rtdbPointer = null;
-        let verificationError;
-        try {
-            const [eventAfter, ctrlAfter] = await Promise.all([
-                getDoc(doc(firestore, "events", eventId)),
-                get(ref(rtdb, `events/${eventId}/ctrl/activeSessionId`)),
-            ]);
-            firestorePointer = eventAfter.exists()
-                ? safeString(eventAfter.data().activeAnalyticsSessionId) || null
-                : null;
-            rtdbPointer = safeString(ctrlAfter.val()) || null;
-        }
-        catch (error) {
-            verificationError = error instanceof Error ? error.message : String(error);
-        }
-        return textResult(summarizeSessionRepair({
-            eventId,
-            sessionId: sessionId || null,
-            deleteRtdbSessionData,
-            attempts,
-            firestorePointer,
-            rtdbPointer,
-            verificationError,
-        }));
-    });
-    server.registerTool("oko_delete_session", {
-        title: "Delete analytics session",
-        description: toolDescription({
-            summary: "Delete an analytics session document and optionally its RTDB session data.",
-            args: [
-                "eventId: event id.",
-                "sessionId: analytics session id.",
-                "deleteRtdbData: best-effort delete of events/{eventId}/sessions/{sessionId}; default false.",
-                "confirm: must be true.",
-            ],
-            returns: "eventId, sessionId, deleted=true, and cleaned paths.",
-            examples: ["Use only after confirming the exact session id with the organizer."],
-            notes: ["Destructive. If the session is active, active pointers are cleared first. RTDB session data cleanup is best-effort because rules may deny deleting historical session snapshots."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            sessionId: z.string().min(1).describe("analyticsSessions document id."),
-            deleteRtdbData: z.boolean().default(false).describe("Best-effort delete RTDB session data for this session."),
-            confirm: z.boolean().optional().describe("Required true for session deletion."),
-        },
-        outputSchema: basicEventOutputSchema,
-        annotations: destructiveTool,
-    }, async ({ eventId, sessionId, deleteRtdbData, confirm }) => {
-        const { uid } = await authed(["analytics:write", "live:control"]);
-        const event = await readEvent(eventId, uid, "session");
-        requireConfirm(confirm, "oko_delete_session", { eventId, sessionId, deleteRtdbData });
-        const isActive = safeString(event.activeAnalyticsSessionId) === sessionId;
-        const cleanup = [];
-        if (isActive) {
-            cleanup.push(updateDoc(doc(firestore, "events", eventId), { activeAnalyticsSessionId: deleteField() }));
-            cleanup.push(remove(ref(rtdb, `events/${eventId}/ctrl/activeSessionId`)));
-            cleanup.push(remove(ref(rtdb, `activeSessions/${sessionId}`)));
-        }
-        cleanup.push(deleteDoc(doc(firestore, "events", eventId, "analyticsSessions", sessionId)));
-        const results = await Promise.allSettled(cleanup);
-        const warnings = results
-            .filter((result) => result.status === "rejected")
-            .map((result) => result.reason instanceof Error ? result.reason.message : String(result.reason));
-        if (warnings.length > 0)
-            throw new Error(`Session delete partially failed: ${warnings.join("; ")}`);
-        const rtdbCleanupWarnings = [];
-        if (deleteRtdbData) {
-            try {
-                await remove(ref(rtdb, `events/${eventId}/sessions/${sessionId}`));
-            }
-            catch (err) {
-                rtdbCleanupWarnings.push(err instanceof Error ? err.message : String(err));
-            }
-        }
-        return textResult({ eventId, sessionId, deleted: true, wasActive: isActive, deleteRtdbData, rtdbCleanupWarnings });
-    });
-    server.registerTool("oko_get_analytics", {
-        title: "Get analytics sessions",
-        description: toolDescription({
-            summary: "Read paginated analytics session summaries for an event.",
-            args: [
-                "eventId: event to inspect.",
-                "limit: max sessions to return, default 10, max 50.",
-                "cursor: timestamp cursor returned as nextCursor by the previous page.",
-                "includeTimeline: include recent timeline buckets; default false to keep context small.",
-                "timelineLimit: max timeline buckets per session when includeTimeline=true.",
-                "includeSnapshots: include baseline/final snapshots; default false.",
-            ],
-            returns: "sessions plus count, limit, hasMore/has_more, nextCursor/next_cursor. Heavy timeline/snapshot fields are omitted unless requested.",
-            examples: ["Use default options for dashboard-like summaries; request includeTimeline only for chart/debug tasks."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            limit: limitField(50, ANALYTICS_DEFAULT_LIMIT),
-            cursor: cursorField,
-            includeTimeline: z.boolean().default(false).describe("Include recent timeline buckets for each session."),
-            timelineLimit: z.number().int().min(1).max(500).default(ANALYTICS_TIMELINE_DEFAULT_LIMIT).describe("Max timeline buckets per session when includeTimeline=true."),
-            includeSnapshots: z.boolean().default(false).describe("Include baselineSnapshot and finalSnapshot."),
-        },
-        outputSchema: analyticsOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId, limit: max, cursor, includeTimeline, timelineLimit, includeSnapshots }) => {
-        const { uid } = await authed(["analytics:read"]);
-        await readEvent(eventId, uid, "analytics");
-        const constraints = [
-            orderBy("startedAt", "desc"),
-            limit(max + 1),
-        ];
-        if (cursor)
-            constraints.splice(1, 0, startAfter(parseTimestampCursor(cursor)));
-        const snap = await getDocs(query(collection(firestore, "events", eventId, "analyticsSessions"), ...constraints));
-        const { page, hasMore } = pickPage(snap.docs, max);
-        const sessions = page.map((item) => compactAnalyticsSession({ id: item.id, ...item.data() }, { includeTimeline, timelineLimit, includeSnapshots }));
-        const nextCursor = hasMore ? timestampCursorFrom(page.at(-1)?.data().startedAt) : null;
-        return textResult({ sessions, ...cursorMeta(sessions.length, max, hasMore, nextCursor) }, { truncationHint: "Use limit/cursor or keep includeTimeline/includeSnapshots disabled." });
-    });
-    server.registerTool("oko_get_session_report", {
-        title: "Get session report",
-        description: toolDescription({
-            summary: "Build a ready-to-share report for one analytics session, with compact structured data and markdown.",
-            args: [
-                "eventId: event to inspect.",
-                "sessionId: optional analytics session id; omitted means latest session.",
-                "includeTimeline: include recent timeline buckets; default false.",
-                "timelineLimit: max timeline buckets when includeTimeline=true.",
-                "includeSnapshots: include baseline/final snapshots; default false.",
-            ],
-            returns: "event/session ids, report URL, markdown summary, event summary, and compact session object.",
-            examples: ["Use after a webinar when the user asks for the finished session report without manually opening the report page."],
-        }),
-        inputSchema: {
-            eventId: eventIdField,
-            sessionId: z.string().min(1).optional().describe("analyticsSessions document id. Omit to use the latest session."),
-            includeTimeline: z.boolean().default(false).describe("Include recent timeline buckets."),
-            timelineLimit: z.number().int().min(1).max(500).default(ANALYTICS_TIMELINE_DEFAULT_LIMIT).describe("Max timeline buckets when includeTimeline=true."),
-            includeSnapshots: z.boolean().default(false).describe("Include baselineSnapshot and finalSnapshot."),
-        },
-        outputSchema: sessionReportOutputSchema,
-        annotations: readOnlyTool,
-    }, async ({ eventId, sessionId, includeTimeline, timelineLimit, includeSnapshots }) => {
-        const { uid } = await authed(["analytics:read"]);
-        const event = await readEvent(eventId, uid, "report");
-        let resolvedSessionId = sessionId;
-        let sessionData = null;
-        if (resolvedSessionId) {
-            const sessionSnap = await getDoc(doc(firestore, "events", eventId, "analyticsSessions", resolvedSessionId));
-            if (!sessionSnap.exists())
-                throw new Error("Analytics session not found.");
-            sessionData = sessionSnap.data();
-        }
-        else {
-            const snap = await getDocs(query(collection(firestore, "events", eventId, "analyticsSessions"), orderBy("startedAt", "desc"), limit(1)));
-            const first = snap.docs[0];
-            if (!first)
-                throw new Error("No analytics sessions found for this event.");
-            resolvedSessionId = first.id;
-            sessionData = first.data();
-        }
-        const session = compactAnalyticsSession({ id: resolvedSessionId, ...sessionData }, { includeTimeline, timelineLimit, includeSnapshots });
-        const markdown = sessionReportMarkdown({ eventId, event, sessionId: resolvedSessionId, session });
-        return textResult({
-            eventId,
-            sessionId: resolvedSessionId,
-            event: {
-                id: eventId,
-                title: safeString(event.title, eventId),
-                ...eventLinks(eventId),
-            },
-            reportUrl: sessionReportUrl(eventId, resolvedSessionId),
-            markdown,
-            session,
-        }, { truncationHint: "Keep includeTimeline/includeSnapshots disabled or lower timelineLimit." });
-    });
-}

package/dist/tools/setupValidation.js

@@ -1,144 +0,0 @@
-// Проверка готовности события к эфиру — чистая функция над документом.
-//
-// Отвечает на вопрос «можно ли это показывать зрителям»: есть ли заголовок и
-// видео, осмысленны ли блоки, не ведут ли кнопки в никуда, не потеряны ли
-// картинки. Ни одного обращения к базам: всё решается по уже прочитанному
-// документу — поэтому логика проверяется юнит-тестом, а не прогоном по проду.
-//
-// Различие уровней намеренное: ошибка мешает эфиру, предупреждение видно
-// только организатору, подсказка — совет.
-import { safeString } from "../utils.js";
-import { asRecord, eventLinks } from "./context.js";
-import { toMillis } from "./formatting.js";
-import { eventFormIds, readCardsConfig, readImageVariants } from "./imagePipeline.js";
-export function validateEventSetup(eventId, event) {
-    const errors = [];
-    const warnings = [];
-    const suggestions = [];
-    const add = (target, code, path, message) => {
-        target.push({ code, path, message });
-    };
-    const blocks = asRecord(event.blocks);
-    const forms = Array.isArray(event.forms) ? event.forms.filter((item) => item && typeof item === "object") : [];
-    const formIds = eventFormIds(event);
-    const title = safeString(event.title).trim();
-    if (!title)
-        add(errors, "title_missing", "title", "Event title is required.");
-    const video = asRecord(event.video);
-    if (!safeString(video.embedUrl).trim()) {
-        add(warnings, "video_missing", "video.embedUrl", "No normalized video URL is configured. This warning is for the organizer only and never appears as page text above other blocks. Without a video URL the player slot shows a small 'video not configured' notice, but when the video placeholder block is enabled and switched on, the placeholder fully covers that slot and viewers see only the placeholder.");
-    }
-    const meta = asRecord(event.meta);
-    const eventDateMs = toMillis(meta.eventDate);
-    if (eventDateMs == null) {
-        add(suggestions, "date_missing", "meta.eventDate", "Add the webinar date/time if it is known.");
-    }
-    else if (eventDateMs < Date.now() - 60 * 60 * 1000) {
-        add(warnings, "date_in_past", "meta.eventDate", "Configured webinar date appears to be in the past.");
-    }
-    const duplicateFormIds = new Set();
-    const seenFormIds = new Set();
-    forms.forEach((form, index) => {
-        const id = safeString(form.id).trim();
-        if (!id)
-            add(errors, "form_id_missing", `forms[${index}].id`, "Every form must have a stable id.");
-        else if (seenFormIds.has(id))
-            duplicateFormIds.add(id);
-        else
-            seenFormIds.add(id);
-        const fields = Array.isArray(form.fields) ? form.fields : [];
-        if (fields.length === 0)
-            add(warnings, "form_fields_missing", `forms[${index}].fields`, "Lead form has no fields.");
-    });
-    for (const id of duplicateFormIds)
-        add(errors, "form_id_duplicate", "forms", `Duplicate form id: ${id}.`);
-    const checkFormBinding = (path, formId) => {
-        const id = safeString(formId).trim();
-        if (id && !formIds.has(id))
-            add(errors, "form_binding_missing", path, `Referenced formId "${id}" does not exist in event.forms.`);
-    };
-    const promo = asRecord(blocks.promoBanner);
-    if (promo.enabled === true) {
-        checkFormBinding("blocks.promoBanner.formId", promo.formId);
-        if (!safeString(promo.link).trim() && !safeString(promo.formId).trim()) {
-            add(suggestions, "promo_target_missing", "blocks.promoBanner", "Enabled promo banner has no link or form binding.");
-        }
-        if (!safeString(promo.imageUrl).trim()) {
-            add(warnings, "promo_image_missing", "blocks.promoBanner.imageUrl", "Enabled promo banner has no image.");
-        }
-        else if (safeString(promo.imageMasterUrl).trim() && !readImageVariants(promo.imageVariants)) {
-            add(warnings, "promo_variants_pending", "blocks.promoBanner.imageVariants", "Promo banner image variants are not ready yet.");
-        }
-    }
-    const cta = asRecord(blocks.primaryCta);
-    if (cta.enabled === true) {
-        checkFormBinding("blocks.primaryCta.formId", cta.formId);
-        if (!safeString(cta.title).trim() && !safeString(cta.text).trim()) {
-            add(suggestions, "cta_copy_missing", "blocks.primaryCta", "Enabled CTA has no title or text.");
-        }
-        if (!safeString(cta.buttonLabel).trim()) {
-            add(warnings, "cta_button_missing", "blocks.primaryCta.buttonLabel", "Enabled CTA has no button label.");
-        }
-        if (safeString(cta.buttonLabel).trim() && !safeString(cta.buttonUrl).trim() && !safeString(cta.formId).trim()) {
-            add(warnings, "cta_target_missing", "blocks.primaryCta", "CTA button has no URL or form binding.");
-        }
-    }
-    const videoPlaceholder = asRecord(asRecord(blocks.video).placeholder);
-    if (videoPlaceholder.enabled === true && videoPlaceholder.mode === "image") {
-        if (!safeString(videoPlaceholder.imageUrl).trim()) {
-            add(warnings, "placeholder_image_missing", "blocks.video.placeholder.imageUrl", "Image placeholder mode is enabled but no image is configured.");
-        }
-        else if (safeString(videoPlaceholder.imageMasterUrl).trim() && !readImageVariants(videoPlaceholder.imageVariants)) {
-            add(warnings, "placeholder_variants_pending", "blocks.video.placeholder.imageVariants", "Video placeholder image variants are not ready yet.");
-        }
-    }
-    const cards = readCardsConfig(event);
-    // 🔴 Карточка без пригодного `id` — это ошибка данных, а не мелочь: id
-    // связывает запись с её картинкой в Storage и с обратной записью CF4.
-    // Пока подстановка молчала, проверка не могла назвать причину, по которой
-    // у карточки пропадает изображение при каждой правке.
-    cards.repairedIdPositions.forEach((position) => {
-        add(errors, "card_id_missing", `blocks.cards.items[${position}].id`, "Card has no usable id in Firestore; its image cannot be matched and will be dropped on the next update.");
-    });
-    if (cards.enabled) {
-        if (cards.items.length === 0)
-            add(warnings, "cards_empty", "blocks.cards.items", "Cards block is enabled but has no cards.");
-        const cardIds = new Set();
-        cards.items.forEach((card, index) => {
-            const path = `blocks.cards.items[${index}]`;
-            if (cardIds.has(card.id))
-                add(errors, "card_id_duplicate", `${path}.id`, `Duplicate card id: ${card.id}.`);
-            cardIds.add(card.id);
-            if (!card.title && !card.text)
-                add(suggestions, "card_copy_missing", path, "Card has no title or text.");
-            if (card.buttonLabel && !card.buttonUrl && !card.formId)
-                add(warnings, "card_target_missing", path, "Card button has no URL or form binding.");
-            if (card.formId && !formIds.has(card.formId))
-                add(errors, "card_form_missing", `${path}.formId`, `Referenced formId "${card.formId}" does not exist.`);
-            if (card.imageMasterUrl && !card.imageVariants)
-                add(warnings, "card_variants_pending", `${path}.imageVariants`, "Card image variants are not ready yet.");
-        });
-    }
-    const telegram = asRecord(event.telegram);
-    const telegramChannels = Array.isArray(telegram.channelIds) ? telegram.channelIds : [];
-    if (telegram.enabled === true && telegramChannels.length === 0) {
-        add(warnings, "telegram_channel_missing", "telegram.channelIds", "Telegram is enabled but no channel is configured.");
-    }
-    const nextActions = [
-        ...errors.map((item) => `Fix error: ${item.message}`),
-        ...warnings.slice(0, 5).map((item) => `Review warning: ${item.message}`),
-    ];
-    if (nextActions.length === 0)
-        nextActions.push("No blocking setup issues found.");
-    const penalty = errors.length * 25 + warnings.length * 8 + suggestions.length * 2;
-    return {
-        eventId,
-        ok: errors.length === 0,
-        score: Math.max(0, Math.min(100, 100 - penalty)),
-        errors,
-        warnings,
-        suggestions,
-        nextActions,
-        links: eventLinks(eventId),
-    };
-}