@contractspec/lib.analytics 1.57.0 → 1.59.0

package/dist/browser/index.js

@@ -0,0 +1,723 @@
+// src/churn/predictor.ts
+import dayjs from "dayjs";
+
+class ChurnPredictor {
+  recencyWeight;
+  frequencyWeight;
+  errorWeight;
+  decayDays;
+  constructor(options) {
+    this.recencyWeight = options?.recencyWeight ?? 0.5;
+    this.frequencyWeight = options?.frequencyWeight ?? 0.3;
+    this.errorWeight = options?.errorWeight ?? 0.2;
+    this.decayDays = options?.decayDays ?? 14;
+  }
+  score(events) {
+    const grouped = groupBy(events, (event) => event.userId);
+    const signals = [];
+    for (const [userId, userEvents] of grouped.entries()) {
+      const score = this.computeScore(userEvents);
+      signals.push({
+        userId,
+        score,
+        bucket: score >= 0.7 ? "high" : score >= 0.4 ? "medium" : "low",
+        drivers: this.drivers(userEvents)
+      });
+    }
+    return signals.sort((a, b) => b.score - a.score);
+  }
+  computeScore(events) {
+    if (!events.length)
+      return 0;
+    const sorted = events.sort((a, b) => dateMs(a) - dateMs(b));
+    const lastEvent = sorted[sorted.length - 1];
+    if (!lastEvent)
+      return 0;
+    const daysSinceLast = dayjs().diff(dayjs(lastEvent.timestamp), "day");
+    const recencyScore = Math.max(0, 1 - daysSinceLast / this.decayDays);
+    const windowStart = dayjs().subtract(this.decayDays, "day");
+    const recentEvents = sorted.filter((event) => dayjs(event.timestamp).isAfter(windowStart));
+    const averagePerDay = recentEvents.length / Math.max(this.decayDays, 1);
+    const frequencyScore = Math.min(1, averagePerDay * 5);
+    const errorEvents = recentEvents.filter((event) => typeof event.properties?.error !== "undefined" || /error|failed/i.test(event.name)).length;
+    const errorScore = Math.min(1, errorEvents / 3);
+    const score = recencyScore * this.recencyWeight + frequencyScore * this.frequencyWeight + (1 - errorScore) * this.errorWeight;
+    return Number(score.toFixed(3));
+  }
+  drivers(events) {
+    const drivers = [];
+    const sorted = events.sort((a, b) => dateMs(a) - dateMs(b));
+    const lastEvent = sorted[sorted.length - 1];
+    if (lastEvent) {
+      const days = dayjs().diff(dayjs(lastEvent.timestamp), "day");
+      if (days > this.decayDays)
+        drivers.push(`Inactive for ${days} days`);
+    }
+    const errorEvents = events.filter((event) => typeof event.properties?.error !== "undefined" || /error|failed/i.test(event.name));
+    if (errorEvents.length)
+      drivers.push(`${errorEvents.length} errors logged`);
+    return drivers;
+  }
+}
+function groupBy(items, selector) {
+  const map = new Map;
+  for (const item of items) {
+    const key = selector(item);
+    const list = map.get(key) ?? [];
+    list.push(item);
+    map.set(key, list);
+  }
+  return map;
+}
+function dateMs(event) {
+  return new Date(event.timestamp).getTime();
+}
+// src/cohort/tracker.ts
+import dayjs2 from "dayjs";
+
+class CohortTracker {
+  analyze(events, definition) {
+    const groupedByUser = groupBy2(events, (event) => event.userId);
+    const cohorts = new Map;
+    for (const [userId, userEvents] of groupedByUser.entries()) {
+      userEvents.sort((a, b) => dateMs2(a) - dateMs2(b));
+      const signup = userEvents[0];
+      if (!signup)
+        continue;
+      const cohortKey = bucketKey(signup.timestamp, definition.bucket);
+      const builder = cohorts.get(cohortKey) ?? new CohortStatsBuilder(cohortKey, definition);
+      builder.addUser(userId);
+      for (const event of userEvents) {
+        builder.addEvent(userId, event);
+      }
+      cohorts.set(cohortKey, builder);
+    }
+    return {
+      definition,
+      cohorts: [...cohorts.values()].map((builder) => builder.build())
+    };
+  }
+}
+
+class CohortStatsBuilder {
+  key;
+  definition;
+  users = new Set;
+  retentionMap = new Map;
+  ltv = 0;
+  constructor(key, definition) {
+    this.key = key;
+    this.definition = definition;
+  }
+  addUser(userId) {
+    this.users.add(userId);
+  }
+  addEvent(userId, event) {
+    const period = bucketDiff(this.key, event.timestamp, this.definition.bucket);
+    if (period < 0 || period >= this.definition.periods)
+      return;
+    const bucket = this.retentionMap.get(period) ?? new Set;
+    bucket.add(userId);
+    this.retentionMap.set(period, bucket);
+    const amount = typeof event.properties?.amount === "number" ? event.properties.amount : 0;
+    this.ltv += amount;
+  }
+  build() {
+    const totalUsers = this.users.size || 1;
+    const retention = [];
+    for (let period = 0;period < this.definition.periods; period++) {
+      const active = this.retentionMap.get(period)?.size ?? 0;
+      retention.push(Number((active / totalUsers).toFixed(3)));
+    }
+    return {
+      cohortKey: this.key,
+      users: this.users.size,
+      retention,
+      ltv: Number(this.ltv.toFixed(2))
+    };
+  }
+}
+function groupBy2(items, selector) {
+  const map = new Map;
+  for (const item of items) {
+    const key = selector(item);
+    const list = map.get(key) ?? [];
+    list.push(item);
+    map.set(key, list);
+  }
+  return map;
+}
+function bucketKey(timestamp, bucket) {
+  const dt = dayjs2(timestamp);
+  switch (bucket) {
+    case "day":
+      return dt.startOf("day").format("YYYY-MM-DD");
+    case "week":
+      return dt.startOf("week").format("YYYY-[W]WW");
+    case "month":
+    default:
+      return dt.startOf("month").format("YYYY-MM");
+  }
+}
+function bucketDiff(cohortKey, timestamp, bucket) {
+  const start = parseBucketKey(cohortKey, bucket);
+  const target = dayjs2(timestamp);
+  switch (bucket) {
+    case "day":
+      return target.diff(start, "day");
+    case "week":
+      return target.diff(start, "week");
+    case "month":
+    default:
+      return target.diff(start, "month");
+  }
+}
+function parseBucketKey(key, bucket) {
+  switch (bucket) {
+    case "day":
+      return dayjs2(key, "YYYY-MM-DD");
+    case "week":
+      return dayjs2(key.replace("W", ""), "YYYY-ww");
+    case "month":
+    default:
+      return dayjs2(key, "YYYY-MM");
+  }
+}
+function dateMs2(event) {
+  return new Date(event.timestamp).getTime();
+}
+// src/funnel/analyzer.ts
+class FunnelAnalyzer {
+  analyze(events, definition) {
+    const windowMs = (definition.windowHours ?? 72) * 60 * 60 * 1000;
+    const eventsByUser = groupByUser(events);
+    const stepCounts = definition.steps.map(() => 0);
+    for (const userEvents of eventsByUser.values()) {
+      const completionIndex = this.evaluateUser(userEvents, definition.steps, windowMs);
+      completionIndex.forEach((hit, stepIdx) => {
+        if (hit) {
+          stepCounts[stepIdx] = (stepCounts[stepIdx] ?? 0) + 1;
+        }
+      });
+    }
+    const totalUsers = eventsByUser.size;
+    const steps = definition.steps.map((step, index) => {
+      const prevCount = index === 0 ? totalUsers : stepCounts[index - 1] || 1;
+      const count = stepCounts[index] ?? 0;
+      const conversionRate = prevCount === 0 ? 0 : Number((count / prevCount).toFixed(3));
+      const dropOffRate = Number((1 - conversionRate).toFixed(3));
+      return { step, count, conversionRate, dropOffRate };
+    });
+    return {
+      definition,
+      totalUsers,
+      steps
+    };
+  }
+  evaluateUser(events, steps, windowMs) {
+    const sorted = [...events].sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+    const completion = Array(steps.length).fill(false);
+    let cursor = 0;
+    let anchorTime;
+    for (const event of sorted) {
+      const step = steps[cursor];
+      if (!step)
+        break;
+      if (event.name !== step.eventName)
+        continue;
+      if (step.match && !step.match(event))
+        continue;
+      const eventTime = new Date(event.timestamp).getTime();
+      if (cursor === 0) {
+        anchorTime = eventTime;
+        completion[cursor] = true;
+        cursor += 1;
+        continue;
+      }
+      if (anchorTime && eventTime - anchorTime <= windowMs) {
+        completion[cursor] = true;
+        cursor += 1;
+      }
+    }
+    return completion;
+  }
+}
+function groupByUser(events) {
+  const map = new Map;
+  for (const event of events) {
+    const list = map.get(event.userId) ?? [];
+    list.push(event);
+    map.set(event.userId, list);
+  }
+  return map;
+}
+// src/growth/hypothesis-generator.ts
+class GrowthHypothesisGenerator {
+  minDelta;
+  constructor(options) {
+    this.minDelta = options?.minDelta ?? 0.05;
+  }
+  generate(metrics) {
+    return metrics.map((metric) => this.fromMetric(metric)).filter((hypothesis) => Boolean(hypothesis));
+  }
+  fromMetric(metric) {
+    const change = this.delta(metric);
+    if (Math.abs(change) < this.minDelta)
+      return null;
+    const direction = change > 0 ? "rising" : "declining";
+    const statement = this.statement(metric, change, direction);
+    return {
+      statement,
+      metric: metric.name,
+      confidence: Math.abs(change) > 0.2 ? "high" : "medium",
+      impact: this.impact(metric)
+    };
+  }
+  delta(metric) {
+    if (metric.previous == null)
+      return 0;
+    const prev = metric.previous || 1;
+    return (metric.current - prev) / Math.abs(prev);
+  }
+  impact(metric) {
+    if (metric.target && metric.current < metric.target * 0.8)
+      return "high";
+    if (metric.target && metric.current < metric.target)
+      return "medium";
+    return "low";
+  }
+  statement(metric, change, direction) {
+    const percent = Math.abs(parseFloat((change * 100).toFixed(1)));
+    if (direction === "declining") {
+      return `${metric.name} is down ${percent}% vs last period; test new onboarding prompts to recover activation.`;
+    }
+    return `${metric.name} grew ${percent}% period-over-period; double down with expanded experiment or pricing test.`;
+  }
+}
+// src/lifecycle/metric-collectors.ts
+var collectLifecycleMetrics = async (source) => {
+  const [
+    activeUsers,
+    weeklyActiveUsers,
+    retentionRate,
+    monthlyRecurringRevenue,
+    customerCount,
+    teamSize,
+    burnMultiple
+  ] = await Promise.all([
+    source.getActiveUsers(),
+    source.getWeeklyActiveUsers?.(),
+    source.getRetentionRate?.(),
+    source.getMonthlyRecurringRevenue?.(),
+    source.getCustomerCount?.(),
+    source.getTeamSize?.(),
+    source.getBurnMultiple?.()
+  ]);
+  return {
+    activeUsers,
+    weeklyActiveUsers,
+    retentionRate,
+    monthlyRecurringRevenue,
+    customerCount,
+    teamSize,
+    burnMultiple
+  };
+};
+var metricsToSignals = (metrics, tenantId) => Object.entries(metrics).filter(([, value]) => value !== undefined && value !== null).map(([metricKey, value]) => ({
+  id: `lifecycle-metric:${metricKey}`,
+  kind: "metric",
+  source: "analytics",
+  name: metricKey,
+  value,
+  weight: 1,
+  confidence: 0.8,
+  details: tenantId ? { tenantId } : undefined,
+  capturedAt: new Date().toISOString()
+}));
+var lifecycleEventNames = {
+  assessmentRun: "lifecycle_assessment_run",
+  stageChanged: "lifecycle_stage_changed",
+  guidanceConsumed: "lifecycle_guidance_consumed"
+};
+var createStageChangeEvent = (payload) => ({
+  name: lifecycleEventNames.stageChanged,
+  userId: "system",
+  tenantId: payload.tenantId,
+  timestamp: new Date,
+  properties: { ...payload }
+});
+
+// src/lifecycle/posthog-bridge.ts
+var trackLifecycleAssessment = async (client, tenantId, assessment) => {
+  await client.capture({
+    distinctId: tenantId,
+    event: lifecycleEventNames.assessmentRun,
+    properties: {
+      stage: assessment.stage,
+      confidence: assessment.confidence,
+      axes: assessment.axes
+    }
+  });
+};
+var trackLifecycleStageChange = async (client, tenantId, previousStage, nextStage) => {
+  await client.capture({
+    distinctId: tenantId,
+    event: lifecycleEventNames.stageChanged,
+    properties: {
+      previousStage,
+      nextStage
+    }
+  });
+};
+
+// src/lifecycle/posthog-metric-source.ts
+class PosthogLifecycleMetricSource {
+  reader;
+  activityEvents;
+  retentionWindowDays;
+  revenueEvent;
+  revenueProperty;
+  customerEvent;
+  customerProperty;
+  teamSizeEvent;
+  teamSizeProperty;
+  burnMultipleEvent;
+  burnMultipleProperty;
+  constructor(reader, options = {}) {
+    this.reader = reader;
+    this.activityEvents = options.activityEvents;
+    this.retentionWindowDays = options.retentionWindowDays ?? 7;
+    this.revenueEvent = options.revenueEvent;
+    this.revenueProperty = options.revenueProperty ?? "amount";
+    this.customerEvent = options.customerEvent;
+    this.customerProperty = options.customerProperty ?? "is_customer";
+    this.teamSizeEvent = options.teamSizeEvent;
+    this.teamSizeProperty = options.teamSizeProperty ?? "team_size";
+    this.burnMultipleEvent = options.burnMultipleEvent;
+    this.burnMultipleProperty = options.burnMultipleProperty ?? "burn_multiple";
+  }
+  async getActiveUsers() {
+    return this.countDistinctUsers(1);
+  }
+  async getWeeklyActiveUsers() {
+    return this.countDistinctUsers(7);
+  }
+  async getRetentionRate() {
+    const windowDays = this.retentionWindowDays;
+    const now = new Date;
+    const prevEnd = new Date(now.getTime() - windowDays * 24 * 60 * 60 * 1000);
+    const prevStart = new Date(now.getTime() - windowDays * 2 * 24 * 60 * 60 * 1000);
+    const returningUsers = await this.countReturningUsers(prevStart, prevEnd, now);
+    const prevUsers = await this.countDistinctUsersBetween(prevStart, prevEnd);
+    if (prevUsers === undefined || prevUsers === 0)
+      return;
+    return returningUsers / prevUsers;
+  }
+  async getMonthlyRecurringRevenue() {
+    if (!this.revenueEvent || !this.revenueProperty)
+      return;
+    return this.sumMetric(this.revenueEvent, this.revenueProperty);
+  }
+  async getCustomerCount() {
+    if (!this.customerEvent || !this.customerProperty)
+      return;
+    return this.countDistinctUsersByProperty(this.customerEvent, this.customerProperty);
+  }
+  async getTeamSize() {
+    if (!this.teamSizeEvent || !this.teamSizeProperty)
+      return;
+    return this.latestMetric(this.teamSizeEvent, this.teamSizeProperty);
+  }
+  async getBurnMultiple() {
+    if (!this.burnMultipleEvent || !this.burnMultipleProperty)
+      return;
+    return this.latestMetric(this.burnMultipleEvent, this.burnMultipleProperty);
+  }
+  async countDistinctUsers(days) {
+    const range = buildDateRange(days);
+    return this.countDistinctUsersBetween(range.from, range.to);
+  }
+  async countDistinctUsersBetween(from, to) {
+    const eventFilter = buildEventFilter(this.activityEvents, "activityEvent");
+    const result = await this.queryHogQL({
+      query: [
+        "select",
+        "  countDistinct(distinct_id) as total",
+        "from events",
+        `where timestamp >= {dateFrom} and timestamp < {dateTo}`,
+        eventFilter.clause ? `and ${eventFilter.clause}` : ""
+      ].filter(Boolean).join(`
+`),
+      values: {
+        dateFrom: from.toISOString(),
+        dateTo: to.toISOString(),
+        ...eventFilter.values
+      }
+    });
+    return readSingleNumber(result);
+  }
+  async countReturningUsers(previousStart, previousEnd, currentEnd) {
+    const eventFilter = buildEventFilter(this.activityEvents, "activityEvent");
+    const result = await this.queryHogQL({
+      query: [
+        "select",
+        "  countDistinct(distinct_id) as total",
+        "from events",
+        `where timestamp >= {currentFrom} and timestamp < {currentTo}`,
+        eventFilter.clause ? `and ${eventFilter.clause}` : "",
+        "and distinct_id in (",
+        "  select distinct_id from events",
+        "  where timestamp >= {previousFrom} and timestamp < {previousTo}",
+        eventFilter.clause ? `and ${eventFilter.clause}` : "",
+        ")"
+      ].join(`
+`),
+      values: {
+        currentFrom: previousEnd.toISOString(),
+        currentTo: currentEnd.toISOString(),
+        previousFrom: previousStart.toISOString(),
+        previousTo: previousEnd.toISOString(),
+        ...eventFilter.values
+      }
+    });
+    return readSingleNumber(result) ?? 0;
+  }
+  async sumMetric(eventName, propertyKey) {
+    const result = await this.queryHogQL({
+      query: [
+        "select",
+        `  sum(properties.${propertyKey}) as total`,
+        "from events",
+        "where event = {eventName}"
+      ].join(`
+`),
+      values: { eventName }
+    });
+    return readSingleNumber(result);
+  }
+  async countDistinctUsersByProperty(eventName, propertyKey) {
+    const result = await this.queryHogQL({
+      query: [
+        "select",
+        "  countDistinct(distinct_id) as total",
+        "from events",
+        "where event = {eventName}",
+        `and properties.${propertyKey} = {propertyValue}`
+      ].join(`
+`),
+      values: { eventName, propertyValue: true }
+    });
+    return readSingleNumber(result);
+  }
+  async latestMetric(eventName, propertyKey) {
+    const result = await this.queryHogQL({
+      query: [
+        "select",
+        `  properties.${propertyKey} as value`,
+        "from events",
+        "where event = {eventName}",
+        "order by timestamp desc",
+        "limit 1"
+      ].join(`
+`),
+      values: { eventName }
+    });
+    return readSingleNumber(result);
+  }
+  async queryHogQL(input) {
+    if (!this.reader.queryHogQL) {
+      throw new Error("Analytics reader does not support HogQL queries.");
+    }
+    return this.reader.queryHogQL(input);
+  }
+}
+function buildDateRange(days) {
+  const to = new Date;
+  const from = new Date(to.getTime() - days * 24 * 60 * 60 * 1000);
+  return { from, to };
+}
+function buildEventFilter(events, prefix) {
+  if (!events || events.length === 0)
+    return {};
+  if (events.length === 1) {
+    return {
+      clause: `event = {${prefix}0}`,
+      values: { [`${prefix}0`]: events[0] }
+    };
+  }
+  const clauses = events.map((_event, index) => `event = {${prefix}${index}}`);
+  const values = {};
+  events.forEach((event, index) => {
+    values[`${prefix}${index}`] = event;
+  });
+  return {
+    clause: `(${clauses.join(" or ")})`,
+    values
+  };
+}
+function readSingleNumber(result) {
+  if (!Array.isArray(result.results) || result.results.length === 0) {
+    return;
+  }
+  const firstRow = result.results[0];
+  if (Array.isArray(firstRow) && firstRow.length > 0) {
+    const value = firstRow[0];
+    if (typeof value === "number" && Number.isFinite(value))
+      return value;
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed))
+        return parsed;
+    }
+  }
+  return;
+}
+// src/posthog/event-source.ts
+class PosthogAnalyticsEventSource {
+  reader;
+  limitPerEvent;
+  tenantPropertyKey;
+  defaultRangeDays;
+  constructor(reader, options = {}) {
+    this.reader = reader;
+    this.limitPerEvent = options.limitPerEvent ?? 1000;
+    this.tenantPropertyKey = options.tenantPropertyKey ?? "tenantId";
+    this.defaultRangeDays = options.defaultRangeDays ?? 30;
+  }
+  async getEventsForFunnel(definition, dateRange) {
+    const eventNames = definition.steps.map((step) => step.eventName);
+    return this.getEventsByNames(eventNames, dateRange);
+  }
+  async getEventsForCohort(definition, dateRange, eventNames) {
+    const events = eventNames && eventNames.length > 0 ? eventNames : ["*"];
+    if (events[0] === "*") {
+      return this.getEventsByNames([], dateRange, definition.periods * 500);
+    }
+    return this.getEventsByNames(events, dateRange, definition.periods * 500);
+  }
+  async getUserActivity(userId, dateRange, limit = 1000) {
+    if (!this.reader.getEvents) {
+      throw new Error("Analytics reader does not support event queries.");
+    }
+    const response = await this.reader.getEvents({
+      distinctId: userId,
+      dateRange,
+      limit
+    });
+    return response.results.map((event) => toAnalyticsEvent(event, this.tenantPropertyKey));
+  }
+  async getGrowthMetrics(metricNames, dateRange) {
+    const range = resolveRange(dateRange, this.defaultRangeDays);
+    const previous = shiftRange(range);
+    const results = [];
+    for (const metricName of metricNames) {
+      const current = await this.countEvents(metricName, range);
+      const previousCount = await this.countEvents(metricName, previous);
+      results.push({
+        name: metricName,
+        current,
+        previous: previousCount
+      });
+    }
+    return results;
+  }
+  async getEventsByNames(eventNames, dateRange, limitPerEvent = this.limitPerEvent) {
+    if (!this.reader.getEvents) {
+      throw new Error("Analytics reader does not support event queries.");
+    }
+    if (eventNames.length === 0) {
+      const response = await this.reader.getEvents({
+        dateRange,
+        limit: limitPerEvent
+      });
+      return response.results.map((event) => toAnalyticsEvent(event, this.tenantPropertyKey));
+    }
+    const events = [];
+    for (const eventName of eventNames) {
+      const response = await this.reader.getEvents({
+        event: eventName,
+        dateRange,
+        limit: limitPerEvent
+      });
+      response.results.forEach((event) => {
+        events.push(toAnalyticsEvent(event, this.tenantPropertyKey));
+      });
+    }
+    return events;
+  }
+  async countEvents(eventName, range) {
+    if (!this.reader.queryHogQL) {
+      throw new Error("Analytics reader does not support HogQL queries.");
+    }
+    const result = await this.reader.queryHogQL({
+      query: [
+        "select",
+        "  count() as total",
+        "from events",
+        "where event = {eventName}",
+        "and timestamp >= {dateFrom}",
+        "and timestamp < {dateTo}"
+      ].join(`
+`),
+      values: {
+        eventName,
+        dateFrom: range.from.toISOString(),
+        dateTo: range.to.toISOString()
+      }
+    });
+    return readSingleNumber2(result) ?? 0;
+  }
+}
+function toAnalyticsEvent(event, tenantPropertyKey) {
+  const tenantIdValue = event.properties?.[tenantPropertyKey] ?? event.properties?.tenantId;
+  return {
+    name: event.event,
+    userId: event.distinctId,
+    tenantId: typeof tenantIdValue === "string" ? tenantIdValue : undefined,
+    timestamp: event.timestamp,
+    properties: event.properties
+  };
+}
+function resolveRange(dateRange, defaultDays) {
+  const to = dateRange?.to instanceof Date ? dateRange.to : dateRange?.to ? new Date(dateRange.to) : new Date;
+  const from = dateRange?.from instanceof Date ? dateRange.from : dateRange?.from ? new Date(dateRange.from) : new Date(to.getTime() - defaultDays * 24 * 60 * 60 * 1000);
+  return { from, to };
+}
+function shiftRange(range) {
+  const duration = range.to.getTime() - range.from.getTime();
+  return {
+    from: new Date(range.from.getTime() - duration),
+    to: new Date(range.to.getTime() - duration)
+  };
+}
+function readSingleNumber2(result) {
+  if (!Array.isArray(result.results) || result.results.length === 0) {
+    return;
+  }
+  const firstRow = result.results[0];
+  if (Array.isArray(firstRow) && firstRow.length > 0) {
+    const value = firstRow[0];
+    if (typeof value === "number" && Number.isFinite(value))
+      return value;
+    if (typeof value === "string" && value.trim()) {
+      const parsed = Number(value);
+      if (Number.isFinite(parsed))
+        return parsed;
+    }
+  }
+  return;
+}
+export {
+  trackLifecycleStageChange,
+  trackLifecycleAssessment,
+  metricsToSignals,
+  lifecycleEventNames,
+  createStageChangeEvent,
+  collectLifecycleMetrics,
+  PosthogLifecycleMetricSource,
+  PosthogAnalyticsEventSource,
+  GrowthHypothesisGenerator,
+  FunnelAnalyzer,
+  CohortTracker,
+  ChurnPredictor
+};