@intranefr/superbackend 1.5.1 → 1.5.3

package/src/services/consoleManager.service.js

@@ -13,6 +13,21 @@ const { logErrorSync } = require("./errorLogger");
 const CronJob = require("../models/CronJob");
 const ScriptDefinition = require("../models/ScriptDefinition");
 
+// Import consoleOverride to access the truly original console
+const consoleOverride = require("./consoleOverride.service");
+
+// Simplified module prefix tracking
+let currentModulePrefix = '';
+
+// Module prefix mapping based on module name
+const MODULE_PREFIXES = {
+  'cronScheduler.service.js': '[SuperBackend][Cron]',
+  'healthChecksScheduler.service.js': '[SuperBackend][Health]',
+  'consoleManager.service.js': '[SuperBackend][Console]',
+  'middleware': '[SuperBackend][Core]',
+  'middleware.js': '[SuperBackend][Core]'
+};
+
 let isActive = false;
 let previousConsole = null;
 let isHandling = false;
@@ -41,19 +56,9 @@ function normalizeMessage(message) {
     .slice(0, 500);
 }
 
-function extractTopFrame(stack) {
-  if (!stack) return "";
-  // Skip: Error, console wrapper, handleConsoleCall
-  const lines = String(stack).split("\n").slice(3, 6);
-  for (const line of lines) {
-    const match = line.match(/at\s+(?:(.+?)\s+)?\(?(.+?):(\d+):(\d+)\)?/);
-    if (match) {
-      const fn = match[1] || "<anonymous>";
-      const file = match[2].split("/").pop();
-      return `${fn}@${file}:${match[3]}`;
-    }
-  }
-  return "";
+// Simplified approach - no stack trace parsing needed
+function getModulePrefix() {
+  return currentModulePrefix;
 }
 
 function computeHash({ method, messageTemplate, topFrame }) {
@@ -377,16 +382,26 @@ let configFromMemory = null;
 function handleConsoleCall(method, args, stack) {
   const message = buildMessageFromArgs(args);
   const messageTemplate = normalizeMessage(message);
-  const topFrame = extractTopFrame(stack);
+  // Use empty string for topFrame since we're not using stack trace parsing
+  const topFrame = ""; 
   const hash = computeHash({ method, messageTemplate, topFrame });
 
+  // Get the current module prefix (simplified approach)
+  const prefix = getModulePrefix();
+
+  // Add prefix to args if prefix exists
+  let prefixedArgs = args;
+  if (prefix) {
+    prefixedArgs = [prefix, ...args];
+  }
+
   let entryFromMemory = memoryEntries.get(hash);
 
   asyncUpdate();
 
   if (!configFromMemory && !entryFromMemory) {
     // First pass - always log and wait for async update to complete
-    previousConsole[method](...args);
+    previousConsole[method](...prefixedArgs);
     return;
   } 
 
@@ -396,7 +411,7 @@ function handleConsoleCall(method, args, stack) {
     : configFromMemory?.defaultEntryEnabled !== false;
     
   if (isEnabled) {
-    previousConsole[method](...args);
+    previousConsole[method](...prefixedArgs);
   } else {
     // Entry is disabled - suppress stdout but still capture error aggregation for errors
     if (method === "error") {
@@ -568,11 +583,30 @@ async function ensureRetentionCron() {
 
 const consoleManager = {
   getConsole:()=>console,
+  
+  // New method to set module prefix
+  setModulePrefix(moduleName) {
+    // If moduleName is already a prefix, use it directly
+    if (moduleName.startsWith('[') && moduleName.endsWith(']')) {
+      currentModulePrefix = moduleName;
+    } else {
+      // Otherwise look it up in the mapping
+      currentModulePrefix = MODULE_PREFIXES[moduleName] || '';
+    }
+  },
+  
+  // Get current module prefix
+  getModulePrefix() {
+    return currentModulePrefix;
+  },
+  
   init() {
     if (isActive) return;
     if (isHandling) return;
 
-    previousConsole = { ...console };
+    // Use the truly original console from consoleOverride if available
+    // Otherwise fall back to current console
+    previousConsole = consoleOverride.TRULY_ORIGINAL_CONSOLE || { ...console };
 
     METHODS.forEach((method) => {
       console[method] = (...args) => {
@@ -697,4 +731,8 @@ const consoleManager = {
   },
 };
 
-module.exports = consoleManager;
+module.exports = {
+  consoleManager,
+  MODULE_PREFIXES,
+  handleConsoleCall
+};

package/src/services/consoleOverride.service.js

@@ -294,3 +294,4 @@ process.on('SIGTERM', () => {
 });
 
 module.exports = consoleOverride;
+module.exports.TRULY_ORIGINAL_CONSOLE = TRULY_ORIGINAL_CONSOLE;

package/src/services/experiments.service.js

@@ -0,0 +1,273 @@
+const crypto = require('crypto');
+const mongoose = require('mongoose');
+
+const Experiment = require('../models/Experiment');
+const ExperimentAssignment = require('../models/ExperimentAssignment');
+const ExperimentEvent = require('../models/ExperimentEvent');
+
+const cacheLayer = require('./cacheLayer.service');
+const jsonConfigsService = require('./jsonConfigs.service');
+
+function normalizeStr(v) {
+  return String(v || '').trim();
+}
+
+function normalizeOrgId(orgId) {
+  if (orgId === null || orgId === undefined || orgId === '') return null;
+  const str = String(orgId);
+  if (!mongoose.Types.ObjectId.isValid(str)) {
+    const err = new Error('Invalid orgId');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+  return new mongoose.Types.ObjectId(str);
+}
+
+function normalizeExperimentCode(code) {
+  const c = normalizeStr(code);
+  if (!c) {
+    const err = new Error('experiment code is required');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+  return c;
+}
+
+function normalizeSubjectId(subjectId) {
+  const s = normalizeStr(subjectId);
+  if (!s) {
+    const err = new Error('subjectId is required');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+  return s;
+}
+
+function computeSubjectKey({ orgId, subjectId }) {
+  const sid = normalizeSubjectId(subjectId);
+  const oid = orgId ? String(orgId) : 'global';
+  return `org:${oid}:subject:${sid}`;
+}
+
+function computeBucketInt(input, max) {
+  const hash = crypto.createHash('sha256').update(String(input), 'utf8').digest('hex');
+  const int = parseInt(hash.slice(0, 8), 16);
+  return max <= 0 ? 0 : int % max;
+}
+
+function pickWeightedVariant({ experiment, subjectKey }) {
+  const variants = Array.isArray(experiment?.variants) ? experiment.variants : [];
+  const eligible = variants
+    .map((v) => ({
+      key: normalizeStr(v?.key),
+      weight: Number(v?.weight || 0) || 0,
+      configSlug: normalizeStr(v?.configSlug),
+    }))
+    .filter((v) => v.key && v.weight > 0);
+
+  if (!eligible.length) {
+    const err = new Error('Experiment has no weighted variants');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const total = eligible.reduce((acc, v) => acc + v.weight, 0);
+  const salt = normalizeStr(experiment?.assignment?.salt) || String(experiment?._id || '');
+  const pos = computeBucketInt(`${salt}:${subjectKey}`, total);
+
+  let cursor = 0;
+  for (const v of eligible) {
+    cursor += v.weight;
+    if (pos < cursor) return v;
+  }
+
+  return eligible[eligible.length - 1];
+}
+
+async function getExperimentByCode({ orgId, code }) {
+  const c = normalizeExperimentCode(code);
+  const oid = orgId ? normalizeOrgId(orgId) : null;
+
+  const doc = await Experiment.findOne({ organizationId: oid, code: c }).lean();
+  if (doc) return doc;
+
+  if (oid) {
+    const globalDoc = await Experiment.findOne({ organizationId: null, code: c }).lean();
+    if (globalDoc) return globalDoc;
+  }
+
+  const err = new Error('Experiment not found');
+  err.code = 'NOT_FOUND';
+  throw err;
+}
+
+async function resolveVariantConfig(variant) {
+  const slug = normalizeStr(variant?.configSlug);
+  if (!slug) return null;
+  return jsonConfigsService.getJsonConfigValueBySlug(slug);
+}
+
+async function getOrCreateAssignment({ orgId, experimentCode, subjectId, context }) {
+  const exp = await getExperimentByCode({ orgId, code: experimentCode });
+  const effectiveOrgId = exp.organizationId ? String(exp.organizationId) : null;
+  const subjectKey = computeSubjectKey({ orgId: effectiveOrgId || orgId || null, subjectId });
+
+  const cacheKey = `${String(exp._id)}:${subjectKey}`;
+  const cached = await cacheLayer.get(cacheKey, { namespace: 'experiments.assignments' });
+  if (cached && cached.variantKey) return { experiment: exp, assignment: cached };
+
+  const existing = await ExperimentAssignment.findOne({ experimentId: exp._id, subjectKey }).lean();
+  if (existing) {
+    const assignment = {
+      experimentId: String(existing.experimentId),
+      organizationId: existing.organizationId ? String(existing.organizationId) : null,
+      subjectKey: existing.subjectKey,
+      variantKey: existing.variantKey,
+      assignedAt: existing.assignedAt,
+      context: existing.context || {},
+    };
+    await cacheLayer.set(cacheKey, assignment, { namespace: 'experiments.assignments', ttlSeconds: 60 });
+    return { experiment: exp, assignment };
+  }
+
+  if (exp.status !== 'running' && exp.status !== 'completed') {
+    const err = new Error('Experiment is not active');
+    err.code = 'CONFLICT';
+    throw err;
+  }
+
+  const picked = pickWeightedVariant({ experiment: exp, subjectKey });
+
+  const created = await ExperimentAssignment.create({
+    experimentId: exp._id,
+    organizationId: exp.organizationId || null,
+    subjectKey,
+    variantKey: picked.key,
+    assignedAt: new Date(),
+    context: context && typeof context === 'object' ? context : {},
+  });
+
+  const assignment = {
+    experimentId: String(created.experimentId),
+    organizationId: created.organizationId ? String(created.organizationId) : null,
+    subjectKey: created.subjectKey,
+    variantKey: created.variantKey,
+    assignedAt: created.assignedAt,
+    context: created.context || {},
+  };
+
+  await cacheLayer.set(cacheKey, assignment, { namespace: 'experiments.assignments', ttlSeconds: 60 });
+  return { experiment: exp, assignment };
+}
+
+async function ingestEvents({ orgId, experimentCode, subjectId, events }) {
+  const exp = await getExperimentByCode({ orgId, code: experimentCode });
+
+  const effectiveOrgId = exp.organizationId ? String(exp.organizationId) : null;
+  const subjectKey = computeSubjectKey({ orgId: effectiveOrgId || orgId || null, subjectId });
+
+  const list = Array.isArray(events) ? events : [];
+  if (!list.length) {
+    const err = new Error('events[] is required');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const variantKeys = new Set((exp.variants || []).map((v) => String(v?.key || '').trim()).filter(Boolean));
+
+  const now = new Date();
+  const docs = [];
+  for (const e of list) {
+    if (!e || typeof e !== 'object') continue;
+
+    const eventKey = normalizeStr(e.eventKey);
+    if (!eventKey) {
+      const err = new Error('eventKey is required');
+      err.code = 'VALIDATION';
+      throw err;
+    }
+
+    const ts = e.ts ? new Date(e.ts) : now;
+    if (!Number.isFinite(ts.getTime())) {
+      const err = new Error('Invalid ts');
+      err.code = 'VALIDATION';
+      throw err;
+    }
+
+    let variantKey = normalizeStr(e.variantKey);
+    if (!variantKey) {
+      const { assignment } = await getOrCreateAssignment({ orgId, experimentCode, subjectId, context: null });
+      variantKey = assignment.variantKey;
+    }
+
+    if (!variantKeys.has(variantKey)) {
+      const err = new Error('Invalid variantKey');
+      err.code = 'VALIDATION';
+      throw err;
+    }
+
+    const value = e.value === undefined ? 1 : Number(e.value);
+    if (!Number.isFinite(value)) {
+      const err = new Error('Invalid value');
+      err.code = 'VALIDATION';
+      throw err;
+    }
+
+    docs.push({
+      experimentId: exp._id,
+      organizationId: exp.organizationId || null,
+      subjectKey,
+      variantKey,
+      eventKey,
+      value,
+      ts,
+      meta: e.meta && typeof e.meta === 'object' ? e.meta : {},
+    });
+  }
+
+  if (!docs.length) {
+    const err = new Error('No valid events provided');
+    err.code = 'VALIDATION';
+    throw err;
+  }
+
+  const inserted = await ExperimentEvent.insertMany(docs, { ordered: false });
+  return { insertedCount: Array.isArray(inserted) ? inserted.length : 0 };
+}
+
+async function getWinnerSnapshot({ orgId, experimentCode }) {
+  const exp = await getExperimentByCode({ orgId, code: experimentCode });
+
+  const cacheKey = String(exp._id);
+  const cached = await cacheLayer.get(cacheKey, { namespace: 'experiments.winner' });
+  if (cached && typeof cached === 'object') return { experiment: exp, snapshot: cached };
+
+  const snapshot = {
+    experimentId: String(exp._id),
+    organizationId: exp.organizationId ? String(exp.organizationId) : null,
+    code: exp.code,
+    status: exp.status,
+    winnerVariantKey: exp.winnerVariantKey || null,
+    winnerDecidedAt: exp.winnerDecidedAt || null,
+    winnerReason: exp.winnerReason || null,
+  };
+
+  await cacheLayer.set(cacheKey, snapshot, { namespace: 'experiments.winner', ttlSeconds: 30 });
+  return { experiment: exp, snapshot };
+}
+
+async function clearExperimentCaches(experimentId) {
+  const id = String(experimentId || '').trim();
+  if (!id) return;
+  await cacheLayer.delete(id, { namespace: 'experiments.winner' }).catch(() => {});
+}
+
+module.exports = {
+  computeSubjectKey,
+  getExperimentByCode,
+  resolveVariantConfig,
+  getOrCreateAssignment,
+  ingestEvents,
+  getWinnerSnapshot,
+  clearExperimentCaches,
+};

package/src/services/experimentsAggregation.service.js

@@ -0,0 +1,308 @@
+const mongoose = require('mongoose');
+
+const Experiment = require('../models/Experiment');
+const ExperimentEvent = require('../models/ExperimentEvent');
+const ExperimentMetricBucket = require('../models/ExperimentMetricBucket');
+
+const experimentsService = require('./experiments.service');
+const { broadcastWinnerChanged } = require('./experimentsWs.service');
+const webhookService = require('./webhook.service');
+
+function normalizeStr(v) {
+  return String(v || '').trim();
+}
+
+function floorToBucket(date, bucketMs) {
+  const t = new Date(date).getTime();
+  const ms = Number(bucketMs || 0) || 0;
+  if (!Number.isFinite(t) || ms <= 0) return null;
+  return new Date(Math.floor(t / ms) * ms);
+}
+
+function resolveMetricKeys(exp) {
+  const defs = [];
+  if (exp?.primaryMetric) defs.push(exp.primaryMetric);
+  for (const m of exp?.secondaryMetrics || []) defs.push(m);
+
+  const keys = new Set();
+  for (const d of defs) {
+    const kind = normalizeStr(d?.kind);
+    const key = normalizeStr(d?.key);
+    if (!key) continue;
+
+    if (kind === 'rate') {
+      const num = normalizeStr(d?.numeratorEventKey);
+      const den = normalizeStr(d?.denominatorEventKey);
+      if (num) keys.add(num);
+      if (den) keys.add(den);
+      continue;
+    }
+
+    keys.add(key);
+  }
+  return Array.from(keys);
+}
+
+async function aggregateExperiment({ experimentId, bucketMs, start, end }) {
+  const exp = await Experiment.findById(experimentId).lean();
+  if (!exp) {
+    const err = new Error('Experiment not found');
+    err.code = 'NOT_FOUND';
+    throw err;
+  }
+
+  const metricEventKeys = resolveMetricKeys(exp);
+  if (!metricEventKeys.length) {
+    return { experimentId: String(exp._id), aggregated: 0 };
+  }
+
+  const startAt = start ? new Date(start) : (exp.startedAt ? new Date(exp.startedAt) : new Date(Date.now() - 24 * 60 * 60 * 1000));
+  const endAt = end ? new Date(end) : new Date();
+
+  const bucket = Number(bucketMs || 0) || 3600000;
+
+  const pipeline = [
+    {
+      $match: {
+        experimentId: new mongoose.Types.ObjectId(String(exp._id)),
+        ts: { $gte: startAt, $lte: endAt },
+        eventKey: { $in: metricEventKeys },
+      },
+    },
+    {
+      $addFields: {
+        bucketStart: {
+          $toDate: {
+            $multiply: [
+              { $floor: { $divide: [{ $toLong: '$ts' }, bucket] } },
+              bucket,
+            ],
+          },
+        },
+      },
+    },
+    {
+      $group: {
+        _id: {
+          variantKey: '$variantKey',
+          metricKey: '$eventKey',
+          bucketStart: '$bucketStart',
+        },
+        count: { $sum: 1 },
+        sum: { $sum: '$value' },
+        sumSq: { $sum: { $multiply: ['$value', '$value'] } },
+        min: { $min: '$value' },
+        max: { $max: '$value' },
+      },
+    },
+  ];
+
+  const rows = await ExperimentEvent.aggregate(pipeline);
+
+  let aggregated = 0;
+  for (const r of rows || []) {
+    if (!r || !r._id) continue;
+
+    await ExperimentMetricBucket.updateOne(
+      {
+        experimentId: exp._id,
+        organizationId: exp.organizationId || null,
+        variantKey: String(r._id.variantKey),
+        metricKey: String(r._id.metricKey),
+        bucketStart: new Date(r._id.bucketStart),
+        bucketMs: bucket,
+      },
+      {
+        $set: {
+          count: Number(r.count || 0) || 0,
+          sum: Number(r.sum || 0) || 0,
+          sumSq: Number(r.sumSq || 0) || 0,
+          min: r.min === undefined ? null : r.min,
+          max: r.max === undefined ? null : r.max,
+        },
+      },
+      { upsert: true },
+    );
+
+    aggregated += 1;
+  }
+
+  return { experimentId: String(exp._id), aggregated };
+}
+
+async function computeTotalsForMetric({ experimentId, variantKey, metricKey, startAt }) {
+  const q = {
+    experimentId: new mongoose.Types.ObjectId(String(experimentId)),
+    variantKey: String(variantKey),
+    metricKey: String(metricKey),
+  };
+
+  if (startAt) {
+    q.bucketStart = { $gte: new Date(startAt) };
+  }
+
+  const rows = await ExperimentMetricBucket.find(q).select('count sum').lean();
+
+  let count = 0;
+  let sum = 0;
+  for (const r of rows || []) {
+    count += Number(r.count || 0) || 0;
+    sum += Number(r.sum || 0) || 0;
+  }
+
+  return { count, sum };
+}
+
+async function evaluateWinner({ experimentId }) {
+  const exp = await Experiment.findById(experimentId);
+  if (!exp) {
+    const err = new Error('Experiment not found');
+    err.code = 'NOT_FOUND';
+    throw err;
+  }
+
+  if (exp.winnerPolicy?.mode !== 'automatic') {
+    return { decided: false, reason: 'manual_mode' };
+  }
+
+  if (exp.winnerVariantKey && exp.winnerDecidedAt) {
+    return { decided: true, reason: 'already_decided', winnerVariantKey: exp.winnerVariantKey };
+  }
+
+  const pickAfterMs = Number(exp.winnerPolicy?.pickAfterMs || 0) || 0;
+  const startedAt = exp.startedAt ? new Date(exp.startedAt) : null;
+  if (!startedAt) {
+    return { decided: false, reason: 'missing_startedAt' };
+  }
+
+  if (pickAfterMs > 0 && Date.now() - startedAt.getTime() < pickAfterMs) {
+    return { decided: false, reason: 'too_early' };
+  }
+
+  const primary = exp.primaryMetric || {};
+  const kind = normalizeStr(primary.kind) || 'count';
+
+  const variants = (exp.variants || []).map((v) => normalizeStr(v?.key)).filter(Boolean);
+  if (!variants.length) {
+    return { decided: false, reason: 'no_variants' };
+  }
+
+  const evalStart = startedAt;
+
+  const scores = [];
+  for (const variantKey of variants) {
+    if (kind === 'rate') {
+      const numeratorKey = normalizeStr(primary.numeratorEventKey);
+      const denominatorKey = normalizeStr(primary.denominatorEventKey);
+
+      if (!numeratorKey || !denominatorKey) {
+        return { decided: false, reason: 'invalid_primary_rate_metric' };
+      }
+
+      const num = await computeTotalsForMetric({ experimentId: exp._id, variantKey, metricKey: numeratorKey, startAt: evalStart });
+      const den = await computeTotalsForMetric({ experimentId: exp._id, variantKey, metricKey: denominatorKey, startAt: evalStart });
+
+      const conversions = num.sum;
+      const exposures = den.sum;
+
+      const score = exposures > 0 ? conversions / exposures : 0;
+      scores.push({ variantKey, score, conversions, exposures });
+      continue;
+    }
+
+    const metricKey = normalizeStr(primary.key);
+    if (!metricKey) {
+      return { decided: false, reason: 'invalid_primary_metric' };
+    }
+
+    const totals = await computeTotalsForMetric({ experimentId: exp._id, variantKey, metricKey, startAt: evalStart });
+
+    let score = 0;
+    if (kind === 'count') score = totals.count;
+    else if (kind === 'sum') score = totals.sum;
+    else if (kind === 'avg') score = totals.count > 0 ? totals.sum / totals.count : 0;
+    else score = totals.sum;
+
+    scores.push({ variantKey, score, count: totals.count, sum: totals.sum });
+  }
+
+  const minAssignments = Number(exp.winnerPolicy?.minAssignments || 0) || 0;
+  const minExposures = Number(exp.winnerPolicy?.minExposures || 0) || 0;
+  const minConversions = Number(exp.winnerPolicy?.minConversions || 0) || 0;
+
+  if (kind === 'rate') {
+    const anyOk = scores.some((s) => (Number(s.exposures || 0) || 0) >= minExposures && (Number(s.conversions || 0) || 0) >= minConversions);
+    if (!anyOk) return { decided: false, reason: 'insufficient_data' };
+  }
+
+  if (minAssignments > 0) {
+    // Placeholder: assignment counts could be derived from assignments collection.
+    // We enforce it later once we implement an efficient counter.
+  }
+
+  const objective = normalizeStr(primary.objective) || 'maximize';
+  const sorted = [...scores].sort((a, b) => (objective === 'minimize' ? a.score - b.score : b.score - a.score));
+  const winner = sorted[0];
+  if (!winner) return { decided: false, reason: 'no_scores' };
+
+  const override = normalizeStr(exp.winnerPolicy?.overrideWinnerVariantKey);
+  const winnerKey = override || winner.variantKey;
+
+  exp.winnerVariantKey = winnerKey;
+  exp.winnerDecidedAt = new Date();
+  exp.winnerReason = override ? 'manual_override' : `auto:${kind}:${objective}`;
+  exp.status = 'completed';
+
+  await exp.save();
+
+  await experimentsService.clearExperimentCaches(exp._id);
+
+  broadcastWinnerChanged({
+    experimentId: String(exp._id),
+    experimentCode: exp.code,
+    organizationId: exp.organizationId ? String(exp.organizationId) : null,
+    winnerVariantKey: exp.winnerVariantKey,
+    decidedAt: exp.winnerDecidedAt,
+  });
+
+  if (exp.organizationId) {
+    webhookService.emit(
+      'experiment.winner_changed',
+      {
+        experimentId: String(exp._id),
+        code: exp.code,
+        winnerVariantKey: exp.winnerVariantKey,
+        decidedAt: exp.winnerDecidedAt,
+      },
+      String(exp.organizationId),
+    );
+  }
+
+  return { decided: true, reason: exp.winnerReason, winnerVariantKey: exp.winnerVariantKey, scores };
+}
+
+async function runAggregationAndWinner({ bucketMs, start, end } = {}) {
+  const now = new Date();
+  const bucket = Number(bucketMs || 0) || 3600000;
+
+  const startAt = start ? new Date(start) : new Date(now.getTime() - 6 * 60 * 60 * 1000);
+  const endAt = end ? new Date(end) : now;
+
+  const experiments = await Experiment.find({ status: { $in: ['running', 'completed'] } }).select('_id').lean();
+
+  const out = [];
+  for (const e of experiments || []) {
+    const res = await aggregateExperiment({ experimentId: e._id, bucketMs: bucket, start: startAt, end: endAt });
+    const win = await evaluateWinner({ experimentId: e._id }).catch((err) => ({ decided: false, reason: err.message }));
+    out.push({ experimentId: String(e._id), aggregated: res.aggregated, winner: win });
+  }
+
+  return { range: { start: startAt.toISOString(), end: endAt.toISOString() }, bucketMs: bucket, items: out };
+}
+
+module.exports = {
+  floorToBucket,
+  aggregateExperiment,
+  evaluateWinner,
+  runAggregationAndWinner,
+};