@aglyn/plugins-email 1.0.0-beta.143

package/src/lib/components/dynamic-list-rule-fields.js

@@ -0,0 +1,1473 @@
+/**
+ * @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.
+ */ 'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Every field of `DynamicListRule`, with a control for each.
+ *
+ * ## Why the whole rule, and why in one place
+ *
+ * Every dimension the matcher reads has a control here, including the two
+ * that are answered by a keyed lookup rather than by the person's own record
+ * — engagement, and membership of another audience — and the combinator that
+ * decides whether the filters are ANDed, ORed or inverted. Needing to
+ * hand-write a stored structure to reach a shipped engine is a missing
+ * picker, not a power-user affordance, which is the standard this form is
+ * held to rather than a count of fields.
+ *
+ * One component rather than a form on the create card and a second on the edit
+ * page: the two would drift, and the half that drifts is whichever the
+ * merchant is not looking at. A rule authored at creation and the same rule
+ * reopened for editing are the same questions.
+ *
+ * ## The draft is text, the value is a rule
+ *
+ * The controls hold what was TYPED — `vip, ` is a legitimate intermediate
+ * state of a tag list, and a component that round-tripped every keystroke
+ * through `normalizeDynamicListRule` would delete the comma the moment it was
+ * typed. So the draft is strings, `draftToRule` is the one place it becomes a
+ * rule, and the parent never sees anything else.
+ *
+ * ## Money is entered the way a merchant says it
+ *
+ * `ltvCentsAtLeast` is stored in cents. A field labeled for the stored unit
+ * turns "customers who spent over 500" into customers who spent over five
+ * dollars, silently, and the audience looks plausible either way. The control
+ * takes whole currency units and this file owns the only multiplication.
+ *
+ * ## It reads the segments, and only when it is on screen
+ *
+ * The segment picker needs the org's saved segments, through
+ * `useOrgContactSegments`. That listen belongs to this component so it opens
+ * when a rule is actually being authored — the audiences section's cost is a
+ * list of lists, and a segment read on arrival would be a read for a form
+ * nobody has opened.
+ */ import { CONTACT_LIFECYCLE_STAGES, CONTACT_LIFECYCLE_STAGE_LABELS, CONTACT_SOURCE_LABELS, DYNAMIC_LIST_CUSTOM_OPS, normalizeDynamicListRule } from "@aglyn/aglyn";
+import { Autocomplete, Box, Button, Divider, MenuItem, Stack, TextField, Typography } from "@mui/material";
+import { useEffect, useMemo, useRef, useState } from "react";
+import { useHostCampaigns, useOrgMemberOptions } from "@aglyn/tenant-feature-instance";
+import CampaignPicker from "@aglyn/shared-ui-email-campaigns/components/campaign-picker.component";
+import { useOrgCompanyOptions } from "../hooks/use-org-company-options.js";
+import { useOrgContactFields } from "../hooks/use-org-contact-fields.js";
+import { useOrgContactSegments } from "../hooks/use-org-contact-segments.js";
+import { useOrgCrmViews } from "../hooks/use-org-crm-views.js";
+import { useOrgLists } from "../hooks/use-org-lists.js";
+/** How each silo reads on screen. */ const SOURCE_LABELS = {
+    contacts: 'Contacts',
+    leads: 'Leads',
+    siteMembers: 'Site members',
+    formSubmissions: 'Form submissions'
+};
+/** The same silos, lower-cased for the middle of a sentence. */ const SOURCE_PHRASES = {
+    contacts: 'contacts',
+    leads: 'leads',
+    siteMembers: 'site members',
+    formSubmissions: 'form submissions'
+};
+/** A day, in the same UTC calendar the rule's boundaries are stored against. */ const dayLabel = (ms)=>new Date(ms).toISOString().slice(0, 10);
+/** An id, as its name when one is known and as itself when none is. */ const named = (id, names)=>(names == null ? void 0 : names[id]) || id;
+/**
+ * How each custom-field operator reads, as the verb of a clause.
+ *
+ * `neq` carries its lean in the sentence: the matcher requires a VALUE that
+ * differs, so a merchant excluding one plan does not sweep in everyone whose
+ * plan was never recorded — and a reader checking a paragraph against their
+ * intent cannot be expected to know that from the word "not".
+ */ const CUSTOM_OP_LABELS = {
+    eq: 'is',
+    neq: 'is not',
+    contains: 'contains',
+    gt: 'is more than',
+    lt: 'is less than',
+    set: 'is set',
+    unset: 'is not set'
+};
+/** The operators that take no value — the clause is about presence. */ const PRESENCE_OPS = new Set([
+    'set',
+    'unset'
+]);
+/** One custom clause as a sentence fragment: `Plan is enterprise`. */ const describeCustomClause = (clause, names)=>{
+    var _clause_value;
+    const field = named(clause.key, names == null ? void 0 : names.fields);
+    const verb = CUSTOM_OP_LABELS[clause.op];
+    if (clause.op === 'set' || clause.op === 'unset') return `${field} ${verb}`;
+    const value = String((_clause_value = clause.value) != null ? _clause_value : '');
+    return clause.op === 'neq' ? `${field} ${verb} ${value} (a blank does not count)` : `${field} ${verb} ${value}`;
+};
+/** One AND-block, as clauses. The rule's own block and each branch share it. */ function describeDimensions(rule, names) {
+    var _rule_custom;
+    var _rule_tags, _rule_captureSources, _rule_formNames, _rule_campaignIds, _rule_inListIds, _rule_notInListIds, _rule_ownerUids, _rule_lifecycleStages, _rule_companyIds;
+    const clauses = [];
+    if ((_rule_tags = rule.tags) == null ? void 0 : _rule_tags.length) {
+        clauses.push(`Tagged any of: ${rule.tags.join(', ')}.`);
+    }
+    if ((_rule_captureSources = rule.captureSources) == null ? void 0 : _rule_captureSources.length) {
+        clauses.push(`Captured by: ${rule.captureSources.map((source)=>{
+            var _CONTACT_SOURCE_LABELS_source;
+            return (_CONTACT_SOURCE_LABELS_source = CONTACT_SOURCE_LABELS[source]) != null ? _CONTACT_SOURCE_LABELS_source : source;
+        }).join(', ')}.`);
+    }
+    if ((_rule_formNames = rule.formNames) == null ? void 0 : _rule_formNames.length) {
+        clauses.push(`Submitted any of: ${rule.formNames.join(', ')}.`);
+    }
+    /*
+   * The clause names the SILOS the dimension applies to, like every other
+   * silo-specific clause here. A lead and a site member carry no campaign, so
+   * the sentence has to say that the filter passes them through rather than
+   * leaving a reader to conclude that a rule drawing from leads and naming a
+   * campaign selects no leads.
+   */ if ((_rule_campaignIds = rule.campaignIds) == null ? void 0 : _rule_campaignIds.length) {
+        clauses.push(`Filed under any of these campaigns: ${rule.campaignIds.map((id)=>named(id, names == null ? void 0 : names.campaigns)).join(', ')} — contacts and form submissions only.`);
+    }
+    if (rule.createdAfterMs !== undefined) {
+        clauses.push(`Created on or after ${dayLabel(rule.createdAfterMs)}.`);
+    }
+    if (rule.createdBeforeMs !== undefined) {
+        clauses.push(`Created before ${dayLabel(rule.createdBeforeMs)}.`);
+    }
+    const behavior = rule.behavior;
+    if ((behavior == null ? void 0 : behavior.ordersCountAtLeast) !== undefined) {
+        clauses.push(`At least ${behavior.ordersCountAtLeast} orders.`);
+    }
+    if ((behavior == null ? void 0 : behavior.ltvCentsAtLeast) !== undefined) {
+        clauses.push(`Spent at least ${behavior.ltvCentsAtLeast / 100}.`);
+    }
+    if ((behavior == null ? void 0 : behavior.lastPurchaseWithinDays) !== undefined) {
+        clauses.push(`Bought within the last ${behavior.lastPurchaseWithinDays} days.`);
+    }
+    if ((behavior == null ? void 0 : behavior.noPurchaseForDays) !== undefined) {
+        clauses.push(`Has bought nothing for ${behavior.noPurchaseForDays} days.`);
+    }
+    /*
+   * The quiet arms say "or never" out loud.
+   *
+   * The engine counts a person with no open on record as having not opened,
+   * which is the opposite lean from `noPurchaseForDays` two clauses above —
+   * and a reader checking a paragraph against their intent cannot be expected
+   * to remember which dimension leans which way. So the sentence carries it.
+   */ const engagement = rule.engagement;
+    if ((engagement == null ? void 0 : engagement.openedWithinDays) !== undefined) {
+        clauses.push(`Opened one of your emails in the last ${engagement.openedWithinDays} days.`);
+    }
+    if ((engagement == null ? void 0 : engagement.clickedWithinDays) !== undefined) {
+        clauses.push(`Clicked a link in one of your emails in the last ` + `${engagement.clickedWithinDays} days.`);
+    }
+    if ((engagement == null ? void 0 : engagement.notOpenedForDays) !== undefined) {
+        clauses.push(`Has opened nothing for ${engagement.notOpenedForDays} days, or never ` + `opened anything.`);
+    }
+    if ((engagement == null ? void 0 : engagement.notClickedForDays) !== undefined) {
+        clauses.push(`Has clicked nothing for ${engagement.notClickedForDays} days, or never ` + `clicked anything.`);
+    }
+    if ((_rule_inListIds = rule.inListIds) == null ? void 0 : _rule_inListIds.length) {
+        clauses.push(`Already on: ${rule.inListIds.map((id)=>named(id, names == null ? void 0 : names.lists)).join(', ')}.`);
+    }
+    if ((_rule_notInListIds = rule.notInListIds) == null ? void 0 : _rule_notInListIds.length) {
+        clauses.push(`Not on: ${rule.notInListIds.map((id)=>named(id, names == null ? void 0 : names.lists)).join(', ')}.`);
+    }
+    /*
+   * THE CRM DIMENSIONS (AGL-2603). Each names people, stages and companies
+   * the way the pickers show them, never by id: a clause reading `uid-8f2a`
+   * is a clause nobody can check against their intent. The custom clauses
+   * are one sentence each, because each is its own condition and a reader
+   * adding a second one has narrowed the audience by exactly one sentence.
+   */ if ((_rule_ownerUids = rule.ownerUids) == null ? void 0 : _rule_ownerUids.length) {
+        clauses.push(`Owned by: ${rule.ownerUids.map((uid)=>named(uid, names == null ? void 0 : names.members)).join(', ')}.`);
+    }
+    if ((_rule_lifecycleStages = rule.lifecycleStages) == null ? void 0 : _rule_lifecycleStages.length) {
+        clauses.push(`In stage: ${rule.lifecycleStages.map((stage)=>{
+            var _CONTACT_LIFECYCLE_STAGE_LABELS_stage;
+            return (_CONTACT_LIFECYCLE_STAGE_LABELS_stage = CONTACT_LIFECYCLE_STAGE_LABELS[stage]) != null ? _CONTACT_LIFECYCLE_STAGE_LABELS_stage : stage;
+        }).join(', ')}.`);
+    }
+    if ((_rule_companyIds = rule.companyIds) == null ? void 0 : _rule_companyIds.length) {
+        clauses.push(`At company: ${rule.companyIds.map((id)=>named(id, names == null ? void 0 : names.companies)).join(', ')}.`);
+    }
+    /*
+   * "One of your campaigns", against the engagement arms above that say
+   * "one of your emails": those count every message this workspace sent the
+   * address, this counts the campaigns the reading site's group sent — the
+   * sentence is the only place a reader can tell the two windows apart.
+   */ if (rule.engagedWithinDays !== undefined) {
+        clauses.push(`Opened or clicked one of your campaigns in the last ` + `${rule.engagedWithinDays} days.`);
+    }
+    for (const clause of (_rule_custom = rule.custom) != null ? _rule_custom : []){
+        clauses.push(`${describeCustomClause(clause, names)}.`);
+    }
+    return clauses;
+}
+export function describeDynamicListRule(rule, names) {
+    var _rule_any;
+    const clauses = [];
+    clauses.push(rule.sources.length ? `Draws from ${rule.sources.map((source)=>{
+        var _SOURCE_PHRASES_source;
+        return (_SOURCE_PHRASES_source = SOURCE_PHRASES[source]) != null ? _SOURCE_PHRASES_source : source;
+    }).join(', ')}.` : 'Draws from nothing, so it matches nobody.');
+    if (rule.segmentId) {
+        clauses.push(`Reuses saved segment ${named(rule.segmentId, names == null ? void 0 : names.segments)}.`);
+    }
+    if (rule.viewId) {
+        clauses.push(`Reuses saved view ${named(rule.viewId, names == null ? void 0 : names.views)}.`);
+    }
+    const own = describeDimensions(rule, names);
+    if (rule.negate && own.length) {
+        /*
+     * A negated block is ONE clause, not a list of them.
+     *
+     * "Excludes anyone who is tagged vip. Excludes anyone who has spent over
+     * 500." would read as two independent exclusions, and the rule is one:
+     * it excludes people who are BOTH. Somebody checking a paragraph against
+     * their intent would come away with the wrong audience.
+     */ clauses.push(`Excludes anyone matching all of: ${own.map((clause)=>clause.replace(/\.$/, '')).join('; ')}.`);
+    } else {
+        clauses.push(...own);
+    }
+    /*
+   * The OR branches are ONE clause covering all of them, not one clause each.
+   *
+   * A candidate has to satisfy at least one branch — so "at least one of"
+   * printed once per branch would read as a separate requirement per branch,
+   * which is the AND this operator exists to escape. The whole disjunction is
+   * therefore rendered as a single sentence, with each branch's own filters
+   * joined by "and" inside it.
+   */ const branches = ((_rule_any = rule.any) != null ? _rule_any : []).map((group)=>{
+        const inner = describeDimensions(group, names);
+        if (!inner.length) return '';
+        const joined = inner.map((clause)=>clause.replace(/\.$/, '').toLowerCase()).join(' and ');
+        return group.negate ? `not (${joined})` : joined;
+    }).filter(Boolean);
+    if (branches.length) {
+        clauses.push(`And at least one of these: ${branches.join('; or ')}.`);
+    }
+    return clauses;
+}
+export const EMPTY_RULE_DRAFT = {
+    sources: [
+        'contacts'
+    ],
+    match: 'all',
+    segmentId: '',
+    viewId: '',
+    tags: '',
+    captureSources: [],
+    formNames: '',
+    campaignIds: [],
+    createdAfter: '',
+    createdBefore: '',
+    ordersCountAtLeast: '',
+    ltvAtLeast: '',
+    lastPurchaseWithinDays: '',
+    noPurchaseForDays: '',
+    openedWithinDays: '',
+    clickedWithinDays: '',
+    notOpenedForDays: '',
+    notClickedForDays: '',
+    inListIds: [],
+    notInListIds: [],
+    ownerUids: [],
+    lifecycleStages: [],
+    companyIds: [],
+    custom: [],
+    engagedWithinDays: ''
+};
+/** Comma-separated free text → the trimmed, non-empty values. */ export const splitRuleList = (value)=>value.split(',').map((entry)=>entry.trim()).filter(Boolean);
+/**
+ * A day stamp for a date input, in UTC.
+ *
+ * `Date.parse('2026-01-01')` is UTC midnight, so reading the value back
+ * through the local calendar would move the boundary by the reader's offset —
+ * a rule saved in Los Angeles would reopen naming the previous day, and saving
+ * it again would walk it backwards once per edit.
+ */ const dayStamp = (ms)=>ms === undefined || !Number.isFinite(ms) ? '' : dayLabel(ms);
+/**
+ * A stored rule, as the controls should show it.
+ *
+ * ⚠️ The three shapes {@link DynamicListRuleMatch} names are the shapes this
+ * form AUTHORS. A rule written through the REST API can hold branches the
+ * controls have no place for — a branch with its own `negate`, or top-level
+ * filters alongside branches — and this reads such a rule back as the union
+ * of every filter in it, in `any` mode. It is not a silent rewrite: the
+ * sentences above the controls are computed from `draftToRule(draft)`, so
+ * what a save would store is on screen before the reader saves it.
+ */ export function ruleToDraft(rule) {
+    var _rule_any, _rule_sources, _rule_segmentId, _rule_viewId;
+    var _rule_any1;
+    // Every filter the rule carries, wherever it carries it. The branches are
+    // read for their VALUES; how they combined is answered by `match` below.
+    const blocks = [
+        rule,
+        ...(_rule_any = rule.any) != null ? _rule_any : []
+    ];
+    const first = (read)=>{
+        for (const block of blocks){
+            const value = read(block);
+            if (value !== undefined) return value;
+        }
+        return undefined;
+    };
+    const list = (read)=>{
+        var _read;
+        const found = new Set();
+        for (const block of blocks)for (const entry of (_read = read(block)) != null ? _read : [])found.add(entry);
+        return [
+            ...found
+        ];
+    };
+    const number = (read)=>{
+        const value = first(read);
+        return value === undefined ? '' : String(value);
+    };
+    const ltvCents = first((block)=>{
+        var _block_behavior;
+        return (_block_behavior = block.behavior) == null ? void 0 : _block_behavior.ltvCentsAtLeast;
+    });
+    return {
+        sources: (_rule_sources = rule.sources) != null ? _rule_sources : [],
+        match: ((_rule_any1 = rule.any) == null ? void 0 : _rule_any1.length) ? 'any' : rule.negate ? 'none' : 'all',
+        segmentId: (_rule_segmentId = rule.segmentId) != null ? _rule_segmentId : '',
+        viewId: (_rule_viewId = rule.viewId) != null ? _rule_viewId : '',
+        tags: list((block)=>block.tags).join(', '),
+        captureSources: list((block)=>block.captureSources),
+        formNames: list((block)=>block.formNames).join(', '),
+        campaignIds: list((block)=>block.campaignIds),
+        createdAfter: dayStamp(first((block)=>block.createdAfterMs)),
+        createdBefore: dayStamp(first((block)=>block.createdBeforeMs)),
+        ordersCountAtLeast: number((block)=>{
+            var _block_behavior;
+            return (_block_behavior = block.behavior) == null ? void 0 : _block_behavior.ordersCountAtLeast;
+        }),
+        ltvAtLeast: ltvCents === undefined ? '' : String(ltvCents / 100),
+        lastPurchaseWithinDays: number((block)=>{
+            var _block_behavior;
+            return (_block_behavior = block.behavior) == null ? void 0 : _block_behavior.lastPurchaseWithinDays;
+        }),
+        noPurchaseForDays: number((block)=>{
+            var _block_behavior;
+            return (_block_behavior = block.behavior) == null ? void 0 : _block_behavior.noPurchaseForDays;
+        }),
+        openedWithinDays: number((block)=>{
+            var _block_engagement;
+            return (_block_engagement = block.engagement) == null ? void 0 : _block_engagement.openedWithinDays;
+        }),
+        clickedWithinDays: number((block)=>{
+            var _block_engagement;
+            return (_block_engagement = block.engagement) == null ? void 0 : _block_engagement.clickedWithinDays;
+        }),
+        notOpenedForDays: number((block)=>{
+            var _block_engagement;
+            return (_block_engagement = block.engagement) == null ? void 0 : _block_engagement.notOpenedForDays;
+        }),
+        notClickedForDays: number((block)=>{
+            var _block_engagement;
+            return (_block_engagement = block.engagement) == null ? void 0 : _block_engagement.notClickedForDays;
+        }),
+        inListIds: list((block)=>block.inListIds),
+        notInListIds: list((block)=>block.notInListIds),
+        ownerUids: list((block)=>block.ownerUids),
+        lifecycleStages: list((block)=>block.lifecycleStages),
+        companyIds: list((block)=>block.companyIds),
+        engagedWithinDays: number((block)=>block.engagedWithinDays),
+        // Clauses are objects, so the string-set dedupe above cannot hold them;
+        // two blocks carrying the same clause are one condition, keyed on its
+        // whole shape.
+        custom: (()=>{
+            const seen = new Map();
+            for (const block of blocks){
+                var _block_custom;
+                for (const clause of (_block_custom = block.custom) != null ? _block_custom : []){
+                    seen.set(JSON.stringify(clause), clause);
+                }
+            }
+            return [
+                ...seen.values()
+            ];
+        })()
+    };
+}
+/**
+ * A typed number, or nothing at all.
+ *
+ * An empty box is not zero. `Number('')` is `0`, and a rule normalizer that
+ * accepts zero would turn every field the merchant left alone into an active
+ * filter — `noPurchaseForDays: 0` matches nobody, so an untouched form would
+ * quietly produce an empty audience.
+ */ const typedNumber = (value)=>{
+    const trimmed = value.trim();
+    if (!trimmed) return undefined;
+    const parsed = Number(trimmed);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : undefined;
+};
+/**
+ * One filter of the draft, as the smallest block it can live in.
+ *
+ * `any` mode puts each of these in its own OR branch, so this list is what
+ * decides how finely "any of these filters" is read: per CONTROL, which is
+ * what a reader who just typed into eleven boxes means by "any of them". A
+ * coarser split — the whole purchase-history block as one branch — would ask
+ * them to satisfy three purchase conditions together to match the branch.
+ */ function draftDimensions(draft) {
+    const blocks = [];
+    const tags = splitRuleList(draft.tags);
+    if (tags.length) blocks.push({
+        tags
+    });
+    if (draft.captureSources.length) {
+        blocks.push({
+            captureSources: draft.captureSources
+        });
+    }
+    const formNames = splitRuleList(draft.formNames);
+    if (formNames.length) blocks.push({
+        formNames
+    });
+    if (draft.campaignIds.length) blocks.push({
+        campaignIds: draft.campaignIds
+    });
+    const createdAfterMs = draft.createdAfter ? Date.parse(draft.createdAfter) : undefined;
+    if (createdAfterMs !== undefined && Number.isFinite(createdAfterMs)) {
+        blocks.push({
+            createdAfterMs
+        });
+    }
+    const createdBeforeMs = draft.createdBefore ? Date.parse(draft.createdBefore) : undefined;
+    if (createdBeforeMs !== undefined && Number.isFinite(createdBeforeMs)) {
+        blocks.push({
+            createdBeforeMs
+        });
+    }
+    const ordersCountAtLeast = typedNumber(draft.ordersCountAtLeast);
+    if (ordersCountAtLeast !== undefined) {
+        blocks.push({
+            behavior: {
+                ordersCountAtLeast
+            }
+        });
+    }
+    // Whole units in, cents out — rounded, because a half-cent threshold is not
+    // a quantity any order total can be compared against.
+    const ltv = typedNumber(draft.ltvAtLeast);
+    if (ltv !== undefined) {
+        blocks.push({
+            behavior: {
+                ltvCentsAtLeast: Math.round(ltv * 100)
+            }
+        });
+    }
+    const lastPurchaseWithinDays = typedNumber(draft.lastPurchaseWithinDays);
+    if (lastPurchaseWithinDays !== undefined) {
+        blocks.push({
+            behavior: {
+                lastPurchaseWithinDays
+            }
+        });
+    }
+    const noPurchaseForDays = typedNumber(draft.noPurchaseForDays);
+    if (noPurchaseForDays !== undefined) {
+        blocks.push({
+            behavior: {
+                noPurchaseForDays
+            }
+        });
+    }
+    const openedWithinDays = typedNumber(draft.openedWithinDays);
+    if (openedWithinDays !== undefined) {
+        blocks.push({
+            engagement: {
+                openedWithinDays
+            }
+        });
+    }
+    const clickedWithinDays = typedNumber(draft.clickedWithinDays);
+    if (clickedWithinDays !== undefined) {
+        blocks.push({
+            engagement: {
+                clickedWithinDays
+            }
+        });
+    }
+    const notOpenedForDays = typedNumber(draft.notOpenedForDays);
+    if (notOpenedForDays !== undefined) {
+        blocks.push({
+            engagement: {
+                notOpenedForDays
+            }
+        });
+    }
+    const notClickedForDays = typedNumber(draft.notClickedForDays);
+    if (notClickedForDays !== undefined) {
+        blocks.push({
+            engagement: {
+                notClickedForDays
+            }
+        });
+    }
+    if (draft.inListIds.length) blocks.push({
+        inListIds: draft.inListIds
+    });
+    if (draft.notInListIds.length) {
+        blocks.push({
+            notInListIds: draft.notInListIds
+        });
+    }
+    if (draft.ownerUids.length) blocks.push({
+        ownerUids: draft.ownerUids
+    });
+    if (draft.lifecycleStages.length) {
+        blocks.push({
+            lifecycleStages: draft.lifecycleStages
+        });
+    }
+    if (draft.companyIds.length) blocks.push({
+        companyIds: draft.companyIds
+    });
+    const engagedWithinDays = typedNumber(draft.engagedWithinDays);
+    if (engagedWithinDays !== undefined) blocks.push({
+        engagedWithinDays
+    });
+    // One block PER CLAUSE, so that "any one of the filters below" reads each
+    // condition row as a filter of its own — the same grain the purchase
+    // figures get. `mergeDimensions` folds them back into one list for `all`.
+    // An unfinished row (no value where one is compared) is dropped by the
+    // normalizer at the end, so it is never a condition until it is one.
+    for (const clause of draft.custom)blocks.push({
+        custom: [
+            clause
+        ]
+    });
+    return blocks;
+}
+/** The blocks merged into one AND-block, for `all` and `none`. */ function mergeDimensions(blocks) {
+    const merged = {};
+    for (const block of blocks){
+        for (const [key, value] of Object.entries(block)){
+            var _merged_key, _merged_key1;
+            // `behavior` and `engagement` arrive one leaf at a time, so they are
+            // merged at depth. A shallow assign would keep only the last leaf of
+            // each and silently drop the other three. `custom` arrives one clause
+            // at a time for the same reason and is concatenated for the same one.
+            merged[key] = key === 'behavior' || key === 'engagement' ? _extends({}, (_merged_key = merged[key]) != null ? _merged_key : {}, value) : key === 'custom' ? [
+                ...(_merged_key1 = merged[key]) != null ? _merged_key1 : [],
+                ...value
+            ] : value;
+        }
+    }
+    return merged;
+}
+/** What the controls mean, coerced by the function the matcher reads through. */ export function draftToRule(draft) {
+    const blocks = draftDimensions(draft);
+    /*
+   * Normalized on the way IN by the same function the materializer reads it
+   * back through. A rule coerced on the way out but not on the way in is a
+   * rule the console can display differently from the way it evaluates.
+   */ return normalizeDynamicListRule(_extends({
+        sources: draft.sources
+    }, draft.segmentId ? {
+        segmentId: draft.segmentId
+    } : {}, draft.viewId ? {
+        viewId: draft.viewId
+    } : {}, draft.match === 'any' ? // is no constraint — so the rule is `sources AND (one of these)`.
+    {
+        any: blocks
+    } : _extends({}, mergeDimensions(blocks), draft.match === 'none' && blocks.length ? {
+        negate: true
+    } : {})));
+}
+export function DynamicListRuleFields(props) {
+    var _team_error;
+    const { scope, hostId, draft, onChange, listId } = props;
+    const segmentDocs = useOrgContactSegments(scope);
+    const viewDocs = useOrgCrmViews(scope);
+    const listDocs = useOrgLists(scope);
+    /*
+   * The site's campaigns, read because this form is on screen.
+   *
+   * `enabled` is off by default on the hook for the surfaces that render a
+   * picker beside fields a reader came for; here the picker IS one of the
+   * fields the reader came for, and the same reasoning that opens the segment
+   * listen opens this one.
+   */ const siteCampaigns = useHostCampaigns(hostId, {
+        enabled: true
+    });
+    /*
+   * THE CRM PICKERS' OPTIONS (AGL-2603), read because this form is on screen
+   * — the same bargain the segments and the campaigns get, one section up.
+   *
+   * The team comes through the members route rather than the collection, so
+   * a collaborator scoped to one site can still assign an owner; the field
+   * definitions are one bounded read; the companies are a SEARCH and read
+   * nothing until something is typed.
+   */ const team = useOrgMemberOptions(scope[1], {
+        enabled: true
+    });
+    const fieldDefinitions = useOrgContactFields(scope);
+    const [companySearch, setCompanySearch] = useState('');
+    const companies = useOrgCompanyOptions({
+        scope,
+        search: companySearch,
+        selectedIds: draft.companyIds
+    });
+    /*
+   * The saved segment the rule already names, even when the picker's window
+   * does not reach it.
+   *
+   * A `Select` whose value is not among its options renders empty and warns,
+   * so a rule pointing at the fifty-first segment would reopen looking as
+   * though it named none — and saving from that screen would erase the
+   * reference. The id is offered as its own option instead.
+   */ const segments = useMemo(()=>{
+        const rows = segmentDocs;
+        if (!draft.segmentId || rows.some((row)=>row.$id === draft.segmentId)) {
+            return rows;
+        }
+        return [
+            {
+                $id: draft.segmentId,
+                name: draft.segmentId
+            },
+            ...rows
+        ];
+    }, [
+        segmentDocs,
+        draft.segmentId
+    ]);
+    /*
+   * The saved VIEW the rule already names, kept the way the segment is
+   * (AGL-2617) — and for one more reason: the picker lists only views that
+   * translate whole, so a view edited past that after the rule named it
+   * would vanish from its own picker, and saving from that screen would
+   * erase the reference. Shown as its id, the sweep's refusal is at least
+   * visible.
+   */ const crmViews = useMemo(()=>{
+        const rows = viewDocs;
+        if (!draft.viewId || rows.some((row)=>row.$id === draft.viewId)) {
+            return rows;
+        }
+        return [
+            {
+                $id: draft.viewId,
+                name: draft.viewId
+            },
+            ...rows
+        ];
+    }, [
+        viewDocs,
+        draft.viewId
+    ]);
+    /** Every audience except the one being edited — see the prop's note. */ const lists = useMemo(()=>listDocs.filter((row)=>row.$id !== listId), [
+        listDocs,
+        listId
+    ]);
+    /** Ids the pickers can show, so a clause names an audience rather than a uid. */ const names = useMemo(()=>({
+            lists: Object.fromEntries(listDocs.map((row)=>{
+                var _row_name;
+                return [
+                    row.$id,
+                    (_row_name = row.name) != null ? _row_name : row.$id
+                ];
+            })),
+            segments: Object.fromEntries(segments.map((row)=>{
+                var _row_name;
+                return [
+                    row.$id,
+                    (_row_name = row.name) != null ? _row_name : row.$id
+                ];
+            })),
+            views: Object.fromEntries(crmViews.map((row)=>[
+                    row.$id,
+                    row.name
+                ])),
+            campaigns: Object.fromEntries(siteCampaigns.options.map((option)=>[
+                    option.value,
+                    option.label
+                ])),
+            members: Object.fromEntries(team.options.map((option)=>[
+                    option.uid,
+                    option.label
+                ])),
+            companies: companies.names,
+            fields: Object.fromEntries(fieldDefinitions.fields.map((field)=>[
+                    field.key,
+                    field.label
+                ]))
+        }), [
+        listDocs,
+        segments,
+        crmViews,
+        siteCampaigns.options,
+        team.options,
+        companies.names,
+        fieldDefinitions.fields
+    ]);
+    /*
+   * A stored owner the roster no longer lists, and a stored field key no
+   * definition names, are offered as their own option — the segment picker's
+   * discipline, for the same reason: a `Select` whose value is not among its
+   * options renders empty, and a rule saved from that screen would lose the
+   * clause it was opened with. A team member who left still owns the
+   * contacts they were assigned until somebody reassigns them, and a retired
+   * field still holds every value written under it.
+   */ const ownerOptions = useMemo(()=>{
+        const known = new Set(team.options.map((option)=>option.uid));
+        return [
+            ...draft.ownerUids.filter((uid)=>!known.has(uid)).map((uid)=>({
+                    uid,
+                    label: uid
+                })),
+            ...team.options
+        ];
+    }, [
+        team.options,
+        draft.ownerUids
+    ]);
+    const fieldOptions = useMemo(()=>{
+        const known = new Set(fieldDefinitions.fields.map((field)=>field.key));
+        return [
+            ...draft.custom.filter((clause)=>!known.has(clause.key)).map((clause)=>({
+                    key: clause.key,
+                    label: clause.key
+                })).filter((entry, index, all)=>all.findIndex((other)=>other.key === entry.key) === index),
+            ...fieldDefinitions.fields.map(({ key, label })=>({
+                    key,
+                    label
+                }))
+        ];
+    }, [
+        fieldDefinitions.fields,
+        draft.custom
+    ]);
+    /** The definition a clause's key names, when the org still has one. */ const definitionFor = (key)=>fieldDefinitions.fields.find((field)=>field.key === key);
+    const set = (key, value)=>onChange(_extends({}, draft, {
+            [key]: value
+        }));
+    /*
+   * THE CUSTOM-FIELD ROWS. A new row names the first definition with an
+   * empty value, so it is on screen and NOT yet a filter — `draftDimensions`
+   * hands it to the normalizer, which drops a valued operator with no value
+   * until the reader types one. Changing the field clears the value, because
+   * a value typed for a number field is not a value for the select that
+   * replaced it; changing the operator to a presence test removes it, so the
+   * stored clause carries no value the sentence does not read.
+   */ const addClause = ()=>{
+        const first = fieldOptions[0];
+        if (!first) return;
+        set('custom', [
+            ...draft.custom,
+            {
+                key: first.key,
+                op: 'eq',
+                value: ''
+            }
+        ]);
+    };
+    const updateClause = (index, patch)=>set('custom', draft.custom.map((clause, at)=>{
+            if (at !== index) return clause;
+            const next = _extends({}, clause, patch);
+            if (PRESENCE_OPS.has(next.op)) delete next.value;
+            return next;
+        }));
+    const removeClause = (index)=>set('custom', draft.custom.filter((_, at)=>at !== index));
+    /** A multi-select hands back a string when only one option is chosen. */ const asArray = (value)=>typeof value === 'string' ? [
+            value
+        ] : value != null ? value : [];
+    const contactsOnly = draft.sources.includes('contacts');
+    return /*#__PURE__*/ _jsxs(Stack, {
+        spacing: 1.5,
+        children: [
+            /*#__PURE__*/ _jsxs(Box, {
+                sx: {
+                    border: 1,
+                    borderColor: 'divider',
+                    borderRadius: 1,
+                    p: 1.5
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(Typography, {
+                        variant: "overline",
+                        color: "text.secondary",
+                        children: 'This audience'
+                    }),
+                    describeDynamicListRule(draftToRule(draft), names).map((clause)=>/*#__PURE__*/ _jsx(Typography, {
+                            variant: "body2",
+                            children: clause
+                        }, clause))
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Stack, {
+                direction: "row",
+                spacing: 1,
+                useFlexGap: true,
+                sx: {
+                    flexWrap: 'wrap'
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(TextField, {
+                        select: true,
+                        size: "small",
+                        label: "People from",
+                        value: draft.sources,
+                        onChange: (event)=>set('sources', asArray(event.target.value)),
+                        slotProps: {
+                            select: {
+                                multiple: true
+                            }
+                        },
+                        sx: {
+                            minWidth: 220
+                        },
+                        children: Object.entries(SOURCE_LABELS).map(([value, label])=>/*#__PURE__*/ _jsx(MenuItem, {
+                                value: value,
+                                children: label
+                            }, value))
+                    }),
+                    /*#__PURE__*/ _jsxs(TextField, {
+                        select: true,
+                        size: "small",
+                        label: "Match",
+                        value: draft.match,
+                        onChange: (event)=>set('match', event.target.value),
+                        helperText: "A saved segment always applies",
+                        sx: {
+                            minWidth: 210
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(MenuItem, {
+                                value: "all",
+                                children: 'All of the filters below'
+                            }),
+                            /*#__PURE__*/ _jsx(MenuItem, {
+                                value: "any",
+                                children: 'Any one of the filters below'
+                            }),
+                            /*#__PURE__*/ _jsx(MenuItem, {
+                                value: "none",
+                                children: 'Nobody matching all of them'
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        type: "date",
+                        size: "small",
+                        label: "Created after",
+                        value: draft.createdAfter,
+                        onChange: (event)=>set('createdAfter', event.target.value),
+                        slotProps: {
+                            inputLabel: {
+                                shrink: true
+                            }
+                        },
+                        sx: {
+                            minWidth: 170
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        type: "date",
+                        size: "small",
+                        label: "Created before",
+                        value: draft.createdBefore,
+                        onChange: (event)=>set('createdBefore', event.target.value),
+                        slotProps: {
+                            inputLabel: {
+                                shrink: true
+                            }
+                        },
+                        sx: {
+                            minWidth: 170
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        size: "small",
+                        label: "Submitted form",
+                        placeholder: "Contact us",
+                        helperText: "Form submissions only",
+                        value: draft.formNames,
+                        onChange: (event)=>set('formNames', event.target.value),
+                        sx: {
+                            minWidth: 180
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(Box, {
+                        sx: {
+                            minWidth: 240,
+                            flexGrow: 1,
+                            maxWidth: 360
+                        },
+                        children: /*#__PURE__*/ _jsx(CampaignPicker, {
+                            options: siteCampaigns.options,
+                            value: draft.campaignIds,
+                            onChange: (next)=>set('campaignIds', next),
+                            label: "In campaign",
+                            helperText: "Contacts and form submissions filed under any campaign picked. Being in a campaign is not consent to be emailed.",
+                            empty: siteCampaigns.ready && !siteCampaigns.options.length,
+                            emptyText: "This site has no campaigns yet. Create one from Marketing to build an audience from it."
+                        })
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(Divider, {}),
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "overline",
+                color: "text.secondary",
+                children: 'Contacts'
+            }),
+            contactsOnly ? null : /*#__PURE__*/ _jsx(Typography, {
+                variant: "caption",
+                color: "text.secondary",
+                children: 'These apply only to people drawn from Contacts. The rule does not ' + 'draw from Contacts, so they select nobody on their own — the ' + 'other sources are matched without them.'
+            }),
+            /*#__PURE__*/ _jsxs(Stack, {
+                direction: "row",
+                spacing: 1,
+                useFlexGap: true,
+                sx: {
+                    flexWrap: 'wrap'
+                },
+                children: [
+                    /*#__PURE__*/ _jsxs(TextField, {
+                        select: true,
+                        size: "small",
+                        label: "Saved segment",
+                        value: draft.segmentId,
+                        onChange: (event)=>set('segmentId', event.target.value),
+                        helperText: "Reuses that segment's tags and sources",
+                        sx: {
+                            minWidth: 200
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(MenuItem, {
+                                value: "",
+                                children: 'None'
+                            }),
+                            segments.map((segment)=>{
+                                var _segment_name;
+                                return /*#__PURE__*/ _jsx(MenuItem, {
+                                    value: segment.$id,
+                                    children: (_segment_name = segment.name) != null ? _segment_name : segment.$id
+                                }, segment.$id);
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsxs(TextField, {
+                        select: true,
+                        size: "small",
+                        label: "Saved view",
+                        value: draft.viewId,
+                        onChange: (event)=>set('viewId', event.target.value),
+                        helperText: "Reuses that Contacts view's filters",
+                        sx: {
+                            minWidth: 200
+                        },
+                        children: [
+                            /*#__PURE__*/ _jsx(MenuItem, {
+                                value: "",
+                                children: 'None'
+                            }),
+                            crmViews.map((view)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                    value: view.$id,
+                                    children: view.name
+                                }, view.$id))
+                        ]
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        size: "small",
+                        label: "Tagged",
+                        placeholder: "vip, wholesale",
+                        value: draft.tags,
+                        onChange: (event)=>set('tags', event.target.value),
+                        sx: {
+                            minWidth: 180
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        select: true,
+                        size: "small",
+                        label: "Captured by",
+                        value: draft.captureSources,
+                        onChange: (event)=>set('captureSources', asArray(event.target.value)),
+                        slotProps: {
+                            select: {
+                                multiple: true
+                            }
+                        },
+                        helperText: "How the contact reached you",
+                        sx: {
+                            minWidth: 200
+                        },
+                        children: Object.entries(CONTACT_SOURCE_LABELS).map(([value, label])=>/*#__PURE__*/ _jsx(MenuItem, {
+                                value: value,
+                                children: label
+                            }, value))
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Stack, {
+                direction: "row",
+                spacing: 1,
+                useFlexGap: true,
+                sx: {
+                    flexWrap: 'wrap'
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(TextField, {
+                        select: true,
+                        size: "small",
+                        label: "Owned by",
+                        value: draft.ownerUids,
+                        onChange: (event)=>set('ownerUids', asArray(event.target.value)),
+                        slotProps: {
+                            select: {
+                                multiple: true,
+                                renderValue: (selected)=>selected.map((uid)=>named(uid, names.members)).join(', ')
+                            }
+                        },
+                        error: Boolean(team.error),
+                        helperText: (_team_error = team.error) != null ? _team_error : 'Any of these team members. Unowned contacts are left out.',
+                        sx: {
+                            minWidth: 220
+                        },
+                        children: ownerOptions.map((option)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                value: option.uid,
+                                children: option.label
+                            }, option.uid))
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        select: true,
+                        size: "small",
+                        label: "Lifecycle stage",
+                        value: draft.lifecycleStages,
+                        onChange: (event)=>set('lifecycleStages', asArray(event.target.value)),
+                        slotProps: {
+                            select: {
+                                multiple: true,
+                                renderValue: (selected)=>selected.map((stage)=>{
+                                        var _CONTACT_LIFECYCLE_STAGE_LABELS_stage;
+                                        return (_CONTACT_LIFECYCLE_STAGE_LABELS_stage = CONTACT_LIFECYCLE_STAGE_LABELS[stage]) != null ? _CONTACT_LIFECYCLE_STAGE_LABELS_stage : stage;
+                                    }).join(', ')
+                            }
+                        },
+                        helperText: "Any of these stages",
+                        sx: {
+                            minWidth: 200
+                        },
+                        children: CONTACT_LIFECYCLE_STAGES.map((stage)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                value: stage,
+                                children: CONTACT_LIFECYCLE_STAGE_LABELS[stage]
+                            }, stage))
+                    }),
+                    /*#__PURE__*/ _jsx(Autocomplete, {
+                        multiple: true,
+                        size: "small",
+                        options: companies.hits,
+                        value: draft.companyIds.map((id)=>{
+                            var _companies_names_id;
+                            return {
+                                id,
+                                label: (_companies_names_id = companies.names[id]) != null ? _companies_names_id : id
+                            };
+                        }),
+                        getOptionLabel: (option)=>option.label,
+                        isOptionEqualToValue: (option, chosen)=>option.id === chosen.id,
+                        // The query already narrowed the hits; a second, client-side
+                        // filter on the label would hide a match whose stored name differs
+                        // from its search key.
+                        filterOptions: (options)=>options,
+                        inputValue: companySearch,
+                        onInputChange: (_event, value, reason)=>{
+                            if (reason !== 'reset') setCompanySearch(value);
+                        },
+                        onChange: (_event, value)=>set('companyIds', value.map((option)=>option.id)),
+                        loading: companies.searching,
+                        noOptionsText: companySearch ? 'No company by that name' : 'Type to search companies',
+                        renderInput: (params)=>/*#__PURE__*/ _jsx(TextField, _extends({}, params, {
+                                label: "At company",
+                                helperText: "Any of these companies"
+                            })),
+                        sx: {
+                            minWidth: 260,
+                            flexGrow: 1,
+                            maxWidth: 420
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        type: "number",
+                        size: "small",
+                        label: "Engaged with a campaign within (days)",
+                        helperText: "Opened or clicked one of your campaigns. Never engaged is left out.",
+                        value: draft.engagedWithinDays,
+                        onChange: (event)=>set('engagedWithinDays', event.target.value),
+                        sx: {
+                            minWidth: 280
+                        }
+                    })
+                ]
+            }),
+            draft.custom.map((clause, index)=>{
+                var _clause_value, _definition_options;
+                const definition = definitionFor(clause.key);
+                const valueText = String((_clause_value = clause.value) != null ? _clause_value : '');
+                return /*#__PURE__*/ _jsxs(Stack, {
+                    direction: "row",
+                    spacing: 1,
+                    useFlexGap: true,
+                    sx: {
+                        flexWrap: 'wrap',
+                        alignItems: 'flex-start'
+                    },
+                    children: [
+                        /*#__PURE__*/ _jsx(TextField, {
+                            select: true,
+                            size: "small",
+                            label: "Field",
+                            value: clause.key,
+                            onChange: (event)=>updateClause(index, {
+                                    key: event.target.value,
+                                    value: ''
+                                }),
+                            sx: {
+                                minWidth: 180
+                            },
+                            children: fieldOptions.map((option)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                    value: option.key,
+                                    children: option.label
+                                }, option.key))
+                        }),
+                        /*#__PURE__*/ _jsx(TextField, {
+                            select: true,
+                            size: "small",
+                            label: "Condition",
+                            value: clause.op,
+                            onChange: (event)=>updateClause(index, {
+                                    op: event.target.value
+                                }),
+                            sx: {
+                                minWidth: 160
+                            },
+                            children: DYNAMIC_LIST_CUSTOM_OPS.map((op)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                    value: op,
+                                    children: CUSTOM_OP_LABELS[op]
+                                }, op))
+                        }),
+                        PRESENCE_OPS.has(clause.op) ? null : (definition == null ? void 0 : definition.type) === 'select' ? /*#__PURE__*/ _jsx(TextField, {
+                            select: true,
+                            size: "small",
+                            label: "Value",
+                            value: valueText,
+                            onChange: (event)=>updateClause(index, {
+                                    value: event.target.value
+                                }),
+                            sx: {
+                                minWidth: 180
+                            },
+                            children: ((_definition_options = definition.options) != null ? _definition_options : []).map((option)=>/*#__PURE__*/ _jsx(MenuItem, {
+                                    value: option,
+                                    children: option
+                                }, option))
+                        }) : (definition == null ? void 0 : definition.type) === 'checkbox' ? /*#__PURE__*/ _jsxs(TextField, {
+                            select: true,
+                            size: "small",
+                            label: "Value",
+                            value: clause.value === true ? 'true' : clause.value === false ? 'false' : '',
+                            onChange: (event)=>updateClause(index, {
+                                    value: event.target.value === 'true'
+                                }),
+                            sx: {
+                                minWidth: 140
+                            },
+                            children: [
+                                /*#__PURE__*/ _jsx(MenuItem, {
+                                    value: "true",
+                                    children: 'Checked'
+                                }),
+                                /*#__PURE__*/ _jsx(MenuItem, {
+                                    value: "false",
+                                    children: 'Not checked'
+                                })
+                            ]
+                        }) : (definition == null ? void 0 : definition.type) === 'number' ? /*#__PURE__*/ _jsx(TextField, {
+                            type: "number",
+                            size: "small",
+                            label: "Value",
+                            value: valueText,
+                            onChange: (event)=>{
+                                // A number field stores a NUMBER, so the matcher compares
+                                // 10 with 9 and not "10" with "9"; half-typed text stays
+                                // text until it parses, rather than becoming NaN.
+                                const text = event.target.value;
+                                const parsed = Number(text);
+                                updateClause(index, {
+                                    value: text.trim() !== '' && Number.isFinite(parsed) ? parsed : text
+                                });
+                            },
+                            sx: {
+                                minWidth: 140
+                            }
+                        }) : /*#__PURE__*/ _jsx(TextField, {
+                            type: (definition == null ? void 0 : definition.type) === 'date' ? 'date' : 'text',
+                            size: "small",
+                            label: "Value",
+                            value: valueText,
+                            onChange: (event)=>updateClause(index, {
+                                    value: event.target.value
+                                }),
+                            slotProps: (definition == null ? void 0 : definition.type) === 'date' ? {
+                                inputLabel: {
+                                    shrink: true
+                                }
+                            } : undefined,
+                            sx: {
+                                minWidth: 180
+                            }
+                        }),
+                        /*#__PURE__*/ _jsx(Button, {
+                            size: "small",
+                            onClick: ()=>removeClause(index),
+                            children: 'Remove'
+                        })
+                    ]
+                }, index);
+            }),
+            /*#__PURE__*/ _jsxs(Box, {
+                children: [
+                    /*#__PURE__*/ _jsx(Button, {
+                        size: "small",
+                        variant: "outlined",
+                        disabled: !fieldOptions.length,
+                        onClick: addClause,
+                        children: 'Add a field condition'
+                    }),
+                    fieldDefinitions.ready && !fieldDefinitions.fields.length ? /*#__PURE__*/ _jsx(Typography, {
+                        variant: "caption",
+                        color: "text.secondary",
+                        sx: {
+                            display: 'block',
+                            mt: 0.5
+                        },
+                        children: 'This workspace has no custom contact fields yet. Define them ' + 'under CRM → Fields to filter on them here.'
+                    }) : null
+                ]
+            }),
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "overline",
+                color: "text.secondary",
+                children: 'Purchase history'
+            }),
+            /*#__PURE__*/ _jsxs(Stack, {
+                direction: "row",
+                spacing: 1,
+                useFlexGap: true,
+                sx: {
+                    flexWrap: 'wrap'
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(TextField, {
+                        type: "number",
+                        size: "small",
+                        label: "Orders at least",
+                        value: draft.ordersCountAtLeast,
+                        onChange: (event)=>set('ordersCountAtLeast', event.target.value),
+                        sx: {
+                            minWidth: 160
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        type: "number",
+                        size: "small",
+                        label: "Spent at least",
+                        helperText: "Lifetime, in your store's currency",
+                        value: draft.ltvAtLeast,
+                        onChange: (event)=>set('ltvAtLeast', event.target.value),
+                        sx: {
+                            minWidth: 190
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        type: "number",
+                        size: "small",
+                        label: "Bought within (days)",
+                        value: draft.lastPurchaseWithinDays,
+                        onChange: (event)=>set('lastPurchaseWithinDays', event.target.value),
+                        sx: {
+                            minWidth: 190
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        type: "number",
+                        size: "small",
+                        label: "Nothing bought for (days)",
+                        helperText: "Lapsed customers — never bought is not lapsed",
+                        value: draft.noPurchaseForDays,
+                        onChange: (event)=>set('noPurchaseForDays', event.target.value),
+                        sx: {
+                            minWidth: 220
+                        }
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(Divider, {}),
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "overline",
+                color: "text.secondary",
+                children: 'Email engagement'
+            }),
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "caption",
+                color: "text.secondary",
+                children: 'Opens and clicks across every email this workspace has sent the ' + 'person. Clicks are the stronger signal: mail apps that preload ' + 'images record an open the reader never made.'
+            }),
+            /*#__PURE__*/ _jsxs(Stack, {
+                direction: "row",
+                spacing: 1,
+                useFlexGap: true,
+                sx: {
+                    flexWrap: 'wrap'
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(TextField, {
+                        type: "number",
+                        size: "small",
+                        label: "Opened within (days)",
+                        value: draft.openedWithinDays,
+                        onChange: (event)=>set('openedWithinDays', event.target.value),
+                        sx: {
+                            minWidth: 190
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        type: "number",
+                        size: "small",
+                        label: "Clicked within (days)",
+                        value: draft.clickedWithinDays,
+                        onChange: (event)=>set('clickedWithinDays', event.target.value),
+                        sx: {
+                            minWidth: 190
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        type: "number",
+                        size: "small",
+                        label: "Nothing opened for (days)",
+                        helperText: "Never opened counts",
+                        value: draft.notOpenedForDays,
+                        onChange: (event)=>set('notOpenedForDays', event.target.value),
+                        sx: {
+                            minWidth: 210
+                        }
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        type: "number",
+                        size: "small",
+                        label: "Nothing clicked for (days)",
+                        helperText: "Never clicked counts",
+                        value: draft.notClickedForDays,
+                        onChange: (event)=>set('notClickedForDays', event.target.value),
+                        sx: {
+                            minWidth: 210
+                        }
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(Divider, {}),
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "overline",
+                color: "text.secondary",
+                children: 'Other audiences'
+            }),
+            /*#__PURE__*/ _jsxs(Stack, {
+                direction: "row",
+                spacing: 1,
+                useFlexGap: true,
+                sx: {
+                    flexWrap: 'wrap'
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(TextField, {
+                        select: true,
+                        size: "small",
+                        label: "Already on",
+                        value: draft.inListIds,
+                        onChange: (event)=>set('inListIds', asArray(event.target.value)),
+                        slotProps: {
+                            select: {
+                                multiple: true
+                            }
+                        },
+                        helperText: "Members of every audience picked",
+                        sx: {
+                            minWidth: 220
+                        },
+                        children: lists.map((row)=>{
+                            var _row_name;
+                            return /*#__PURE__*/ _jsx(MenuItem, {
+                                value: row.$id,
+                                children: (_row_name = row.name) != null ? _row_name : row.$id
+                            }, row.$id);
+                        })
+                    }),
+                    /*#__PURE__*/ _jsx(TextField, {
+                        select: true,
+                        size: "small",
+                        label: "Not on",
+                        value: draft.notInListIds,
+                        onChange: (event)=>set('notInListIds', asArray(event.target.value)),
+                        slotProps: {
+                            select: {
+                                multiple: true
+                            }
+                        },
+                        helperText: "Excludes members of any audience picked",
+                        sx: {
+                            minWidth: 220
+                        },
+                        children: lists.map((row)=>{
+                            var _row_name;
+                            return /*#__PURE__*/ _jsx(MenuItem, {
+                                value: row.$id,
+                                children: (_row_name = row.name) != null ? _row_name : row.$id
+                            }, row.$id);
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+DynamicListRuleFields.displayName = 'DynamicListRuleFields';
+/**
+ * A draft seeded from a rule that arrives after the form does.
+ *
+ * The edit page mounts before its list document lands, so the controls are
+ * built from an empty rule and filled in once. Seeding ONCE per subject is the
+ * whole point: the document is a live listen, and re-seeding on every snapshot
+ * would overwrite whatever the reader had typed each time anything on the list
+ * changed — including the snapshot the reader's own save produces.
+ */ export function useRuleDraft(rule, resetKey) {
+    const [draft, setDraft] = useState(EMPTY_RULE_DRAFT);
+    const seededFor = useRef('');
+    useEffect(()=>{
+        if (!rule || seededFor.current === resetKey) return;
+        seededFor.current = resetKey;
+        setDraft(ruleToDraft(rule));
+    }, [
+        rule,
+        resetKey
+    ]);
+    return [
+        draft,
+        setDraft
+    ];
+}
+export default DynamicListRuleFields;
+
+//# sourceMappingURL=dynamic-list-rule-fields.js.map