@aglyn/tenant-data-admin 1.0.0-beta.261 → 1.0.0-beta.262

package/src/lib/server/weekly-summary.d.ts

@@ -0,0 +1,144 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { AglynOrgMember } from '@aglyn/aglyn/foundation/definitions/organization.types';
+import { type ReleaseFlagKey } from '@aglyn/aglyn/app-utils/release-flags';
+import { type ResolvedPluginFigureReader } from '@aglyn/aglyn/plugin-manager/plugin-figures';
+import { type FigureReaderContext } from './figure-readers';
+/**
+ * THE WEEKLY SUMMARY'S SENDS (AGL-3867): `POST /api/admin/weekly-summary`,
+ * Mondays at 13:00 UTC (08:00 Central) from `scheduled-crons.yml`.
+ *
+ * ## Who is told
+ *
+ * A workspace's owners and admins: the people who reach every site and every
+ * figure, so one set of figures per workspace is true for each of them. The
+ * **Weekly summary** switch on their own account
+ * (`users/{uid}.digestPrefs.weeklySummary`, on until turned off) governs it.
+ * A locked or disabled account, a suppressed address and a suspended member
+ * are not mailed.
+ *
+ * ## What it reads
+ *
+ * The workspace's busiest `WEEKLY_SUMMARY_MAX_SITES` sites by last week's
+ * page views, each through every site reader that declares a
+ * `weeklySummary`, and the workspace through every workspace reader that
+ * does. Each reader is offered only where its plan feature is included and
+ * its plugin runs (`eligibleFigureReaders`), read over the seven whole days
+ * before the run, and worded by its owner. A reader that fails is left out;
+ * the rest are still read.
+ *
+ * ## Once a week, and resumable
+ *
+ * `orgs/{orgId}/weeklySummaries/{week}` records each person sent, stamped
+ * after each send, so a run that dies mid-workspace re-sends only to those it
+ * never reached and a second run in the same week sends nothing. Workspaces
+ * are swept in id order behind a cursor, the `done: false` loop the workflow
+ * already runs for the CRM digest.
+ *
+ * The email is a `bulk` send under the platform send-rate governor: a refusal
+ * stops the run and answers `done: true`, and the unsent are picked up by a
+ * manual re-run in the same week. Metered as PLATFORM mail, not the
+ * workspace's: it is the platform reporting to the people who run it.
+ */
+type Firestore = FirebaseFirestore.Firestore;
+/** The beat `/api/health/crons` reads, once this job joins its inventory. */
+export declare const WEEKLY_SUMMARY_JOB_ID = "weekly-summary";
+/** `orgs/{orgId}/weeklySummaries/{week}` — server-written, matched by no rule. */
+export declare const WEEKLY_SUMMARY_MARKERS = "weeklySummaries";
+/** Workspaces per invocation; a chunk that times out never advances its cursor. */
+export declare const WEEKLY_SUMMARY_ORG_CHUNK = 20;
+/** Sites a workspace's sweep ranks, by document id. */
+export declare const WEEKLY_SUMMARY_HOST_READ_LIMIT = 50;
+/** Sites one summary reports on: the busiest by last week's page views. */
+export declare const WEEKLY_SUMMARY_MAX_SITES = 5;
+/** Members per workspace whose address is chased through the auth pools when their member document has none. */
+export declare const WEEKLY_SUMMARY_MAX_UID_LOOKUPS = 5;
+/** How long one call works before it stops and leaves the rest to the next. */
+export declare const WEEKLY_SUMMARY_RUN_BUDGET_MS = 45000;
+export interface WeeklySummarySendResult {
+    sent: boolean;
+    /** The platform's send rate refused it for now. */
+    rateLimited: boolean;
+    reason?: string;
+}
+export interface WeeklySummaryEmail {
+    to: string;
+    subject: string;
+    /** The body token: the figures without the closing line the footer carries. */
+    body: string;
+    /** The plain fallback, closing line included. */
+    text: string;
+    org: Record<string, unknown>;
+    merge: Record<string, string>;
+}
+/** Everything the sweep reaches beyond Firestore, so a spec can hold each one. */
+export interface WeeklySummaryDeps {
+    firestore: Firestore;
+    runAt: Date;
+    dryRun: boolean;
+    /** The console's absolute origin, or `''` when none is configured. */
+    origin: string;
+    /** Whether a release flag is on for an org. */
+    flagOn: (flag: ReleaseFlagKey, orgId: string, org: Record<string, unknown>) => boolean;
+    orgMembers: (orgId: string) => Promise<AglynOrgMember[]>;
+    /** The uids whose accounts may be mailed. */
+    reachable: (uids: string[]) => Promise<string[]>;
+    /** The readers that declare a `weeklySummary` and pass the gates here. */
+    readers: (context: Omit<FigureReaderContext, 'accept'>) => Promise<ResolvedPluginFigureReader[]>;
+    /** The member's deliverable address, or `null` when there is none or it is suppressed. */
+    address: (member: AglynOrgMember, lookups: {
+        left: number;
+    }) => Promise<string | null>;
+    send: (email: WeeklySummaryEmail) => Promise<WeeklySummarySendResult>;
+    budgetMs?: number;
+}
+export interface WeeklySummaryOrgReport {
+    skipped?: string;
+    sites: number;
+    recipients: number;
+    sent: number;
+    failed?: number;
+    /** Why the workspace stopped short: the call's time ran out, or the send rate refused. */
+    deferred?: 'time' | 'rate';
+}
+export interface WeeklySummaryReport {
+    week: string;
+    dryRun: boolean;
+    swept: number;
+    sent: number;
+    orgs: Record<string, WeeklySummaryOrgReport>;
+    deferred: false | 'time' | 'rate';
+    nextCursor: string | null;
+    done: boolean;
+}
+/** One chunk of the sweep: workspaces in id order after `cursor`. */
+export declare function runWeeklySummarySweep(deps: WeeklySummaryDeps, options?: {
+    cursor?: string | null;
+    limit?: number;
+}): Promise<WeeklySummaryReport>;
+/** The sweep's reach into the real platform: Firestore, the flags, the roster, the mail. */
+export declare function weeklySummaryDeps(options: {
+    runAt: Date;
+    dryRun: boolean;
+}): Promise<WeeklySummaryDeps>;
+/**
+ * `POST /api/admin/weekly-summary` sends; a GET, or `{"dryRun": true}`,
+ * reports who would be sent what and sends nothing. The body may carry the
+ * `cursor` a previous chunk answered and a smaller `limit`.
+ */
+export declare function weeklySummaryRoute(request: Request): Promise<Response>;
+export {};

package/src/lib/server/weekly-summary.js

@@ -0,0 +1,479 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+import { brandSupportLine } from "@aglyn/aglyn/app-utils/brand-support-line";
+import { buildRoute, Route } from "@aglyn/aglyn/app-utils/console-routes";
+import { writeCronBeat } from "@aglyn/aglyn/app-utils/health-report";
+import { DIGEST_PREFS_FIELD, digestEnabled, INSIGHT_DIGESTS_FIELD, insightDigestSubscribed } from "@aglyn/aglyn/app-utils/notifications";
+import { checkEntitlement, resolveBrandingProfile, resolveEffectivePlan } from "@aglyn/aglyn/app-utils/plan-entitlements";
+import { platformConsoleOrigin } from "@aglyn/aglyn/app-utils/platform-brand";
+import { isReleaseFlagOnForOrg, parseOrgReleaseFlagOverrides } from "@aglyn/aglyn/app-utils/release-flags";
+import { composeWeeklySummaryEmailText, composeWeeklySummarySubject, WEEKLY_SUMMARY_DAYS, WEEKLY_SUMMARY_DIGEST_KEY, weeklySummaryPeriod } from "@aglyn/aglyn/app-utils/weekly-summary";
+import { normalizePluginFigureTable, pluginFigureSummarySection } from "@aglyn/aglyn/plugin-manager/plugin-figures";
+import { rateLimitedRetryAtMs, sendEmail } from "@aglyn/shared-util-email";
+import { withoutMailWithheldAccounts } from "./account-mail.js";
+import { findUserByUidAcrossPools } from "./auth-pools.js";
+import { isCronAuthorized, isCronDryRun } from "./cron-auth.js";
+import { meterPlatformEmail } from "./email-metering.js";
+import { filterSuppressedEmails } from "./email-suppression.js";
+import { eligibleFigureReaders } from "./figure-readers.js";
+import firebaseAdmin from "./firebase-admin.js";
+import { listOrgMembers } from "./organizations.js";
+import { getServerReleaseFlagValues } from "./release-flags.js";
+import { loadSystemEmail, renderLoadedSystemEmail, systemEmailBrand, systemEmailContent } from "./render-system-email.js";
+/** The beat `/api/health/crons` reads, once this job joins its inventory. */ export const WEEKLY_SUMMARY_JOB_ID = 'weekly-summary';
+/** `orgs/{orgId}/weeklySummaries/{week}` — server-written, matched by no rule. */ export const WEEKLY_SUMMARY_MARKERS = 'weeklySummaries';
+/** Workspaces per invocation; a chunk that times out never advances its cursor. */ export const WEEKLY_SUMMARY_ORG_CHUNK = 20;
+/** Sites a workspace's sweep ranks, by document id. */ export const WEEKLY_SUMMARY_HOST_READ_LIMIT = 50;
+/** Sites one summary reports on: the busiest by last week's page views. */ export const WEEKLY_SUMMARY_MAX_SITES = 5;
+/** Members per workspace whose address is chased through the auth pools when their member document has none. */ export const WEEKLY_SUMMARY_MAX_UID_LOOKUPS = 5;
+/** How long one call works before it stops and leaves the rest to the next. */ export const WEEKLY_SUMMARY_RUN_BUDGET_MS = 45000;
+const str = (value)=>typeof value === 'string' ? value.trim() : '';
+function siteName(data, id) {
+    return str(data['displayName']) || str(data['name']) || str(data['subdomain']) || id;
+}
+/** Last week's page views for each site, read from the daily analytics documents. */ async function weekViews(firestore, hosts, days) {
+    const views = new Map();
+    if (!hosts.length) return views;
+    const refs = hosts.flatMap((host)=>days.map((day)=>host.ref.collection('analytics').doc(day)));
+    const docs = await firestore.getAll(...refs);
+    for (const doc of docs){
+        var _ref, _views_get, _doc_get;
+        var _doc_ref_parent_parent;
+        const hostId = (_ref = (_doc_ref_parent_parent = doc.ref.parent.parent) == null ? void 0 : _doc_ref_parent_parent.id) != null ? _ref : '';
+        views.set(hostId, ((_views_get = views.get(hostId)) != null ? _views_get : 0) + (Number((_doc_get = doc.get('total')) != null ? _doc_get : 0) || 0));
+    }
+    return views;
+}
+function weekDays(from) {
+    const start = Date.parse(`${from}T00:00:00Z`);
+    return Array.from({
+        length: WEEKLY_SUMMARY_DAYS
+    }, (_, index)=>new Date(start + index * 86400000).toISOString().slice(0, 10));
+}
+/**
+ * Each reader's entry, in its declared order: read over the week, then worded
+ * by its owner. A reader that fails, answers no table or cannot be read over
+ * seven days is left out.
+ */ async function readEntries(readers, base) {
+    const ordered = readers.filter(({ reader })=>reader.weeklySummary).sort((a, b)=>{
+        var _ref, _ref1;
+        var _a_reader_weeklySummary, _b_reader_weeklySummary;
+        return ((_ref = (_a_reader_weeklySummary = a.reader.weeklySummary) == null ? void 0 : _a_reader_weeklySummary.order) != null ? _ref : 0) - ((_ref1 = (_b_reader_weeklySummary = b.reader.weeklySummary) == null ? void 0 : _b_reader_weeklySummary.order) != null ? _ref1 : 0) || a.reader.id.localeCompare(b.reader.id);
+    });
+    const entries = [];
+    for (const { reader } of ordered){
+        const summary = reader.weeklySummary;
+        if (!summary) continue;
+        const days = reader.windows.length ? reader.windows.includes(WEEKLY_SUMMARY_DAYS) ? WEEKLY_SUMMARY_DAYS : null : 0;
+        if (days === null) continue;
+        try {
+            var _ref;
+            const read = await reader.read(_extends({}, base, {
+                days,
+                uid: null,
+                params: {}
+            }));
+            if (read.ok === false) continue;
+            const table = normalizePluginFigureTable(read.table);
+            if (!table) continue;
+            entries.push({
+                lines: summary.lines(table),
+                headline: (_ref = summary.headline == null ? void 0 : summary.headline.call(summary, table)) != null ? _ref : null
+            });
+        } catch (error) {
+            console.error('[weekly-summary] reader failed', {
+                reader: reader.id,
+                orgId: base.orgId,
+                error
+            });
+        }
+    }
+    return entries;
+}
+async function summarizeOrg(deps, orgDoc, period, overBudget) {
+    var _orgDoc_data, _get;
+    const { firestore } = deps;
+    const orgId = orgDoc.id;
+    const org = (_orgDoc_data = orgDoc.data()) != null ? _orgDoc_data : {};
+    const report = {
+        sites: 0,
+        recipients: 0,
+        sent: 0
+    };
+    const markerRef = orgDoc.ref.collection(WEEKLY_SUMMARY_MARKERS).doc(period.week);
+    const sentAlready = (_get = (await markerRef.get()).get('sent')) != null ? _get : {};
+    // Owners and admins, not suspended, whose accounts may be mailed, who kept the switch on.
+    const managers = (await deps.orgMembers(orgId)).filter((member)=>(member.role === 'owner' || member.role === 'admin') && member.orgSuspended !== true);
+    const reachable = new Set(await deps.reachable(managers.map((member)=>member.$id)));
+    const candidates = managers.filter((member)=>reachable.has(member.$id) && !sentAlready[member.$id]).sort((a, b)=>a.$id.localeCompare(b.$id));
+    if (!candidates.length) return _extends({}, report, {
+        skipped: managers.length ? 'nobody-left' : 'no-managers'
+    });
+    const userDocs = await firestore.getAll(...candidates.map((member)=>firestore.collection('users').doc(member.$id)));
+    const users = new Map(userDocs.map((doc)=>[
+            doc.id,
+            doc
+        ]));
+    const recipients = candidates.filter((member)=>{
+        var _users_get;
+        return digestEnabled((_users_get = users.get(member.$id)) == null ? void 0 : _users_get.get(DIGEST_PREFS_FIELD), WEEKLY_SUMMARY_DIGEST_KEY);
+    });
+    report.recipients = recipients.length;
+    if (!recipients.length) return _extends({}, report, {
+        skipped: 'summary-off'
+    });
+    // The busiest sites by last week's page views, ties by id.
+    const hostPage = await firestore.collection('hosts').where('orgId', '==', orgId).orderBy(firebaseAdmin.firestore.FieldPath.documentId()).limit(WEEKLY_SUMMARY_HOST_READ_LIMIT).get();
+    const hosts = hostPage.docs.filter((doc)=>!doc.get('deletedAt'));
+    const views = await weekViews(firestore, hosts, weekDays(period.from));
+    const chosen = [
+        ...hosts
+    ].sort((a, b)=>{
+        var _views_get, _views_get1;
+        return ((_views_get = views.get(b.id)) != null ? _views_get : 0) - ((_views_get1 = views.get(a.id)) != null ? _views_get1 : 0) || a.id.localeCompare(b.id);
+    }).slice(0, WEEKLY_SUMMARY_MAX_SITES);
+    const orgSlug = str(org['slug']);
+    const sites = [];
+    for (const host of chosen){
+        var _host_data;
+        const data = (_host_data = host.data()) != null ? _host_data : {};
+        const readers = (await deps.readers({
+            orgId,
+            hostId: host.id,
+            org,
+            host: data
+        })).filter(({ reader })=>pluginFigureSummarySection(reader) === 'site');
+        const entries = await readEntries(readers, {
+            orgId,
+            hostId: host.id,
+            now: period.now
+        });
+        const subdomain = str(data['subdomain']);
+        sites.push({
+            name: siteName(data, host.id),
+            url: deps.origin && orgSlug && subdomain ? `${deps.origin}${buildRoute(Route.HOST_DASHBOARD, {
+                orgSlug,
+                host: subdomain
+            })}` : null,
+            entries
+        });
+    }
+    const orgReaders = await deps.readers({
+        orgId,
+        hostId: null,
+        org,
+        host: null
+    });
+    const workspace = await readEntries(orgReaders.filter(({ reader })=>pluginFigureSummarySection(reader) === 'workspace'), {
+        orgId,
+        hostId: null,
+        now: period.now
+    });
+    const branding = resolveBrandingProfile(org);
+    const workspaceName = str(org['name']) || orgSlug || 'your workspace';
+    const settingsUrl = `${deps.origin}${buildRoute(Route.MANAGE_NOTIFICATION_SETTINGS)}`;
+    // AI weekly insights, pointed to only where the plan includes them and they are released.
+    const offersInsights = checkEntitlement(org, 'aiGenerative') && deps.flagOn('release_ai_generative', orgId, org);
+    const busiest = chosen[0];
+    const analyticsUrl = offersInsights && deps.origin && orgSlug && busiest && str(busiest.get('subdomain')) ? `${deps.origin}${buildRoute(Route.HOST_ANALYTICS, {
+        orgSlug,
+        host: str(busiest.get('subdomain'))
+    })}` : null;
+    const supportLine = brandSupportLine(branding);
+    const subject = composeWeeklySummarySubject(workspaceName, sites);
+    const input = {
+        workspaceName,
+        productName: branding.productName,
+        periodLabel: period.label,
+        sites,
+        workspace,
+        settingsUrl
+    };
+    report.sites = sites.length;
+    const lookups = {
+        left: WEEKLY_SUMMARY_MAX_UID_LOOKUPS
+    };
+    if (!composeWeeklySummaryEmailText(_extends({}, input, {
+        aiInsightsUrl: null
+    }))) {
+        return _extends({}, report, {
+            skipped: 'nothing-to-report'
+        });
+    }
+    for (const member of recipients){
+        var _composeWeeklySummaryEmailText, _composeWeeklySummaryEmailText1;
+        var _users_get;
+        if (overBudget()) return _extends({}, report, {
+            deferred: 'time'
+        });
+        const subscribed = insightDigestSubscribed((_users_get = users.get(member.$id)) == null ? void 0 : _users_get.get(INSIGHT_DIGESTS_FIELD), orgId);
+        const aiInsightsUrl = analyticsUrl && !subscribed ? analyticsUrl : null;
+        const body = (_composeWeeklySummaryEmailText = composeWeeklySummaryEmailText(_extends({}, input, {
+            aiInsightsUrl,
+            omitClosing: true
+        }))) != null ? _composeWeeklySummaryEmailText : '';
+        if (deps.dryRun) {
+            report.sent += 1;
+            continue;
+        }
+        const to = await deps.address(member, lookups);
+        if (!to) continue;
+        const text = [
+            (_composeWeeklySummaryEmailText1 = composeWeeklySummaryEmailText(_extends({}, input, {
+                aiInsightsUrl
+            }))) != null ? _composeWeeklySummaryEmailText1 : body,
+            supportLine
+        ].filter(Boolean).join('\n\n');
+        const result = await deps.send({
+            to,
+            subject,
+            body,
+            text,
+            org,
+            merge: {
+                'summary.subject': subject,
+                'org.name': workspaceName,
+                'summary.period': period.label,
+                'summary.body': body,
+                settingsUrl
+            }
+        });
+        if (result.sent) {
+            report.sent += 1;
+            await markerRef.set({
+                week: period.week,
+                sent: {
+                    [member.$id]: true
+                },
+                updatedAt: firebaseAdmin.firestore.FieldValue.serverTimestamp()
+            }, {
+                merge: true
+            });
+        } else if (result.rateLimited) {
+            return _extends({}, report, {
+                deferred: 'rate'
+            });
+        } else {
+            var _report_failed;
+            report.failed = ((_report_failed = report.failed) != null ? _report_failed : 0) + 1;
+        }
+    }
+    return report;
+}
+/** One chunk of the sweep: workspaces in id order after `cursor`. */ export async function runWeeklySummarySweep(deps, options = {}) {
+    var _deps_budgetMs, _options_limit;
+    const { firestore } = deps;
+    const startedAt = Date.now();
+    const budget = (_deps_budgetMs = deps.budgetMs) != null ? _deps_budgetMs : WEEKLY_SUMMARY_RUN_BUDGET_MS;
+    const overBudget = ()=>Date.now() - startedAt > budget;
+    const period = weeklySummaryPeriod(deps.runAt);
+    const pageSize = Math.max(1, Math.min(Math.floor((_options_limit = options.limit) != null ? _options_limit : WEEKLY_SUMMARY_ORG_CHUNK), WEEKLY_SUMMARY_ORG_CHUNK));
+    let query = firestore.collection('orgs').orderBy(firebaseAdmin.firestore.FieldPath.documentId()).limit(pageSize + 1);
+    if (options.cursor) query = query.startAfter(firestore.collection('orgs').doc(options.cursor));
+    const page = await query.get();
+    const hasMore = page.docs.length > pageSize;
+    const orgDocs = hasMore ? page.docs.slice(0, pageSize) : page.docs;
+    const report = {
+        week: period.week,
+        dryRun: deps.dryRun,
+        swept: 0,
+        sent: 0,
+        orgs: {},
+        deferred: false,
+        nextCursor: null,
+        done: true
+    };
+    let last = null;
+    for (const orgDoc of orgDocs){
+        if (overBudget()) {
+            report.deferred = 'time';
+            break;
+        }
+        try {
+            const orgReport = await summarizeOrg(deps, orgDoc, period, overBudget);
+            report.orgs[orgDoc.id] = orgReport;
+            report.sent += orgReport.sent;
+            if (orgReport.deferred) {
+                report.deferred = orgReport.deferred;
+                break;
+            }
+        } catch (error) {
+            console.error('[weekly-summary] workspace failed', orgDoc.id, error);
+            report.orgs[orgDoc.id] = {
+                skipped: 'failed',
+                sites: 0,
+                recipients: 0,
+                sent: 0
+            };
+        }
+        report.swept += 1;
+        last = orgDoc.id;
+    }
+    /*
+   * Out of time: the next call starts after the last workspace that finished,
+   * and the marker skips whoever the unfinished one already reached. Refused
+   * by the send rate: the window is full, so the run stops (`done: true`)
+   * rather than re-POSTing into it; a re-run in the same week reaches the rest.
+   */ if (report.deferred === 'time') {
+        var _ref;
+        report.nextCursor = (_ref = last != null ? last : options.cursor) != null ? _ref : null;
+        report.done = false;
+    } else if (report.deferred === 'rate') {
+        report.done = true;
+    } else {
+        report.nextCursor = hasMore ? last : null;
+        report.done = report.nextCursor === null;
+    }
+    return report;
+}
+/** The sweep's reach into the real platform: Firestore, the flags, the roster, the mail. */ export async function weeklySummaryDeps(options) {
+    const firestore = firebaseAdmin.app().firestore();
+    const flags = await getServerReleaseFlagValues();
+    // The designed email is read once per call and rendered per recipient.
+    let loaded;
+    return {
+        firestore,
+        runAt: options.runAt,
+        dryRun: options.dryRun,
+        origin: platformConsoleOrigin(),
+        flagOn: (flag, orgId, org)=>isReleaseFlagOnForOrg(flag, flags[flag], orgId, parseOrgReleaseFlagOverrides(org['releaseFlags']), resolveEffectivePlan(org)),
+        orgMembers: (orgId)=>listOrgMembers(orgId),
+        reachable: (uids)=>withoutMailWithheldAccounts(uids),
+        readers: (context)=>eligibleFigureReaders(_extends({}, context, {
+                accept: (reader)=>Boolean(reader.weeklySummary)
+            })),
+        address: async (member, lookups)=>{
+            let address = str(member.email).toLowerCase();
+            if (!address.includes('@') && lookups.left > 0) {
+                var _pooled_record;
+                lookups.left -= 1;
+                const pooled = await findUserByUidAcrossPools(member.$id).catch(()=>null);
+                address = str(pooled == null ? void 0 : (_pooled_record = pooled.record) == null ? void 0 : _pooled_record.email).toLowerCase();
+            }
+            if (!address.includes('@')) return null;
+            const [kept] = await filterSuppressedEmails([
+                address
+            ], firestore);
+            return kept != null ? kept : null;
+        },
+        send: async (email)=>{
+            var _result_reason;
+            loaded != null ? loaded : loaded = loadSystemEmail('weekly-summary').catch(()=>null);
+            const template = await loaded;
+            const brand = systemEmailBrand(email.org);
+            const rendered = template ? renderLoadedSystemEmail(template, _extends({}, brand.merge, email.merge), brand.options) : null;
+            const result = await sendEmail(_extends({
+                to: [
+                    email.to
+                ]
+            }, systemEmailContent(rendered, {
+                subject: email.subject,
+                text: email.text
+            }), {
+                fromName: resolveBrandingProfile(email.org).fromName,
+                context: 'weekly-summary',
+                priority: 'bulk'
+            }));
+            if (result.sent) {
+                await meterPlatformEmail().catch(()=>undefined);
+                return {
+                    sent: true,
+                    rateLimited: false
+                };
+            }
+            return {
+                sent: false,
+                rateLimited: rateLimitedRetryAtMs(result) !== null,
+                reason: (_result_reason = result.reason) != null ? _result_reason : 'failed'
+            };
+        }
+    };
+}
+// lockdown-423: exempt — server-internal cron (x-cron-secret), no user caller; it reads each workspace's figures to report them to its owners and admins and writes nothing a locked org could lose.
+/**
+ * `POST /api/admin/weekly-summary` sends; a GET, or `{"dryRun": true}`,
+ * reports who would be sent what and sends nothing. The body may carry the
+ * `cursor` a previous chunk answered and a smaller `limit`.
+ */ export async function weeklySummaryRoute(request) {
+    const method = request.method.toUpperCase();
+    if (method !== 'POST' && method !== 'GET') {
+        return Response.json({
+            error: 'Method not allowed'
+        }, {
+            status: 405,
+            headers: {
+                Allow: 'GET, POST'
+            }
+        });
+    }
+    if (!process.env['CRON_SECRET']) {
+        return Response.json({
+            error: 'The weekly summary is not configured (CRON_SECRET).'
+        }, {
+            status: 501
+        });
+    }
+    const headers = Object.fromEntries(request.headers.entries());
+    if (!isCronAuthorized(headers)) return Response.json({
+        error: 'Unauthenticated'
+    }, {
+        status: 401
+    });
+    const body = method === 'POST' ? await request.json().catch(()=>null) : null;
+    const query = Object.fromEntries(new URL(request.url).searchParams.entries());
+    const dryRun = isCronDryRun({
+        method,
+        body: body != null ? body : undefined,
+        query
+    });
+    // Stamped on the invocation, not on the work (AGL-1955), so the beat is
+    // already there the day this job joins `SCHEDULED_JOBS`.
+    if (method === 'POST') {
+        try {
+            await writeCronBeat(firebaseAdmin.app().firestore(), WEEKLY_SUMMARY_JOB_ID);
+        } catch (unused) {
+        // A job that stops stamping reds its own row; it never fails the run.
+        }
+    }
+    try {
+        const rawCursor = body == null ? void 0 : body['cursor'];
+        const cursor = typeof rawCursor === 'string' && rawCursor.length > 0 && !rawCursor.includes('/') ? rawCursor : null;
+        const limit = Number(body == null ? void 0 : body['limit']);
+        const report = await runWeeklySummarySweep(await weeklySummaryDeps({
+            runAt: new Date(),
+            dryRun
+        }), _extends({
+            cursor
+        }, Number.isFinite(limit) && limit > 0 ? {
+            limit
+        } : {}));
+        return Response.json(report, {
+            headers: {
+                'Cache-Control': 'no-store'
+            }
+        });
+    } catch (error) {
+        console.error('[weekly-summary] run failed', error);
+        return Response.json({
+            error: 'Weekly summary run failed'
+        }, {
+            status: 500
+        });
+    }
+}
+
+//# sourceMappingURL=weekly-summary.js.map