@aglyn/tenant-feature-instance 1.0.0-beta.143

package/src/lib/hooks/use-sorted-paged-collection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/tenant/feature/instance/src/lib/hooks/use-sorted-paged-collection.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 type { DocumentData, Query } from 'firebase/firestore'\nimport {\n  useCallback,\n  useEffect,\n  useRef,\n  useState,\n  type DependencyList,\n} from 'react'\nimport { TABLE_PAGE_SIZE_DEFAULT } from '@aglyn/shared-ui-jsx/const/table-pagination'\nimport {\n  planKeyedSegment,\n  planSortedWindow,\n  sortedKeyedQuery,\n  sortedScanLimit,\n  sortedUnkeyedQuery,\n  sortFieldIsTotal,\n  type CollectionSort,\n} from './sorted-collection-window'\nimport {\n  useFirestoreCollection,\n  type FirestoreCollectionStatus,\n  type UseFirestoreCollectionOptions,\n} from './use-firestore-collection'\nimport type { UsePagedCollectionResult } from './use-paged-collection'\n\nexport interface UseSortedPagedCollectionOptions\n  extends UseFirestoreCollectionOptions {\n  /**\n   * Required: the keyed and unkeyed segments are two listeners, and a\n   * document moving between them is recognized by its id.\n   */\n  idField: string\n  /** Rows per page. Defaults to the console-wide smallest option. */\n  pageSize?: number\n  /**\n   * The fields `buildBase` pins by EQUALITY. A sort on one of them needs no\n   * unkeyed segment — see `sortFieldIsTotal`.\n   */\n  equalityFields?: readonly string[]\n}\n\n/** `Object.is` over two dependency lists, the comparison React itself uses. */\nconst sameDeps = (a: DependencyList, b: DependencyList) =>\n  a.length === b.length && a.every((value, index) => Object.is(value, b[index]))\n\n/**\n * The request a read's CURRENT rows were delivered for.\n *\n * `useFirestoreCollection` re-subscribes in an effect, so the render in which\n * its inputs change still returns the previous subscription's rows — rows for\n * another limit, sort or subject. Planning on them would judge a window by a\n * read that was never made for it: page two's window measured against page\n * one's eleven rows looks like a walk that ran out.\n *\n * So rows are labeled with the request that was current when they ARRIVED,\n * which is the render their array first appears in, and a render whose request\n * has since moved on treats them as unread. Held as state and adjusted during\n * render — the pattern React documents for state that follows a prop — so no\n * render ever pairs a request with rows read for another.\n */\nfunction useCurrentRows(rows: unknown, request: DependencyList): boolean {\n  const [delivered, setDelivered] = useState<{\n    rows: unknown\n    request: DependencyList\n  }>(() => ({ rows, request }))\n  if (delivered.rows !== rows) {\n    setDelivered({ rows, request })\n    return true\n  }\n  return sameDeps(delivered.request, request)\n}\n\n/**\n * A paged window over a live collection SORTED BY A FIELD, which still drops\n * no document that lacks the field (AGL-2853).\n *\n * The same contract as `usePagedCollection` — the window is the query, one\n * page plus a probe row, `hasMore` a fact — over the two-segment walk in\n * `sorted-collection-window.ts`: the documents that carry the sort field in\n * its order, then the ones that do not, in name order. See that module for why\n * both segments are needed and what the second one costs.\n *\n * `buildBase` returns the collection with any EQUALITY predicates and nothing\n * else; the ordering and the limits are this hook's. `deps` identify the\n * subject as they do for `useFirestoreCollection`. A new subject, sort or\n * filter starts again from page one.\n *\n * ```ts\n * useSortedPagedCollection<Entry>(\n *   () => query(\n *     collection(firestore, 'hosts', hostId, 'collections', collectionId, 'entries'),\n *     where('status', '==', status),\n *   ),\n *   { field: 'publishedAt', direction: 'desc' },\n *   [firestore, hostId, collectionId, status],\n *   { idField: '$id', equalityFields: ['status'] },\n * )\n * ```\n */\nexport function useSortedPagedCollection<T = DocumentData>(\n  buildBase: () => Query<DocumentData> | null | undefined,\n  sort: CollectionSort,\n  deps: DependencyList,\n  options: UseSortedPagedCollectionOptions,\n): UsePagedCollectionResult<T> {\n  const {\n    pageSize: initialPageSize = TABLE_PAGE_SIZE_DEFAULT,\n    equalityFields = [],\n    ...collectionOptions\n  } = options\n  const idField = options.idField\n  const [pageSize, setPageSizeState] = useState(initialPageSize)\n  const buildBaseRef = useRef(buildBase)\n  buildBaseRef.current = buildBase\n\n  const equalityKey = equalityFields.join('\\n')\n  const subject: DependencyList = [\n    ...deps,\n    sort.field,\n    sort.direction,\n    equalityKey,\n  ]\n\n  /*\n   * The reader's position belongs to ONE subject. It resets in the render the\n   * subject changes in, not in an effect after it: an effect would let that\n   * render subscribe the new sort at the old page's limit, and a sort change\n   * on page four would bill forty-one documents to show ten.\n   */\n  const [cursor, setCursor] = useState(() => ({\n    subject,\n    page: 0,\n    widenedTo: 0,\n  }))\n  const sameSubject = sameDeps(cursor.subject, subject)\n  const position = sameSubject ? cursor : { subject, page: 0, widenedTo: 0 }\n  if (!sameSubject) setCursor(position)\n  const { page } = position\n\n  const keyedIsTotal = sortFieldIsTotal(sort, equalityFields)\n  const { keyedLimit } = planKeyedSegment({\n    page,\n    pageSize,\n    keyed: undefined,\n    keyedSettled: false,\n    keyedIsTotal,\n  })\n\n  const keyedRequest: DependencyList = [...subject, keyedLimit]\n  const keyedRead = useFirestoreCollection<T>(\n    () => {\n      const base = buildBaseRef.current()\n      return base\n        ? sortedKeyedQuery(base, sort, keyedLimit, equalityFields)\n        : null\n    },\n    keyedRequest,\n    collectionOptions,\n  )\n  const keyedCurrent = useCurrentRows(keyedRead.data, keyedRequest)\n  const keyed =\n    keyedCurrent && keyedRead.status !== 'loading' ? keyedRead.data : undefined\n  const keyedSettled =\n    keyedCurrent && keyedRead.status === 'success' && !keyedRead.fromCache\n\n  const keyedPlan = planKeyedSegment({\n    page,\n    pageSize,\n    keyed,\n    keyedSettled,\n    keyedIsTotal,\n  })\n  const scanLimit = sortedScanLimit(keyedPlan, position.widenedTo)\n\n  const scanRequest: DependencyList = [...subject, scanLimit]\n  const scanRead = useFirestoreCollection<T>(\n    () => {\n      if (scanLimit <= 0) return null\n      const base = buildBaseRef.current()\n      return base ? sortedUnkeyedQuery(base, scanLimit) : null\n    },\n    scanRequest,\n    collectionOptions,\n  )\n  const scanCurrent = useCurrentRows(scanRead.data, scanRequest)\n  const scanOpen = scanLimit > 0\n\n  const sorted = planSortedWindow<T>({\n    page,\n    pageSize,\n    sort,\n    keyedIsTotal,\n    keyed,\n    keyedSettled,\n    scan:\n      scanOpen && scanCurrent && scanRead.status !== 'loading'\n        ? scanRead.data\n        : undefined,\n    scanSettled:\n      scanOpen &&\n      scanCurrent &&\n      scanRead.status === 'success' &&\n      !scanRead.fromCache,\n    scanLimit,\n    idOf: (row) => String((row as Record<string, unknown>)[idField]),\n  })\n\n  /*\n   * Widening is remembered for the subject, so paging back to where the scan\n   * is not needed and forward again re-opens it at the width it reached\n   * instead of doubling its way back up.\n   */\n  const widenTo = sorted.scanLimit\n  useEffect(() => {\n    if (widenTo <= position.widenedTo) return\n    setCursor((previous) =>\n      sameDeps(previous.subject, position.subject) &&\n      widenTo > previous.widenedTo\n        ? { ...previous, widenedTo: widenTo }\n        : previous,\n    )\n  }, [widenTo, position.widenedTo, position.subject])\n\n  const setPage = useCallback((next: number) => {\n    setCursor((previous) => ({ ...previous, page: next }))\n  }, [])\n  const setPageSize = useCallback((next: number) => {\n    setPageSizeState(next)\n    // Page four of a ten-row list does not exist once the reader asks for\n    // fifty at a time, and an out-of-range page renders as an empty list.\n    setCursor((previous) => ({ ...previous, page: 0 }))\n  }, [])\n\n  /*\n   * A short window is a claim that the list ENDS here, so it is `loading`\n   * until the server has confirmed both segments. A window holding its probe\n   * row claims only that more exists, which a cached read can say.\n   */\n  const errored =\n    keyedRead.status === 'error' || (scanOpen && scanRead.status === 'error')\n  const status: FirestoreCollectionStatus = errored\n    ? 'error'\n    : keyed === undefined\n      ? 'loading'\n      : sorted.hasMore || sorted.settled\n        ? 'success'\n        : 'loading'\n\n  return {\n    data: sorted.ordered,\n    rows: sorted.rows,\n    hasMore: sorted.hasMore,\n    page,\n    setPage,\n    pageSize,\n    setPageSize,\n    status,\n    error: keyedRead.error ?? (scanOpen ? scanRead.error : undefined),\n    fromCache: keyedRead.fromCache || (scanOpen && scanRead.fromCache),\n    serverDenied:\n      keyedRead.serverDenied || (scanOpen && scanRead.serverDenied),\n  }\n}\n\nexport default useSortedPagedCollection\n"],"names":["useCallback","useEffect","useRef","useState","TABLE_PAGE_SIZE_DEFAULT","planKeyedSegment","planSortedWindow","sortedKeyedQuery","sortedScanLimit","sortedUnkeyedQuery","sortFieldIsTotal","useFirestoreCollection","sameDeps","a","b","length","every","value","index","Object","is","useCurrentRows","rows","request","delivered","setDelivered","useSortedPagedCollection","buildBase","sort","deps","options","keyedRead","pageSize","initialPageSize","equalityFields","collectionOptions","idField","setPageSizeState","buildBaseRef","current","equalityKey","join","subject","field","direction","cursor","setCursor","page","widenedTo","sameSubject","position","keyedIsTotal","keyedLimit","keyed","undefined","keyedSettled","keyedRequest","base","keyedCurrent","data","status","fromCache","keyedPlan","scanLimit","scanRequest","scanRead","scanCurrent","scanOpen","sorted","scan","scanSettled","idOf","row","String","widenTo","previous","setPage","next","setPageSize","errored","hasMore","settled","ordered","error","serverDenied"],"mappings":"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"}

package/src/lib/hooks/use-switcher-collection.d.ts

@@ -0,0 +1,105 @@
+import { type DocumentData, type Firestore, type WhereFilterOp } from 'firebase/firestore';
+import { type DependencyList } from 'react';
+/**
+ * Collection KEY for the session-health verdict (AGL-2486).
+ *
+ * The even path segments only — `['users', uid, 'hostMemberships']` becomes
+ * `users/hostMemberships`. That is the convention `use-org-hosts` already
+ * uses for the same collection, so the two report the SAME key and still
+ * count as one collection rather than inflating each other toward the
+ * two-collection threshold. It also keeps document ids — a uid among them —
+ * out of a module-scope map.
+ */
+export declare function switcherCollectionKey(path: string[]): string;
+export interface UseSwitcherCollectionOptions<T> {
+    firestore: Firestore;
+    /** Collection path segments, e.g. `['hosts', hostId, 'screens']`. */
+    path: string[];
+    /** Optional single filter, e.g. `['orgId', '==', orgId]`. */
+    where?: readonly [string, WhereFilterOp, unknown];
+    /** Raw search text from the field; debounced and normalized internally. */
+    query: string;
+    /** Recent-first window size when the query is empty (default 10). */
+    idleLimit?: number;
+    /** Result cap for the name-prefix search (default 20). */
+    searchLimit?: number;
+    /**
+     * The field holding the human-readable name, matched client-side.
+     *
+     * Both switchers store it as `displayName`, which is the default; a caller
+     * whose rows name themselves differently passes its own.
+     */
+    nameField?: string;
+    /**
+     * How many documents the client-side pass reads (default 50).
+     *
+     * Fetched ONCE per scope and cached for the life of the mount, so typing
+     * costs nothing after the first character — see the search-mode note on the
+     * hook itself.
+     */
+    searchWindow?: number;
+    /** Field written with the doc id (default `$id`). */
+    idField?: string;
+    /** Client post-filter, e.g. drop soft-deleted or email screens. */
+    filter?: (item: T) => boolean;
+    /** Stable scope dependencies (firestore, ids) — like a useEffect dep array. */
+    deps: DependencyList;
+    /** Debounce for the search query in ms (default 200). */
+    debounceMs?: number;
+    /**
+     * Hold off entirely, because a value this listen must be SCOPED BY is not
+     * resolved yet (AGL-2350).
+     *
+     * The empty-path-segment hold-off below covers a scope that appears IN the
+     * path. A `where` filter is the other kind, and it fails the opposite way:
+     * an unresolved id makes `where` `undefined`, which does not error — it
+     * silently drops the filter and returns the UNSCOPED collection. For
+     * `users/{uid}/hostMemberships` that is every site the person holds in
+     * every org, which on an agency running one workspace per client puts two
+     * clients' site names in one dropdown.
+     *
+     * Defaults to `false`, so this is inert for any caller that does not scope
+     * by a filter.
+     */
+    skip?: boolean;
+}
+export interface UseSwitcherCollectionResult<T> {
+    items: T[];
+    /** A fetch is in flight and there are no prior rows to show yet. */
+    loading: boolean;
+    /** The (debounced) query is non-empty — results are name-search matches. */
+    hasQuery: boolean;
+    /**
+     * The most recent fetch FAILED (AGL-1066).
+     *
+     * Keeping the prior rows on a failure is right and stays (see the catch
+     * below), but the failure was previously erased along with `loading` — so
+     * the first fetch of a scope, which has no prior rows, settled on
+     * `{ items: [], loading: false }` and every switcher read that as "this
+     * person holds no sites". Consumers must render "couldn't load", never a
+     * zero-state, when this is true.
+     */
+    error: boolean;
+}
+/**
+ * Data source for the org/site/screen switchers that scales past a switcher's
+ * naive "load the whole collection and filter in memory" (AGL-838). Two modes:
+ *
+ * - **idle** (empty query): a recent-first window, `orderBy(updatedAt desc)`
+ *   capped at `idleLimit` — the handful of docs you actually cycle between, not
+ *   a full read.
+ * - **search** (non-empty query): a true Firestore prefix range over the
+ *   normalized `nameLower` (`orderBy(nameLower) startAt(key)..endAt(key+'\uf8ff')`),
+ *   capped at `searchLimit` — finds a match anywhere in the collection without
+ *   loading it, where the old client-side filter could only match already-
+ *   loaded rows.
+ *
+ * Reads are one-shot `getDocs` (a switcher list doesn't need live updates), so
+ * there is no per-keystroke listener churn and no flash: prior rows stay
+ * visible while the next fetch is in flight, and only a scope change (a
+ * dependency in `deps`) clears them — the same hold-the-right-scope rule as
+ * `useFirestoreCollection` (AGL-591), without its clear-to-empty-then-refill.
+ * Out-of-order responses are dropped by request id.
+ */
+export declare function useSwitcherCollection<T = DocumentData>(options: UseSwitcherCollectionOptions<T>): UseSwitcherCollectionResult<T>;
+export default useSwitcherCollection;

package/src/lib/hooks/use-switcher-collection.js

@@ -0,0 +1,275 @@
+/**
+ * @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 { compareScored, nameSearchKey, scoreMatch } from "@aglyn/aglyn";
+import { collection, documentId, endAt, getDocs, limit, orderBy, query, startAt, where } from "firebase/firestore";
+import { useEffect, useRef, useState } from "react";
+import { reportFirestoreDenial, reportFirestoreServerRead } from "./firestore-denial-reporter.js";
+/**
+ * Collection KEY for the session-health verdict (AGL-2486).
+ *
+ * The even path segments only — `['users', uid, 'hostMemberships']` becomes
+ * `users/hostMemberships`. That is the convention `use-org-hosts` already
+ * uses for the same collection, so the two report the SAME key and still
+ * count as one collection rather than inflating each other toward the
+ * two-collection threshold. It also keeps document ids — a uid among them —
+ * out of a module-scope map.
+ */ export function switcherCollectionKey(path) {
+    return path.filter((_, index)=>index % 2 === 0).join('/');
+}
+function useDebouncedValue(value, ms) {
+    const [debounced, setDebounced] = useState(value);
+    useEffect(()=>{
+        const timer = setTimeout(()=>setDebounced(value), ms);
+        return ()=>clearTimeout(timer);
+    }, [
+        value,
+        ms
+    ]);
+    return debounced;
+}
+/**
+ * Data source for the org/site/screen switchers that scales past a switcher's
+ * naive "load the whole collection and filter in memory" (AGL-838). Two modes:
+ *
+ * - **idle** (empty query): a recent-first window, `orderBy(updatedAt desc)`
+ *   capped at `idleLimit` — the handful of docs you actually cycle between, not
+ *   a full read.
+ * - **search** (non-empty query): a true Firestore prefix range over the
+ *   normalized `nameLower` (`orderBy(nameLower) startAt(key)..endAt(key+'\uf8ff')`),
+ *   capped at `searchLimit` — finds a match anywhere in the collection without
+ *   loading it, where the old client-side filter could only match already-
+ *   loaded rows.
+ *
+ * Reads are one-shot `getDocs` (a switcher list doesn't need live updates), so
+ * there is no per-keystroke listener churn and no flash: prior rows stay
+ * visible while the next fetch is in flight, and only a scope change (a
+ * dependency in `deps`) clears them — the same hold-the-right-scope rule as
+ * `useFirestoreCollection` (AGL-591), without its clear-to-empty-then-refill.
+ * Out-of-order responses are dropped by request id.
+ */ export function useSwitcherCollection(options) {
+    const { firestore, path, where: whereClause, query: rawQuery, idleLimit = 10, searchLimit = 20, nameField = 'displayName', searchWindow = 50, idField = '$id', filter, deps, debounceMs = 200, skip = false } = options;
+    const debounced = useDebouncedValue(rawQuery.trim(), debounceMs);
+    const key = nameSearchKey(debounced);
+    const hasQuery = key.length > 0;
+    const [items, setItems] = useState([]);
+    const [loading, setLoading] = useState(true);
+    const [error, setError] = useState(false);
+    const requestRef = useRef(0);
+    /**
+   * The client-side search window, cached for the life of this SCOPE.
+   *
+   * A ref rather than state: filling it must not itself cause a render, and
+   * the render that matters is the one `setItems` already causes. Cleared by
+   * the scope effect below, which is the same place the rows are cleared —
+   * keeping the two together is what stops site A's window being matched
+   * against while standing on site B.
+   */ const windowRef = useRef(null);
+    // Clear on a genuine scope change (host A → host B) so the previous scope's
+    // rows never bleed into the new one; a query change keeps the prior rows so
+    // the list doesn't flash (AGL-591 rule, applied per-scope not per-fetch).
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    useEffect(()=>{
+        setItems([]);
+        setLoading(true);
+        setError(false);
+        windowRef.current = null;
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, deps);
+    useEffect(()=>{
+        const requestId = ++requestRef.current;
+        // A path segment can be momentarily empty (e.g. the uid before auth
+        // resolves); hold rather than build an invalid collection ref. `skip` is
+        // the same hold for a scope that lives in `where` rather than the path,
+        // where an unresolved id would widen the query instead of breaking it.
+        if (skip || path.some((segment)=>!segment)) {
+            setItems([]);
+            setLoading(true);
+            setError(false);
+            // A hold means the scope is not trustworthy yet, so anything already
+            // read under it must not survive into the scope that unblocks.
+            windowRef.current = null;
+            return;
+        }
+        setLoading(true);
+        const ref = collection(firestore, path[0], ...path.slice(1));
+        const scopeFilter = whereClause ? [
+            where(whereClause[0], whereClause[1], whereClause[2])
+        ] : [];
+        const toRows = (snapshot)=>snapshot.docs.map((docSnap)=>{
+                const value = _extends({}, docSnap.data());
+                if (idField) value[idField] = docSnap.id;
+                return value;
+            });
+        /**
+     * SEARCH MODE (AGL-2486) — a client-side window first, the prefix range
+     * only when the window cannot have held everything.
+     *
+     * This used to be the prefix range alone, and that had two defects which
+     * look like one from the outside.
+     *
+     * **It hid documents.** `orderBy('nameLower')` makes Firestore OMIT every
+     * document that does not carry the field — and `nameLower` is optional,
+     * stamped by three write paths for one resource kind. A document written
+     * any other way stayed visible in the idle list and vanished the instant
+     * you typed. Measured against the seeded emulator: a screen named "Home"
+     * listed, and `home` returned nothing. Production happens to be clean
+     * today (68/68 live screens and 10/10 membership rows carry it, checked
+     * with the Admin SDK), so this is a LATENT defect rather than a firing
+     * one — but it is armed for the next write path that forgets, and nothing
+     * would fail when it does. Ordering the window by `documentId()`, which no
+     * document can be missing, disarms it permanently: correctness stops
+     * depending on a field staying in step across write paths.
+     *
+     * **And it could not match the way people type.** A prefix over the whole
+     * stored name means somebody looking for "Main Layout" who types `layout`
+     * gets nothing. That one IS firing, on every surface, today.
+     *
+     * The window is read ONCE per scope and cached for the life of the mount,
+     * so the common case — a site whose collection fits inside it — costs one
+     * read burst and then nothing at all per keystroke, which is CHEAPER than
+     * the query it replaces. The prefix range is kept and issued only when the
+     * window came back full, because that is the case AGL-838 built it for: a
+     * host with hundreds of screens must still find one that is not in the
+     * window. Dropping it to simplify would have regressed exactly the
+     * property the switcher exists to provide.
+     */ const searchRead = async ()=>{
+            let windowRows = windowRef.current;
+            if (!windowRows) {
+                var _windowSnapshot_metadata;
+                const windowSnapshot = await getDocs(query(ref, ...scopeFilter, orderBy(documentId()), limit(searchWindow)));
+                windowRows = {
+                    rows: toRows(windowSnapshot),
+                    fromCache: (_windowSnapshot_metadata = windowSnapshot.metadata) == null ? void 0 : _windowSnapshot_metadata.fromCache
+                };
+                windowRef.current = windowRows;
+            }
+            const scored = windowRows.rows.map((row)=>{
+                var _ref;
+                const label = String((_ref = row == null ? void 0 : row[nameField]) != null ? _ref : '');
+                const score = scoreMatch({
+                    name: label
+                }, debounced);
+                return score === null ? null : {
+                    row,
+                    score,
+                    label
+                };
+            }).filter(Boolean);
+            // Only reach past the window when the window could not have held the
+            // whole collection. A partial window is proof there is nothing beyond it.
+            let beyond = [];
+            let beyondFromCache;
+            if (windowRows.rows.length >= searchWindow) {
+                var _prefixSnapshot_metadata;
+                const prefixSnapshot = await getDocs(query(ref, ...scopeFilter, orderBy('nameLower'), startAt(key), endAt(key + '\uf8ff'), limit(searchLimit)));
+                beyondFromCache = (_prefixSnapshot_metadata = prefixSnapshot.metadata) == null ? void 0 : _prefixSnapshot_metadata.fromCache;
+                beyond = toRows(prefixSnapshot);
+            }
+            const seen = new Set(scored.map((hit)=>{
+                var _hit_row;
+                return (_hit_row = hit.row) == null ? void 0 : _hit_row[idField];
+            }));
+            const merged = [
+                ...scored.sort((a, b)=>compareScored(a, b)).map((hit)=>hit.row),
+                ...beyond.filter((row)=>!seen.has(row == null ? void 0 : row[idField]))
+            ];
+            return {
+                rows: merged.slice(0, searchLimit),
+                fromCache: windowRows.fromCache === false ? false : beyondFromCache
+            };
+        };
+        const read = hasQuery ? searchRead() : getDocs(query(ref, ...scopeFilter, orderBy('updatedAt', 'desc'), limit(idleLimit))).then((snapshot)=>{
+            var _snapshot_metadata;
+            return {
+                rows: toRows(snapshot),
+                fromCache: (_snapshot_metadata = snapshot.metadata) == null ? void 0 : _snapshot_metadata.fromCache
+            };
+        });
+        read.then((result)=>{
+            var _snapshot_metadata;
+            if (requestRef.current !== requestId) return; // superseded
+            const snapshot = {
+                metadata: {
+                    fromCache: result.fromCache
+                }
+            };
+            const rows = result.rows;
+            setItems(filter ? rows.filter(filter) : rows);
+            setError(false);
+            setLoading(false);
+            // A SERVER answer is proof the session can read, and it clears the
+            // denial evidence outright (AGL-2486). Guarded on `fromCache`
+            // because `getDocs` falls back to the cache while offline, and the
+            // reporter contract is explicit that a cached snapshot proves
+            // nothing.
+            //
+            // Written as `=== false` rather than `!fromCache` on purpose: the
+            // claim being made is "the server answered", so absent metadata
+            // must report NOTHING rather than be read as a server read. It also
+            // keeps this branch from throwing on a snapshot shape it did not
+            // expect — a throw here lands in the `catch` below and would show
+            // the user a refusal for a fetch that actually succeeded.
+            if (((_snapshot_metadata = snapshot.metadata) == null ? void 0 : _snapshot_metadata.fromCache) === false) reportFirestoreServerRead();
+        }).catch((error)=>{
+            // A missing composite index or transient error leaves the prior rows
+            // in place rather than blanking the menu; the caller's "view all"
+            // escape hatch still reaches everything.
+            //
+            // But SAY SO (AGL-1066). Swallowing the failure into `loading: false`
+            // meant the no-prior-rows case — a cold load, or the first fetch
+            // after a scope change — was indistinguishable from a genuinely
+            // empty collection, and the site switcher printed "No sites yet."
+            // at people who hold sites.
+            if (requestRef.current !== requestId) return;
+            setError(true);
+            setLoading(false);
+            // …and tell the session detector, which this read used to keep to
+            // itself (AGL-2486). the production report was a Sites list that
+            // "could not be loaded" while the console had no idea the session
+            // was the reason: the switcher is one of the first reads on the
+            // page and it contributed ZERO evidence toward the stale verdict,
+            // so the very list that failed could never be what raised the
+            // prompt. Only `permission-denied` — a missing index
+            // (`failed-precondition`) or a dropped network (`unavailable`) is
+            // not a session problem and must never be counted as one.
+            if ((error == null ? void 0 : error.code) === 'permission-denied') {
+                reportFirestoreDenial(switcherCollectionKey(path));
+            }
+        });
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    // `skip` is listed even though it is derived from a value already in
+    // `deps` for every caller today — a future caller whose skip condition is
+    // independent of its scope would otherwise stay held after unblocking.
+    }, [
+        ...deps,
+        key,
+        hasQuery,
+        idleLimit,
+        searchLimit,
+        skip
+    ]);
+    return {
+        items,
+        loading,
+        hasQuery,
+        error
+    };
+}
+export default useSwitcherCollection;
+
+//# sourceMappingURL=use-switcher-collection.js.map

package/src/lib/hooks/use-switcher-collection.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/tenant/feature/instance/src/lib/hooks/use-switcher-collection.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 { compareScored, nameSearchKey, scoreMatch } from '@aglyn/aglyn'\nimport {\n  collection,\n  documentId,\n  endAt,\n  type DocumentData,\n  type Firestore,\n  getDocs,\n  limit,\n  orderBy,\n  query,\n  startAt,\n  where,\n  type WhereFilterOp,\n} from 'firebase/firestore'\nimport {\n  type DependencyList,\n  useEffect,\n  useRef,\n  useState,\n} from 'react'\nimport {\n  reportFirestoreDenial,\n  reportFirestoreServerRead,\n} from './firestore-denial-reporter'\n\n/**\n * Collection KEY for the session-health verdict (AGL-2486).\n *\n * The even path segments only — `['users', uid, 'hostMemberships']` becomes\n * `users/hostMemberships`. That is the convention `use-org-hosts` already\n * uses for the same collection, so the two report the SAME key and still\n * count as one collection rather than inflating each other toward the\n * two-collection threshold. It also keeps document ids — a uid among them —\n * out of a module-scope map.\n */\nexport function switcherCollectionKey(path: string[]): string {\n  return path.filter((_, index) => index % 2 === 0).join('/')\n}\n\nexport interface UseSwitcherCollectionOptions<T> {\n  firestore: Firestore\n  /** Collection path segments, e.g. `['hosts', hostId, 'screens']`. */\n  path: string[]\n  /** Optional single filter, e.g. `['orgId', '==', orgId]`. */\n  where?: readonly [string, WhereFilterOp, unknown]\n  /** Raw search text from the field; debounced and normalized internally. */\n  query: string\n  /** Recent-first window size when the query is empty (default 10). */\n  idleLimit?: number\n  /** Result cap for the name-prefix search (default 20). */\n  searchLimit?: number\n  /**\n   * The field holding the human-readable name, matched client-side.\n   *\n   * Both switchers store it as `displayName`, which is the default; a caller\n   * whose rows name themselves differently passes its own.\n   */\n  nameField?: string\n  /**\n   * How many documents the client-side pass reads (default 50).\n   *\n   * Fetched ONCE per scope and cached for the life of the mount, so typing\n   * costs nothing after the first character — see the search-mode note on the\n   * hook itself.\n   */\n  searchWindow?: number\n  /** Field written with the doc id (default `$id`). */\n  idField?: string\n  /** Client post-filter, e.g. drop soft-deleted or email screens. */\n  filter?: (item: T) => boolean\n  /** Stable scope dependencies (firestore, ids) — like a useEffect dep array. */\n  deps: DependencyList\n  /** Debounce for the search query in ms (default 200). */\n  debounceMs?: number\n  /**\n   * Hold off entirely, because a value this listen must be SCOPED BY is not\n   * resolved yet (AGL-2350).\n   *\n   * The empty-path-segment hold-off below covers a scope that appears IN the\n   * path. A `where` filter is the other kind, and it fails the opposite way:\n   * an unresolved id makes `where` `undefined`, which does not error — it\n   * silently drops the filter and returns the UNSCOPED collection. For\n   * `users/{uid}/hostMemberships` that is every site the person holds in\n   * every org, which on an agency running one workspace per client puts two\n   * clients' site names in one dropdown.\n   *\n   * Defaults to `false`, so this is inert for any caller that does not scope\n   * by a filter.\n   */\n  skip?: boolean\n}\n\nexport interface UseSwitcherCollectionResult<T> {\n  items: T[]\n  /** A fetch is in flight and there are no prior rows to show yet. */\n  loading: boolean\n  /** The (debounced) query is non-empty — results are name-search matches. */\n  hasQuery: boolean\n  /**\n   * The most recent fetch FAILED (AGL-1066).\n   *\n   * Keeping the prior rows on a failure is right and stays (see the catch\n   * below), but the failure was previously erased along with `loading` — so\n   * the first fetch of a scope, which has no prior rows, settled on\n   * `{ items: [], loading: false }` and every switcher read that as \"this\n   * person holds no sites\". Consumers must render \"couldn't load\", never a\n   * zero-state, when this is true.\n   */\n  error: boolean\n}\n\nfunction useDebouncedValue<V>(value: V, ms: number): V {\n  const [debounced, setDebounced] = useState(value)\n  useEffect(() => {\n    const timer = setTimeout(() => setDebounced(value), ms)\n    return () => clearTimeout(timer)\n  }, [value, ms])\n  return debounced\n}\n\n/**\n * Data source for the org/site/screen switchers that scales past a switcher's\n * naive \"load the whole collection and filter in memory\" (AGL-838). Two modes:\n *\n * - **idle** (empty query): a recent-first window, `orderBy(updatedAt desc)`\n *   capped at `idleLimit` — the handful of docs you actually cycle between, not\n *   a full read.\n * - **search** (non-empty query): a true Firestore prefix range over the\n *   normalized `nameLower` (`orderBy(nameLower) startAt(key)..endAt(key+'\\uf8ff')`),\n *   capped at `searchLimit` — finds a match anywhere in the collection without\n *   loading it, where the old client-side filter could only match already-\n *   loaded rows.\n *\n * Reads are one-shot `getDocs` (a switcher list doesn't need live updates), so\n * there is no per-keystroke listener churn and no flash: prior rows stay\n * visible while the next fetch is in flight, and only a scope change (a\n * dependency in `deps`) clears them — the same hold-the-right-scope rule as\n * `useFirestoreCollection` (AGL-591), without its clear-to-empty-then-refill.\n * Out-of-order responses are dropped by request id.\n */\nexport function useSwitcherCollection<T = DocumentData>(\n  options: UseSwitcherCollectionOptions<T>,\n): UseSwitcherCollectionResult<T> {\n  const {\n    firestore,\n    path,\n    where: whereClause,\n    query: rawQuery,\n    idleLimit = 10,\n    searchLimit = 20,\n    nameField = 'displayName',\n    searchWindow = 50,\n    idField = '$id',\n    filter,\n    deps,\n    debounceMs = 200,\n    skip = false,\n  } = options\n\n  const debounced = useDebouncedValue(rawQuery.trim(), debounceMs)\n  const key = nameSearchKey(debounced)\n  const hasQuery = key.length > 0\n\n  const [items, setItems] = useState<T[]>([])\n  const [loading, setLoading] = useState(true)\n  const [error, setError] = useState(false)\n  const requestRef = useRef(0)\n  /**\n   * The client-side search window, cached for the life of this SCOPE.\n   *\n   * A ref rather than state: filling it must not itself cause a render, and\n   * the render that matters is the one `setItems` already causes. Cleared by\n   * the scope effect below, which is the same place the rows are cleared —\n   * keeping the two together is what stops site A's window being matched\n   * against while standing on site B.\n   */\n  const windowRef = useRef<{ rows: any[]; fromCache?: boolean } | null>(null)\n\n  // Clear on a genuine scope change (host A → host B) so the previous scope's\n  // rows never bleed into the new one; a query change keeps the prior rows so\n  // the list doesn't flash (AGL-591 rule, applied per-scope not per-fetch).\n  // eslint-disable-next-line react-hooks/exhaustive-deps\n  useEffect(() => {\n    setItems([])\n    setLoading(true)\n    setError(false)\n    windowRef.current = null\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, deps)\n\n  useEffect(() => {\n    const requestId = ++requestRef.current\n    // A path segment can be momentarily empty (e.g. the uid before auth\n    // resolves); hold rather than build an invalid collection ref. `skip` is\n    // the same hold for a scope that lives in `where` rather than the path,\n    // where an unresolved id would widen the query instead of breaking it.\n    if (skip || path.some((segment) => !segment)) {\n      setItems([])\n      setLoading(true)\n      setError(false)\n      // A hold means the scope is not trustworthy yet, so anything already\n      // read under it must not survive into the scope that unblocks.\n      windowRef.current = null\n      return\n    }\n    setLoading(true)\n    const ref = collection(firestore, path[0], ...path.slice(1))\n    const scopeFilter = whereClause\n      ? [where(whereClause[0], whereClause[1], whereClause[2])]\n      : []\n    const toRows = (snapshot: { docs: any[] }) =>\n      snapshot.docs.map((docSnap) => {\n        const value = { ...docSnap.data() } as Record<string, unknown>\n        if (idField) value[idField] = docSnap.id\n        return value as T\n      })\n\n    /**\n     * SEARCH MODE (AGL-2486) — a client-side window first, the prefix range\n     * only when the window cannot have held everything.\n     *\n     * This used to be the prefix range alone, and that had two defects which\n     * look like one from the outside.\n     *\n     * **It hid documents.** `orderBy('nameLower')` makes Firestore OMIT every\n     * document that does not carry the field — and `nameLower` is optional,\n     * stamped by three write paths for one resource kind. A document written\n     * any other way stayed visible in the idle list and vanished the instant\n     * you typed. Measured against the seeded emulator: a screen named \"Home\"\n     * listed, and `home` returned nothing. Production happens to be clean\n     * today (68/68 live screens and 10/10 membership rows carry it, checked\n     * with the Admin SDK), so this is a LATENT defect rather than a firing\n     * one — but it is armed for the next write path that forgets, and nothing\n     * would fail when it does. Ordering the window by `documentId()`, which no\n     * document can be missing, disarms it permanently: correctness stops\n     * depending on a field staying in step across write paths.\n     *\n     * **And it could not match the way people type.** A prefix over the whole\n     * stored name means somebody looking for \"Main Layout\" who types `layout`\n     * gets nothing. That one IS firing, on every surface, today.\n     *\n     * The window is read ONCE per scope and cached for the life of the mount,\n     * so the common case — a site whose collection fits inside it — costs one\n     * read burst and then nothing at all per keystroke, which is CHEAPER than\n     * the query it replaces. The prefix range is kept and issued only when the\n     * window came back full, because that is the case AGL-838 built it for: a\n     * host with hundreds of screens must still find one that is not in the\n     * window. Dropping it to simplify would have regressed exactly the\n     * property the switcher exists to provide.\n     */\n    const searchRead = async () => {\n      let windowRows = windowRef.current\n      if (!windowRows) {\n        const windowSnapshot = await getDocs(\n          query(ref, ...scopeFilter, orderBy(documentId()), limit(searchWindow)),\n        )\n        windowRows = {\n          rows: toRows(windowSnapshot),\n          fromCache: windowSnapshot.metadata?.fromCache,\n        }\n        windowRef.current = windowRows\n      }\n      const scored = windowRows.rows\n        .map((row: any) => {\n          const label = String(row?.[nameField] ?? '')\n          const score = scoreMatch({ name: label }, debounced)\n          return score === null ? null : { row, score, label }\n        })\n        .filter(Boolean) as Array<{ row: T; score: number; label: string }>\n\n      // Only reach past the window when the window could not have held the\n      // whole collection. A partial window is proof there is nothing beyond it.\n      let beyond: T[] = []\n      let beyondFromCache: boolean | undefined\n      if (windowRows.rows.length >= searchWindow) {\n        const prefixSnapshot = await getDocs(\n          query(\n            ref,\n            ...scopeFilter,\n            orderBy('nameLower'),\n            startAt(key),\n            endAt(key + '\\uf8ff'),\n            limit(searchLimit),\n          ),\n        )\n        beyondFromCache = prefixSnapshot.metadata?.fromCache\n        beyond = toRows(prefixSnapshot)\n      }\n\n      const seen = new Set(scored.map((hit) => (hit.row as any)?.[idField]))\n      const merged = [\n        ...scored\n          .sort((a, b) => compareScored(a, b))\n          .map((hit) => hit.row),\n        ...beyond.filter((row: any) => !seen.has(row?.[idField])),\n      ]\n      return {\n        rows: merged.slice(0, searchLimit),\n        fromCache: windowRows.fromCache === false ? false : beyondFromCache,\n      }\n    }\n\n    const read = hasQuery\n      ? searchRead()\n      : getDocs(\n          query(ref, ...scopeFilter, orderBy('updatedAt', 'desc'), limit(idleLimit)),\n        ).then((snapshot) => ({\n          rows: toRows(snapshot),\n          fromCache: snapshot.metadata?.fromCache,\n        }))\n\n    read\n      .then((result) => {\n        if (requestRef.current !== requestId) return // superseded\n        const snapshot = { metadata: { fromCache: result.fromCache } }\n        const rows = result.rows\n        setItems(filter ? rows.filter(filter) : rows)\n        setError(false)\n        setLoading(false)\n        // A SERVER answer is proof the session can read, and it clears the\n        // denial evidence outright (AGL-2486). Guarded on `fromCache`\n        // because `getDocs` falls back to the cache while offline, and the\n        // reporter contract is explicit that a cached snapshot proves\n        // nothing.\n        //\n        // Written as `=== false` rather than `!fromCache` on purpose: the\n        // claim being made is \"the server answered\", so absent metadata\n        // must report NOTHING rather than be read as a server read. It also\n        // keeps this branch from throwing on a snapshot shape it did not\n        // expect — a throw here lands in the `catch` below and would show\n        // the user a refusal for a fetch that actually succeeded.\n        if (snapshot.metadata?.fromCache === false) reportFirestoreServerRead()\n      })\n      .catch((error: unknown) => {\n        // A missing composite index or transient error leaves the prior rows\n        // in place rather than blanking the menu; the caller's \"view all\"\n        // escape hatch still reaches everything.\n        //\n        // But SAY SO (AGL-1066). Swallowing the failure into `loading: false`\n        // meant the no-prior-rows case — a cold load, or the first fetch\n        // after a scope change — was indistinguishable from a genuinely\n        // empty collection, and the site switcher printed \"No sites yet.\"\n        // at people who hold sites.\n        if (requestRef.current !== requestId) return\n        setError(true)\n        setLoading(false)\n        // …and tell the session detector, which this read used to keep to\n        // itself (AGL-2486). the production report was a Sites list that\n        // \"could not be loaded\" while the console had no idea the session\n        // was the reason: the switcher is one of the first reads on the\n        // page and it contributed ZERO evidence toward the stale verdict,\n        // so the very list that failed could never be what raised the\n        // prompt. Only `permission-denied` — a missing index\n        // (`failed-precondition`) or a dropped network (`unavailable`) is\n        // not a session problem and must never be counted as one.\n        if ((error as { code?: string })?.code === 'permission-denied') {\n          reportFirestoreDenial(switcherCollectionKey(path))\n        }\n      })\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n    // `skip` is listed even though it is derived from a value already in\n    // `deps` for every caller today — a future caller whose skip condition is\n    // independent of its scope would otherwise stay held after unblocking.\n  }, [...deps, key, hasQuery, idleLimit, searchLimit, skip])\n\n  return { items, loading, hasQuery, error }\n}\n\nexport default useSwitcherCollection\n"],"names":["compareScored","nameSearchKey","scoreMatch","collection","documentId","endAt","getDocs","limit","orderBy","query","startAt","where","useEffect","useRef","useState","reportFirestoreDenial","reportFirestoreServerRead","switcherCollectionKey","path","filter","_","index","join","useDebouncedValue","value","ms","debounced","setDebounced","timer","setTimeout","clearTimeout","useSwitcherCollection","options","firestore","whereClause","rawQuery","idleLimit","searchLimit","nameField","searchWindow","idField","deps","debounceMs","skip","trim","key","hasQuery","length","items","setItems","loading","setLoading","error","setError","requestRef","windowRef","current","requestId","some","segment","ref","slice","scopeFilter","toRows","snapshot","docs","map","docSnap","data","id","searchRead","windowRows","windowSnapshot","rows","fromCache","metadata","scored","row","label","String","score","name","Boolean","beyond","beyondFromCache","prefixSnapshot","seen","Set","hit","merged","sort","a","b","has","read","then","result","catch","code"],"mappings":"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"}

package/src/lib/hooks/use-user-name.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The signed-in user's NAME, resolved the way their photo already is
+ * (AGL-2486).
+ *
+ * ## The defect this closes
+ *
+ * `user.displayName` is empty for every SSO account: a SAML identity arrives
+ * with `displayName: undefined`, `photoURL: undefined` and a single provider
+ * entry for the SAML provider, because GCIP leaves the assertion's mapped
+ * attributes under `firebase.sign_in_attributes`. A surface that reads that
+ * field alone falls through to the email, so it renders the address as the
+ * person's NAME and again underneath as their address — and `memberInitials`,
+ * given an address with no space in it, yields a single letter where the
+ * presence stack beside it shows two.
+ *
+ * The name is not actually missing. `users/{uid}` holds `firstName` and
+ * `lastName`, the org member doc holds a `displayName`, and presence reads the
+ * ID token's IdP claims. Three surfaces, three answers to "what is this person
+ * called", and the auth record is the only one that is blank for the
+ * enterprise tier.
+ *
+ * ## Why here, and why this order
+ *
+ * `users/{uid}` is the profile the user themselves edits, so it outranks the
+ * provider's copy — exactly the precedence `useUserProfilePhotoUrl` already
+ * establishes for the picture, on the same document, through the same
+ * listener. This is that hook's sibling and is deliberately shaped like it;
+ * two hooks answering "who is signed in" should not disagree about where to
+ * look.
+ *
+ * The auth record is the fallback rather than the lead because it is the one
+ * an IdP may never populate. The email is last and is not really a name — it
+ * is what the surface shows when nothing else exists, and callers that want
+ * to show an address separately should keep doing so.
+ */
+/**
+ * The resolution itself, without React (AGL-2486).
+ *
+ * Pure and exported so the ORDER can be pinned in a spec. The order is the
+ * entire content of this hook and the only part that can be wrong — and the
+ * case that matters is one no unit test can reach through the hook, because
+ * it needs a real SSO session in a GCIP tenant.
+ */
+export declare function resolveUserName(sources: {
+    profileFirstName?: string | null;
+    profileLastName?: string | null;
+    authDisplayName?: string | null;
+    email?: string | null;
+}): string;
+export declare function useUserName(): string;
+export default useUserName;

package/src/lib/hooks/use-user-name.js

@@ -0,0 +1,90 @@
+/**
+ * @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 { doc } from "firebase/firestore";
+import { useFirestore, useUser } from "./firebase/firebase-services.js";
+import { useFirestoreDoc } from "./use-firestore-doc.js";
+/**
+ * The signed-in user's NAME, resolved the way their photo already is
+ * (AGL-2486).
+ *
+ * ## The defect this closes
+ *
+ * `user.displayName` is empty for every SSO account: a SAML identity arrives
+ * with `displayName: undefined`, `photoURL: undefined` and a single provider
+ * entry for the SAML provider, because GCIP leaves the assertion's mapped
+ * attributes under `firebase.sign_in_attributes`. A surface that reads that
+ * field alone falls through to the email, so it renders the address as the
+ * person's NAME and again underneath as their address — and `memberInitials`,
+ * given an address with no space in it, yields a single letter where the
+ * presence stack beside it shows two.
+ *
+ * The name is not actually missing. `users/{uid}` holds `firstName` and
+ * `lastName`, the org member doc holds a `displayName`, and presence reads the
+ * ID token's IdP claims. Three surfaces, three answers to "what is this person
+ * called", and the auth record is the only one that is blank for the
+ * enterprise tier.
+ *
+ * ## Why here, and why this order
+ *
+ * `users/{uid}` is the profile the user themselves edits, so it outranks the
+ * provider's copy — exactly the precedence `useUserProfilePhotoUrl` already
+ * establishes for the picture, on the same document, through the same
+ * listener. This is that hook's sibling and is deliberately shaped like it;
+ * two hooks answering "who is signed in" should not disagree about where to
+ * look.
+ *
+ * The auth record is the fallback rather than the lead because it is the one
+ * an IdP may never populate. The email is last and is not really a name — it
+ * is what the surface shows when nothing else exists, and callers that want
+ * to show an address separately should keep doing so.
+ */ /**
+ * The resolution itself, without React (AGL-2486).
+ *
+ * Pure and exported so the ORDER can be pinned in a spec. The order is the
+ * entire content of this hook and the only part that can be wrong — and the
+ * case that matters is one no unit test can reach through the hook, because
+ * it needs a real SSO session in a GCIP tenant.
+ */ export function resolveUserName(sources) {
+    var _sources_authDisplayName, _sources_email;
+    const fromProfile = [
+        sources.profileFirstName,
+        sources.profileLastName
+    ].map((part)=>String(part != null ? part : '').trim()).filter(Boolean).join(' ');
+    if (fromProfile) return fromProfile;
+    const fromAuth = String((_sources_authDisplayName = sources.authDisplayName) != null ? _sources_authDisplayName : '').trim();
+    if (fromAuth) return fromAuth;
+    return String((_sources_email = sources.email) != null ? _sources_email : '').trim();
+}
+export function useUserName() {
+    const firestore = useFirestore();
+    const { data: user } = useUser();
+    const uid = user == null ? void 0 : user.uid;
+    const { data } = useFirestoreDoc(// Null ref until a uid exists, so a signed-out mount opens no listen at
+    // all rather than one the rules refuse — same shape as the photo hook.
+    ()=>uid ? doc(firestore, 'users', uid) : null, [
+        firestore,
+        uid
+    ]);
+    return resolveUserName({
+        profileFirstName: data == null ? void 0 : data.firstName,
+        profileLastName: data == null ? void 0 : data.lastName,
+        authDisplayName: user == null ? void 0 : user.displayName,
+        email: user == null ? void 0 : user.email
+    });
+}
+export default useUserName;
+
+//# sourceMappingURL=use-user-name.js.map

package/src/lib/hooks/use-user-name.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../libs/tenant/feature/instance/src/lib/hooks/use-user-name.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 */\nimport { doc } from 'firebase/firestore'\nimport { useFirestore, useUser } from './firebase/firebase-services'\nimport { useFirestoreDoc } from './use-firestore-doc'\n\n/**\n * The signed-in user's NAME, resolved the way their photo already is\n * (AGL-2486).\n *\n * ## The defect this closes\n *\n * `user.displayName` is empty for every SSO account: a SAML identity arrives\n * with `displayName: undefined`, `photoURL: undefined` and a single provider\n * entry for the SAML provider, because GCIP leaves the assertion's mapped\n * attributes under `firebase.sign_in_attributes`. A surface that reads that\n * field alone falls through to the email, so it renders the address as the\n * person's NAME and again underneath as their address — and `memberInitials`,\n * given an address with no space in it, yields a single letter where the\n * presence stack beside it shows two.\n *\n * The name is not actually missing. `users/{uid}` holds `firstName` and\n * `lastName`, the org member doc holds a `displayName`, and presence reads the\n * ID token's IdP claims. Three surfaces, three answers to \"what is this person\n * called\", and the auth record is the only one that is blank for the\n * enterprise tier.\n *\n * ## Why here, and why this order\n *\n * `users/{uid}` is the profile the user themselves edits, so it outranks the\n * provider's copy — exactly the precedence `useUserProfilePhotoUrl` already\n * establishes for the picture, on the same document, through the same\n * listener. This is that hook's sibling and is deliberately shaped like it;\n * two hooks answering \"who is signed in\" should not disagree about where to\n * look.\n *\n * The auth record is the fallback rather than the lead because it is the one\n * an IdP may never populate. The email is last and is not really a name — it\n * is what the surface shows when nothing else exists, and callers that want\n * to show an address separately should keep doing so.\n */\n/**\n * The resolution itself, without React (AGL-2486).\n *\n * Pure and exported so the ORDER can be pinned in a spec. The order is the\n * entire content of this hook and the only part that can be wrong — and the\n * case that matters is one no unit test can reach through the hook, because\n * it needs a real SSO session in a GCIP tenant.\n */\nexport function resolveUserName(sources: {\n  profileFirstName?: string | null\n  profileLastName?: string | null\n  authDisplayName?: string | null\n  email?: string | null\n}): string {\n  const fromProfile = [sources.profileFirstName, sources.profileLastName]\n    .map((part) => String(part ?? '').trim())\n    .filter(Boolean)\n    .join(' ')\n  if (fromProfile) return fromProfile\n  const fromAuth = String(sources.authDisplayName ?? '').trim()\n  if (fromAuth) return fromAuth\n  return String(sources.email ?? '').trim()\n}\n\nexport function useUserName(): string {\n  const firestore = useFirestore()\n  const { data: user } = useUser()\n  const uid = user?.uid\n  const { data } = useFirestoreDoc<{\n    firstName?: string\n    lastName?: string\n  }>(\n    // Null ref until a uid exists, so a signed-out mount opens no listen at\n    // all rather than one the rules refuse — same shape as the photo hook.\n    () => (uid ? doc(firestore, 'users', uid) : null),\n    [firestore, uid],\n  )\n  return resolveUserName({\n    profileFirstName: data?.firstName,\n    profileLastName: data?.lastName,\n    authDisplayName: user?.displayName,\n    email: user?.email,\n  })\n}\n\nexport default useUserName\n"],"names":["doc","useFirestore","useUser","useFirestoreDoc","resolveUserName","sources","fromProfile","profileFirstName","profileLastName","map","part","String","trim","filter","Boolean","join","fromAuth","authDisplayName","email","useUserName","firestore","data","user","uid","firstName","lastName","displayName"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GACD,SAASA,GAAG,QAAQ,qBAAoB;AACxC,SAASC,YAAY,EAAEC,OAAO,QAAQ,kCAA8B;AACpE,SAASC,eAAe,QAAQ,yBAAqB;AAErD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCC,GACD;;;;;;;CAOC,GACD,OAAO,SAASC,gBAAgBC,OAK/B;QAMyBA,0BAEVA;IAPd,MAAMC,cAAc;QAACD,QAAQE,gBAAgB;QAAEF,QAAQG,eAAe;KAAC,CACpEC,GAAG,CAAC,CAACC,OAASC,OAAOD,eAAAA,OAAQ,IAAIE,IAAI,IACrCC,MAAM,CAACC,SACPC,IAAI,CAAC;IACR,IAAIT,aAAa,OAAOA;IACxB,MAAMU,WAAWL,QAAON,2BAAAA,QAAQY,eAAe,YAAvBZ,2BAA2B,IAAIO,IAAI;IAC3D,IAAII,UAAU,OAAOA;IACrB,OAAOL,QAAON,iBAAAA,QAAQa,KAAK,YAAbb,iBAAiB,IAAIO,IAAI;AACzC;AAEA,OAAO,SAASO;IACd,MAAMC,YAAYnB;IAClB,MAAM,EAAEoB,MAAMC,IAAI,EAAE,GAAGpB;IACvB,MAAMqB,MAAMD,wBAAAA,KAAMC,GAAG;IACrB,MAAM,EAAEF,IAAI,EAAE,GAAGlB,gBAIf,wEAAwE;IACxE,uEAAuE;IACvE,IAAOoB,MAAMvB,IAAIoB,WAAW,SAASG,OAAO,MAC5C;QAACH;QAAWG;KAAI;IAElB,OAAOnB,gBAAgB;QACrBG,gBAAgB,EAAEc,wBAAAA,KAAMG,SAAS;QACjChB,eAAe,EAAEa,wBAAAA,KAAMI,QAAQ;QAC/BR,eAAe,EAAEK,wBAAAA,KAAMI,WAAW;QAClCR,KAAK,EAAEI,wBAAAA,KAAMJ,KAAK;IACpB;AACF;AAEA,eAAeC,YAAW"}