@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/dynamic-list-rule.js

@@ -0,0 +1,914 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { _ as _object_without_properties_loose } from "@swc/helpers/_/_object_without_properties_loose";
+/**
+ * @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.
+ */ /**
+ * The rule behind a dynamic list (`docs/specs/email-overhaul.md` §3b/§3c).
+ *
+ * A list has held manually enrolled members only. A dynamic one stores this
+ * rule instead and materializes into the same `members` subcollection, so the
+ * send path keeps reading one deterministic collection rather than running an
+ * unbounded scan per campaign.
+ *
+ * ## It extends the segment vocabulary rather than inventing one
+ *
+ * `tags` and `captureSources` mean exactly what they mean in
+ * `contactMatchesSegment`, which this module reuses rather than restating:
+ * two filter languages over the same contact document would drift, and the
+ * one that drifts is whichever the merchant is not looking at. What is new is
+ * a SOURCE dimension, because a list must be able to draw from silos that are
+ * not `contacts` at all.
+ *
+ * ## Every field reads a value that is already written
+ *
+ * Nothing here collects anything new. `tags`, `captureSources` and the
+ * `behavior` figures are contact fields; `formNames` is the `formName` a
+ * submission already stores; `createdAfterMs`/`createdBeforeMs` read the
+ * `createdAt` all three person silos already stamp; `campaignIds` reads the
+ * membership `campaign-membership.ts` defines, which the forms console writes
+ * and the submit route propagates.
+ *
+ * ⚠️ A rule selects an AUDIENCE. It does not grant consent — a person matched
+ * by "submitted a form" has not opted in by submitting it. Membership and
+ * basis are separate joins and `marketing-consent.ts` owns the second one.
+ */ import { normalizeCampaignIds } from "./campaign-membership.js";
+import { CONTACT_SOURCE_LABELS, contactMatchesSegment } from "./contacts.js";
+import { isContactLifecycleStage, normalizeContactFieldKey, CRM_CONTACT_VIEW_FIELDS, crmContactCustomKey } from "./crm.js";
+/**
+ * The silos whose rows can be filed under a campaign.
+ *
+ * A contact carries the membership inside the holder's own facet and a form
+ * submission carries the membership its form had when it arrived. A lead and a
+ * site member carry none — nothing writes one — so the campaign dimension is
+ * SKIPPED for them rather than failed, which is the same discipline every
+ * silo-specific dimension here follows.
+ *
+ * Stated as a value because both the matcher and the materializer's enrichment
+ * decide off it, and two lists would drift into a rule that selects a silo the
+ * scan never reads the field for.
+ */ export const CAMPAIGN_MEMBER_SILOS = [
+    'contacts',
+    'formSubmissions'
+];
+/**
+ * How a custom-field clause compares the stored value to the one it names.
+ *
+ * Seven operators and no more, because each one has to be readable back as
+ * a sentence and each one has to state what it does with a BLANK value —
+ * see {@link customValueMatches} for the lean every operator takes.
+ */ export const DYNAMIC_LIST_CUSTOM_OPS = [
+    'eq',
+    'neq',
+    'contains',
+    'gt',
+    'lt',
+    'set',
+    'unset'
+];
+/** The operators that compare against a value the clause carries. */ const VALUED_CUSTOM_OPS = new Set([
+    'eq',
+    'neq',
+    'contains',
+    'gt',
+    'lt'
+]);
+/**
+ * The most custom-field clauses one block may carry.
+ *
+ * A bound on the predicate rather than on the audience — every clause is
+ * evaluated in memory against a candidate already read — kept small for the
+ * reason the branch cap is: the rule is merchant-authored and a stored array
+ * has no natural end.
+ */ export const DYNAMIC_LIST_MAX_CUSTOM_CLAUSES = 20;
+const asStringArray = (value)=>Array.isArray(value) ? value.map((entry)=>String(entry != null ? entry : '').trim()).filter((entry)=>entry.length > 0 && entry.length <= 120).slice(0, 50) : [];
+const asPositiveNumber = (value)=>{
+    const parsed = Number(value);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+};
+const DYNAMIC_LIST_SOURCES = [
+    'contacts',
+    'leads',
+    'siteMembers',
+    'formSubmissions'
+];
+/**
+ * Coerces a stored rule to the shape the matcher expects.
+ *
+ * The rule is merchant-authored through the console and read back on a
+ * scheduled sweep, so it arrives as whatever Firestore held. Unknown source
+ * names are dropped rather than tolerated: a typo that fell through would
+ * read as a silo the materializer never scans, and the list would quietly
+ * materialize a smaller set than the rule appears to describe.
+ */ /**
+ * The most OR branches one rule may carry.
+ *
+ * A bound on the PREDICATE, not on the audience — every branch is evaluated
+ * in memory against a candidate the sweep has already read, so this costs no
+ * Firestore work. It exists because the rule is merchant-authored and a
+ * stored array has no natural end: a thousand branches would be a thousand
+ * evaluations per candidate per sweep.
+ *
+ * ⚠️ Set ABOVE what the console form can produce, and that is a correctness
+ * requirement rather than headroom. The form's "any of these filters" mode
+ * puts each control in a branch of its own, so a reader who fills in every
+ * box authors nineteen, plus one branch per custom-field condition up to
+ * {@link DYNAMIC_LIST_MAX_CUSTOM_CLAUSES} — and dropping a branch NARROWS an
+ * OR, so a cap the form could reach would silently select fewer people than
+ * the sentences above the controls say. The rule editor's spec holds the sum
+ * under this number.
+ */ export const DYNAMIC_LIST_MAX_GROUPS = 40;
+/**
+ * The most lists one dimension may name.
+ *
+ * This one DOES cost reads — a named list is a keyed lookup per candidate per
+ * page — so it is deliberately small, and it is the same number on both arms
+ * so that "in these" and "not in those" cannot be combined into a larger
+ * fan-out than either alone.
+ */ export const DYNAMIC_LIST_MAX_LIST_REFERENCES = 5;
+/**
+ * Coerces a stored custom-field clause, or drops it.
+ *
+ * Dropped rather than tolerated for the reason a typo'd silo is: a clause
+ * with a key no definition uses, an operator the matcher does not know, or a
+ * missing value where one is compared against, is a filter no contact can
+ * satisfy — and a rule that quietly matches nobody reads exactly like a rule
+ * that has not run yet. The key goes through the definition's own normalizer
+ * so a clause written against a label (`Plan Name`) still reaches the stored
+ * key (`plan_name`), and a value is kept only as a scalar because that is all
+ * a custom field may hold.
+ */ function normalizeCustomClause(raw) {
+    const entry = raw != null ? raw : {};
+    const key = normalizeContactFieldKey(entry['key']);
+    const op = entry['op'];
+    if (!key || typeof op !== 'string' || !DYNAMIC_LIST_CUSTOM_OPS.includes(op)) {
+        return null;
+    }
+    const operator = op;
+    if (!VALUED_CUSTOM_OPS.has(operator)) return {
+        key,
+        op: operator
+    };
+    const value = entry['value'];
+    if (typeof value === 'string') {
+        const trimmed = value.trim().slice(0, 500);
+        return trimmed ? {
+            key,
+            op: operator,
+            value: trimmed
+        } : null;
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? {
+            key,
+            op: operator,
+            value
+        } : null;
+    }
+    if (typeof value === 'boolean') return {
+        key,
+        op: operator,
+        value
+    };
+    return null;
+}
+/** Coerces the dimensions shared by the rule and each of its OR branches. */ function normalizeDimensions(value) {
+    var _value_behavior, _value_engagement;
+    const behavior = (_value_behavior = value['behavior']) != null ? _value_behavior : {};
+    const normalizedBehavior = _extends({}, asPositiveNumber(behavior['ordersCountAtLeast']) !== undefined ? {
+        ordersCountAtLeast: asPositiveNumber(behavior['ordersCountAtLeast'])
+    } : {}, asPositiveNumber(behavior['ltvCentsAtLeast']) !== undefined ? {
+        ltvCentsAtLeast: asPositiveNumber(behavior['ltvCentsAtLeast'])
+    } : {}, asPositiveNumber(behavior['lastPurchaseWithinDays']) !== undefined ? {
+        lastPurchaseWithinDays: asPositiveNumber(behavior['lastPurchaseWithinDays'])
+    } : {}, asPositiveNumber(behavior['noPurchaseForDays']) !== undefined ? {
+        noPurchaseForDays: asPositiveNumber(behavior['noPurchaseForDays'])
+    } : {});
+    const engagement = (_value_engagement = value['engagement']) != null ? _value_engagement : {};
+    const normalizedEngagement = _extends({}, asPositiveNumber(engagement['openedWithinDays']) !== undefined ? {
+        openedWithinDays: asPositiveNumber(engagement['openedWithinDays'])
+    } : {}, asPositiveNumber(engagement['clickedWithinDays']) !== undefined ? {
+        clickedWithinDays: asPositiveNumber(engagement['clickedWithinDays'])
+    } : {}, asPositiveNumber(engagement['notOpenedForDays']) !== undefined ? {
+        notOpenedForDays: asPositiveNumber(engagement['notOpenedForDays'])
+    } : {}, asPositiveNumber(engagement['notClickedForDays']) !== undefined ? {
+        notClickedForDays: asPositiveNumber(engagement['notClickedForDays'])
+    } : {});
+    const tags = asStringArray(value['tags']);
+    const captureSources = asStringArray(value['captureSources']);
+    const formNames = asStringArray(value['formNames']);
+    // Through the campaign field's own normalizer rather than the local string
+    // coercion: the cap, the dedupe and the trim are properties of the stored
+    // membership, and a second reading of them here would let a rule name more
+    // campaigns than any record is allowed to be filed under.
+    const campaignIds = normalizeCampaignIds(value['campaignIds']);
+    const createdAfterMs = asPositiveNumber(value['createdAfterMs']);
+    const createdBeforeMs = asPositiveNumber(value['createdBeforeMs']);
+    const inListIds = asStringArray(value['inListIds']).slice(0, DYNAMIC_LIST_MAX_LIST_REFERENCES);
+    const notInListIds = asStringArray(value['notInListIds']).slice(0, DYNAMIC_LIST_MAX_LIST_REFERENCES);
+    const ownerUids = asStringArray(value['ownerUids']);
+    // A stage the model does not name is dropped, not kept: kept, it would be
+    // a filter no contact can satisfy, and the rule would read as the stages
+    // it does name while selecting nobody.
+    const lifecycleStages = asStringArray(value['lifecycleStages']).filter(isContactLifecycleStage);
+    const companyIds = asStringArray(value['companyIds']);
+    const custom = (Array.isArray(value['custom']) ? value['custom'] : []).slice(0, DYNAMIC_LIST_MAX_CUSTOM_CLAUSES).map(normalizeCustomClause).filter((clause)=>clause !== null);
+    const engagedWithinDays = asPositiveNumber(value['engagedWithinDays']);
+    return _extends({}, tags.length ? {
+        tags
+    } : {}, captureSources.length ? {
+        captureSources
+    } : {}, formNames.length ? {
+        formNames
+    } : {}, campaignIds.length ? {
+        campaignIds
+    } : {}, createdAfterMs !== undefined ? {
+        createdAfterMs
+    } : {}, createdBeforeMs !== undefined ? {
+        createdBeforeMs
+    } : {}, Object.keys(normalizedBehavior).length ? {
+        behavior: normalizedBehavior
+    } : {}, Object.keys(normalizedEngagement).length ? {
+        engagement: normalizedEngagement
+    } : {}, inListIds.length ? {
+        inListIds
+    } : {}, notInListIds.length ? {
+        notInListIds
+    } : {}, ownerUids.length ? {
+        ownerUids
+    } : {}, lifecycleStages.length ? {
+        lifecycleStages
+    } : {}, companyIds.length ? {
+        companyIds
+    } : {}, custom.length ? {
+        custom
+    } : {}, engagedWithinDays !== undefined ? {
+        engagedWithinDays
+    } : {});
+}
+/** True when a branch constrains nothing, so keeping it would widen the rule. */ function dimensionsAreEmpty(dimensions) {
+    return Object.keys(dimensions).length === 0;
+}
+export function normalizeDynamicListRule(stored) {
+    var _value_segmentId, _value_viewId;
+    const value = stored != null ? stored : {};
+    const sources = asStringArray(value['sources']).filter((source)=>DYNAMIC_LIST_SOURCES.includes(source));
+    const segmentId = String((_value_segmentId = value['segmentId']) != null ? _value_segmentId : '').trim();
+    const viewId = String((_value_viewId = value['viewId']) != null ? _value_viewId : '').trim();
+    /*
+   * An empty OR branch is DROPPED rather than kept.
+   *
+   * A branch with no dimensions matches everybody, and `any` is satisfied by
+   * one branch — so a single empty one would silently disable every other
+   * branch beside it. Dropping it is the same decision the source filter
+   * makes about a typo'd silo name, for the same reason: a rule must not
+   * quietly select a different population than the one it reads as.
+   */ const groups = (Array.isArray(value['any']) ? value['any'] : []).slice(0, DYNAMIC_LIST_MAX_GROUPS).map((raw)=>{
+        const entry = raw != null ? raw : {};
+        const dimensions = normalizeDimensions(entry);
+        return _extends({}, dimensions, entry['negate'] === true ? {
+            negate: true
+        } : {});
+    }).filter((group)=>!dimensionsAreEmpty(stripNegate(group)));
+    return _extends({
+        sources
+    }, segmentId ? {
+        segmentId
+    } : {}, viewId ? {
+        viewId
+    } : {}, value['negate'] === true ? {
+        negate: true
+    } : {}, normalizeDimensions(value), groups.length ? {
+        any: groups
+    } : {});
+}
+/** A branch without its flag, so emptiness is decided on its filters alone. */ function stripNegate(group) {
+    const { negate } = group, dimensions = _object_without_properties_loose(group, [
+        "negate"
+    ]);
+    void negate;
+    return dimensions;
+}
+/**
+ * True when a rule can select nobody no matter what the data holds.
+ *
+ * Worth its own answer because the failure it prevents is silent: an empty
+ * `sources` materializes an empty list, and an empty list reads in the
+ * composer exactly like a rule that simply has not run yet.
+ */ export function dynamicListRuleIsEmpty(rule) {
+    return rule.sources.length === 0;
+}
+/**
+ * Does this person match the rule?
+ *
+ * AND across dimensions, OR within one — the same shape `contactMatchesSegment`
+ * uses, so a merchant who has built a segment already knows how this reads.
+ *
+ * On top of that flat block sit two operators, and the whole verdict is:
+ *
+ * ```
+ * silo is in sources
+ *   AND (negate ? NOT top-level block : top-level block)
+ *   AND (any branches ? at least one branch, each with its own negate : true)
+ * ```
+ *
+ * Which is nested AND/OR with negation, arranged so that the only part the
+ * materializer's scan plan depends on — `sources` — sits outside both
+ * operators and cannot be touched by either.
+ *
+ * Dimensions that do not apply to a candidate's silo are SKIPPED rather than
+ * failed. A rule of `sources: ['contacts','siteMembers'], tags: ['vip']` means
+ * "VIP contacts, and site members" — reading `tags` against a member document
+ * that cannot carry tags would make the second source contribute nobody, and
+ * a source that silently contributes nobody is the same defect as a dropped
+ * typo above.
+ *
+ * @param segment filters resolved from `rule.segmentId`, when it names one.
+ * @param view    the dimensions resolved from `rule.viewId`, when it names
+ *                one — see {@link dynamicListDimensionsForCrmView}.
+ * @param nowMs   evaluation instant, injected so a sweep is reproducible.
+ */ export function candidateMatchesDynamicListRule(candidate, rule, options) {
+    var _options_segment, _rule_any;
+    /*
+   * The source filter, first and outside everything else. It is the one
+   * dimension that is neither negatable nor groupable, because it is the scan
+   * plan rather than a filter over what the scan found.
+   */ if (!rule.sources.includes(candidate.silo)) return false;
+    /*
+   * A resolved VIEW is its own AND-block beside the rule's, inside the
+   * negatable top level with the segment — the view always applies, and a
+   * rule that inverts its block inverts the view with it, which is what
+   * "nobody matching all of these" reads as when a view is one of them.
+   * Beside rather than merged INTO the rule's dimensions: the lists within
+   * a dimension are OR, so merging a view's owners with the rule's would
+   * widen both.
+   */ const top = matchesDimensions(candidate, rule, {
+        segment: (_options_segment = options.segment) != null ? _options_segment : null,
+        nowMs: options.nowMs
+    }) && (!options.view || matchesDimensions(candidate, options.view, {
+        segment: null,
+        nowMs: options.nowMs
+    }));
+    if ((rule.negate === true ? !top : top) === false) return false;
+    /*
+   * The OR branches, ANDed with the block above. Absent or empty is no
+   * constraint — `Array.prototype.some` on an empty array is `false`, which
+   * would turn a rule that named no branches into one nobody satisfies.
+   */ const groups = (_rule_any = rule.any) != null ? _rule_any : [];
+    if (!groups.length) return true;
+    return groups.some((group)=>{
+        const matched = matchesDimensions(candidate, group, {
+            // A saved segment belongs to the rule, not to a branch: it is resolved
+            // once by the caller from the rule's own `segmentId`, and folding it
+            // into every branch would make each branch narrower than it reads.
+            segment: null,
+            nowMs: options.nowMs
+        });
+        return group.negate === true ? !matched : matched;
+    });
+}
+/**
+ * One AND-block of dimensions against one candidate.
+ *
+ * Extracted so the top-level block and every OR branch are decided by the
+ * same code. Two implementations of "does this person match these filters"
+ * would drift, and the half that drifts is whichever the merchant is not
+ * looking at — the same reason `contactMatchesSegment` is reused here rather
+ * than restated.
+ */ function matchesDimensions(candidate, rule, options) {
+    var _candidate_listIds;
+    var _rule_formNames, _rule_campaignIds, _rule_inListIds, _rule_notInListIds;
+    const day = 86400000;
+    if (rule.createdAfterMs !== undefined) {
+        // A record with no creation stamp cannot satisfy an age window, and
+        // admitting it would put people INTO an audience the merchant bounded on
+        // purpose. This is the opposite lean from the consent module's unknown
+        // handling, and deliberately so: there, the unknown keeps somebody
+        // reachable; here, it would add somebody the rule excluded.
+        if (candidate.createdAtMs == null) return false;
+        if (candidate.createdAtMs < rule.createdAfterMs) return false;
+    }
+    if (rule.createdBeforeMs !== undefined) {
+        if (candidate.createdAtMs == null) return false;
+        if (candidate.createdAtMs >= rule.createdBeforeMs) return false;
+    }
+    if (candidate.silo === 'formSubmissions' && ((_rule_formNames = rule.formNames) == null ? void 0 : _rule_formNames.length)) {
+        var _candidate_formName;
+        const wanted = new Set(rule.formNames.map((name)=>name.toLowerCase()));
+        if (!wanted.has(String((_candidate_formName = candidate.formName) != null ? _candidate_formName : '').trim().toLowerCase())) {
+            return false;
+        }
+    }
+    /*
+   * FILED UNDER A CAMPAIGN — the two silos that can be, and only those.
+   *
+   * OR within the dimension, like every other list here: a merchant naming
+   * three campaigns means anyone in any of them, not the handful of people
+   * filed under all three at once.
+   *
+   * A row in a silo that carries no membership is SKIPPED rather than failed,
+   * so "people in the spring push, and every site member" contributes members
+   * — the same reading `tags` gets for a lead. ⚠️ Which also means a NEGATED
+   * branch whose only filter is this one excludes those silos entirely; that
+   * is the honest consequence of the skip rule, stated on the branch flag
+   * itself.
+   */ if (((_rule_campaignIds = rule.campaignIds) == null ? void 0 : _rule_campaignIds.length) && CAMPAIGN_MEMBER_SILOS.includes(candidate.silo)) {
+        var _candidate_campaignIds;
+        // An absent field reads as "filed under nothing", which is what a row
+        // written before the form named a campaign actually says.
+        const filed = new Set((_candidate_campaignIds = candidate.campaignIds) != null ? _candidate_campaignIds : []);
+        if (!rule.campaignIds.some((campaignId)=>filed.has(campaignId))) {
+            return false;
+        }
+    }
+    if (candidate.silo === 'contacts') {
+        var _ref, _rule_tags, _ref1, _rule_captureSources, _candidate_tags, _candidate_sources, _rule_custom;
+        var _options_segment, _options_segment1, _rule_ownerUids, _rule_lifecycleStages, _rule_companyIds;
+        const segmentFilters = {
+            tags: [
+                ...(_ref = (_options_segment = options.segment) == null ? void 0 : _options_segment.tags) != null ? _ref : [],
+                ...(_rule_tags = rule.tags) != null ? _rule_tags : []
+            ],
+            sources: [
+                ...(_ref1 = (_options_segment1 = options.segment) == null ? void 0 : _options_segment1.sources) != null ? _ref1 : [],
+                ...(_rule_captureSources = rule.captureSources) != null ? _rule_captureSources : []
+            ]
+        };
+        if (!contactMatchesSegment({
+            tags: (_candidate_tags = candidate.tags) != null ? _candidate_tags : [],
+            sources: (_candidate_sources = candidate.sources) != null ? _candidate_sources : {}
+        }, segmentFilters)) {
+            return false;
+        }
+        const behavior = rule.behavior;
+        if (behavior) {
+            var _candidate_ordersCount, _candidate_ltvCents;
+            if (behavior.ordersCountAtLeast !== undefined && ((_candidate_ordersCount = candidate.ordersCount) != null ? _candidate_ordersCount : 0) < behavior.ordersCountAtLeast) {
+                return false;
+            }
+            if (behavior.ltvCentsAtLeast !== undefined && ((_candidate_ltvCents = candidate.ltvCents) != null ? _candidate_ltvCents : 0) < behavior.ltvCentsAtLeast) {
+                return false;
+            }
+            if (behavior.lastPurchaseWithinDays !== undefined) {
+                var _candidate_lastPurchaseAtMs;
+                const last = (_candidate_lastPurchaseAtMs = candidate.lastPurchaseAtMs) != null ? _candidate_lastPurchaseAtMs : null;
+                if (last === null) return false;
+                if (last < options.nowMs - behavior.lastPurchaseWithinDays * day) {
+                    return false;
+                }
+            }
+            if (behavior.noPurchaseForDays !== undefined) {
+                var _candidate_lastPurchaseAtMs1;
+                const last = (_candidate_lastPurchaseAtMs1 = candidate.lastPurchaseAtMs) != null ? _candidate_lastPurchaseAtMs1 : null;
+                // Never purchased is not lapsed — see DynamicListBehavior.
+                if (last === null) return false;
+                if (last > options.nowMs - behavior.noPurchaseForDays * day) {
+                    return false;
+                }
+            }
+        }
+        /*
+     * THE CRM DIMENSIONS — OR within each, AND across them, like the tags.
+     *
+     * An absent value matches none of the first three. "Owned by A or B" is
+     * a positive claim about the relationship, and a contact nobody owns is
+     * not a contact A owns; the same for a stage never set and a company
+     * never linked. The lean is the dated-window one rather than the
+     * consent module's: admitting the unknown here would put people INTO an
+     * audience the merchant bounded on purpose.
+     */ if ((_rule_ownerUids = rule.ownerUids) == null ? void 0 : _rule_ownerUids.length) {
+            if (!candidate.ownerUid || !rule.ownerUids.includes(candidate.ownerUid)) {
+                return false;
+            }
+        }
+        if ((_rule_lifecycleStages = rule.lifecycleStages) == null ? void 0 : _rule_lifecycleStages.length) {
+            if (!candidate.lifecycleStage || !rule.lifecycleStages.includes(candidate.lifecycleStage)) {
+                return false;
+            }
+        }
+        if ((_rule_companyIds = rule.companyIds) == null ? void 0 : _rule_companyIds.length) {
+            if (!candidate.companyId || !rule.companyIds.includes(candidate.companyId)) {
+                return false;
+            }
+        }
+        // Every clause must hold. A merchant adding a second condition on a
+        // custom field is narrowing, which is what a second box on a form means
+        // everywhere else in it — the OR is the `any` branches, not this list.
+        for (const clause of (_rule_custom = rule.custom) != null ? _rule_custom : []){
+            var _candidate_custom;
+            if (!customValueMatches((_candidate_custom = candidate.custom) == null ? void 0 : _candidate_custom[clause.key], clause)) {
+                return false;
+            }
+        }
+        /*
+     * ENGAGED WITH OUR CAMPAIGNS — the facet stamp, on the same lean as
+     * `lastPurchaseWithinDays`: no stamp is no match. This is the one
+     * engagement figure that is about THIS holder's mail; the address-level
+     * arms further down are about the address.
+     */ if (rule.engagedWithinDays !== undefined) {
+            var _candidate_lastEmailEngagementAtMs;
+            const last = (_candidate_lastEmailEngagementAtMs = candidate.lastEmailEngagementAtMs) != null ? _candidate_lastEmailEngagementAtMs : null;
+            if (last === null) return false;
+            if (last < options.nowMs - rule.engagedWithinDays * day) return false;
+        }
+    }
+    /*
+   * ENGAGEMENT — every silo, not contacts only.
+   *
+   * The rollup keys on the ADDRESS, and a lead, a site member and a form
+   * submission all have one. Restricting this to contacts the way `behavior`
+   * is restricted would be restricting it to the silo that happens to store
+   * the OTHER figures, which is not a fact about engagement.
+   */ const engagement = rule.engagement;
+    if (engagement) {
+        var _candidate_lastOpenedAtMs, _candidate_lastClickedAtMs;
+        const opened = (_candidate_lastOpenedAtMs = candidate.lastOpenedAtMs) != null ? _candidate_lastOpenedAtMs : null;
+        const clicked = (_candidate_lastClickedAtMs = candidate.lastClickedAtMs) != null ? _candidate_lastClickedAtMs : null;
+        if (engagement.openedWithinDays !== undefined) {
+            if (opened === null) return false;
+            if (opened < options.nowMs - engagement.openedWithinDays * day) {
+                return false;
+            }
+        }
+        if (engagement.clickedWithinDays !== undefined) {
+            if (clicked === null) return false;
+            if (clicked < options.nowMs - engagement.clickedWithinDays * day) {
+                return false;
+            }
+        }
+        // No record MATCHES the quiet arms — see DynamicListEngagement for why
+        // this leans the opposite way from `noPurchaseForDays` above it.
+        if (engagement.notOpenedForDays !== undefined && opened !== null) {
+            if (opened > options.nowMs - engagement.notOpenedForDays * day) {
+                return false;
+            }
+        }
+        if (engagement.notClickedForDays !== undefined && clicked !== null) {
+            if (clicked > options.nowMs - engagement.notClickedForDays * day) {
+                return false;
+            }
+        }
+    }
+    /*
+   * LIST MEMBERSHIP — "and not the people already on my customers list".
+   *
+   * An absent `listIds` reads as "on no list", and that is the reading a
+   * failed or skipped lookup gets too. The direction is chosen rather than
+   * defaulted: an unenriched candidate failing `inListIds` keeps them OUT of
+   * an audience, where an unenriched candidate passing `notInListIds` would
+   * let a lookup failure quietly re-admit the people a merchant excluded. The
+   * materializer runs the enrichment whenever a rule names a list, so the
+   * absent case is a lookup that failed rather than an ordinary one — and
+   * these two readings are what it costs when one does.
+   */ const memberOf = new Set((_candidate_listIds = candidate.listIds) != null ? _candidate_listIds : []);
+    if ((_rule_inListIds = rule.inListIds) == null ? void 0 : _rule_inListIds.length) {
+        if (!rule.inListIds.every((listId)=>memberOf.has(listId))) return false;
+    }
+    if ((_rule_notInListIds = rule.notInListIds) == null ? void 0 : _rule_notInListIds.length) {
+        if (rule.notInListIds.some((listId)=>memberOf.has(listId))) return false;
+    }
+    return true;
+}
+/** A value that is on the record: not absent, not `null`, not blank text. */ const customValueIsSet = (value)=>value !== undefined && value !== null && !(typeof value === 'string' && value.trim() === '');
+/** A value as text, for the comparisons that read it that way. */ const customValueText = (value)=>String(value).trim().toLowerCase();
+/**
+ * Does one stored custom value satisfy one clause?
+ *
+ * Exported because the comparison is the whole meaning of the dimension and
+ * a surface that previews a value against a clause must not carry a second
+ * copy of it. The leans, per operator, because each has to be readable back
+ * as a sentence the merchant can check against their intent:
+ *
+ *  - `eq` — the same value. Text compares case-insensitively and trimmed,
+ *    because a `select` option typed as `Enterprise` and stored as
+ *    `enterprise` is one option; a number and a boolean compare as
+ *    themselves, and a number stored as text still equals the number.
+ *  - `neq` — a value that is set AND differs. A blank does NOT count: a
+ *    merchant excluding one plan is not asking for everyone whose plan was
+ *    never recorded, and `unset` exists for that question.
+ *  - `contains` — text containment, case-insensitive; a blank contains
+ *    nothing.
+ *  - `gt` / `lt` — numeric when both sides parse as numbers, text otherwise.
+ *    Text ordering is what a `date` field stores (ISO dates order as text),
+ *    and a blank is neither greater nor less than anything.
+ *  - `set` / `unset` — presence. `false` and `0` are set; `null`, absent and
+ *    blank text are not.
+ */ export function customValueMatches(value, clause) {
+    const present = customValueIsSet(value);
+    switch(clause.op){
+        case 'set':
+            return present;
+        case 'unset':
+            return !present;
+        default:
+            break;
+    }
+    if (!present || clause.value === undefined) return false;
+    const stored = value;
+    const wanted = clause.value;
+    switch(clause.op){
+        case 'eq':
+            return customValueText(stored) === customValueText(wanted);
+        case 'neq':
+            return customValueText(stored) !== customValueText(wanted);
+        case 'contains':
+            return customValueText(stored).includes(customValueText(wanted));
+        case 'gt':
+        case 'lt':
+            {
+                const left = Number(stored);
+                const right = Number(wanted);
+                const numeric = typeof stored !== 'boolean' && typeof wanted !== 'boolean' && String(stored).trim() !== '' && String(wanted).trim() !== '' && Number.isFinite(left) && Number.isFinite(right);
+                if (numeric) return clause.op === 'gt' ? left > right : left < right;
+                const a = customValueText(stored);
+                const b = customValueText(wanted);
+                return clause.op === 'gt' ? a > b : a < b;
+            }
+        default:
+            return false;
+    }
+}
+/** Every dimension block a rule carries: its own, then each OR branch. */ function allDimensions(rule) {
+    var _rule_any;
+    return [
+        rule,
+        ...(_rule_any = rule.any) != null ? _rule_any : []
+    ];
+}
+/**
+ * Does evaluating this rule need the sweeping holder's contact FACET?
+ *
+ * The campaign membership and the four CRM fields all live inside the facet,
+ * which is keyed by the consent group the materializer has to resolve with
+ * one org read. A rule that names none of them pays nothing — the same
+ * opt-in cost `dynamicListRuleNeedsCampaigns` already describes, widened to
+ * every dimension the facet holds so the materializer asks one question
+ * rather than five.
+ */ export function dynamicListRuleNeedsContactFacet(rule) {
+    return allDimensions(rule).some((dimensions)=>{
+        var _ref, _ref1, _ref2, _ref3, _ref4;
+        var _dimensions_campaignIds, _dimensions_ownerUids, _dimensions_lifecycleStages, _dimensions_companyIds, _dimensions_custom;
+        return ((_ref = (_dimensions_campaignIds = dimensions.campaignIds) == null ? void 0 : _dimensions_campaignIds.length) != null ? _ref : 0) > 0 || ((_ref1 = (_dimensions_ownerUids = dimensions.ownerUids) == null ? void 0 : _dimensions_ownerUids.length) != null ? _ref1 : 0) > 0 || ((_ref2 = (_dimensions_lifecycleStages = dimensions.lifecycleStages) == null ? void 0 : _dimensions_lifecycleStages.length) != null ? _ref2 : 0) > 0 || ((_ref3 = (_dimensions_companyIds = dimensions.companyIds) == null ? void 0 : _dimensions_companyIds.length) != null ? _ref3 : 0) > 0 || ((_ref4 = (_dimensions_custom = dimensions.custom) == null ? void 0 : _dimensions_custom.length) != null ? _ref4 : 0) > 0 || dimensions.engagedWithinDays !== undefined;
+    });
+}
+/**
+ * Does evaluating this rule need the per-person engagement rollup?
+ *
+ * Asked by the materializer before it spends a keyed read per candidate. A
+ * rule with no engagement clause anywhere pays nothing, which is what keeps
+ * the lookup an opt-in cost rather than a tax on every sweep.
+ */ export function dynamicListRuleNeedsEngagement(rule) {
+    return allDimensions(rule).some((dimensions)=>dimensions.engagement !== undefined && Object.keys(dimensions.engagement).length > 0);
+}
+/**
+ * Does evaluating this rule need a contact's campaign membership?
+ *
+ * Asked by the materializer before it resolves the consent group the facet is
+ * keyed by — one org read, and only for a rule that names a campaign. A
+ * submission's membership is on the row the sweep already paged and costs
+ * nothing either way, so this answers about the CONTACTS silo's extra work.
+ */ export function dynamicListRuleNeedsCampaigns(rule) {
+    return allDimensions(rule).some((dimensions)=>{
+        var _ref;
+        var _dimensions_campaignIds;
+        return ((_ref = (_dimensions_campaignIds = dimensions.campaignIds) == null ? void 0 : _dimensions_campaignIds.length) != null ? _ref : 0) > 0;
+    });
+}
+/**
+ * The rule with one list id removed from both membership arms.
+ *
+ * ⛔ A dynamic list whose rule referred to ITSELF would oscillate, and the
+ * oscillation removes people. `notInListIds: [self]` matches everybody on the
+ * first sweep, which enrolls them; on the second sweep they are all members,
+ * so nobody matches, and reconciliation deletes every row the rule created.
+ * The third sweep enrolls them again. Membership would flip on every beat of
+ * the materializing sweep forever, and half of those beats are deletions.
+ *
+ * A self-reference also cannot mean anything useful — the answer depends on
+ * whether the sweep has run yet — so it is dropped rather than refused: a
+ * merchant who picks their own audience gets the rule without that clause,
+ * which is what it would have meant if it meant anything.
+ */ export function dynamicListRuleWithoutListReference(rule, listId) {
+    var _rule_any;
+    if (!listId) return rule;
+    const strip = (dimensions)=>{
+        var _dimensions_inListIds, _dimensions_notInListIds;
+        const inListIds = ((_dimensions_inListIds = dimensions.inListIds) != null ? _dimensions_inListIds : []).filter((id)=>id !== listId);
+        const notInListIds = ((_dimensions_notInListIds = dimensions.notInListIds) != null ? _dimensions_notInListIds : []).filter((id)=>id !== listId);
+        const next = _extends({}, dimensions);
+        if (dimensions.inListIds) {
+            if (inListIds.length) next.inListIds = inListIds;
+            else delete next.inListIds;
+        }
+        if (dimensions.notInListIds) {
+            if (notInListIds.length) next.notInListIds = notInListIds;
+            else delete next.notInListIds;
+        }
+        return next;
+    };
+    const stripped = strip(rule);
+    /*
+   * A branch whose ONLY filter was the self-reference is dropped, not kept
+   * empty: an empty branch matches everybody, and one satisfied branch
+   * satisfies `any`, so keeping it would silently disable every branch
+   * beside it. Same reasoning as the normalizer's own empty-branch drop.
+   */ const groups = ((_rule_any = rule.any) != null ? _rule_any : []).map((group)=>strip(group)).filter((group)=>Object.keys(stripNegate(group)).length > 0);
+    if (groups.length) stripped.any = groups;
+    else delete stripped.any;
+    return stripped;
+}
+/** Every list id this rule refers to, in either direction, de-duplicated. */ export function dynamicListRuleListIds(rule) {
+    const ids = new Set();
+    for (const dimensions of allDimensions(rule)){
+        var _dimensions_inListIds, _dimensions_notInListIds;
+        for (const listId of (_dimensions_inListIds = dimensions.inListIds) != null ? _dimensions_inListIds : [])ids.add(listId);
+        for (const listId of (_dimensions_notInListIds = dimensions.notInListIds) != null ? _dimensions_notInListIds : [])ids.add(listId);
+    }
+    return [
+        ...ids
+    ];
+}
+const DAY_MS = 86400000;
+/** The values an `isAnyOf` carries, or the one an equality does; `null` for any other operator. */ const viewClauseValues = (clause)=>{
+    const value = clause.value.trim();
+    if (clause.op === 'isAnyOf') {
+        return value.split(',').map((entry)=>entry.trim()).filter(Boolean);
+    }
+    if (clause.op === 'equals' || clause.op === 'is' || clause.op === 'contains') {
+        return value ? [
+            value
+        ] : [];
+    }
+    return null;
+};
+const CUSTOM_VIEW_OPS = {
+    equals: 'eq',
+    is: 'eq',
+    '=': 'eq',
+    doesNotEqual: 'neq',
+    '!=': 'neq',
+    contains: 'contains',
+    '>': 'gt',
+    '<': 'lt',
+    isNotEmpty: 'set',
+    isEmpty: 'unset'
+};
+/**
+ * A view's filters as the dimensions of one AND-block, and the clauses
+ * that could not be.
+ *
+ * Every list operator keeps its own meaning across the translation:
+ * `isAnyOf` is the OR the dimension lists already are, an equality is a
+ * list of one, a `contains` on the tag array is one tag matched whole. The
+ * dates read the clause's value as an instant — a day, as the filter bar
+ * writes one — with `after` and `onOrBefore` stepping a day past it the
+ * way the list's own matcher does. A purchase threshold has a floor here
+ * and no ceiling, so `at least` and `over` carry and `under` cannot.
+ */ export function dynamicListDimensionsForCrmView(filters) {
+    const fields = CRM_CONTACT_VIEW_FIELDS;
+    const dimensions = {};
+    const unsupported = [];
+    const behavior = {};
+    const custom = [];
+    const extend = (key, values)=>{
+        var _dimensions_key;
+        dimensions[key] = [
+            ...(_dimensions_key = dimensions[key]) != null ? _dimensions_key : [],
+            ...values
+        ];
+    };
+    for (const clause of filters){
+        const values = viewClauseValues(clause);
+        const value = clause.value.trim();
+        const customKey = crmContactCustomKey(clause.field);
+        if (customKey !== null) {
+            const key = normalizeContactFieldKey(customKey);
+            const op = CUSTOM_VIEW_OPS[clause.op];
+            if (key && op) {
+                custom.push(op === 'set' || op === 'unset' ? {
+                    key,
+                    op
+                } : {
+                    key,
+                    op,
+                    value
+                });
+                continue;
+            }
+            unsupported.push(clause);
+            continue;
+        }
+        switch(clause.field){
+            case fields.tags:
+                if (values == null ? void 0 : values.length) {
+                    extend('tags', values.map((tag)=>tag.toLowerCase()));
+                    continue;
+                }
+                break;
+            case fields.source:
+                if (values == null ? void 0 : values.length) {
+                    const sources = values.filter((source)=>source in CONTACT_SOURCE_LABELS);
+                    if (sources.length === values.length) {
+                        var _dimensions_captureSources;
+                        dimensions.captureSources = [
+                            ...(_dimensions_captureSources = dimensions.captureSources) != null ? _dimensions_captureSources : [],
+                            ...sources
+                        ];
+                        continue;
+                    }
+                }
+                break;
+            case fields.owner:
+                if (values == null ? void 0 : values.length) {
+                    extend('ownerUids', values);
+                    continue;
+                }
+                break;
+            case fields.stage:
+                if ((values == null ? void 0 : values.length) && values.every(isContactLifecycleStage)) {
+                    var _dimensions_lifecycleStages;
+                    dimensions.lifecycleStages = [
+                        ...(_dimensions_lifecycleStages = dimensions.lifecycleStages) != null ? _dimensions_lifecycleStages : [],
+                        ...values
+                    ];
+                    continue;
+                }
+                break;
+            case fields.company:
+                if (values == null ? void 0 : values.length) {
+                    extend('companyIds', values);
+                    continue;
+                }
+                break;
+            case fields.createdAt:
+                {
+                    const at = Date.parse(value);
+                    if (Number.isFinite(at)) {
+                        if (clause.op === 'after') dimensions.createdAfterMs = at + DAY_MS;
+                        else if (clause.op === 'onOrAfter') dimensions.createdAfterMs = at;
+                        else if (clause.op === 'before') dimensions.createdBeforeMs = at;
+                        else if (clause.op === 'onOrBefore') {
+                            dimensions.createdBeforeMs = at + DAY_MS;
+                        } else if (clause.op === 'is') {
+                            dimensions.createdAfterMs = at;
+                            dimensions.createdBeforeMs = at + DAY_MS;
+                        } else break;
+                        continue;
+                    }
+                    break;
+                }
+            case fields.orders:
+            case fields.ltv:
+                {
+                    const amount = Number(value);
+                    if (Number.isFinite(amount) && (clause.op === '>=' || clause.op === '>')) {
+                        const floor = clause.op === '>' ? amount + 1 : amount;
+                        if (clause.field === fields.orders) behavior.ordersCountAtLeast = floor;
+                        else behavior.ltvCentsAtLeast = floor;
+                        continue;
+                    }
+                    break;
+                }
+            default:
+                break;
+        }
+        unsupported.push(clause);
+    }
+    if (Object.keys(behavior).length) dimensions.behavior = behavior;
+    if (custom.length) dimensions.custom = custom;
+    return {
+        dimensions,
+        unsupported
+    };
+}
+/**
+ * The rule the sweep PLANS with once a view is resolved: the rule itself
+ * with the view's block beside its branches, so the planners that read
+ * every block — does this need the contact facet, an engagement lookup, a
+ * list membership — see the view's dimensions too. For planning only; the
+ * matcher takes the view as its own option, because a branch is OR and a
+ * view is AND.
+ */ export function dynamicListPlanningRule(rule, view) {
+    var _rule_any;
+    if (!view || Object.keys(view).length === 0) return rule;
+    return _extends({}, rule, {
+        any: [
+            ...(_rule_any = rule.any) != null ? _rule_any : [],
+            view
+        ]
+    });
+}
+
+//# sourceMappingURL=dynamic-list-rule.js.map