@prenta/core 5.8.1 → 5.10.0

package/dist/seo/geo-record.js

@@ -0,0 +1,252 @@
+/**
+ * GEO measurement write path: daily (date, bot, path) crawl buckets and
+ * (date, engine, path) referral buckets (spec 2026-09-08 §3).
+ *
+ * Both writers are best-effort — a storage failure or a consumer schema that
+ * predates the tables must never break a public response. Server-side callers
+ * (`recordAiCrawlerHit`, the beacon route) DO await them: on serverless an
+ * un-awaited write may be dropped when the response ends. The fire-and-forget
+ * part of the pipeline is the site middleware's beacon `fetch`, not these.
+ *
+ * The kill switch (`SeoModuleSettings.geoMeasurementEnabled`) is enforced
+ * *here*, inside the writers, so it covers every caller — the public beacon and
+ * the server-side surfaces (`/llms.txt`, `/llms-full.txt`, `.md`, honeypot)
+ * alike. See {@link isGeoMeasurementEnabled}.
+ *
+ * Query budget (spec §3): an existing `(date, actor, path)` row costs exactly
+ * one `updateMany`; only a new path pays for the memoised distinct-path count
+ * (one `count` per `(date, actor)` per {@link GEO_CAP_MEMO_MS}) plus one
+ * `upsert`. The settings read behind the kill switch is memoised for
+ * {@link GEO_SETTINGS_MEMO_MS}.
+ */
+import { hasModel } from '../api/route-helpers.js';
+import { normalizeRedirectPath } from '../redirects/graph.js';
+import { startOfDayUTC } from './autopilot-ledger.js';
+import { getSeoOverrides, resolveSeoModuleSettings } from './config-store.js';
+export { GEO_RETENTION_DEFAULT_DAYS, GEO_RETENTION_MAX_DAYS, GEO_RETENTION_MIN_DAYS, clampGeoRetentionDays, } from './geo-retention.js';
+/**
+ * Max distinct paths per `(date, bot)` — the rest of that bot's day rolls into
+ * {@link GEO_OTHER_PATH}, so a crawler (or an attacker replaying the public
+ * beacon) cannot grow the table by inventing paths.
+ *
+ * This is a **soft bound**: the distinct-path count is memoised per isolate
+ * for {@link GEO_CAP_MEMO_MS}, so N cold isolates (serverless) that each read
+ * a below-cap count in the same minute can together overshoot to ≈ N × cap
+ * rows for that `(date, actor)` before their memos expire. Bounded, not exact.
+ */
+export const GEO_CRAWL_PATH_CAP = 500;
+/**
+ * Same cap and the same soft-bound caveat, keyed by `(date, engine)`. Referral
+ * beacons are as unauthenticated as crawl beacons, so "a path must exist on
+ * the site to be linked" is not a property the server can rely on.
+ */
+export const GEO_REFERRAL_PATH_CAP = GEO_CRAWL_PATH_CAP;
+export const GEO_OTHER_PATH = '(other)';
+/** How long a `(date, actor)` distinct-path count is trusted before re-counting. */
+export const GEO_CAP_MEMO_MS = 60_000;
+/** How long the kill-switch setting is trusted before re-reading it. */
+export const GEO_SETTINGS_MEMO_MS = 30_000;
+/** Minimum gap between two storage-failure `console.warn`s per process. */
+export const GEO_WARN_THROTTLE_MS = 60_000;
+export const GEO_MAX_PATH_LEN = 2048;
+export const GEO_MAX_ACTOR_LEN = 64;
+/** Largest `POST /geo/beacon` body accepted; a real payload is under 200 bytes. */
+export const GEO_MAX_BEACON_BYTES = 4096;
+/** UTC calendar day — the same convention as `SearchPerfDaily`. */
+export function geoDay(now) {
+    return startOfDayUTC(now);
+}
+/**
+ * Characters a percent-encoded `url.pathname` can contain: RFC 3986 unreserved
+ * (`A-Z a-z 0-9 - . _ ~`) plus `/` and the `%` of an escape. The middleware
+ * sends `url.pathname` verbatim (never decoded), so spaces, quotes, unicode,
+ * angle brackets and sub-delims can only arrive from a hand-crafted beacon.
+ */
+const GEO_PATH_CHARS = /^[A-Za-z0-9/_\-.~%]*$/;
+/**
+ * Site-relative path for storage: lower-cased, no query/hash, no trailing
+ * slash. Absolute URLs, over-long inputs and anything outside
+ * {@link GEO_PATH_CHARS} are rejected (`null` → the hit is dropped).
+ */
+export function normalizeGeoPath(input) {
+    if (typeof input !== 'string' || input.length > GEO_MAX_PATH_LEN)
+        return null;
+    const trimmed = input.trim();
+    // absolute (`https://…`) and protocol-relative (`//host/…`) URLs are not paths
+    if (/^https?:\/\//i.test(trimmed) || trimmed.startsWith('//'))
+        return null;
+    const normalized = normalizeRedirectPath(input);
+    if (!normalized.startsWith('/') || normalized.startsWith('//'))
+        return null;
+    return GEO_PATH_CHARS.test(normalized) ? normalized : null;
+}
+// ─── Kill-switch memo (one settings read per 30 s per process) ───────────────
+let settingsMemo = null;
+/** Test hook; also called after a successful settings write so it takes effect at once. */
+export function resetGeoSettingsMemo() {
+    settingsMemo = null;
+}
+/**
+ * `SeoModuleSettings.geoMeasurementEnabled`, memoised for
+ * {@link GEO_SETTINGS_MEMO_MS}. Both writers consult it, so flipping the switch
+ * stops server-side recording as well as the beacon. `getSeoOverrides` never
+ * throws (it returns `null` on any read failure), which resolves to the
+ * default — measurement on.
+ */
+export async function isGeoMeasurementEnabled(db) {
+    const now = Date.now();
+    if (settingsMemo && now - settingsMemo.at < GEO_SETTINGS_MEMO_MS)
+        return settingsMemo.enabled;
+    const s = resolveSeoModuleSettings(await getSeoOverrides(db));
+    settingsMemo = { enabled: s.geoMeasurementEnabled, at: now };
+    return s.geoMeasurementEnabled;
+}
+// ─── Warn throttle ───────────────────────────────────────────────────────────
+let lastWarnAt = 0;
+/** Test hook. */
+export function resetGeoWarnThrottle() {
+    lastWarnAt = 0;
+}
+/**
+ * One `console.warn` per {@link GEO_WARN_THROTTLE_MS} per process, shared by
+ * both writers: a bot storm against a broken database must not flood the log
+ * with one line per dropped hit (spec "Failure handling").
+ */
+function warnThrottled(message, err) {
+    const now = Date.now();
+    if (now - lastWarnAt < GEO_WARN_THROTTLE_MS)
+        return;
+    lastWarnAt = now;
+    console.warn(message, err);
+}
+let capMemo = new Map();
+/** Test hook. */
+export function resetGeoCapMemo() {
+    capMemo = new Map();
+}
+const MEMO_KEY_SEP = '|';
+/** Day first so {@link evictOtherDays} can read it off the key. */
+function memoKey(date, kind, actor) {
+    return [date.toISOString(), kind, actor].join(MEMO_KEY_SEP);
+}
+/**
+ * Drops memo entries for any day other than `date`. Called when a new entry is
+ * inserted, so the map never grows past (actors seen today); the map is small,
+ * so a linear sweep is fine.
+ */
+function evictOtherDays(date) {
+    const today = date.toISOString();
+    for (const key of capMemo.keys()) {
+        if (key.slice(0, key.indexOf(MEMO_KEY_SEP)) !== today)
+            capMemo.delete(key);
+    }
+}
+async function distinctPathCount(spec) {
+    const key = memoKey(spec.date, spec.kind, spec.actor);
+    const memo = capMemo.get(key);
+    if (memo && spec.nowMs - memo.at < GEO_CAP_MEMO_MS)
+        return memo.count;
+    const count = await spec.delegate.count({
+        where: { date: spec.date, [spec.actorField]: spec.actor },
+    });
+    evictOtherDays(spec.date);
+    capMemo.set(key, { count, at: spec.nowMs });
+    return count;
+}
+function bumpMemo(spec) {
+    const memo = capMemo.get(memoKey(spec.date, spec.kind, spec.actor));
+    if (memo)
+        memo.count += 1;
+}
+/**
+ * Upsert one `(date, actor, path)` bucket under the per-`(date, actor)`
+ * distinct-path cap. Shared by both writers so the cap, memo and overflow
+ * semantics cannot drift between crawls and referrals. Throws on storage
+ * failure — the callers translate that into `'skipped'`.
+ */
+async function recordDailyBucket(spec) {
+    const { delegate, date, actorField, actor, path, counterField, extra = {} } = spec;
+    const actorWhere = { date, [actorField]: actor };
+    const touch = { [counterField]: { increment: 1 }, ...extra };
+    // Hot path: an existing bucket is a single UPDATE … WHERE (date, actor, path).
+    const { count: updated } = await delegate.updateMany({
+        where: { ...actorWhere, path },
+        data: touch,
+    });
+    if (updated > 0)
+        return 'recorded';
+    // New path for this (date, actor): consult the memoised distinct-path count.
+    const distinct = await distinctPathCount(spec);
+    const capped = distinct >= spec.cap;
+    const target = capped ? GEO_OTHER_PATH : path;
+    // upsert (not create) so a concurrent insert of the same key increments
+    // instead of failing on the unique constraint.
+    await delegate.upsert({
+        where: { [`date_${actorField}_path`]: { ...actorWhere, path: target } },
+        update: touch,
+        create: { ...actorWhere, path: target, [counterField]: 1, ...extra },
+    });
+    if (capped)
+        return 'other';
+    bumpMemo(spec);
+    return 'recorded';
+}
+// ─── Writers ─────────────────────────────────────────────────────────────────
+export async function recordGeoCrawl(db, input) {
+    if (!db || !hasModel(db, 'geoCrawlDaily'))
+        return 'skipped';
+    const path = normalizeGeoPath(input.path);
+    if (!path)
+        return 'skipped';
+    const now = input.now ?? new Date();
+    try {
+        if (!(await isGeoMeasurementEnabled(db)))
+            return 'skipped';
+        return await recordDailyBucket({
+            kind: 'crawl',
+            delegate: db.geoCrawlDaily,
+            date: geoDay(now),
+            actorField: 'bot',
+            actor: input.bot,
+            path,
+            counterField: 'hits',
+            cap: GEO_CRAWL_PATH_CAP,
+            extra: { category: input.category },
+            nowMs: now.getTime(),
+        });
+    }
+    catch (err) {
+        // best-effort — this runs behind public surfaces and must never throw
+        warnThrottled('[prenta/seo] recordGeoCrawl failed:', err);
+        return 'skipped';
+    }
+}
+export async function recordGeoReferral(db, input) {
+    if (!db || !hasModel(db, 'geoReferralDaily'))
+        return 'skipped';
+    const path = normalizeGeoPath(input.path);
+    if (!path)
+        return 'skipped';
+    const now = input.now ?? new Date();
+    try {
+        if (!(await isGeoMeasurementEnabled(db)))
+            return 'skipped';
+        return await recordDailyBucket({
+            kind: 'referral',
+            delegate: db.geoReferralDaily,
+            date: geoDay(now),
+            actorField: 'engine',
+            actor: input.engine,
+            path,
+            counterField: 'visits',
+            cap: GEO_REFERRAL_PATH_CAP,
+            nowMs: now.getTime(),
+        });
+    }
+    catch (err) {
+        // best-effort — this runs behind public surfaces and must never throw
+        warnThrottled('[prenta/seo] recordGeoReferral failed:', err);
+        return 'skipped';
+    }
+}
+//# sourceMappingURL=geo-record.js.map

package/dist/seo/geo-record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"geo-record.js","sourceRoot":"","sources":["../../src/seo/geo-record.ts"],"names":[],"mappings":"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"}

package/dist/seo/geo-report.d.ts

@@ -0,0 +1,96 @@
+import type { PrentaCMSConfig } from '../config/types.js';
+import { type AiBotCategory } from './ai-bots.js';
+import type { SeoModuleSettings } from './config-store.js';
+export declare const GEO_REPORT_WINDOWS: readonly [7, 28, 90];
+export type GeoReportDays = (typeof GEO_REPORT_WINDOWS)[number];
+export declare const GEO_TOP_PATHS = 20;
+/** `days` query param → one of the three windows (default 28). */
+export declare function clampGeoDays(raw: string | number | null | undefined): GeoReportDays;
+/**
+ * `blocked_still_crawling` = robots.txt disallows this bot's category, yet it
+ * was observed in the window — the signal the UI surfaces most prominently.
+ */
+export type GeoBotPolicy = 'allowed' | 'blocked' | 'blocked_still_crawling';
+/**
+ * Why `enabled` is `false`: the kill switch in SEO settings is off
+ * (`settings`), or the GEO tables are not in the connected schema yet
+ * (`unavailable` — migration `0018_geo_daily` has not been deployed).
+ */
+export type GeoDisabledReason = 'settings' | 'unavailable';
+export interface SeoGeoReport {
+    enabled: boolean;
+    /** Present only when `enabled` is `false`. */
+    disabledReason?: GeoDisabledReason;
+    window: {
+        from: string;
+        to: string;
+        days: number;
+    };
+    /** ISO date of the earliest row across both tables, or null. */
+    firstSeenAt: string | null;
+    crawl: {
+        /**
+         * Whole-window crawl volume: every row in the window, including the
+         * `GEO_OTHER_PATH` bucket and (for `prevHits`) bots that crawled only in
+         * the prior window and therefore have no entry in `bots`.
+         */
+        total: {
+            hits: number;
+            prevHits: number | null;
+        };
+        series: Array<{
+            date: string;
+            hits: Record<string, number>;
+        }>;
+        bots: Array<{
+            bot: string;
+            category: AiBotCategory;
+            hits: number;
+            prevHits: number | null;
+            lastSeenAt: string | null;
+            policy: GeoBotPolicy;
+        }>;
+        topPaths: Array<{
+            path: string;
+            hits: number;
+            bots: string[];
+            entityId?: string;
+            entityTitle?: string;
+            /** Collection slug of the matched document — the admin routes the editor link by it. */
+            collection?: string;
+        }>;
+        /** Hits that rolled into `GEO_OTHER_PATH` under the per-(day, bot) path cap. */
+        otherHits: number;
+    };
+    referrals: {
+        /** Whole-window referral volume, including the `GEO_OTHER_PATH` bucket. */
+        total: {
+            visits: number;
+            prevVisits: number | null;
+        };
+        engines: Array<{
+            engine: string;
+            visits: number;
+            prevVisits: number | null;
+        }>;
+        /** ≤ `GEO_TOP_PATHS`, excludes `GEO_OTHER_PATH`. */
+        topPaths: Array<{
+            path: string;
+            visits: number;
+            engines: string[];
+            entityId?: string;
+            entityTitle?: string;
+            collection?: string;
+        }>;
+        /** Visits that rolled into `GEO_OTHER_PATH` under the per-(day, engine) path cap. */
+        otherVisits: number;
+    };
+}
+export interface BuildSeoGeoReportOptions {
+    days: GeoReportDays;
+    settings: SeoModuleSettings;
+    config: PrentaCMSConfig | null | undefined;
+    now?: Date;
+}
+export declare function buildSeoGeoReport(db: unknown, opts: BuildSeoGeoReportOptions): Promise<SeoGeoReport>;
+//# sourceMappingURL=geo-report.d.ts.map

package/dist/seo/geo-report.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geo-report.d.ts","sourceRoot":"","sources":["../../src/seo/geo-report.ts"],"names":[],"mappings":"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"}

package/dist/seo/geo-report.js

@@ -0,0 +1,315 @@
+/**
+ * `GET /seo/geo` aggregation (spec 2026-09-08-geo-measurement-design.md §5).
+ *
+ * A bounded number of `groupBy` / `aggregate` passes per table over the
+ * current + prior windows (never one query per bot or per path), then
+ * in-memory shaping. Prior-window (`prev*`) values are `null` whenever the
+ * prior window is not fully covered by data — it starts before `firstSeenAt`
+ * or before the retention horizon — so the UI never shows a delta against a
+ * partial baseline. Windows are UTC calendar days.
+ */
+import { hasModel } from '../api/route-helpers.js';
+import { aiBotStanceFor } from './ai-bots.js';
+import { GEO_OTHER_PATH, geoDay } from './geo-record.js';
+import { buildPathEntityMap } from './search-console/sync.js';
+export const GEO_REPORT_WINDOWS = [7, 28, 90];
+export const GEO_TOP_PATHS = 20;
+const DAY_MS = 24 * 60 * 60 * 1000;
+/** `days` query param → one of the three windows (default 28). */
+export function clampGeoDays(raw) {
+    const n = typeof raw === 'string' ? Number.parseInt(raw, 10) : raw;
+    return GEO_REPORT_WINDOWS.includes(n) ? n : 28;
+}
+const iso = (d) => new Date(d).toISOString().slice(0, 10);
+const addDays = (d, n) => new Date(d.getTime() + n * DAY_MS);
+/** Locale-pinned so the output order does not depend on the host's ICU data. */
+const byName = (a, b) => a.localeCompare(b, 'en');
+function emptyReport(days, from, to, disabledReason) {
+    return {
+        enabled: false,
+        disabledReason,
+        window: { from: iso(from), to: iso(to), days },
+        firstSeenAt: null,
+        crawl: { total: { hits: 0, prevHits: null }, series: [], bots: [], topPaths: [], otherHits: 0 },
+        referrals: {
+            total: { visits: 0, prevVisits: null },
+            engines: [],
+            topPaths: [],
+            otherVisits: 0,
+        },
+    };
+}
+function asCategory(v) {
+    return v === 'training' || v === 'retrieval' || v === 'search' ? v : 'retrieval';
+}
+function policyFor(category, hits, aiPolicy, legacy) {
+    if (aiBotStanceFor(category, aiPolicy, legacy) === 'allow')
+        return 'allowed';
+    return hits > 0 ? 'blocked_still_crawling' : 'blocked';
+}
+/** Collect the distinct second-column values per path from a `(path, x)` groupBy. */
+function namesByPath(rows, key) {
+    const sets = new Map();
+    for (const r of rows) {
+        let set = sets.get(r.path);
+        if (!set) {
+            set = new Set();
+            sets.set(r.path, set);
+        }
+        set.add(r[key]);
+    }
+    const out = new Map();
+    for (const [path, set] of sets)
+        out.set(path, Array.from(set).sort(byName));
+    return out;
+}
+/* eslint-disable @typescript-eslint/no-explicit-any -- the Prisma client is
+ * passed as `unknown` and probed with `hasModel`; delegate shapes vary by
+ * consumer schema version. Query results are narrowed to the row interfaces
+ * above at each call site. */
+/**
+ * Best-effort path → entity join: `SearchPageInsight` first (already
+ * path-keyed), then the published-document index for anything missing, then
+ * one title lookup. Every step is optional — a failure yields fewer
+ * annotations, never an error.
+ */
+async function entityLookup(db, config, paths) {
+    const out = new Map();
+    if (paths.length === 0)
+        return out;
+    const entityIds = new Map(); // path → entityId
+    try {
+        if (hasModel(db, 'searchPageInsight')) {
+            const rows = await db.searchPageInsight.findMany({
+                where: { path: { in: paths }, entityId: { not: null } },
+                select: { path: true, entityId: true },
+            });
+            for (const r of rows)
+                if (r.entityId)
+                    entityIds.set(r.path, r.entityId);
+        }
+    }
+    catch {
+        /* insight join is optional */
+    }
+    const missing = paths.filter((p) => !entityIds.has(p));
+    if (missing.length > 0) {
+        try {
+            const index = await buildPathEntityMap(db, config ?? null);
+            for (const p of missing) {
+                const hit = index.get(p);
+                if (hit)
+                    entityIds.set(p, hit.entityId);
+            }
+        }
+        catch {
+            /* fallback index is optional */
+        }
+    }
+    if (entityIds.size === 0)
+        return out;
+    const docMeta = new Map();
+    try {
+        if (hasModel(db, 'document')) {
+            const docs = await db.document.findMany({
+                where: { id: { in: Array.from(new Set(entityIds.values())) }, deletedAt: null },
+                select: { id: true, title: true, collection: true },
+            });
+            for (const d of docs)
+                docMeta.set(d.id, { title: d.title, collection: d.collection });
+        }
+    }
+    catch {
+        /* titles / collections are optional */
+    }
+    for (const [path, entityId] of entityIds) {
+        const meta = docMeta.get(entityId);
+        const ref = { entityId };
+        if (meta?.title)
+            ref.entityTitle = meta.title;
+        if (meta?.collection)
+            ref.collection = meta.collection;
+        out.set(path, ref);
+    }
+    return out;
+}
+export async function buildSeoGeoReport(db, opts) {
+    const d = db;
+    const now = opts.now ?? new Date();
+    const to = geoDay(now);
+    const from = addDays(to, -(opts.days - 1));
+    const prevTo = addDays(from, -1);
+    const prevFrom = addDays(prevTo, -(opts.days - 1));
+    if (!d || !hasModel(d, 'geoCrawlDaily') || !hasModel(d, 'geoReferralDaily')) {
+        return emptyReport(opts.days, from, to, 'unavailable');
+    }
+    if (!opts.settings.geoMeasurementEnabled)
+        return emptyReport(opts.days, from, to, 'settings');
+    // firstSeenAt across both tables (one MIN per table).
+    const [firstCrawl, firstRef] = await Promise.all([
+        d.geoCrawlDaily.aggregate({ _min: { date: true } }),
+        d.geoReferralDaily.aggregate({ _min: { date: true } }),
+    ]);
+    const firstDates = [];
+    for (const agg of [firstCrawl, firstRef]) {
+        const date = agg?._min?.date;
+        if (date)
+            firstDates.push(new Date(date).getTime());
+    }
+    const firstSeen = firstDates.length > 0 ? new Date(Math.min(...firstDates)) : null;
+    // The prior window is comparable only when data plausibly covers all of it:
+    // it must start no earlier than max(firstSeenAt, retention horizon). The
+    // horizon mirrors what `processCleanup` keeps — it deletes
+    // `date < startOfDayUTC(now − N days)`, so the row dated exactly N days ago
+    // is the oldest one still present.
+    const retentionStart = addDays(to, -opts.settings.geoRetentionDays);
+    const earliestAvailable = firstSeen && firstSeen.getTime() > retentionStart.getTime() ? firstSeen : retentionStart;
+    const prevComparable = firstSeen !== null && prevFrom.getTime() >= earliestAvailable.getTime();
+    const prev = (n) => (prevComparable ? n : null);
+    const cur = { date: { gte: from, lte: to } };
+    const prior = { date: { gte: prevFrom, lte: prevTo } };
+    // ── Crawl ──────────────────────────────────────────────────────────────
+    const [seriesRows, botRows, prevBotRows, pathRows, otherAgg] = await Promise.all([
+        d.geoCrawlDaily.groupBy({ by: ['date', 'bot'], where: cur, _sum: { hits: true } }),
+        d.geoCrawlDaily.groupBy({
+            by: ['bot', 'category'],
+            where: cur,
+            _sum: { hits: true },
+            _max: { date: true },
+        }),
+        d.geoCrawlDaily.groupBy({ by: ['bot'], where: prior, _sum: { hits: true } }),
+        d.geoCrawlDaily.groupBy({
+            by: ['path'],
+            where: { ...cur, path: { not: GEO_OTHER_PATH } },
+            _sum: { hits: true },
+            orderBy: [{ _sum: { hits: 'desc' } }, { path: 'asc' }],
+            take: GEO_TOP_PATHS,
+        }),
+        d.geoCrawlDaily.aggregate({ where: { ...cur, path: GEO_OTHER_PATH }, _sum: { hits: true } }),
+    ]);
+    const series = [];
+    const byDay = new Map();
+    for (let t = from.getTime(); t <= to.getTime(); t += DAY_MS) {
+        const key = iso(new Date(t));
+        const bucket = {};
+        byDay.set(key, bucket);
+        series.push({ date: key, hits: bucket });
+    }
+    for (const r of seriesRows) {
+        const bucket = byDay.get(iso(r.date));
+        if (bucket)
+            bucket[r.bot] = (bucket[r.bot] ?? 0) + (r._sum?.hits ?? 0);
+    }
+    const prevByBot = new Map();
+    let totalPrevHits = 0;
+    for (const r of prevBotRows) {
+        const hits = r._sum?.hits ?? 0;
+        prevByBot.set(r.bot, (prevByBot.get(r.bot) ?? 0) + hits);
+        totalPrevHits += hits;
+    }
+    const aiPolicy = opts.config?.seo?.robots?.aiPolicy;
+    const legacyBlock = opts.config?.seo?.robots?.blockAIBots;
+    // A bot's category is re-derived from the registry on every write, so a
+    // (bot, category) split only happens across a registry change; fold it.
+    const botAgg = new Map();
+    for (const r of botRows) {
+        const hits = r._sum?.hits ?? 0;
+        const lastSeen = r._max?.date ? new Date(r._max.date) : null;
+        const existing = botAgg.get(r.bot);
+        if (!existing) {
+            botAgg.set(r.bot, { category: asCategory(r.category), hits, lastSeen });
+            continue;
+        }
+        existing.hits += hits;
+        if (lastSeen && (!existing.lastSeen || lastSeen > existing.lastSeen)) {
+            existing.lastSeen = lastSeen;
+            existing.category = asCategory(r.category);
+        }
+    }
+    const bots = Array.from(botAgg, ([bot, agg]) => ({
+        bot,
+        category: agg.category,
+        hits: agg.hits,
+        prevHits: prev(prevByBot.get(bot) ?? 0),
+        lastSeenAt: agg.lastSeen ? iso(agg.lastSeen) : null,
+        policy: policyFor(agg.category, agg.hits, aiPolicy, legacyBlock),
+    })).sort((a, b) => b.hits - a.hits || byName(a.bot, b.bot));
+    // `botRows` has no path filter, so this is the whole current window
+    // (`GEO_OTHER_PATH` rows included) — unlike `topPaths`, which excludes them.
+    const totalHits = bots.reduce((s, b) => s + b.hits, 0);
+    const topCrawlPaths = pathRows.map((r) => ({ path: r.path, hits: r._sum?.hits ?? 0 }));
+    let crawlBotsByPath = new Map();
+    if (topCrawlPaths.length > 0) {
+        const rows = await d.geoCrawlDaily.groupBy({
+            by: ['path', 'bot'],
+            where: { ...cur, path: { in: topCrawlPaths.map((p) => p.path) } },
+        });
+        crawlBotsByPath = namesByPath(rows, 'bot');
+    }
+    // ── Referrals ──────────────────────────────────────────────────────────
+    const [engineRows, prevEngineRows, refPathRows, refOtherAgg] = await Promise.all([
+        d.geoReferralDaily.groupBy({ by: ['engine'], where: cur, _sum: { visits: true } }),
+        d.geoReferralDaily.groupBy({ by: ['engine'], where: prior, _sum: { visits: true } }),
+        d.geoReferralDaily.groupBy({
+            by: ['path'],
+            where: { ...cur, path: { not: GEO_OTHER_PATH } },
+            _sum: { visits: true },
+            orderBy: [{ _sum: { visits: 'desc' } }, { path: 'asc' }],
+            take: GEO_TOP_PATHS,
+        }),
+        d.geoReferralDaily.aggregate({
+            where: { ...cur, path: GEO_OTHER_PATH },
+            _sum: { visits: true },
+        }),
+    ]);
+    const prevByEngine = new Map();
+    for (const r of prevEngineRows) {
+        prevByEngine.set(r.engine, (prevByEngine.get(r.engine) ?? 0) + (r._sum?.visits ?? 0));
+    }
+    const engines = engineRows
+        .map((r) => ({
+        engine: r.engine,
+        visits: r._sum?.visits ?? 0,
+        prevVisits: prev(prevByEngine.get(r.engine) ?? 0),
+    }))
+        .sort((a, b) => b.visits - a.visits || byName(a.engine, b.engine));
+    const totalVisits = engines.reduce((s, e) => s + e.visits, 0);
+    let totalPrev = 0;
+    for (const n of prevByEngine.values())
+        totalPrev += n;
+    const topRefPaths = refPathRows.map((r) => ({ path: r.path, visits: r._sum?.visits ?? 0 }));
+    let enginesByPath = new Map();
+    if (topRefPaths.length > 0) {
+        const rows = await d.geoReferralDaily.groupBy({
+            by: ['path', 'engine'],
+            where: { ...cur, path: { in: topRefPaths.map((p) => p.path) } },
+        });
+        enginesByPath = namesByPath(rows, 'engine');
+    }
+    // ── Entity join (best-effort) ──────────────────────────────────────────
+    const allPaths = Array.from(new Set([...topCrawlPaths.map((p) => p.path), ...topRefPaths.map((p) => p.path)]));
+    const entities = await entityLookup(d, opts.config, allPaths);
+    const withEntity = (row) => {
+        const e = entities.get(row.path);
+        return e ? { ...row, ...e } : row;
+    };
+    return {
+        enabled: true,
+        window: { from: iso(from), to: iso(to), days: opts.days },
+        firstSeenAt: firstSeen ? iso(firstSeen) : null,
+        crawl: {
+            total: { hits: totalHits, prevHits: prev(totalPrevHits) },
+            series,
+            bots,
+            topPaths: topCrawlPaths.map((p) => withEntity({ ...p, bots: crawlBotsByPath.get(p.path) ?? [] })),
+            otherHits: otherAgg?._sum?.hits ?? 0,
+        },
+        referrals: {
+            total: { visits: totalVisits, prevVisits: prev(totalPrev) },
+            engines,
+            topPaths: topRefPaths.map((p) => withEntity({ ...p, engines: enginesByPath.get(p.path) ?? [] })),
+            otherVisits: refOtherAgg?._sum?.visits ?? 0,
+        },
+    };
+}
+//# sourceMappingURL=geo-report.js.map