@omnizap-system/omnizap 2.5.12

package/app/modules/stickerPackModule/stickerDedicatedTaskWorkerRuntime.js

@@ -0,0 +1,249 @@
+import logger from '#logger';
+import { setQueueDepth } from '../../observability/metrics.js';
+import { isFeatureEnabled } from '../../services/infra/featureFlagService.js';
+import { runStickerClassificationCycle } from './stickerClassificationBackgroundRuntime.js';
+import { runStickerAutoPackByTagsCycle } from './stickerAutoPackByTagsRuntime.js';
+import { claimWorkerTask, completeWorkerTask, countWorkerTasksByStatus, failWorkerTask } from './stickerWorkerTaskQueueRepository.js';
+
+const parseEnvBool = (value, fallback) => {
+  if (value === undefined || value === null || value === '') return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+};
+
+const clampInt = (value, fallback, min, max) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(min, Math.min(max, Math.floor(numeric)));
+};
+
+const clampNumber = (value, fallback, min, max) => {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(min, Math.min(max, numeric));
+};
+
+const DEDICATED_WORKERS_ENABLED = parseEnvBool(process.env.STICKER_DEDICATED_WORKERS_ENABLED, true);
+const DEDICATED_WORKERS_FORCE_ENABLED = parseEnvBool(process.env.STICKER_DEDICATED_WORKERS_FORCE_ENABLED, false);
+const DEDICATED_WORKER_RETRY_DELAY_SECONDS = clampInt(process.env.STICKER_DEDICATED_WORKER_RETRY_DELAY_SECONDS, 60, 5, 3600);
+const DEDICATED_WORKER_POLL_INTERVAL_MS = clampInt(process.env.STICKER_DEDICATED_WORKER_POLL_INTERVAL_MS, 2500, 250, 60_000);
+const DEDICATED_WORKER_MAX_TASKS_PER_TICK = clampInt(process.env.STICKER_DEDICATED_WORKER_MAX_TASKS_PER_TICK, 1, 1, 25);
+const DEDICATED_WORKER_IDLE_BACKOFF_MULTIPLIER = clampNumber(process.env.STICKER_DEDICATED_WORKER_IDLE_BACKOFF_MULTIPLIER, 1.7, 1, 5);
+const DEDICATED_WORKER_IDLE_MAX_POLL_INTERVAL_MS = clampInt(process.env.STICKER_DEDICATED_WORKER_IDLE_MAX_POLL_INTERVAL_MS, Math.max(30_000, DEDICATED_WORKER_POLL_INTERVAL_MS * 8), 1_000, 300_000);
+const DEDICATED_WORKER_IDLE_JITTER_PERCENT = clampInt(process.env.STICKER_DEDICATED_WORKER_IDLE_JITTER_PERCENT, 12, 0, 60);
+const DEDICATED_WORKER_COHORT_KEY = String(process.env.STICKER_DEDICATED_WORKER_COHORT_KEY || process.env.HOSTNAME || process.pid).trim() || 'worker';
+
+const SUPPORTED_TASK_TYPES = new Set(['classification_cycle', 'curation_cycle', 'rebuild_cycle']);
+
+const normalizeTaskType = (value) => {
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
+  return SUPPORTED_TASK_TYPES.has(normalized) ? normalized : null;
+};
+
+const runTaskHandler = async (taskType, payload = {}) => {
+  if (taskType === 'classification_cycle') {
+    return runStickerClassificationCycle({
+      processPending: true,
+      processReprocess: true,
+      processDeterministic: true,
+      ...payload,
+    });
+  }
+  if (taskType === 'curation_cycle') {
+    return runStickerAutoPackByTagsCycle({
+      enableAdditions: true,
+      enableRebuild: false,
+      ...payload,
+    });
+  }
+  if (taskType === 'rebuild_cycle') {
+    return runStickerAutoPackByTagsCycle({
+      enableAdditions: false,
+      enableRebuild: true,
+      ...payload,
+    });
+  }
+  throw new Error(`unsupported_task_type:${taskType}`);
+};
+
+const refreshQueueDepthMetrics = async () => {
+  const [pending, processing, failed] = await Promise.all([countWorkerTasksByStatus('pending'), countWorkerTasksByStatus('processing'), countWorkerTasksByStatus('failed')]);
+  setQueueDepth('sticker_worker_tasks_pending', pending);
+  setQueueDepth('sticker_worker_tasks_processing', processing);
+  setQueueDepth('sticker_worker_tasks_failed', failed);
+};
+
+const canRunDedicatedWorkers = async (taskType) => {
+  if (!DEDICATED_WORKERS_ENABLED) return false;
+  if (DEDICATED_WORKERS_FORCE_ENABLED) return true;
+  return isFeatureEnabled('enable_worker_dedicated_processes', {
+    fallback: false,
+    subjectKey: `worker:${taskType}:${DEDICATED_WORKER_COHORT_KEY}`,
+  });
+};
+
+export const isSupportedStickerWorkerTaskType = (taskType) => Boolean(normalizeTaskType(taskType));
+
+export const runDedicatedStickerWorkerTick = async ({ taskType, maxTasks = DEDICATED_WORKER_MAX_TASKS_PER_TICK, retryDelaySeconds = DEDICATED_WORKER_RETRY_DELAY_SECONDS } = {}) => {
+  const normalizedTaskType = normalizeTaskType(taskType);
+  if (!normalizedTaskType) {
+    return { executed: false, reason: 'invalid_task_type', task_type: taskType || null };
+  }
+
+  const enabled = await canRunDedicatedWorkers(normalizedTaskType);
+  if (!enabled) {
+    return { executed: false, reason: 'feature_disabled', task_type: normalizedTaskType };
+  }
+
+  const safeMaxTasks = clampInt(maxTasks, DEDICATED_WORKER_MAX_TASKS_PER_TICK, 1, 25);
+  const stats = {
+    executed: true,
+    task_type: normalizedTaskType,
+    claimed: 0,
+    completed: 0,
+    failed: 0,
+  };
+
+  for (let i = 0; i < safeMaxTasks; i += 1) {
+    const task = await claimWorkerTask({ taskType: normalizedTaskType });
+    if (!task) break;
+
+    stats.claimed += 1;
+
+    try {
+      await runTaskHandler(normalizedTaskType, task.payload || {});
+      await completeWorkerTask(task.id);
+      stats.completed += 1;
+    } catch (error) {
+      stats.failed += 1;
+      await failWorkerTask(task.id, {
+        error: error?.message || 'dedicated_worker_task_failed',
+        retryDelaySeconds,
+      });
+
+      logger.warn('Task falhou no worker dedicado.', {
+        action: 'sticker_dedicated_worker_task_failed',
+        task_type: normalizedTaskType,
+        task_id: task.id,
+        attempts: task.attempts,
+        error: error?.message,
+      });
+    }
+  }
+
+  if (stats.claimed > 0) {
+    await refreshQueueDepthMetrics().catch(() => null);
+  }
+
+  return stats;
+};
+
+const applyDelayJitter = (delayMs, jitterPercent) => {
+  const baseDelay = Math.max(250, Math.floor(Number(delayMs) || 0));
+  const safeJitterPercent = clampInt(jitterPercent, DEDICATED_WORKER_IDLE_JITTER_PERCENT, 0, 60);
+  if (safeJitterPercent <= 0) return baseDelay;
+  const variation = (Math.random() * 2 - 1) * (safeJitterPercent / 100);
+  return Math.max(250, Math.floor(baseDelay * (1 + variation)));
+};
+
+export const startDedicatedStickerWorker = ({ taskType, pollIntervalMs = DEDICATED_WORKER_POLL_INTERVAL_MS, maxTasksPerTick = DEDICATED_WORKER_MAX_TASKS_PER_TICK, retryDelaySeconds = DEDICATED_WORKER_RETRY_DELAY_SECONDS, idleBackoffMultiplier = DEDICATED_WORKER_IDLE_BACKOFF_MULTIPLIER, idleMaxPollIntervalMs = DEDICATED_WORKER_IDLE_MAX_POLL_INTERVAL_MS, idleJitterPercent = DEDICATED_WORKER_IDLE_JITTER_PERCENT, label = '' } = {}) => {
+  const normalizedTaskType = normalizeTaskType(taskType);
+  if (!normalizedTaskType) {
+    throw new Error(`invalid_task_type:${taskType}`);
+  }
+
+  const safePollIntervalMs = clampInt(pollIntervalMs, DEDICATED_WORKER_POLL_INTERVAL_MS, 250, 60_000);
+  const safeIdleBackoffMultiplier = clampNumber(idleBackoffMultiplier, DEDICATED_WORKER_IDLE_BACKOFF_MULTIPLIER, 1, 5);
+  const safeIdleMaxPollIntervalMs = clampInt(idleMaxPollIntervalMs, Math.max(DEDICATED_WORKER_IDLE_MAX_POLL_INTERVAL_MS, safePollIntervalMs), safePollIntervalMs, 300_000);
+  const safeIdleJitterPercent = clampInt(idleJitterPercent, DEDICATED_WORKER_IDLE_JITTER_PERCENT, 0, 60);
+  let tickInFlight = false;
+  let stopped = false;
+  let tickHandle = null;
+  let nextDelayMs = safePollIntervalMs;
+
+  const scheduleNextTick = (delayMs = safePollIntervalMs) => {
+    if (stopped) return;
+    if (tickHandle) {
+      clearTimeout(tickHandle);
+      tickHandle = null;
+    }
+
+    const effectiveDelayMs = applyDelayJitter(delayMs, safeIdleJitterPercent);
+    tickHandle = setTimeout(() => {
+      tickHandle = null;
+      void runTick();
+    }, effectiveDelayMs);
+
+    if (typeof tickHandle?.unref === 'function') {
+      tickHandle.unref();
+    }
+  };
+
+  const runTick = async () => {
+    if (stopped || tickInFlight) return;
+    tickInFlight = true;
+    let tickResult = null;
+    try {
+      tickResult = await runDedicatedStickerWorkerTick({
+        taskType: normalizedTaskType,
+        maxTasks: maxTasksPerTick,
+        retryDelaySeconds,
+      });
+    } catch (error) {
+      if (error?.code !== 'ER_NO_SUCH_TABLE') {
+        logger.error('Falha no worker dedicado de sticker.', {
+          action: 'sticker_dedicated_worker_tick_failed',
+          task_type: normalizedTaskType,
+          error: error?.message,
+        });
+      }
+    } finally {
+      tickInFlight = false;
+    }
+
+    if (stopped) return;
+
+    const claimedTasks = Number(tickResult?.claimed || 0);
+    if (claimedTasks > 0) {
+      nextDelayMs = safePollIntervalMs;
+    } else {
+      nextDelayMs = Math.min(safeIdleMaxPollIntervalMs, Math.max(safePollIntervalMs, Math.floor(nextDelayMs * safeIdleBackoffMultiplier)));
+    }
+
+    scheduleNextTick(nextDelayMs);
+  };
+
+  void runTick();
+
+  logger.info('Worker dedicado de sticker iniciado.', {
+    action: 'sticker_dedicated_worker_started',
+    task_type: normalizedTaskType,
+    poll_interval_ms: safePollIntervalMs,
+    idle_backoff_multiplier: safeIdleBackoffMultiplier,
+    idle_max_poll_interval_ms: safeIdleMaxPollIntervalMs,
+    idle_jitter_percent: safeIdleJitterPercent,
+    max_tasks_per_tick: maxTasksPerTick,
+    label: label || null,
+  });
+
+  return {
+    taskType: normalizedTaskType,
+    stop: () => {
+      if (stopped) return;
+      stopped = true;
+      if (tickHandle) {
+        clearTimeout(tickHandle);
+        tickHandle = null;
+      }
+      logger.info('Worker dedicado de sticker encerrado.', {
+        action: 'sticker_dedicated_worker_stopped',
+        task_type: normalizedTaskType,
+        label: label || null,
+      });
+    },
+  };
+};

package/app/modules/stickerPackModule/stickerDomainEventBus.js

@@ -0,0 +1,65 @@
+import logger from '#logger';
+import { isFeatureEnabled } from '../../services/infra/featureFlagService.js';
+import { enqueueDomainEvent } from './domainEventOutboxRepository.js';
+
+const resolveDefaultIdempotencyKey = ({ eventType, aggregateType, aggregateId, payload = null }) => {
+  const payloadKey = payload && typeof payload === 'object' ? JSON.stringify(payload).slice(0, 80) : '';
+  return `${eventType}:${aggregateType}:${aggregateId}:${payloadKey}`.slice(0, 180);
+};
+
+export const publishStickerDomainEvent = async (eventPayload, { connection = null, force = false } = {}) => {
+  const eventType = String(eventPayload?.eventType || '').trim();
+  const aggregateType = String(eventPayload?.aggregateType || '').trim();
+  const aggregateId = String(eventPayload?.aggregateId || '').trim();
+
+  if (!eventType || !aggregateType || !aggregateId) return false;
+
+  const enabled = force
+    ? true
+    : await isFeatureEnabled('enable_domain_event_outbox', {
+        fallback: true,
+        subjectKey: `${aggregateType}:${aggregateId}`,
+      });
+  if (!enabled) return false;
+
+  try {
+    const idempotencyKey =
+      String(eventPayload?.idempotencyKey || '').trim() ||
+      resolveDefaultIdempotencyKey({
+        eventType,
+        aggregateType,
+        aggregateId,
+        payload: eventPayload?.payload || null,
+      });
+
+    return await enqueueDomainEvent(
+      {
+        eventType,
+        aggregateType,
+        aggregateId,
+        payload: eventPayload?.payload || null,
+        priority: eventPayload?.priority ?? 50,
+        availableAt: eventPayload?.availableAt || null,
+        maxAttempts: eventPayload?.maxAttempts ?? 10,
+        idempotencyKey,
+      },
+      connection,
+    );
+  } catch (error) {
+    if (error?.code === 'ER_NO_SUCH_TABLE') {
+      logger.warn('Outbox indisponível; evento de domínio descartado.', {
+        action: 'sticker_domain_event_outbox_unavailable',
+        event_type: eventType,
+      });
+      return false;
+    }
+    logger.warn('Falha ao publicar evento de domínio.', {
+      action: 'sticker_domain_event_publish_failed',
+      event_type: eventType,
+      aggregate_type: aggregateType,
+      aggregate_id: aggregateId,
+      error: error?.message,
+    });
+    return false;
+  }
+};

package/app/modules/stickerPackModule/stickerDomainEventConsumerRuntime.js

@@ -0,0 +1,208 @@
+import logger from '#logger';
+import { setQueueDepth } from '../../observability/metrics.js';
+import { isFeatureEnabled } from '../../services/infra/featureFlagService.js';
+import { claimDomainEvent, completeDomainEvent, countDomainEventsByStatus, failDomainEvent } from './domainEventOutboxRepository.js';
+import { STICKER_DOMAIN_EVENTS } from './domainEvents.js';
+import { enqueueWorkerTask } from './stickerWorkerTaskQueueRepository.js';
+import { enqueuePackScoreSnapshotRefresh } from './stickerPackScoreSnapshotRuntime.js';
+import { listPackIdsByStickerId } from './stickerPackItemRepository.js';
+
+const parseEnvBool = (value, fallback) => {
+  if (value === undefined || value === null || value === '') return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+};
+
+const CONSUMER_ENABLED = parseEnvBool(process.env.STICKER_DOMAIN_EVENT_CONSUMER_ENABLED, true);
+const STARTUP_DELAY_MS = Math.max(1_000, Number(process.env.STICKER_DOMAIN_EVENT_CONSUMER_STARTUP_DELAY_MS) || 8_000);
+const POLLER_INTERVAL_MS = Math.max(1_000, Number(process.env.STICKER_DOMAIN_EVENT_CONSUMER_POLLER_INTERVAL_MS) || 2_000);
+const RETRY_DELAY_SECONDS = Math.max(5, Math.min(3600, Number(process.env.STICKER_DOMAIN_EVENT_CONSUMER_RETRY_DELAY_SECONDS) || 45));
+const CLASSIFICATION_COALESCE_WINDOW_SECONDS = Math.max(30, Math.min(3600, Number(process.env.STICKER_DOMAIN_EVENT_CLASSIFICATION_COALESCE_WINDOW_SECONDS) || 60));
+const CURATION_COALESCE_WINDOW_SECONDS = Math.max(30, Math.min(3600, Number(process.env.STICKER_DOMAIN_EVENT_CURATION_COALESCE_WINDOW_SECONDS) || 60));
+const REBUILD_COALESCE_WINDOW_SECONDS = Math.max(30, Math.min(3600, Number(process.env.STICKER_DOMAIN_EVENT_REBUILD_COALESCE_WINDOW_SECONDS) || 120));
+const CONSUMER_COHORT_KEY = String(process.env.STICKER_DOMAIN_EVENT_CONSUMER_COHORT_KEY || process.env.HOSTNAME || process.pid).trim() || 'consumer';
+
+let startupHandle = null;
+let pollerHandle = null;
+let running = false;
+
+const refreshOutboxDepthMetrics = async () => {
+  const [pending, processing, failed] = await Promise.all([countDomainEventsByStatus('pending'), countDomainEventsByStatus('processing'), countDomainEventsByStatus('failed')]);
+  setQueueDepth('domain_event_outbox_pending', pending);
+  setQueueDepth('domain_event_outbox_processing', processing);
+  setQueueDepth('domain_event_outbox_failed', failed);
+};
+
+const canRunConsumer = async () =>
+  isFeatureEnabled('enable_domain_event_outbox', {
+    fallback: true,
+    subjectKey: `domain_event_consumer:${CONSUMER_COHORT_KEY}`,
+  });
+
+const enqueueTaskSafely = async ({ taskType, payload, priority, idempotencyKey }) => {
+  await enqueueWorkerTask({
+    taskType,
+    payload,
+    priority,
+    idempotencyKey,
+  });
+};
+
+const toUnixSeconds = (value) => {
+  if (!value) return Math.floor(Date.now() / 1000);
+  const numeric = Date.parse(value);
+  if (!Number.isFinite(numeric)) return Math.floor(Date.now() / 1000);
+  return Math.floor(numeric / 1000);
+};
+
+const toWindowBucket = (value, windowSeconds) => {
+  const safeWindow = Math.max(1, Math.floor(windowSeconds || 1));
+  return Math.floor(toUnixSeconds(value) / safeWindow);
+};
+
+const handleDomainEvent = async (event) => {
+  const eventType = String(event?.event_type || '')
+    .trim()
+    .toUpperCase();
+  const aggregateId = String(event?.aggregate_id || '').trim();
+  const payload = event?.payload && typeof event.payload === 'object' ? event.payload : {};
+
+  if (eventType === STICKER_DOMAIN_EVENTS.STICKER_ASSET_CREATED) {
+    const coalesceBucket = toWindowBucket(event?.created_at, CLASSIFICATION_COALESCE_WINDOW_SECONDS);
+    await enqueueTaskSafely({
+      taskType: 'classification_cycle',
+      payload: {
+        reason: 'domain_event',
+        event_type: eventType,
+        aggregate_id: aggregateId,
+        coalesced: true,
+      },
+      priority: 80,
+      idempotencyKey: `evt:${eventType}:${coalesceBucket}:classification_cycle`,
+    });
+    return;
+  }
+
+  if (eventType === STICKER_DOMAIN_EVENTS.STICKER_CLASSIFIED) {
+    const coalesceBucket = toWindowBucket(event?.created_at, CURATION_COALESCE_WINDOW_SECONDS);
+    const assetId = String(payload?.asset_id || aggregateId || '').trim();
+    const relatedPackIds = assetId ? await listPackIdsByStickerId(assetId).catch(() => []) : [];
+    if (relatedPackIds.length) {
+      enqueuePackScoreSnapshotRefresh(relatedPackIds);
+    }
+    await enqueueTaskSafely({
+      taskType: 'curation_cycle',
+      payload: {
+        reason: 'domain_event',
+        event_type: eventType,
+        aggregate_id: aggregateId,
+        related_pack_ids: relatedPackIds,
+        coalesced: true,
+      },
+      priority: 65,
+      idempotencyKey: `evt:${eventType}:${coalesceBucket}:curation_cycle`,
+    });
+    return;
+  }
+
+  if (eventType === STICKER_DOMAIN_EVENTS.PACK_UPDATED) {
+    const coalesceBucket = toWindowBucket(event?.created_at, REBUILD_COALESCE_WINDOW_SECONDS);
+    const packId = String(payload?.pack_id || aggregateId || '').trim();
+    if (packId) {
+      enqueuePackScoreSnapshotRefresh([packId]);
+    }
+    const rebuildIdempotency = packId ? `evt:${eventType}:${packId}:${coalesceBucket}:rebuild_cycle` : `evt:${eventType}:${coalesceBucket}:rebuild_cycle`;
+    await enqueueTaskSafely({
+      taskType: 'rebuild_cycle',
+      payload: {
+        reason: 'domain_event',
+        event_type: eventType,
+        aggregate_id: aggregateId,
+        pack_id: packId || null,
+        coalesced: true,
+      },
+      priority: 60,
+      idempotencyKey: rebuildIdempotency,
+    });
+    return;
+  }
+
+  if (eventType === STICKER_DOMAIN_EVENTS.ENGAGEMENT_RECORDED) {
+    const packId = String(payload?.pack_id || aggregateId || '').trim();
+    if (packId) {
+      enqueuePackScoreSnapshotRefresh([packId]);
+    }
+    return;
+  }
+};
+
+const pollOnce = async () => {
+  if (running || !CONSUMER_ENABLED) return;
+  running = true;
+  try {
+    if (!(await canRunConsumer())) return;
+
+    const event = await claimDomainEvent();
+    if (!event) {
+      await refreshOutboxDepthMetrics();
+      return;
+    }
+
+    try {
+      await handleDomainEvent(event);
+      await completeDomainEvent(event.id);
+    } catch (error) {
+      await failDomainEvent(event.id, {
+        error: error?.message || 'domain_event_consumer_failed',
+        retryDelaySeconds: RETRY_DELAY_SECONDS,
+      });
+      logger.warn('Evento de domínio falhou no consumidor interno.', {
+        action: 'sticker_domain_event_consumer_event_failed',
+        event_id: event.id,
+        event_type: event.event_type,
+        aggregate_type: event.aggregate_type,
+        aggregate_id: event.aggregate_id,
+        error: error?.message,
+      });
+    }
+
+    await refreshOutboxDepthMetrics();
+  } catch (error) {
+    if (error?.code !== 'ER_NO_SUCH_TABLE') {
+      logger.error('Falha no poller do consumidor de eventos de domínio.', {
+        action: 'sticker_domain_event_consumer_poll_failed',
+        error: error?.message,
+      });
+    }
+  } finally {
+    running = false;
+  }
+};
+
+export const startStickerDomainEventConsumer = () => {
+  if (!CONSUMER_ENABLED) return;
+  if (startupHandle || pollerHandle) return;
+
+  startupHandle = setTimeout(() => {
+    startupHandle = null;
+    void pollOnce();
+    pollerHandle = setInterval(() => {
+      void pollOnce();
+    }, POLLER_INTERVAL_MS);
+    if (typeof pollerHandle?.unref === 'function') pollerHandle.unref();
+  }, STARTUP_DELAY_MS);
+  if (typeof startupHandle?.unref === 'function') startupHandle.unref();
+};
+
+export const stopStickerDomainEventConsumer = () => {
+  if (startupHandle) {
+    clearTimeout(startupHandle);
+    startupHandle = null;
+  }
+  if (pollerHandle) {
+    clearInterval(pollerHandle);
+    pollerHandle = null;
+  }
+};

package/app/modules/stickerPackModule/stickerMarketplaceDriftService.js

@@ -0,0 +1,99 @@
+import { listClassificationCategoryDistribution } from './stickerAssetClassificationRepository.js';
+
+const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+
+const REFRESH_MS = Math.max(30_000, Number(process.env.STICKER_DRIFT_REFRESH_MS) || 10 * 60 * 1000);
+const DIVERGENCE_SENSITIVITY = clamp(Number(process.env.STICKER_DRIFT_SENSITIVITY || 1), 0.5, 2.5);
+
+const BASE_WEIGHTS = Object.freeze({
+  classification: 0.4,
+  engagement: 0.3,
+  quality: 0.2,
+  diversity: 0.1,
+});
+
+let cache = {
+  expiresAt: 0,
+  weights: BASE_WEIGHTS,
+  driftScore: 0,
+  distribution7d: {},
+  distribution30d: {},
+};
+
+const toProbabilityMap = (distribution) => {
+  const total = Number(distribution?.total || 0);
+  const categories = distribution?.categories instanceof Map ? distribution.categories : new Map();
+  const map = new Map();
+  if (!total || categories.size === 0) return map;
+
+  for (const [category, count] of categories.entries()) {
+    const probability = Number(count) / total;
+    if (probability > 0) {
+      map.set(category, probability);
+    }
+  }
+  return map;
+};
+
+const computeL1Divergence = (left, right) => {
+  const keys = new Set([...left.keys(), ...right.keys()]);
+  if (!keys.size) return 0;
+
+  let sumAbs = 0;
+  for (const key of keys) {
+    sumAbs += Math.abs((left.get(key) || 0) - (right.get(key) || 0));
+  }
+
+  return clamp(sumAbs / 2, 0, 1);
+};
+
+const normalizeWeights = (weights) => {
+  const total = Object.values(weights).reduce((sum, value) => sum + value, 0);
+  if (!total || !Number.isFinite(total)) return BASE_WEIGHTS;
+  return {
+    classification: Number((weights.classification / total).toFixed(6)),
+    engagement: Number((weights.engagement / total).toFixed(6)),
+    quality: Number((weights.quality / total).toFixed(6)),
+    diversity: Number((weights.diversity / total).toFixed(6)),
+  };
+};
+
+const buildDynamicWeights = (driftScore) => {
+  const adjustedDrift = clamp(driftScore * DIVERGENCE_SENSITIVITY, 0, 1);
+  const classificationShift = clamp(BASE_WEIGHTS.classification - adjustedDrift * 0.1, 0.25, 0.45);
+  const engagementShift = clamp(BASE_WEIGHTS.engagement + adjustedDrift * 0.08, 0.25, 0.42);
+  const qualityShift = clamp(BASE_WEIGHTS.quality + adjustedDrift * 0.01, 0.15, 0.3);
+  const diversityShift = clamp(BASE_WEIGHTS.diversity + adjustedDrift * 0.01, 0.08, 0.2);
+  return normalizeWeights({
+    classification: classificationShift,
+    engagement: engagementShift,
+    quality: qualityShift,
+    diversity: diversityShift,
+  });
+};
+
+export const getBaseMarketplaceWeights = () => BASE_WEIGHTS;
+
+export const getMarketplaceDriftSnapshot = async ({ force = false } = {}) => {
+  const now = Date.now();
+  if (!force && now < cache.expiresAt) {
+    return cache;
+  }
+
+  const [distribution7d, distribution30d] = await Promise.all([listClassificationCategoryDistribution({ days: 7 }), listClassificationCategoryDistribution({ days: 30 })]);
+
+  const probability7d = toProbabilityMap(distribution7d);
+  const probability30d = toProbabilityMap(distribution30d);
+  const driftScore = Number(computeL1Divergence(probability7d, probability30d).toFixed(6));
+  const weights = buildDynamicWeights(driftScore);
+
+  cache = {
+    expiresAt: now + REFRESH_MS,
+    weights,
+    driftScore,
+    distribution7d: Object.fromEntries(probability7d.entries()),
+    distribution30d: Object.fromEntries(probability30d.entries()),
+  };
+
+  return cache;
+};