@aglyn/plugins-crm 1.0.0-beta.143

package/src/lib/constants/bundle-common.js

@@ -0,0 +1,14 @@
+/**
+ * @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.
+ */ /**
+ * The persisted plugin id (AGL-2595). It was `contacts` while the surface was
+ * one list; the stored lists were rewritten and the plugin manager's alias for
+ * the old value was retired once that backfill reported nothing left
+ * (AGL-2614), so `contacts` now reads as an unknown id like any other.
+ */ export const BUNDLE_ID = 'crm';
+
+//# sourceMappingURL=bundle-common.js.map

package/src/lib/constants/bundle-common.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/crm/src/lib/constants/bundle-common.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 */\n\n/**\n * The persisted plugin id (AGL-2595). It was `contacts` while the surface was\n * one list; the stored lists were rewritten and the plugin manager's alias for\n * the old value was retired once that backfill reported nothing left\n * (AGL-2614), so `contacts` now reads as an unknown id like any other.\n */\nexport const BUNDLE_ID = 'crm'\n"],"names":["BUNDLE_ID"],"mappings":"AAAA;;;;;;CAMC,GAED;;;;;CAKC,GACD,OAAO,MAAMA,YAAY,MAAK"}

package/src/lib/constants/company-filters.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { ListFilterField } from '@aglyn/shared-ui-jsx/const/list-filter';
+export declare const COMPANY_LIST_FILTER_FIELDS: readonly ListFilterField[];

package/src/lib/constants/company-filters.js

@@ -0,0 +1,51 @@
+/**
+ * @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.
+ */ /*
+ * Companies (`orgs/{orgId}/companies`, read scoped to a host).
+ *
+ * Every predicate here is appended to the listener's `visibleTo
+ * array-contains-any`, which is the constraint that decides what a company
+ * filter may be. Firestore carries ONE array clause per query, so the
+ * word-prefix `contains` search the contact list declares through
+ * `nameTokens` cannot run beside the scope predicate — a query with both is
+ * refused outright, not served slowly. The name is therefore offered as a
+ * PREFIX range and an exact match over `nameLower`, which the
+ * `(visibleTo CONTAINS, nameLower ASC)` index serves with the scope in
+ * place. No `tokensPath`, deliberately.
+ *
+ * `ownerUid` is declared so the translator can answer it; the column itself
+ * renders a person's name from the roster and offers a single-select
+ * operator in the panel, which the section maps onto this field's `equals`.
+ * Served by `(visibleTo CONTAINS, ownerUid ASC)`.
+ */ export const COMPANY_LIST_FILTER_FIELDS = [
+    {
+        column: 'name',
+        kind: 'text',
+        path: 'name',
+        lowerPath: 'nameLower',
+        presence: 'always'
+    },
+    {
+        column: 'ownerUid',
+        kind: 'exact',
+        path: 'ownerUid',
+        operators: [
+            'equals'
+        ]
+    }
+];
+
+//# sourceMappingURL=company-filters.js.map

package/src/lib/constants/company-filters.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/crm/src/lib/constants/company-filters.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\nimport type { ListFilterField } from '@aglyn/shared-ui-jsx/const/list-filter'\n\n/*\n * Companies (`orgs/{orgId}/companies`, read scoped to a host).\n *\n * Every predicate here is appended to the listener's `visibleTo\n * array-contains-any`, which is the constraint that decides what a company\n * filter may be. Firestore carries ONE array clause per query, so the\n * word-prefix `contains` search the contact list declares through\n * `nameTokens` cannot run beside the scope predicate — a query with both is\n * refused outright, not served slowly. The name is therefore offered as a\n * PREFIX range and an exact match over `nameLower`, which the\n * `(visibleTo CONTAINS, nameLower ASC)` index serves with the scope in\n * place. No `tokensPath`, deliberately.\n *\n * `ownerUid` is declared so the translator can answer it; the column itself\n * renders a person's name from the roster and offers a single-select\n * operator in the panel, which the section maps onto this field's `equals`.\n * Served by `(visibleTo CONTAINS, ownerUid ASC)`.\n */\nexport const COMPANY_LIST_FILTER_FIELDS: readonly ListFilterField[] = [\n  {\n    column: 'name',\n    kind: 'text',\n    path: 'name',\n    lowerPath: 'nameLower',\n    presence: 'always',\n  },\n  {\n    column: 'ownerUid',\n    kind: 'exact',\n    path: 'ownerUid',\n    operators: ['equals'],\n  },\n]\n"],"names":["COMPANY_LIST_FILTER_FIELDS","column","kind","path","lowerPath","presence","operators"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAID;;;;;;;;;;;;;;;;;CAiBC,GACD,OAAO,MAAMA,6BAAyD;IACpE;QACEC,QAAQ;QACRC,MAAM;QACNC,MAAM;QACNC,WAAW;QACXC,UAAU;IACZ;IACA;QACEJ,QAAQ;QACRC,MAAM;QACNC,MAAM;QACNG,WAAW;YAAC;SAAS;IACvB;CACD,CAAA"}

package/src/lib/constants/contact-filters.d.ts

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { type ContactFieldDefinition } from '@aglyn/aglyn';
+import type { ListFilterField } from '@aglyn/shared-ui-jsx/const/list-filter';
+export declare const CONTACT_LIST_FILTER_FIELDS: readonly ListFilterField[];
+/**
+ * One filter field per active custom contact field (AGL-2617).
+ *
+ * A custom value lives under the facet's `custom` map, so every one is
+ * window-only for the reason the facet fields above are, and its column is
+ * the one the table shows it under — `crmContactCustomColumn(key)` — so a
+ * clause and a column agree on the name and a saved view's columns and
+ * filters name the same thing. The kind follows the definition's type, and
+ * `nullable` is how a cleared value is stored, which is what makes both
+ * empty operators honest here.
+ */
+export declare function contactCustomFilterFields(definitions: readonly Pick<ContactFieldDefinition, 'key' | 'type' | 'retiredAt'>[]): ListFilterField[];
+/** The custom fields' headers, keyed by the column each filters as. */
+export declare function contactCustomFilterHeaders(definitions: readonly Pick<ContactFieldDefinition, 'key' | 'label'>[]): Record<string, string>;
+/**
+ * How every filterable contact field reads — on a chip, in the add-filter
+ * picker, and as the header of a filter-only hidden column.
+ */
+export declare const CONTACT_LIST_FILTER_HEADERS: Readonly<Record<string, string>>;

package/src/lib/constants/contact-filters.js

@@ -0,0 +1,294 @@
+/**
+ * @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 { CRM_CONTACT_VIEW_FIELDS, crmContactCustomColumn } from "@aglyn/aglyn";
+/*
+ * Contacts (`orgs/{orgId}/contacts`, read scoped to a host).
+ *
+ * The card's listener is `limit(1000)` and stays that way — nobody needs
+ * forty thousand rows streamed into a table. What that cap must NOT do is
+ * decide what a search can find, and it did: an org with 40,000 contacts
+ * searched 1,000 of them and answered "no contacts match" for the rest. The
+ * head-count already learned this lesson (AGL-1706, a server aggregate); the
+ * search is the same mistake one field over.
+ *
+ * ⛔ `marketingConsent`, `ordersCount` and `ltvCents` are written only when
+ * they apply, so a `false`/`0` filter would return nothing rather than
+ * everyone else. `isNotEmpty` is exact on them and is what the menu offers.
+ */ export const CONTACT_LIST_FILTER_FIELDS = [
+    {
+        column: 'name',
+        kind: 'text',
+        path: 'name',
+        lowerPath: 'nameLower',
+        tokensPath: 'nameTokens',
+        reversedPath: 'nameReversed'
+    },
+    {
+        // `normalizeContactEmail` lower-cases before every write, so the stored
+        // value IS its own normalized key.
+        column: 'email',
+        kind: 'text',
+        path: 'email',
+        lowerPath: 'email',
+        presence: 'always'
+    },
+    {
+        /*
+     * Already an array of lower-cased tags, so `contains` is a plain
+     * `array-contains` — the one place the word-level caveat does not apply,
+     * because a tag is matched whole rather than by word prefix.
+     */ column: 'tags',
+        kind: 'text',
+        path: 'tags',
+        tokensPath: 'tags',
+        // Ordered by the timestamp the list already sorts on, not by the tag
+        // array — `orderBy` on the same field an `array-contains` matches is a
+        // composite index nobody wants to explain.
+        containsOrderBy: 'updatedAt',
+        // `isAnyOf` is a saved segment's "any of these tags" (AGL-2617). The
+        // query cannot serve it — `array-contains-any` is the scope clause's
+        // — so the translator refuses it and the list matches it over the
+        // window, which the caption says.
+        operators: [
+            'contains',
+            'isAnyOf',
+            'isNotEmpty'
+        ]
+    },
+    {
+        /*
+     * The forms a person came in through — the top-level `formIds` mirror
+     * of the interactions' `formId` (AGL-2612), matched whole and as typed
+     * because a form id is minted with mixed case. The form's own page links
+     * here with its id; nobody types one. Ordered by the list's own
+     * timestamp for the reason `tags` is, served by the
+     * `(formIds CONTAINS, updatedAt DESC)` index.
+     *
+     * ⚠️ An `array-contains` on the mirror cannot share a query with the
+     * `visibleTo` scope clause, so the list drops that clause for this one
+     * filter and the rules admit the read to an org-wide member only — the
+     * caveat the company contacts card states, stated again on the list.
+     */ column: 'formIds',
+        kind: 'text',
+        path: 'formIds',
+        tokensPath: 'formIds',
+        verbatimTokens: true,
+        containsOrderBy: 'updatedAt',
+        operators: [
+            'contains'
+        ]
+    },
+    {
+        column: 'hostId',
+        kind: 'exact',
+        path: 'hostId',
+        presence: 'always'
+    },
+    {
+        column: 'ordersCount',
+        kind: 'number',
+        path: 'ordersCount'
+    },
+    {
+        column: 'ltvCents',
+        kind: 'number',
+        path: 'ltvCents'
+    },
+    {
+        column: 'createdAt',
+        kind: 'date',
+        path: 'createdAt',
+        presence: 'always'
+    },
+    {
+        column: 'updatedAt',
+        kind: 'date',
+        path: 'updatedAt',
+        presence: 'always'
+    },
+    /*
+   * When the earliest open task is due (AGL-2661) — window-only, because
+   * the value is on the SHARED row but a record written before the field
+   * existed has none, and Firestore cannot query for absence. `nullable`
+   * is honest: the writer stores `null` for nothing scheduled, and the
+   * matcher reads absent the same way, so "is empty" is the "No next
+   * activity" filter over the loaded window.
+   */ {
+        column: 'nextTaskAtMs',
+        kind: 'date',
+        path: 'nextTaskAtMs',
+        windowOnly: true,
+        presence: 'nullable'
+    },
+    /*
+   * THE FACET FIELDS (AGL-2617) — window-only, every one of them.
+   *
+   * An owner, a stage, a company and the capture sources live on the
+   * viewing group's facet of the shared contact row, and a facet path is
+   * per group: a `where` on it would need an index per group, and the
+   * translator would send a scoped member a query the rules deny. So these
+   * are declared for the menu and for a saved view, matched over the loaded
+   * window against the flattened row (`ContactRecord` carries each at the
+   * top), and never put on a query — `windowOnly` is what holds that line.
+   * The paths are the ROW'S, which is what the matcher reads.
+   *
+   * The values are picked, not typed — a uid from the roster, a stage from
+   * the fixed list, a source from its labels, a company from the picker —
+   * so `equals` and `isAnyOf` are what they offer; the section supplies
+   * the choices. The column names are the contract `CRM_CONTACT_VIEW_FIELDS`
+   * states, because the dynamic-list translator reads a view by them.
+   */ {
+        column: CRM_CONTACT_VIEW_FIELDS.owner,
+        kind: 'exact',
+        path: 'ownerUid',
+        windowOnly: true,
+        operators: [
+            'equals',
+            'isAnyOf',
+            'isNotEmpty'
+        ]
+    },
+    {
+        column: CRM_CONTACT_VIEW_FIELDS.stage,
+        kind: 'exact',
+        path: 'lifecycleStage',
+        windowOnly: true,
+        operators: [
+            'equals',
+            'isAnyOf',
+            'isNotEmpty'
+        ]
+    },
+    {
+        // The `sources` presence map, matched on its keys — see `keysOf`.
+        column: CRM_CONTACT_VIEW_FIELDS.source,
+        kind: 'exact',
+        path: 'sources',
+        keysOf: true,
+        windowOnly: true,
+        operators: [
+            'equals',
+            'isAnyOf'
+        ]
+    },
+    {
+        column: CRM_CONTACT_VIEW_FIELDS.company,
+        kind: 'exact',
+        path: 'companyId',
+        windowOnly: true,
+        operators: [
+            'equals',
+            'isNotEmpty'
+        ]
+    }
+];
+/**
+ * One filter field per active custom contact field (AGL-2617).
+ *
+ * A custom value lives under the facet's `custom` map, so every one is
+ * window-only for the reason the facet fields above are, and its column is
+ * the one the table shows it under — `crmContactCustomColumn(key)` — so a
+ * clause and a column agree on the name and a saved view's columns and
+ * filters name the same thing. The kind follows the definition's type, and
+ * `nullable` is how a cleared value is stored, which is what makes both
+ * empty operators honest here.
+ */ export function contactCustomFilterFields(definitions) {
+    return definitions.filter((definition)=>!definition.retiredAt).map((definition)=>{
+        const column = crmContactCustomColumn(definition.key);
+        const path = `custom.${definition.key}`;
+        switch(definition.type){
+            case 'number':
+                return {
+                    column,
+                    kind: 'number',
+                    path,
+                    windowOnly: true,
+                    presence: 'nullable'
+                };
+            case 'date':
+                return {
+                    column,
+                    kind: 'date',
+                    path,
+                    windowOnly: true,
+                    presence: 'nullable'
+                };
+            case 'checkbox':
+                return {
+                    column,
+                    kind: 'boolean',
+                    path,
+                    windowOnly: true
+                };
+            case 'select':
+                return {
+                    column,
+                    kind: 'exact',
+                    path,
+                    windowOnly: true,
+                    presence: 'nullable',
+                    operators: [
+                        'equals',
+                        'isAnyOf',
+                        'isEmpty',
+                        'isNotEmpty'
+                    ]
+                };
+            default:
+                return {
+                    column,
+                    kind: 'text',
+                    path,
+                    windowOnly: true,
+                    presence: 'nullable',
+                    operators: [
+                        'contains',
+                        'equals',
+                        'startsWith',
+                        'isEmpty',
+                        'isNotEmpty'
+                    ]
+                };
+        }
+    });
+}
+/** The custom fields' headers, keyed by the column each filters as. */ export function contactCustomFilterHeaders(definitions) {
+    return Object.fromEntries(definitions.map((definition)=>[
+            crmContactCustomColumn(definition.key),
+            definition.label || definition.key
+        ]));
+}
+/**
+ * How every filterable contact field reads — on a chip, in the add-filter
+ * picker, and as the header of a filter-only hidden column.
+ */ export const CONTACT_LIST_FILTER_HEADERS = {
+    name: 'Contact',
+    email: 'Email',
+    tags: 'Tags',
+    formIds: 'Form ID',
+    hostId: 'Site ID',
+    ordersCount: 'Orders',
+    ltvCents: 'Lifetime value (cents)',
+    createdAt: 'Created',
+    updatedAt: 'Updated',
+    nextTaskAtMs: 'Next activity',
+    [CRM_CONTACT_VIEW_FIELDS.owner]: 'Owner',
+    [CRM_CONTACT_VIEW_FIELDS.stage]: 'Stage',
+    [CRM_CONTACT_VIEW_FIELDS.source]: 'Source',
+    [CRM_CONTACT_VIEW_FIELDS.company]: 'Company'
+};
+
+//# sourceMappingURL=contact-filters.js.map

package/src/lib/constants/contact-filters.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/crm/src/lib/constants/contact-filters.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\nimport {\n  type ContactFieldDefinition,\n  CRM_CONTACT_VIEW_FIELDS,\n  crmContactCustomColumn,\n} from '@aglyn/aglyn'\nimport type { ListFilterField } from '@aglyn/shared-ui-jsx/const/list-filter'\n\n/*\n * Contacts (`orgs/{orgId}/contacts`, read scoped to a host).\n *\n * The card's listener is `limit(1000)` and stays that way — nobody needs\n * forty thousand rows streamed into a table. What that cap must NOT do is\n * decide what a search can find, and it did: an org with 40,000 contacts\n * searched 1,000 of them and answered \"no contacts match\" for the rest. The\n * head-count already learned this lesson (AGL-1706, a server aggregate); the\n * search is the same mistake one field over.\n *\n * ⛔ `marketingConsent`, `ordersCount` and `ltvCents` are written only when\n * they apply, so a `false`/`0` filter would return nothing rather than\n * everyone else. `isNotEmpty` is exact on them and is what the menu offers.\n */\nexport const CONTACT_LIST_FILTER_FIELDS: readonly ListFilterField[] = [\n  {\n    column: 'name',\n    kind: 'text',\n    path: 'name',\n    lowerPath: 'nameLower',\n    tokensPath: 'nameTokens',\n    reversedPath: 'nameReversed',\n  },\n  {\n    // `normalizeContactEmail` lower-cases before every write, so the stored\n    // value IS its own normalized key.\n    column: 'email',\n    kind: 'text',\n    path: 'email',\n    lowerPath: 'email',\n    presence: 'always',\n  },\n  {\n    /*\n     * Already an array of lower-cased tags, so `contains` is a plain\n     * `array-contains` — the one place the word-level caveat does not apply,\n     * because a tag is matched whole rather than by word prefix.\n     */\n    column: 'tags',\n    kind: 'text',\n    path: 'tags',\n    tokensPath: 'tags',\n    // Ordered by the timestamp the list already sorts on, not by the tag\n    // array — `orderBy` on the same field an `array-contains` matches is a\n    // composite index nobody wants to explain.\n    containsOrderBy: 'updatedAt',\n    // `isAnyOf` is a saved segment's \"any of these tags\" (AGL-2617). The\n    // query cannot serve it — `array-contains-any` is the scope clause's\n    // — so the translator refuses it and the list matches it over the\n    // window, which the caption says.\n    operators: ['contains', 'isAnyOf', 'isNotEmpty'],\n  },\n  {\n    /*\n     * The forms a person came in through — the top-level `formIds` mirror\n     * of the interactions' `formId` (AGL-2612), matched whole and as typed\n     * because a form id is minted with mixed case. The form's own page links\n     * here with its id; nobody types one. Ordered by the list's own\n     * timestamp for the reason `tags` is, served by the\n     * `(formIds CONTAINS, updatedAt DESC)` index.\n     *\n     * ⚠️ An `array-contains` on the mirror cannot share a query with the\n     * `visibleTo` scope clause, so the list drops that clause for this one\n     * filter and the rules admit the read to an org-wide member only — the\n     * caveat the company contacts card states, stated again on the list.\n     */\n    column: 'formIds',\n    kind: 'text',\n    path: 'formIds',\n    tokensPath: 'formIds',\n    verbatimTokens: true,\n    containsOrderBy: 'updatedAt',\n    operators: ['contains'],\n  },\n  { column: 'hostId', kind: 'exact', path: 'hostId', presence: 'always' },\n  { column: 'ordersCount', kind: 'number', path: 'ordersCount' },\n  { column: 'ltvCents', kind: 'number', path: 'ltvCents' },\n  { column: 'createdAt', kind: 'date', path: 'createdAt', presence: 'always' },\n  { column: 'updatedAt', kind: 'date', path: 'updatedAt', presence: 'always' },\n  /*\n   * When the earliest open task is due (AGL-2661) — window-only, because\n   * the value is on the SHARED row but a record written before the field\n   * existed has none, and Firestore cannot query for absence. `nullable`\n   * is honest: the writer stores `null` for nothing scheduled, and the\n   * matcher reads absent the same way, so \"is empty\" is the \"No next\n   * activity\" filter over the loaded window.\n   */\n  {\n    column: 'nextTaskAtMs',\n    kind: 'date',\n    path: 'nextTaskAtMs',\n    windowOnly: true,\n    presence: 'nullable',\n  },\n  /*\n   * THE FACET FIELDS (AGL-2617) — window-only, every one of them.\n   *\n   * An owner, a stage, a company and the capture sources live on the\n   * viewing group's facet of the shared contact row, and a facet path is\n   * per group: a `where` on it would need an index per group, and the\n   * translator would send a scoped member a query the rules deny. So these\n   * are declared for the menu and for a saved view, matched over the loaded\n   * window against the flattened row (`ContactRecord` carries each at the\n   * top), and never put on a query — `windowOnly` is what holds that line.\n   * The paths are the ROW'S, which is what the matcher reads.\n   *\n   * The values are picked, not typed — a uid from the roster, a stage from\n   * the fixed list, a source from its labels, a company from the picker —\n   * so `equals` and `isAnyOf` are what they offer; the section supplies\n   * the choices. The column names are the contract `CRM_CONTACT_VIEW_FIELDS`\n   * states, because the dynamic-list translator reads a view by them.\n   */\n  {\n    column: CRM_CONTACT_VIEW_FIELDS.owner,\n    kind: 'exact',\n    path: 'ownerUid',\n    windowOnly: true,\n    operators: ['equals', 'isAnyOf', 'isNotEmpty'],\n  },\n  {\n    column: CRM_CONTACT_VIEW_FIELDS.stage,\n    kind: 'exact',\n    path: 'lifecycleStage',\n    windowOnly: true,\n    operators: ['equals', 'isAnyOf', 'isNotEmpty'],\n  },\n  {\n    // The `sources` presence map, matched on its keys — see `keysOf`.\n    column: CRM_CONTACT_VIEW_FIELDS.source,\n    kind: 'exact',\n    path: 'sources',\n    keysOf: true,\n    windowOnly: true,\n    operators: ['equals', 'isAnyOf'],\n  },\n  {\n    column: CRM_CONTACT_VIEW_FIELDS.company,\n    kind: 'exact',\n    path: 'companyId',\n    windowOnly: true,\n    operators: ['equals', 'isNotEmpty'],\n  },\n]\n\n/**\n * One filter field per active custom contact field (AGL-2617).\n *\n * A custom value lives under the facet's `custom` map, so every one is\n * window-only for the reason the facet fields above are, and its column is\n * the one the table shows it under — `crmContactCustomColumn(key)` — so a\n * clause and a column agree on the name and a saved view's columns and\n * filters name the same thing. The kind follows the definition's type, and\n * `nullable` is how a cleared value is stored, which is what makes both\n * empty operators honest here.\n */\nexport function contactCustomFilterFields(\n  definitions: readonly Pick<ContactFieldDefinition, 'key' | 'type' | 'retiredAt'>[],\n): ListFilterField[] {\n  return definitions\n    .filter((definition) => !definition.retiredAt)\n    .map((definition) => {\n      const column = crmContactCustomColumn(definition.key)\n      const path = `custom.${definition.key}`\n      switch (definition.type) {\n        case 'number':\n          return { column, kind: 'number', path, windowOnly: true, presence: 'nullable' }\n        case 'date':\n          return { column, kind: 'date', path, windowOnly: true, presence: 'nullable' }\n        case 'checkbox':\n          return { column, kind: 'boolean', path, windowOnly: true }\n        case 'select':\n          return {\n            column,\n            kind: 'exact',\n            path,\n            windowOnly: true,\n            presence: 'nullable',\n            operators: ['equals', 'isAnyOf', 'isEmpty', 'isNotEmpty'],\n          }\n        default:\n          return {\n            column,\n            kind: 'text',\n            path,\n            windowOnly: true,\n            presence: 'nullable',\n            operators: ['contains', 'equals', 'startsWith', 'isEmpty', 'isNotEmpty'],\n          }\n      }\n    })\n}\n\n/** The custom fields' headers, keyed by the column each filters as. */\nexport function contactCustomFilterHeaders(\n  definitions: readonly Pick<ContactFieldDefinition, 'key' | 'label'>[],\n): Record<string, string> {\n  return Object.fromEntries(\n    definitions.map((definition) => [\n      crmContactCustomColumn(definition.key),\n      definition.label || definition.key,\n    ]),\n  )\n}\n\n/**\n * How every filterable contact field reads — on a chip, in the add-filter\n * picker, and as the header of a filter-only hidden column.\n */\nexport const CONTACT_LIST_FILTER_HEADERS: Readonly<Record<string, string>> = {\n  name: 'Contact',\n  email: 'Email',\n  tags: 'Tags',\n  formIds: 'Form ID',\n  hostId: 'Site ID',\n  ordersCount: 'Orders',\n  ltvCents: 'Lifetime value (cents)',\n  createdAt: 'Created',\n  updatedAt: 'Updated',\n  nextTaskAtMs: 'Next activity',\n  [CRM_CONTACT_VIEW_FIELDS.owner]: 'Owner',\n  [CRM_CONTACT_VIEW_FIELDS.stage]: 'Stage',\n  [CRM_CONTACT_VIEW_FIELDS.source]: 'Source',\n  [CRM_CONTACT_VIEW_FIELDS.company]: 'Company',\n}\n"],"names":["CRM_CONTACT_VIEW_FIELDS","crmContactCustomColumn","CONTACT_LIST_FILTER_FIELDS","column","kind","path","lowerPath","tokensPath","reversedPath","presence","containsOrderBy","operators","verbatimTokens","windowOnly","owner","stage","source","keysOf","company","contactCustomFilterFields","definitions","filter","definition","retiredAt","map","key","type","contactCustomFilterHeaders","Object","fromEntries","label","CONTACT_LIST_FILTER_HEADERS","name","email","tags","formIds","hostId","ordersCount","ltvCents","createdAt","updatedAt","nextTaskAtMs"],"mappings":"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"}

package/src/lib/hooks/use-contact-field-definitions.d.ts

@@ -0,0 +1,48 @@
+import { type ContactFieldDefinition, type CrmFieldObject } from '@aglyn/aglyn';
+/** A stored definition, with the document id every write needs. */
+export interface ContactFieldDefinitionDoc extends ContactFieldDefinition {
+    $id: string;
+}
+export interface ContactFieldDefinitionsResult {
+    /** Every definition describing the asked-for object, retired ones included, in `order`. */
+    definitions: ContactFieldDefinitionDoc[];
+    /** The definitions a value may still be written under, in `order`. */
+    active: ContactFieldDefinitionDoc[];
+    /**
+     * Whether the answer above is the server's. False while the listen is
+     * settling or while there is no org to ask, so a surface that would draw
+     * "no fields yet" waits rather than saying it for one paint.
+     */
+    ready: boolean;
+    /** The rows have been seen by the server — `writeGuardedBySeed`'s input. */
+    fromCache: boolean;
+}
+/**
+ * The org's custom contact field definitions, sorted, for every surface that
+ * needs them (AGL-2601): the Fields list, the contact list's columns, the
+ * profile card, the form editor's mapping picker, an import's target list
+ * and an audience filter's field menu.
+ *
+ * ONE bounded read of a small collection. `orgs/{orgId}/contactFields` has
+ * no index — it is read whole, ordered by document id so the query needs
+ * none, and sorted by `order` here in memory; `CONTACT_FIELDS_MAX_PER_ORG`
+ * is the ceiling on that read and the one every reader shares. The listen is
+ * cached per org by the Firestore SDK itself: two mounts asking for the same
+ * query share one target and one set of documents, so a page with the list
+ * and the columns both open pays for the collection once, and a write from
+ * the Fields section reaches every reader without an invalidation to forget.
+ *
+ * `orgId` rather than `hostId` because definitions are ORG-WIDE — the org is
+ * what the reader has already resolved through `useOrgDataScope`, and a hook
+ * that resolved it again would be a second lookup per surface. Null while
+ * that lookup is in flight issues no query at all.
+ */
+export declare function useContactFieldDefinitions(orgId: string | null | undefined, 
+/**
+ * Which record's definitions to answer with (AGL-2661). Contacts when
+ * unsaid, so every reader written before companies and deals carried
+ * fields — the form mapping, the contact columns, the audience filter —
+ * keeps seeing exactly the definitions it always did.
+ */
+object?: CrmFieldObject): ContactFieldDefinitionsResult;
+export default useContactFieldDefinitions;

package/src/lib/hooks/use-contact-field-definitions.js

@@ -0,0 +1,72 @@
+/**
+ * @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 { activeContactFieldDefinitions, CONTACT_FIELDS_MAX_PER_ORG, CRM_COLLECTIONS, fieldDefinitionsForObject } from "@aglyn/aglyn";
+import { useFirestore, useFirestoreCollection } from "@aglyn/tenant-feature-instance";
+import { collection, documentId, limit, orderBy, query } from "firebase/firestore";
+import { useMemo } from "react";
+const EMPTY = [];
+/**
+ * The org's custom contact field definitions, sorted, for every surface that
+ * needs them (AGL-2601): the Fields list, the contact list's columns, the
+ * profile card, the form editor's mapping picker, an import's target list
+ * and an audience filter's field menu.
+ *
+ * ONE bounded read of a small collection. `orgs/{orgId}/contactFields` has
+ * no index — it is read whole, ordered by document id so the query needs
+ * none, and sorted by `order` here in memory; `CONTACT_FIELDS_MAX_PER_ORG`
+ * is the ceiling on that read and the one every reader shares. The listen is
+ * cached per org by the Firestore SDK itself: two mounts asking for the same
+ * query share one target and one set of documents, so a page with the list
+ * and the columns both open pays for the collection once, and a write from
+ * the Fields section reaches every reader without an invalidation to forget.
+ *
+ * `orgId` rather than `hostId` because definitions are ORG-WIDE — the org is
+ * what the reader has already resolved through `useOrgDataScope`, and a hook
+ * that resolved it again would be a second lookup per surface. Null while
+ * that lookup is in flight issues no query at all.
+ */ export function useContactFieldDefinitions(orgId, /**
+   * Which record's definitions to answer with (AGL-2661). Contacts when
+   * unsaid, so every reader written before companies and deals carried
+   * fields — the form mapping, the contact columns, the audience filter —
+   * keeps seeing exactly the definitions it always did.
+   */ object = 'contact') {
+    const firestore = useFirestore();
+    const { data, status, fromCache } = useFirestoreCollection(()=>orgId ? query(collection(firestore, 'orgs', orgId, CRM_COLLECTIONS.contactFields), orderBy(documentId()), limit(CONTACT_FIELDS_MAX_PER_ORG)) : null, [
+        firestore,
+        orgId
+    ], {
+        idField: '$id'
+    });
+    // One listen per org, narrowed per reader: the collection is small and
+    // shared, and a query per object would be three targets for one list.
+    const definitions = useMemo(()=>(data == null ? void 0 : data.length) ? fieldDefinitionsForObject(data, object) : EMPTY, [
+        data,
+        object
+    ]);
+    const active = useMemo(()=>definitions.length ? activeContactFieldDefinitions(definitions) : EMPTY, [
+        definitions
+    ]);
+    return {
+        definitions,
+        active,
+        ready: Boolean(orgId) && status !== 'loading',
+        fromCache
+    };
+}
+export default useContactFieldDefinitions;
+
+//# sourceMappingURL=use-contact-field-definitions.js.map

package/src/lib/hooks/use-contact-field-definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/crm/src/lib/hooks/use-contact-field-definitions.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 {\n  activeContactFieldDefinitions,\n  CONTACT_FIELDS_MAX_PER_ORG,\n  type ContactFieldDefinition,\n  CRM_COLLECTIONS,\n  type CrmFieldObject,\n  fieldDefinitionsForObject,\n} from '@aglyn/aglyn'\nimport {\n  useFirestore,\n  useFirestoreCollection,\n} from '@aglyn/tenant-feature-instance'\nimport {\n  collection,\n  documentId,\n  limit,\n  orderBy,\n  query,\n} from 'firebase/firestore'\nimport { useMemo } from 'react'\n\n/** A stored definition, with the document id every write needs. */\nexport interface ContactFieldDefinitionDoc extends ContactFieldDefinition {\n  $id: string\n}\n\nexport interface ContactFieldDefinitionsResult {\n  /** Every definition describing the asked-for object, retired ones included, in `order`. */\n  definitions: ContactFieldDefinitionDoc[]\n  /** The definitions a value may still be written under, in `order`. */\n  active: ContactFieldDefinitionDoc[]\n  /**\n   * Whether the answer above is the server's. False while the listen is\n   * settling or while there is no org to ask, so a surface that would draw\n   * \"no fields yet\" waits rather than saying it for one paint.\n   */\n  ready: boolean\n  /** The rows have been seen by the server — `writeGuardedBySeed`'s input. */\n  fromCache: boolean\n}\n\nconst EMPTY: ContactFieldDefinitionDoc[] = []\n\n/**\n * The org's custom contact field definitions, sorted, for every surface that\n * needs them (AGL-2601): the Fields list, the contact list's columns, the\n * profile card, the form editor's mapping picker, an import's target list\n * and an audience filter's field menu.\n *\n * ONE bounded read of a small collection. `orgs/{orgId}/contactFields` has\n * no index — it is read whole, ordered by document id so the query needs\n * none, and sorted by `order` here in memory; `CONTACT_FIELDS_MAX_PER_ORG`\n * is the ceiling on that read and the one every reader shares. The listen is\n * cached per org by the Firestore SDK itself: two mounts asking for the same\n * query share one target and one set of documents, so a page with the list\n * and the columns both open pays for the collection once, and a write from\n * the Fields section reaches every reader without an invalidation to forget.\n *\n * `orgId` rather than `hostId` because definitions are ORG-WIDE — the org is\n * what the reader has already resolved through `useOrgDataScope`, and a hook\n * that resolved it again would be a second lookup per surface. Null while\n * that lookup is in flight issues no query at all.\n */\nexport function useContactFieldDefinitions(\n  orgId: string | null | undefined,\n  /**\n   * Which record's definitions to answer with (AGL-2661). Contacts when\n   * unsaid, so every reader written before companies and deals carried\n   * fields — the form mapping, the contact columns, the audience filter —\n   * keeps seeing exactly the definitions it always did.\n   */\n  object: CrmFieldObject = 'contact',\n): ContactFieldDefinitionsResult {\n  const firestore = useFirestore()\n  const { data, status, fromCache } =\n    useFirestoreCollection<ContactFieldDefinitionDoc>(\n      () =>\n        orgId\n          ? query(\n              collection(\n                firestore,\n                'orgs',\n                orgId,\n                CRM_COLLECTIONS.contactFields,\n              ),\n              orderBy(documentId()),\n              limit(CONTACT_FIELDS_MAX_PER_ORG),\n            )\n          : null,\n      [firestore, orgId],\n      { idField: '$id' },\n    )\n  // One listen per org, narrowed per reader: the collection is small and\n  // shared, and a query per object would be three targets for one list.\n  const definitions = useMemo(\n    () => (data?.length ? fieldDefinitionsForObject(data, object) : EMPTY),\n    [data, object],\n  )\n  const active = useMemo(\n    () => (definitions.length ? activeContactFieldDefinitions(definitions) : EMPTY),\n    [definitions],\n  )\n  return {\n    definitions,\n    active,\n    ready: Boolean(orgId) && status !== 'loading',\n    fromCache,\n  }\n}\n\nexport default useContactFieldDefinitions\n"],"names":["activeContactFieldDefinitions","CONTACT_FIELDS_MAX_PER_ORG","CRM_COLLECTIONS","fieldDefinitionsForObject","useFirestore","useFirestoreCollection","collection","documentId","limit","orderBy","query","useMemo","EMPTY","useContactFieldDefinitions","orgId","object","firestore","data","status","fromCache","contactFields","idField","definitions","length","active","ready","Boolean"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GACD;AAEA,SACEA,6BAA6B,EAC7BC,0BAA0B,EAE1BC,eAAe,EAEfC,yBAAyB,QACpB,eAAc;AACrB,SACEC,YAAY,EACZC,sBAAsB,QACjB,iCAAgC;AACvC,SACEC,UAAU,EACVC,UAAU,EACVC,KAAK,EACLC,OAAO,EACPC,KAAK,QACA,qBAAoB;AAC3B,SAASC,OAAO,QAAQ,QAAO;AAsB/B,MAAMC,QAAqC,EAAE;AAE7C;;;;;;;;;;;;;;;;;;;CAmBC,GACD,OAAO,SAASC,2BACdC,KAAgC,EAChC;;;;;GAKC,GACDC,SAAyB,SAAS;IAElC,MAAMC,YAAYZ;IAClB,MAAM,EAAEa,IAAI,EAAEC,MAAM,EAAEC,SAAS,EAAE,GAC/Bd,uBACE,IACES,QACIJ,MACEJ,WACEU,WACA,QACAF,OACAZ,gBAAgBkB,aAAa,GAE/BX,QAAQF,eACRC,MAAMP,+BAER,MACN;QAACe;QAAWF;KAAM,EAClB;QAAEO,SAAS;IAAM;IAErB,uEAAuE;IACvE,sEAAsE;IACtE,MAAMC,cAAcX,QAClB,IAAOM,CAAAA,wBAAAA,KAAMM,MAAM,IAAGpB,0BAA0Bc,MAAMF,UAAUH,OAChE;QAACK;QAAMF;KAAO;IAEhB,MAAMS,SAASb,QACb,IAAOW,YAAYC,MAAM,GAAGvB,8BAA8BsB,eAAeV,OACzE;QAACU;KAAY;IAEf,OAAO;QACLA;QACAE;QACAC,OAAOC,QAAQZ,UAAUI,WAAW;QACpCC;IACF;AACF;AAEA,eAAeN,2BAA0B"}

package/src/lib/hooks/use-contact-update.d.ts

@@ -0,0 +1,25 @@
+import type { ContactUpdateFields } from '../model/contact-update';
+import type { CrmBulkAnswer } from '../model/crm-bulk-writes';
+/**
+ * THE CONSOLE'S DOOR TO `crm/contact-update` (AGL-2804).
+ *
+ * Every surface that edits a contact's facet saves through here rather than
+ * writing the document — the record page's profile, custom fields, files and
+ * campaign filing, the company page's link, and the contacts bar — because
+ * the rules leave a client nothing in a facet but letting a holder go.
+ *
+ * Built on `useCrmApi`, so beneath the organization hub's mount the request
+ * names the org and the route writes each contact through its own primary
+ * holder, and under a site it writes the site's.
+ *
+ * A request refused WHOLE — no session, no permission, a plan without the CRM
+ * — throws with the route's sentence.
+ * `updateMany` hands a per-contact answer back in the bulk runners' shape;
+ * `updateOne` throws that one contact's refusal, which is what a single
+ * record's Save shows.
+ */
+export declare function useContactUpdate(hostId: string | null): {
+    updateMany: (contactIds: readonly string[], set: ContactUpdateFields) => Promise<CrmBulkAnswer[]>;
+    updateOne: (contactId: string, set: ContactUpdateFields) => Promise<void>;
+};
+export default useContactUpdate;