@aglyn/aglyn 1.0.0-beta.143

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

@@ -0,0 +1,1814 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /**
+ * Contacts CRM v2 (AGL-2595): the records that sit BESIDE a contact.
+ *
+ * v1 is one collection — `contacts` — and everything a holder knows about a
+ * person lives in that holder's facet on the shared row. That shape is right
+ * for the person and wrong for everything a sales team keeps AROUND the
+ * person: a company is known by several contacts, a deal moves through
+ * stages on its own clock, a task is due whether or not anybody opens the
+ * contact it hangs off, and an activity log grows past anything a facet
+ * should carry. So each of those is a collection of its own under
+ * `orgs/{orgId}/`, pointing back at the contact by id.
+ *
+ * ## One scope model, not a second one
+ *
+ * Every collection here carries `visibleTo`, the same array `contacts`
+ * carries, and is stamped the same way — {@link crmScopeTokens} is the
+ * contact create path's expression, exported so that no creator computes its
+ * own. The rules gate all six on the contacts predicate (`canReadScopedPeople`,
+ * `data.manage`), because a deal or a call log is a fact about a person and
+ * discloses exactly what the contact row would.
+ *
+ * What these collections do NOT have is the facet map. A contact is shared
+ * across holders because one human is one row; a company, deal or task is
+ * one holder's record from the moment it is created, so `visibleTo` alone
+ * says who may see it and there is nothing to split per holder.
+ *
+ * Pure data module: types, constants and the small helpers every surface
+ * would otherwise write for itself. No Firestore, no React.
+ */ import { _ as _extends } from "@swc/helpers/_/_extends";
+import { consentGroupScope } from "./consent-groups.js";
+import { CONTACT_LIFECYCLE_STAGES, isContactLifecycleStage } from "./crm-kinds.js";
+import { CONTACT_FACETS_FIELD, CONTACT_SOURCE_LABELS, normalizeContactEmail, readContactFacet } from "./contacts.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.
+export * from "./crm-kinds.js";
+/**
+ * The CRM's collections, every one under `orgs/{orgId}/`.
+ *
+ * Named here rather than spelled at each call site because the rules, the
+ * indexes and the console must agree on the string, and the three prefixed
+ * ones are prefixed on purpose: `tasks`, `activities` and `views` are words
+ * the org document will want for something else one day, and a collection
+ * name is persisted in every document path that uses it.
+ */ export const CRM_COLLECTIONS = {
+    companies: 'companies',
+    pipelines: 'pipelines',
+    deals: 'deals',
+    tasks: 'crmTasks',
+    activities: 'crmActivities',
+    contactFields: 'contactFields',
+    views: 'crmViews',
+    emailTemplates: 'crmEmailTemplates'
+};
+/**
+ * The three collections the CRM RECORDS band counts (AGL-2611), in the order
+ * the billing caption lists them. `contacts` is not in `CRM_COLLECTIONS`
+ * because it predates the hub and is addressed through `orgDataCollection`,
+ * so the band's own list has to name all three itself. Tasks, pipelines,
+ * activities and field definitions are deliberately absent: a band that
+ * counted what a rep does every hour would price the team's effort, not the
+ * audience it holds.
+ */ export const CRM_RECORD_COLLECTIONS = [
+    'contacts',
+    CRM_COLLECTIONS.companies,
+    CRM_COLLECTIONS.deals
+];
+/**
+ * What a create says when the records band refused it, on every surface —
+ * the contacts list's alert, the company and deal drawers, the plugin's
+ * create routes and the lead conversion (AGL-2596, widened in AGL-2611).
+ *
+ * One sentence in one place, because a reader who is refused in the drawer
+ * and then reads the list must be told the same thing, and the remedy is the
+ * same wherever the refusal lands: a band refuses only on a plan that puts
+ * no overage rate past it, so "upgrade" is the whole of the answer.
+ */ export const CRM_RECORDS_BAND_FULL_MESSAGE = 'CRM records limit reached — this record was not added. Upgrade in ' + 'Billing to keep collecting.';
+/**
+ * The most logged activities ONE record may carry (AGL-2611) — a contact's,
+ * a company's or a deal's own log, counted on the link the activity was
+ * filed under.
+ *
+ * A platform ceiling and not a plan dimension, in the family of
+ * `WEBHOOK_MAX_PER_HOST` and `NON_PAGE_SCREEN_MAX_PER_HOST`: activities are
+ * not in the records band because they are bounded by human effort, and
+ * this is the bound. Five thousand is a call a day for fourteen years on one
+ * person, so nobody working a real relationship reaches it — what does is
+ * an automation logging on every event, or an import replaying a history,
+ * and either of those past this line is a document cost with no reader.
+ *
+ * Enforced where an activity is written: the console's log dialog, the
+ * `logCrmActivity` automation step and `POST /v1/activities`, each with one
+ * aggregate read on the record's link before the create. The timeline reads
+ * a hundred at a time and is untouched by the number.
+ */ export const CRM_ACTIVITIES_PER_RECORD_CEILING = 5000;
+/**
+ * What every writer says when a record's log is full — the console's log
+ * dialog, the automation step's run history and `POST /v1/activities`.
+ */ export const CRM_ACTIVITY_LOG_FULL_MESSAGE = `This record already has ${CRM_ACTIVITIES_PER_RECORD_CEILING.toLocaleString('en-US')} activities, which is the most one record can carry.`;
+/**
+ * The field the per-record activity ceiling is counted on, or `null` for an
+ * activity that names no record at all.
+ *
+ * The contact leads, then the company, then the deal: an activity logged
+ * from a contact's page carries the company beside it (the automation step
+ * copies the facet's `companyId` onto every record it creates), and a
+ * ceiling counted on the company would let one busy account exhaust every
+ * contact filed under it. The record whose PAGE the log is read on is the
+ * one whose log has the limit. Shared by the client dialog and the two
+ * server writers so they count the same thing.
+ */ export function crmActivityCeilingLink(link) {
+    if (link.contactId) return {
+        field: 'contactId',
+        id: String(link.contactId)
+    };
+    if (link.companyId) return {
+        field: 'companyId',
+        id: String(link.companyId)
+    };
+    if (link.dealId) return {
+        field: 'dealId',
+        id: String(link.dealId)
+    };
+    // Last, because a converted lead's activities carry the contact beside it
+    // and the contact is the record whose page they are read on.
+    if (link.leadId) return {
+        field: 'leadId',
+        id: String(link.leadId)
+    };
+    return null;
+}
+/**
+ * Whether ONE MORE activity fits under `CRM_ACTIVITIES_PER_RECORD_CEILING`.
+ * Both halves of the boundary live here so no writer re-derives `>=`.
+ */ export function crmActivityLogHasRoom(existing) {
+    const count = Number(existing);
+    return !(Number.isFinite(count) && count >= CRM_ACTIVITIES_PER_RECORD_CEILING);
+}
+/** How a lifecycle stage reads on screen — typed so a stage cannot ship unlabeled. */ export const CONTACT_LIFECYCLE_STAGE_LABELS = {
+    subscriber: 'Subscriber',
+    lead: 'Lead',
+    'marketing-qualified': 'Marketing qualified',
+    'sales-qualified': 'Sales qualified',
+    opportunity: 'Opportunity',
+    customer: 'Customer',
+    evangelist: 'Evangelist',
+    other: 'Other'
+};
+/**
+ * The stage a person is in once a capture has happened that implies at least
+ * `floor` (AGL-2612).
+ *
+ * The one ordering rule every capture door shares: a door names the EARLIEST
+ * stage that describes what just happened — a form submission is a lead, a
+ * newsletter opt-in is a subscriber, a purchase is a customer — and the
+ * result is that stage for a person who had none or an earlier one, and the
+ * stage they already had otherwise. "Never downgrades" is the whole contract:
+ * a customer who fills in a contact form is still a customer, and `other` —
+ * the deliberate stage a business picked for a funnel step none of the names
+ * fit — sits after `customer` in the list precisely so no capture can
+ * overwrite it. A stored value that is not a stage at all reads as absent,
+ * because a capture door is not the place to preserve a typo.
+ *
+ * With no floor the answer is the current stage as it stands, or `undefined`
+ * for one that is absent or unusable — so a writer can apply this
+ * unconditionally and write only what comes back.
+ */ export function advanceContactLifecycleStage(current, floor) {
+    const held = isContactLifecycleStage(current) ? current : undefined;
+    if (!floor) return held;
+    if (!held) return floor;
+    const order = CONTACT_LIFECYCLE_STAGES;
+    return order.indexOf(held) < order.indexOf(floor) ? floor : held;
+}
+/**
+ * The stage a person is in once they have BOUGHT something (AGL-2596).
+ *
+ * `customer` when they had no stage or an earlier one; whatever they already
+ * had otherwise — {@link advanceContactLifecycleStage} with `customer` as the
+ * floor, kept under its own name because "after a purchase" is the question
+ * the order paths and the reports ask.
+ */ export function contactLifecycleStageAfterPurchase(current) {
+    var _advanceContactLifecycleStage;
+    return (_advanceContactLifecycleStage = advanceContactLifecycleStage(current, 'customer')) != null ? _advanceContactLifecycleStage : 'customer';
+}
+/** 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.
+ *
+ * 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',
+        order: 0,
+        probability: 10,
+        kind: 'open'
+    },
+    {
+        id: 'contact-made',
+        name: 'Contact made',
+        order: 1,
+        probability: 20,
+        kind: 'open'
+    },
+    {
+        id: 'proposal-sent',
+        name: 'Proposal sent',
+        order: 2,
+        probability: 40,
+        kind: 'open'
+    },
+    {
+        id: 'negotiation',
+        name: 'Negotiation',
+        order: 3,
+        probability: 60,
+        kind: 'open'
+    },
+    {
+        id: 'won',
+        name: 'Won',
+        order: 4,
+        probability: 100,
+        kind: 'won'
+    },
+    {
+        id: 'lost',
+        name: 'Lost',
+        order: 5,
+        probability: 0,
+        kind: 'lost'
+    }
+];
+/** 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;
+export const CRM_TASK_KIND_LABELS = {
+    call: 'Call',
+    email: 'Email',
+    meeting: 'Meeting',
+    todo: 'To-do'
+};
+/** How an activity kind reads on screen — typed so a kind cannot ship unlabeled. */ export const CRM_ACTIVITY_KIND_LABELS = {
+    call: 'Call',
+    email: 'Email',
+    meeting: 'Meeting',
+    note: 'Note',
+    other: 'Other'
+};
+/**
+ * Whether a kind takes an outcome and a duration.
+ *
+ * A call and a meeting are conversations: they end somewhere ("left a
+ * voicemail", "agreed to a trial") and they take a measurable amount of
+ * time, and both are what a manager reading the log wants to know. An email
+ * has neither in any useful sense, a note is not an event at all, and
+ * `other` is unknowable — so the dialog hides the two fields for those
+ * rather than offering boxes that mean nothing.
+ */ export function activityKindHasOutcome(kind) {
+    return kind === 'call' || kind === 'meeting';
+}
+/**
+ * Where a one-to-one email got to (AGL-2615), in the order it normally
+ * happens — the vocabulary the delivery webhook maps its events onto an
+ * `email` activity in, and the chip the timeline shows beside the entry.
+ *
+ * The first four are a progression: a message is sent, then delivered, then
+ * opened, then clicked, and a later state implies the earlier ones. The last
+ * two are terminal failures. A message the mailbox provider bounced or that
+ * the recipient reported is never "opened" in any sense the timeline should
+ * report, whatever a tracking pixel says afterwards.
+ */ export const CRM_EMAIL_DELIVERY_STATES = [
+    'sent',
+    'delivered',
+    'opened',
+    'clicked',
+    'bounced',
+    'complained'
+];
+/** How a delivery state reads on the chip — typed so a state cannot ship unlabeled. */ export const CRM_EMAIL_DELIVERY_STATE_LABELS = {
+    sent: 'Sent',
+    delivered: 'Delivered',
+    opened: 'Opened',
+    clicked: 'Clicked',
+    bounced: 'Bounced',
+    complained: 'Marked as spam'
+};
+export function isCrmEmailDeliveryState(value) {
+    return typeof value === 'string' && CRM_EMAIL_DELIVERY_STATES.includes(value);
+}
+/** The two states that mean the message did not land. */ export function isCrmEmailDeliveryFailure(state) {
+    return state === 'bounced' || state === 'complained';
+}
+/**
+ * The rank the webhook advances by. Higher wins; a failure outranks every
+ * progression state, and a complaint outranks a bounce because it is the
+ * one a sender is scored on.
+ */ const CRM_EMAIL_DELIVERY_RANK = {
+    sent: 1,
+    delivered: 2,
+    opened: 3,
+    clicked: 4,
+    bounced: 5,
+    complained: 6
+};
+/**
+ * The state an activity holds after one more delivery event, from the state
+ * it held before.
+ *
+ * MONOTONIC. Provider events arrive at least once and in no promised order
+ * — an `opened` can reach the webhook before the `delivered` it implies, and
+ * a replay can hand back yesterday's `delivered` after today's `clicked` —
+ * so the row keeps whichever state is further along, and an event that says
+ * less than the row already knows changes nothing. A stored value the
+ * vocabulary does not name reads as nothing, so the incoming event stands.
+ */ export function nextCrmEmailDeliveryState(current, incoming) {
+    if (!isCrmEmailDeliveryState(current)) return incoming;
+    return CRM_EMAIL_DELIVERY_RANK[incoming] > CRM_EMAIL_DELIVERY_RANK[current] ? incoming : current;
+}
+/** The most a one-to-one email's subject may hold. */ export const CRM_EMAIL_SUBJECT_MAX = 200;
+/** The most a one-to-one email's body may hold — a letter, not a document. */ export const CRM_EMAIL_BODY_MAX = 10000;
+/**
+ * The `context` a one-to-one email is sent under, which `sendEmail` stamps
+ * as a provider tag on the message and the delivery log files it by.
+ */ export const CRM_EMAIL_CONTEXT = 'crm';
+/** The provider tag naming the activity row a one-to-one email belongs to. */ export const CRM_EMAIL_ACTIVITY_TAG = 'activityId';
+/** The provider tag naming the org whose `crmActivities` holds that row. */ export const CRM_EMAIL_ORG_TAG = 'orgId';
+/** What a provider tag value may be — anything else fails the whole send. */ const PROVIDER_TAG_VALUE = /^[A-Za-z0-9_-]{1,256}$/;
+/**
+ * The tags a one-to-one email carries so the delivery webhook can find its
+ * activity row (AGL-2615): the org, the activity, and the site for the
+ * per-site suppression list a bounce lands on.
+ *
+ * Every value is checked against the provider's alphabet rather than
+ * trusted, for the reason `contextTag` gives — a value the provider rejects
+ * fails the send, and a failed send is worse than an untracked one. The
+ * org and the activity are the pair the webhook needs, so an unusable
+ * value for EITHER yields no tags at all: a tag set that named a row it
+ * could not locate would be a promise the timeline cannot keep. The site
+ * is stamped when it can be and dropped alone when it cannot.
+ */ export function crmEmailDeliveryTags(input) {
+    var _input_orgId, _input_activityId, _input_hostId;
+    const orgId = String((_input_orgId = input.orgId) != null ? _input_orgId : '');
+    const activityId = String((_input_activityId = input.activityId) != null ? _input_activityId : '');
+    const hostId = String((_input_hostId = input.hostId) != null ? _input_hostId : '');
+    if (!PROVIDER_TAG_VALUE.test(orgId) || !PROVIDER_TAG_VALUE.test(activityId)) {
+        return [];
+    }
+    return [
+        {
+            name: CRM_EMAIL_ORG_TAG,
+            value: orgId
+        },
+        {
+            name: CRM_EMAIL_ACTIVITY_TAG,
+            value: activityId
+        },
+        ...PROVIDER_TAG_VALUE.test(hostId) ? [
+            {
+                name: 'hostId',
+                value: hostId
+            }
+        ] : []
+    ];
+}
+/**
+ * The activity row a sent one-to-one email is logged as (AGL-2615).
+ *
+ * ONE builder for the two writers — the console's send route and the
+ * `sendEmail` automation step — so a message a rep wrote and a message a
+ * flow sent are the same kind of entry on the timeline: `kind: 'email'`,
+ * outbound, starting at `sent` for the delivery webhook to advance. A
+ * writer that assembled its own would be the one whose rows the chip did
+ * not know how to read. Timestamps are the writer's: a server stamps
+ * `serverTimestamp()` and this module has no Firestore.
+ */ export function buildCrmEmailActivity(input) {
+    var _input_subject, _input_body;
+    const { link } = input;
+    return _extends({
+        kind: 'email',
+        subject: String((_input_subject = input.subject) != null ? _input_subject : '').slice(0, CRM_EMAIL_SUBJECT_MAX),
+        body: String((_input_body = input.body) != null ? _input_body : '').slice(0, CRM_EMAIL_BODY_MAX),
+        to: input.to,
+        direction: 'outbound',
+        deliveryState: 'sent',
+        deliveryAtMs: input.atMs,
+        atMs: input.atMs,
+        byUid: input.byUid
+    }, input.byName ? {
+        byName: input.byName
+    } : {}, input.sourceActionId ? {
+        sourceActionId: input.sourceActionId
+    } : {}, link.contactId ? {
+        contactId: String(link.contactId)
+    } : {}, link.companyId ? {
+        companyId: String(link.companyId)
+    } : {}, link.dealId ? {
+        dealId: String(link.dealId)
+    } : {}, link.leadId ? {
+        leadId: String(link.leadId)
+    } : {}, {
+        hostId: input.hostId,
+        visibleTo: [
+            ...input.visibleTo
+        ]
+    });
+}
+/**
+ * What became of one campaign email, as the words a timeline row prints
+ * after the email's name: `sent · delivered · opened ×2 · clicked`.
+ *
+ * In lifecycle order, and only the states that happened. `sent` is always
+ * first because the row exists; the counts appear only past one, because
+ * "opened ×1" says nothing "opened" does not. A bounce or a complaint is
+ * printed where it falls, after whatever succeeded before it — a message
+ * delivered and then complained about reads as both, which is what
+ * happened.
+ */ export function campaignEmailSummary(email) {
+    const counted = (word, count)=>count > 1 ? `${word} ×${count}` : word;
+    const parts = [
+        'sent'
+    ];
+    if (email.deliveredAtMs) parts.push('delivered');
+    if (email.openedAtMs) parts.push(counted('opened', email.openCount));
+    if (email.clickedAtMs) parts.push(counted('clicked', email.clickCount));
+    if (email.bouncedAtMs) parts.push('bounced');
+    if (email.complainedAtMs) parts.push('marked as spam');
+    return parts;
+}
+/** A time that can be sorted on; anything that is not one sinks to the bottom. */ const sortableMs = (value)=>typeof value === 'number' && Number.isFinite(value) ? value : Number.NEGATIVE_INFINITY;
+/**
+ * ONE newest-first stream from a contact's two histories.
+ *
+ * The captured interactions live on the contact's facet and the logged
+ * activities in their own collection, and a page showing them as two lists
+ * asks the reader to do the interleaving in their head — "did the call come
+ * before or after the order?" is the question a timeline exists to answer.
+ *
+ * STABLE on purpose. The sort is on `atMs` alone, and at a tie the captured
+ * entries keep their place ahead of the logged ones, each in the order it
+ * arrived: a facet's interactions are already newest-first and a listener's
+ * rows are already ordered, so the merge must not reshuffle what its inputs
+ * settled. An entry with no usable time goes LAST, never first — a row that
+ * cannot say when it happened must not read as the most recent thing.
+ *
+ * The key is what a list renders by. A captured interaction has no id of its
+ * own, so its key is built from what it does carry; a logged activity's is
+ * its document id; a campaign email's is the provider's message id.
+ *
+ * A campaign email is placed at the instant it was SENT, not at its latest
+ * open. The row tells the whole story of that message in one line, and a
+ * message that moved up the stream every time its reader re-opened it would
+ * be a timeline that reorders itself under the reader.
+ */ export function mergeContactTimeline(interactions, activities, campaignEmails) {
+    const entries = [
+        ...(interactions != null ? interactions : []).map((interaction, index)=>{
+            var _interaction_refId;
+            return {
+                kind: 'captured',
+                key: `captured:${interaction.type}:${(_interaction_refId = interaction.refId) != null ? _interaction_refId : index}:${interaction.atMs}:${index}`,
+                atMs: interaction.atMs,
+                interaction
+            };
+        }),
+        ...(activities != null ? activities : []).map((activity)=>({
+                kind: 'logged',
+                key: `logged:${activity.$id}`,
+                atMs: activity.atMs,
+                activity
+            })),
+        ...(campaignEmails != null ? campaignEmails : []).map((email)=>({
+                kind: 'campaign',
+                key: `campaign:${email.messageId}`,
+                atMs: email.sentAtMs,
+                email
+            }))
+    ];
+    // `Array.prototype.sort` is stable, which is what keeps the tie rule above
+    // true without a secondary comparison on the entry's kind or position.
+    return entries.sort((a, b)=>sortableMs(b.atMs) - sortableMs(a.atMs));
+}
+/**
+ * Which record an activity is ABOUT, for a surface that links to it, or
+ * `null` when it was filed against nothing.
+ *
+ * A contact outranks a deal outranks a company. An activity can name all
+ * three — a call with a person about a deal at their company — and the
+ * contact is the one a reader means when they ask "who was this with"; the
+ * deal is next because it is the thing with a clock on it; the company is
+ * the widest and so the last resort.
+ */ export function crmActivityRecordLink(activity) {
+    if (activity.contactId) return {
+        record: 'contact',
+        id: activity.contactId
+    };
+    if (activity.dealId) return {
+        record: 'deal',
+        id: activity.dealId
+    };
+    if (activity.companyId) return {
+        record: 'company',
+        id: activity.companyId
+    };
+    // A lead is the narrowest: once converted, the contact it became leads.
+    if (activity.leadId) return {
+        record: 'lead',
+        id: activity.leadId
+    };
+    return null;
+}
+const MINUTE_MS = 60000;
+const HOUR_MS = 60 * MINUTE_MS;
+const DAY_MS = 24 * HOUR_MS;
+/**
+ * How long ago something happened, in the words a list row uses.
+ *
+ * Coarse on purpose. A row reads "3 days ago" and carries the full timestamp
+ * in its tooltip; the sentence exists so that a reader scanning a log can
+ * tell this week from last month without parsing dates. Past a week the
+ * relative form stops helping — "412 days ago" is a date the reader has to
+ * compute — so it becomes one. A time AHEAD of now is a date too: a call
+ * logged for tomorrow is a scheduling mistake the page should show plainly
+ * rather than dress as "in 14 hours". An unusable time reads as nothing.
+ *
+ * English rather than `Intl.RelativeTimeFormat` because the console is
+ * English-only, and the thresholds are what the spec pins.
+ */ export function activityTimeLabel(atMs, nowMs) {
+    if (!Number.isFinite(atMs) || !Number.isFinite(nowMs)) return '';
+    const elapsed = nowMs - atMs;
+    if (elapsed < -MINUTE_MS || elapsed >= 7 * DAY_MS) {
+        return new Date(atMs).toLocaleDateString();
+    }
+    if (elapsed < MINUTE_MS) return 'just now';
+    if (elapsed < HOUR_MS) return `${Math.floor(elapsed / MINUTE_MS)} min ago`;
+    if (elapsed < DAY_MS) return `${Math.floor(elapsed / HOUR_MS)} h ago`;
+    if (elapsed < 2 * DAY_MS) return 'yesterday';
+    return `${Math.floor(elapsed / DAY_MS)} days ago`;
+}
+/**
+ * The records a custom field may describe, in the order the Fields
+ * section tabs them (AGL-2661).
+ */ export const CRM_FIELD_OBJECTS = [
+    'contact',
+    'company',
+    'deal'
+];
+/** How each object reads on the Fields section's tabs and in a refusal. */ export const CRM_FIELD_OBJECT_LABELS = {
+    contact: 'Contacts',
+    company: 'Companies',
+    deal: 'Deals'
+};
+export function isCrmFieldObject(value) {
+    return typeof value === 'string' && CRM_FIELD_OBJECTS.includes(value);
+}
+/**
+ * Which record a definition describes — `contact` when the document says
+ * nothing, or says something no reader understands.
+ *
+ * The one reader of {@link ContactFieldDefinition.object}. A stored value
+ * outside the list is read as `contact` rather than refused, for the
+ * reason an absent one is: the definition predates the field, or was
+ * written by something that never learned it, and either way the values
+ * under its key sit on contacts.
+ */ export function fieldDefinitionObject(definition) {
+    return isCrmFieldObject(definition == null ? void 0 : definition.object) ? definition.object : 'contact';
+}
+/** What a stored field key must look like — a letter, then up to 39 of `[a-z0-9_]`. */ export const CONTACT_FIELD_KEY_PATTERN = /^[a-z][a-z0-9_]{0,39}$/;
+/**
+ * A typed label, as the key it would be stored under, or `null` when nothing
+ * usable survives.
+ *
+ * Lowercased and snake-cased rather than refused, because the key is derived
+ * from the label a merchant typed ("Annual revenue" → `annual_revenue`) and
+ * they should not have to learn the grammar. Anything outside `[a-z0-9_]` is
+ * dropped after separators become underscores, runs collapse, and a leading
+ * run of digits or underscores goes — a key has to start with a letter so it
+ * can never collide with an array index or read as a number in a filter.
+ */ export function normalizeContactFieldKey(input) {
+    const key = String(input != null ? input : '').trim().toLowerCase().replace(/[\s-]+/g, '_').replace(/[^a-z0-9_]/g, '').replace(/_+/g, '_').replace(/^[^a-z]+/, '').replace(/_+$/, '').slice(0, 40);
+    return CONTACT_FIELD_KEY_PATTERN.test(key) ? key : null;
+}
+/** The stage a deal is in, or `null` when the pipeline no longer has it. */ export function dealStageById(pipeline, stageId) {
+    var _ref;
+    var _pipeline_stages;
+    return (_ref = pipeline == null ? void 0 : (_pipeline_stages = pipeline.stages) == null ? void 0 : _pipeline_stages.find((stage)=>stage.id === stageId)) != null ? _ref : null;
+}
+/**
+ * What a deal is worth to a forecast, in cents.
+ *
+ * STATUS wins over the stage. A deal marked won is worth its full amount
+ * whatever stage it happens to sit in, and a lost one is worth nothing —
+ * the stage's probability is the odds of an OPEN deal, and applying it to a
+ * closed one would forecast a sale that has already happened as a fraction
+ * 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.
+ */ export function weightedDealAmountCents(deal, stage) {
+    var _deal_amountCents;
+    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));
+    return Math.round(amount * probability / 100);
+}
+/** Whether a deal's amount is derived — it has at least one line item. */ export function dealHasLineItems(deal) {
+    return Array.isArray(deal == null ? void 0 : deal.lineItems) && deal.lineItems.length > 0;
+}
+/**
+ * What a set of line items adds up to, in cents — the amount a deal with
+ * line items stores. Whole cents, never negative: a line's quantity and
+ * unit amount have both been through `readDealLineItems`, but a stored
+ * document from an older writer is trusted no further than that.
+ */ export function lineItemsTotalCents(items) {
+    let total = 0;
+    for (const item of items != null ? items : []){
+        const quantity = Math.max(0, Math.round(Number(item.quantity) || 0));
+        const unit = Math.max(0, Math.round(Number(item.unitAmountCents) || 0));
+        total += quantity * unit;
+    }
+    return total;
+}
+/**
+ * Line items as a client typed or sent them, validated into the stored
+ * shape, or the one reason they were refused.
+ *
+ * The one reader for both writers — the products card on a deal's page
+ * and `POST`/`PATCH /v1/deals` — so a line the console accepts is a line
+ * the API accepts and the other way round. The rules: at most
+ * {@link DEAL_LINE_ITEMS_MAX} lines; every line a name, a whole quantity
+ * of one or more, a whole unit amount of zero or more; every line in the
+ * DEAL's currency (`currency`), which a line may omit and may not
+ * contradict. An empty list is valid and means "no line items" — the
+ * amount goes back to being typed.
+ */ export function readDealLineItems(input, currency) {
+    if (input === undefined || input === null) return {
+        items: []
+    };
+    if (!Array.isArray(input)) return {
+        error: 'Line items must be a list'
+    };
+    if (input.length > DEAL_LINE_ITEMS_MAX) {
+        return {
+            error: `A deal carries at most ${DEAL_LINE_ITEMS_MAX} line items`
+        };
+    }
+    const dealCurrency = String(currency || 'usd').trim().toLowerCase();
+    const items = [];
+    for (const [index, raw] of input.entries()){
+        var _line_name;
+        const at = `Line ${index + 1}`;
+        if (!raw || typeof raw !== 'object' || Array.isArray(raw)) {
+            return {
+                error: `${at} must be an object`
+            };
+        }
+        const line = raw;
+        const name = String((_line_name = line.name) != null ? _line_name : '').trim().slice(0, DEAL_LINE_ITEM_NAME_MAX);
+        if (!name) return {
+            error: `${at} needs a name`
+        };
+        const quantity = Number(line.quantity);
+        if (!Number.isInteger(quantity) || quantity < 1 || quantity > DEAL_LINE_ITEM_QUANTITY_MAX) {
+            return {
+                error: `${at}: the quantity must be a whole number from 1 to ${DEAL_LINE_ITEM_QUANTITY_MAX.toLocaleString()}`
+            };
+        }
+        const unitAmountCents = Number(line.unitAmountCents);
+        if (!Number.isInteger(unitAmountCents) || unitAmountCents < 0) {
+            return {
+                error: `${at}: the unit amount must be a whole number of cents, 0 or more`
+            };
+        }
+        const lineCurrency = line.currency === undefined || line.currency === null || line.currency === '' ? dealCurrency : String(line.currency).trim().toLowerCase();
+        if (lineCurrency !== dealCurrency) {
+            return {
+                error: `${at} is in ${lineCurrency.toUpperCase()}; every line must be in the deal's currency, ${dealCurrency.toUpperCase()}`
+            };
+        }
+        const productId = typeof line.productId === 'string' && line.productId.trim() ? line.productId.trim().slice(0, 200) : undefined;
+        items.push(_extends({}, productId ? {
+            productId
+        } : {}, {
+            name,
+            quantity,
+            unitAmountCents,
+            currency: dealCurrency
+        }));
+    }
+    return {
+        items
+    };
+}
+/**
+ * Where a task stands against the clock.
+ *
+ * `today` is decided on the LOCAL calendar day and beats `overdue`: a task
+ * due at nine this morning is today's work until midnight, not something the
+ * list should paint red at 9:01. Overdue is yesterday or earlier. `done`
+ * comes first because a completed task's due date is history whichever side
+ * of now it fell on.
+ */ export function taskDueState(task, nowMs) {
+    if (task.status === 'done') return 'done';
+    const dueAtMs = task.dueAtMs;
+    if (typeof dueAtMs !== 'number' || !Number.isFinite(dueAtMs)) return 'none';
+    const due = new Date(dueAtMs);
+    const now = new Date(nowMs);
+    const sameDay = due.getFullYear() === now.getFullYear() && due.getMonth() === now.getMonth() && due.getDate() === now.getDate();
+    if (sameDay) return 'today';
+    return dueAtMs < nowMs ? 'overdue' : 'upcoming';
+}
+/**
+ * A hostname label: `[a-z0-9-]`, not starting or ending with a hyphen, at
+ * most 63 characters — RFC 1123 as far as a company domain needs it.
+ */ const DOMAIN_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+/**
+ * A typed or pasted domain, reduced to the bare lowercase hostname a company
+ * is keyed by, or `null` when what is left is not one.
+ *
+ * Strips what people paste along with a domain — the protocol, a `www.`, a
+ * path, a query, a port — because the value is a KEY: two contacts at
+ * `https://www.acme.com/about` and `acme.com` work for one company, and the
+ * match is only findable if both reduce to the same string. The last label
+ * has to be letters because a company's domain has a TLD; a bare IP address
+ * or a single word is not one and answers `null` rather than being stored as
+ * something a later match will never hit.
+ */ export function normalizeCompanyDomain(input) {
+    let value = String(input != null ? input : '').trim().toLowerCase();
+    if (!value) return null;
+    value = value.replace(/^[a-z][a-z0-9+.-]*:\/\//, '');
+    value = value.replace(/^www\./, '');
+    value = value.split(/[/?#]/, 1)[0];
+    value = value.split(':', 1)[0];
+    value = value.replace(/\.+$/, '');
+    if (!value || value.length > 253) return null;
+    const labels = value.split('.');
+    if (labels.length < 2) return null;
+    if (!labels.every((label)=>DOMAIN_LABEL.test(label))) return null;
+    if (!/^[a-z]{2,}$/.test(labels[labels.length - 1])) return null;
+    return value;
+}
+/** The longest website URL a company stores. */ const COMPANY_WEBSITE_MAX = 500;
+/**
+ * The typed website, as a URL; `''` for a blank; `null` when it cannot be
+ * one.
+ *
+ * People type `acme.com` where a URL is asked for, and refusing that is
+ * pedantry — it becomes `https://acme.com`. What IS refused is anything the
+ * URL parser cannot read or a scheme other than http(s): a `javascript:` link
+ * on a record that renders as an anchor is not a website. One function for
+ * the company drawer and the companies import, so a website typed and a
+ * website imported are stored the same way.
+ */ export function normalizeCompanyWebsite(input) {
+    const raw = String(input != null ? input : '').trim();
+    if (!raw) return '';
+    const candidate = /^[a-z][a-z0-9+.-]*:\/\//i.test(raw) ? raw : `https://${raw}`;
+    try {
+        const url = new URL(candidate);
+        if (url.protocol !== 'http:' && url.protocol !== 'https:') return null;
+        return url.href.length > COMPANY_WEBSITE_MAX ? null : url.href;
+    } catch (unused) {
+        return 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
+ * hands its subscribers.
+ *
+ * Auto-associating a contact with a company by email domain is the whole
+ * reason {@link companyDomainForEmail} exists, and it is wrong for every
+ * address at a public mailbox: `gmail.com` is not a company, and a rule
+ * that treated it as one would file half of a consumer list under a single
+ * phantom account. It is also the fact a cold email has to know — an
+ * address here is a person's own, not their work address — which is why the
+ * list is exported with {@link isPublicMailboxDomain}: a second list kept
+ * for that question would drift from this one.
+ *
+ * Exact domains, not suffixes: a subscriber's regional host (`nc.rr.com`)
+ * is not listed, and neither is a company that happens to end in `mail.com`.
+ */ export const PUBLIC_MAILBOX_DOMAINS = new Set([
+    // Google, Yahoo, Microsoft, Apple, AOL.
+    'gmail.com',
+    'googlemail.com',
+    'yahoo.com',
+    'yahoo.co.uk',
+    'yahoo.ca',
+    'yahoo.com.au',
+    'yahoo.co.in',
+    'yahoo.fr',
+    'yahoo.de',
+    'ymail.com',
+    'rocketmail.com',
+    'hotmail.com',
+    'hotmail.co.uk',
+    'hotmail.fr',
+    'hotmail.de',
+    'hotmail.it',
+    'outlook.com',
+    'live.com',
+    'live.co.uk',
+    'live.ca',
+    'msn.com',
+    'icloud.com',
+    'me.com',
+    'mac.com',
+    'aol.com',
+    'aim.com',
+    // Independent and privacy-first providers.
+    'proton.me',
+    'protonmail.com',
+    'protonmail.ch',
+    'pm.me',
+    'tutanota.com',
+    'tuta.io',
+    'hushmail.com',
+    'gmx.com',
+    'gmx.net',
+    'gmx.de',
+    'web.de',
+    'mail.com',
+    'yandex.com',
+    'yandex.ru',
+    'zoho.com',
+    'zohomail.com',
+    'fastmail.com',
+    'hey.com',
+    // The largest consumer providers outside the US and Europe.
+    'qq.com',
+    '163.com',
+    '126.com',
+    'sina.com',
+    'naver.com',
+    'hanmail.net',
+    'rediffmail.com',
+    // US internet providers' subscriber mailboxes.
+    'comcast.net',
+    'att.net',
+    'sbcglobal.net',
+    'bellsouth.net',
+    'pacbell.net',
+    'verizon.net',
+    'cox.net',
+    'charter.net',
+    'earthlink.net',
+    'optonline.net',
+    'frontier.com',
+    'windstream.net',
+    'centurylink.net',
+    'juno.com',
+    'netzero.net',
+    // Subscriber mailboxes at the largest providers in Canada, the UK, France,
+    // Germany, Italy and Australia.
+    'shaw.ca',
+    'sympatico.ca',
+    'btinternet.com',
+    'sky.com',
+    'virginmedia.com',
+    'orange.fr',
+    'free.fr',
+    'laposte.net',
+    't-online.de',
+    'libero.it',
+    'bigpond.com'
+]);
+/**
+ * Whether a domain — or the domain of an address — is one of the
+ * {@link PUBLIC_MAILBOX_DOMAINS}. Read the way a company domain is, so case,
+ * a trailing dot and a pasted `www.` do not hide one.
+ */ export function isPublicMailboxDomain(domainOrEmail) {
+    const value = String(domainOrEmail != null ? domainOrEmail : '').trim();
+    const domain = normalizeCompanyDomain(value.slice(value.lastIndexOf('@') + 1));
+    return domain !== null && PUBLIC_MAILBOX_DOMAINS.has(domain);
+}
+/**
+ * The company domain an email address implies, or `null` when it implies
+ * none — a malformed address, or one at a public mailbox provider.
+ */ export function companyDomainForEmail(email) {
+    const value = String(email != null ? email : '').trim().toLowerCase();
+    const at = value.lastIndexOf('@');
+    if (at < 1 || at === value.length - 1) return null;
+    if (/[\s@]/.test(value.slice(0, at))) return null;
+    const domain = normalizeCompanyDomain(value.slice(at + 1));
+    if (!domain || PUBLIC_MAILBOX_DOMAINS.has(domain)) return null;
+    return domain;
+}
+/**
+ * The name a company minted from a domain starts with: the first label with
+ * a capital — `acme.com` → `Acme`, `initech.co.uk` → `Initech`.
+ *
+ * A starting point and not a claim about what the business is called: the
+ * lead-convert dialog offers it for editing, and a company the capture door
+ * creates on its own carries it until somebody renames the record. The
+ * domain itself would be an honest name too, but a list of companies that
+ * reads `acme.com`, `globex.example` looks like a list of websites, and the
+ * domain is on the row beside the name anyway.
+ */ export function companyNameForDomain(domain) {
+    const label = domain.split('.')[0] || domain;
+    return label.charAt(0).toUpperCase() + label.slice(1);
+}
+/*==========================================
+ * THE CONTACT–COMPANY LINK (AGL-2597, AGL-2613).
+ *
+ * The association proper is `facets.{groupId}.companyId` — one company per
+ * holder, inside that holder's facet like the notes and the tags, and for
+ * the same reason: which account a person belongs to is one business's
+ * knowledge of them. But a facet path is per group, and Firestore cannot
+ * answer "every contact whose facet, whichever group's, names company X" —
+ * a `where` needs one field path, and the group id is part of the path. So
+ * the facet is MIRRORED into a top-level array an `array-contains` can
+ * query, and the company carries a COUNT of the contacts whose mirror names
+ * it, so a list of companies can say how many people are at each without
+ * reading a person.
+ *
+ * Three fields, kept in step by ONE planner. Every writer — the picker on a
+ * contact's page, the company page's link control, the bulk bar, the server
+ * doors that link on capture — asks {@link planContactCompanyLink} what
+ * changes and applies the answer with its own SDK's sentinels. None of them
+ * decides for itself whether the old id leaves the mirror, which is the rule
+ * a second copy would get wrong: another business filing the same person
+ * under the same account is THEIR link, and this holder letting go must not
+ * take it away.
+ *=========================================*/ /**
+ * The top-level field on a CONTACT naming every company it is linked to.
+ *
+ * It carries the union of every holder's link, so removing an id from it is
+ * only correct when no other holder's facet still names that id — the rule
+ * the planner enforces, and the reason nothing writes this field without
+ * going through it. The facet is the truth and this is its index: a reader
+ * answering "which company is this person at" reads the facet; only a QUERY
+ * reads this.
+ */ export const CONTACT_COMPANY_IDS_FIELD = 'companyIds';
+/**
+ * The field on a COMPANY counting the contacts whose mirror names it.
+ *
+ * Denormalized because the honest figure is an aggregate over every contact
+ * in the org, which a list of two hundred companies cannot afford to take
+ * per row. Moved by `increment` in the same batch as the link that changes
+ * it, so the two cannot disagree by a failed second write; a company's own
+ * page still takes the live aggregate, which is what corrects a count that
+ * predates the counter.
+ */ export const COMPANY_CONTACTS_COUNT_FIELD = 'contactsCount';
+/** The link state of a stored contact, read for one holder. */ export function readContactCompanyLink(contact, groupId) {
+    var _readContactFacet_companyId;
+    const document = contact != null ? contact : {};
+    const facets = document[CONTACT_FACETS_FIELD];
+    const heldElsewhere = new Set();
+    if (facets && typeof facets === 'object' && !Array.isArray(facets)) {
+        for (const [holder, facet] of Object.entries(facets)){
+            if (holder === groupId) continue;
+            const named = facet && typeof facet === 'object' && !Array.isArray(facet) ? facet['companyId'] : undefined;
+            if (typeof named === 'string' && named) heldElsewhere.add(named);
+        }
+    }
+    const mirror = document[CONTACT_COMPANY_IDS_FIELD];
+    return {
+        companyId: (_readContactFacet_companyId = readContactFacet(document, groupId).companyId) != null ? _readContactFacet_companyId : null,
+        companyIds: Array.isArray(mirror) ? mirror.filter((id)=>typeof id === 'string' && !!id) : [],
+        heldElsewhere: [
+            ...heldElsewhere
+        ]
+    };
+}
+/**
+ * Every holder whose facet names this company, in no order.
+ *
+ * What a company's DELETION clears. Unlike a link change, which is one
+ * holder's, a deletion takes the record away from every holder at once: a
+ * facet still naming it would be a link to nothing, on a surface its holder
+ * has no reason to revisit. Nothing else about another holder's facet is
+ * read.
+ */ export function contactGroupsNamingCompany(contact, companyId) {
+    const facets = (contact != null ? contact : {})[CONTACT_FACETS_FIELD];
+    if (!companyId || !facets || typeof facets !== 'object' || Array.isArray(facets)) {
+        return [];
+    }
+    return Object.entries(facets).filter(([, facet])=>Boolean(facet && typeof facet === 'object' && !Array.isArray(facet) && facet['companyId'] === companyId)).map(([groupId])=>groupId);
+}
+/**
+ * What linking a contact to a company FOR ONE HOLDER changes — or unlinking
+ * them, with `null`. `null` when the document already says what was asked.
+ *
+ * Three cases, and the mirror is handled differently in each because it is
+ * shared across holders while the facet is not:
+ *
+ *  - A first link `union`s the id in, which is safe against a concurrent
+ *    writer adding another holder's id.
+ *  - A MOVE from one company to another rewrites the mirror as a whole. The
+ *    old id is dropped only if no other holder's facet still names it.
+ *  - An unlink `remove`s the old id, on the same condition, and leaves the
+ *    mirror alone when another holder still needs it there.
+ *
+ * The counts follow the mirror, not the facet: the company's figure is "how
+ * many contacts name me in the mirror", and that is the quantity the
+ * company page's live aggregate measures.
+ */ export function planContactCompanyLink(state, companyId) {
+    const previous = state.companyId;
+    if (previous === companyId) return null;
+    const mirror = new Set(state.companyIds);
+    const previousLeaves = previous !== null && !state.heldElsewhere.includes(previous);
+    const counts = [];
+    let change = null;
+    if (companyId && !previous) {
+        change = {
+            op: 'union',
+            companyId
+        };
+        if (!mirror.has(companyId)) counts.push({
+            companyId,
+            delta: 1
+        });
+    } else if (companyId && previous) {
+        const kept = state.companyIds.filter((id)=>id !== previous || !previousLeaves);
+        change = {
+            op: 'set',
+            companyIds: [
+                ...new Set([
+                    ...kept,
+                    companyId
+                ])
+            ]
+        };
+        if (previousLeaves && mirror.has(previous)) {
+            counts.push({
+                companyId: previous,
+                delta: -1
+            });
+        }
+        if (!mirror.has(companyId)) counts.push({
+            companyId,
+            delta: 1
+        });
+    } else if (previous && previousLeaves) {
+        change = {
+            op: 'remove',
+            companyId: previous
+        };
+        if (mirror.has(previous)) counts.push({
+            companyId: previous,
+            delta: -1
+        });
+    }
+    return {
+        companyId,
+        mirror: change,
+        counts
+    };
+}
+/*==========================================
+ * THE CRM's ORGANIZATION SETTINGS (AGL-2613).
+ *
+ * One map under `crm` on the org document, so the CRM → Settings section
+ * can grow a key per setting without a rules change each time: the org
+ * document's client branch is a deny-list, and `crm` is declared
+ * client-writable in `ORG_CLIENT_WRITABLE_FIELDS` with its reason.
+ *=========================================*/ /** The org-document key the CRM's settings live under. */ export const ORG_CRM_SETTINGS_FIELD = 'crm';
+/** The dotted path an `update()` writes the auto-create switch by. */ export const CRM_AUTO_CREATE_COMPANIES_PATH = `${ORG_CRM_SETTINGS_FIELD}.autoCreateCompanies`;
+/**
+ * Whether a capture from a work email domain no visible company carries
+ * should CREATE the company. Off unless the org document says `true`: a
+ * company minted from every domain that ever submitted a form is a list
+ * nobody asked for, so the default is the quiet one.
+ *
+ * Read off the raw document rather than a typed field, because the capture
+ * door holds a `Partial<AglynOrganization>` and the console a
+ * `Partial<AglynOrgBilling>`, and one reader has to answer both.
+ */ export function orgAutoCreatesCompanies(orgDocument) {
+    const settings = (orgDocument != null ? orgDocument : {})[ORG_CRM_SETTINGS_FIELD];
+    return Boolean(settings && typeof settings === 'object' && !Array.isArray(settings) && settings['autoCreateCompanies'] === true);
+}
+/*==========================================
+ * WHO A NEW RECORD BELONGS TO (AGL-2618).
+ *
+ * Salesforce calls these assignment rules and HubSpot rotates to an owner;
+ * either way they are the first thing a sales team configures, because a
+ * record with no owner is one nobody follows up. The shape here is what the
+ * CRM → Settings section writes onto the org document under `crm`, what the
+ * capture door's assignment pass reads, and what the `assignContactOwner`
+ * automation step's round-robin mode reads — one vocabulary, three readers.
+ *
+ * ## The order of decision
+ *
+ * The rules are tried in their stored order and the FIRST match assigns; a
+ * rule that names a member the roster no longer has, or a round-robin rule
+ * over an empty pool, is passed over rather than stopping the pass. When no
+ * rule claims the capture, the capturing site's default owner does; when
+ * the site has none, the record stays unassigned, which is what the product
+ * did before any of this existed and is the honest answer to "nobody has
+ * said".
+ *
+ * ## Only a record with no owner
+ *
+ * The capture pass runs when a record is CREATED and never overwrites an
+ * owner: a door that named one (the console's drawer, an import column, a
+ * conversion with a picked owner) has expressed a person's choice, and a
+ * returning visitor's contact already belongs to somebody. The automation
+ * step is the deliberate exception — an author who put "assign an owner"
+ * on a stage change means to reassign.
+ *
+ * ## Why the pointer is a uid, and why the server moves it
+ *
+ * See `OrgCrmRoundRobin`. The pool is edited in the console and the pointer
+ * is advanced by the Admin SDK inside the transaction that writes the owner,
+ * so concurrent captures take distinct turns and an edit to the pool never
+ * skips or repeats a member.
+ *=========================================*/ /** Where the ordered rules live on the org document. */ export const CRM_ASSIGNMENT_RULES_PATH = `${ORG_CRM_SETTINGS_FIELD}.assignmentRules`;
+/** The round-robin pool's member list, in rotation order. */ export const CRM_ROUND_ROBIN_POOL_PATH = `${ORG_CRM_SETTINGS_FIELD}.roundRobin.memberUids`;
+/** The member handed the most recent round-robin record. */ export const CRM_ROUND_ROBIN_LAST_ASSIGNED_PATH = `${ORG_CRM_SETTINGS_FIELD}.roundRobin.lastAssignedUid`;
+/**
+ * The most rules an org may keep. A first-match list longer than this is
+ * one nobody can reason about, and the section refuses the fifty-first
+ * rather than letting the document grow unbounded.
+ */ export const CRM_ASSIGNMENT_RULES_MAX = 50;
+/** The most members a round-robin pool may hold. */ export const CRM_ROUND_ROBIN_POOL_MAX = 50;
+/**
+ * The map of per-site CRM settings under `crm` on the ORG document, keyed
+ * by host id. A field on the org, not a subcollection of the host: the
+ * host-subcollection guards read a quoted `'hosts'` beside a site id as a
+ * client path under `hosts/{hostId}`, which this is not, so the key is
+ * named here and spelled nowhere else.
+ */ const CRM_HOST_SETTINGS_KEY = 'hosts';
+/**
+ * The field-path SEGMENTS of a site's default owner on the org document.
+ *
+ * Segments rather than a dotted string, because the host id is a document
+ * id and a document id may contain a dot; joined with dots it would be read
+ * as two path elements and the write would land beside the setting rather
+ * than in it. A caller builds a `FieldPath` from these on either SDK.
+ */ export function crmHostDefaultOwnerSegments(hostId) {
+    if (!hostId) throw new Error('a site default owner must name a site');
+    return [
+        ORG_CRM_SETTINGS_FIELD,
+        CRM_HOST_SETTINGS_KEY,
+        hostId,
+        'defaultOwnerUid'
+    ];
+}
+function isContactSourceValue(value) {
+    return typeof value === 'string' && value in CONTACT_SOURCE_LABELS;
+}
+function cleanText(value, max) {
+    const text = typeof value === 'string' ? value.trim().slice(0, max) : '';
+    return text || undefined;
+}
+/** A rule as the document holds it, or `null` for one that cannot assign. */ export function readCrmAssignmentRule(raw) {
+    var _whenRaw_emailDomain;
+    var _cleanText;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+    const entry = raw;
+    const id = cleanText(entry['id'], 64);
+    if (!id) return null;
+    const whenRaw = entry['when'] && typeof entry['when'] === 'object' && !Array.isArray(entry['when']) ? entry['when'] : {};
+    const when = {};
+    if (isContactSourceValue(whenRaw['source'])) when.source = whenRaw['source'];
+    const formId = cleanText(whenRaw['formId'], 128);
+    if (formId) when.formId = formId;
+    // A person types a domain the way they see one in an address — `@acme.com`
+    // — so the `@` is what the field means, not part of the domain.
+    const emailDomain = normalizeCompanyDomain(String((_whenRaw_emailDomain = whenRaw['emailDomain']) != null ? _whenRaw_emailDomain : '').trim().replace(/^@/, ''));
+    if (emailDomain) when.emailDomain = emailDomain;
+    const tag = (_cleanText = cleanText(whenRaw['tag'], 60)) == null ? void 0 : _cleanText.toLowerCase();
+    if (tag) when.tag = tag;
+    const assignRaw = entry['assign'] && typeof entry['assign'] === 'object' && !Array.isArray(entry['assign']) ? entry['assign'] : null;
+    if (!assignRaw) return null;
+    if (assignRaw['roundRobin'] === true) {
+        return {
+            id,
+            when,
+            assign: {
+                roundRobin: true
+            }
+        };
+    }
+    const memberUid = cleanText(assignRaw['memberUid'], 128);
+    return memberUid ? {
+        id,
+        when,
+        assign: {
+            memberUid
+        }
+    } : null;
+}
+export function readCrmAssignmentSettings(orgDocument) {
+    var _cleanText;
+    const settings = (orgDocument != null ? orgDocument : {})[ORG_CRM_SETTINGS_FIELD];
+    const crm = settings && typeof settings === 'object' && !Array.isArray(settings) ? settings : {};
+    const rules = (Array.isArray(crm['assignmentRules']) ? crm['assignmentRules'] : []).map(readCrmAssignmentRule).filter((rule)=>rule !== null).slice(0, CRM_ASSIGNMENT_RULES_MAX);
+    const roundRobin = crm['roundRobin'] && typeof crm['roundRobin'] === 'object' ? crm['roundRobin'] : {};
+    const memberUids = [
+        ...new Set((Array.isArray(roundRobin['memberUids']) ? roundRobin['memberUids'] : []).map((uid)=>cleanText(uid, 128)).filter((uid)=>Boolean(uid)))
+    ].slice(0, CRM_ROUND_ROBIN_POOL_MAX);
+    const hostSettings = crm[CRM_HOST_SETTINGS_KEY];
+    const hosts = hostSettings && typeof hostSettings === 'object' && !Array.isArray(hostSettings) ? hostSettings : {};
+    const hostDefaultOwners = {};
+    for (const [hostId, value] of Object.entries(hosts)){
+        const owner = value && typeof value === 'object' ? cleanText(value['defaultOwnerUid'], 128) : undefined;
+        if (owner) hostDefaultOwners[hostId] = owner;
+    }
+    return {
+        rules,
+        pool: {
+            memberUids,
+            lastAssignedUid: (_cleanText = cleanText(roundRobin['lastAssignedUid'], 128)) != null ? _cleanText : null
+        },
+        hostDefaultOwners
+    };
+}
+/** The member a site hands unclaimed captures to, or `null` for nobody. */ export function crmHostDefaultOwner(orgDocument, hostId) {
+    var _readCrmAssignmentSettings_hostDefaultOwners_hostId;
+    return (_readCrmAssignmentSettings_hostDefaultOwners_hostId = readCrmAssignmentSettings(orgDocument).hostDefaultOwners[hostId]) != null ? _readCrmAssignmentSettings_hostDefaultOwners_hostId : null;
+}
+/**
+ * The domain a rule's `emailDomain` is compared with — the address's own,
+ * lowercased. Not `companyDomainForEmail`, which answers `null` for a public
+ * mailbox: a team may well route every `gmail.com` sign-up to one rep, and
+ * a rule that could not name a consumer domain could not say so.
+ */ export function assignmentEmailDomain(email) {
+    const at = email.lastIndexOf('@');
+    if (at < 0) return null;
+    return normalizeCompanyDomain(email.slice(at + 1));
+}
+/**
+ * Whether every condition the rule names holds for this capture. A rule
+ * with no condition matches every capture — the catch-all.
+ */ export function assignmentRuleMatches(when, capture) {
+    var _capture_formId;
+    if (when.source && when.source !== capture.source) return false;
+    if (when.formId && when.formId !== ((_capture_formId = capture.formId) != null ? _capture_formId : '')) return false;
+    if (when.emailDomain && when.emailDomain !== assignmentEmailDomain(capture.email)) {
+        return false;
+    }
+    if (when.tag) {
+        var _capture_tags;
+        const worn = ((_capture_tags = capture.tags) != null ? _capture_tags : []).map((tag)=>String(tag).trim().toLowerCase());
+        if (!worn.includes(when.tag)) return false;
+    }
+    return true;
+}
+/**
+ * The pool in the order the next record should try it: the member after
+ * the last recipient first, wrapping round, and the last recipient
+ * themselves at the end — so a pool of one still assigns, and a pointer
+ * naming somebody no longer in the pool starts from the top.
+ */ export function roundRobinOrder(memberUids, lastAssignedUid) {
+    if (!memberUids.length) return [];
+    const at = lastAssignedUid ? memberUids.indexOf(lastAssignedUid) : -1;
+    if (at < 0) return [
+        ...memberUids
+    ];
+    return [
+        ...memberUids.slice(at + 1),
+        ...memberUids.slice(0, at + 1)
+    ];
+}
+/**
+ * How a rule reads in the settings list — its conditions in words and
+ * where it sends the record — so a reader can tell two rules apart without
+ * opening either. `memberLabel` turns a uid into a name; the section passes
+ * the roster's.
+ */ export function describeAssignmentRule(rule, memberLabel) {
+    const parts = [];
+    if (rule.when.source) parts.push(`source is ${CONTACT_SOURCE_LABELS[rule.when.source]}`);
+    if (rule.when.formId) parts.push(`form is ${rule.when.formId}`);
+    if (rule.when.emailDomain) parts.push(`email domain is ${rule.when.emailDomain}`);
+    if (rule.when.tag) parts.push(`tagged ${rule.when.tag}`);
+    return {
+        when: parts.length ? parts.join(' and ') : 'Every capture',
+        assign: 'roundRobin' in rule.assign ? 'Round robin' : memberLabel(rule.assign.memberUid)
+    };
+}
+/**
+ * A fresh rule id, unique among the ones the org already holds. Time and
+ * entropy rather than a counter, so two admins adding a rule in two tabs
+ * do not mint the same id and have one reorder clobber the other's rule.
+ */ export function newAssignmentRuleId(existing) {
+    for(;;){
+        const id = `rule-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+        if (!existing.includes(id)) return id;
+    }
+}
+/**
+ * The `visibleTo` every CRM creator stamps — client or server, whichever
+ * door the record comes in through.
+ *
+ * The contact create path's own expression (`upsertHostContact`), lifted
+ * here so that a company, a deal or a task created from a site's console
+ * lands in exactly the scope a contact captured on that site would: the
+ * whole org when the org has chosen `defaultResourceScope: 'org'`, and
+ * otherwise the sites that present as one sender — which, undeclared, is
+ * this site alone. That is the agency's isolation, arrived at with nothing
+ * configured, and the reason this is a function rather than a convention
+ * eight creators are asked to remember.
+ *
+ * Widening past the group is an ACT — an org-wide member editing the scope
+ * on the record — never a default. The rules refuse a scoped member creating
+ * a record outside their own tokens, so a creator that bypassed this could
+ * only make its record invisible to itself, never wider.
+ */ export function crmScopeTokens(org, group) {
+    return (org != null ? org : {})['defaultResourceScope'] === 'org' ? [
+        ORG_SCOPE_TOKEN
+    ] : consentGroupScope(group);
+}
+/**
+ * The `visibleTo` tokens a reader of this group may LIST, for the
+ * `array-contains-any` every CRM listener filters by.
+ *
+ * The other half of {@link crmScopeTokens}: that is what a creator stamps,
+ * this is what a reader asks for, and the two differ by exactly one token.
+ * `'org'` leads because an org-wide record is visible to every site — an org
+ * that widened its default deliberately still sees its own rows — and the
+ * group's sites follow. The contacts list computes this inline; every other
+ * CRM reader takes it from here so that none of them can drop the org token
+ * and lose the org-wide rows, or forget the cap and have Firestore refuse
+ * the query outright.
+ *
+ * Capped at {@link MAX_SCOPE_HOSTS}: a group wider than the operator's limit
+ * is listed as far as the limit reaches, which is the contacts list's
+ * behavior and the only one short of an error.
+ */ export function crmReadTokens(group) {
+    return [
+        ORG_SCOPE_TOKEN,
+        ...consentGroupScope(group)
+    ].slice(0, MAX_SCOPE_HOSTS);
+}
+export function parseCrmMemberRef(value) {
+    const text = String(value != null ? value : '').trim();
+    if (!text) return null;
+    if (text.includes('@')) {
+        const email = normalizeContactEmail(text);
+        return email ? {
+            kind: 'email',
+            email
+        } : null;
+    }
+    return {
+        kind: 'uid',
+        uid: text
+    };
+}
+/**
+ * A roster row as every CRM picker and column shows it.
+ *
+ * One mapping rather than four, because four is what the CRM had — and one
+ * of them dropped a member whose document had neither a display name nor an
+ * address, which is precisely the member the uid fallback exists for.
+ */ export function crmMemberOption(member) {
+    var _ref, _member_$id, _member_displayName, _member_email;
+    const uid = String((_ref = (_member_$id = member['$id']) != null ? _member_$id : member['uid']) != null ? _ref : '').trim();
+    if (!uid) return null;
+    const displayName = String((_member_displayName = member['displayName']) != null ? _member_displayName : '').trim();
+    const email = String((_member_email = member['email']) != null ? _member_email : '').trim();
+    return _extends({
+        uid,
+        label: displayName || email || uid
+    }, email ? {
+        email
+    } : {});
+}
+/**
+ * The member a stored reference names: by uid first — the stored shape —
+ * and by address second, so a record that carries an address where a uid
+ * belongs (an older import, a hand edit) still names the person the roster
+ * has under it. Undefined for nobody, which the caller renders honestly as
+ * "former member" or as the reference itself rather than as unassigned.
+ */ export function findOrgMember(members, ref) {
+    const parsed = parseCrmMemberRef(ref);
+    if (!parsed) return undefined;
+    if (parsed.kind === 'uid') {
+        return members.find((member)=>member.uid === parsed.uid);
+    }
+    return members.find((member)=>normalizeContactEmail(member.email) === parsed.email);
+}
+/*==========================================
+ * LEADS (AGL-2608).
+ *
+ * A lead is NOT one of the six collections above. It lives at
+ * `hosts/{hostId}/leads/{personKey}`, written by `addHostLead` when a
+ * visitor signs up, books or submits a form, and it is host-scoped by PATH:
+ * no `visibleTo`, no facet map, private to the site that captured it. What
+ * the CRM adds is the working state a sales team keeps on such a capture —
+ * a status, an owner, notes — and the record of its conversion into the
+ * contact, company and deal that live in the org collections.
+ *
+ * These fields are typed here rather than beside `addHostLead` because the
+ * writer of the capture and the reader of the working state are different
+ * programs: the capture door stamps none of them, and a lead that predates
+ * this block carries none of them, which is why every field is optional and
+ * {@link crmLeadStatus} reads an absent status as `new`.
+ *=========================================*/ /**
+ * Where a lead stands, in the order a person works one.
+ *
+ * `qualified` is the CONVERTED state — a lead becomes a contact by being
+ * qualified, and the conversion stamps `convertedContactId` beside it — and
+ * `unqualified` is the closed-without-conversion state with its reason. A
+ * fixed list rather than free text for the reason the lifecycle stages are:
+ * the section filters on it and a report counts by it.
+ */ export const CRM_LEAD_STATUSES = [
+    'new',
+    'working',
+    'qualified',
+    'unqualified'
+];
+/** How a lead status reads on screen — typed so a status cannot ship unlabeled. */ export const CRM_LEAD_STATUS_LABELS = {
+    new: 'New',
+    working: 'Working',
+    qualified: 'Qualified',
+    unqualified: 'Unqualified'
+};
+/**
+ * The statuses a lead still needs somebody's attention in — what the Leads
+ * section shows by default, so the list opens on the work rather than on
+ * the history.
+ */ export const CRM_LEAD_OPEN_STATUSES = [
+    'new',
+    'working'
+];
+/**
+ * The statuses that mean nobody needs to work the lead any more — the
+ * operand of the `in` clause an open-lead figure subtracts with. Subtracts,
+ * because an untouched lead carries no status field at all and Firestore
+ * cannot select on a field's absence; the closed statuses are always
+ * written, so they can be counted, and what remains is open. See
+ * `openLeadsFromCounts`.
+ */ export const CRM_LEAD_CLOSED_STATUSES = CRM_LEAD_STATUSES.filter((status)=>!CRM_LEAD_OPEN_STATUSES.includes(status));
+export function isCrmLeadStatus(value) {
+    return typeof value === 'string' && CRM_LEAD_STATUSES.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
+ *
+ * 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
+ * else made their default must not become everybody's.
+ *=========================================*/ /** The lists a view can be saved for — every CRM section that has one. */ export const CRM_VIEW_SECTIONS = [
+    'contacts',
+    'companies',
+    'deals',
+    'tasks',
+    'leads'
+];
+export function isCrmViewSection(value) {
+    return typeof value === 'string' && CRM_VIEW_SECTIONS.includes(value);
+}
+export const CRM_VIEW_NAME_MAX = 60;
+/**
+ * The most clauses one view carries. A bound on the predicate, not the
+ * audience: the list matches most of them in memory over a bounded window,
+ * and a stored array has no natural end.
+ */ export const CRM_VIEW_MAX_FILTERS = 20;
+export const CRM_VIEW_MAX_COLUMNS = 60;
+/** Filter operators that carry no value, so an empty `value` is not a dropped clause. */ const VALUELESS_VIEW_OPS = new Set([
+    'isEmpty',
+    'isNotEmpty'
+]);
+export const EMPTY_CRM_VIEW_STATE = Object.freeze({
+    filters: [],
+    columns: [],
+    sort: null
+});
+const asViewText = (value, max)=>typeof value === 'string' ? value.trim().slice(0, max) : '';
+/**
+ * A stored view's filters, held to the clause shape.
+ *
+ * Strict about what it keeps: a clause with no field or no operator is not
+ * a filter, and a valued operator with no value would read as a filter
+ * that matches nothing — so both are dropped rather than kept, for the same
+ * reason the dynamic-list rule drops an empty branch: a view must not
+ * quietly select a different population than the one it reads as.
+ */ export function normalizeCrmViewFilters(value) {
+    if (!Array.isArray(value)) return [];
+    const clauses = [];
+    for (const raw of value){
+        const entry = raw != null ? raw : {};
+        const field = asViewText(entry['field'], 80);
+        const op = asViewText(entry['op'], 40);
+        const text = asViewText(entry['value'], 500);
+        if (!field || !op) continue;
+        if (!text && !VALUELESS_VIEW_OPS.has(op)) continue;
+        const label = asViewText(entry['label'], 120);
+        clauses.push(_extends({
+            field,
+            op,
+            value: text
+        }, label ? {
+            label
+        } : {}));
+        if (clauses.length >= CRM_VIEW_MAX_FILTERS) break;
+    }
+    return clauses;
+}
+export function normalizeCrmViewColumns(value) {
+    if (!Array.isArray(value)) return [];
+    const seen = new Set();
+    for (const raw of value){
+        const column = asViewText(raw, 80);
+        if (column) seen.add(column);
+        if (seen.size >= CRM_VIEW_MAX_COLUMNS) break;
+    }
+    return [
+        ...seen
+    ];
+}
+export function normalizeCrmViewSort(value) {
+    const entry = value != null ? value : null;
+    const field = entry ? asViewText(entry['field'], 80) : '';
+    if (!field) return null;
+    return {
+        field,
+        direction: (entry == null ? void 0 : entry['direction']) === 'desc' ? 'desc' : 'asc'
+    };
+}
+/** A stored document's three list-facing fields, held to their shapes. */ export function normalizeCrmViewState(value) {
+    const entry = value != null ? value : {};
+    return {
+        filters: normalizeCrmViewFilters(entry['filters']),
+        columns: normalizeCrmViewColumns(entry['columns']),
+        sort: normalizeCrmViewSort(entry['sort'])
+    };
+}
+/**
+ * Whether two states describe the same list — what "unsaved changes" means.
+ *
+ * Clause order matters (a list applies them in order, and the first one the
+ * query can serve is the one it serves); the label on a clause does not,
+ * because nothing matches on it.
+ */ export function crmViewStateEquals(a, b) {
+    if (a.filters.length !== b.filters.length) return false;
+    for(let index = 0; index < a.filters.length; index += 1){
+        const left = a.filters[index];
+        const right = b.filters[index];
+        if (left.field !== right.field || left.op !== right.op || left.value !== right.value) {
+            return false;
+        }
+    }
+    if (a.columns.length !== b.columns.length) return false;
+    if (a.columns.some((column, index)=>column !== b.columns[index])) {
+        return false;
+    }
+    if (!a.sort || !b.sort) return a.sort === b.sort;
+    return a.sort.field === b.sort.field && a.sort.direction === b.sort.direction;
+}
+/**
+ * Whether a view belongs in this reader's menu: their own, or one somebody
+ * shared. The rules admit the read either way — see the module note — so
+ * this is what keeps one person's private arrangement out of another's
+ * list.
+ */ export function crmViewIsListed(view, uid) {
+    return view.shared === true || Boolean(uid) && view.ownerUid === uid;
+}
+/**
+ * The Contacts list's filterable fields, by the names a view clause carries.
+ *
+ * A contract between three readers that cannot import one another: the
+ * list's own filter grammar (which declares these as its columns), a saved
+ * view (which stores them), and the dynamic-list translator below in
+ * `dynamic-list-rule.ts` (which turns them into audience dimensions). Named
+ * once so a rename on the list cannot silently stop an audience matching.
+ * `custom` is a PREFIX: a custom field's column is the prefix and its key.
+ */ export const CRM_CONTACT_VIEW_FIELDS = {
+    tags: 'tags',
+    source: 'source',
+    owner: 'ownerUid',
+    stage: 'lifecycleStage',
+    company: 'companyId',
+    createdAt: 'createdAt',
+    updatedAt: 'updatedAt',
+    orders: 'ordersCount',
+    ltv: 'ltvCents',
+    custom: 'custom_'
+};
+/** The column a custom contact field filters and shows as. */ export const crmContactCustomColumn = (key)=>`${CRM_CONTACT_VIEW_FIELDS.custom}${key}`;
+/** The field key a custom column stands for, or `null` for any other column. */ export function crmContactCustomKey(column) {
+    const prefix = CRM_CONTACT_VIEW_FIELDS.custom;
+    return column.startsWith(prefix) && column.length > prefix.length ? column.slice(prefix.length) : null;
+}
+/**
+ * A stored phone number as the `href` of a click-to-call link, or `null`
+ * when the value is not one (AGL-2661).
+ *
+ * The console stores E.164 (`normalizePhone` runs before every write), and
+ * a `tel:` URL wants exactly that: digits with a leading `+`, nothing else.
+ * Spaces, dots, dashes and parentheses are dropped rather than refused
+ * because a value written before normalization existed may carry them;
+ * anything that is not a run of digits after that — a word, an extension
+ * typed as `x123` — is refused, because a dialer handed it would ring
+ * nothing and the link would be a lie.
+ */ export function crmTelHref(phone) {
+    const text = String(phone != null ? phone : '').trim();
+    if (!text) return null;
+    const compact = text.replace(/[\s().-]/g, '');
+    return /^\+?\d{3,20}$/.test(compact) ? `tel:${compact}` : null;
+}
+const CRM_VIEW_TAGS_FIELD = CRM_CONTACT_VIEW_FIELDS.tags;
+const CRM_VIEW_SOURCE_FIELD = CRM_CONTACT_VIEW_FIELDS.source;
+/**
+ * A saved segment, as the filters of a contacts view.
+ *
+ * A segment is "any of these tags AND any of these sources", so each
+ * becomes one `isAnyOf` clause — OR within, AND across, which is the
+ * reading `contactMatchesSegment` gives it. A single tag is emitted as
+ * `contains` instead: that operator is the one the contacts query can serve
+ * from the index, so a one-tag segment opened as a view reaches the whole
+ * collection rather than the loaded window. The values are the segment's
+ * own, joined the way the grammar's `isAnyOf` splits them.
+ */ export function crmViewFiltersFromSegment(segment) {
+    var _segment_tags, _segment_sources;
+    const tags = ((_segment_tags = segment.tags) != null ? _segment_tags : []).map((tag)=>tag.trim()).filter(Boolean);
+    const sources = ((_segment_sources = segment.sources) != null ? _segment_sources : []).filter((source)=>source in CONTACT_SOURCE_LABELS);
+    return [
+        ...tags.length === 1 ? [
+            {
+                field: CRM_VIEW_TAGS_FIELD,
+                op: 'contains',
+                value: tags[0]
+            }
+        ] : tags.length ? [
+            {
+                field: CRM_VIEW_TAGS_FIELD,
+                op: 'isAnyOf',
+                value: tags.join(',')
+            }
+        ] : [],
+        ...sources.length === 1 ? [
+            {
+                field: CRM_VIEW_SOURCE_FIELD,
+                op: 'equals',
+                value: sources[0]
+            }
+        ] : sources.length ? [
+            {
+                field: CRM_VIEW_SOURCE_FIELD,
+                op: 'isAnyOf',
+                value: sources.join(',')
+            }
+        ] : []
+    ];
+}
+/**
+ * The other direction: the segment a view's filters describe, or `null`
+ * when the view carries no tag or source clause a segment could hold.
+ *
+ * Only the two dimensions a segment has are read, and only through the
+ * operators that mean "has one of these"; a `name startsWith` or an owner
+ * clause is not a segment's to keep. What comes back is what "Save as
+ * segment" writes, so a campaign audience built from it selects exactly the
+ * tags and sources the reader could see on the chips.
+ */ export function crmViewSegmentFilters(filters) {
+    const tags = new Set();
+    const sources = new Set();
+    const split = (value)=>value.split(',').map((entry)=>entry.trim()).filter(Boolean);
+    for (const clause of filters){
+        if (clause.field === CRM_VIEW_TAGS_FIELD) {
+            if (clause.op === 'contains') tags.add(clause.value.trim().toLowerCase());
+            else if (clause.op === 'isAnyOf') {
+                for (const tag of split(clause.value))tags.add(tag.toLowerCase());
+            }
+        } else if (clause.field === CRM_VIEW_SOURCE_FIELD) {
+            const values = clause.op === 'equals' ? [
+                clause.value.trim()
+            ] : clause.op === 'isAnyOf' ? split(clause.value) : [];
+            for (const source of values){
+                if (source in CONTACT_SOURCE_LABELS) sources.add(source);
+            }
+        }
+    }
+    tags.delete('');
+    if (!tags.size && !sources.size) return null;
+    return _extends({}, tags.size ? {
+        tags: [
+            ...tags
+        ]
+    } : {}, sources.size ? {
+        sources: [
+            ...sources
+        ]
+    } : {});
+}
+/**
+ * `users/{uid}.crmDefaultViews` — `{ [orgId]: { [section]: viewId } }`.
+ *
+ * On the reader's own profile document, beside `notificationPrefs`, because
+ * it is the same kind of fact: how one person wants their console to
+ * behave, owned and written by them alone. Keyed by org first because one
+ * account sits on several organizations and a view id is only meaningful
+ * inside the one that holds it.
+ */ export const CRM_DEFAULT_VIEWS_FIELD = 'crmDefaultViews';
+/** The view a section opens on for this reader in this org, or none. */ export function crmDefaultViewId(profile, orgId, section) {
+    if (!profile || !orgId) return null;
+    const byOrg = profile[CRM_DEFAULT_VIEWS_FIELD];
+    if (!byOrg || typeof byOrg !== 'object' || Array.isArray(byOrg)) return null;
+    const bySection = byOrg[orgId];
+    if (!bySection || typeof bySection !== 'object' || Array.isArray(bySection)) {
+        return null;
+    }
+    const viewId = bySection[section];
+    return typeof viewId === 'string' && viewId.trim() ? viewId : null;
+}
+/**
+ * The merge patch that sets — or, with `null`, clears — one default.
+ *
+ * Shaped for a merged write so the other organizations' and sections'
+ * defaults on the same document survive it; `null` rather than a delete
+ * sentinel because this module carries no Firestore, and the reader above
+ * treats a null as no default.
+ */ export function crmDefaultViewPatch(orgId, section, viewId) {
+    return {
+        [CRM_DEFAULT_VIEWS_FIELD]: {
+            [orgId]: {
+                [section]: viewId
+            }
+        }
+    };
+}
+/*==========================================
+ * FILES ON A RECORD (AGL-2662)
+ *=========================================*/ /** The field a record's attached files are stored under, on all three. */ export const CRM_MEDIA_IDS_FIELD = 'mediaIds';
+/**
+ * The most files one record may carry.
+ *
+ * A platform ceiling in the family of {@link CRM_ACTIVITIES_PER_RECORD_CEILING}
+ * rather than a plan dimension: attachments are bounded by human effort, and
+ * this is the bound. It is also what the Firestore rules can actually check
+ * — a rule can assert a list and its size, and cannot walk one — so the
+ * number is enforced rather than merely documented.
+ */ export const CRM_MEDIA_IDS_MAX = 20;
+/**
+ * A stored or submitted attachment list, cleaned.
+ *
+ * Ids rather than URLs, deduplicated, trimmed, non-empty and capped. Written
+ * through by every path that sets the field — the console card, the REST
+ * write — so a record cannot hold a list one of them would refuse.
+ *
+ * An id is a media DOCUMENT id, resolved against the organization's library
+ * (`orgs/{orgId}/media/{mediaId}`) at read time. Storing the id and not the
+ * URL is what lets a file move between folders, and what keeps a private
+ * asset behind the signed CDN door rather than pinned to a raw storage URL
+ * that names its current location.
+ */ export function normalizeCrmMediaIds(value) {
+    if (!Array.isArray(value)) return [];
+    return [
+        ...new Set(value.map((id)=>String(id != null ? id : '').trim()).filter((id)=>id.length > 0 && id.length <= 200))
+    ].slice(0, CRM_MEDIA_IDS_MAX);
+}
+
+//# sourceMappingURL=crm.js.map