@aglyn/plugins-crm 1.0.0-beta.221 → 1.0.0-beta.223

package/src/lib/server/assign-contact-owner.d.ts

@@ -0,0 +1,188 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { type ContactSource, type CrmAssignmentTarget } from '@aglyn/aglyn/server';
+/**
+ * WHO A NEW RECORD BELONGS TO — the one place an owner is decided on the
+ * server (AGL-2618).
+ *
+ * Two entry points over one transaction. `assignOwnerForCapture` is the
+ * capture door's pass: it runs the org's assignment rules in order, falls
+ * back to the capturing site's default owner, and touches only a record
+ * that has NO 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. `reassignContactOwner` is the automation's: an author who put
+ * "assign an owner" on a stage change means to reassign, and the step hands
+ * this either a member or the rotation.
+ *
+ * ## One transaction, because the pointer is shared
+ *
+ * The round-robin pool's pointer lives on the org document, and two
+ * captures landing together must take two different members. Firestore
+ * transactions serialize on what they read, so the org document, the
+ * contact and the roster documents are all read inside the transaction and
+ * the pointer is advanced in the same commit that writes the owner: a
+ * concurrent capture that read the same pointer retries and reads the moved
+ * one. The alternative — read the pointer, decide, then write — is exactly
+ * the read-then-write shape that lets two captures pick the same person.
+ *
+ * ## The roster is checked, once per member per attempt
+ *
+ * A rule may name a member who has since left, and a pool may hold one. A
+ * rule naming nobody on the roster is passed over rather than stopping the
+ * pass — the next rule may well assign — and a pool member who is gone is
+ * skipped for the next in the order. `orgs/{orgId}/members/{uid}` is keyed
+ * by uid, so the check is one document read per candidate, and only the
+ * roster is consulted: a project-level Auth lookup would admit people who
+ * are not on this organization at all (AGL-1122).
+ *
+ * ## The lead follows the contact
+ *
+ * The capture doors that file a lead (`addHostLead`: a form routed to leads,
+ * a sign-up, a booking) key it by `personKey(email)`, so the lead's document
+ * is addressable from the capture alone. When it exists it is given the same
+ * owner in the same transaction; two doors write the lead AFTER the contact
+ * they `void`ed, so for those sources the mirror is retried a few times over
+ * the next seconds, detached, and the person's Leads list shows the owner
+ * as soon as the lead is there.
+ *
+ * ## The owner is told, unless they chose themselves
+ *
+ * One console notification per assignment, for the record the recipient
+ * will open: the lead when the site holds one for this person, the contact
+ * otherwise. Not when the actor IS the new owner — a rep who converts a
+ * lead into their own contact has not been handed anything.
+ *
+ * ## Never rejects
+ *
+ * The capture has already succeeded and a form submission must not fail
+ * because the CRM could not decide who follows up; a failure is logged and
+ * answered as `none`, and the record is exactly as assignable by hand as it
+ * was before this existed. The automation executor turns a `none` into the
+ * step's recorded error.
+ */
+export interface OwnerAssignmentInput {
+    hostId: string;
+    /** `orgs/{orgId}/contacts/{contactId}` — the record the owner is written on. */
+    contactId: string;
+    /** The contact's address, which keys the lead and names the person in the notification. */
+    email: string;
+    /**
+     * The signed-in person making the assignment, when there is one. Never
+     * notified about their own choice; absent for a capture and an automation.
+     */
+    actorUid?: string | null;
+}
+export interface CaptureAssignmentInput extends OwnerAssignmentInput {
+    source: ContactSource;
+    /** The form the capture came through, for a rule conditioned on it. */
+    formId?: string | null;
+    /** The tags the capture carried; the contact's own are read from the facet. */
+    tags?: readonly string[];
+}
+export interface ReassignmentInput extends OwnerAssignmentInput {
+    assign: CrmAssignmentTarget;
+}
+/** Why an assignment assigned nobody — the automation reports these verbatim. */
+export type OwnerAssignmentRefusal = 'no-org' | 'no-contact' | 'no-lead' | 'no-rule' | 'empty-pool' | 'not-a-member' | 'failed';
+/** What decided an assignment: a rule, the site default, the step's member, or the rotation. */
+export type OwnerAssignedBy = 'rule' | 'default' | 'member' | 'roundRobin';
+export type OwnerAssignment = {
+    outcome: 'assigned';
+    ownerUid: string;
+    by: OwnerAssignedBy;
+    /** The rule that decided it, when one did. */
+    ruleId?: string;
+    /** The lead document existed and now carries the owner too. */
+    leadMirrored: boolean;
+    /** A notification was fanned out to the new owner. */
+    notified: boolean;
+}
+/** The record already had this owner (a capture), or the same one was named again (a reassignment). */
+ | {
+    outcome: 'unchanged';
+    ownerUid: string;
+} | {
+    outcome: 'none';
+    reason: OwnerAssignmentRefusal;
+};
+/** The words the run history and the log give each refusal. */
+export declare const OWNER_ASSIGNMENT_REFUSALS: Record<OwnerAssignmentRefusal, string>;
+/** The record an assignment notification opens. */
+export type AssignedRecord = {
+    kind: 'contact';
+    id: string;
+} | {
+    kind: 'lead';
+    id: string;
+};
+/**
+ * Tells a member a record is now theirs — one console notification, typed
+ * by the record it opens — unless the member handed it to themselves.
+ * Shared by the pass above and by the routes where a person picks the
+ * owner outright (a lead conversion naming a colleague), so every server
+ * path that writes `ownerUid` says so in the same words. Never throws;
+ * the fan-out swallows its own failures.
+ */
+export declare function notifyRecordAssigned(input: {
+    hostId: string;
+    orgId: string;
+    ownerUid: string;
+    actorUid?: string | null;
+    record: AssignedRecord;
+    /** How the person reads in the message: their name, else their address. */
+    who: string;
+}): Promise<boolean>;
+/**
+ * The capture door's pass: the org's rules in order, then the capturing
+ * site's default owner, on a record that has no owner yet. See the module
+ * comment for the whole of it.
+ */
+export declare function assignOwnerForCapture(input: CaptureAssignmentInput): Promise<OwnerAssignment>;
+/**
+ * The deliberate assignment — the `assignContactOwner` step, and a person
+ * handing a record to somebody: a member by uid (verified on the roster) or
+ * the next in the round-robin pool, overwriting whoever held it. Naming the
+ * owner the record already has changes nothing and tells nobody.
+ */
+export declare function reassignContactOwner(input: ReassignmentInput): Promise<OwnerAssignment>;
+/** The deliberate assignment of a LEAD the site holds and no contact has absorbed yet. */
+export interface LeadReassignmentInput {
+    hostId: string;
+    /** `orgs/{orgId}/leads/{leadId}` — the person's key. */
+    leadId: string;
+    assign: CrmAssignmentTarget;
+    /** As {@link OwnerAssignmentInput.actorUid}: never told about their own choice. */
+    actorUid?: string | null;
+}
+/**
+ * {@link reassignContactOwner} for a person who is still a LEAD (AGL-3458).
+ *
+ * A lead-routed form files a lead and no contact (AGL-3232), so an
+ * automation welcoming that person — "assign an owner, then book them a
+ * call" — has only the lead to act on. The owner is the lead's own
+ * `ownerUid`, the field the Leads list's Owner column and filter read and a
+ * conversion hands to the contact. Same transaction shape as a contact's:
+ * the org document, the lead and every roster candidate are read inside it,
+ * and the round-robin pointer moves in the commit that writes the owner, so
+ * a lead and a contact assigned at the same moment take two different
+ * members of the one rotation.
+ *
+ * Never rejects; a failure is logged and answered as `none`, which the
+ * automation records as the step's error.
+ */
+export declare function reassignLeadOwner(input: LeadReassignmentInput): Promise<OwnerAssignment>;
+export default assignOwnerForCapture;

package/src/lib/server/assign-contact-owner.js

@@ -0,0 +1,446 @@
+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 { assignmentRuleMatches, consentGroupForHost, contactFacetPath, CRM_ROUND_ROBIN_LAST_ASSIGNED_PATH, personKey, readContactFacet, readCrmAssignmentSettings, roundRobinOrder } from "@aglyn/aglyn/server";
+import { firebaseAdmin, getHostDocAdmin, getOrgForHost, hostDisplayName, notifyUsers, restampCrmListFieldsAt } from "@aglyn/tenant-data-admin";
+import { FieldValue } from "firebase-admin/firestore";
+/** The words the run history and the log give each refusal. */ export const OWNER_ASSIGNMENT_REFUSALS = {
+    'no-org': 'this site has no organization',
+    'no-contact': 'the contact no longer exists',
+    'no-lead': 'the lead no longer exists',
+    'no-rule': 'no assignment rule matched and the site has no default owner',
+    'empty-pool': 'the round-robin pool has nobody on the roster in it',
+    'not-a-member': 'the owner named is not on the team',
+    failed: 'the owner could not be assigned'
+};
+/**
+ * The doors whose lead lands after the contact they `void`ed — the ones the
+ * mirror is worth retrying for. An order, an import, a manual add and an
+ * API call file no lead, and a retry for them would be reads for nothing.
+ */ const LEAD_FILING_SOURCES = new Set([
+    'form',
+    'member',
+    'booking'
+]);
+/** How long the detached lead mirror waits between its looks, in order. */ const LEAD_MIRROR_RETRY_MS = [
+    1000,
+    2000,
+    3000
+];
+/**
+ * The console path the owner's notification opens, in the `/{hostDocId}/rest`
+ * shape every host notification uses — the console rewrites it to
+ * `/{orgSlug}/hosts/{subdomain}/rest` when the link is followed, which is
+ * why `hostId` and `orgId` travel on the document. The same spelling the
+ * CRM's task notification uses; the hub's own route builder lives in the
+ * plugin, which this layer cannot import.
+ */ function recordLink(hostId, record) {
+    const section = record.kind === 'contact' ? 'contacts' : 'leads';
+    return `/${hostId}/crm/${section}/${encodeURIComponent(record.id)}`;
+}
+/**
+ * Tells a member a record is now theirs — one console notification, typed
+ * by the record it opens — unless the member handed it to themselves.
+ * Shared by the pass above and by the routes where a person picks the
+ * owner outright (a lead conversion naming a colleague), so every server
+ * path that writes `ownerUid` says so in the same words. Never throws;
+ * the fan-out swallows its own failures.
+ */ export async function notifyRecordAssigned(input) {
+    var _input_actorUid;
+    if (!input.ownerUid || input.ownerUid === ((_input_actorUid = input.actorUid) != null ? _input_actorUid : '')) return false;
+    const lead = input.record.kind === 'lead';
+    /*
+   * THE BODY SAYS WHAT HAPPENED, AND ON WHICH SITE (AGL-3432).
+   *
+   * It was the bare name, so a member who owns records on several sites read
+   * "Ada" in an email body and could not tell what Ada was or where. The
+   * site's name is one request-cached read of a document most callers have
+   * already paid for, taken only when somebody is actually notified; a read
+   * that fails drops the "on {site}" clause rather than the notification.
+   */ let site = '';
+    try {
+        const host = await getHostDocAdmin(input.hostId);
+        if (host) site = ` on ${hostDisplayName(host, input.hostId)}`;
+    } catch (unused) {
+    // The clause goes, never the notification.
+    }
+    await notifyUsers([
+        input.ownerUid
+    ], {
+        type: lead ? 'content.leadAssigned' : 'content.contactAssigned',
+        title: lead ? 'Lead assigned to you' : 'Contact assigned to you',
+        body: `${input.who} was assigned to you as a ${lead ? 'lead' : 'contact'}${site}.`,
+        link: recordLink(input.hostId, input.record),
+        orgId: input.orgId,
+        hostId: input.hostId
+    });
+    return true;
+}
+/**
+ * The roster checks one assignment transaction makes: whether a uid is on the
+ * team, and who a target names — a member as named, or the next member of
+ * the round-robin pool who is still on the roster. One read per candidate
+ * per attempt; a retried transaction builds a fresh one and reads afresh, as
+ * it must.
+ */ function rosterResolver(tx, membersRef, settings) {
+    const onRoster = new Map();
+    const isMember = (uid)=>{
+        let known = onRoster.get(uid);
+        if (!known) {
+            known = tx.get(membersRef.doc(uid)).then((snapshot)=>snapshot.exists);
+            onRoster.set(uid, known);
+        }
+        return known;
+    };
+    const fromPool = async ()=>{
+        for (const uid of roundRobinOrder(settings.pool.memberUids, settings.pool.lastAssignedUid)){
+            if (await isMember(uid)) return uid;
+        }
+        return null;
+    };
+    const resolveTarget = async (target)=>{
+        if ('roundRobin' in target) {
+            const uid = await fromPool();
+            return uid ? {
+                uid,
+                advancePointer: true
+            } : null;
+        }
+        return await isMember(target.memberUid) ? {
+            uid: target.memberUid,
+            advancePointer: false
+        } : null;
+    };
+    return {
+        isMember,
+        resolveTarget
+    };
+}
+async function assignOwner(policy) {
+    const { input } = policy;
+    try {
+        const resolved = await getOrgForHost(input.hostId);
+        if (!resolved) return {
+            outcome: 'none',
+            reason: 'no-org'
+        };
+        const { orgId } = resolved;
+        const firestore = firebaseAdmin.app().firestore();
+        const orgRef = firestore.collection('orgs').doc(orgId);
+        const contactRef = orgRef.collection('contacts').doc(input.contactId);
+        const membersRef = orgRef.collection('members');
+        const leadKey = personKey(input.email);
+        // Beside the contact on the org, keyed by the same address (AGL-3275).
+        const leadRef = leadKey ? orgRef.collection('leads').doc(leadKey) : null;
+        let contactName = '';
+        const verdict = await firestore.runTransaction(async (tx)=>{
+            var _orgSnapshot_data, _contactSnapshot_data, _contact_name, _ref;
+            /*
+         * ALL READS BEFORE THE WRITE, which Firestore requires. The org
+         * document is read here rather than trusted from `getOrgForHost`,
+         * because the pointer it carries is the one thing a concurrent
+         * capture may have moved, and the rules and the pool are read from
+         * the same snapshot so the decision and the pointer agree.
+         */ const [orgSnapshot, contactSnapshot, leadSnapshot] = await Promise.all([
+                tx.get(orgRef),
+                tx.get(contactRef),
+                leadRef ? tx.get(leadRef) : Promise.resolve(null)
+            ]);
+            if (!contactSnapshot.exists) {
+                return {
+                    outcome: 'none',
+                    reason: 'no-contact'
+                };
+            }
+            const org = (_orgSnapshot_data = orgSnapshot.data()) != null ? _orgSnapshot_data : {};
+            const contact = (_contactSnapshot_data = contactSnapshot.data()) != null ? _contactSnapshot_data : {};
+            contactName = String((_contact_name = contact['name']) != null ? _contact_name : '');
+            const group = consentGroupForHost(org, input.hostId);
+            const facet = readContactFacet(contact, group.groupId);
+            const current = typeof facet.ownerUid === 'string' ? facet.ownerUid : '';
+            if (policy.kind === 'capture' && current) {
+                return {
+                    outcome: 'unchanged',
+                    ownerUid: current
+                };
+            }
+            const settings = readCrmAssignmentSettings(org);
+            const { isMember, resolveTarget } = rosterResolver(tx, membersRef, settings);
+            let decision = null;
+            let refusal = 'no-rule';
+            if (policy.kind === 'capture') {
+                var _policy_input_formId, _policy_input_tags, _facet_tags;
+                const capture = {
+                    source: policy.input.source,
+                    email: input.email,
+                    formId: (_policy_input_formId = policy.input.formId) != null ? _policy_input_formId : null,
+                    tags: [
+                        ...(_policy_input_tags = policy.input.tags) != null ? _policy_input_tags : [],
+                        ...(_facet_tags = facet.tags) != null ? _facet_tags : []
+                    ]
+                };
+                for (const rule of settings.rules){
+                    if (!assignmentRuleMatches(rule.when, capture)) continue;
+                    const hit = await resolveTarget(rule.assign);
+                    if (hit) {
+                        decision = _extends({}, hit, {
+                            ownerUid: hit.uid,
+                            by: 'rule',
+                            ruleId: rule.id
+                        });
+                        break;
+                    }
+                }
+                const fallback = settings.hostDefaultOwners[input.hostId];
+                if (!decision && fallback && await isMember(fallback)) {
+                    decision = {
+                        ownerUid: fallback,
+                        by: 'default',
+                        advancePointer: false
+                    };
+                }
+            } else {
+                const { assign } = policy.input;
+                const hit = await resolveTarget(assign);
+                if (hit) {
+                    decision = _extends({}, hit, {
+                        ownerUid: hit.uid,
+                        by: 'roundRobin' in assign ? 'roundRobin' : 'member'
+                    });
+                } else {
+                    refusal = 'roundRobin' in assign ? 'empty-pool' : 'not-a-member';
+                }
+            }
+            if (!decision) return {
+                outcome: 'none',
+                reason: refusal
+            };
+            if (decision.ownerUid === current) {
+                return {
+                    outcome: 'unchanged',
+                    ownerUid: current
+                };
+            }
+            tx.update(contactRef, {
+                [contactFacetPath(group.groupId, 'ownerUid')]: decision.ownerUid,
+                updatedAt: FieldValue.serverTimestamp()
+            });
+            if (decision.advancePointer) {
+                tx.update(orgRef, {
+                    [CRM_ROUND_ROBIN_LAST_ASSIGNED_PATH]: decision.ownerUid
+                });
+            }
+            /*
+         * A lead somebody already assigned by hand keeps its owner on a
+         * capture — the contact was new, the lead may not have been — and
+         * follows the contact on a deliberate reassignment.
+         */ const leadOwner = String((_ref = leadSnapshot == null ? void 0 : leadSnapshot.get('ownerUid')) != null ? _ref : '');
+            const leadMirrored = Boolean((leadSnapshot == null ? void 0 : leadSnapshot.exists) && (policy.kind === 'reassign' || !leadOwner));
+            if (leadMirrored && leadRef) {
+                tx.update(leadRef, {
+                    ownerUid: decision.ownerUid,
+                    updatedAt: FieldValue.serverTimestamp()
+                });
+            }
+            return _extends({
+                outcome: 'assigned',
+                ownerUid: decision.ownerUid,
+                by: decision.by
+            }, decision.ruleId ? {
+                ruleId: decision.ruleId
+            } : {}, {
+                leadMirrored,
+                notified: false
+            });
+        });
+        if (verdict.outcome !== 'assigned') return verdict;
+        // The owner is what the Contacts list filters by (AGL-3321).
+        await restampCrmListFieldsAt(contactRef, 'contacts');
+        if (!verdict.leadMirrored && leadRef && policy.kind === 'capture' && LEAD_FILING_SOURCES.has(policy.input.source)) {
+            void mirrorOwnerOntoLeadLater(leadRef, verdict.ownerUid);
+        }
+        const notified = await notifyRecordAssigned({
+            hostId: input.hostId,
+            orgId,
+            ownerUid: verdict.ownerUid,
+            actorUid: input.actorUid,
+            record: verdict.leadMirrored && leadKey ? {
+                kind: 'lead',
+                id: leadKey
+            } : {
+                kind: 'contact',
+                id: input.contactId
+            },
+            who: contactName || input.email
+        });
+        return _extends({}, verdict, {
+            notified
+        });
+    } catch (error) {
+        console.error('assignContactOwner failed', input.hostId, input.contactId, error);
+        return {
+            outcome: 'none',
+            reason: 'failed'
+        };
+    }
+}
+/**
+ * The detached second look for a lead that lands after the contact.
+ *
+ * Bounded, and only ever ADDS an owner: a lead that arrived with one (a
+ * person assigned it in the meantime) is left alone, and a lead that never
+ * arrives costs three reads over six seconds and nothing else. Detached
+ * because the capture must not hold `contactCreated` back for it — an
+ * automation welcoming the contact has nothing to do with the lead's owner
+ * column.
+ */ async function mirrorOwnerOntoLeadLater(leadRef, ownerUid, delaysMs = LEAD_MIRROR_RETRY_MS) {
+    for (const delay of delaysMs){
+        await new Promise((resolve)=>setTimeout(resolve, delay));
+        try {
+            var _lead_get;
+            const lead = await leadRef.get();
+            if (!lead.exists) continue;
+            if (String((_lead_get = lead.get('ownerUid')) != null ? _lead_get : '')) return false;
+            await leadRef.update({
+                ownerUid,
+                updatedAt: FieldValue.serverTimestamp()
+            });
+            return true;
+        } catch (error) {
+            console.error('assignContactOwner lead mirror failed', leadRef.path, error);
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * The capture door's pass: the org's rules in order, then the capturing
+ * site's default owner, on a record that has no owner yet. See the module
+ * comment for the whole of it.
+ */ export function assignOwnerForCapture(input) {
+    return assignOwner({
+        kind: 'capture',
+        input
+    });
+}
+/**
+ * The deliberate assignment — the `assignContactOwner` step, and a person
+ * handing a record to somebody: a member by uid (verified on the roster) or
+ * the next in the round-robin pool, overwriting whoever held it. Naming the
+ * owner the record already has changes nothing and tells nobody.
+ */ export function reassignContactOwner(input) {
+    return assignOwner({
+        kind: 'reassign',
+        input
+    });
+}
+/**
+ * {@link reassignContactOwner} for a person who is still a LEAD (AGL-3458).
+ *
+ * A lead-routed form files a lead and no contact (AGL-3232), so an
+ * automation welcoming that person — "assign an owner, then book them a
+ * call" — has only the lead to act on. The owner is the lead's own
+ * `ownerUid`, the field the Leads list's Owner column and filter read and a
+ * conversion hands to the contact. Same transaction shape as a contact's:
+ * the org document, the lead and every roster candidate are read inside it,
+ * and the round-robin pointer moves in the commit that writes the owner, so
+ * a lead and a contact assigned at the same moment take two different
+ * members of the one rotation.
+ *
+ * Never rejects; a failure is logged and answered as `none`, which the
+ * automation records as the step's error.
+ */ export async function reassignLeadOwner(input) {
+    try {
+        const resolved = await getOrgForHost(input.hostId);
+        if (!resolved) return {
+            outcome: 'none',
+            reason: 'no-org'
+        };
+        const { orgId } = resolved;
+        const firestore = firebaseAdmin.app().firestore();
+        const orgRef = firestore.collection('orgs').doc(orgId);
+        const leadRef = orgRef.collection('leads').doc(input.leadId);
+        const membersRef = orgRef.collection('members');
+        let who = '';
+        const verdict = await firestore.runTransaction(async (tx)=>{
+            var _leadSnapshot_data, _lead_name, _lead_email, _lead_ownerUid, _orgSnapshot_data;
+            const [orgSnapshot, leadSnapshot] = await Promise.all([
+                tx.get(orgRef),
+                tx.get(leadRef)
+            ]);
+            if (!leadSnapshot.exists) return {
+                outcome: 'none',
+                reason: 'no-lead'
+            };
+            const lead = (_leadSnapshot_data = leadSnapshot.data()) != null ? _leadSnapshot_data : {};
+            who = String((_lead_name = lead['name']) != null ? _lead_name : '') || String((_lead_email = lead['email']) != null ? _lead_email : '');
+            const current = String((_lead_ownerUid = lead['ownerUid']) != null ? _lead_ownerUid : '');
+            const settings = readCrmAssignmentSettings((_orgSnapshot_data = orgSnapshot.data()) != null ? _orgSnapshot_data : {});
+            const { resolveTarget } = rosterResolver(tx, membersRef, settings);
+            const hit = await resolveTarget(input.assign);
+            if (!hit) {
+                return {
+                    outcome: 'none',
+                    reason: 'roundRobin' in input.assign ? 'empty-pool' : 'not-a-member'
+                };
+            }
+            if (hit.uid === current) return {
+                outcome: 'unchanged',
+                ownerUid: current
+            };
+            tx.update(leadRef, {
+                ownerUid: hit.uid,
+                updatedAt: FieldValue.serverTimestamp()
+            });
+            if (hit.advancePointer) {
+                tx.update(orgRef, {
+                    [CRM_ROUND_ROBIN_LAST_ASSIGNED_PATH]: hit.uid
+                });
+            }
+            return {
+                outcome: 'assigned',
+                ownerUid: hit.uid,
+                by: 'roundRobin' in input.assign ? 'roundRobin' : 'member',
+                leadMirrored: false,
+                notified: false
+            };
+        });
+        if (verdict.outcome !== 'assigned') return verdict;
+        const notified = await notifyRecordAssigned({
+            hostId: input.hostId,
+            orgId,
+            ownerUid: verdict.ownerUid,
+            actorUid: input.actorUid,
+            record: {
+                kind: 'lead',
+                id: input.leadId
+            },
+            who
+        });
+        return _extends({}, verdict, {
+            notified
+        });
+    } catch (error) {
+        console.error('assignLeadOwner failed', input.hostId, input.leadId, error);
+        return {
+            outcome: 'none',
+            reason: 'failed'
+        };
+    }
+}
+export default assignOwnerForCapture;
+
+//# sourceMappingURL=assign-contact-owner.js.map