dotdo 0.0.1 → 0.1.0

package/dist/workflows/data/track/context.js

@@ -0,0 +1,883 @@
+/**
+ * Track Context - Event tracking API implementation
+ *
+ * Provides the $.track API for event tracking, analysis, and subscriptions.
+ *
+ * @module workflows/data/track/context
+ */
+// =============================================================================
+// UTILITY FUNCTIONS
+// =============================================================================
+let idCounter = 0;
+function generateId() {
+    return `evt_${Date.now()}_${++idCounter}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function generateSubscriptionId() {
+    return `sub_${Date.now()}_${++idCounter}_${Math.random().toString(36).substring(2, 9)}`;
+}
+/**
+ * Parse duration string to milliseconds.
+ * Returns the actual timestamp if given a number (for since(timestamp) calls).
+ */
+function parseDuration(duration) {
+    if (typeof duration === 'number') {
+        // If it's a large number (> 1 year in ms), treat it as a timestamp
+        // Otherwise treat it as milliseconds duration
+        const oneYearMs = 365 * 24 * 60 * 60 * 1000;
+        if (duration > oneYearMs) {
+            return { isTimestamp: true, value: duration };
+        }
+        return { isTimestamp: false, value: duration };
+    }
+    const match = duration.match(/^(\d+)([smhdwMy]|month|quarter|year|week)?$/);
+    if (!match) {
+        // Handle special cases
+        if (duration === 'month')
+            return { isTimestamp: false, value: 30 * 24 * 60 * 60 * 1000 };
+        if (duration === 'quarter')
+            return { isTimestamp: false, value: 90 * 24 * 60 * 60 * 1000 };
+        if (duration === 'year')
+            return { isTimestamp: false, value: 365 * 24 * 60 * 60 * 1000 };
+        if (duration === 'week')
+            return { isTimestamp: false, value: 7 * 24 * 60 * 60 * 1000 };
+        throw new Error(`Invalid duration: ${duration}`);
+    }
+    const value = parseInt(match[1], 10);
+    const unit = match[2] || 's';
+    let ms;
+    switch (unit) {
+        case 's':
+            ms = value * 1000;
+            break;
+        case 'm':
+            ms = value * 60 * 1000;
+            break;
+        case 'h':
+            ms = value * 60 * 60 * 1000;
+            break;
+        case 'd':
+            ms = value * 24 * 60 * 60 * 1000;
+            break;
+        case 'w':
+        case 'week':
+            ms = value * 7 * 24 * 60 * 60 * 1000;
+            break;
+        case 'M':
+        case 'month':
+            ms = value * 30 * 24 * 60 * 60 * 1000;
+            break;
+        case 'quarter':
+            ms = value * 90 * 24 * 60 * 60 * 1000;
+            break;
+        case 'y':
+        case 'year':
+            ms = value * 365 * 24 * 60 * 60 * 1000;
+            break;
+        default:
+            ms = value * 1000;
+    }
+    return { isTimestamp: false, value: ms };
+}
+/**
+ * Get the "since" timestamp from duration or timestamp
+ */
+function getSinceTimestamp(duration) {
+    const parsed = parseDuration(duration);
+    if (parsed.isTimestamp) {
+        return parsed.value;
+    }
+    return Date.now() - parsed.value;
+}
+/**
+ * Get period start for a timestamp based on granularity
+ */
+function getPeriodStart(timestamp, granularity) {
+    const date = new Date(timestamp);
+    switch (granularity) {
+        case 'minute':
+            return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes()).getTime();
+        case 'hour':
+            return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours()).getTime();
+        case 'day':
+            return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+        case 'week':
+            const day = date.getDay();
+            const diff = date.getDate() - day;
+            return new Date(date.getFullYear(), date.getMonth(), diff).getTime();
+        case 'month':
+            return new Date(date.getFullYear(), date.getMonth(), 1).getTime();
+        default:
+            return timestamp;
+    }
+}
+/**
+ * Get the period number from anchor timestamp
+ */
+function getPeriodNumber(anchorTimestamp, eventTimestamp, granularity) {
+    const diff = eventTimestamp - anchorTimestamp;
+    switch (granularity) {
+        case 'day':
+            return Math.floor(diff / (24 * 60 * 60 * 1000));
+        case 'week':
+            return Math.floor(diff / (7 * 24 * 60 * 60 * 1000));
+        case 'month':
+            return Math.floor(diff / (30 * 24 * 60 * 60 * 1000));
+        default:
+            return 0;
+    }
+}
+/**
+ * Check if event matches filter
+ */
+function matchesFilter(event, filter) {
+    for (const [key, value] of Object.entries(filter)) {
+        // Handle experiment and variant as top-level properties
+        if (key === 'experiment') {
+            if (event.experiment !== value)
+                return false;
+            continue;
+        }
+        if (key === 'variant') {
+            if (event.variant !== value)
+                return false;
+            continue;
+        }
+        const eventValue = event.data[key];
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            const ops = value;
+            if (ops.gte !== undefined && (typeof eventValue !== 'number' || eventValue < ops.gte))
+                return false;
+            if (ops.gt !== undefined && (typeof eventValue !== 'number' || eventValue <= ops.gt))
+                return false;
+            if (ops.lte !== undefined && (typeof eventValue !== 'number' || eventValue > ops.lte))
+                return false;
+            if (ops.lt !== undefined && (typeof eventValue !== 'number' || eventValue >= ops.lt))
+                return false;
+            if (ops.ne !== undefined && eventValue === ops.ne)
+                return false;
+            if (ops.in !== undefined && !ops.in.includes(eventValue))
+                return false;
+        }
+        else {
+            if (eventValue !== value)
+                return false;
+        }
+    }
+    return true;
+}
+function createStorage() {
+    return {
+        events: [],
+        subscriptions: new Map(),
+    };
+}
+// =============================================================================
+// EVENT PROXY
+// =============================================================================
+function createEventProxy(eventType, storage) {
+    const getEvents = (since) => {
+        return storage.events.filter((e) => {
+            if (e.type !== eventType)
+                return false;
+            if (since !== undefined && e.timestamp < since)
+                return false;
+            return true;
+        });
+    };
+    const getFilteredEvents = (filter, since) => {
+        return storage.events.filter((e) => {
+            if (e.type !== eventType)
+                return false;
+            if (since !== undefined && e.timestamp < since)
+                return false;
+            return matchesFilter(e, filter);
+        });
+    };
+    const proxy = async (data, options) => {
+        const event = {
+            id: generateId(),
+            type: eventType,
+            data,
+            timestamp: Date.now(),
+            ...(options?.experiment && { experiment: options.experiment }),
+            ...(options?.variant && { variant: options.variant }),
+        };
+        storage.events.push(event);
+        // Notify subscribers
+        const subs = storage.subscriptions.get(eventType) || [];
+        for (const sub of subs) {
+            if (!sub.filter || matchesFilter(event, sub.filter)) {
+                sub.handler(event);
+            }
+        }
+        return event;
+    };
+    // count()
+    proxy.count = () => {
+        let sinceTime;
+        // Create a thenable that also has methods
+        const countPromise = Promise.resolve().then(async () => {
+            const events = getEvents(sinceTime);
+            return events.length;
+        });
+        // Add chainable methods
+        const countFn = countPromise;
+        countFn.since = (duration) => {
+            sinceTime = getSinceTimestamp(duration);
+            // Return a new thenable with the updated sinceTime
+            const newPromise = Promise.resolve().then(async () => {
+                const events = getEvents(sinceTime);
+                return events.length;
+            });
+            const newFn = newPromise;
+            newFn.by = async (field) => {
+                const events = getEvents(sinceTime);
+                const result = {};
+                for (const event of events) {
+                    const value = field === 'variant' ? event.variant : event.data[field];
+                    if (value !== undefined) {
+                        const key = String(value);
+                        result[key] = (result[key] || 0) + 1;
+                    }
+                }
+                return result;
+            };
+            newFn.groupBy = async (granularity) => {
+                const events = getEvents(sinceTime);
+                const buckets = new Map();
+                for (const event of events) {
+                    const periodStart = getPeriodStart(event.timestamp, granularity);
+                    buckets.set(periodStart, (buckets.get(periodStart) || 0) + 1);
+                }
+                return Array.from(buckets.entries())
+                    .map(([timestamp, count]) => ({ timestamp, count }))
+                    .sort((a, b) => a.timestamp - b.timestamp);
+            };
+            return newFn;
+        };
+        countFn.by = async (field) => {
+            const events = getEvents(sinceTime);
+            const result = {};
+            for (const event of events) {
+                const value = field === 'variant' ? event.variant : event.data[field];
+                if (value !== undefined) {
+                    const key = String(value);
+                    result[key] = (result[key] || 0) + 1;
+                }
+            }
+            return result;
+        };
+        countFn.groupBy = async (granularity) => {
+            const events = getEvents(sinceTime);
+            const buckets = new Map();
+            for (const event of events) {
+                const periodStart = getPeriodStart(event.timestamp, granularity);
+                buckets.set(periodStart, (buckets.get(periodStart) || 0) + 1);
+            }
+            return Array.from(buckets.entries())
+                .map(([timestamp, count]) => ({ timestamp, count }))
+                .sort((a, b) => a.timestamp - b.timestamp);
+        };
+        return countFn;
+    };
+    // events()
+    proxy.events = () => {
+        let sinceTime;
+        const eventsQuery = {
+            limit: async (n) => {
+                const events = getEvents(sinceTime);
+                // Get events with their original indices for stable sorting
+                const eventsWithIndex = events.map((e, i) => ({ event: e, originalIndex: i }));
+                // Return in reverse chronological order (most recent first)
+                // Use original index as tiebreaker when timestamps are equal (stable sort)
+                eventsWithIndex.sort((a, b) => {
+                    const timeDiff = b.event.timestamp - a.event.timestamp;
+                    if (timeDiff !== 0)
+                        return timeDiff;
+                    // Same timestamp: later in array = more recent
+                    return b.originalIndex - a.originalIndex;
+                });
+                return eventsWithIndex.slice(0, n).map((e) => e.event);
+            },
+            since: (duration) => {
+                sinceTime = getSinceTimestamp(duration);
+                return eventsQuery;
+            },
+        };
+        return eventsQuery;
+    };
+    // where()
+    proxy.where = (filter) => {
+        const whereQuery = {
+            count: () => {
+                let sinceTime;
+                const countPromise = Promise.resolve().then(async () => {
+                    return getFilteredEvents(filter, sinceTime).length;
+                });
+                const countFn = countPromise;
+                countFn.since = (duration) => {
+                    sinceTime = getSinceTimestamp(duration);
+                    const newPromise = Promise.resolve().then(async () => {
+                        return getFilteredEvents(filter, sinceTime).length;
+                    });
+                    const newFn = newPromise;
+                    newFn.by = async (field) => {
+                        const events = getFilteredEvents(filter, sinceTime);
+                        const result = {};
+                        for (const event of events) {
+                            const value = field === 'variant' ? event.variant : event.data[field];
+                            if (value !== undefined) {
+                                const key = String(value);
+                                result[key] = (result[key] || 0) + 1;
+                            }
+                        }
+                        return result;
+                    };
+                    return newFn;
+                };
+                countFn.by = async (field) => {
+                    const events = getFilteredEvents(filter, sinceTime);
+                    const result = {};
+                    for (const event of events) {
+                        const value = field === 'variant' ? event.variant : event.data[field];
+                        if (value !== undefined) {
+                            const key = String(value);
+                            result[key] = (result[key] || 0) + 1;
+                        }
+                    }
+                    return result;
+                };
+                return countFn;
+            },
+            sum: (field) => {
+                let sinceTime;
+                const sumPromise = Promise.resolve().then(async () => {
+                    const events = getFilteredEvents(filter, sinceTime);
+                    return events.reduce((sum, e) => {
+                        const val = e.data[field];
+                        return sum + (typeof val === 'number' ? val : 0);
+                    }, 0);
+                });
+                const sumFn = sumPromise;
+                sumFn.since = (duration) => {
+                    sinceTime = getSinceTimestamp(duration);
+                    return Promise.resolve().then(async () => {
+                        const events = getFilteredEvents(filter, sinceTime);
+                        return events.reduce((sum, e) => {
+                            const val = e.data[field];
+                            return sum + (typeof val === 'number' ? val : 0);
+                        }, 0);
+                    });
+                };
+                return sumFn;
+            },
+            avg: async (field) => {
+                const events = getFilteredEvents(filter);
+                if (events.length === 0)
+                    return null;
+                const sum = events.reduce((sum, e) => {
+                    const val = e.data[field];
+                    return sum + (typeof val === 'number' ? val : 0);
+                }, 0);
+                return sum / events.length;
+            },
+            countUnique: (field) => {
+                let sinceTime;
+                const uniquePromise = Promise.resolve().then(async () => {
+                    const events = getFilteredEvents(filter, sinceTime);
+                    const unique = new Set(events.map((e) => e.data[field]));
+                    return unique.size;
+                });
+                const uniqueFn = uniquePromise;
+                uniqueFn.since = (duration) => {
+                    sinceTime = getSinceTimestamp(duration);
+                    return Promise.resolve().then(async () => {
+                        const events = getFilteredEvents(filter, sinceTime);
+                        const unique = new Set(events.map((e) => e.data[field]));
+                        return unique.size;
+                    });
+                };
+                return uniqueFn;
+            },
+        };
+        return whereQuery;
+    };
+    // sum()
+    proxy.sum = (field) => {
+        let sinceTime;
+        const sumPromise = Promise.resolve().then(async () => {
+            const events = getEvents(sinceTime);
+            return events.reduce((sum, e) => {
+                const val = e.data[field];
+                return sum + (typeof val === 'number' ? val : 0);
+            }, 0);
+        });
+        const sumFn = sumPromise;
+        sumFn.since = (duration) => {
+            sinceTime = getSinceTimestamp(duration);
+            return Promise.resolve().then(async () => {
+                const events = getEvents(sinceTime);
+                return events.reduce((sum, e) => {
+                    const val = e.data[field];
+                    return sum + (typeof val === 'number' ? val : 0);
+                }, 0);
+            });
+        };
+        return sumFn;
+    };
+    // avg()
+    proxy.avg = async (field) => {
+        const events = getEvents();
+        if (events.length === 0)
+            return null;
+        const sum = events.reduce((sum, e) => {
+            const val = e.data[field];
+            return sum + (typeof val === 'number' ? val : 0);
+        }, 0);
+        return sum / events.length;
+    };
+    // min()
+    proxy.min = async (field) => {
+        const events = getEvents();
+        if (events.length === 0)
+            return null;
+        let min = null;
+        for (const e of events) {
+            const val = e.data[field];
+            if (typeof val === 'number') {
+                if (min === null || val < min)
+                    min = val;
+            }
+        }
+        return min;
+    };
+    // max()
+    proxy.max = async (field) => {
+        const events = getEvents();
+        if (events.length === 0)
+            return null;
+        let max = null;
+        for (const e of events) {
+            const val = e.data[field];
+            if (typeof val === 'number') {
+                if (max === null || val > max)
+                    max = val;
+            }
+        }
+        return max;
+    };
+    // countUnique()
+    proxy.countUnique = (field) => {
+        let sinceTime;
+        const uniquePromise = Promise.resolve().then(async () => {
+            const events = getEvents(sinceTime);
+            const unique = new Set(events.map((e) => e.data[field]));
+            return unique.size;
+        });
+        const uniqueFn = uniquePromise;
+        uniqueFn.since = (duration) => {
+            sinceTime = getSinceTimestamp(duration);
+            return Promise.resolve().then(async () => {
+                const events = getEvents(sinceTime);
+                const unique = new Set(events.map((e) => e.data[field]));
+                return unique.size;
+            });
+        };
+        return uniqueFn;
+    };
+    // subscribe()
+    proxy.subscribe = (handler, options) => {
+        const id = generateSubscriptionId();
+        if (!storage.subscriptions.has(eventType)) {
+            storage.subscriptions.set(eventType, []);
+        }
+        storage.subscriptions.get(eventType).push({
+            id,
+            handler,
+            filter: options?.where,
+        });
+        return {
+            id,
+            unsubscribe: () => {
+                const subs = storage.subscriptions.get(eventType);
+                if (subs) {
+                    const idx = subs.findIndex((s) => s.id === id);
+                    if (idx !== -1)
+                        subs.splice(idx, 1);
+                }
+            },
+        };
+    };
+    return proxy;
+}
+// =============================================================================
+// FUNNEL IMPLEMENTATION
+// =============================================================================
+function createFunnelQuery(steps, storage) {
+    return {
+        within: (duration) => {
+            const parsed = parseDuration(duration);
+            const windowMs = parsed.value;
+            let isStrict = false;
+            let whereFilter;
+            const calculateFunnel = (events) => {
+                if (steps.length === 0) {
+                    return { steps: [], overallConversionRate: 0 };
+                }
+                // Group events by userId
+                const userEvents = new Map();
+                for (const event of events) {
+                    const userId = event.data.userId;
+                    if (!userId)
+                        continue;
+                    if (!userEvents.has(userId))
+                        userEvents.set(userId, []);
+                    userEvents.get(userId).push(event);
+                }
+                // Sort each user's events by timestamp
+                for (const events of userEvents.values()) {
+                    events.sort((a, b) => a.timestamp - b.timestamp);
+                }
+                const stepResults = [];
+                const usersInStep = [];
+                const stepTimes = [];
+                for (let i = 0; i < steps.length; i++) {
+                    usersInStep.push(new Set());
+                    stepTimes.push(new Map());
+                }
+                // For each user, check if they complete the funnel
+                for (const [userId, events] of userEvents) {
+                    let lastStepTime = -Infinity;
+                    let lastStepIdx = -1;
+                    for (const event of events) {
+                        // Find which step this event matches
+                        for (let stepIdx = 0; stepIdx < steps.length; stepIdx++) {
+                            const step = steps[stepIdx];
+                            if (event.type !== step.eventType)
+                                continue;
+                            if (step.filter && !matchesFilter(event, step.filter))
+                                continue;
+                            // Check if this is the next expected step
+                            if (stepIdx === 0) {
+                                // First step - always valid
+                                usersInStep[0].add(userId);
+                                stepTimes[0].set(userId, event.timestamp);
+                                lastStepTime = event.timestamp;
+                                lastStepIdx = 0;
+                            }
+                            else if (stepIdx === lastStepIdx + 1) {
+                                // Next step in sequence
+                                const prevTime = stepTimes[stepIdx - 1].get(userId);
+                                if (prevTime === undefined)
+                                    continue;
+                                // Check time window
+                                if (event.timestamp - prevTime > windowMs)
+                                    continue;
+                                // For strict mode, ensure this step happens after the previous
+                                if (isStrict && event.timestamp <= lastStepTime)
+                                    continue;
+                                usersInStep[stepIdx].add(userId);
+                                stepTimes[stepIdx].set(userId, event.timestamp);
+                                lastStepTime = event.timestamp;
+                                lastStepIdx = stepIdx;
+                            }
+                            break;
+                        }
+                    }
+                }
+                // Build results
+                for (let i = 0; i < steps.length; i++) {
+                    const count = usersInStep[i].size;
+                    const prevCount = i === 0 ? count : usersInStep[i - 1].size;
+                    // Calculate average time from previous step
+                    let avgTimeFromPrevious;
+                    if (i > 0) {
+                        const times = [];
+                        for (const userId of usersInStep[i]) {
+                            const currTime = stepTimes[i].get(userId);
+                            const prevTime = stepTimes[i - 1].get(userId);
+                            if (currTime !== undefined && prevTime !== undefined) {
+                                times.push(currTime - prevTime);
+                            }
+                        }
+                        if (times.length > 0) {
+                            avgTimeFromPrevious = times.reduce((a, b) => a + b, 0) / times.length;
+                        }
+                    }
+                    stepResults.push({
+                        count,
+                        conversionRate: prevCount > 0 ? count / prevCount : i === 0 ? 1 : 0,
+                        ...(avgTimeFromPrevious !== undefined && { avgTimeFromPrevious }),
+                    });
+                }
+                const firstCount = stepResults[0]?.count || 0;
+                const lastCount = stepResults[stepResults.length - 1]?.count || 0;
+                return {
+                    steps: stepResults,
+                    overallConversionRate: firstCount > 0 ? lastCount / firstCount : 0,
+                };
+            };
+            const getEventsForFunnel = () => {
+                let events = storage.events;
+                if (whereFilter) {
+                    events = events.filter((e) => matchesFilter(e, whereFilter));
+                }
+                return events;
+            };
+            // Create a thenable that is directly awaitable
+            const withinPromise = Promise.resolve().then(async () => {
+                return calculateFunnel(getEventsForFunnel());
+            });
+            const withinQuery = withinPromise;
+            withinQuery.by = async (field) => {
+                const events = getEventsForFunnel();
+                const groups = new Map();
+                for (const event of events) {
+                    const value = event.data[field];
+                    if (value !== undefined) {
+                        const key = String(value);
+                        if (!groups.has(key))
+                            groups.set(key, []);
+                        groups.get(key).push(event);
+                    }
+                }
+                const result = {};
+                for (const [key, groupEvents] of groups) {
+                    result[key] = calculateFunnel(groupEvents);
+                }
+                return result;
+            };
+            withinQuery.strict = () => {
+                isStrict = true;
+                // Return a new thenable with strict mode enabled
+                const strictPromise = Promise.resolve().then(async () => {
+                    return calculateFunnel(getEventsForFunnel());
+                });
+                return strictPromise;
+            };
+            withinQuery.where = (filter) => {
+                whereFilter = filter;
+                return {
+                    by: async (field) => {
+                        const events = getEventsForFunnel();
+                        const groups = new Map();
+                        for (const event of events) {
+                            const value = field === 'variant' ? event.variant : event.data[field];
+                            if (value !== undefined) {
+                                const key = String(value);
+                                if (!groups.has(key))
+                                    groups.set(key, []);
+                                groups.get(key).push(event);
+                            }
+                        }
+                        const result = {};
+                        for (const [key, groupEvents] of groups) {
+                            result[key] = calculateFunnel(groupEvents);
+                        }
+                        return result;
+                    },
+                };
+            };
+            return withinQuery;
+        },
+    };
+}
+// =============================================================================
+// COHORT IMPLEMENTATION
+// =============================================================================
+function createCohortQuery(config, storage) {
+    const calculateCohort = (events) => {
+        const { anchor, activity, periods, granularity } = config;
+        // Find anchor events (e.g., Signup)
+        const anchorEvents = events.filter((e) => e.type === anchor);
+        const activityEvents = events.filter((e) => e.type === activity);
+        // Group anchor events by period and user
+        const periodMs = granularity === 'day' ? 24 * 60 * 60 * 1000 : granularity === 'week' ? 7 * 24 * 60 * 60 * 1000 : 30 * 24 * 60 * 60 * 1000;
+        // Group by cohort period
+        const cohortGroups = new Map(); // periodStart -> (userId -> anchorTime)
+        for (const event of anchorEvents) {
+            const userId = event.data.userId;
+            if (!userId)
+                continue;
+            const periodStart = getPeriodStart(event.timestamp, granularity);
+            if (!cohortGroups.has(periodStart)) {
+                cohortGroups.set(periodStart, new Map());
+            }
+            const cohort = cohortGroups.get(periodStart);
+            if (!cohort.has(userId)) {
+                cohort.set(userId, event.timestamp);
+            }
+        }
+        // Build activity lookup by user
+        const userActivities = new Map();
+        for (const event of activityEvents) {
+            const userId = event.data.userId;
+            if (!userId)
+                continue;
+            if (!userActivities.has(userId)) {
+                userActivities.set(userId, []);
+            }
+            userActivities.get(userId).push(event.timestamp);
+        }
+        // Calculate retention for each cohort
+        const cohorts = [];
+        for (const [periodStart, users] of cohortGroups) {
+            const size = users.size;
+            const retention = [];
+            for (let period = 1; period < periods; period++) {
+                let retainedCount = 0;
+                for (const [userId, anchorTime] of users) {
+                    const activities = userActivities.get(userId) || [];
+                    // Check if user had activity in this period
+                    // retention[0] = period 1 = activity in 1st week after signup (anchorTime+week to anchorTime+2*week)
+                    const periodStartTime = anchorTime + period * periodMs;
+                    const periodEndTime = anchorTime + (period + 1) * periodMs;
+                    const hasActivity = activities.some((t) => t >= periodStartTime && t < periodEndTime);
+                    if (hasActivity)
+                        retainedCount++;
+                }
+                retention.push(size > 0 ? retainedCount / size : 0);
+            }
+            cohorts.push({ startDate: periodStart, size, retention });
+        }
+        // Sort by start date
+        cohorts.sort((a, b) => a.startDate - b.startDate);
+        return { cohorts, granularity };
+    };
+    // Create a thenable that can be awaited directly
+    const cohortPromise = Promise.resolve().then(async () => {
+        return calculateCohort(storage.events);
+    });
+    const cohortQuery = cohortPromise;
+    cohortQuery.by = async (field) => {
+        const groups = new Map();
+        for (const event of storage.events) {
+            const value = event.data[field];
+            if (value !== undefined) {
+                const key = String(value);
+                if (!groups.has(key))
+                    groups.set(key, []);
+                groups.get(key).push(event);
+            }
+        }
+        const result = {};
+        for (const [key, groupEvents] of groups) {
+            result[key] = calculateCohort(groupEvents);
+        }
+        return result;
+    };
+    return cohortQuery;
+}
+// =============================================================================
+// STEP HELPER
+// =============================================================================
+/**
+ * Create a funnel step definition
+ */
+export function $step(eventType) {
+    const step = { eventType };
+    step.where = (filter) => {
+        return { eventType, filter };
+    };
+    return step;
+}
+// =============================================================================
+// TRACK PROXY
+// =============================================================================
+function createTrackProxy(storage) {
+    const cache = new Map();
+    const proxy = new Proxy({}, {
+        get(target, prop) {
+            if (prop === 'batch') {
+                return async (events) => {
+                    const results = [];
+                    const baseTime = Date.now();
+                    for (let i = 0; i < events.length; i++) {
+                        const { event: eventType, data, options } = events[i];
+                        const trackedEvent = {
+                            id: generateId(),
+                            type: eventType,
+                            data,
+                            timestamp: baseTime + i, // Sequential timestamps
+                            ...(options?.experiment && { experiment: options.experiment }),
+                            ...(options?.variant && { variant: options.variant }),
+                        };
+                        storage.events.push(trackedEvent);
+                        results.push(trackedEvent);
+                        // Notify subscribers
+                        const subs = storage.subscriptions.get(eventType) || [];
+                        for (const sub of subs) {
+                            if (!sub.filter || matchesFilter(trackedEvent, sub.filter)) {
+                                sub.handler(trackedEvent);
+                            }
+                        }
+                    }
+                    return results;
+                };
+            }
+            if (prop === 'funnel') {
+                return (steps) => {
+                    return createFunnelQuery(steps, storage);
+                };
+            }
+            if (prop === 'cohort') {
+                return (config) => {
+                    return createCohortQuery(config, storage);
+                };
+            }
+            if (prop === 'ratio') {
+                return async (numerator, denominator) => {
+                    // Parse denominator - may include filter like "PageView:/pricing"
+                    let denomEventType = denominator;
+                    let denomFilter;
+                    if (denominator.includes(':')) {
+                        const [type, path] = denominator.split(':');
+                        denomEventType = type;
+                        denomFilter = { path };
+                    }
+                    const numeratorEvents = storage.events.filter((e) => e.type === numerator);
+                    const denominatorEvents = storage.events.filter((e) => {
+                        if (e.type !== denomEventType)
+                            return false;
+                        if (denomFilter && !matchesFilter(e, denomFilter))
+                            return false;
+                        return true;
+                    });
+                    if (denominatorEvents.length === 0)
+                        return 0;
+                    return numeratorEvents.length / denominatorEvents.length;
+                };
+            }
+            // Return cached event proxy or create new one
+            if (!cache.has(prop)) {
+                cache.set(prop, createEventProxy(prop, storage));
+            }
+            return cache.get(prop);
+        },
+    });
+    return proxy;
+}
+/**
+ * Create a track context for event tracking
+ */
+export function createTrackContext() {
+    const storage = createStorage();
+    return {
+        track: createTrackProxy(storage),
+        _storage: {
+            put: async (type, data, timestamp) => {
+                const event = {
+                    id: generateId(),
+                    type,
+                    data,
+                    timestamp,
+                };
+                storage.events.push(event);
+            },
+            clear: async () => {
+                storage.events.length = 0;
+            },
+        },
+    };
+}
+//# sourceMappingURL=context.js.map