@reachy/audience-module 1.0.4 → 1.0.6

package/dist/engine/V2AudienceEngine.js

@@ -0,0 +1,1269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.V2AudienceEngine = void 0;
+const CriteriaParser_1 = require("../builders/CriteriaParser");
+class V2AudienceEngine {
+    constructor(params) {
+        this.supabase = params.supabaseClient;
+        this.debug = !!params.debug;
+        this.logger = params.logger || console;
+    }
+    async getContactIdsByAudienceCriteriaV2(organizationId, projectId, criteriaRaw) {
+        let criteria = CriteriaParser_1.CriteriaParser.parse(criteriaRaw);
+        if ((!Array.isArray(criteria.groups) || criteria.groups.length === 0) &&
+            (Array.isArray(criteria.filters) || Array.isArray(criteria.conditions))) {
+            criteria = coerceCriteriaToGroups(criteria);
+        }
+        this.dlog('start', {
+            organizationId,
+            projectId,
+            type: String(criteria?.type || ''),
+            groups: Array.isArray(criteria?.groups) ? criteria.groups.length : 0
+        });
+        if (!criteria || !Array.isArray(criteria.groups) || criteria.groups.length === 0) {
+            this.dlog('V2 Engine: no groups; returning empty set');
+            return new Set();
+        }
+        const typeId = String(criteria?.type || '');
+        const isPastBehavior = typeId === 'past-behavior';
+        const rawAsOf = (criteria?.asOf ?? criteria?.as_of ?? criteria?.frozenAt ?? criteria?.frozen_at);
+        const asOfDate = isPastBehavior && typeof rawAsOf === 'string' && rawAsOf.trim() ? new Date(rawAsOf) : null;
+        const asOf = isPastBehavior && asOfDate && !Number.isNaN(asOfDate.getTime())
+            ? asOfDate
+            : null;
+        const asOfIso = asOf ? asOf.toISOString() : null;
+        const { data: allContacts } = await this.supabase
+            .from('contacts')
+            .select('id, reachy_id, email')
+            .eq('organization_id', organizationId)
+            .eq('project_id', projectId);
+        const allContactIds = new Set((allContacts || []).map((c) => c.id));
+        const reachyIdToContactId = new Map();
+        const emailToContactId = new Map();
+        for (const c of allContacts || []) {
+            const rid = c?.reachy_id ? String(c.reachy_id).trim() : '';
+            const cid = c?.id ? String(c.id).trim() : '';
+            if (rid && cid)
+                reachyIdToContactId.set(rid, cid);
+            const email = c?.email ? String(c.email).trim().toLowerCase() : '';
+            if (email && cid)
+                emailToContactId.set(email, cid);
+        }
+        const union = (a, b) => new Set([...a, ...b]);
+        const intersect = (a, b) => new Set([...a].filter(x => b.has(x)));
+        const diff = (a, b) => new Set([...a].filter(x => !b.has(x)));
+        const resolveEventContactId = (row) => {
+            const rawReachyId = row?.reachy_id ? String(row.reachy_id).trim() : '';
+            if (rawReachyId) {
+                const mapped = reachyIdToContactId.get(rawReachyId);
+                if (mapped)
+                    return mapped;
+            }
+            const rawContactId = row?.contact_id ? String(row.contact_id).trim() : '';
+            if (rawContactId && allContactIds.has(rawContactId))
+                return rawContactId;
+            const ed = row?.event_data || {};
+            const emailCandidates = [ed.email, ed.user_email, ed.userEmail, ed.contact_email, ed.contactEmail];
+            for (const e of emailCandidates) {
+                if (typeof e === 'string') {
+                    const normalized = e.trim().toLowerCase();
+                    if (!normalized)
+                        continue;
+                    const mapped = emailToContactId.get(normalized);
+                    if (mapped)
+                        return mapped;
+                }
+            }
+            return null;
+        };
+        const evalEventRule = async (rule) => {
+            const cfg = criteria?.config || {};
+            const effectiveEventName = cfg.eventType && String(cfg.eventType).trim() !== ''
+                ? String(cfg.eventType)
+                : String(rule.eventName);
+            let query = this.supabase
+                .from('contact_events')
+                .select('contact_id, reachy_id, event_data, event_timestamp, event_name')
+                .eq('organization_id', organizationId)
+                .eq('project_id', projectId)
+                .eq('event_name', effectiveEventName);
+            if (isPastBehavior && asOfIso) {
+                query = query.lte('event_timestamp', asOfIso);
+            }
+            if (typeId === 'live-page-visit') {
+                const v = cfg.pageUrl;
+                const d = cfg.domain;
+                const ors = [];
+                if (v && String(v).trim() !== '') {
+                    const like = `%${String(v)}%`;
+                    ors.push(`path.ilike.${like}`);
+                    ors.push(`current_url.ilike.${like}`);
+                }
+                if (d && String(d).trim() !== '') {
+                    const dlike = `%${String(d)}%`;
+                    ors.push(`domain.ilike.${dlike}`);
+                    ors.push(`event_data->>domain.ilike.${dlike}`);
+                }
+                if (ors.length > 0)
+                    query = query.or(ors.join(','));
+            }
+            if (typeId === 'live-referrer') {
+                query = query.eq('session_is_new', true);
+                const ors = [];
+                const v = cfg.referrerUrl;
+                if (v && String(v).trim() !== '')
+                    ors.push(`referrer.ilike.%${String(v)}%`);
+                if (cfg.utm_source && String(cfg.utm_source).trim() !== '')
+                    ors.push(`event_data->>utm_source.ilike.%${String(cfg.utm_source)}%`);
+                if (cfg.utm_medium && String(cfg.utm_medium).trim() !== '')
+                    ors.push(`event_data->>utm_medium.ilike.%${String(cfg.utm_medium)}%`);
+                if (cfg.utm_campaign && String(cfg.utm_campaign).trim() !== '')
+                    ors.push(`event_data->>utm_campaign.ilike.%${String(cfg.utm_campaign)}%`);
+                if (cfg.utm_term && String(cfg.utm_term).trim() !== '')
+                    ors.push(`event_data->>utm_term.ilike.%${String(cfg.utm_term)}%`);
+                if (cfg.utm_content && String(cfg.utm_content).trim() !== '')
+                    ors.push(`event_data->>utm_content.ilike.%${String(cfg.utm_content)}%`);
+                if (ors.length > 0)
+                    query = query.or(ors.join(','));
+            }
+            if (!rule.time && cfg && cfg.timeFrame) {
+                const tf = String(cfg.timeFrame).trim();
+                const now = asOf ?? new Date();
+                let unit = 'days';
+                let value = 7;
+                if (/^\d+$/.test(tf)) {
+                    value = Number(tf);
+                    unit = 'days';
+                }
+                else if (/^\d+\s*m$/.test(tf)) {
+                    value = Number(tf.replace(/m$/, ''));
+                    unit = 'minutes';
+                }
+                else if (/^\d+\s*h$/.test(tf)) {
+                    value = Number(tf.replace(/h$/, ''));
+                    unit = 'hours';
+                }
+                else if (/^\d+\s*d$/.test(tf)) {
+                    value = Number(tf.replace(/d$/, ''));
+                    unit = 'days';
+                }
+                else if (/^\d+\s*w$/.test(tf)) {
+                    value = Number(tf.replace(/w$/, ''));
+                    unit = 'weeks';
+                }
+                else if (/^\d+\s*mo$/.test(tf)) {
+                    value = Number(tf.replace(/mo$/, ''));
+                    unit = 'months';
+                }
+                const units = {
+                    minutes: 60 * 1000,
+                    hours: 60 * 60 * 1000,
+                    days: 24 * 60 * 60 * 1000,
+                    weeks: 7 * 24 * 60 * 60 * 1000,
+                    months: 30 * 24 * 60 * 60 * 1000
+                };
+                const from = new Date(now.getTime() - value * units[unit]);
+                query = query.gte('event_timestamp', from.toISOString());
+            }
+            if (rule.time) {
+                if (rule.time.unit && rule.time.value) {
+                    const unit = String(rule.time.unit);
+                    const value = Number(rule.time.value);
+                    const now = asOf ?? new Date();
+                    const units = {
+                        minutes: 60 * 1000,
+                        hours: 60 * 60 * 1000,
+                        days: 24 * 60 * 60 * 1000,
+                        weeks: 7 * 24 * 60 * 60 * 1000,
+                        months: 30 * 24 * 60 * 60 * 1000
+                    };
+                    const ms = units[unit] ?? units['days'];
+                    const from = new Date(now.getTime() - value * ms);
+                    query = query.gte('event_timestamp', from.toISOString());
+                }
+                else {
+                    if (rule.time.from) {
+                        const rawFrom = rule.time.from;
+                        const fromStr = typeof rawFrom === 'string' ? rawFrom : String(rawFrom);
+                        const isDateOnly = typeof rawFrom === 'string' && !fromStr.includes('T');
+                        const startIso = isDateOnly ? normalizeDateBoundary(fromStr, 'start') : undefined;
+                        const finalFrom = startIso || fromStr;
+                        query = query.gte('event_timestamp', finalFrom);
+                    }
+                    if (rule.time.to) {
+                        const rawTo = rule.time.to;
+                        const toStr = typeof rawTo === 'string' ? rawTo : String(rawTo);
+                        const isDateOnly = typeof rawTo === 'string' && !toStr.includes('T');
+                        const endIsoExclusive = isDateOnly ? normalizeDateBoundary(toStr, 'end') : undefined;
+                        const finalTo = endIsoExclusive || toStr;
+                        query = isDateOnly ? query.lt('event_timestamp', finalTo) : query.lte('event_timestamp', finalTo);
+                    }
+                }
+            }
+            try {
+                const attributes = Array.isArray(rule.attributes) ? rule.attributes : (rule.attributes ? [rule.attributes] : []);
+                const trackerEvents = new Set([
+                    'click',
+                    'page_view',
+                    'form_submit',
+                    'time_on_page',
+                    'heartbeat',
+                    'scroll_depth',
+                    'scroll_depth_snapshot'
+                ]);
+                const resolveDbFieldForAttrKey = (keyRaw) => {
+                    const key = String(keyRaw || '').trim();
+                    if (!key)
+                        return null;
+                    const columnKeys = new Set([
+                        'current_url',
+                        'domain',
+                        'path',
+                        'referrer',
+                        'page_title',
+                        'utm_source',
+                        'utm_medium',
+                        'utm_campaign',
+                        'utm_term',
+                        'utm_content',
+                        'session_id',
+                        'session_is_new'
+                    ]);
+                    if (columnKeys.has(key))
+                        return { kind: 'column', field: key };
+                    const buildNested = (root, dottedPath) => jsonNestedTextAccessor(root, dottedPath);
+                    if (key.startsWith('event_data.'))
+                        return { kind: 'json', field: buildNested('event_data', key.replace(/^event_data\./, '')) };
+                    if (key.startsWith('custom_data.'))
+                        return { kind: 'json', field: buildNested('event_data->custom_data', key.replace(/^custom_data\./, '')) };
+                    if (key.startsWith('url_data.'))
+                        return { kind: 'json', field: buildNested('event_data->url_data', key.replace(/^url_data\./, '')) };
+                    if (key.startsWith('utm_data.'))
+                        return { kind: 'json', field: buildNested('event_data->utm_data', key.replace(/^utm_data\./, '')) };
+                    if (key.startsWith('session_data.'))
+                        return { kind: 'json', field: buildNested('event_data->session_data', key.replace(/^session_data\./, '')) };
+                    if (key.includes('.'))
+                        return { kind: 'json', field: buildNested('event_data->custom_data', key) };
+                    if (trackerEvents.has(effectiveEventName))
+                        return { kind: 'json', field: jsonTextAccessor('event_data->custom_data', key) };
+                    return { kind: 'json', field: jsonTextAccessor('event_data', key) };
+                };
+                for (const attr of attributes) {
+                    const key = String(attr.key || '').trim();
+                    const op = String(attr.op || 'contains');
+                    const value = attr.value;
+                    if (!key || value == null)
+                        continue;
+                    const resolved = resolveDbFieldForAttrKey(key);
+                    if (!resolved)
+                        continue;
+                    const dbField = resolved.field;
+                    switch (op) {
+                        case 'equals':
+                            query = query.filter(dbField, 'eq', value);
+                            break;
+                        case 'not_equals':
+                            query = query.filter(dbField, 'neq', value);
+                            break;
+                        case 'starts_with':
+                            query = query.filter(dbField, 'ilike', `${value}%`);
+                            break;
+                        case 'ends_with':
+                            query = query.filter(dbField, 'ilike', `%${value}`);
+                            break;
+                        case 'contains':
+                        default:
+                            query = query.filter(dbField, 'ilike', `%${value}%`);
+                            break;
+                    }
+                }
+            }
+            catch (e) {
+                if (this.debug)
+                    this.logger.warn('[AUDIENCE_MODULE_ENGINE] event attributes filter error');
+            }
+            const { data, error } = await query;
+            if (error)
+                return new Set();
+            if (rule.frequency && rule.frequency.value != null) {
+                const { op, value, type = 'count', field = 'value' } = rule.frequency;
+                const counts = new Map();
+                for (const row of data || []) {
+                    const id = resolveEventContactId(row);
+                    if (!id)
+                        continue;
+                    if (type === 'count') {
+                        counts.set(id, (counts.get(id) || 0) + 1);
+                    }
+                    else if (type === 'sum' || type === 'avg') {
+                        let numVal = 0;
+                        const eventData = row.event_data || {};
+                        if (eventData[field] !== undefined)
+                            numVal = Number(eventData[field]);
+                        else if (eventData['value'] !== undefined)
+                            numVal = Number(eventData['value']);
+                        else if (eventData['amount'] !== undefined)
+                            numVal = Number(eventData['amount']);
+                        if (!Number.isNaN(numVal)) {
+                            counts.set(id, (counts.get(id) || 0) + numVal);
+                        }
+                    }
+                }
+                const res = new Set();
+                counts.forEach((aggregatedValue, id) => {
+                    let finalValue = aggregatedValue;
+                    if (type === 'avg') {
+                        let eventCount = 0;
+                        for (const row of data || []) {
+                            const rid = resolveEventContactId(row);
+                            if (rid === id)
+                                eventCount++;
+                        }
+                        finalValue = eventCount > 0 ? aggregatedValue / eventCount : 0;
+                    }
+                    if ((op === '>=' && finalValue >= value) ||
+                        (op === '>' && finalValue > value) ||
+                        (op === '=' && finalValue === value) ||
+                        (op === '<=' && finalValue <= value) ||
+                        (op === '<' && finalValue < value)) {
+                        res.add(id);
+                    }
+                });
+                return res;
+            }
+            if (typeId === 'live-page-count' && cfg && cfg.pageCount != null) {
+                const threshold = Number(cfg.pageCount);
+                const counts = new Map();
+                for (const row of data || []) {
+                    const id = resolveEventContactId(row);
+                    if (!id)
+                        continue;
+                    counts.set(id, (counts.get(id) || 0) + 1);
+                }
+                const res = new Set();
+                counts.forEach((cnt, id) => { if (cnt >= threshold)
+                    res.add(id); });
+                return res;
+            }
+            const res = new Set();
+            for (const row of data || []) {
+                const id = resolveEventContactId(row);
+                if (id)
+                    res.add(id);
+            }
+            return res;
+        };
+        const evalPropertyRule = async (rule) => {
+            let query = this.supabase
+                .from('contacts')
+                .select('id')
+                .eq('organization_id', organizationId)
+                .eq('project_id', projectId);
+            if (isPastBehavior && asOfIso) {
+                query = query.lte('created_at', asOfIso);
+            }
+            const field = rule.field;
+            const op = rule.op;
+            const value = rule.value;
+            const value2 = rule.value2;
+            const isDateField = field === 'created_at' || field === 'updated_at';
+            const timeFrom = rule?.time?.from;
+            const timeTo = rule?.time?.to;
+            const hasTimeRange = isDateField && (typeof timeFrom === 'string' || typeof timeTo === 'string');
+            const computeRelativeRange = (direction = 'past') => {
+                const unitSource = rule.timeUnit ?? rule.unit ?? 'days';
+                const rawUnit = String(unitSource).toLowerCase();
+                const numericValue = Number(rule.timeValue ?? rule.value ?? NaN);
+                if (!Number.isFinite(numericValue) || numericValue < 0)
+                    return null;
+                const units = {
+                    minutes: 60 * 1000,
+                    hours: 60 * 60 * 1000,
+                    days: 24 * 60 * 60 * 1000,
+                    weeks: 7 * 24 * 60 * 60 * 1000,
+                    months: 30 * 24 * 60 * 60 * 1000,
+                    years: 365 * 24 * 60 * 60 * 1000
+                };
+                const now = asOf ?? new Date();
+                const baseUnitMs = units[rawUnit] ?? units['days'] ?? 24 * 60 * 60 * 1000;
+                const delta = baseUnitMs * numericValue;
+                const start = direction === 'past' ? new Date(now.getTime() - delta) : now;
+                const end = direction === 'past' ? now : new Date(now.getTime() + delta);
+                return { start: start.toISOString(), end: end.toISOString() };
+            };
+            const apply = (dbField, isJsonb = false) => {
+                switch (op) {
+                    case 'equals':
+                        if (isDateField) {
+                            if (hasTimeRange) {
+                                if (typeof timeFrom === 'string' && timeFrom.trim())
+                                    query = query.gte(dbField, timeFrom.trim());
+                                if (typeof timeTo === 'string' && timeTo.trim())
+                                    query = query.lte(dbField, timeTo.trim());
+                            }
+                            else {
+                                const startIso = normalizeDateBoundary(value, 'start');
+                                const endIsoExclusive = normalizeDateBoundary(value, 'end');
+                                if (startIso)
+                                    query = query.gte(dbField, startIso);
+                                if (endIsoExclusive)
+                                    query = query.lt(dbField, endIsoExclusive);
+                            }
+                        }
+                        else {
+                            query = query.eq(dbField, value);
+                        }
+                        break;
+                    case 'not_equals':
+                        if (isJsonb && value === '') {
+                            query = query.not(dbField, 'is', null).neq(dbField, '');
+                        }
+                        else {
+                            query = query.neq(dbField, value);
+                        }
+                        break;
+                    case 'contains':
+                        query = query.ilike(dbField, `%${value}%`);
+                        break;
+                    case 'not_contains':
+                        query = query.not(dbField, 'ilike', `%${value}%`);
+                        break;
+                    case 'starts_with':
+                        query = query.ilike(dbField, `${value}%`);
+                        break;
+                    case 'ends_with':
+                        query = query.ilike(dbField, `%${value}`);
+                        break;
+                    case '>':
+                        query = query.gt(dbField, value);
+                        break;
+                    case '>=':
+                        query = query.gte(dbField, value);
+                        break;
+                    case '<':
+                        query = query.lt(dbField, value);
+                        break;
+                    case '<=':
+                        query = query.lte(dbField, value);
+                        break;
+                    case 'between':
+                        if (isDateField) {
+                            if (hasTimeRange) {
+                                if (typeof timeFrom === 'string' && timeFrom.trim())
+                                    query = query.gte(dbField, timeFrom.trim());
+                                if (typeof timeTo === 'string' && timeTo.trim())
+                                    query = query.lte(dbField, timeTo.trim());
+                            }
+                            else {
+                                const startIso = normalizeDateBoundary(value, 'start');
+                                const endIsoExclusive = normalizeDateBoundary(value2 ?? value, 'end');
+                                if (startIso)
+                                    query = query.gte(dbField, startIso);
+                                if (endIsoExclusive)
+                                    query = query.lt(dbField, endIsoExclusive);
+                            }
+                        }
+                        else {
+                            if (value != null)
+                                query = query.gte(dbField, value);
+                            if (value2 != null)
+                                query = query.lte(dbField, value2);
+                        }
+                        break;
+                    case 'after':
+                        if (isDateField) {
+                            if (hasTimeRange && typeof timeFrom === 'string' && timeFrom.trim()) {
+                                query = query.gte(dbField, timeFrom.trim());
+                            }
+                            else {
+                                const startIso = normalizeDateBoundary(value, 'start');
+                                if (startIso)
+                                    query = query.gte(dbField, startIso);
+                            }
+                        }
+                        else {
+                            query = query.gt(dbField, value);
+                        }
+                        break;
+                    case 'before':
+                        if (isDateField) {
+                            if (hasTimeRange && typeof timeTo === 'string' && timeTo.trim()) {
+                                query = query.lte(dbField, timeTo.trim());
+                            }
+                            else {
+                                const endIsoExclusive = normalizeDateBoundary(value, 'end');
+                                if (endIsoExclusive)
+                                    query = query.lt(dbField, endIsoExclusive);
+                            }
+                        }
+                        else {
+                            query = query.lt(dbField, value);
+                        }
+                        break;
+                    case 'is_empty':
+                        if (isJsonb)
+                            query = query.or(`${dbField}.is.null,${dbField}.eq.`);
+                        else
+                            query = query.is(dbField, null);
+                        break;
+                    case 'is_not_empty':
+                        if (isJsonb) {
+                            const parts = dbField.split('->>');
+                            const propertyObj = (parts[0] || '').trim();
+                            const keyName = field;
+                            if (propertyObj) {
+                                query = query
+                                    .filter(`${propertyObj}`, 'cs', `{"${keyName}":`)
+                                    .not(dbField, 'is', null)
+                                    .neq(dbField, '');
+                            }
+                            else {
+                                query = query.not(dbField, 'is', null).neq(dbField, '');
+                            }
+                        }
+                        else {
+                            query = query.not(dbField, 'is', null);
+                        }
+                        break;
+                    case 'is_true':
+                        query = query.eq(dbField, true);
+                        break;
+                    case 'is_false':
+                        query = query.eq(dbField, false);
+                        break;
+                    case 'in_the_last': {
+                        const range = computeRelativeRange('past');
+                        if (range)
+                            query = query.gte(dbField, range.start).lte(dbField, range.end);
+                        break;
+                    }
+                    case 'in_the_next': {
+                        const range = computeRelativeRange('future');
+                        if (range)
+                            query = query.gte(dbField, range.start).lte(dbField, range.end);
+                        break;
+                    }
+                }
+            };
+            const mappedField = mapAudienceFieldToContactField(field);
+            const known = ['email', 'first_name', 'last_name', 'phone', 'is_subscribed', 'created_at', 'updated_at', 'name'];
+            if (known.includes(field) || known.includes(mappedField)) {
+                apply(mappedField, false);
+            }
+            else {
+                const dbField = `properties->>${field}`;
+                apply(dbField, true);
+            }
+            const { data, error } = await query;
+            if (error)
+                return new Set();
+            return new Set((data || []).map((r) => r.id));
+        };
+        const evalGroup = async (group) => {
+            let acc = null;
+            for (const rule of group.rules || []) {
+                const set = rule.kind === 'event' ? await evalEventRule(rule) : await evalPropertyRule(rule);
+                const shouldNegate = rule.negate;
+                const s = shouldNegate ? diff(allContactIds, set) : set;
+                if (acc == null) {
+                    acc = s;
+                }
+                else {
+                    if (group.operator === 'AND')
+                        acc = intersect(acc, s);
+                    else if (group.operator === 'OR')
+                        acc = union(acc, s);
+                    else if (group.operator === 'NOT')
+                        acc = diff(acc, s);
+                }
+            }
+            return acc || new Set();
+        };
+        let result = null;
+        for (let i = 0; i < criteria.groups.length; i++) {
+            const group = criteria.groups[i];
+            const gset = await evalGroup(group);
+            if (result == null) {
+                result = gset;
+            }
+            else {
+                if (group.operator === 'AND')
+                    result = intersect(result, gset);
+                else if (group.operator === 'OR')
+                    result = union(result, gset);
+                else if (group.operator === 'NOT')
+                    result = diff(result, gset);
+            }
+        }
+        const finalSet = result || new Set();
+        this.dlog('done', { total: finalSet.size });
+        return finalSet;
+    }
+    async matchesContactByAudienceCriteriaV2(organizationId, projectId, criteriaRaw, contactId) {
+        let criteria = CriteriaParser_1.CriteriaParser.parse(criteriaRaw);
+        if ((!Array.isArray(criteria.groups) || criteria.groups.length === 0) &&
+            (Array.isArray(criteria.filters) || Array.isArray(criteria.conditions))) {
+            criteria = coerceCriteriaToGroups(criteria);
+        }
+        if (!criteria || !Array.isArray(criteria.groups) || criteria.groups.length === 0) {
+            return false;
+        }
+        const typeId = String(criteria?.type || '');
+        const isPastBehavior = typeId === 'past-behavior';
+        const rawAsOf = (criteria?.asOf ?? criteria?.as_of ?? criteria?.frozenAt ?? criteria?.frozen_at);
+        const asOfDate = isPastBehavior && typeof rawAsOf === 'string' && rawAsOf.trim() ? new Date(rawAsOf) : null;
+        const asOf = isPastBehavior && asOfDate && !Number.isNaN(asOfDate.getTime())
+            ? asOfDate
+            : null;
+        const asOfIso = asOf ? asOf.toISOString() : null;
+        const { data: contactRow } = await this.supabase
+            .from('contacts')
+            .select('id, reachy_id, email')
+            .eq('organization_id', organizationId)
+            .eq('project_id', projectId)
+            .eq('id', contactId)
+            .maybeSingle();
+        const reachyId = contactRow?.reachy_id ? String(contactRow.reachy_id).trim() : '';
+        const evalEventRuleForContact = async (rule) => {
+            const cfg = criteria?.config || {};
+            const effectiveEventName = cfg.eventType && String(cfg.eventType).trim() !== ''
+                ? String(cfg.eventType)
+                : String(rule.eventName);
+            let query = this.supabase
+                .from('contact_events')
+                .select('contact_id, reachy_id, event_data, event_timestamp, event_name')
+                .eq('organization_id', organizationId)
+                .eq('project_id', projectId)
+                .eq('event_name', effectiveEventName);
+            if (isPastBehavior && asOfIso) {
+                query = query.lte('event_timestamp', asOfIso);
+            }
+            const ors = [];
+            if (contactId)
+                ors.push(`contact_id.eq.${contactId}`);
+            if (reachyId)
+                ors.push(`reachy_id.eq.${reachyId}`);
+            if (ors.length > 0)
+                query = query.or(ors.join(','));
+            if (typeId === 'live-page-visit') {
+                const v = cfg.pageUrl;
+                const d = cfg.domain;
+                const ors2 = [];
+                if (v && String(v).trim() !== '') {
+                    const like = `%${String(v)}%`;
+                    ors2.push(`path.ilike.${like}`);
+                    ors2.push(`current_url.ilike.${like}`);
+                }
+                if (d && String(d).trim() !== '') {
+                    const dlike = `%${String(d)}%`;
+                    ors2.push(`domain.ilike.${dlike}`);
+                    ors2.push(`event_data->>domain.ilike.${dlike}`);
+                }
+                if (ors2.length > 0)
+                    query = query.or(ors2.join(','));
+            }
+            if (typeId === 'live-referrer') {
+                query = query.eq('session_is_new', true);
+                const ors2 = [];
+                const v = cfg.referrerUrl;
+                if (v && String(v).trim() !== '')
+                    ors2.push(`referrer.ilike.%${String(v)}%`);
+                if (cfg.utm_source && String(cfg.utm_source).trim() !== '')
+                    ors2.push(`event_data->>utm_source.ilike.%${String(cfg.utm_source)}%`);
+                if (cfg.utm_medium && String(cfg.utm_medium).trim() !== '')
+                    ors2.push(`event_data->>utm_medium.ilike.%${String(cfg.utm_medium)}%`);
+                if (cfg.utm_campaign && String(cfg.utm_campaign).trim() !== '')
+                    ors2.push(`event_data->>utm_campaign.ilike.%${String(cfg.utm_campaign)}%`);
+                if (cfg.utm_term && String(cfg.utm_term).trim() !== '')
+                    ors2.push(`event_data->>utm_term.ilike.%${String(cfg.utm_term)}%`);
+                if (cfg.utm_content && String(cfg.utm_content).trim() !== '')
+                    ors2.push(`event_data->>utm_content.ilike.%${String(cfg.utm_content)}%`);
+                if (ors2.length > 0)
+                    query = query.or(ors2.join(','));
+            }
+            if (!rule.time && cfg && cfg.timeFrame) {
+                const tf = String(cfg.timeFrame).trim();
+                const now = asOf ?? new Date();
+                let unit = 'days';
+                let value = 7;
+                if (/^\d+$/.test(tf)) {
+                    value = Number(tf);
+                    unit = 'days';
+                }
+                else if (/^\d+\s*m$/.test(tf)) {
+                    value = Number(tf.replace(/m$/, ''));
+                    unit = 'minutes';
+                }
+                else if (/^\d+\s*h$/.test(tf)) {
+                    value = Number(tf.replace(/h$/, ''));
+                    unit = 'hours';
+                }
+                else if (/^\d+\s*d$/.test(tf)) {
+                    value = Number(tf.replace(/d$/, ''));
+                    unit = 'days';
+                }
+                else if (/^\d+\s*w$/.test(tf)) {
+                    value = Number(tf.replace(/w$/, ''));
+                    unit = 'weeks';
+                }
+                else if (/^\d+\s*mo$/.test(tf)) {
+                    value = Number(tf.replace(/mo$/, ''));
+                    unit = 'months';
+                }
+                const units = {
+                    minutes: 60 * 1000,
+                    hours: 60 * 60 * 1000,
+                    days: 24 * 60 * 60 * 1000,
+                    weeks: 7 * 24 * 60 * 60 * 1000,
+                    months: 30 * 24 * 60 * 60 * 1000
+                };
+                const from = new Date(now.getTime() - value * units[unit]);
+                query = query.gte('event_timestamp', from.toISOString());
+            }
+            if (rule.time) {
+                if (rule.time.unit && rule.time.value) {
+                    const unit = String(rule.time.unit);
+                    const value = Number(rule.time.value);
+                    const now = asOf ?? new Date();
+                    const units = {
+                        minutes: 60 * 1000,
+                        hours: 60 * 60 * 1000,
+                        days: 24 * 60 * 60 * 1000,
+                        weeks: 7 * 24 * 60 * 60 * 1000,
+                        months: 30 * 24 * 60 * 60 * 1000
+                    };
+                    const ms = units[unit] ?? units['days'];
+                    const from = new Date(now.getTime() - value * ms);
+                    query = query.gte('event_timestamp', from.toISOString());
+                }
+                else {
+                    if (rule.time.from) {
+                        const rawFrom = rule.time.from;
+                        const fromStr = typeof rawFrom === 'string' ? rawFrom : String(rawFrom);
+                        const isDateOnly = typeof rawFrom === 'string' && !fromStr.includes('T');
+                        const startIso = isDateOnly ? normalizeDateBoundary(fromStr, 'start') : undefined;
+                        const finalFrom = startIso || fromStr;
+                        query = query.gte('event_timestamp', finalFrom);
+                    }
+                    if (rule.time.to) {
+                        const rawTo = rule.time.to;
+                        const toStr = typeof rawTo === 'string' ? rawTo : String(rawTo);
+                        const isDateOnly = typeof rawTo === 'string' && !toStr.includes('T');
+                        const endIsoExclusive = isDateOnly ? normalizeDateBoundary(toStr, 'end') : undefined;
+                        const finalTo = endIsoExclusive || toStr;
+                        query = isDateOnly ? query.lt('event_timestamp', finalTo) : query.lte('event_timestamp', finalTo);
+                    }
+                }
+            }
+            try {
+                const attributes = Array.isArray(rule.attributes) ? rule.attributes : (rule.attributes ? [rule.attributes] : []);
+                const resolveDbFieldForAttrKey = (keyRaw) => {
+                    const key = String(keyRaw || '').trim();
+                    if (!key)
+                        return null;
+                    const columnKeys = new Set([
+                        'current_url',
+                        'domain',
+                        'path',
+                        'referrer',
+                        'page_title',
+                        'utm_source',
+                        'utm_medium',
+                        'utm_campaign',
+                        'utm_term',
+                        'utm_content',
+                        'session_id',
+                        'session_is_new'
+                    ]);
+                    if (columnKeys.has(key))
+                        return { kind: 'column', field: key };
+                    const buildNested = (root, dottedPath) => jsonNestedTextAccessor(root, dottedPath);
+                    if (key.startsWith('event_data.'))
+                        return { kind: 'json', field: buildNested('event_data', key.replace(/^event_data\./, '')) };
+                    if (key.startsWith('custom_data.'))
+                        return { kind: 'json', field: buildNested('event_data->custom_data', key.replace(/^custom_data\./, '')) };
+                    if (key.startsWith('url_data.'))
+                        return { kind: 'json', field: buildNested('event_data->url_data', key.replace(/^url_data\./, '')) };
+                    if (key.startsWith('utm_data.'))
+                        return { kind: 'json', field: buildNested('event_data->utm_data', key.replace(/^utm_data\./, '')) };
+                    if (key.startsWith('session_data.'))
+                        return { kind: 'json', field: buildNested('event_data->session_data', key.replace(/^session_data\./, '')) };
+                    if (key.includes('.'))
+                        return { kind: 'json', field: buildNested('event_data->custom_data', key) };
+                    return { kind: 'json', field: jsonTextAccessor('event_data', key) };
+                };
+                for (const attr of attributes) {
+                    const key = String(attr.key || '').trim();
+                    const op = String(attr.op || 'contains');
+                    const value = attr.value;
+                    if (!key || value == null)
+                        continue;
+                    const resolved = resolveDbFieldForAttrKey(key);
+                    if (!resolved)
+                        continue;
+                    const dbField = resolved.field;
+                    switch (op) {
+                        case 'equals':
+                            query = query.filter(dbField, 'eq', value);
+                            break;
+                        case 'not_equals':
+                            query = query.filter(dbField, 'neq', value);
+                            break;
+                        case 'starts_with':
+                            query = query.filter(dbField, 'ilike', `${value}%`);
+                            break;
+                        case 'ends_with':
+                            query = query.filter(dbField, 'ilike', `%${value}`);
+                            break;
+                        case 'contains':
+                        default:
+                            query = query.filter(dbField, 'ilike', `%${value}%`);
+                            break;
+                    }
+                }
+            }
+            catch {
+            }
+            const { data, error } = await query;
+            if (error)
+                return false;
+            const rows = data || [];
+            if (rule.frequency && rule.frequency.value != null) {
+                const { op, value, type = 'count', field = 'value' } = rule.frequency;
+                let aggregatedValue = 0;
+                if (type === 'count') {
+                    aggregatedValue = rows.length;
+                }
+                else {
+                    for (const row of rows) {
+                        const eventData = row.event_data || {};
+                        let numVal = 0;
+                        if (eventData[field] !== undefined)
+                            numVal = Number(eventData[field]);
+                        else if (eventData['value'] !== undefined)
+                            numVal = Number(eventData['value']);
+                        else if (eventData['amount'] !== undefined)
+                            numVal = Number(eventData['amount']);
+                        if (!Number.isNaN(numVal))
+                            aggregatedValue += numVal;
+                    }
+                    if (type === 'avg')
+                        aggregatedValue = rows.length > 0 ? aggregatedValue / rows.length : 0;
+                }
+                return ((op === '>=' && aggregatedValue >= value) ||
+                    (op === '>' && aggregatedValue > value) ||
+                    (op === '=' && aggregatedValue === value) ||
+                    (op === '<=' && aggregatedValue <= value) ||
+                    (op === '<' && aggregatedValue < value));
+            }
+            if (typeId === 'live-page-count' && cfg && cfg.pageCount != null) {
+                const threshold = Number(cfg.pageCount);
+                return rows.length >= threshold;
+            }
+            return rows.length > 0;
+        };
+        const evalPropertyRuleForContact = async (rule) => {
+            let query = this.supabase
+                .from('contacts')
+                .select('id')
+                .eq('organization_id', organizationId)
+                .eq('project_id', projectId)
+                .eq('id', contactId);
+            if (isPastBehavior && asOfIso) {
+                query = query.lte('created_at', asOfIso);
+            }
+            const field = rule.field;
+            const op = rule.op;
+            const value = rule.value;
+            const value2 = rule.value2;
+            const isDateField = field === 'created_at' || field === 'updated_at';
+            const timeFrom = rule?.time?.from;
+            const timeTo = rule?.time?.to;
+            const hasTimeRange = isDateField && (typeof timeFrom === 'string' || typeof timeTo === 'string');
+            const computeRelativeRange = (direction = 'past') => {
+                const unitSource = rule.timeUnit ?? rule.unit ?? 'days';
+                const rawUnit = String(unitSource).toLowerCase();
+                const numericValue = Number(rule.timeValue ?? rule.value ?? NaN);
+                if (!Number.isFinite(numericValue) || numericValue < 0)
+                    return null;
+                const units = {
+                    minutes: 60 * 1000,
+                    hours: 60 * 60 * 1000,
+                    days: 24 * 60 * 60 * 1000,
+                    weeks: 7 * 24 * 60 * 60 * 1000,
+                    months: 30 * 24 * 60 * 60 * 1000,
+                    years: 365 * 24 * 60 * 60 * 1000
+                };
+                const now = asOf ?? new Date();
+                const baseUnitMs = units[rawUnit] ?? units['days'] ?? 24 * 60 * 60 * 1000;
+                const delta = baseUnitMs * numericValue;
+                const start = direction === 'past' ? new Date(now.getTime() - delta) : now;
+                const end = direction === 'past' ? now : new Date(now.getTime() + delta);
+                return { start: start.toISOString(), end: end.toISOString() };
+            };
+            const apply = (dbField, isJsonb = false) => {
+                switch (op) {
+                    case 'equals':
+                        if (isDateField) {
+                            if (hasTimeRange) {
+                                if (typeof timeFrom === 'string' && timeFrom.trim())
+                                    query = query.gte(dbField, timeFrom.trim());
+                                if (typeof timeTo === 'string' && timeTo.trim())
+                                    query = query.lte(dbField, timeTo.trim());
+                            }
+                            else {
+                                const startIso = normalizeDateBoundary(value, 'start');
+                                const endIsoExclusive = normalizeDateBoundary(value, 'end');
+                                if (startIso)
+                                    query = query.gte(dbField, startIso);
+                                if (endIsoExclusive)
+                                    query = query.lt(dbField, endIsoExclusive);
+                            }
+                        }
+                        else {
+                            query = query.eq(dbField, value);
+                        }
+                        break;
+                    case 'not_equals':
+                        if (isJsonb && value === '')
+                            query = query.not(dbField, 'is', null).neq(dbField, '');
+                        else
+                            query = query.neq(dbField, value);
+                        break;
+                    case 'contains':
+                        query = query.ilike(dbField, `%${value}%`);
+                        break;
+                    case 'not_contains':
+                        query = query.not(dbField, 'ilike', `%${value}%`);
+                        break;
+                    case 'starts_with':
+                        query = query.ilike(dbField, `${value}%`);
+                        break;
+                    case 'ends_with':
+                        query = query.ilike(dbField, `%${value}`);
+                        break;
+                    case '>':
+                        query = query.gt(dbField, value);
+                        break;
+                    case '>=':
+                        query = query.gte(dbField, value);
+                        break;
+                    case '<':
+                        query = query.lt(dbField, value);
+                        break;
+                    case '<=':
+                        query = query.lte(dbField, value);
+                        break;
+                    case 'between':
+                        if (isDateField) {
+                            if (hasTimeRange) {
+                                if (typeof timeFrom === 'string' && timeFrom.trim())
+                                    query = query.gte(dbField, timeFrom.trim());
+                                if (typeof timeTo === 'string' && timeTo.trim())
+                                    query = query.lte(dbField, timeTo.trim());
+                            }
+                            else {
+                                const startIso = normalizeDateBoundary(value, 'start');
+                                const endIsoExclusive = normalizeDateBoundary(value2 ?? value, 'end');
+                                if (startIso)
+                                    query = query.gte(dbField, startIso);
+                                if (endIsoExclusive)
+                                    query = query.lt(dbField, endIsoExclusive);
+                            }
+                        }
+                        else {
+                            if (value != null)
+                                query = query.gte(dbField, value);
+                            if (value2 != null)
+                                query = query.lte(dbField, value2);
+                        }
+                        break;
+                    case 'after':
+                        if (isDateField) {
+                            if (hasTimeRange && typeof timeFrom === 'string' && timeFrom.trim())
+                                query = query.gte(dbField, timeFrom.trim());
+                            else {
+                                const startIso = normalizeDateBoundary(value, 'start');
+                                if (startIso)
+                                    query = query.gte(dbField, startIso);
+                            }
+                        }
+                        else
+                            query = query.gt(dbField, value);
+                        break;
+                    case 'before':
+                        if (isDateField) {
+                            if (hasTimeRange && typeof timeTo === 'string' && timeTo.trim())
+                                query = query.lte(dbField, timeTo.trim());
+                            else {
+                                const endIsoExclusive = normalizeDateBoundary(value, 'end');
+                                if (endIsoExclusive)
+                                    query = query.lt(dbField, endIsoExclusive);
+                            }
+                        }
+                        else
+                            query = query.lt(dbField, value);
+                        break;
+                    case 'is_empty':
+                        if (isJsonb)
+                            query = query.or(`${dbField}.is.null,${dbField}.eq.`);
+                        else
+                            query = query.is(dbField, null);
+                        break;
+                    case 'is_not_empty':
+                        if (isJsonb)
+                            query = query.not(dbField, 'is', null).neq(dbField, '');
+                        else
+                            query = query.not(dbField, 'is', null);
+                        break;
+                    case 'is_true':
+                        query = query.eq(dbField, true);
+                        break;
+                    case 'is_false':
+                        query = query.eq(dbField, false);
+                        break;
+                    case 'in_the_last': {
+                        const range = computeRelativeRange('past');
+                        if (range)
+                            query = query.gte(dbField, range.start).lte(dbField, range.end);
+                        break;
+                    }
+                    case 'in_the_next': {
+                        const range = computeRelativeRange('future');
+                        if (range)
+                            query = query.gte(dbField, range.start).lte(dbField, range.end);
+                        break;
+                    }
+                }
+            };
+            const mappedField = mapAudienceFieldToContactField(field);
+            const known = ['email', 'first_name', 'last_name', 'phone', 'is_subscribed', 'created_at', 'updated_at', 'name'];
+            if (known.includes(field) || known.includes(mappedField)) {
+                apply(mappedField, false);
+            }
+            else {
+                const dbField = `properties->>${field}`;
+                apply(dbField, true);
+            }
+            const { data, error } = await query;
+            if (error)
+                return false;
+            return (data || []).length > 0;
+        };
+        const evalRuleForContact = async (rule) => {
+            const base = rule.kind === 'event' ? await evalEventRuleForContact(rule) : await evalPropertyRuleForContact(rule);
+            const res = rule.negate ? !base : base;
+            return res;
+        };
+        const evalGroupForContact = async (group) => {
+            let acc = null;
+            for (const rule of group.rules || []) {
+                const r = await evalRuleForContact(rule);
+                if (acc == null)
+                    acc = r;
+                else {
+                    if (group.operator === 'AND')
+                        acc = acc && r;
+                    else if (group.operator === 'OR')
+                        acc = acc || r;
+                    else if (group.operator === 'NOT')
+                        acc = acc && !r;
+                }
+            }
+            return !!acc;
+        };
+        let result = null;
+        for (const group of criteria.groups) {
+            const g = await evalGroupForContact(group);
+            if (result == null)
+                result = g;
+            else {
+                if (group.operator === 'AND')
+                    result = result && g;
+                else if (group.operator === 'OR')
+                    result = result || g;
+                else if (group.operator === 'NOT')
+                    result = result && !g;
+            }
+        }
+        return !!result;
+    }
+    dlog(...args) {
+        if (!this.debug)
+            return;
+        this.logger.log('[AUDIENCE_MODULE_ENGINE]', ...args);
+    }
+}
+exports.V2AudienceEngine = V2AudienceEngine;
+function jsonTextAccessor(base, key) {
+    const safeKey = String(key || '').replace(/'/g, "''");
+    return `${base}->>'${safeKey}'`;
+}
+function jsonNestedTextAccessor(base, path) {
+    const parts = String(path || '')
+        .split('.')
+        .map((p) => p.trim())
+        .filter(Boolean);
+    if (parts.length === 0)
+        return jsonTextAccessor(base, 'value');
+    if (parts.length === 1)
+        return jsonTextAccessor(base, parts[0]);
+    const chain = parts
+        .slice(0, -1)
+        .map((p) => `->'${String(p).replace(/'/g, "''")}'`)
+        .join('');
+    const last = String(parts[parts.length - 1]).replace(/'/g, "''");
+    return `${base}${chain}->>'${last}'`;
+}
+function mapAudienceFieldToContactField(audienceField) {
+    const fieldMapping = {
+        is_subscribed: 'is_subscribed',
+        email: 'email',
+        name: 'first_name',
+        first_name: 'first_name',
+        last_name: 'last_name',
+        phone: 'phone',
+        created_at: 'created_at',
+        updated_at: 'updated_at',
+        city: 'city',
+        country: 'country',
+        tags: 'tags',
+        status: 'status'
+    };
+    return fieldMapping[audienceField] || audienceField;
+}
+function normalizeDateBoundary(value, boundary) {
+    if (!value || typeof value !== 'string')
+        return undefined;
+    const hasTimeComponent = value.includes('T');
+    const toUtcStartOfDay = (y, mZeroBased, d) => {
+        return new Date(Date.UTC(y, mZeroBased, d, 0, 0, 0, 0));
+    };
+    let baseDate = null;
+    if (hasTimeComponent) {
+        const dt = new Date(value);
+        baseDate = Number.isNaN(dt.getTime()) ? null : dt;
+    }
+    else if (/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        const parts = value.split('-');
+        if (parts.length === 3) {
+            const y = parseInt(parts[0], 10);
+            const mm = parseInt(parts[1], 10);
+            const d = parseInt(parts[2], 10);
+            if (Number.isFinite(y) && Number.isFinite(mm) && Number.isFinite(d)) {
+                baseDate = toUtcStartOfDay(y, mm - 1, d);
+            }
+        }
+    }
+    else if (/^\d{2}\/\d{2}\/\d{4}$/.test(value)) {
+        const parts = value.split('/');
+        if (parts.length === 3) {
+            const d = parseInt(parts[0], 10);
+            const mm = parseInt(parts[1], 10);
+            const y = parseInt(parts[2], 10);
+            if (Number.isFinite(y) && Number.isFinite(mm) && Number.isFinite(d)) {
+                baseDate = toUtcStartOfDay(y, mm - 1, d);
+            }
+        }
+    }
+    else {
+        const dt = new Date(`${value}T00:00:00Z`);
+        baseDate = Number.isNaN(dt.getTime()) ? null : dt;
+    }
+    if (!baseDate)
+        return undefined;
+    const utcYear = baseDate.getUTCFullYear();
+    const utcMonth = baseDate.getUTCMonth();
+    const utcDay = baseDate.getUTCDate();
+    if (boundary === 'start') {
+        const startOfDay = new Date(Date.UTC(utcYear, utcMonth, utcDay, 0, 0, 0, 0));
+        return startOfDay.toISOString();
+    }
+    const nextDay = new Date(Date.UTC(utcYear, utcMonth, utcDay + 1, 0, 0, 0, 0));
+    return nextDay.toISOString();
+}
+function coerceCriteriaToGroups(criteria) {
+    const groups = [];
+    const pushGroup = (operator, rules) => {
+        if (!rules || rules.length === 0)
+            return;
+        const op = operator === 'OR' || operator === 'NOT' ? operator : 'AND';
+        groups.push({ operator: op, rules });
+    };
+    if (Array.isArray(criteria.filters)) {
+        for (const fg of criteria.filters) {
+            const rules = [];
+            for (const c of fg?.conditions || []) {
+                const fieldRaw = String(c?.field || '');
+                const operator = c?.operator;
+                const value = c?.value;
+                const value2 = c?.value2;
+                if (fieldRaw === 'event') {
+                    rules.push({
+                        kind: 'event',
+                        eventName: value,
+                        negate: operator === 'not_equals',
+                        ...(c?.dateFrom || c?.dateTo ? { time: { from: c?.dateFrom, to: c?.dateTo } } : {}),
+                        ...(c?.timeValue != null ? { time: { unit: c?.timeUnit || 'days', value: Number(c?.timeValue) } } : {})
+                    });
+                    continue;
+                }
+                const field = fieldRaw === 'custom_field' && c?.customFieldKey ? String(c.customFieldKey) : fieldRaw;
+                const rule = {
+                    kind: 'property',
+                    field,
+                    op: operator
+                };
+                if (operator === 'in_the_last' || operator === 'in_the_next') {
+                    rule.timeValue = c?.timeValue ?? value;
+                    rule.timeUnit = c?.timeUnit || 'days';
+                }
+                else if (operator === 'between') {
+                    rule.value = value;
+                    rule.value2 = value2;
+                }
+                else if (operator === 'is_empty' || operator === 'is_not_empty') {
+                }
+                else {
+                    rule.value = value;
+                    if (value2 != null)
+                        rule.value2 = value2;
+                }
+                rules.push(rule);
+            }
+            pushGroup(fg?.operator, rules);
+        }
+    }
+    if (Array.isArray(criteria.conditions)) {
+        for (const cg of criteria.conditions) {
+            const rules = [];
+            for (const c of cg?.conditions || []) {
+                const fieldRaw = String(c?.field || '');
+                const operator = c?.operator;
+                const value = c?.value;
+                const value2 = c?.value2;
+                const field = fieldRaw === 'custom_field' && c?.customFieldKey ? String(c.customFieldKey) : fieldRaw;
+                const rule = { kind: 'property', field, op: operator };
+                if (operator === 'between') {
+                    rule.value = value;
+                    rule.value2 = value2;
+                }
+                else if (operator === 'in_the_last' || operator === 'in_the_next') {
+                    rule.timeValue = c?.timeValue ?? value;
+                    rule.timeUnit = c?.timeUnit || 'days';
+                }
+                else if (operator === 'is_empty' || operator === 'is_not_empty') {
+                }
+                else {
+                    rule.value = value;
+                    if (value2 != null)
+                        rule.value2 = value2;
+                }
+                rules.push(rule);
+            }
+            pushGroup(cg?.operator, rules);
+        }
+    }
+    return { ...criteria, groups };
+}
+//# sourceMappingURL=V2AudienceEngine.js.map