@aglyn/aglyn 1.0.0-beta.221 → 1.0.0-beta.222

package/src/lib/app-utils/crm.js

@@ -44,10 +44,11 @@ import { _ as _extends } from "@swc/helpers/_/_extends";
  * would otherwise write for itself. No Firestore, no React.
  */ import { normalizeAddress, normalizePhone } from "../foundation/index.js";
 import { consentGroupScope } from "./consent-groups.js";
-import { CONTACT_LIFECYCLE_STAGES, isContactLifecycleStage } from "./crm-kinds.js";
-import { CONTACT_ALTERNATE_EMAILS_FIELD, CONTACT_FACETS_FIELD, CONTACT_SOURCE_LABELS, normalizeContactEmail, readContactFacet } from "./contacts.js";
+import { CONTACT_LIFECYCLE_STAGES, CRM_TASK_KINDS, isContactLifecycleStage } from "./crm-kinds.js";
+import { CONTACT_ALTERNATE_EMAILS_FIELD, CONTACT_FACETS_FIELD, CONTACT_SOURCE_LABELS, composeContactName, normalizeContactEmail, readContactFacet } from "./contacts.js";
 import { isEmailStateStatus } from "./email-state.js";
 import { NAME_TOKEN_MAX_PREFIX, nameSearchKey, nameSearchTokens, SCOPED_SEARCH_JOIN, scopedSearchTokens } from "./name-search.js";
+import { effectivePicklistValueSet, isStandardPicklistValueId, judgePicklistValue, mintPicklistValueId, normalizePicklistLabel, normalizePicklistValueSet, PICKLIST_VALUES_MAX, picklistActiveValues, picklistDefaultLabel, picklistFromLabels, picklistOptions, picklistRank, picklistRefusalSentence, picklistValueByLabel } from "./picklists.js";
 import { MAX_SCOPE_HOSTS, ORG_SCOPE_TOKEN } from "./scope-tokens.js";
 // The fixed vocabularies and their guards live in a leaf module; every name
 // stays importable from here.
@@ -201,62 +202,300 @@ export * from "./crm-kinds.js";
     var _advanceContactLifecycleStage;
     return (_advanceContactLifecycleStage = advanceContactLifecycleStage(current, 'customer')) != null ? _advanceContactLifecycleStage : 'customer';
 }
+/*==========================================
+ * FORECAST CATEGORIES (AGL-3516).
+ *
+ * Salesforce's Opportunity forecast categories, a FIXED set — not a
+ * picklist an org edits, as in Salesforce, because a forecast rolls up by
+ * them and a renamed or added category would be one no forecast knows. A
+ * stage names the category a deal takes on landing in it; the deal stores
+ * its own copy, stamped at every stage move, which the deal page may then
+ * change for that deal alone.
+ *=========================================*/ export const CRM_FORECAST_CATEGORIES = [
+    'omitted',
+    'pipeline',
+    'bestCase',
+    'commit',
+    'closed'
+];
+export const CRM_FORECAST_CATEGORY_LABELS = {
+    omitted: 'Omitted',
+    pipeline: 'Pipeline',
+    bestCase: 'Best Case',
+    commit: 'Commit',
+    closed: 'Closed'
+};
+export function isCrmForecastCategory(value) {
+    return typeof value === 'string' && CRM_FORECAST_CATEGORIES.includes(value);
+}
+/**
+ * A category as typed — the stored key or its label in any case and
+ * spacing ("Best Case", "best case", `bestCase`) — or `null`.
+ */ export function readCrmForecastCategory(value) {
+    var _CRM_FORECAST_CATEGORIES_find;
+    if (isCrmForecastCategory(value)) return value;
+    const key = String(value != null ? value : '').trim().replace(/\s+/g, ' ').toLowerCase();
+    if (!key) return null;
+    return (_CRM_FORECAST_CATEGORIES_find = CRM_FORECAST_CATEGORIES.find((category)=>category.toLowerCase() === key || CRM_FORECAST_CATEGORY_LABELS[category].toLowerCase() === key)) != null ? _CRM_FORECAST_CATEGORIES_find : null;
+}
+/** The category a stage stamps: its own, else its kind's. */ export function dealStageForecastCategory(stage) {
+    if (isCrmForecastCategory(stage.forecastCategory)) return stage.forecastCategory;
+    return stage.kind === 'won' ? 'closed' : stage.kind === 'lost' ? 'omitted' : 'pipeline';
+}
+/**
+ * A deal's forecast category as every reader takes it: the deal's own,
+ * else its stage's, else its status's — a deal written before the field
+ * existed forecasts where its stage puts it.
+ */ export function dealForecastCategory(deal, stage) {
+    if (isCrmForecastCategory(deal.forecastCategory)) return deal.forecastCategory;
+    if (stage) return dealStageForecastCategory(stage);
+    return deal.status === 'won' ? 'closed' : deal.status === 'lost' ? 'omitted' : 'pipeline';
+}
+/** The longest Next step a deal keeps — Salesforce's own 255. */ export const DEAL_NEXT_STEP_MAX = 255;
+/**
+ * A probability override as stored: a whole number 0–100, or `null` for
+ * none (the stage's applies). Anything that is not a number in range is
+ * `undefined` — unreadable, for the writer to refuse.
+ */ export function readDealProbability(value) {
+    if (value === null || value === undefined) return null;
+    if (typeof value === 'string' && !value.trim()) return null;
+    const number = typeof value === 'number' ? value : Number(String(value).trim().replace(/%$/, ''));
+    if (!Number.isFinite(number) || !Number.isInteger(number) || number < 0 || number > 100) {
+        return undefined;
+    }
+    return number;
+}
+/**
+ * A deal's probability: its own override when it holds one, else its
+ * stage's, else `null` for a stage the pipeline no longer has.
+ */ export function dealProbability(deal, stage) {
+    const own = readDealProbability(deal.probability);
+    if (typeof own === 'number') return own;
+    if (!stage) return null;
+    return Math.min(100, Math.max(0, Number(stage.probability) || 0));
+}
+/**
+ * What a stage move writes besides the stage, the status and the clocks:
+ * the new stage's forecast category, and the probability override CLEARED
+ * — Salesforce re-defaults a probability when the stage changes, so an
+ * override typed for the last stage does not follow the deal into the next.
+ * A write that sets either field itself, in the same request, wins.
+ */ export function dealStageMoveFields(stage) {
+    return {
+        forecastCategory: dealStageForecastCategory(stage),
+        probability: null
+    };
+}
 /** Whether a pipeline has been retired — see {@link CrmPipeline.archivedAt}. */ export function isPipelineArchived(pipeline) {
     return typeof (pipeline == null ? void 0 : pipeline.archivedAt) === 'number' && pipeline.archivedAt > 0;
 }
 /**
- * The stages a fresh pipeline starts with.
+ * The stages a fresh pipeline starts with: Salesforce's standard
+ * Opportunity stages, with its probabilities and forecast categories
+ * (AGL-3516). A pipeline seeded before them keeps the stages it was seeded
+ * with — nothing migrates a stored pipeline.
+ *
+ * The closing stages keep the ids `won` and `lost` every pipeline has had,
+ * so an automation filter naming them reads the same on old pipelines and
+ * new ones.
  *
  * Readonly on purpose: a pipeline document stores its own COPY (`[...]`), so
  * a merchant editing their stages must not be editing the module's default,
  * and a second pipeline seeded later must start from the original set.
  */ export const DEFAULT_DEAL_STAGES = [
     {
-        id: 'qualified',
-        name: 'Qualified',
+        id: 'prospecting',
+        name: 'Prospecting',
         order: 0,
         probability: 10,
-        kind: 'open'
+        kind: 'open',
+        forecastCategory: 'pipeline'
     },
     {
-        id: 'contact-made',
-        name: 'Contact made',
+        id: 'qualification',
+        name: 'Qualification',
         order: 1,
-        probability: 20,
-        kind: 'open'
+        probability: 10,
+        kind: 'open',
+        forecastCategory: 'pipeline'
     },
     {
-        id: 'proposal-sent',
-        name: 'Proposal sent',
+        id: 'needs-analysis',
+        name: 'Needs Analysis',
         order: 2,
-        probability: 40,
-        kind: 'open'
+        probability: 20,
+        kind: 'open',
+        forecastCategory: 'pipeline'
     },
     {
-        id: 'negotiation',
-        name: 'Negotiation',
+        id: 'value-proposition',
+        name: 'Value Proposition',
         order: 3,
+        probability: 50,
+        kind: 'open',
+        forecastCategory: 'pipeline'
+    },
+    {
+        id: 'id-decision-makers',
+        name: 'Id. Decision Makers',
+        order: 4,
         probability: 60,
-        kind: 'open'
+        kind: 'open',
+        forecastCategory: 'pipeline'
+    },
+    {
+        id: 'perception-analysis',
+        name: 'Perception Analysis',
+        order: 5,
+        probability: 70,
+        kind: 'open',
+        forecastCategory: 'pipeline'
+    },
+    {
+        id: 'proposal-price-quote',
+        name: 'Proposal/Price Quote',
+        order: 6,
+        probability: 75,
+        kind: 'open',
+        forecastCategory: 'bestCase'
+    },
+    {
+        id: 'negotiation-review',
+        name: 'Negotiation/Review',
+        order: 7,
+        probability: 90,
+        kind: 'open',
+        forecastCategory: 'commit'
     },
     {
         id: 'won',
-        name: 'Won',
-        order: 4,
+        name: 'Closed Won',
+        order: 8,
         probability: 100,
-        kind: 'won'
+        kind: 'won',
+        forecastCategory: 'closed'
     },
     {
         id: 'lost',
-        name: 'Lost',
-        order: 5,
+        name: 'Closed Lost',
+        order: 9,
         probability: 0,
-        kind: 'lost'
+        kind: 'lost',
+        forecastCategory: 'omitted'
     }
 ];
 /** The most lines one deal carries — a quote, not a catalog. */ export const DEAL_LINE_ITEMS_MAX = 50;
 export const DEAL_LINE_ITEM_NAME_MAX = 120;
 /** Units per line; past this the number is a data-entry slip. */ export const DEAL_LINE_ITEM_QUANTITY_MAX = 1000000;
+/*------------------------------------------
+ * OPPORTUNITY CONTACT ROLES (AGL-3521).
+ *
+ * A deal names any number of contacts, each with the part they play — a
+ * label of the org's `opportunityContactRole` picklist, or none — and at
+ * most one of them Primary. The Primary is `contactId`, which every reader
+ * that existed before roles keeps reading: the won-deal customer floor, the
+ * send-email button, the CSV's Contact column, the REST filter. So the two
+ * are written together by every door — setting a Primary sets `contactId`,
+ * and a door that sets `contactId` the old way makes that contact Primary,
+ * adding them without a role when the deal did not name them.
+ *
+ * A deal written before roles holds `contactId` alone, which reads as one
+ * Primary row with no role; its first write through any door stores it.
+ * Where the two disagree — a write from a door that knows only
+ * `contactId` — `contactId` wins, because it is what every older reader
+ * already acted on.
+ *-----------------------------------------*/ /** The most contacts one deal names — a buying committee, not a mailing list. */ export const DEAL_CONTACT_ROLES_MAX = 50;
+/**
+ * Stored or sent roles, read defensively: a row without a usable contact
+ * id is dropped, a contact named twice keeps its first row, only the first
+ * Primary stays Primary, and the list stops at {@link DEAL_CONTACT_ROLES_MAX}.
+ */ export function readDealContactRoles(raw) {
+    if (!Array.isArray(raw)) return [];
+    const roles = [];
+    const seen = new Set();
+    let primaryTaken = false;
+    for (const entry of raw){
+        if (!entry || typeof entry !== 'object') continue;
+        const row = entry;
+        const contactId = typeof row['contactId'] === 'string' ? row['contactId'].trim() : '';
+        if (!contactId || contactId.length > 200 || contactId.includes('/') || seen.has(contactId)) {
+            continue;
+        }
+        seen.add(contactId);
+        const role = typeof row['role'] === 'string' ? normalizePicklistLabel(row['role']) : '';
+        const primary = row['primary'] === true && !primaryTaken;
+        if (primary) primaryTaken = true;
+        roles.push(_extends({
+            contactId
+        }, role ? {
+            role
+        } : {}, {
+            primary
+        }));
+        if (roles.length >= DEAL_CONTACT_ROLES_MAX) break;
+    }
+    return roles;
+}
+/**
+ * `roles` with `contactId` as the one Primary — added first, with no role,
+ * when the list does not name them — or, for `null`, with no Primary.
+ */ export function dealContactRolesWithPrimary(roles, contactId) {
+    const id = typeof contactId === 'string' ? contactId.trim() : '';
+    const next = roles.map((row)=>_extends({}, row, {
+            primary: Boolean(id) && row.contactId === id
+        }));
+    if (id && !next.some((row)=>row.contactId === id)) next.unshift({
+        contactId: id,
+        primary: true
+    });
+    return next.slice(0, DEAL_CONTACT_ROLES_MAX);
+}
+/**
+ * The roles a deal holds, in step with its `contactId`: the stored list
+ * with the contact `contactId` names as its Primary — so a deal written
+ * before roles reads as its one contact, Primary, with no role.
+ */ export function dealContactRolesOf(deal) {
+    const contactId = typeof deal.contactId === 'string' ? deal.contactId : null;
+    return dealContactRolesWithPrimary(readDealContactRoles(deal.contactRoles), contactId);
+}
+/** The Primary's contact id, or `null` for a deal with none. */ export function dealPrimaryContactId(roles) {
+    var _ref;
+    var _roles_find;
+    return (_ref = (_roles_find = roles.find((row)=>row.primary)) == null ? void 0 : _roles_find.contactId) != null ? _ref : null;
+}
+/** `roles` without one contact — a delete or an erasure of that person. */ export function dealContactRolesWithout(roles, contactId) {
+    return roles.filter((row)=>row.contactId !== contactId);
+}
+/**
+ * `roles` with every row naming `from` moved to `to` — a contact merge.
+ * When both are on the deal the survivor keeps its own row, taking the
+ * merged row's role where it has none and its Primary where it was.
+ */ export function dealContactRolesRepointed(roles, from, to) {
+    const merged = roles.find((row)=>row.contactId === from);
+    if (!merged || from === to) return [
+        ...roles
+    ];
+    if (!roles.some((row)=>row.contactId === to)) {
+        return roles.map((row)=>row.contactId === from ? _extends({}, row, {
+                contactId: to
+            }) : row);
+    }
+    return roles.filter((row)=>row.contactId !== from).map((row)=>row.contactId === to ? _extends({}, row, !row.role && merged.role ? {
+            role: merged.role
+        } : {}, {
+            primary: row.primary || merged.primary
+        }) : row);
+}
+/**
+ * What a deal stores for a list of roles: the list, and the `contactId`
+ * its Primary names — `null` for none, which a writer turns into a delete.
+ */ export function dealContactRoleFields(roles) {
+    const contactRoles = readDealContactRoles(roles);
+    return {
+        contactRoles,
+        contactId: dealPrimaryContactId(contactRoles)
+    };
+}
 export const CRM_TASK_KIND_LABELS = {
     call: 'Call',
     email: 'Email',
@@ -386,6 +625,34 @@ export function isCrmEmailDeliveryState(value) {
         ] : []
     ];
 }
+/** The directions each kind takes, in the order a select lists them; none for the rest. */ export const CRM_ACTIVITY_DIRECTIONS = {
+    call: [
+        'outbound',
+        'inbound',
+        'internal'
+    ],
+    email: [
+        'outbound',
+        'inbound'
+    ]
+};
+export const CRM_ACTIVITY_DIRECTION_LABELS = {
+    outbound: 'Outbound',
+    inbound: 'Inbound',
+    internal: 'Internal'
+};
+/** `value` when `kind` takes it as a direction, else `null`. */ export function crmActivityDirection(kind, value) {
+    var _CRM_ACTIVITY_DIRECTIONS_kind;
+    const allowed = (_CRM_ACTIVITY_DIRECTIONS_kind = CRM_ACTIVITY_DIRECTIONS[kind]) != null ? _CRM_ACTIVITY_DIRECTIONS_kind : [];
+    const text = String(value != null ? value : '').trim().toLowerCase();
+    return allowed.includes(text) ? text : null;
+}
+/** "Inbound call", "Outbound email", "Internal call" — or the kind alone with no direction. */ export function crmActivityKindTitle(kind, direction) {
+    var _CRM_ACTIVITY_KIND_LABELS_kind;
+    const known = crmActivityDirection(kind, direction);
+    const noun = (_CRM_ACTIVITY_KIND_LABELS_kind = CRM_ACTIVITY_KIND_LABELS[kind]) != null ? _CRM_ACTIVITY_KIND_LABELS_kind : String(kind);
+    return known ? `${CRM_ACTIVITY_DIRECTION_LABELS[known]} ${noun.toLowerCase()}` : noun;
+}
 /**
  * The activity row a sent one-to-one email is logged as (AGL-2615).
  *
@@ -648,12 +915,15 @@ export function isCrmFieldObject(value) {
  * of itself. An open deal with no resolvable stage is worth nothing rather
  * than everything: the pipeline lost the stage, and a forecast that filled
  * the gap with 100% would be the most optimistic number available.
+ *
+ * An open deal's own probability override (AGL-3516) replaces its stage's
+ * — see {@link dealProbability}.
  */ export function weightedDealAmountCents(deal, stage) {
-    var _deal_amountCents;
+    var _deal_amountCents, _dealProbability;
     const amount = Math.max(0, Math.round(Number((_deal_amountCents = deal.amountCents) != null ? _deal_amountCents : 0) || 0));
     if (deal.status === 'won') return amount;
     if (deal.status === 'lost' || !stage) return 0;
-    const probability = Math.min(100, Math.max(0, Number(stage.probability) || 0));
+    const probability = (_dealProbability = dealProbability(deal, stage)) != null ? _dealProbability : 0;
     return Math.round(amount * probability / 100);
 }
 /** Whether a deal's amount is derived — it has at least one line item. */ export function dealHasLineItems(deal) {
@@ -815,6 +1085,213 @@ export function isCrmFieldObject(value) {
         return null;
     }
 }
+/*==========================================
+ * A COMPANY'S ACCOUNT FIELDS (AGL-3514).
+ *
+ * Salesforce's Account carries more than a name and a domain: a Type, an
+ * Industry, a Rating, an Ownership and an Account Source, each a picklist;
+ * an annual revenue and a head count; a fax, an account number, a site, a
+ * ticker symbol and an SIC code; a shipping address beside the billing one;
+ * and a parent account. Every door that writes a company — the drawer, the
+ * REST resource, the import, a lead's conversion — reads them through this
+ * block, so a value one door refuses is refused by all of them.
+ *
+ * ## Each field's three answers
+ *
+ * A door reads what a request said about a field: not named (`undefined`)
+ * leaves the record alone, `null` or a blank clears it, and anything else
+ * is normalized or refused by name. A picklist field stores the value's
+ * LABEL, judged against the org's list with the record's current value
+ * kept (see the picklist block); the Companies list filters by the key of
+ * Type, Industry and Rating, which `crmCompanyListFields` writes beside
+ * the label.
+ *=========================================*/ /** Each company picklist field: the list it holds a value of, and the key the list filters by. */ export const CRM_COMPANY_PICKLIST_FIELDS = [
+    {
+        field: 'type',
+        picklistId: 'accountType',
+        keyField: 'typeKey'
+    },
+    {
+        field: 'industry',
+        picklistId: 'industry',
+        keyField: 'industryKey'
+    },
+    {
+        field: 'rating',
+        picklistId: 'rating',
+        keyField: 'ratingKey'
+    },
+    {
+        field: 'ownership',
+        picklistId: 'ownership'
+    },
+    {
+        field: 'accountSource',
+        picklistId: 'leadSource',
+        keyField: 'accountSourceKey'
+    }
+];
+/** The short text fields, each capped at Salesforce's own length. */ export const CRM_COMPANY_TEXT_MAX = {
+    accountNumber: 40,
+    site: 80,
+    tickerSymbol: 20,
+    sicCode: 20
+};
+/** The most employees a company records — Salesforce's eight digits. */ export const CRM_COMPANY_EMPLOYEES_MAX = 99999999;
+/** The account fields that are not picklists, as every door names them. */ export const CRM_COMPANY_ACCOUNT_FIELDS = [
+    'annualRevenueCents',
+    'currency',
+    'numberOfEmployees',
+    'fax',
+    'accountNumber',
+    'site',
+    'tickerSymbol',
+    'sicCode',
+    'shippingAddress'
+];
+/** A short text field as stored: trimmed, single-spaced. */ export function normalizeCompanyText(value) {
+    return String(value != null ? value : '').trim().replace(/\s+/g, ' ');
+}
+const blank = (value)=>value === null || typeof value === 'string' && value.trim() === '';
+/**
+ * The account fields a request names, normalized, or the refusal of each
+ * one that cannot be stored — see the block above. A value the door has
+ * already parsed from text (the drawer's revenue, a file's head count)
+ * arrives here as the number it parsed.
+ */ export function readCrmCompanyAccountFields(input) {
+    const values = {};
+    const errors = {};
+    for (const field of CRM_COMPANY_ACCOUNT_FIELDS){
+        const raw = input[field];
+        if (raw === undefined) continue;
+        if (blank(raw)) {
+            values[field] = null;
+            continue;
+        }
+        switch(field){
+            case 'annualRevenueCents':
+                if (typeof raw === 'number' && Number.isSafeInteger(raw) && raw >= 0) values[field] = raw;
+                else errors[field] = 'Must be a whole number of cents, 0 or more';
+                break;
+            case 'currency':
+                {
+                    const code = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+                    if (/^[a-z]{3}$/.test(code)) values[field] = code;
+                    else errors[field] = 'Must be a three-letter ISO 4217 code, like usd';
+                    break;
+                }
+            case 'numberOfEmployees':
+                if (typeof raw === 'number' && Number.isInteger(raw) && raw >= 0 && raw <= CRM_COMPANY_EMPLOYEES_MAX) {
+                    values[field] = raw;
+                } else {
+                    errors[field] = `Must be a whole number from 0 to ${CRM_COMPANY_EMPLOYEES_MAX}`;
+                }
+                break;
+            case 'fax':
+                {
+                    const fax = typeof raw === 'string' ? normalizePhone(raw) : null;
+                    if (fax) values[field] = fax;
+                    else errors[field] = 'Must be a phone number with a country code, like +15125550123';
+                    break;
+                }
+            case 'shippingAddress':
+                if (typeof raw === 'object' && !Array.isArray(raw)) {
+                    values[field] = normalizeAddress(raw);
+                } else {
+                    errors[field] = 'Must be an address object';
+                }
+                break;
+            default:
+                {
+                    const max = CRM_COMPANY_TEXT_MAX[field];
+                    if (typeof raw !== 'string' && typeof raw !== 'number') {
+                        errors[field] = 'Must be text';
+                        break;
+                    }
+                    const text = normalizeCompanyText(raw);
+                    if (text.length > max) errors[field] = `Must be at most ${max} characters`;
+                    else values[field] = text;
+                }
+        }
+    }
+    return {
+        values: values,
+        errors
+    };
+}
+/**
+ * The picklist fields a request names, judged against the org's lists —
+ * `lists` holds each list the caller read, and a list it did not read is
+ * judged as the standard values alone. `current` is the record as stored:
+ * its value is kept even when the list no longer offers it, which is how
+ * a company whose industry was typed before Industry became a picklist
+ * keeps it. On a create (`created`), a field not named starts from its
+ * list's default when the org set one.
+ */ export function judgeCrmCompanyPicklists(lists, requested, options = {}) {
+    const values = {};
+    const errors = {};
+    for (const { field, picklistId } of CRM_COMPANY_PICKLIST_FIELDS){
+        var _lists_picklistId;
+        var _options_current;
+        const list = (_lists_picklistId = lists[picklistId]) != null ? _lists_picklistId : effectiveCrmPicklist(picklistId, undefined);
+        const raw = requested[field];
+        if (raw === undefined) {
+            const fallback = options.created ? picklistDefaultLabel(list) : null;
+            if (fallback) values[field] = fallback;
+            continue;
+        }
+        if (blank(raw)) {
+            values[field] = null;
+            continue;
+        }
+        if (typeof raw !== 'string') {
+            errors[field] = 'Must be text';
+            continue;
+        }
+        const judged = judgeCrmPicklistValue(picklistId, list, raw, (_options_current = options.current) == null ? void 0 : _options_current[field]);
+        if (judged.ok === false) errors[field] = judged.error;
+        else values[field] = judged.value;
+    }
+    return {
+        values,
+        errors
+    };
+}
+/** How deep a chain of parent companies may run. */ export const CRM_COMPANY_PARENT_DEPTH_MAX = 25;
+/**
+ * Why `parentId` cannot be the parent of `companyId` (`null` for a company
+ * not yet created), or `null` when it can: a company is never its own
+ * parent, the parent must be a company the writer can see, and a company
+ * already UNDER this one cannot be put above it — the cycle Salesforce
+ * refuses too. Walks up from the parent through `read`, at most
+ * {@link CRM_COMPANY_PARENT_DEPTH_MAX} steps.
+ */ export async function crmCompanyParentRefusal(companyId, parentId, read) {
+    if (companyId && parentId === companyId) return 'A company cannot be its own parent.';
+    const parent = await read(parentId);
+    if (!parent) return 'There is no such parent company.';
+    const seen = new Set([
+        parentId
+    ]);
+    let cursor = parent.parentCompanyId;
+    for(let depth = 1; cursor; depth += 1){
+        var _ref;
+        var _this;
+        if (companyId && cursor === companyId) {
+            return 'That company sits under this one, so it cannot be its parent.';
+        }
+        // A loop above that does not pass through this company is not this write's.
+        if (seen.has(cursor)) return null;
+        if (depth >= CRM_COMPANY_PARENT_DEPTH_MAX) {
+            return `A company can sit at most ${CRM_COMPANY_PARENT_DEPTH_MAX} levels under another.`;
+        }
+        seen.add(cursor);
+        cursor = (_ref = (_this = await read(cursor)) == null ? void 0 : _this.parentCompanyId) != null ? _ref : null;
+    }
+    return null;
+}
+/** A stored parent id as a reader takes it, `null` for none. */ export function crmCompanyParentId(value) {
+    return typeof value === 'string' && value.trim() !== '' ? value : null;
+}
 /**
  * Mailbox domains that belong to people rather than to a business: the
  * providers anybody can sign up with, and the ones an internet provider
@@ -1550,21 +2027,32 @@ export function isCrmLeadStatus(value) {
  * `sources` is the capture door's record of which SURFACES met the person
  * — `signup`, `booking`, `form:{id}`, `import` — and no file may rewrite
  * it. `leadSource` is what Salesforce calls Lead Source: one of the org's
- * own picklist values ("Trade show", "Referral" — see LEAD SOURCE IS A
- * PICKLIST below), reported on and filtered by, and never derived. Two
+ * own picklist values ("Trade show", "Webinar" — see THE CRM'S PICKLISTS
+ * below), reported on and filtered by, and never derived. Two
  * fields because they answer two questions, and a file that could write
  * the first would be rewriting the site's own history.
  *=========================================*/ /** The longest text one profile field holds — the contact's own cap. */ export const CRM_LEAD_TEXT_MAX = 120;
 /** The most tags one lead keeps — the contact's own cap. */ export const CRM_LEAD_TAGS_MAX = 20;
 /** The longest note a lead keeps — the lead page's own cap. */ export const CRM_LEAD_NOTES_MAX = 4000;
 /** The profile's keys, in the order a card lists them. */ export const CRM_LEAD_PROFILE_KEYS = [
+    'salutation',
+    'firstName',
+    'lastName',
     'company',
     'jobTitle',
     'phone',
+    'mobilePhone',
+    'fax',
+    'doNotCall',
     'website',
     'address',
     'tags',
-    'leadSource'
+    'leadSource',
+    'industry',
+    'rating',
+    'annualRevenueCents',
+    'currency',
+    'numberOfEmployees'
 ];
 /** The sentence an unreadable phone number is refused with, under the field. */ export const CRM_LEAD_PHONE_REFUSAL = 'That phone number could not be read. Enter it with its country code, like ' + '+1 512 555 0107.';
 /** The sentence an unreadable website is refused with, under the field. */ export const CRM_LEAD_WEBSITE_REFUSAL = 'Enter a web address, like acme.com';
@@ -1589,6 +2077,7 @@ export function isCrmLeadStatus(value) {
  * way a company's is; a phone the way a contact's is; both refuse rather
  * than store a value the record would then render as a link to nowhere.
  */ export function normalizeCrmLeadProfile(input) {
+    var _body_annualRevenueCents, _body_currency;
     const body = input != null ? input : {};
     const patch = {};
     const errors = {};
@@ -1601,14 +2090,60 @@ export function isCrmLeadStatus(value) {
     text('company');
     text('jobTitle');
     text('leadSource');
-    if ('phone' in body) {
-        var _body_phone;
-        const raw = String((_body_phone = body['phone']) != null ? _body_phone : '').trim();
-        if (!raw) patch.phone = null;
+    text('salutation');
+    text('industry');
+    text('rating');
+    // A name part as the contact's facet keeps one — see `composeContactName`.
+    for (const key of [
+        'firstName',
+        'lastName'
+    ]){
+        if (!(key in body)) continue;
+        const value = composeContactName(body[key], '');
+        patch[key] = value || null;
+    }
+    for (const key of [
+        'phone',
+        'mobilePhone',
+        'fax'
+    ]){
+        var _body_key;
+        if (!(key in body)) continue;
+        const raw = String((_body_key = body[key]) != null ? _body_key : '').trim();
+        if (!raw) patch[key] = null;
         else {
             const phone = normalizePhone(raw);
-            if (phone) patch.phone = phone;
-            else errors.phone = CRM_LEAD_PHONE_REFUSAL;
+            if (phone) patch[key] = phone;
+            else errors[key] = CRM_LEAD_PHONE_REFUSAL;
+        }
+    }
+    if ('doNotCall' in body) {
+        // Stored only as `true`: anything else is "may be called", a clear.
+        patch.doNotCall = body['doNotCall'] === true ? true : null;
+    }
+    /*
+   * The revenue, its currency and the head count, read by the company's
+   * own reader so a value one record refuses the other refuses in the same
+   * words. A head count typed as digits is read as the number it spells.
+   */ const account = {};
+    if ('annualRevenueCents' in body) account['annualRevenueCents'] = (_body_annualRevenueCents = body['annualRevenueCents']) != null ? _body_annualRevenueCents : null;
+    if ('currency' in body) account['currency'] = (_body_currency = body['currency']) != null ? _body_currency : null;
+    if ('numberOfEmployees' in body) {
+        const raw = body['numberOfEmployees'];
+        const digits = typeof raw === 'string' ? raw.replace(/[\s,]/g, '') : null;
+        account['numberOfEmployees'] = digits === null ? raw != null ? raw : null : digits === '' ? null : /^\d+$/.test(digits) ? Number(digits) : raw;
+    }
+    if (Object.keys(account).length) {
+        const read = readCrmCompanyAccountFields(account);
+        const into = patch;
+        for (const key of [
+            'annualRevenueCents',
+            'currency',
+            'numberOfEmployees'
+        ]){
+            var _read_values_key;
+            if (read.errors[key]) errors[key] = read.errors[key];
+            else if (key in read.values) into[key] = (_read_values_key = read.values[key]) != null ? _read_values_key : null;
         }
     }
     if ('website' in body) {
@@ -1634,282 +2169,1330 @@ export function isCrmLeadStatus(value) {
         errors
     };
 }
-/*==========================================
- * LEAD SOURCE IS A PICKLIST (AGL-3298).
- *
- * Salesforce's Lead Source is a restricted picklist: an admin keeps the
- * list of values, a rep picks one, and an import or an API write naming
- * anything else is refused. Here the list is one org document,
- * `orgs/{orgId}/crmPicklists/leadSource`, holding the values in order as
- * `{ id, label, active }` and an optional default for new records.
- *
- * ## Records store the LABEL
- *
- * A lead carries `leadSource: "Trade show"`, not an id. Every reader that
- * existed before the picklist — the CSV export, the REST resource, the
- * record facts, a saved view's filter, a report grouped by the field —
- * reads the text and keeps working, and a file exported from here
- * re-imports as is. What an id would have bought is a free rename; here a
- * rename (and a delete) REPLACES the old label on every record in the same
- * operation, the way Salesforce's own Replace does, so a report grouped
- * by the field follows the rename rather than splitting in two. The value's
- * `id` is what the list itself is keyed by — the default, a reorder, the
- * manage page's rows — and it never changes.
- *
- * ## Inactive, not gone
- *
- * A deactivated value leaves every picker but stays on the records that
- * hold it, shown with an "(inactive)" hint, and a write that keeps a
- * record's current value is never refused for it. A value is removed only
- * by Delete, which names the value its records move to.
- *
- * ## An org that never edited the list
- *
- * Has no document, and reads {@link CRM_LEAD_SOURCE_STARTER_LABELS} — a
- * small Salesforce-like set. The first edit on the manage page writes that
- * set down as the org's own, so a new org starts with a usable list and no
- * org-creation step has to seed it.
- *=========================================*/ /** The picklists an org keeps, by document id — one per standard field. */ export const CRM_PICKLIST_IDS = [
-    'leadSource'
-];
-/** The lead source value set's document id. */ export const CRM_LEAD_SOURCE_PICKLIST = 'leadSource';
-/** The most values one picklist holds — a menu, not a table. */ export const CRM_PICKLIST_VALUES_MAX = 200;
-/**
- * The values an org that has never edited its list reads — see the block
- * header. Salesforce's own standard set, trimmed to what a small team
- * recognizes.
- */ export const CRM_LEAD_SOURCE_STARTER_LABELS = [
-    'Web',
-    'Phone inquiry',
-    'Referral',
-    'Partner',
-    'Purchased list',
-    'Trade show',
-    'Other'
-];
-/** A label as a picklist stores it: trimmed, single-spaced, capped. */ export function normalizeCrmPicklistLabel(value) {
-    return String(value != null ? value : '').trim().replace(/\s+/g, ' ').slice(0, CRM_LEAD_TEXT_MAX);
-}
-/** The key two labels are compared by: case and spacing do not make a new value. */ function picklistKey(label) {
-    return normalizeCrmPicklistLabel(label).toLowerCase();
-}
 /**
- * A new value's id: the label as a slug, suffixed until it is not one of
- * `taken`. Derived rather than random so a seeded list reads the same in
- * every org, and never reused, because a default names a value by it.
- */ export function crmPicklistValueId(label, taken) {
-    const used = new Set(taken);
-    const base = normalizeCrmPicklistLabel(label).toLowerCase().normalize('NFKD').replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 40) || 'value';
-    let id = base;
-    for(let n = 2; used.has(id); n += 1)id = `${base}-${n}`;
-    return id;
-}
-/** A picklist of active values from labels, in order, with no default. */ export function crmPicklistFromLabels(labels) {
-    const values = [];
-    const seen = new Set();
-    for (const raw of labels){
-        const label = normalizeCrmPicklistLabel(raw);
-        if (!label || seen.has(picklistKey(label))) continue;
-        seen.add(picklistKey(label));
-        values.push({
-            id: crmPicklistValueId(label, values.map((value)=>value.id)),
-            label,
-            active: true
-        });
-    }
-    return {
-        values: values.slice(0, CRM_PICKLIST_VALUES_MAX),
-        defaultValueId: null
+ * The `name` a write must store beside a lead's first and last names
+ * (AGL-3513), the contact's rule: while either part is set the name is
+ * their composition, written whenever either moves. `undefined` when the
+ * write names neither part, or when it leaves both blank — a name-only
+ * lead keeps its name, and clearing both parts leaves the name as it
+ * stands.
+ */ export function crmLeadComposedName(stored, patch) {
+    if (patch.firstName === undefined && patch.lastName === undefined) return undefined;
+    const part = (key)=>{
+        var _patch_key;
+        return patch[key] === undefined ? stored == null ? void 0 : stored[key] : (_patch_key = patch[key]) != null ? _patch_key : '';
     };
+    return composeContactName(part('firstName'), part('lastName')) || undefined;
 }
 /**
- * A stored document as a picklist, or `null` for one that holds none.
- *
- * Tolerant, because the document is client-written: a value with no label
- * is dropped, a second value with the same label (in any case) or the same
- * id is dropped, `active` is true unless it is `false`, and a default that
- * names no value is no default.
- */ export function normalizeCrmPicklist(raw) {
-    var _stored_defaultValueId;
-    if (!raw || typeof raw !== 'object') return null;
-    const stored = raw;
-    if (!Array.isArray(stored['values'])) return null;
-    const values = [];
-    const labels = new Set();
-    const ids = new Set();
-    for (const entry of stored['values']){
-        var _value_id;
-        if (!entry || typeof entry !== 'object') continue;
-        const value = entry;
-        const label = normalizeCrmPicklistLabel(value['label']);
-        if (!label || labels.has(picklistKey(label))) continue;
-        let id = String((_value_id = value['id']) != null ? _value_id : '').trim().slice(0, 64);
-        if (!id || id.includes('/') || ids.has(id)) id = crmPicklistValueId(label, ids);
-        labels.add(picklistKey(label));
-        ids.add(id);
-        values.push({
-            id,
-            label,
-            active: value['active'] !== false
-        });
-        if (values.length >= CRM_PICKLIST_VALUES_MAX) break;
+ * Each lead picklist field beside the lead source (AGL-3513): the list it
+ * holds a value of, and the key the Leads list filters by. The lists are
+ * the contact's and the company's own — one Salutation, one Industry, one
+ * Rating per org — so a lead converts into the same values.
+ */ export const CRM_LEAD_PICKLIST_FIELDS = [
+    {
+        field: 'salutation',
+        picklistId: 'salutation'
+    },
+    {
+        field: 'industry',
+        picklistId: 'industry',
+        keyField: 'industryKey'
+    },
+    {
+        field: 'rating',
+        picklistId: 'rating',
+        keyField: 'ratingKey'
     }
-    const defaultId = String((_stored_defaultValueId = stored['defaultValueId']) != null ? _stored_defaultValueId : '');
-    return {
-        values,
-        defaultValueId: ids.has(defaultId) ? defaultId : null
-    };
-}
-/** The org's lead source list as every reader should take it — see the block header. */ export function effectiveCrmLeadSourcePicklist(raw) {
-    var _normalizeCrmPicklist;
-    return (_normalizeCrmPicklist = normalizeCrmPicklist(raw)) != null ? _normalizeCrmPicklist : crmPicklistFromLabels(CRM_LEAD_SOURCE_STARTER_LABELS);
-}
-/** The value a label names, in any case or spacing — `null` for none. */ export function crmPicklistValueByLabel(picklist, label) {
-    var _picklist_values_find;
-    const key = picklistKey(String(label != null ? label : ''));
-    if (!key) return null;
-    return (_picklist_values_find = picklist.values.find((value)=>picklistKey(value.label) === key)) != null ? _picklist_values_find : null;
-}
-/** The values a picker offers. */ export function crmPicklistActiveValues(picklist) {
-    return picklist.values.filter((value)=>value.active);
-}
-/** The label a new record starts with — only while the default value is active. */ export function crmPicklistDefaultLabel(picklist) {
-    const value = picklist.values.find((entry)=>entry.id === picklist.defaultValueId);
-    return (value == null ? void 0 : value.active) ? value.label : null;
-}
+];
 /**
- * The sentence a lead source outside the list is refused with, naming what
- * the list allows. A long list is cut at twenty names so the sentence stays
- * one a person can read.
- */ export function crmLeadSourceRefusal(picklist) {
-    const active = crmPicklistActiveValues(picklist).map((value)=>value.label);
-    if (!active.length) {
-        return 'This organization has no active lead sources. Add one under CRM › Fields › Leads.';
+ * The lead picklist fields a write names, judged against the org's lists
+ * — the company's {@link judgeCrmCompanyPicklists} over the lead's fields:
+ * `lists` holds each list the caller read (a list it did not read is
+ * judged as the standard values alone), the lead's `current` value is kept
+ * even when the list no longer offers it, and on a create a field not
+ * named starts from its list's default.
+ */ export function judgeCrmLeadPicklists(lists, requested, options = {}) {
+    const values = {};
+    const errors = {};
+    for (const { field, picklistId } of CRM_LEAD_PICKLIST_FIELDS){
+        var _lists_picklistId;
+        var _options_current;
+        const list = (_lists_picklistId = lists[picklistId]) != null ? _lists_picklistId : effectiveCrmPicklist(picklistId, undefined);
+        const raw = requested[field];
+        if (raw === undefined) {
+            const fallback = options.created ? picklistDefaultLabel(list) : null;
+            if (fallback) values[field] = fallback;
+            continue;
+        }
+        if (raw === null || typeof raw === 'string' && !raw.trim()) {
+            values[field] = null;
+            continue;
+        }
+        if (typeof raw !== 'string') {
+            errors[field] = 'Must be text';
+            continue;
+        }
+        const judged = judgeCrmPicklistValue(picklistId, list, raw, (_options_current = options.current) == null ? void 0 : _options_current[field]);
+        if (judged.ok === false) errors[field] = judged.error;
+        else values[field] = judged.value;
     }
-    const shown = active.slice(0, 20).join(', ');
-    const more = active.length > 20 ? `, and ${active.length - 20} more` : '';
-    return `Lead source must be one of: ${shown}${more}.`;
-}
-/**
- * Whether a write may store `value` as a record's lead source, and the
- * label it stores.
- *
- *  - Blank or `null` clears the field — lead source is never required.
- *  - An ACTIVE value, in any case or spacing, stores that value's label.
- *  - The record's `current` value is kept even when it is inactive or no
- *    longer listed: re-saving a record must never be refused for a value
- *    somebody else deactivated.
- *  - Anything else is refused with {@link crmLeadSourceRefusal}.
- */ export function judgeCrmLeadSource(picklist, value, current) {
-    const label = normalizeCrmPicklistLabel(value);
-    if (!label) return {
-        ok: true,
-        value: null
-    };
-    const held = normalizeCrmPicklistLabel(current);
-    if (held && picklistKey(held) === picklistKey(label)) return {
-        ok: true,
-        value: held
-    };
-    const match = crmPicklistValueByLabel(picklist, label);
-    if (match == null ? void 0 : match.active) return {
-        ok: true,
-        value: match.label
-    };
     return {
-        ok: false,
-        error: crmLeadSourceRefusal(picklist)
+        values,
+        errors
     };
 }
 /**
- * What a select offers for a record holding `current`: every active value
- * in order, then the record's own value when the list would not otherwise
- * show it, so the select keeps what the record holds until it is changed.
- */ export function crmPicklistOptions(picklist, current) {
-    const options = crmPicklistActiveValues(picklist).map((value)=>({
-            label: value.label,
-            inactive: false,
-            unlisted: false
-        }));
-    const held = normalizeCrmPicklistLabel(current);
-    if (held && !options.some((option)=>picklistKey(option.label) === picklistKey(held))) {
-        const listed = crmPicklistValueByLabel(picklist, held);
-        options.push({
-            label: held,
-            inactive: Boolean(listed),
-            unlisted: !listed
-        });
-    }
-    return options;
-}
-/**
- * Where a label sorts: its value's position in the list, unlisted values
- * after every listed one, and a record with none last. The order the admin
- * chose is the order a sort by the field reads in, as Salesforce's does.
- */ export function crmPicklistRank(picklist, label) {
-    const text = normalizeCrmPicklistLabel(label);
-    if (!text) return Number.MAX_SAFE_INTEGER;
-    const at = picklist.values.findIndex((value)=>picklistKey(value.label) === picklistKey(text));
-    return at < 0 ? CRM_PICKLIST_VALUES_MAX : at;
-}
-/** The name a lead is listed under: the name it carries, else its address. */ export function crmLeadDisplayName(lead) {
-    var _ref, _ref1;
-    const name = String((_ref = lead == null ? void 0 : lead['name']) != null ? _ref : '').trim();
-    return name || String((_ref1 = lead == null ? void 0 : lead['email']) != null ? _ref1 : '').trim();
+ * The Fields tabs, in order: every object with custom fields, then Tasks,
+ * which has standard picklists and no custom fields (AGL-3517).
+ */ export const CRM_PICKLIST_OBJECTS = [
+    ...CRM_FIELD_OBJECTS,
+    'task'
+];
+/** How each object reads on the Fields tabs and in a refusal. */ export const CRM_PICKLIST_OBJECT_LABELS = _extends({}, CRM_FIELD_OBJECT_LABELS, {
+    task: 'Tasks'
+});
+export function isCrmPicklistObject(value) {
+    return typeof value === 'string' && CRM_PICKLIST_OBJECTS.includes(value);
 }
 /**
- * A lead's status as the list and the filter should read it.
- *
- * `new` for a lead that carries no status at all — every lead captured
- * before the CRM existed, and every lead the capture door writes today,
- * because `addHostLead` stamps none. Reading the absence as `new` is what
- * lets the section open on the leads a site already holds rather than on an
- * empty list until each one has been touched once. A stored value the union
- * does not name also reads as `new`: it is a document some other writer
- * produced, and refusing to list it would hide a person.
- */ export function crmLeadStatus(lead) {
-    const status = lead == null ? void 0 : lead.status;
-    return isCrmLeadStatus(status) ? status : 'new';
-}
-/** Whether a lead still needs working — see {@link CRM_LEAD_OPEN_STATUSES}. */ export function isCrmLeadOpen(lead) {
-    return CRM_LEAD_OPEN_STATUSES.includes(crmLeadStatus(lead));
-}
-/*==========================================
- * SAVED VIEWS (AGL-2617) — a list the way one person works it.
- *
- * "My open leads in Texas" is a list a rep opens every morning, and it is
- * three things at once: the filters that pick the people, the columns they
- * want to see about them, and the order they want them in. A `ContactSegment`
- * kept the first of those for two dimensions — tags and capture sources —
- * and nothing kept the rest, so every reload put the reader back at the
- * whole list. A view keeps all three, for every list in the CRM, under a
- * name, and is addressable: `?view=<id>` on the section's own URL opens it.
- *
- * ## The filters are the LIST'S grammar, not a second one
- *
- * A clause here is `{ field, op, value }` — structurally the
- * `ListFilterRequest` the shared list-filter grammar already speaks, the
- * request a grid's filter panel produces and the one the query translator
- * and the in-memory matcher both read. A view stores a list of them and
- * nothing more, so a view can only ask what the list can already answer,
- * and a list that gains a filterable field gains it for its views at no
- * cost. The type is restated here rather than imported because this module
- * is pure data and the grammar's home is a UI library; the shape is the
- * contract, and `normalizeCrmViewFilters` is what holds a stored document
- * to it.
- *
- * ## Mine, and shared
- *
- * A view is one person's working arrangement until they say otherwise, so
- * it lists only for its owner; `shared` puts it in front of everyone who
- * can read the section. Both are stamped `visibleTo` like every CRM row,
- * because a view is a description of the people it selects and answers to
- * the same authority they do — a private view is hidden by the LISTING, not
- * by the rules, and the rules let the creator or an org-wide member change
- * or remove it.
- *
- * ## The default is the reader's, not the view's
- *
+ * Lead Source, with Salesforce's standard values and Aglyn's own (AGL-3519).
+ * Each carries the group a report splits pipeline by: Inbound for a lead
+ * who came to the org, Outbound for one the org went to, and Other in
+ * neither. Aglyn's are the doors and the outreach the platform runs itself
+ * — a website form, a booking, a sequence — stamped on a record the door
+ * met first ({@link CRM_LEAD_SOURCE_ORIGINS}); a vendor the platform does
+ * not run (a data provider, a sending tool) is an org's own value.
+ */ const LEAD_SOURCE_DEFINITION = {
+    id: 'leadSource',
+    label: 'Lead source',
+    plural: 'lead sources',
+    object: 'lead',
+    restricted: true,
+    groups: [
+        {
+            id: 'inbound',
+            label: 'Inbound'
+        },
+        {
+            id: 'outbound',
+            label: 'Outbound'
+        }
+    ],
+    standardValues: [
+        {
+            id: 'web',
+            label: 'Web',
+            group: 'inbound'
+        },
+        {
+            id: 'phone-inquiry',
+            label: 'Phone inquiry',
+            group: 'inbound'
+        },
+        {
+            id: 'email-inquiry',
+            label: 'Email inquiry',
+            group: 'inbound'
+        },
+        {
+            id: 'partner-referral',
+            label: 'Partner referral',
+            group: 'inbound'
+        },
+        {
+            id: 'employee-referral',
+            label: 'Employee referral',
+            group: 'inbound'
+        },
+        {
+            id: 'external-referral',
+            label: 'External referral',
+            group: 'inbound'
+        },
+        {
+            id: 'advertisement',
+            label: 'Advertisement',
+            group: 'inbound'
+        },
+        {
+            id: 'trade-show',
+            label: 'Trade show',
+            group: 'inbound'
+        },
+        {
+            id: 'webinar',
+            label: 'Webinar',
+            group: 'inbound'
+        },
+        {
+            id: 'word-of-mouth',
+            label: 'Word of mouth',
+            group: 'inbound'
+        },
+        // Aglyn's own doors (AGL-3519), each stamped by the door that met the person.
+        {
+            id: 'website-form',
+            label: 'Website form',
+            group: 'inbound'
+        },
+        {
+            id: 'booking',
+            label: 'Booking',
+            group: 'inbound'
+        },
+        {
+            id: 'newsletter-sign-up',
+            label: 'Newsletter sign-up',
+            group: 'inbound'
+        },
+        {
+            id: 'site-member-sign-up',
+            label: 'Site member sign-up',
+            group: 'inbound'
+        },
+        {
+            id: 'online-purchase',
+            label: 'Online purchase',
+            group: 'inbound'
+        },
+        {
+            id: 'account-sign-up',
+            label: 'Account sign-up',
+            group: 'inbound'
+        },
+        {
+            id: 'purchased-list',
+            label: 'Purchased list',
+            group: 'outbound'
+        },
+        // Aglyn's own outreach (AGL-3519).
+        {
+            id: 'sequence',
+            label: 'Sequence',
+            group: 'outbound'
+        },
+        {
+            id: 'email-campaign',
+            label: 'Email campaign',
+            group: 'outbound'
+        },
+        {
+            id: 'other',
+            label: 'Other'
+        }
+    ],
+    targets: [
+        // The key the Leads list filters by moves with the label (AGL-3321).
+        {
+            object: 'lead',
+            field: 'leadSource',
+            keyField: 'leadSourceKey'
+        },
+        // A contact's lead source is each holder's own, like the rest of its profile.
+        {
+            object: 'contact',
+            field: 'leadSource',
+            facet: true
+        },
+        // A company's Account Source is a lead source value (AGL-3514).
+        {
+            object: 'company',
+            field: 'accountSource',
+            keyField: 'accountSourceKey'
+        },
+        // A deal's, stamped by the conversion that opened it (AGL-3516).
+        {
+            object: 'deal',
+            field: 'leadSource',
+            keyField: 'leadSourceKey'
+        }
+    ]
+};
+/*------------------------------------------
+ * LEAD STATUS (AGL-3512) — a SEMANTIC picklist.
+ *
+ * Every value MEANS one of {@link CRM_LEAD_STATUSES}, and the meaning stays
+ * on the lead as `status`, which every query, count, index, automation and
+ * rule reads exactly as before. The value's label sits beside it as
+ * `statusLabel` — see {@link crmLeadStatusLabel}. Salesforce ships one
+ * standard value per meaning; an org adds its own ("Contacted", "Meeting
+ * set") under a meaning, never under Qualified, which only a conversion
+ * sets.
+ *-----------------------------------------*/ const LEAD_STATUS_DEFINITION = {
+    id: 'leadStatus',
+    label: 'Lead status',
+    plural: 'lead statuses',
+    object: 'lead',
+    restricted: true,
+    meanings: CRM_LEAD_STATUSES,
+    meaningLabels: CRM_LEAD_STATUS_LABELS,
+    reservedMeanings: [
+        'qualified'
+    ],
+    standardValues: [
+        {
+            id: 'new',
+            label: CRM_LEAD_STATUS_LABELS.new,
+            meaning: 'new'
+        },
+        {
+            id: 'nurturing',
+            label: CRM_LEAD_STATUS_LABELS.nurturing,
+            meaning: 'nurturing'
+        },
+        {
+            id: 'working',
+            label: CRM_LEAD_STATUS_LABELS.working,
+            meaning: 'working'
+        },
+        {
+            id: 'qualified',
+            label: CRM_LEAD_STATUS_LABELS.qualified,
+            meaning: 'qualified'
+        },
+        {
+            id: 'unqualified',
+            label: CRM_LEAD_STATUS_LABELS.unqualified,
+            meaning: 'unqualified'
+        }
+    ],
+    targets: [
+        {
+            object: 'lead',
+            field: 'statusLabel'
+        }
+    ]
+};
+/*------------------------------------------
+ * THE COMPANY PICKLISTS (AGL-3514).
+ *
+ * Salesforce's Account Type, Industry, Rating and Ownership, each kept on
+ * the Companies tab. Industry and Rating are shared with leads, whose
+ * targets join these definitions rather than repeating them. Account
+ * Source is not a list of its own: it holds a lead source value, so it is
+ * a target of the lead source definition above.
+ *-----------------------------------------*/ /** Salesforce's Account Type. */ const ACCOUNT_TYPE_DEFINITION = {
+    id: 'accountType',
+    label: 'Type',
+    plural: 'account types',
+    object: 'company',
+    restricted: true,
+    standardValues: [
+        {
+            id: 'analyst',
+            label: 'Analyst'
+        },
+        {
+            id: 'press',
+            label: 'Press'
+        },
+        {
+            id: 'competitor',
+            label: 'Competitor'
+        },
+        {
+            id: 'prospect',
+            label: 'Prospect'
+        },
+        {
+            id: 'customer',
+            label: 'Customer'
+        },
+        {
+            id: 'reseller',
+            label: 'Reseller'
+        },
+        {
+            id: 'integrator',
+            label: 'Integrator'
+        },
+        {
+            id: 'investor',
+            label: 'Investor'
+        },
+        {
+            id: 'partner',
+            label: 'Partner'
+        },
+        {
+            id: 'consulting',
+            label: 'Consulting'
+        },
+        {
+            id: 'other',
+            label: 'Other'
+        }
+    ],
+    targets: [
+        {
+            object: 'company',
+            field: 'type',
+            keyField: 'typeKey'
+        }
+    ]
+};
+/**
+ * Salesforce's Industry. A company written while the field was free text
+ * keeps its text; a write that keeps it is never refused.
+ */ const INDUSTRY_DEFINITION = {
+    id: 'industry',
+    label: 'Industry',
+    plural: 'industries',
+    object: 'company',
+    restricted: true,
+    standardValues: [
+        {
+            id: 'agriculture',
+            label: 'Agriculture'
+        },
+        {
+            id: 'apparel',
+            label: 'Apparel'
+        },
+        {
+            id: 'banking',
+            label: 'Banking'
+        },
+        {
+            id: 'biotechnology',
+            label: 'Biotechnology'
+        },
+        {
+            id: 'chemicals',
+            label: 'Chemicals'
+        },
+        {
+            id: 'communications',
+            label: 'Communications'
+        },
+        {
+            id: 'construction',
+            label: 'Construction'
+        },
+        {
+            id: 'consulting',
+            label: 'Consulting'
+        },
+        {
+            id: 'education',
+            label: 'Education'
+        },
+        {
+            id: 'electronics',
+            label: 'Electronics'
+        },
+        {
+            id: 'energy',
+            label: 'Energy'
+        },
+        {
+            id: 'engineering',
+            label: 'Engineering'
+        },
+        {
+            id: 'entertainment',
+            label: 'Entertainment'
+        },
+        {
+            id: 'environmental',
+            label: 'Environmental'
+        },
+        {
+            id: 'finance',
+            label: 'Finance'
+        },
+        {
+            id: 'food-and-beverage',
+            label: 'Food & Beverage'
+        },
+        {
+            id: 'government',
+            label: 'Government'
+        },
+        {
+            id: 'healthcare',
+            label: 'Healthcare'
+        },
+        {
+            id: 'hospitality',
+            label: 'Hospitality'
+        },
+        {
+            id: 'insurance',
+            label: 'Insurance'
+        },
+        {
+            id: 'machinery',
+            label: 'Machinery'
+        },
+        {
+            id: 'manufacturing',
+            label: 'Manufacturing'
+        },
+        {
+            id: 'media',
+            label: 'Media'
+        },
+        {
+            id: 'not-for-profit',
+            label: 'Not For Profit'
+        },
+        {
+            id: 'recreation',
+            label: 'Recreation'
+        },
+        {
+            id: 'retail',
+            label: 'Retail'
+        },
+        {
+            id: 'shipping',
+            label: 'Shipping'
+        },
+        {
+            id: 'technology',
+            label: 'Technology'
+        },
+        {
+            id: 'telecommunications',
+            label: 'Telecommunications'
+        },
+        {
+            id: 'transportation',
+            label: 'Transportation'
+        },
+        {
+            id: 'utilities',
+            label: 'Utilities'
+        },
+        {
+            id: 'other',
+            label: 'Other'
+        }
+    ],
+    targets: [
+        {
+            object: 'company',
+            field: 'industry',
+            keyField: 'industryKey'
+        },
+        // Leads (AGL-3513): the same list, so a lead converts into its value.
+        {
+            object: 'lead',
+            field: 'industry',
+            keyField: 'industryKey'
+        }
+    ]
+};
+/** Salesforce's Rating. */ const RATING_DEFINITION = {
+    id: 'rating',
+    label: 'Rating',
+    plural: 'ratings',
+    object: 'company',
+    restricted: true,
+    standardValues: [
+        {
+            id: 'hot',
+            label: 'Hot'
+        },
+        {
+            id: 'warm',
+            label: 'Warm'
+        },
+        {
+            id: 'cold',
+            label: 'Cold'
+        }
+    ],
+    targets: [
+        {
+            object: 'company',
+            field: 'rating',
+            keyField: 'ratingKey'
+        },
+        // Leads (AGL-3513).
+        {
+            object: 'lead',
+            field: 'rating',
+            keyField: 'ratingKey'
+        }
+    ]
+};
+/** Salesforce's Ownership. */ const OWNERSHIP_DEFINITION = {
+    id: 'ownership',
+    label: 'Ownership',
+    plural: 'ownership values',
+    object: 'company',
+    restricted: true,
+    standardValues: [
+        {
+            id: 'public',
+            label: 'Public'
+        },
+        {
+            id: 'private',
+            label: 'Private'
+        },
+        {
+            id: 'subsidiary',
+            label: 'Subsidiary'
+        },
+        {
+            id: 'other',
+            label: 'Other'
+        }
+    ],
+    targets: [
+        {
+            object: 'company',
+            field: 'ownership'
+        }
+    ]
+};
+/*------------------------------------------
+ * CONTACT picklists (AGL-3515).
+ *-----------------------------------------*/ /**
+ * Salutation, with Salesforce's standard values. Shared by every object
+ * that addresses a person: defined here with the contact target, where the
+ * label lives in each holder's facet like the rest of the profile.
+ */ const SALUTATION_DEFINITION = {
+    id: 'salutation',
+    label: 'Salutation',
+    plural: 'salutations',
+    object: 'contact',
+    restricted: true,
+    standardValues: [
+        {
+            id: 'mr',
+            label: 'Mr.'
+        },
+        {
+            id: 'ms',
+            label: 'Ms.'
+        },
+        {
+            id: 'mrs',
+            label: 'Mrs.'
+        },
+        {
+            id: 'dr',
+            label: 'Dr.'
+        },
+        {
+            id: 'prof',
+            label: 'Prof.'
+        }
+    ],
+    targets: [
+        {
+            object: 'contact',
+            field: 'salutation',
+            facet: true
+        },
+        // Leads (AGL-3513): on the lead itself, carried to the facet on convert.
+        {
+            object: 'lead',
+            field: 'salutation'
+        }
+    ]
+};
+/*------------------------------------------
+ * DEALS (AGL-3516).
+ *-----------------------------------------*/ /**
+ * Salesforce's Opportunity Type. Plain: the deal stores the label, and
+ * `typeKey` beside it for the Deals list's filter.
+ */ const OPPORTUNITY_TYPE_DEFINITION = {
+    id: 'opportunityType',
+    label: 'Type',
+    plural: 'deal types',
+    object: 'deal',
+    restricted: true,
+    standardValues: [
+        {
+            id: 'existing-business',
+            label: 'Existing Business'
+        },
+        {
+            id: 'new-business',
+            label: 'New Business'
+        }
+    ],
+    targets: [
+        {
+            object: 'deal',
+            field: 'type',
+            keyField: 'typeKey'
+        }
+    ]
+};
+/**
+ * Salesforce's Opportunity Contact Role (AGL-3521): the part a contact
+ * plays on a deal. Plain; the label sits in each entry of the deal's
+ * `contactRoles`, and `contactRoleKeys` lists their keys, which is how a
+ * rename or a delete finds the deals to rewrite.
+ */ const OPPORTUNITY_CONTACT_ROLE_DEFINITION = {
+    id: 'opportunityContactRole',
+    label: 'Contact role',
+    plural: 'contact roles',
+    object: 'deal',
+    restricted: true,
+    standardValues: [
+        {
+            id: 'business-user',
+            label: 'Business User'
+        },
+        {
+            id: 'decision-maker',
+            label: 'Decision Maker'
+        },
+        {
+            id: 'economic-buyer',
+            label: 'Economic Buyer'
+        },
+        {
+            id: 'economic-decision-maker',
+            label: 'Economic Decision Maker'
+        },
+        {
+            id: 'evaluator',
+            label: 'Evaluator'
+        },
+        {
+            id: 'executive-sponsor',
+            label: 'Executive Sponsor'
+        },
+        {
+            id: 'influencer',
+            label: 'Influencer'
+        },
+        {
+            id: 'technical-buyer',
+            label: 'Technical Buyer'
+        },
+        {
+            id: 'other',
+            label: 'Other'
+        }
+    ],
+    targets: [
+        {
+            object: 'deal',
+            field: 'contactRoles',
+            arrayKey: 'role',
+            keyField: 'contactRoleKeys'
+        }
+    ]
+};
+/*
+ * TASKS (AGL-3517) — Salesforce's Task Status, Priority, Type and Subject.
+ *
+ * Status, Priority and Type are SEMANTIC: each value means one of the
+ * task's existing `status`, `priority` or `kind` values, which stay on the
+ * document untouched for every query, reminder, due state, digest and
+ * automation. The value's LABEL sits beside it in `statusLabel`,
+ * `priorityLabel` or `typeLabel`; a task with no label shows the first
+ * active value of its meaning (see `crmTaskPicklistLabel`). Subject is an
+ * unrestricted combobox over the title: its values are suggestions, the
+ * title stays free text, and no record holds a subject "value", so a
+ * rename or a delete rewrites nothing.
+ */ const TASK_STATUS_DEFINITION = {
+    id: 'taskStatus',
+    label: 'Status',
+    plural: 'task statuses',
+    object: 'task',
+    restricted: true,
+    meanings: [
+        'open',
+        'done'
+    ],
+    standardValues: [
+        {
+            id: 'not-started',
+            label: 'Not Started',
+            meaning: 'open'
+        },
+        {
+            id: 'in-progress',
+            label: 'In Progress',
+            meaning: 'open'
+        },
+        {
+            id: 'waiting',
+            label: 'Waiting on someone else',
+            meaning: 'open'
+        },
+        {
+            id: 'deferred',
+            label: 'Deferred',
+            meaning: 'open'
+        },
+        {
+            id: 'completed',
+            label: 'Completed',
+            meaning: 'done'
+        }
+    ],
+    defaultValueId: 'not-started',
+    targets: [
+        {
+            object: 'task',
+            field: 'statusLabel'
+        }
+    ]
+};
+const TASK_PRIORITY_DEFINITION = {
+    id: 'taskPriority',
+    label: 'Priority',
+    plural: 'task priorities',
+    object: 'task',
+    restricted: true,
+    meanings: [
+        'low',
+        'normal',
+        'high'
+    ],
+    standardValues: [
+        {
+            id: 'high',
+            label: 'High',
+            meaning: 'high'
+        },
+        {
+            id: 'normal',
+            label: 'Normal',
+            meaning: 'normal'
+        },
+        {
+            id: 'low',
+            label: 'Low',
+            meaning: 'low'
+        }
+    ],
+    defaultValueId: 'normal',
+    targets: [
+        {
+            object: 'task',
+            field: 'priorityLabel'
+        }
+    ]
+};
+const TASK_TYPE_DEFINITION = {
+    id: 'taskType',
+    label: 'Type',
+    plural: 'task types',
+    object: 'task',
+    restricted: true,
+    meanings: CRM_TASK_KINDS,
+    standardValues: [
+        {
+            id: 'call',
+            label: 'Call',
+            meaning: 'call'
+        },
+        {
+            id: 'email',
+            label: 'Email',
+            meaning: 'email'
+        },
+        {
+            id: 'meeting',
+            label: 'Meeting',
+            meaning: 'meeting'
+        },
+        // Salesforce's "Other": a task that is none of the three conversations.
+        {
+            id: 'todo',
+            label: 'To-do',
+            meaning: 'todo'
+        }
+    ],
+    defaultValueId: 'todo',
+    targets: [
+        {
+            object: 'task',
+            field: 'typeLabel'
+        }
+    ]
+};
+const TASK_SUBJECT_DEFINITION = {
+    id: 'taskSubject',
+    label: 'Subject',
+    plural: 'task subjects',
+    object: 'task',
+    restricted: false,
+    standardValues: [
+        {
+            id: 'call',
+            label: 'Call'
+        },
+        {
+            id: 'send-letter',
+            label: 'Send Letter'
+        },
+        {
+            id: 'send-quote',
+            label: 'Send Quote'
+        },
+        {
+            id: 'other',
+            label: 'Other'
+        }
+    ],
+    // Suggestions for a free-text title: nothing holds them, nothing moves.
+    targets: []
+};
+/** Every standard picklist field the CRM keeps, one document each. */ export const CRM_PICKLIST_DEFINITIONS = [
+    LEAD_SOURCE_DEFINITION,
+    LEAD_STATUS_DEFINITION,
+    // Companies (AGL-3514).
+    ACCOUNT_TYPE_DEFINITION,
+    INDUSTRY_DEFINITION,
+    RATING_DEFINITION,
+    OWNERSHIP_DEFINITION,
+    // Contacts (AGL-3515).
+    SALUTATION_DEFINITION,
+    // Deals (AGL-3516).
+    OPPORTUNITY_TYPE_DEFINITION,
+    // Deal contact roles (AGL-3521).
+    OPPORTUNITY_CONTACT_ROLE_DEFINITION,
+    // Tasks (AGL-3517).
+    TASK_STATUS_DEFINITION,
+    TASK_PRIORITY_DEFINITION,
+    TASK_TYPE_DEFINITION,
+    TASK_SUBJECT_DEFINITION
+];
+/** The picklists an org keeps, by document id. */ export const CRM_PICKLIST_IDS = CRM_PICKLIST_DEFINITIONS.map((definition)=>definition.id);
+/** The lead source value set's document id. */ export const CRM_LEAD_SOURCE_PICKLIST = 'leadSource';
+/** The salutation value set's document id (AGL-3515). */ export const CRM_SALUTATION_PICKLIST = 'salutation';
+/** A deal's Type value set's document id (AGL-3516). */ export const CRM_OPPORTUNITY_TYPE_PICKLIST = 'opportunityType';
+/** A deal contact's role value set's document id (AGL-3521). */ export const CRM_OPPORTUNITY_CONTACT_ROLE_PICKLIST = 'opportunityContactRole';
+/**
+ * The built-in Lead source value each first-party door stamps (AGL-3519), by
+ * the door's word for how it met a person — a capture's source, or the
+ * outreach that reached them. `api`, `import` and `manual` are ways a record
+ * was ADDED, not where a person came from, and stamp nothing.
+ */ export const CRM_LEAD_SOURCE_ORIGINS = {
+    form: 'website-form',
+    booking: 'booking',
+    newsletter: 'newsletter-sign-up',
+    member: 'site-member-sign-up',
+    order: 'online-purchase',
+    account: 'account-sign-up',
+    sequence: 'sequence',
+    emailCampaign: 'email-campaign'
+};
+export function isCrmPicklistId(value) {
+    return typeof value === 'string' && CRM_PICKLIST_IDS.includes(value);
+}
+/** The definition an id names, or `null` for one the registry does not hold. */ export function crmPicklistDefinition(id) {
+    var _CRM_PICKLIST_DEFINITIONS_find;
+    return (_CRM_PICKLIST_DEFINITIONS_find = CRM_PICKLIST_DEFINITIONS.find((definition)=>definition.id === id)) != null ? _CRM_PICKLIST_DEFINITIONS_find : null;
+}
+/** The definitions whose values are managed on one Fields tab, in registry order. */ export function crmPicklistDefinitionsFor(object) {
+    return CRM_PICKLIST_DEFINITIONS.filter((definition)=>definition.object === object);
+}
+/** The definition behind a registered id — total, because the id is typed. */ function definitionOf(id) {
+    return crmPicklistDefinition(id);
+}
+/** The most values one picklist holds — a menu, not a table. */ export const CRM_PICKLIST_VALUES_MAX = PICKLIST_VALUES_MAX;
+/**
+ * The values an org without a lead source document offered before the
+ * standard set was built in. "Referral" and "Partner" are not standard: a
+ * record holding one, in an org that never stored its list, reads as not in
+ * the list until the value is written down as the org's own.
+ */ export const CRM_LEAD_SOURCE_STARTER_LABELS = [
+    'Web',
+    'Phone inquiry',
+    'Referral',
+    'Partner',
+    'Purchased list',
+    'Trade show',
+    'Other'
+];
+/** A label as a picklist stores it: trimmed, single-spaced, capped. */ export const normalizeCrmPicklistLabel = normalizePicklistLabel;
+/** A new value's id — see `mintPicklistValueId`. */ export const crmPicklistValueId = mintPicklistValueId;
+/** A picklist of active values from labels, in order, with no default. */ export const crmPicklistFromLabels = picklistFromLabels;
+/**
+ * A stored document as a picklist, or `null` for one that holds none —
+ * tolerant, as `normalizePicklistValueSet` reads it, and without the
+ * standard values merged in. {@link effectiveCrmPicklist} is what a reader
+ * judges against.
+ */ export function normalizeCrmPicklist(raw) {
+    return normalizePicklistValueSet(raw);
+}
+/** An org's list for one picklist as every reader should take it — see the block header. */ export function effectiveCrmPicklist(id, raw) {
+    return effectivePicklistValueSet(definitionOf(id), raw);
+}
+/** The org's lead source list as every reader should take it. */ export function effectiveCrmLeadSourcePicklist(raw) {
+    return effectiveCrmPicklist(CRM_LEAD_SOURCE_PICKLIST, raw);
+}
+/**
+ * The label a door stamps for `origin` (AGL-3519): its built-in value as the
+ * org spells it, while that value is ACTIVE — an org that deactivated it has
+ * said not to file people under it — else `null`, as for a word with none.
+ */ export function crmLeadSourceForOrigin(picklist, origin) {
+    const id = typeof origin === 'string' ? CRM_LEAD_SOURCE_ORIGINS[origin] : undefined;
+    if (!id || !Object.hasOwn(CRM_LEAD_SOURCE_ORIGINS, origin)) return null;
+    const value = picklist.values.find((entry)=>entry.id === id);
+    return (value == null ? void 0 : value.active) ? value.label : null;
+}
+/** Whether a value is one of a picklist's standard values — computed from its id, never stored. */ export function isStandardCrmPicklistValue(id, valueId) {
+    return isStandardPicklistValueId(definitionOf(id), valueId);
+}
+/** The value a label names, in any case or spacing — `null` for none. */ export const crmPicklistValueByLabel = picklistValueByLabel;
+/** The values a picker offers. */ export const crmPicklistActiveValues = picklistActiveValues;
+/** The label a new record starts with — only while the default value is active. */ export const crmPicklistDefaultLabel = picklistDefaultLabel;
+/**
+ * The sentence a value outside a restricted picklist is refused with,
+ * naming what the list allows, and where to add one when it allows none.
+ */ export function crmPicklistRefusal(id, picklist) {
+    const definition = definitionOf(id);
+    return picklistRefusalSentence(picklist, {
+        field: definition.label,
+        empty: `This organization has no active ${definition.plural}. Add one under ` + `CRM › Fields › ${CRM_PICKLIST_OBJECT_LABELS[definition.object]}.`
+    });
+}
+/** The sentence a lead source outside the list is refused with. */ export function crmLeadSourceRefusal(picklist) {
+    return crmPicklistRefusal(CRM_LEAD_SOURCE_PICKLIST, picklist);
+}
+/**
+ * Whether a write may store `value` as a record's value of picklist `id`,
+ * and the label it stores — `judgePicklistValue` under the definition's
+ * restriction: blank clears, an active value stores the list's spelling,
+ * the record's `current` value is always kept, and on a restricted
+ * picklist anything else is refused with {@link crmPicklistRefusal}.
+ */ export function judgeCrmPicklistValue(id, picklist, value, current) {
+    return judgePicklistValue(picklist, value, {
+        restricted: definitionOf(id).restricted,
+        current,
+        refusal: ()=>crmPicklistRefusal(id, picklist)
+    });
+}
+/**
+ * A deal's contact roles with each role judged against the org's
+ * `opportunityContactRole` list (AGL-3521): an active value stored as the
+ * list spells it, a blank cleared, and the role a contact already holds on
+ * the deal (`current`) kept — or the first refusal, naming what the list
+ * allows.
+ */ export function judgeDealContactRoles(picklist, roles, current = []) {
+    const judged = [];
+    for (const row of roles){
+        var _row_role;
+        var _current_find;
+        const held = (_current_find = current.find((entry)=>entry.contactId === row.contactId)) == null ? void 0 : _current_find.role;
+        const verdict = judgeCrmPicklistValue('opportunityContactRole', picklist, (_row_role = row.role) != null ? _row_role : '', held);
+        if (verdict.ok === false) return verdict;
+        judged.push(_extends({
+            contactId: row.contactId
+        }, verdict.value ? {
+            role: verdict.value
+        } : {}, {
+            primary: row.primary
+        }));
+    }
+    return {
+        ok: true,
+        roles: judged
+    };
+}
+/** {@link judgeCrmPicklistValue} for the lead source. */ export function judgeCrmLeadSource(picklist, value, current) {
+    return judgeCrmPicklistValue(CRM_LEAD_SOURCE_PICKLIST, picklist, value, current);
+}
+/**
+ * What a select offers for a record holding `current`: every active value
+ * in order, then the record's own value when the list would not otherwise
+ * show it, so the select keeps what the record holds until it is changed.
+ */ export const crmPicklistOptions = picklistOptions;
+/**
+ * Where a label sorts: its value's position in the list, unlisted values
+ * after every listed one, and a record with none last. The order the admin
+ * chose is the order a sort by the field reads in, as Salesforce's does.
+ */ export const crmPicklistRank = picklistRank;
+/*------------------------------------------
+ * A LEAD'S STATUS LABEL (AGL-3512).
+ *
+ * `status` is the meaning and stays the truth: a writer that knows only the
+ * meaning — an automation, an inbox reply, a rule — sets `status` alone and
+ * the lead still reads right. `statusLabel` names which of the org's values
+ * of that meaning the lead holds, and is believed only while it IS one of
+ * that meaning; otherwise, or when absent, the lead shows the default value
+ * when it is active and of that meaning, else the first active value of
+ * that meaning, else the standard label.
+ *-----------------------------------------*/ /** The lead status value set's document id. */ export const CRM_LEAD_STATUS_PICKLIST = 'leadStatus';
+/** The field a lead's status label is stored in, beside `status`. */ export const CRM_LEAD_STATUS_LABEL_FIELD = 'statusLabel';
+/** The org's lead status list as every reader should take it. */ export function effectiveCrmLeadStatusPicklist(raw) {
+    return effectiveCrmPicklist(CRM_LEAD_STATUS_PICKLIST, raw);
+}
+/** The standard lead statuses alone — what a reader answers before the org's list is read. */ export const STANDARD_CRM_LEAD_STATUS_PICKLIST = effectiveCrmLeadStatusPicklist(null);
+/**
+ * The value a lead with `status` shows when it names none of its own: the
+ * default when active and of that meaning, else the first active value of
+ * that meaning, else the first of that meaning at all.
+ */ export function crmLeadStatusValueFor(picklist, status) {
+    var _ref, _ref1;
+    const ofMeaning = picklist.values.filter((value)=>value.meaning === status);
+    const preferred = ofMeaning.find((value)=>value.id === picklist.defaultValueId && value.active);
+    return (_ref = (_ref1 = preferred != null ? preferred : ofMeaning.find((value)=>value.active)) != null ? _ref1 : ofMeaning[0]) != null ? _ref : null;
+}
+/** The label a writer stamps beside `status` when it sets a meaning and names no value. */ export function crmLeadStatusLabelFor(picklist, status) {
+    var _ref;
+    var _crmLeadStatusValueFor;
+    return (_ref = (_crmLeadStatusValueFor = crmLeadStatusValueFor(picklist, status)) == null ? void 0 : _crmLeadStatusValueFor.label) != null ? _ref : CRM_LEAD_STATUS_LABELS[status];
+}
+/**
+ * How a lead's status reads: its own `statusLabel` while that is a value of
+ * its `status`'s meaning (as the list spells it), else the meaning's label
+ * by {@link crmLeadStatusLabelFor}. A label the list no longer holds is shown
+ * as stored while nothing contradicts it — a value deleted without moving
+ * every lead off it reads as what the lead was given.
+ */ export function crmLeadStatusLabel(lead, picklist = STANDARD_CRM_LEAD_STATUS_PICKLIST) {
+    const status = crmLeadStatus(lead);
+    const held = normalizeCrmPicklistLabel(lead == null ? void 0 : lead.statusLabel);
+    if (held) {
+        const value = picklistValueByLabel(picklist, held);
+        if ((value == null ? void 0 : value.meaning) === status) return value.label;
+        if (!value) return held;
+    }
+    return crmLeadStatusLabelFor(picklist, status);
+}
+/**
+ * What a write naming a lead status stores (AGL-3512): an ACTIVE value's
+ * label, in any case or spacing, stores its meaning and its label; one of
+ * the meanings themselves (`working`) stores that meaning and the label
+ * {@link crmLeadStatusLabelFor} gives it; the lead's `current` label is
+ * kept even when inactive. `allowed` narrows the meanings this door may
+ * set — every door but a conversion leaves Qualified out — and anything
+ * else is refused naming what the door accepts.
+ */ export function resolveCrmLeadStatusWrite(picklist, requested, options = {}) {
+    var _options_allowed;
+    const allowed = (_options_allowed = options.allowed) != null ? _options_allowed : CRM_LEAD_STATUSES;
+    const text = normalizeCrmPicklistLabel(requested);
+    const refuse = ()=>{
+        const labels = picklist.values.filter((value)=>value.active && allowed.includes(value.meaning)).map((value)=>value.label);
+        return {
+            ok: false,
+            error: `Lead status must be one of: ${labels.join(', ')}.`
+        };
+    };
+    if (!text) return refuse();
+    const value = picklistValueByLabel(picklist, text);
+    const current = options.current ? normalizeCrmPicklistLabel(options.current.statusLabel) : '';
+    const keeps = Boolean(value && current && picklistLabelKeyOf(current) === picklistLabelKeyOf(value.label));
+    if (value && isCrmLeadStatus(value.meaning) && (value.active || keeps)) {
+        return allowed.includes(value.meaning) ? {
+            ok: true,
+            status: value.meaning,
+            statusLabel: value.label
+        } : refuse();
+    }
+    const meaning = text.toLowerCase();
+    if (isCrmLeadStatus(meaning) && allowed.includes(meaning)) {
+        return {
+            ok: true,
+            status: meaning,
+            statusLabel: crmLeadStatusLabelFor(picklist, meaning)
+        };
+    }
+    return refuse();
+}
+const picklistLabelKeyOf = (label)=>normalizeCrmPicklistLabel(label).toLowerCase();
+/**
+ * The values a lead status select offers for a lead holding `current`:
+ * every active value whose meaning `allowed` admits, in the list's order,
+ * then the lead's own value when the list would not otherwise show it.
+ */ export function crmLeadStatusOptions(picklist, allowed = CRM_LEAD_STATUSES, current) {
+    const options = picklist.values.filter((value)=>value.active && allowed.includes(value.meaning)).map((value)=>({
+            label: value.label,
+            status: value.meaning,
+            inactive: false
+        }));
+    if (current) {
+        const label = crmLeadStatusLabel(current, picklist);
+        if (!options.some((option)=>option.label === label)) {
+            options.push({
+                label,
+                status: crmLeadStatus(current),
+                inactive: true
+            });
+        }
+    }
+    return options;
+}
+/*==========================================
+ * SEMANTIC PICKLISTS ON A TASK (AGL-3517).
+ *
+ * Status, Priority and Type keep the task's own `status`, `priority` and
+ * `kind` as the MEANING every query, reminder and automation reads, and
+ * store the org's label beside it. These helpers are the two directions:
+ * what a task shows for its meaning and label, and what a write stores for
+ * a label or a meaning a person, a file or an API caller named.
+ *=========================================*/ /** The label a value of `meaning` reads as: the first active one, else the first at all. */ export function crmPicklistMeaningLabel(picklist, meaning) {
+    var _ref, _held_find;
+    var _this;
+    if (typeof meaning !== 'string' || !meaning) return null;
+    const held = picklist.values.filter((value)=>value.meaning === meaning);
+    return (_ref = (_this = (_held_find = held.find((value)=>value.active)) != null ? _held_find : held[0]) == null ? void 0 : _this.label) != null ? _ref : null;
+}
+/**
+ * What a record shows for a semantic field: its own label when it holds
+ * one, else the first active value of its meaning, else the meaning itself.
+ */ export function crmPicklistShownLabel(picklist, meaning, label) {
+    var _crmPicklistMeaningLabel;
+    const own = normalizeCrmPicklistLabel(label);
+    if (own) return own;
+    return (_crmPicklistMeaningLabel = crmPicklistMeaningLabel(picklist, meaning)) != null ? _crmPicklistMeaningLabel : String(meaning != null ? meaning : '');
+}
+/**
+ * The label a NEW record of `meaning` starts with: the list's default when
+ * it means that, else the first active value that does.
+ */ export function crmPicklistLabelForNew(picklist, meaning) {
+    const fallback = crmPicklistDefaultLabel(picklist);
+    const value = fallback ? crmPicklistValueByLabel(picklist, fallback) : null;
+    return value && value.meaning === meaning ? value.label : crmPicklistMeaningLabel(picklist, meaning);
+}
+/**
+ * A label OR a meaning, as a write names it, resolved against picklist `id`:
+ *
+ *  - an active value's label (any case or spacing) stores that value's
+ *    label and its meaning;
+ *  - the record's `current` label is kept, with its value's meaning, even
+ *    when the value has since been deactivated;
+ *  - one of the definition's meanings (`high`, `done`, `call`) stores that
+ *    meaning with the first active value's label — or the record's current
+ *    label when that already means it;
+ *  - anything else is refused naming the values the list allows.
+ *
+ * `null` answers a blank input: the caller keeps its own default.
+ */ export function resolveCrmSemanticPicklistWrite(id, picklist, input, current) {
+    var _definition_meanings;
+    const text = normalizeCrmPicklistLabel(input);
+    if (!text) return null;
+    const definition = definitionOf(id);
+    const meanings = (_definition_meanings = definition.meanings) != null ? _definition_meanings : [];
+    const held = normalizeCrmPicklistLabel(current);
+    const byLabel = crmPicklistValueByLabel(picklist, text);
+    const keeps = held && held.toLowerCase() === text.toLowerCase();
+    if ((byLabel == null ? void 0 : byLabel.meaning) && (byLabel.active || keeps)) {
+        return {
+            ok: true,
+            meaning: byLabel.meaning,
+            label: keeps ? held : byLabel.label
+        };
+    }
+    const meaning = meanings.find((entry)=>entry === text.toLowerCase());
+    if (meaning) {
+        const heldValue = held ? crmPicklistValueByLabel(picklist, held) : null;
+        return {
+            ok: true,
+            meaning,
+            label: (heldValue == null ? void 0 : heldValue.meaning) === meaning ? held : crmPicklistMeaningLabel(picklist, meaning)
+        };
+    }
+    return {
+        ok: false,
+        error: crmPicklistRefusal(id, picklist)
+    };
+}
+/** The picklist id behind each of a task's semantic fields. */ export const CRM_TASK_PICKLIST_IDS = {
+    status: 'taskStatus',
+    priority: 'taskPriority',
+    type: 'taskType'
+};
+/** The org's three task lists from their stored documents — standard values alone for none. */ export function effectiveCrmTaskPicklists(raw = {}) {
+    return {
+        status: effectiveCrmPicklist(CRM_TASK_PICKLIST_IDS.status, raw.status),
+        priority: effectiveCrmPicklist(CRM_TASK_PICKLIST_IDS.priority, raw.priority),
+        type: effectiveCrmPicklist(CRM_TASK_PICKLIST_IDS.type, raw.type)
+    };
+}
+/** What a task shows for its status, priority and type — see `crmPicklistShownLabel`. */ export function crmTaskPicklistLabels(task, picklists) {
+    var _task_status, _task_priority, _task_kind;
+    return {
+        status: crmPicklistShownLabel(picklists.status, (_task_status = task.status) != null ? _task_status : 'open', task.statusLabel),
+        priority: crmPicklistShownLabel(picklists.priority, (_task_priority = task.priority) != null ? _task_priority : 'normal', task.priorityLabel),
+        type: crmPicklistShownLabel(picklists.type, (_task_kind = task.kind) != null ? _task_kind : 'todo', task.typeLabel)
+    };
+}
+/**
+ * The status a tick or an untick writes: done with the first active done
+ * value's label ("Completed"), or open with the label a new task starts
+ * with ("Not Started").
+ */ export function crmTaskStatusWrite(picklist, done) {
+    return done ? {
+        status: 'done',
+        statusLabel: crmPicklistMeaningLabel(picklist, 'done')
+    } : {
+        status: 'open',
+        statusLabel: crmPicklistLabelForNew(picklist, 'open')
+    };
+}
+/** The labels a new task of these meanings starts with. */ export function crmTaskLabelsForNew(picklists, meanings) {
+    var _meanings_status;
+    return {
+        statusLabel: crmPicklistLabelForNew(picklists.status, (_meanings_status = meanings.status) != null ? _meanings_status : 'open'),
+        priorityLabel: crmPicklistLabelForNew(picklists.priority, meanings.priority),
+        typeLabel: crmPicklistLabelForNew(picklists.type, meanings.kind)
+    };
+}
+/** The name a lead is listed under: the name it carries, else its address. */ export function crmLeadDisplayName(lead) {
+    var _ref, _ref1;
+    const name = String((_ref = lead == null ? void 0 : lead['name']) != null ? _ref : '').trim();
+    return name || String((_ref1 = lead == null ? void 0 : lead['email']) != null ? _ref1 : '').trim();
+}
+/**
+ * A lead's status as the list and the filter should read it.
+ *
+ * `new` for a lead that carries no status at all — every lead captured
+ * before the CRM existed, and every lead the capture door writes today,
+ * because `addHostLead` stamps none. Reading the absence as `new` is what
+ * lets the section open on the leads a site already holds rather than on an
+ * empty list until each one has been touched once. A stored value the union
+ * does not name also reads as `new`: it is a document some other writer
+ * produced, and refusing to list it would hide a person.
+ */ export function crmLeadStatus(lead) {
+    const status = lead == null ? void 0 : lead.status;
+    return isCrmLeadStatus(status) ? status : 'new';
+}
+/** Whether a lead still needs working — see {@link CRM_LEAD_OPEN_STATUSES}. */ export function isCrmLeadOpen(lead) {
+    return CRM_LEAD_OPEN_STATUSES.includes(crmLeadStatus(lead));
+}
+/*==========================================
+ * SAVED VIEWS (AGL-2617) — a list the way one person works it.
+ *
+ * "My open leads in Texas" is a list a rep opens every morning, and it is
+ * three things at once: the filters that pick the people, the columns they
+ * want to see about them, and the order they want them in. A `ContactSegment`
+ * kept the first of those for two dimensions — tags and capture sources —
+ * and nothing kept the rest, so every reload put the reader back at the
+ * whole list. A view keeps all three, for every list in the CRM, under a
+ * name, and is addressable: `?view=<id>` on the section's own URL opens it.
+ *
+ * ## The filters are the LIST'S grammar, not a second one
+ *
+ * A clause here is `{ field, op, value }` — structurally the
+ * `ListFilterRequest` the shared list-filter grammar already speaks, the
+ * request a grid's filter panel produces and the one the query translator
+ * and the in-memory matcher both read. A view stores a list of them and
+ * nothing more, so a view can only ask what the list can already answer,
+ * and a list that gains a filterable field gains it for its views at no
+ * cost. The type is restated here rather than imported because this module
+ * is pure data and the grammar's home is a UI library; the shape is the
+ * contract, and `normalizeCrmViewFilters` is what holds a stored document
+ * to it.
+ *
+ * ## Mine, and shared
+ *
+ * A view is one person's working arrangement until they say otherwise, so
+ * it lists only for its owner; `shared` puts it in front of everyone who
+ * can read the section. Both are stamped `visibleTo` like every CRM row,
+ * because a view is a description of the people it selects and answers to
+ * the same authority they do — a private view is hidden by the LISTING, not
+ * by the rules, and the rules let the creator or an org-wide member change
+ * or remove it.
+ *
+ * ## The default is the reader's, not the view's
+ *
  * Which view a section opens on is a preference of one person for one
  * organization, so it lives on the reader's own profile document beside
  * their notification mutes rather than on the view — a shared view somebody
@@ -2328,11 +3911,17 @@ export function crmEmailStatusKey(record) {
     // A status outside the vocabulary reads as nothing known, as `readEmailState` reads it.
     return isEmailStateStatus(status) ? status : CRM_EMAIL_STATUS_NONE;
 }
-/** A lead's lead source as the list compares it: the picklist's key, `null` for none. */ export const CRM_LEAD_SOURCE_KEY_FIELD = 'leadSourceKey';
-export function crmLeadSourceKey(value) {
+/**
+ * A picklist label as a list query compares it — the key a target's
+ * `keyField` holds beside the label — `null` for none.
+ */ export function crmPicklistKey(value) {
     const key = SEARCH_KEY(normalizeCrmPicklistLabel(value));
     return key || null;
 }
+/** A lead's lead source as the list compares it: the picklist's key, `null` for none. */ export const CRM_LEAD_SOURCE_KEY_FIELD = 'leadSourceKey';
+export function crmLeadSourceKey(value) {
+    return crmPicklistKey(value);
+}
 /** What a lead's search box reads (AGL-3246). */ export const CRM_LEAD_SEARCH_SOURCES = [
     'name',
     'email',
@@ -2362,28 +3951,67 @@ function leadCampaignIds(lead) {
         scopedCampaignIds: scopedSearchTokens(lead['visibleTo'], leadCampaignIds(lead)),
         status: crmLeadStatus(lead),
         leadSourceKey: crmLeadSourceKey(lead['leadSource']),
-        emailStatus: crmEmailStatusKey(lead)
+        emailStatus: crmEmailStatusKey(lead),
+        // The Industry and Rating the Leads list filters by (AGL-3513).
+        industryKey: crmPicklistKey(lead['industry']),
+        ratingKey: crmPicklistKey(lead['rating'])
     });
 }
 /** What a company's search box reads: its name and its domain. */ export const CRM_COMPANY_SEARCH_SOURCES = [
     'name',
     'domain'
 ];
-export function crmCompanyListFields(record) {
+/**
+ * Every field the Companies list queries by: the search tokens, and the
+ * key of each picklist field that names one (AGL-3514) — `null` for none,
+ * so "no value" is a value a query can ask for.
+ */ export function crmCompanyListFields(record) {
     const company = record;
-    return crmSearchFields(company['visibleTo'], CRM_COMPANY_SEARCH_SOURCES.map((field)=>company[field]));
+    return _extends({}, crmSearchFields(company['visibleTo'], CRM_COMPANY_SEARCH_SOURCES.map((field)=>company[field])), {
+        typeKey: crmPicklistKey(company['type']),
+        industryKey: crmPicklistKey(company['industry']),
+        ratingKey: crmPicklistKey(company['rating']),
+        accountSourceKey: crmPicklistKey(company['accountSource'])
+    });
 }
 /**
  * What a deal's search box reads: its title (AGL-3315) — as word prefixes,
  * and as `titleLower`, the whole title's key, which a reader whose access
- * is some sites searches by its start.
+ * is some sites searches by its start. And the keys the Deals list filters
+ * its Type and Lead source by (AGL-3516): each label as the picklist
+ * compares it, `null` for none.
  */ export function crmDealListFields(record) {
     const deal = record;
     return _extends({}, crmSearchFields(deal['visibleTo'], [
         deal['title']
     ]), {
-        titleLower: SEARCH_KEY(typeof deal['title'] === 'string' ? deal['title'] : '')
-    });
+        titleLower: SEARCH_KEY(typeof deal['title'] === 'string' ? deal['title'] : ''),
+        typeKey: crmPicklistKey(deal['type']),
+        leadSourceKey: crmPicklistKey(deal['leadSource'])
+    }, crmDealContactRoleListFields(deal));
+}
+/**
+ * The arrays a deal's contact roles are found by (AGL-3521): every contact
+ * on it — `contactRoleContactIds`, which a contact's page asks
+ * `array-contains` at the organization level, and the same ids behind each
+ * scope token (`scopedContactRoleContactIds`, `host:x~contactId`), which it
+ * asks under a site in the one array clause a query has — and the keys of
+ * the roles they hold, which a rename of a role finds the deals by.
+ */ export function crmDealContactRoleListFields(deal) {
+    const roles = dealContactRolesOf(deal);
+    const contactRoleContactIds = roles.map((row)=>row.contactId);
+    const keys = new Set();
+    for (const row of roles){
+        const key = crmPicklistKey(row.role);
+        if (key) keys.add(key);
+    }
+    return {
+        contactRoleContactIds,
+        scopedContactRoleContactIds: scopedSearchTokens(deal['visibleTo'], contactRoleContactIds),
+        contactRoleKeys: [
+            ...keys
+        ]
+    };
 }
 /** What a task's search box reads: its title. */ export function crmTaskListFields(record) {
     const task = record;
@@ -2403,8 +4031,8 @@ export function crmCompanyListFields(record) {
  *   `{groupId}:{field}`           this holder has one (for "is set")
  *   `*:{field}={value}`, `*:{field}`   any holder's, for the organization level
  *
- * `field` is `owner`, `stage`, `source`, `company`, `tag` or `custom.{key}`,
- * plus two presence-only fields: `orders` for a holder the person has bought
+ * `field` is `owner`, `stage`, `source`, `company`, `tag`, `custom.{key}` or
+ * `leadSource` (AGL-3511), plus two presence-only fields: `orders` for a holder the person has bought
  * from, and `ltv` for one they are worth something to — the per-holder
  * figures a range cannot reach, asked only whether there are any.
  * A text value is keyed lower-cased and single-spaced; a number or a flag
@@ -2455,6 +4083,8 @@ export function crmCompanyListFields(record) {
             if (/^[A-Za-z0-9_-]{1,64}$/.test(key)) add(`custom.${key}`, value);
         }
     }
+    // Keyed as `crmPicklistKey` compares a label, so a rename's rewrite restamps it.
+    add('leadSource', facet['leadSource']);
 }
 /** Every facet key a contact carries — see the block above. */ export function crmContactFacetKeys(record) {
     const facets = record[CONTACT_FACETS_FIELD];
@@ -2523,7 +4153,10 @@ export function crmContactListFields(record) {
         'status',
         'leadSource',
         'emailState',
-        'campaignIds'
+        'campaignIds',
+        // AGL-3513.
+        'industry',
+        'rating'
     ],
     contacts: [
         'visibleTo',
@@ -2534,11 +4167,19 @@ export function crmContactListFields(record) {
     ],
     companies: [
         'visibleTo',
-        ...CRM_COMPANY_SEARCH_SOURCES
+        ...CRM_COMPANY_SEARCH_SOURCES,
+        'type',
+        'industry',
+        'rating',
+        'accountSource'
     ],
     deals: [
         'visibleTo',
-        'title'
+        'title',
+        'type',
+        'leadSource',
+        'contactRoles',
+        'contactId'
     ],
     crmTasks: [
         'visibleTo',