@aglyn/plugins-crm 1.0.0-beta.143

package/src/lib/components/reports/use-aggregate-read.d.ts

@@ -0,0 +1,99 @@
+import { type DocumentData, type Query } from 'firebase/firestore';
+import { type DependencyList } from 'react';
+export type AggregateReadStatus = 'loading' | 'success' | 'error';
+/**
+ * A server aggregate as a card renders it: the value once it has arrived,
+ * and `null` until then or when the server refused.
+ *
+ * `null` and not 0 for the same reason `Figure` draws a dash for it — "the
+ * count has not arrived" and "the count is zero" are different facts and a
+ * tile that showed 0 for the first would be read as the second.
+ */
+export interface AggregateRead<T> {
+    value: T | null;
+    status: AggregateReadStatus;
+}
+export interface AggregateReadOptions {
+    /**
+     * Remember the answer under this key for {@link AGGREGATE_READ_TTL_MS},
+     * so the same question asked again — the section reopened, a card
+     * remounted — is answered from memory rather than from the server. Omit
+     * it and every change of `deps` reads.
+     */
+    cacheKey?: string;
+    ttlMs?: number;
+}
+/**
+ * How long a report answer is trusted (AGL-2614).
+ *
+ * A report is a snapshot, not a listener: nothing on the page moves while
+ * it is open, and the reader who closes it and opens it again a moment
+ * later is asking the same question. Sixty seconds is long enough to cover
+ * that round trip and short enough that a deal closed over lunch is on the
+ * page after it. The Refresh control is the way to ask sooner.
+ */
+export declare const AGGREGATE_READ_TTL_MS = 60000;
+/**
+ * Forgets every answer whose key starts with `prefix` — the section's
+ * Refresh, which names its own scope so a refresh of one org's reports
+ * does not throw away another's.
+ */
+export declare function invalidateAggregateReads(prefix: string): void;
+/** Test seam: forget everything. */
+export declare function resetAggregateReadCache(): void;
+/**
+ * One server-side read, run once per change of `deps` and never per render,
+ * and — when keyed — once per {@link AGGREGATE_READ_TTL_MS} rather than once
+ * per mount.
+ *
+ * The CRM reports are built from `getCountFromServer`,
+ * `getAggregateFromServer` and bounded `getDocs` windows — a count is a
+ * count, not the length of a capped listener — and each of those is a
+ * promise rather than a subscription, so it needs the effect-with-an-active-
+ * flag the contacts list already writes for its head-count. This is that
+ * effect, once, so that five cards do not carry five copies of it and one of
+ * them forgets the flag and sets state on an unmounted card.
+ *
+ * ## Why the answers are remembered
+ *
+ * The section reads up to 3,500 documents to draw its windows — the newest
+ * thousand contacts, a thousand open deals, a thousand open tasks, five
+ * hundred closed deals of each outcome — and it read them again every time
+ * the reader arrived, including the arrival ten seconds after they left to
+ * check a deal the report named. A report is a snapshot; the second arrival
+ * is the same question. A keyed read is answered from memory while its
+ * answer is fresh, and the key names the scope and the period so a different
+ * org, a different site group or a different period is a different question.
+ * Refusals are never remembered: a dash the server drew once should not be
+ * drawn from memory for a minute after the rules change.
+ *
+ * `read` returning `null` means "not yet" — the org scope has not resolved,
+ * the tokens are not known — and leaves the read pending rather than
+ * counting against nothing. The latest `read` is always the one invoked, via
+ * a ref, so the caller can close over fresh props without listing every one
+ * of them in `deps`; what `deps` names is WHEN to read again.
+ */
+export declare function useAggregateRead<T>(read: () => Promise<T> | null, deps: DependencyList, options?: AggregateReadOptions): AggregateRead<T>;
+/** A bounded window of documents as a card draws it, and whether the bound bit. */
+export interface WindowRead<T> {
+    /** At most `ceiling` rows — the probe row is never among them. */
+    rows: T[];
+    /** The collection holds MORE than the ceiling. A fact from the probe, not a guess. */
+    truncated: boolean;
+    status: AggregateReadStatus;
+}
+/**
+ * A bounded window, read once and remembered — the report's replacement
+ * for a live listener over the same query.
+ *
+ * The cards used to hold their windows open as `onSnapshot` listeners,
+ * which is the right shape for a list somebody edits and the wrong one for
+ * a report: the listener re-delivered the whole window on every mount, and
+ * a snapshot that updates under the reader while they compare it to the
+ * tile above it is a page that contradicts itself. `getDocs` answers once,
+ * `ceilingedWindow` drops the probe row the caller over-fetched by, and the
+ * answer is remembered under `cacheKey` like every other report read.
+ *
+ * `build` returning `null` means "not yet", the way `read` does above.
+ */
+export declare function useWindowRead<T extends DocumentData>(build: () => Query | null, ceiling: number, deps: DependencyList, options?: AggregateReadOptions): WindowRead<T>;

package/src/lib/components/reports/use-aggregate-read.js

@@ -0,0 +1,195 @@
+/**
+ * @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.
+ */ 'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { ceilingedWindow } from "@aglyn/tenant-feature-instance/hooks/host-collection-queries";
+import { getDocs } from "firebase/firestore";
+import { useEffect, useMemo, useRef, useState } from "react";
+/**
+ * How long a report answer is trusted (AGL-2614).
+ *
+ * A report is a snapshot, not a listener: nothing on the page moves while
+ * it is open, and the reader who closes it and opens it again a moment
+ * later is asking the same question. Sixty seconds is long enough to cover
+ * that round trip and short enough that a deal closed over lunch is on the
+ * page after it. The Refresh control is the way to ask sooner.
+ */ export const AGGREGATE_READ_TTL_MS = 60000;
+/**
+ * The answers, for the life of the page load. Module state rather than
+ * React state because the point is to outlive the card that asked: the
+ * section unmounts when the reader leaves it, and everything a component
+ * held goes with it.
+ */ const cache = new Map();
+/**
+ * The reads still in the air, by key (AGL-2620). Two cards that mount
+ * together and ask the same question — the pipeline card and the forecast
+ * card both want the open-deal window — would each miss the empty cache
+ * and each read a thousand documents; the second joins the first's
+ * promise instead. An entry lives only until its promise settles, so a
+ * refusal is neither remembered nor re-joined.
+ */ const inflight = new Map();
+/** A fresh cached answer under `key`, or undefined. Expired entries are dropped on the way. */ function readCache(key, nowMs) {
+    const entry = cache.get(key);
+    if (!entry) return undefined;
+    if (entry.expiresAt <= nowMs) {
+        cache.delete(key);
+        return undefined;
+    }
+    return entry;
+}
+/**
+ * Forgets every answer whose key starts with `prefix` — the section's
+ * Refresh, which names its own scope so a refresh of one org's reports
+ * does not throw away another's.
+ */ export function invalidateAggregateReads(prefix) {
+    for (const key of [
+        ...cache.keys()
+    ]){
+        if (key.startsWith(prefix)) cache.delete(key);
+    }
+}
+/** Test seam: forget everything. */ export function resetAggregateReadCache() {
+    cache.clear();
+    inflight.clear();
+}
+/**
+ * One server-side read, run once per change of `deps` and never per render,
+ * and — when keyed — once per {@link AGGREGATE_READ_TTL_MS} rather than once
+ * per mount.
+ *
+ * The CRM reports are built from `getCountFromServer`,
+ * `getAggregateFromServer` and bounded `getDocs` windows — a count is a
+ * count, not the length of a capped listener — and each of those is a
+ * promise rather than a subscription, so it needs the effect-with-an-active-
+ * flag the contacts list already writes for its head-count. This is that
+ * effect, once, so that five cards do not carry five copies of it and one of
+ * them forgets the flag and sets state on an unmounted card.
+ *
+ * ## Why the answers are remembered
+ *
+ * The section reads up to 3,500 documents to draw its windows — the newest
+ * thousand contacts, a thousand open deals, a thousand open tasks, five
+ * hundred closed deals of each outcome — and it read them again every time
+ * the reader arrived, including the arrival ten seconds after they left to
+ * check a deal the report named. A report is a snapshot; the second arrival
+ * is the same question. A keyed read is answered from memory while its
+ * answer is fresh, and the key names the scope and the period so a different
+ * org, a different site group or a different period is a different question.
+ * Refusals are never remembered: a dash the server drew once should not be
+ * drawn from memory for a minute after the rules change.
+ *
+ * `read` returning `null` means "not yet" — the org scope has not resolved,
+ * the tokens are not known — and leaves the read pending rather than
+ * counting against nothing. The latest `read` is always the one invoked, via
+ * a ref, so the caller can close over fresh props without listing every one
+ * of them in `deps`; what `deps` names is WHEN to read again.
+ */ export function useAggregateRead(read, deps, options = {}) {
+    const { cacheKey, ttlMs = AGGREGATE_READ_TTL_MS } = options;
+    const [state, setState] = useState({
+        value: null,
+        status: 'loading'
+    });
+    const readRef = useRef(read);
+    readRef.current = read;
+    useEffect(()=>{
+        const remembered = cacheKey ? readCache(cacheKey, Date.now()) : undefined;
+        if (remembered) {
+            setState({
+                value: remembered.value,
+                status: 'success'
+            });
+            return undefined;
+        }
+        const joined = cacheKey ? inflight.get(cacheKey) : undefined;
+        const pending = joined != null ? joined : readRef.current();
+        setState({
+            value: null,
+            status: 'loading'
+        });
+        if (!pending) return undefined;
+        if (cacheKey && !joined) {
+            inflight.set(cacheKey, pending);
+            pending.finally(()=>{
+                if (inflight.get(cacheKey) === pending) inflight.delete(cacheKey);
+            }).catch(()=>undefined);
+        }
+        let active = true;
+        pending.then((value)=>{
+            if (cacheKey) cache.set(cacheKey, {
+                value,
+                expiresAt: Date.now() + ttlMs
+            });
+            if (active) setState({
+                value,
+                status: 'success'
+            });
+        }).catch(()=>{
+            // Denied or failed: the tile draws its dash. Nothing here substitutes
+            // a zero, because a zero is a measurement and this is the absence of
+            // one.
+            if (active) setState({
+                value: null,
+                status: 'error'
+            });
+        });
+        return ()=>{
+            active = false;
+        };
+    // `deps` is the caller's dependency list, forwarded the way
+    // `useFirestoreCollection` forwards its own; the key changes with them.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [
+        ...deps,
+        cacheKey
+    ]);
+    return state;
+}
+/**
+ * A bounded window, read once and remembered — the report's replacement
+ * for a live listener over the same query.
+ *
+ * The cards used to hold their windows open as `onSnapshot` listeners,
+ * which is the right shape for a list somebody edits and the wrong one for
+ * a report: the listener re-delivered the whole window on every mount, and
+ * a snapshot that updates under the reader while they compare it to the
+ * tile above it is a page that contradicts itself. `getDocs` answers once,
+ * `ceilingedWindow` drops the probe row the caller over-fetched by, and the
+ * answer is remembered under `cacheKey` like every other report read.
+ *
+ * `build` returning `null` means "not yet", the way `read` does above.
+ */ export function useWindowRead(build, ceiling, deps, options = {}) {
+    const buildRef = useRef(build);
+    buildRef.current = build;
+    const read = useAggregateRead(()=>{
+        const query = buildRef.current();
+        return query ? getDocs(query).then((snapshot)=>ceilingedWindow(snapshot.docs.map((document)=>_extends({}, document.data(), {
+                    $id: document.id
+                })), ceiling)) : null;
+    }, deps, options);
+    return useMemo(()=>{
+        var _ref, _ref1;
+        var _read_value, _read_value1;
+        return {
+            rows: (_ref = (_read_value = read.value) == null ? void 0 : _read_value.rows) != null ? _ref : [],
+            truncated: (_ref1 = (_read_value1 = read.value) == null ? void 0 : _read_value1.truncated) != null ? _ref1 : false,
+            status: read.status
+        };
+    }, [
+        read
+    ]);
+}
+
+//# sourceMappingURL=use-aggregate-read.js.map

package/src/lib/components/reports/use-aggregate-read.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/plugins/crm/src/lib/components/reports/use-aggregate-read.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n'use client'\n\nimport { ceilingedWindow } from '@aglyn/tenant-feature-instance/hooks/host-collection-queries'\nimport { type DocumentData, getDocs, type Query } from 'firebase/firestore'\nimport { type DependencyList, useEffect, useMemo, useRef, useState } from 'react'\n\nexport type AggregateReadStatus = 'loading' | 'success' | 'error'\n\n/**\n * A server aggregate as a card renders it: the value once it has arrived,\n * and `null` until then or when the server refused.\n *\n * `null` and not 0 for the same reason `Figure` draws a dash for it — \"the\n * count has not arrived\" and \"the count is zero\" are different facts and a\n * tile that showed 0 for the first would be read as the second.\n */\nexport interface AggregateRead<T> {\n  value: T | null\n  status: AggregateReadStatus\n}\n\nexport interface AggregateReadOptions {\n  /**\n   * Remember the answer under this key for {@link AGGREGATE_READ_TTL_MS},\n   * so the same question asked again — the section reopened, a card\n   * remounted — is answered from memory rather than from the server. Omit\n   * it and every change of `deps` reads.\n   */\n  cacheKey?: string\n  ttlMs?: number\n}\n\n/**\n * How long a report answer is trusted (AGL-2614).\n *\n * A report is a snapshot, not a listener: nothing on the page moves while\n * it is open, and the reader who closes it and opens it again a moment\n * later is asking the same question. Sixty seconds is long enough to cover\n * that round trip and short enough that a deal closed over lunch is on the\n * page after it. The Refresh control is the way to ask sooner.\n */\nexport const AGGREGATE_READ_TTL_MS = 60_000\n\ninterface CacheEntry {\n  value: unknown\n  expiresAt: number\n}\n\n/**\n * The answers, for the life of the page load. Module state rather than\n * React state because the point is to outlive the card that asked: the\n * section unmounts when the reader leaves it, and everything a component\n * held goes with it.\n */\nconst cache = new Map<string, CacheEntry>()\n\n/**\n * The reads still in the air, by key (AGL-2620). Two cards that mount\n * together and ask the same question — the pipeline card and the forecast\n * card both want the open-deal window — would each miss the empty cache\n * and each read a thousand documents; the second joins the first's\n * promise instead. An entry lives only until its promise settles, so a\n * refusal is neither remembered nor re-joined.\n */\nconst inflight = new Map<string, Promise<unknown>>()\n\n/** A fresh cached answer under `key`, or undefined. Expired entries are dropped on the way. */\nfunction readCache(key: string, nowMs: number): CacheEntry | undefined {\n  const entry = cache.get(key)\n  if (!entry) return undefined\n  if (entry.expiresAt <= nowMs) {\n    cache.delete(key)\n    return undefined\n  }\n  return entry\n}\n\n/**\n * Forgets every answer whose key starts with `prefix` — the section's\n * Refresh, which names its own scope so a refresh of one org's reports\n * does not throw away another's.\n */\nexport function invalidateAggregateReads(prefix: string): void {\n  for (const key of [...cache.keys()]) {\n    if (key.startsWith(prefix)) cache.delete(key)\n  }\n}\n\n/** Test seam: forget everything. */\nexport function resetAggregateReadCache(): void {\n  cache.clear()\n  inflight.clear()\n}\n\n/**\n * One server-side read, run once per change of `deps` and never per render,\n * and — when keyed — once per {@link AGGREGATE_READ_TTL_MS} rather than once\n * per mount.\n *\n * The CRM reports are built from `getCountFromServer`,\n * `getAggregateFromServer` and bounded `getDocs` windows — a count is a\n * count, not the length of a capped listener — and each of those is a\n * promise rather than a subscription, so it needs the effect-with-an-active-\n * flag the contacts list already writes for its head-count. This is that\n * effect, once, so that five cards do not carry five copies of it and one of\n * them forgets the flag and sets state on an unmounted card.\n *\n * ## Why the answers are remembered\n *\n * The section reads up to 3,500 documents to draw its windows — the newest\n * thousand contacts, a thousand open deals, a thousand open tasks, five\n * hundred closed deals of each outcome — and it read them again every time\n * the reader arrived, including the arrival ten seconds after they left to\n * check a deal the report named. A report is a snapshot; the second arrival\n * is the same question. A keyed read is answered from memory while its\n * answer is fresh, and the key names the scope and the period so a different\n * org, a different site group or a different period is a different question.\n * Refusals are never remembered: a dash the server drew once should not be\n * drawn from memory for a minute after the rules change.\n *\n * `read` returning `null` means \"not yet\" — the org scope has not resolved,\n * the tokens are not known — and leaves the read pending rather than\n * counting against nothing. The latest `read` is always the one invoked, via\n * a ref, so the caller can close over fresh props without listing every one\n * of them in `deps`; what `deps` names is WHEN to read again.\n */\nexport function useAggregateRead<T>(\n  read: () => Promise<T> | null,\n  deps: DependencyList,\n  options: AggregateReadOptions = {},\n): AggregateRead<T> {\n  const { cacheKey, ttlMs = AGGREGATE_READ_TTL_MS } = options\n  const [state, setState] = useState<AggregateRead<T>>({\n    value: null,\n    status: 'loading',\n  })\n  const readRef = useRef(read)\n  readRef.current = read\n\n  useEffect(() => {\n    const remembered = cacheKey ? readCache(cacheKey, Date.now()) : undefined\n    if (remembered) {\n      setState({ value: remembered.value as T, status: 'success' })\n      return undefined\n    }\n    const joined = cacheKey ? (inflight.get(cacheKey) as Promise<T> | undefined) : undefined\n    const pending = joined ?? readRef.current()\n    setState({ value: null, status: 'loading' })\n    if (!pending) return undefined\n    if (cacheKey && !joined) {\n      inflight.set(cacheKey, pending)\n      pending.finally(() => {\n        if (inflight.get(cacheKey) === pending) inflight.delete(cacheKey)\n      }).catch(() => undefined)\n    }\n    let active = true\n    pending\n      .then((value) => {\n        if (cacheKey) cache.set(cacheKey, { value, expiresAt: Date.now() + ttlMs })\n        if (active) setState({ value, status: 'success' })\n      })\n      .catch(() => {\n        // Denied or failed: the tile draws its dash. Nothing here substitutes\n        // a zero, because a zero is a measurement and this is the absence of\n        // one.\n        if (active) setState({ value: null, status: 'error' })\n      })\n    return () => {\n      active = false\n    }\n    // `deps` is the caller's dependency list, forwarded the way\n    // `useFirestoreCollection` forwards its own; the key changes with them.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [...deps, cacheKey])\n\n  return state\n}\n\n/** A bounded window of documents as a card draws it, and whether the bound bit. */\nexport interface WindowRead<T> {\n  /** At most `ceiling` rows — the probe row is never among them. */\n  rows: T[]\n  /** The collection holds MORE than the ceiling. A fact from the probe, not a guess. */\n  truncated: boolean\n  status: AggregateReadStatus\n}\n\n/**\n * A bounded window, read once and remembered — the report's replacement\n * for a live listener over the same query.\n *\n * The cards used to hold their windows open as `onSnapshot` listeners,\n * which is the right shape for a list somebody edits and the wrong one for\n * a report: the listener re-delivered the whole window on every mount, and\n * a snapshot that updates under the reader while they compare it to the\n * tile above it is a page that contradicts itself. `getDocs` answers once,\n * `ceilingedWindow` drops the probe row the caller over-fetched by, and the\n * answer is remembered under `cacheKey` like every other report read.\n *\n * `build` returning `null` means \"not yet\", the way `read` does above.\n */\nexport function useWindowRead<T extends DocumentData>(\n  build: () => Query | null,\n  ceiling: number,\n  deps: DependencyList,\n  options: AggregateReadOptions = {},\n): WindowRead<T> {\n  const buildRef = useRef(build)\n  buildRef.current = build\n  const read = useAggregateRead<{ rows: T[]; truncated: boolean }>(\n    () => {\n      const query = buildRef.current()\n      return query\n        ? getDocs(query).then((snapshot) =>\n            ceilingedWindow(\n              snapshot.docs.map(\n                (document) => ({ ...document.data(), $id: document.id }) as unknown as T,\n              ),\n              ceiling,\n            ),\n          )\n        : null\n    },\n    deps,\n    options,\n  )\n  return useMemo(\n    () => ({\n      rows: read.value?.rows ?? [],\n      truncated: read.value?.truncated ?? false,\n      status: read.status,\n    }),\n    [read],\n  )\n}\n"],"names":["ceilingedWindow","getDocs","useEffect","useMemo","useRef","useState","AGGREGATE_READ_TTL_MS","cache","Map","inflight","readCache","key","nowMs","entry","get","undefined","expiresAt","delete","invalidateAggregateReads","prefix","keys","startsWith","resetAggregateReadCache","clear","useAggregateRead","read","deps","options","cacheKey","ttlMs","state","setState","value","status","readRef","current","remembered","Date","now","joined","pending","set","finally","catch","active","then","useWindowRead","build","ceiling","buildRef","query","snapshot","docs","map","document","data","$id","id","rows","truncated"],"mappings":"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"}

package/src/lib/components/reports/won-lost-by-owner-card.d.ts

@@ -0,0 +1,30 @@
+import { type CrmReportScope } from './report-scope';
+export interface WonLostByOwnerCardProps {
+    report: CrmReportScope;
+}
+/**
+ * Who closed what (AGL-2662): the period's wins and losses, by the person
+ * who owned the deal at the close.
+ *
+ * ## It costs no read
+ *
+ * The two windows are the SAME queries the Won and lost card builds, under
+ * the same cache keys — `closed:won` and `closed:lost` — so
+ * `useAggregateRead` either answers this card from the remembered window or
+ * joins the other card's in-flight promise. Two cards, one pair of reads.
+ * A key of its own here would have doubled the most expensive read on the
+ * page to ask a different question of the same rows.
+ *
+ * ## Why the rows can under-report a very busy period
+ *
+ * The window is bounded, and the bound is on the deals rather than on the
+ * owners — so a period with more than {@link CLOSED_DEAL_CEILING} closes of
+ * an outcome is tallied over the most recent of them, and the caption says
+ * so. A server-side group-by would need one aggregate per owner, and the
+ * owner list is not known before the read.
+ */
+export declare function WonLostByOwnerCard(props: WonLostByOwnerCardProps): import("react").JSX.Element;
+export declare namespace WonLostByOwnerCard {
+    var displayName: string;
+}
+export default WonLostByOwnerCard;

package/src/lib/components/reports/won-lost-by-owner-card.js

@@ -0,0 +1,168 @@
+/**
+ * @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.
+ */ 'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import * as Aglyn from "@aglyn/aglyn";
+import { money } from "@aglyn/shared-ui-email-campaigns/components/report-figures";
+import { CardDisplay } from "@aglyn/shared-ui-jsx";
+import { percent } from "@aglyn/shared-ui-jsx/components/measured-figures.component";
+import { Alert, Stack, Typography } from "@mui/material";
+import { limit, orderBy, query, where } from "firebase/firestore";
+import { useMemo } from "react";
+import { useFirestore } from "@aglyn/tenant-feature-instance";
+import { useOrgMemberOptions } from "../../hooks/use-org-member-options.js";
+import { ReportBreakdown } from "./report-breakdown.js";
+import { reportCacheKey, scopedCollection, visibleToClause } from "./report-scope.js";
+import { useWindowRead } from "./use-aggregate-read.js";
+/**
+ * The same ceiling the Won and lost card reads its chart under, spelled
+ * from one constant so the two cards share the read rather than each
+ * paying for its own.
+ */ const CLOSED_DEAL_CEILING = 500;
+/** How many owners the breakdown draws before folding the rest into one row. */ const OWNER_ROW_CEILING = 8;
+/**
+ * Who closed what (AGL-2662): the period's wins and losses, by the person
+ * who owned the deal at the close.
+ *
+ * ## It costs no read
+ *
+ * The two windows are the SAME queries the Won and lost card builds, under
+ * the same cache keys — `closed:won` and `closed:lost` — so
+ * `useAggregateRead` either answers this card from the remembered window or
+ * joins the other card's in-flight promise. Two cards, one pair of reads.
+ * A key of its own here would have doubled the most expensive read on the
+ * page to ask a different question of the same rows.
+ *
+ * ## Why the rows can under-report a very busy period
+ *
+ * The window is bounded, and the bound is on the deals rather than on the
+ * owners — so a period with more than {@link CLOSED_DEAL_CEILING} closes of
+ * an outcome is tallied over the most recent of them, and the caption says
+ * so. A server-side group-by would need one aggregate per owner, and the
+ * owner list is not known before the read.
+ */ export function WonLostByOwnerCard(props) {
+    const { report } = props;
+    const { scope, tokens, range } = report;
+    const firestore = useFirestore();
+    // The roster resolves a uid into the name the team reads; a uid it no
+    // longer carries — somebody who has left — is named by its own id rather
+    // than dropped, because their closed deals still happened.
+    const roster = useOrgMemberOptions(scope[1]);
+    const closedInPeriod = (status)=>query(scopedCollection(firestore, scope, 'deals'), ...visibleToClause(tokens), where('status', '==', status), where('closedAtMs', '>=', range.from), where('closedAtMs', '<', range.to), orderBy('closedAtMs', 'desc'), limit(CLOSED_DEAL_CEILING + 1));
+    const wonWindow = useWindowRead(()=>closedInPeriod('won'), CLOSED_DEAL_CEILING, [
+        firestore,
+        scope,
+        tokens,
+        range
+    ], {
+        cacheKey: reportCacheKey(report, 'closed:won')
+    });
+    const lostWindow = useWindowRead(()=>closedInPeriod('lost'), CLOSED_DEAL_CEILING, [
+        firestore,
+        scope,
+        tokens,
+        range
+    ], {
+        cacheKey: reportCacheKey(report, 'closed:lost')
+    });
+    const owners = useMemo(()=>Aglyn.wonLostByOwner(wonWindow.rows, lostWindow.rows), [
+        wonWindow.rows,
+        lostWindow.rows
+    ]);
+    const currency = useMemo(()=>Aglyn.currencyOfDeals(wonWindow.rows).currency, [
+        wonWindow.rows
+    ]);
+    const read = wonWindow.status === 'success' && lostWindow.status === 'success';
+    const failed = wonWindow.status === 'error' || lostWindow.status === 'error';
+    const rows = useMemo(()=>{
+        const named = (uid)=>{
+            var _ref;
+            var _Aglyn_findOrgMember;
+            return uid ? (_ref = (_Aglyn_findOrgMember = Aglyn.findOrgMember(roster.options, uid)) == null ? void 0 : _Aglyn_findOrgMember.label) != null ? _ref : uid : 'Unassigned';
+        };
+        const shown = owners.slice(0, OWNER_ROW_CEILING);
+        const folded = owners.slice(OWNER_ROW_CEILING);
+        const rest = folded.reduce((total, owner)=>({
+                won: total.won + owner.won,
+                lost: total.lost + owner.lost,
+                wonAmountCents: total.wonAmountCents + owner.wonAmountCents
+            }), {
+            won: 0,
+            lost: 0,
+            wonAmountCents: 0
+        });
+        return [
+            ...shown.map((owner)=>({
+                    key: owner.uid || 'unassigned',
+                    label: named(owner.uid),
+                    value: owner.won,
+                    display: `${owner.won.toLocaleString()} won`,
+                    note: `${owner.lost.toLocaleString()} lost · ` + `${owner.winRate === null ? 'no rate' : `${percent(owner.winRate)} win rate`} · ` + `${money(owner.wonAmountCents, currency)}`,
+                    color: 'success.main'
+                })),
+            ...folded.length ? [
+                {
+                    key: '$rest',
+                    label: `${folded.length} more`,
+                    value: rest.won,
+                    display: `${rest.won.toLocaleString()} won`,
+                    note: `${rest.lost.toLocaleString()} lost · ${money(rest.wonAmountCents, currency)}`,
+                    color: 'success.main'
+                }
+            ] : []
+        ];
+    }, [
+        owners,
+        roster.options,
+        currency
+    ]);
+    return /*#__PURE__*/ _jsx(CardDisplay, {
+        header: 'Won and lost by owner',
+        help: Aglyn.pluginDocsHelp('crmReports', {
+            anchor: '#won-and-lost-by-owner',
+            excerpt: 'Closed deals grouped by the person who owned them at the close, ' + 'ranked by how much closed rather than by win rate, with the deals ' + 'nobody owned kept as a row of their own.'
+        }),
+        contentGutterX: true,
+        contentGutterY: true,
+        children: /*#__PURE__*/ _jsxs(Stack, {
+            spacing: 1.5,
+            children: [
+                failed ? /*#__PURE__*/ _jsx(Alert, {
+                    severity: "warning",
+                    children: 'The closed deals could not be read, so this is not an empty period.'
+                }) : null,
+                /*#__PURE__*/ _jsx(ReportBreakdown, {
+                    rows: rows,
+                    emptyText: read ? 'Nothing closed in this period.' : 'Reading…'
+                }),
+                wonWindow.truncated || lostWindow.truncated ? /*#__PURE__*/ _jsx(Typography, {
+                    variant: "caption",
+                    color: "text.secondary",
+                    children: `Counted over the ${CLOSED_DEAL_CEILING} most recently closed of each outcome; this period held more.`
+                }) : null,
+                /*#__PURE__*/ _jsx(Typography, {
+                    variant: "caption",
+                    color: "text.secondary",
+                    children: 'Credited to whoever owned the deal when it closed, not to whoever created it.'
+                })
+            ]
+        })
+    });
+}
+WonLostByOwnerCard.displayName = 'WonLostByOwnerCard';
+export default WonLostByOwnerCard;
+
+//# sourceMappingURL=won-lost-by-owner-card.js.map

package/src/lib/components/reports/won-lost-by-owner-card.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/plugins/crm/src/lib/components/reports/won-lost-by-owner-card.tsx"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n'use client'\n\nimport * as Aglyn from '@aglyn/aglyn'\nimport { money } from '@aglyn/shared-ui-email-campaigns/components/report-figures'\nimport { CardDisplay } from '@aglyn/shared-ui-jsx'\nimport { percent } from '@aglyn/shared-ui-jsx/components/measured-figures.component'\nimport { Alert, Stack, Typography } from '@mui/material'\nimport { limit, orderBy, query, where } from 'firebase/firestore'\nimport { useMemo } from 'react'\nimport { useFirestore } from '@aglyn/tenant-feature-instance'\nimport { useOrgMemberOptions } from '../../hooks/use-org-member-options'\nimport { ReportBreakdown } from './report-breakdown'\nimport {\n  type CrmReportScope,\n  reportCacheKey,\n  scopedCollection,\n  visibleToClause,\n} from './report-scope'\nimport { useWindowRead } from './use-aggregate-read'\n\n/**\n * The same ceiling the Won and lost card reads its chart under, spelled\n * from one constant so the two cards share the read rather than each\n * paying for its own.\n */\nconst CLOSED_DEAL_CEILING = 500\n\n/** How many owners the breakdown draws before folding the rest into one row. */\nconst OWNER_ROW_CEILING = 8\n\ntype DealRow = Aglyn.CrmDeal & { $id: string }\n\nexport interface WonLostByOwnerCardProps {\n  report: CrmReportScope\n}\n\n/**\n * Who closed what (AGL-2662): the period's wins and losses, by the person\n * who owned the deal at the close.\n *\n * ## It costs no read\n *\n * The two windows are the SAME queries the Won and lost card builds, under\n * the same cache keys — `closed:won` and `closed:lost` — so\n * `useAggregateRead` either answers this card from the remembered window or\n * joins the other card's in-flight promise. Two cards, one pair of reads.\n * A key of its own here would have doubled the most expensive read on the\n * page to ask a different question of the same rows.\n *\n * ## Why the rows can under-report a very busy period\n *\n * The window is bounded, and the bound is on the deals rather than on the\n * owners — so a period with more than {@link CLOSED_DEAL_CEILING} closes of\n * an outcome is tallied over the most recent of them, and the caption says\n * so. A server-side group-by would need one aggregate per owner, and the\n * owner list is not known before the read.\n */\nexport function WonLostByOwnerCard(props: WonLostByOwnerCardProps) {\n  const { report } = props\n  const { scope, tokens, range } = report\n  const firestore = useFirestore()\n  // The roster resolves a uid into the name the team reads; a uid it no\n  // longer carries — somebody who has left — is named by its own id rather\n  // than dropped, because their closed deals still happened.\n  const roster = useOrgMemberOptions(scope[1])\n\n  const closedInPeriod = (status: Aglyn.CrmDealStatus) =>\n    query(\n      scopedCollection(firestore, scope, 'deals'),\n      ...visibleToClause(tokens),\n      where('status', '==', status),\n      where('closedAtMs', '>=', range.from),\n      where('closedAtMs', '<', range.to),\n      orderBy('closedAtMs', 'desc'),\n      limit(CLOSED_DEAL_CEILING + 1),\n    )\n\n  const wonWindow = useWindowRead<DealRow>(\n    () => closedInPeriod('won'),\n    CLOSED_DEAL_CEILING,\n    [firestore, scope, tokens, range],\n    { cacheKey: reportCacheKey(report, 'closed:won') },\n  )\n  const lostWindow = useWindowRead<DealRow>(\n    () => closedInPeriod('lost'),\n    CLOSED_DEAL_CEILING,\n    [firestore, scope, tokens, range],\n    { cacheKey: reportCacheKey(report, 'closed:lost') },\n  )\n\n  const owners = useMemo(\n    () => Aglyn.wonLostByOwner(wonWindow.rows, lostWindow.rows),\n    [wonWindow.rows, lostWindow.rows],\n  )\n  const currency = useMemo(\n    () => Aglyn.currencyOfDeals(wonWindow.rows).currency,\n    [wonWindow.rows],\n  )\n\n  const read = wonWindow.status === 'success' && lostWindow.status === 'success'\n  const failed = wonWindow.status === 'error' || lostWindow.status === 'error'\n\n  const rows = useMemo(() => {\n    const named = (uid: string) =>\n      uid\n        ? (Aglyn.findOrgMember(roster.options, uid)?.label ?? uid)\n        : 'Unassigned'\n    const shown = owners.slice(0, OWNER_ROW_CEILING)\n    const folded = owners.slice(OWNER_ROW_CEILING)\n    const rest = folded.reduce(\n      (total, owner) => ({\n        won: total.won + owner.won,\n        lost: total.lost + owner.lost,\n        wonAmountCents: total.wonAmountCents + owner.wonAmountCents,\n      }),\n      { won: 0, lost: 0, wonAmountCents: 0 },\n    )\n    return [\n      ...shown.map((owner) => ({\n        key: owner.uid || 'unassigned',\n        label: named(owner.uid),\n        value: owner.won,\n        display: `${owner.won.toLocaleString()} won`,\n        note:\n          `${owner.lost.toLocaleString()} lost · ` +\n          `${owner.winRate === null ? 'no rate' : `${percent(owner.winRate)} win rate`} · ` +\n          `${money(owner.wonAmountCents, currency)}`,\n        color: 'success.main',\n      })),\n      ...(folded.length\n        ? [\n            {\n              key: '$rest',\n              label: `${folded.length} more`,\n              value: rest.won,\n              display: `${rest.won.toLocaleString()} won`,\n              note: `${rest.lost.toLocaleString()} lost · ${money(rest.wonAmountCents, currency)}`,\n              color: 'success.main',\n            },\n          ]\n        : []),\n    ]\n  }, [owners, roster.options, currency])\n\n  return (\n    <CardDisplay\n      header={'Won and lost by owner'}\n      help={Aglyn.pluginDocsHelp('crmReports', {\n        anchor: '#won-and-lost-by-owner',\n        excerpt:\n          'Closed deals grouped by the person who owned them at the close, ' +\n          'ranked by how much closed rather than by win rate, with the deals ' +\n          'nobody owned kept as a row of their own.',\n      })}\n      contentGutterX\n      contentGutterY\n    >\n      <Stack spacing={1.5}>\n        {failed ? (\n          <Alert severity=\"warning\">\n            {'The closed deals could not be read, so this is not an empty period.'}\n          </Alert>\n        ) : null}\n        <ReportBreakdown\n          rows={rows}\n          emptyText={read ? 'Nothing closed in this period.' : 'Reading…'}\n        />\n        {wonWindow.truncated || lostWindow.truncated ? (\n          <Typography variant=\"caption\" color=\"text.secondary\">\n            {`Counted over the ${CLOSED_DEAL_CEILING} most recently closed of each outcome; this period held more.`}\n          </Typography>\n        ) : null}\n        <Typography variant=\"caption\" color=\"text.secondary\">\n          {'Credited to whoever owned the deal when it closed, not to whoever created it.'}\n        </Typography>\n      </Stack>\n    </CardDisplay>\n  )\n}\nWonLostByOwnerCard.displayName = 'WonLostByOwnerCard'\n\nexport default WonLostByOwnerCard\n"],"names":["Aglyn","money","CardDisplay","percent","Alert","Stack","Typography","limit","orderBy","query","where","useMemo","useFirestore","useOrgMemberOptions","ReportBreakdown","reportCacheKey","scopedCollection","visibleToClause","useWindowRead","CLOSED_DEAL_CEILING","OWNER_ROW_CEILING","WonLostByOwnerCard","props","report","scope","tokens","range","firestore","roster","closedInPeriod","status","from","to","wonWindow","cacheKey","lostWindow","owners","wonLostByOwner","rows","currency","currencyOfDeals","read","failed","named","uid","findOrgMember","options","label","shown","slice","folded","rest","reduce","total","owner","won","lost","wonAmountCents","map","key","value","display","toLocaleString","note","winRate","color","length","header","help","pluginDocsHelp","anchor","excerpt","contentGutterX","contentGutterY","spacing","severity","emptyText","truncated","variant","displayName"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GACD;;AAEA,YAAYA,WAAW,eAAc;AACrC,SAASC,KAAK,QAAQ,6DAA4D;AAClF,SAASC,WAAW,QAAQ,uBAAsB;AAClD,SAASC,OAAO,QAAQ,6DAA4D;AACpF,SAASC,KAAK,EAAEC,KAAK,EAAEC,UAAU,QAAQ,gBAAe;AACxD,SAASC,KAAK,EAAEC,OAAO,EAAEC,KAAK,EAAEC,KAAK,QAAQ,qBAAoB;AACjE,SAASC,OAAO,QAAQ,QAAO;AAC/B,SAASC,YAAY,QAAQ,iCAAgC;AAC7D,SAASC,mBAAmB,QAAQ,wCAAoC;AACxE,SAASC,eAAe,QAAQ,wBAAoB;AACpD,SAEEC,cAAc,EACdC,gBAAgB,EAChBC,eAAe,QACV,oBAAgB;AACvB,SAASC,aAAa,QAAQ,0BAAsB;AAEpD;;;;CAIC,GACD,MAAMC,sBAAsB;AAE5B,8EAA8E,GAC9E,MAAMC,oBAAoB;AAQ1B;;;;;;;;;;;;;;;;;;;;CAoBC,GACD,OAAO,SAASC,mBAAmBC,KAA8B;IAC/D,MAAM,EAAEC,MAAM,EAAE,GAAGD;IACnB,MAAM,EAAEE,KAAK,EAAEC,MAAM,EAAEC,KAAK,EAAE,GAAGH;IACjC,MAAMI,YAAYf;IAClB,sEAAsE;IACtE,yEAAyE;IACzE,2DAA2D;IAC3D,MAAMgB,SAASf,oBAAoBW,KAAK,CAAC,EAAE;IAE3C,MAAMK,iBAAiB,CAACC,SACtBrB,MACEO,iBAAiBW,WAAWH,OAAO,aAChCP,gBAAgBQ,SACnBf,MAAM,UAAU,MAAMoB,SACtBpB,MAAM,cAAc,MAAMgB,MAAMK,IAAI,GACpCrB,MAAM,cAAc,KAAKgB,MAAMM,EAAE,GACjCxB,QAAQ,cAAc,SACtBD,MAAMY,sBAAsB;IAGhC,MAAMc,YAAYf,cAChB,IAAMW,eAAe,QACrBV,qBACA;QAACQ;QAAWH;QAAOC;QAAQC;KAAM,EACjC;QAAEQ,UAAUnB,eAAeQ,QAAQ;IAAc;IAEnD,MAAMY,aAAajB,cACjB,IAAMW,eAAe,SACrBV,qBACA;QAACQ;QAAWH;QAAOC;QAAQC;KAAM,EACjC;QAAEQ,UAAUnB,eAAeQ,QAAQ;IAAe;IAGpD,MAAMa,SAASzB,QACb,IAAMX,MAAMqC,cAAc,CAACJ,UAAUK,IAAI,EAAEH,WAAWG,IAAI,GAC1D;QAACL,UAAUK,IAAI;QAAEH,WAAWG,IAAI;KAAC;IAEnC,MAAMC,WAAW5B,QACf,IAAMX,MAAMwC,eAAe,CAACP,UAAUK,IAAI,EAAEC,QAAQ,EACpD;QAACN,UAAUK,IAAI;KAAC;IAGlB,MAAMG,OAAOR,UAAUH,MAAM,KAAK,aAAaK,WAAWL,MAAM,KAAK;IACrE,MAAMY,SAAST,UAAUH,MAAM,KAAK,WAAWK,WAAWL,MAAM,KAAK;IAErE,MAAMQ,OAAO3B,QAAQ;QACnB,MAAMgC,QAAQ,CAACC;;gBAER5C;mBADL4C,eACK5C,uBAAAA,MAAM6C,aAAa,CAACjB,OAAOkB,OAAO,EAAEF,yBAApC5C,qBAA0C+C,KAAK,mBAAIH,MACpD;;QACN,MAAMI,QAAQZ,OAAOa,KAAK,CAAC,GAAG7B;QAC9B,MAAM8B,SAASd,OAAOa,KAAK,CAAC7B;QAC5B,MAAM+B,OAAOD,OAAOE,MAAM,CACxB,CAACC,OAAOC,QAAW,CAAA;gBACjBC,KAAKF,MAAME,GAAG,GAAGD,MAAMC,GAAG;gBAC1BC,MAAMH,MAAMG,IAAI,GAAGF,MAAME,IAAI;gBAC7BC,gBAAgBJ,MAAMI,cAAc,GAAGH,MAAMG,cAAc;YAC7D,CAAA,GACA;YAAEF,KAAK;YAAGC,MAAM;YAAGC,gBAAgB;QAAE;QAEvC,OAAO;eACFT,MAAMU,GAAG,CAAC,CAACJ,QAAW,CAAA;oBACvBK,KAAKL,MAAMV,GAAG,IAAI;oBAClBG,OAAOJ,MAAMW,MAAMV,GAAG;oBACtBgB,OAAON,MAAMC,GAAG;oBAChBM,SAAS,GAAGP,MAAMC,GAAG,CAACO,cAAc,GAAG,IAAI,CAAC;oBAC5CC,MACE,GAAGT,MAAME,IAAI,CAACM,cAAc,GAAG,QAAQ,CAAC,GACxC,GAAGR,MAAMU,OAAO,KAAK,OAAO,YAAY,GAAG7D,QAAQmD,MAAMU,OAAO,EAAE,SAAS,CAAC,CAAC,GAAG,CAAC,GACjF,GAAG/D,MAAMqD,MAAMG,cAAc,EAAElB,WAAW;oBAC5C0B,OAAO;gBACT,CAAA;eACIf,OAAOgB,MAAM,GACb;gBACE;oBACEP,KAAK;oBACLZ,OAAO,GAAGG,OAAOgB,MAAM,CAAC,KAAK,CAAC;oBAC9BN,OAAOT,KAAKI,GAAG;oBACfM,SAAS,GAAGV,KAAKI,GAAG,CAACO,cAAc,GAAG,IAAI,CAAC;oBAC3CC,MAAM,GAAGZ,KAAKK,IAAI,CAACM,cAAc,GAAG,QAAQ,EAAE7D,MAAMkD,KAAKM,cAAc,EAAElB,WAAW;oBACpF0B,OAAO;gBACT;aACD,GACD,EAAE;SACP;IACH,GAAG;QAAC7B;QAAQR,OAAOkB,OAAO;QAAEP;KAAS;IAErC,qBACE,KAACrC;QACCiE,QAAQ;QACRC,MAAMpE,MAAMqE,cAAc,CAAC,cAAc;YACvCC,QAAQ;YACRC,SACE,qEACA,uEACA;QACJ;QACAC,cAAc;QACdC,cAAc;kBAEd,cAAA,MAACpE;YAAMqE,SAAS;;gBACbhC,uBACC,KAACtC;oBAAMuE,UAAS;8BACb;qBAED;8BACJ,KAAC7D;oBACCwB,MAAMA;oBACNsC,WAAWnC,OAAO,mCAAmC;;gBAEtDR,UAAU4C,SAAS,IAAI1C,WAAW0C,SAAS,iBAC1C,KAACvE;oBAAWwE,SAAQ;oBAAUb,OAAM;8BACjC,CAAC,iBAAiB,EAAE9C,oBAAoB,6DAA6D,CAAC;qBAEvG;8BACJ,KAACb;oBAAWwE,SAAQ;oBAAUb,OAAM;8BACjC;;;;;AAKX;AACA5C,mBAAmB0D,WAAW,GAAG;AAEjC,eAAe1D,mBAAkB"}

package/src/lib/components/reports-section.d.ts

@@ -0,0 +1,42 @@
+import type { ConsolePluginPageProps } from '@aglyn/aglyn';
+/**
+ * `/crm/reports` — the CRM in aggregate (AGL-2604, AGL-2624).
+ *
+ * Nine cards, each reading its own collection: contacts over time, contacts
+ * by source and stage, which sources convert, this site's lead funnel, the
+ * open pipeline, what closed, who logged what, the forecast by close month
+ * (AGL-2620, over the pipeline card's own window), and the task load. This
+ * section resolves what they share and hands it down — see `CrmReportScope`
+ * — so that every card counts the same reader's records over the same
+ * clock. The lead funnel is the one card handed the site as well: leads live
+ * under the host, not the org.
+ *
+ * ## The period is a control, and the reads follow it
+ *
+ * Nothing on this page reads a year on mount. The picker names the period,
+ * the period sizes every read (one count per week of it, the deals closed
+ * within it), and the default is thirty days. The three cards that are
+ * stocks rather than flows — the open pipeline, its forecast, the open
+ * tasks — ignore the period because "what is open" has no period.
+ *
+ * ## Scoped like the list
+ *
+ * Every query carries `visibleTo array-contains-any` over the group's
+ * tokens, the predicate the rules evaluate, so a report can never count a
+ * record its reader could not open — and the total here is the reader's
+ * total, not the org's billable audience, which is the head-count the
+ * contacts list keeps for the quota.
+ *
+ * ## Read once a minute, not once an arrival
+ *
+ * Every read on this page is keyed by the scope and the period and kept
+ * for `AGGREGATE_READ_TTL_MS` — see `useAggregateRead` — so leaving to open
+ * a deal the report named and coming straight back costs nothing. Refresh
+ * forgets this reader's answers for this org and anchors the period again,
+ * which is what makes every card ask afresh.
+ */
+export declare function ContactsReportsSection(props: ConsolePluginPageProps): import("react").JSX.Element;
+export declare namespace ContactsReportsSection {
+    var displayName: string;
+}
+export default ContactsReportsSection;