@aglyn/tenant-data-admin 1.0.0-beta.143

package/src/lib/server/upsert-contact.js

@@ -0,0 +1,546 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { CAPTURED_BY_HOST_FIELD, checkCrmRecordsQuota, consentGroupScope, CONTACT_FACETS_FIELD, CONTACT_FORM_IDS_CAP, CONTACT_FORM_IDS_FIELD, marketingConsentFieldsForGroup, mergeContactInteraction, normalizeCampaignIds, readContactFacet, normalizeContactEmail, ORG_SCOPE_TOKEN } from "@aglyn/aglyn/server";
+import { FieldValue } from "firebase-admin/firestore";
+import { firebaseAdmin } from "./firebase-admin.js";
+import { countCrmRecords } from "./crm-records.js";
+import { attributeOrderToEmail } from "./email-revenue-attribution.js";
+import { hostRefusesCaptureForErasure } from "./email-suppression.js";
+import { attributeCampaignConversion } from "./campaign-conversion-attribution.js";
+import { nameSearchFields } from "@aglyn/aglyn/app-utils/name-search";
+import { declineMarketingConsentFields, MARKETING_CONSENT_SOURCE_FIELD } from "@aglyn/aglyn/app-utils/marketing-consent";
+/*
+ * The module paths, like `name-search` above, rather than the barrel: the
+ * pure helpers this door leans on are exactly the ones a spec of the door
+ * substitutes a fixture barrel for, and a fixture that has to re-export the
+ * whole of `@aglyn/aglyn` to keep a normalizer reachable is a fixture that
+ * drifts. A direct path is real in every harness.
+ */ import { advanceContactLifecycleStage, CONTACT_COMPANY_IDS_FIELD, CONTACT_FIELD_KEY_PATTERN, CRM_COLLECTIONS, isContactLifecycleStage, planContactCompanyLink, readContactCompanyLink } from "@aglyn/aglyn/app-utils/crm";
+import { normalizeAddress, normalizePhone } from "@aglyn/aglyn/foundation/definitions/contact.types";
+import { contactCompanyMirrorValue, settleCompanyContactsCounts } from "./contact-company-link.js";
+import { emailIndexBeside, findContactByEmail, writeContactEmailIndex } from "./contact-email-index.js";
+import { consentGroupForSite, getOrgForHost, orgDataCollectionForHost } from "./organizations.js";
+/**
+ * The profile as it may be STORED: every value normalized, every unusable
+ * one dropped, and nothing present that was not given.
+ *
+ * Only the keys given come back, which is what lets a merge write this
+ * straight into the facet: a door that knows the phone number and nothing
+ * else leaves the title, the owner and the stage exactly as another door
+ * left them. An address given as `null` is a deliberate clearing and is kept
+ * as `null`; one that normalizes to nothing is the same thing.
+ */ function storableProfile(input) {
+    if (!input) return {};
+    const out = {};
+    if (input.phone !== undefined) {
+        const phone = normalizePhone(input.phone);
+        if (phone) out.phone = phone;
+    }
+    if (typeof input.jobTitle === 'string') {
+        const jobTitle = input.jobTitle.trim().slice(0, 120);
+        if (jobTitle) out.jobTitle = jobTitle;
+    }
+    if (input.address !== undefined) out.address = normalizeAddress(input.address);
+    if (typeof input.companyId === 'string' && input.companyId.trim()) {
+        out.companyId = input.companyId.trim().slice(0, 128);
+    }
+    if (typeof input.ownerUid === 'string' && input.ownerUid.trim()) {
+        out.ownerUid = input.ownerUid.trim().slice(0, 128);
+    }
+    if (isContactLifecycleStage(input.lifecycleStage)) {
+        out.lifecycleStage = input.lifecycleStage;
+    }
+    if (input.custom && typeof input.custom === 'object') {
+        /*
+     * Only a key a field definition could have, and only a value the field
+     * types can hold. A nested object here is a map the merge below would
+     * write as a subtree nobody can render; a key with a dot in it would be
+     * read as a PATH by the next dotted update to touch the facet. Nothing is
+     * coerced — a door that has a number should send one — and an empty map
+     * is left off rather than written as `{}` over a holder's values.
+     */ const custom = {};
+        for (const [key, value] of Object.entries(input.custom)){
+            if (!CONTACT_FIELD_KEY_PATTERN.test(key)) continue;
+            if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                custom[key] = typeof value === 'string' ? value.slice(0, 2000) : value;
+            }
+        }
+        if (Object.keys(custom).length) out.custom = custom;
+    }
+    return out;
+}
+/**
+ * The org's companies collection, beside its contacts one.
+ *
+ * Reached through the contacts reference's parent — the org document —
+ * because that is the one handle this function holds on the org. `parent`
+ * is `null` only for a root collection, which an org subcollection never
+ * is; answered as `null` rather than thrown so a count that has nowhere to
+ * land is skipped, and never costs the capture.
+ */ function companiesBeside(contactsRef) {
+    const parent = contactsRef.parent;
+    return parent ? parent.collection(CRM_COLLECTIONS.companies) : null;
+}
+/**
+ * Tags as the profile drawer stores them: trimmed, lowercased, deduplicated
+ * and capped at twenty — so an imported `VIP` and a typed `vip` are one tag.
+ */ function normalizeTags(tags) {
+    return [
+        ...new Set((tags != null ? tags : []).map((tag)=>String(tag != null ? tag : '').trim().toLowerCase()).filter(Boolean))
+    ].slice(0, 20);
+}
+export async function upsertHostContact(options) {
+    try {
+        var _options_interaction_atMs, _options_campaignIds, _ref, _contactsRef_parent, _ref1, _ref2;
+        var _options_facet, _orgBilling_org;
+        const email = normalizeContactEmail(options.email);
+        if (!email) return {
+            refused: 'invalid-email'
+        };
+        const tags = normalizeTags(options.tags);
+        /*==========================================
+     * THE PURCHASE DOOR, AND THEREFORE THE ATTRIBUTION DOOR.
+     *
+     * Every way of buying something in this product — the cart, buy-now, the
+     * POS register, a draft order, a reservation, a subscription renewal, a
+     * booking — announces itself here, in exactly one shape: source `order`,
+     * a `purchaseCents` amount, and a `refId` naming what was bought. That
+     * shape IS the purchase chokepoint, which is why the revenue join hangs
+     * off it rather than off seven call sites in a webhook.
+     *
+     * ABOVE the audience-band gate below, and deliberately. Contact creation
+     * is band gated, so a Free org past its included count drops the CRM
+     * record — and an attribution written inside that branch would drop the
+     * revenue with it. The join keys on the address hash, exactly as the
+     * touch and the suppression list do, so it never needs a contact document
+     * to exist: a guest checkout by somebody who is not and never becomes a
+     * contact still credits the campaign whose link they clicked.
+     *
+     * Its own `catch`, inside a function that already swallows: this is the
+     * least important write on the path, and a failure here must not cost the
+     * contact capture below it.
+     *=========================================*/ if (options.source === 'order' && options.interaction.refId) {
+            var _options_purchaseCents, _options_interaction_atMs1;
+            await attributeOrderToEmail(_extends({
+                hostId: options.hostId,
+                orderId: String(options.interaction.refId),
+                email,
+                amountCents: Number((_options_purchaseCents = options.purchaseCents) != null ? _options_purchaseCents : 0)
+            }, options.purchaseCurrency ? {
+                currency: options.purchaseCurrency
+            } : {}, {
+                orderedAtMs: (_options_interaction_atMs1 = options.interaction.atMs) != null ? _options_interaction_atMs1 : Date.now()
+            })).catch(()=>null);
+        }
+        const firestore = firebaseAdmin.app().firestore();
+        const hostRef = firestore.collection('hosts').doc(options.hostId);
+        // Contacts are org-scoped (AGL-237): every host in the org feeds one
+        // shared list.
+        const contactsRef = await orgDataCollectionForHost(options.hostId, 'contacts');
+        /*
+     * The consent group this capture belongs to — the sites declared to be
+     * one sender, or this site alone. Resolved once and used for three
+     * different decisions below, which must all agree: which controller the
+     * basis is recorded for, which sites the row becomes visible to, and
+     * whether the capture surface had to disclose anything.
+     */ const group = await consentGroupForSite(options.hostId);
+        /*
+     * THE CONSENT ENTRY THIS CAPTURE WRITES, decided once for both branches.
+     *
+     * A grant outranks a refusal flag set beside it — one door cannot mean
+     * both — and neither writes anything when the door carried no act, so
+     * an unticked box stays the third state. The provenance rides inside the
+     * per-host entry, where the reader looks for it, never at the top of a
+     * document every brand in the org shares.
+     */ const consentExtra = options.marketingConsentSource ? {
+            [MARKETING_CONSENT_SOURCE_FIELD]: options.marketingConsentSource
+        } : undefined;
+        const consentFields = options.marketingConsent ? marketingConsentFieldsForGroup(group, Date.now(), consentExtra) : options.declineMarketingConsent ? declineMarketingConsentFields(options.hostId, Date.now(), consentExtra) : {};
+        const interaction = _extends({
+            type: options.source,
+            atMs: (_options_interaction_atMs = options.interaction.atMs) != null ? _options_interaction_atMs : Date.now(),
+            // WHICH SITE this visit happened on. The row is shared; the history on
+            // it is not, and a timeline with no site cannot be split for an
+            // agency's client without showing them another client's activity.
+            hostId: options.hostId
+        }, options.interaction.refId ? {
+            refId: options.interaction.refId
+        } : {}, options.interaction.summary ? {
+            summary: options.interaction.summary.slice(0, 200)
+        } : {}, options.interaction.formId ? {
+            formId: String(options.interaction.formId).slice(0, 128)
+        } : {}, options.interaction.path ? {
+            path: String(options.interaction.path).slice(0, 500)
+        } : {});
+        /*
+     * THE CAMPAIGNS THIS CAPTURE FILES THE PERSON UNDER.
+     *
+     * Normalized here rather than trusted, because it reaches this function
+     * from a public endpoint's document read and every reader of the stored
+     * array goes through the same coercion.
+     */ const campaignIds = normalizeCampaignIds((_options_campaignIds = options.campaignIds) != null ? _options_campaignIds : []);
+        /*
+     * THE CUSTOM FIELD VALUES THIS CAPTURE CARRIES, as one nested map.
+     *
+     * Only the keys the door resolved. Written in the NESTED form because both
+     * writes below are merge-sets, which deep-merge a map one key at a time:
+     * `custom: { tier: 'Gold' }` lands beside an existing `custom.vip` and
+     * leaves it standing. A dotted `facets.h1.custom.tier` path would be a
+     * literal field name to a `set`, and a `custom` written whole would take
+     * every other key with it.
+     */ const customEntries = Object.entries((_ref = (_options_facet = options.facet) == null ? void 0 : _options_facet.custom) != null ? _ref : {});
+        const customFacet = customEntries.length ? {
+            custom: Object.fromEntries(customEntries)
+        } : {};
+        /*==========================================
+     * THE DEDUPE LOOKUP IS UNSCOPED, AND HAS TO BE.
+     *
+     * One human who touched two sites is ONE person. Narrowing this read to
+     * what the capturing site may already see would make a second submission
+     * on a sibling brand create a SECOND document for the same address —
+     * which loses the dedupe the shared address book exists for, and bills
+     * the org twice for one human.
+     *
+     * Recognizing somebody is not the same act as being allowed to read their
+     * row, and the two were the same query while every contact was stamped
+     * org-wide. They are separated here: this finds the person, and
+     * `visibleTo` below decides who may see them — widened by the capture
+     * that just happened, never by the lookup that found them.
+     *
+     * THROUGH THE ADDRESS INDEX FIRST (AGL-2625). A person whose two records
+     * were merged answers to two addresses, and only one of them is the
+     * document's `email`; the index is what lets a capture on the other one
+     * land on the survivor instead of minting the duplicate again. The query
+     * stays as the fallback, so a row the index has not seen costs one extra
+     * read once and needs no backfill.
+     *=========================================*/ const docSnapshot = await findContactByEmail(contactsRef, email);
+        if (docSnapshot) {
+            var _facet_name, _profile_lifecycleStage;
+            /*
+       * MERGED INTO THIS GROUP'S FACET, not into the top of the document.
+       *
+       * `sources`, `interactions`, the tags, the notes and every commercial
+       * figure are the HOLDER's own business records: a booking taken by one
+       * client of an agency is that client's, and while these lived at the
+       * top of a shared row every other client could read them. The identity
+       * — the address, and a canonical name for a holder that has set none of
+       * its own — stays shared, because that is what makes this one row.
+       */ const facet = readContactFacet(docSnapshot.data(), group.groupId);
+            const merged = mergeContactInteraction({
+                name: (_facet_name = facet.name) != null ? _facet_name : undefined,
+                sources: facet.sources,
+                interactions: facet.interactions
+            }, {
+                source: options.source,
+                interaction,
+                name: options.name
+            });
+            /*
+       * THE PROFILE, as this door knows it (AGL-2596).
+       *
+       * Given keys only, so the merge below leaves untouched whatever another
+       * door wrote. The stage is the one field with a rule of its own: the
+       * door's `initialLifecycleStage` fills an empty stage and advances an
+       * earlier one, and never moves anybody back —
+       * `advanceContactLifecycleStage` is that rule, applied to the stage
+       * this door asked for outright or, failing that, the one already
+       * stored. Written only when it comes back with something: a door that
+       * named no stage and found none leaves the key absent, which reads as
+       * "no stage" rather than as a stage somebody picked.
+       */ const profile = storableProfile(options.facet);
+            const advanced = advanceContactLifecycleStage((_profile_lifecycleStage = profile.lifecycleStage) != null ? _profile_lifecycleStage : facet.lifecycleStage, options.initialLifecycleStage);
+            if (advanced) profile.lifecycleStage = advanced;
+            /*
+       * THE FORM MIRROR, bounded (see `HostContact.formIds`).
+       *
+       * Read off the document the lookup already fetched, so the bound costs
+       * no extra read: a person who has come in through twenty forms keeps
+       * the twenty, and this capture's form stays on the interaction alone.
+       * `arrayUnion` for the add, so a concurrent capture on a sibling site
+       * cannot drop this one's id.
+       */ const heldFormIds = Array.isArray(docSnapshot.get(CONTACT_FORM_IDS_FIELD)) ? docSnapshot.get(CONTACT_FORM_IDS_FIELD) : [];
+            const formIdToAdd = interaction.formId && !heldFormIds.includes(interaction.formId) && heldFormIds.length < CONTACT_FORM_IDS_CAP ? interaction.formId : null;
+            /*
+       * THE COMPANY LINK, when the door carried one (AGL-2613).
+       *
+       * The facet's `companyId` is written with the rest of the profile
+       * below, but the facet is not the whole association: the top-level
+       * `companyIds` mirror is what the company page queries, and the
+       * company's `contactsCount` is what the companies list shows. The
+       * planner reads the row as it stands — this holder's previous link,
+       * the mirror, the other holders' ids — and says what the mirror
+       * becomes and which counts move; the mirror change rides in this same
+       * merge-set, and the counts settle after it.
+       */ const link = profile.companyId !== undefined ? planContactCompanyLink(readContactCompanyLink(docSnapshot.data(), group.groupId), profile.companyId) : null;
+            const mirror = link ? contactCompanyMirrorValue(link) : undefined;
+            await docSnapshot.ref.set(_extends({}, merged.name ? nameSearchFields(merged.name) : {}, profile.phone ? {
+                phone: profile.phone
+            } : {}, mirror !== undefined ? {
+                [CONTACT_COMPANY_IDS_FIELD]: mirror
+            } : {}, {
+                /*
+           * NESTED, not dot-pathed. This is a `set(…, { merge: true })`, and
+           * a merge-set treats a key containing dots as a literal field name
+           * — only `update()` reads them as paths. The nested form is what
+           * Firestore deep-merges, so this writes one holder's facet and
+           * leaves every other holder's untouched.
+           */ [CONTACT_FACETS_FIELD]: {
+                    [group.groupId]: _extends({
+                        sources: merged.sources,
+                        interactions: merged.interactions
+                    }, merged.name ? {
+                        name: merged.name
+                    } : {}, campaignIds.length ? {
+                        campaignIds: FieldValue.arrayUnion(...campaignIds)
+                    } : {}, tags.length ? {
+                        tags: FieldValue.arrayUnion(...tags)
+                    } : {}, profile, options.purchaseCents ? _extends({
+                        ltvCents: FieldValue.increment(options.purchaseCents),
+                        ordersCount: FieldValue.increment(1),
+                        lastPurchaseAtMs: Date.now()
+                    }, facet.firstPurchaseAtMs ? {} : {
+                        firstPurchaseAtMs: Date.now()
+                    }) : {})
+                },
+                /*
+           * ATTRIBUTION GROWS ON THE MERGE BRANCH, which the create-only
+           * `hostId` beside it never did — so a person the first site
+           * captured and the second site later met read as the first site's
+           * alone, forever.
+           *
+           * `arrayUnion`, so the audience filter "everyone captured on A, B
+           * or C" answers with the sites that actually met this person.
+           */ [CAPTURED_BY_HOST_FIELD]: FieldValue.arrayUnion(options.hostId)
+            }, formIdToAdd ? {
+                [CONTACT_FORM_IDS_FIELD]: FieldValue.arrayUnion(formIdToAdd)
+            } : {}, {
+                /*
+           * AND SO DOES VISIBILITY — by the capture, never by the lookup.
+           *
+           * This site just collected this person: it has its own relationship
+           * with them and may see the row. A site that has never captured
+           * them gains nothing here, which is what keeps an agency's clients
+           * apart on a document all of them share. The per-interaction
+           * `hostId` above is what keeps the HISTORY apart on the same row.
+           */ visibleTo: FieldValue.arrayUnion(...consentGroupScope(group))
+            }, consentFields, {
+                updatedAt: FieldValue.serverTimestamp()
+            }), {
+                merge: true
+            });
+            await settleCompanyContactsCounts(companiesBeside(contactsRef), link);
+            return {
+                contactId: docSnapshot.id,
+                created: false
+            };
+        }
+        /*
+     * THE ERASED PERSON DOES NOT COME BACK (AGL-2623).
+     *
+     * Before the band, on the CREATE branch only — the one read this adds
+     * is paid by a capture that would otherwise make a new row, never by
+     * the merge above. An erasure wrote a row on this site's suppression
+     * list with no address on it; finding that row here is what keeps the
+     * next form fill or checkout from rebuilding the record the workspace
+     * just erased. The order or booking that triggered the capture still
+     * succeeds, exactly as it does when the band refuses: the person bought
+     * something, and the merchant's record of the sale is not the CRM's
+     * record of the person.
+     */ if (await hostRefusesCaptureForErasure(options.hostId, email, firestore)) {
+            return {
+                refused: 'erased'
+            };
+        }
+        // New contact: records-band check via the aggregate counts (cheap; no
+        // doc reads) against the owning org's entitlements (AGL-238/890).
+        // Metered plans always pass (overage bills via the report-usage
+        // cron); only free's hard band drops the CRM record — visibly, via
+        // the counter and the console alert (AGL-891). The signup/order that
+        // triggered the capture always succeeds either way.
+        //
+        // THE RECORDS BAND, not the contacts headcount (AGL-2611): companies
+        // and deals share this band, so a capture is refused on a Free org
+        // whose hundred records are ninety companies and ten people — the same
+        // verdict the company drawer would give the ninety-first company.
+        // `contactsRef` is handed in so the contacts aggregate is the one this
+        // door already reads; the org reference is its parent.
+        const orgBilling = await getOrgForHost(options.hostId);
+        const orgRef = (_contactsRef_parent = contactsRef.parent) != null ? _contactsRef_parent : firestore.collection('orgs').doc(String((_ref1 = orgBilling == null ? void 0 : orgBilling.orgId) != null ? _ref1 : ''));
+        const { crmRecordsCount } = await countCrmRecords(orgRef, contactsRef);
+        const quota = checkCrmRecordsQuota((_ref2 = orgBilling == null ? void 0 : orgBilling.org) != null ? _ref2 : null, crmRecordsCount);
+        if (!quota.allowed) {
+            await hostRef.collection('counters').doc('contactsDropped').set({
+                total: FieldValue.increment(1)
+            }, {
+                merge: true
+            });
+            return {
+                refused: 'band'
+            };
+        }
+        /*
+     * The profile on a create, with the door's stage floor applied the same
+     * way as on a merge — there is no stored stage yet, so the floor is what
+     * a door that named one writes. A `null` address is dropped rather than
+     * written: there is nothing on a new document for it to clear.
+     */ const profile = storableProfile(options.facet);
+        const advanced = advanceContactLifecycleStage(profile.lifecycleStage, options.initialLifecycleStage);
+        if (advanced) profile.lifecycleStage = advanced;
+        if (profile.address === null) delete profile.address;
+        const created = await contactsRef.add(_extends({
+            hostId: options.hostId,
+            /*
+       * WHICH SITES HAVE MET THIS PERSON — attribution, and separate from
+       * consent above.
+       *
+       * The scalar `hostId` beside it names the FIRST capturing site and is
+       * never rewritten, which is provenance for the ROW. This array is the
+       * one that grows and the one an audience query can filter on.
+       */ [CAPTURED_BY_HOST_FIELD]: [
+                options.hostId
+            ]
+        }, interaction.formId ? {
+            [CONTACT_FORM_IDS_FIELD]: [
+                interaction.formId
+            ]
+        } : {}, {
+            /*
+       * THE CAPTURING GROUP, not the whole org.
+       *
+       * Stamping `['org']` here made every contact readable by every site in
+       * the account on the day it was created — so an agency's twelve clients
+       * shared one address book by default, and closing the missing-field
+       * fail-open would not have touched it, because the field was present
+       * and said so.
+       *
+       * A group of one — the default — is this site alone. A declared group
+       * is the sites that already present as one sender. Widening beyond that
+       * is available and is an ACT: an org may set `defaultResourceScope` to
+       * `'org'`, or a later capture on a sibling site unions that site in.
+       */ visibleTo: (orgBilling == null ? void 0 : (_orgBilling_org = orgBilling.org) == null ? void 0 : _orgBilling_org.defaultResourceScope) === 'org' ? [
+                ORG_SCOPE_TOKEN
+            ] : consentGroupScope(group),
+            email
+        }, options.name ? nameSearchFields(options.name.slice(0, 120)) : {}, profile.phone ? {
+            phone: profile.phone
+        } : {}, profile.companyId ? {
+            [CONTACT_COMPANY_IDS_FIELD]: [
+                profile.companyId
+            ]
+        } : {}, {
+            // The facet this capture creates. Everything a holder owns lives under
+            // its own group id; the address and the canonical name above are the
+            // only shared identity.
+            [CONTACT_FACETS_FIELD]: {
+                [group.groupId]: _extends({
+                    sources: {
+                        [options.source]: true
+                    },
+                    interactions: [
+                        interaction
+                    ],
+                    tags
+                }, campaignIds.length ? {
+                    campaignIds
+                } : {}, customFacet, options.name ? {
+                    name: options.name.slice(0, 120)
+                } : {}, profile, options.purchaseCents ? {
+                    ltvCents: options.purchaseCents,
+                    ordersCount: 1,
+                    lastPurchaseAtMs: Date.now(),
+                    firstPurchaseAtMs: Date.now()
+                } : {})
+            }
+        }, consentFields, {
+            createdAt: FieldValue.serverTimestamp(),
+            updatedAt: FieldValue.serverTimestamp()
+        }));
+        // The address now resolves to this row (AGL-2625). Its own catch inside
+        // the writer, so an index the capture could not reach costs nothing.
+        await writeContactEmailIndex(emailIndexBeside(contactsRef), created.id, [
+            email
+        ]);
+        // The company the door named now has one more contact naming it
+        // (AGL-2613) — the fresh row's plan is the trivial one, nothing held
+        // before and nothing held elsewhere.
+        if (profile.companyId) {
+            await settleCompanyContactsCounts(companiesBeside(contactsRef), planContactCompanyLink({
+                companyId: null,
+                companyIds: [],
+                heldElsewhere: []
+            }, profile.companyId));
+        }
+        /*
+     * ATTRIBUTED ON CREATION ONLY, and therefore below the band gate rather
+     * than above it — the opposite placement to the order join at the top of
+     * this function, deliberately.
+     *
+     * The order join sits above because it credits MONEY, which is real
+     * whether or not a CRM record was kept for the buyer, and a Free org past
+     * its included band would otherwise silently drop the revenue with the
+     * contact. This credits a contact, which does not exist when the band
+     * dropped it: attributing one above the gate would report a campaign as
+     * having produced people the customer cannot see anywhere in the console.
+     *
+     * The existing-contact branch above returns without reaching here, which
+     * is the same rule `addHostLead` applies — an interaction appended to
+     * somebody the site already held is another visit, not a new person, and
+     * crediting it would let the most recent campaign re-earn the whole list.
+     */ if (options.campaignTouch) {
+            await attributeCampaignConversion({
+                hostId: options.hostId,
+                kind: 'contact',
+                refId: created.id,
+                touch: options.campaignTouch,
+                convertedAtMs: interaction.atMs
+            });
+        }
+        /*
+     * REPORTED ON CREATION ONLY, below the band gate for the reason the
+     * attribution above is: a contact the band dropped does not exist, and
+     * an automation told about it would act on a person the console cannot
+     * show. The merge branch returned long before this line, so a repeat
+     * visit by somebody already held is never announced as a new contact.
+     */ if (options.onCreated) {
+            await Promise.resolve(options.onCreated(_extends({
+                contactId: created.id,
+                hostId: options.hostId,
+                email
+            }, options.name ? {
+                name: options.name.slice(0, 120)
+            } : {}, {
+                source: options.source,
+                campaignIds
+            }, profile.lifecycleStage ? {
+                lifecycleStage: profile.lifecycleStage
+            } : {}))).catch((error)=>{
+                console.error('upsertHostContact onCreated failed', error);
+            });
+        }
+        return {
+            contactId: created.id,
+            created: true
+        };
+    } catch (error) {
+        console.error('upsertHostContact failed', error);
+        return {
+            refused: 'error'
+        };
+    }
+}
+
+//# sourceMappingURL=upsert-contact.js.map