@momentumcms/plugins-analytics 0.1.0 → 0.1.2

package/index.js

@@ -0,0 +1,2195 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// libs/plugins/analytics/src/lib/client/block-tracker.ts
+var block_tracker_exports = {};
+__export(block_tracker_exports, {
+  attachBlockTracking: () => attachBlockTracking
+});
+function attachBlockTracking(tracker, container) {
+  const root = container ?? document.body;
+  const impressionsSeen = /* @__PURE__ */ new Set();
+  const hoverCooldowns = /* @__PURE__ */ new Map();
+  const HOVER_COOLDOWN_MS = 5e3;
+  let observer = null;
+  function handleIntersection(entries) {
+    for (const entry of entries) {
+      if (!entry.isIntersecting)
+        continue;
+      if (!(entry.target instanceof HTMLElement))
+        continue;
+      const el = entry.target;
+      const blockType = el.dataset["blockType"];
+      const blockIndex = el.dataset["blockIndex"];
+      if (!blockType)
+        continue;
+      const key = `${blockType}:${blockIndex ?? "?"}`;
+      if (impressionsSeen.has(key))
+        continue;
+      impressionsSeen.add(key);
+      tracker.track("block_impression", {
+        blockType,
+        blockIndex: blockIndex ? Number(blockIndex) : void 0
+      });
+    }
+  }
+  observer = new IntersectionObserver(handleIntersection, {
+    threshold: 0.5
+  });
+  const tracked = Array.from(root.querySelectorAll("[data-block-track]"));
+  for (const el of tracked) {
+    const trackValue = el.dataset["blockTrack"] ?? "";
+    if (trackValue.includes("impressions")) {
+      observer.observe(el);
+    }
+  }
+  function handleHover(event) {
+    const target = event.target;
+    if (!(target instanceof HTMLElement))
+      return;
+    const blockEl = target.closest("[data-block-track]");
+    if (!blockEl)
+      return;
+    const trackValue = blockEl.dataset["blockTrack"] ?? "";
+    if (!trackValue.includes("hover"))
+      return;
+    const blockType = blockEl.dataset["blockType"];
+    const blockIndex = blockEl.dataset["blockIndex"];
+    if (!blockType)
+      return;
+    const key = `${blockType}:${blockIndex ?? "?"}`;
+    const now = Date.now();
+    const lastFired = hoverCooldowns.get(key);
+    if (lastFired !== void 0 && now - lastFired < HOVER_COOLDOWN_MS)
+      return;
+    hoverCooldowns.set(key, now);
+    tracker.track("block_hover", {
+      blockType,
+      blockIndex: blockIndex ? Number(blockIndex) : void 0
+    });
+  }
+  root.addEventListener("mouseenter", handleHover, true);
+  return () => {
+    observer?.disconnect();
+    observer = null;
+    root.removeEventListener("mouseenter", handleHover, true);
+    impressionsSeen.clear();
+    hoverCooldowns.clear();
+  };
+}
+var init_block_tracker = __esm({
+  "libs/plugins/analytics/src/lib/client/block-tracker.ts"() {
+    "use strict";
+  }
+});
+
+// libs/plugins/analytics/src/lib/utils/type-guards.ts
+function isRecord(val) {
+  return val != null && typeof val === "object" && !Array.isArray(val);
+}
+var init_type_guards = __esm({
+  "libs/plugins/analytics/src/lib/utils/type-guards.ts"() {
+    "use strict";
+  }
+});
+
+// libs/plugins/analytics/src/lib/utils/selector-security.ts
+function normalizeCssEscapes(selector) {
+  return selector.replace(
+    /\\([0-9a-fA-F]{1,6})\s?/g,
+    (_, hex) => String.fromCodePoint(parseInt(hex, 16))
+  ).replace(/\\([^0-9a-fA-F\n])/g, "$1");
+}
+function stripPseudoWrappers(selector) {
+  return selector.replace(/:(is|where|not|has|matches)\s*\(/gi, "(");
+}
+function isSelectorBlocked(selector) {
+  const normalized = stripPseudoWrappers(normalizeCssEscapes(selector));
+  return BLOCKED_SELECTOR_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+var BLOCKED_SELECTOR_PATTERNS;
+var init_selector_security = __esm({
+  "libs/plugins/analytics/src/lib/utils/selector-security.ts"() {
+    "use strict";
+    BLOCKED_SELECTOR_PATTERNS = [
+      /type\s*=\s*["']?password/i,
+      /type\s*=\s*["']?hidden/i,
+      /autocomplete\s*=\s*["']?cc-/i,
+      /autocomplete\s*=\s*["']?current-password/i,
+      /autocomplete\s*=\s*["']?new-password/i
+    ];
+  }
+});
+
+// libs/plugins/analytics/src/lib/client/rule-engine.ts
+var rule_engine_exports = {};
+__export(rule_engine_exports, {
+  createRuleEngine: () => createRuleEngine,
+  matchUrlPattern: () => matchUrlPattern,
+  parseRulesResponse: () => parseRulesResponse
+});
+function matchUrlPattern(pattern, pathname) {
+  if (pattern === "*")
+    return true;
+  const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0GLOBSTAR\0").replace(/\*/g, "[^/]*").replace(/\0GLOBSTAR\0/g, ".*");
+  return new RegExp(`^${escaped}$`).test(pathname);
+}
+function parseRulesResponse(data) {
+  if (!isRecord(data) || !Array.isArray(data["rules"]))
+    return [];
+  const result = [];
+  for (const item of data["rules"]) {
+    if (!isRecord(item))
+      continue;
+    if (typeof item["selector"] !== "string" || typeof item["eventName"] !== "string")
+      continue;
+    if (isSelectorBlocked(item["selector"]))
+      continue;
+    result.push({
+      name: typeof item["name"] === "string" ? item["name"] : "",
+      selector: item["selector"],
+      eventType: typeof item["eventType"] === "string" ? item["eventType"] : "click",
+      eventName: item["eventName"],
+      urlPattern: typeof item["urlPattern"] === "string" ? item["urlPattern"] : "*",
+      properties: isRecord(item["properties"]) ? item["properties"] : {},
+      extractProperties: Array.isArray(item["extractProperties"]) ? item["extractProperties"] : void 0,
+      active: item["active"] === true,
+      rateLimit: typeof item["rateLimit"] === "number" ? item["rateLimit"] : void 0
+    });
+  }
+  return result;
+}
+function truncate(val, max) {
+  return val.length > max ? val.slice(0, max) : val;
+}
+function extractProperties(el, rule) {
+  const props = { ...rule.properties };
+  if (!Array.isArray(rule.extractProperties))
+    return props;
+  for (const raw of rule.extractProperties) {
+    if (!isRecord(raw))
+      continue;
+    const key = typeof raw["key"] === "string" ? raw["key"] : null;
+    const source = typeof raw["source"] === "string" ? raw["source"] : null;
+    if (!key || !source)
+      continue;
+    const rawMaxLen = typeof raw["maxLength"] === "number" ? raw["maxLength"] : MAX_EXTRACT_LENGTH;
+    const maxLen = Math.min(rawMaxLen, MAX_EXTRACT_LENGTH);
+    switch (source) {
+      case "text":
+        props[key] = truncate(el.textContent?.trim() ?? "", maxLen);
+        break;
+      case "attribute": {
+        const attr = typeof raw["attribute"] === "string" ? raw["attribute"] : "";
+        if (BLOCKED_ATTRIBUTES.has(attr.toLowerCase()))
+          break;
+        props[key] = truncate(el.getAttribute(attr) ?? "", maxLen);
+        break;
+      }
+      case "dataset": {
+        const dsKey = typeof raw["attribute"] === "string" ? raw["attribute"] : "";
+        props[key] = truncate(el.dataset[dsKey] ?? "", maxLen);
+        break;
+      }
+    }
+  }
+  return props;
+}
+function createRuleEngine(tracker, config = {}) {
+  const endpoint = config.endpoint ?? "/api/analytics/tracking-rules";
+  let rules = [];
+  let activeCleanups = [];
+  let running = false;
+  let navigationCleanup = null;
+  const rateLimits = /* @__PURE__ */ new Map();
+  function checkRateLimit(rule) {
+    if (!rule.rateLimit)
+      return true;
+    const now = Date.now();
+    const state = rateLimits.get(rule.eventName);
+    if (!state || now >= state.resetAt) {
+      rateLimits.set(rule.eventName, { count: 1, resetAt: now + 6e4 });
+      return true;
+    }
+    if (state.count >= rule.rateLimit)
+      return false;
+    state.count++;
+    return true;
+  }
+  function fireRule(rule, el) {
+    if (!checkRateLimit(rule))
+      return;
+    tracker.track(rule.eventName, extractProperties(el, rule));
+  }
+  function attachRulesForUrl(url) {
+    for (const cleanup of activeCleanups)
+      cleanup();
+    activeCleanups = [];
+    const pathname = url.startsWith("http") ? new URL(url).pathname : url;
+    const matching = rules.filter((r) => r.active && matchUrlPattern(r.urlPattern, pathname));
+    if (matching.length === 0)
+      return;
+    const delegatedTypes = [
+      { eventType: "click", domEvent: "click", capture: false },
+      { eventType: "submit", domEvent: "submit", capture: true },
+      { eventType: "hover", domEvent: "mouseenter", capture: true },
+      { eventType: "focus", domEvent: "focusin", capture: false }
+    ];
+    for (const { eventType, domEvent, capture } of delegatedTypes) {
+      const typeRules = matching.filter((r) => r.eventType === eventType);
+      if (typeRules.length === 0)
+        continue;
+      const handler = (e) => {
+        const target = e.target;
+        if (!(target instanceof HTMLElement))
+          return;
+        for (const rule of typeRules) {
+          try {
+            const matched = target.closest(rule.selector);
+            if (matched instanceof HTMLElement) {
+              fireRule(rule, matched);
+            }
+          } catch {
+          }
+        }
+      };
+      document.body.addEventListener(domEvent, handler, capture);
+      activeCleanups.push(() => document.body.removeEventListener(domEvent, handler, capture));
+    }
+    const scrollRules = matching.filter((r) => r.eventType === "scroll-into-view");
+    if (scrollRules.length > 0) {
+      const seen = /* @__PURE__ */ new Set();
+      const observer = new IntersectionObserver(
+        (entries) => {
+          for (const entry of entries) {
+            if (!entry.isIntersecting)
+              continue;
+            const el = entry.target;
+            if (!(el instanceof HTMLElement))
+              continue;
+            for (const rule of scrollRules) {
+              try {
+                if (!el.matches(rule.selector))
+                  continue;
+              } catch {
+                continue;
+              }
+              const key = `${rule.eventName}:${rule.selector}`;
+              if (seen.has(key))
+                continue;
+              seen.add(key);
+              fireRule(rule, el);
+              observer.unobserve(el);
+            }
+          }
+        },
+        { threshold: 0.5 }
+      );
+      for (const rule of scrollRules) {
+        try {
+          const elements = Array.from(document.querySelectorAll(rule.selector));
+          for (const el of elements)
+            observer.observe(el);
+        } catch {
+        }
+      }
+      activeCleanups.push(() => observer.disconnect());
+    }
+  }
+  function setupNavigationDetection() {
+    const cleanups = [];
+    const popstateHandler = () => {
+      if (running)
+        attachRulesForUrl(location.pathname);
+    };
+    window.addEventListener("popstate", popstateHandler);
+    cleanups.push(() => window.removeEventListener("popstate", popstateHandler));
+    const originalPushState = history.pushState.bind(history);
+    const originalReplaceState = history.replaceState.bind(history);
+    history.pushState = function(...args) {
+      originalPushState(...args);
+      if (running)
+        attachRulesForUrl(location.pathname);
+    };
+    history.replaceState = function(...args) {
+      originalReplaceState(...args);
+      if (running)
+        attachRulesForUrl(location.pathname);
+    };
+    cleanups.push(() => {
+      history.pushState = originalPushState;
+      history.replaceState = originalReplaceState;
+    });
+    return () => {
+      for (const fn of cleanups)
+        fn();
+    };
+  }
+  return {
+    async start() {
+      try {
+        const res = await fetch(endpoint);
+        if (!res.ok)
+          return;
+        const data = await res.json();
+        rules = parseRulesResponse(data);
+      } catch {
+        return;
+      }
+      if (rules.length === 0)
+        return;
+      running = true;
+      attachRulesForUrl(location.pathname);
+      navigationCleanup = setupNavigationDetection();
+    },
+    stop() {
+      running = false;
+      for (const cleanup of activeCleanups)
+        cleanup();
+      activeCleanups = [];
+      navigationCleanup?.();
+      navigationCleanup = null;
+      rateLimits.clear();
+    },
+    onNavigate(url) {
+      if (running)
+        attachRulesForUrl(url);
+    }
+  };
+}
+var BLOCKED_ATTRIBUTES, MAX_EXTRACT_LENGTH;
+var init_rule_engine = __esm({
+  "libs/plugins/analytics/src/lib/client/rule-engine.ts"() {
+    "use strict";
+    init_type_guards();
+    init_selector_security();
+    BLOCKED_ATTRIBUTES = /* @__PURE__ */ new Set(["value", "password", "autocomplete", "autofill"]);
+    MAX_EXTRACT_LENGTH = 200;
+  }
+});
+
+// libs/logger/src/lib/log-level.ts
+var LOG_LEVEL_VALUES = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3,
+  fatal: 4,
+  silent: 5
+};
+function shouldLog(messageLevel, configuredLevel) {
+  return LOG_LEVEL_VALUES[messageLevel] >= LOG_LEVEL_VALUES[configuredLevel];
+}
+
+// libs/logger/src/lib/ansi-colors.ts
+var ANSI = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  // Foreground colors
+  red: "\x1B[31m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  blue: "\x1B[34m",
+  magenta: "\x1B[35m",
+  cyan: "\x1B[36m",
+  white: "\x1B[37m",
+  gray: "\x1B[90m",
+  // Background colors
+  bgRed: "\x1B[41m",
+  bgYellow: "\x1B[43m"
+};
+function colorize(text2, ...codes) {
+  if (codes.length === 0)
+    return text2;
+  return `${codes.join("")}${text2}${ANSI.reset}`;
+}
+function supportsColor() {
+  if (process.env["FORCE_COLOR"] === "1")
+    return true;
+  if (process.env["NO_COLOR"] !== void 0)
+    return false;
+  if (process.env["TERM"] === "dumb")
+    return false;
+  return process.stdout.isTTY === true;
+}
+
+// libs/logger/src/lib/formatters.ts
+var LEVEL_COLORS = {
+  debug: [ANSI.dim, ANSI.gray],
+  info: [ANSI.cyan],
+  warn: [ANSI.yellow],
+  error: [ANSI.red],
+  fatal: [ANSI.bold, ANSI.white, ANSI.bgRed]
+};
+function padLevel(level) {
+  return level.toUpperCase().padEnd(5);
+}
+function formatTimestamp(date2) {
+  const y = date2.getFullYear();
+  const mo = String(date2.getMonth() + 1).padStart(2, "0");
+  const d = String(date2.getDate()).padStart(2, "0");
+  const h = String(date2.getHours()).padStart(2, "0");
+  const mi = String(date2.getMinutes()).padStart(2, "0");
+  const s = String(date2.getSeconds()).padStart(2, "0");
+  const ms = String(date2.getMilliseconds()).padStart(3, "0");
+  return `${y}-${mo}-${d} ${h}:${mi}:${s}.${ms}`;
+}
+function formatData(data) {
+  const entries = Object.entries(data);
+  if (entries.length === 0)
+    return "";
+  return " " + entries.map(([k, v]) => `${k}=${typeof v === "string" ? v : JSON.stringify(v)}`).join(" ");
+}
+function prettyFormatter(entry) {
+  const useColor = supportsColor();
+  const level = entry.level;
+  const ts = formatTimestamp(entry.timestamp);
+  const levelStr = padLevel(entry.level);
+  const ctx = `[${entry.context}]`;
+  const msg = entry.message;
+  const enrichmentStr = entry.enrichments ? formatData(entry.enrichments) : "";
+  const dataStr = entry.data ? formatData(entry.data) : "";
+  const extra = `${enrichmentStr}${dataStr}`;
+  if (useColor) {
+    const colors = LEVEL_COLORS[level];
+    const coloredLevel = colorize(levelStr, ...colors);
+    const coloredCtx = colorize(ctx, ANSI.magenta);
+    const coloredTs = colorize(ts, ANSI.gray);
+    return `${coloredTs} ${coloredLevel} ${coloredCtx} ${msg}${extra}
+`;
+  }
+  return `${ts} ${levelStr} ${ctx} ${msg}${extra}
+`;
+}
+function jsonFormatter(entry) {
+  const output = {
+    timestamp: entry.timestamp.toISOString(),
+    level: entry.level,
+    context: entry.context,
+    message: entry.message
+  };
+  if (entry.enrichments && Object.keys(entry.enrichments).length > 0) {
+    Object.assign(output, entry.enrichments);
+  }
+  if (entry.data && Object.keys(entry.data).length > 0) {
+    output["data"] = entry.data;
+  }
+  return JSON.stringify(output) + "\n";
+}
+
+// libs/logger/src/lib/logger-config.types.ts
+function resolveLoggingConfig(config) {
+  return {
+    level: config?.level ?? "info",
+    format: config?.format ?? "pretty",
+    timestamps: config?.timestamps ?? true,
+    output: config?.output ?? ((msg) => {
+      process.stdout.write(msg);
+    }),
+    errorOutput: config?.errorOutput ?? ((msg) => {
+      process.stderr.write(msg);
+    })
+  };
+}
+
+// libs/logger/src/lib/logger.ts
+var ERROR_LEVELS = /* @__PURE__ */ new Set(["warn", "error", "fatal"]);
+var MomentumLogger = class _MomentumLogger {
+  static {
+    this.enrichers = [];
+  }
+  constructor(context, config) {
+    this.context = context;
+    this.config = isResolvedConfig(config) ? config : resolveLoggingConfig(config);
+    this.formatter = this.config.format === "json" ? jsonFormatter : prettyFormatter;
+  }
+  debug(message, data) {
+    this.log("debug", message, data);
+  }
+  info(message, data) {
+    this.log("info", message, data);
+  }
+  warn(message, data) {
+    this.log("warn", message, data);
+  }
+  error(message, data) {
+    this.log("error", message, data);
+  }
+  fatal(message, data) {
+    this.log("fatal", message, data);
+  }
+  /**
+   * Creates a child logger with a sub-context.
+   * e.g., `Momentum:DB` → `Momentum:DB:Migrate`
+   */
+  child(subContext) {
+    return new _MomentumLogger(`${this.context}:${subContext}`, this.config);
+  }
+  /**
+   * Registers a global enricher that adds extra fields to all log entries.
+   */
+  static registerEnricher(enricher) {
+    _MomentumLogger.enrichers.push(enricher);
+  }
+  /**
+   * Removes a previously registered enricher.
+   */
+  static removeEnricher(enricher) {
+    const index = _MomentumLogger.enrichers.indexOf(enricher);
+    if (index >= 0) {
+      _MomentumLogger.enrichers.splice(index, 1);
+    }
+  }
+  /**
+   * Clears all registered enrichers. Primarily for testing.
+   */
+  static clearEnrichers() {
+    _MomentumLogger.enrichers.length = 0;
+  }
+  log(level, message, data) {
+    if (!shouldLog(level, this.config.level))
+      return;
+    const enrichments = this.collectEnrichments();
+    const entry = {
+      timestamp: /* @__PURE__ */ new Date(),
+      level,
+      context: this.context,
+      message,
+      data,
+      enrichments: Object.keys(enrichments).length > 0 ? enrichments : void 0
+    };
+    const formatted = this.formatter(entry);
+    if (ERROR_LEVELS.has(level)) {
+      this.config.errorOutput(formatted);
+    } else {
+      this.config.output(formatted);
+    }
+  }
+  collectEnrichments() {
+    const result = {};
+    for (const enricher of _MomentumLogger.enrichers) {
+      Object.assign(result, enricher.enrich());
+    }
+    return result;
+  }
+};
+function isResolvedConfig(config) {
+  if (!config)
+    return false;
+  return typeof config.level === "string" && typeof config.format === "string" && typeof config.timestamps === "boolean" && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- type guard narrows union
+  typeof config.output === "function" && // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- type guard narrows union
+  typeof config.errorOutput === "function";
+}
+
+// libs/logger/src/lib/logger-singleton.ts
+var loggerInstance = null;
+var ROOT_CONTEXT = "Momentum";
+function getMomentumLogger() {
+  if (!loggerInstance) {
+    loggerInstance = new MomentumLogger(ROOT_CONTEXT);
+  }
+  return loggerInstance;
+}
+function createLogger(context) {
+  return getMomentumLogger().child(context);
+}
+
+// libs/plugins/analytics/src/lib/event-store.ts
+var EventStore = class {
+  constructor(options) {
+    this.buffer = [];
+    this.timer = null;
+    this.flushing = false;
+    this.adapter = options.adapter;
+    this.flushInterval = options.flushInterval ?? 5e3;
+    this.flushBatchSize = options.flushBatchSize ?? 100;
+    this.logger = createLogger("Analytics");
+  }
+  /**
+   * Start the periodic flush timer.
+   */
+  start() {
+    if (this.timer)
+      return;
+    this.timer = setInterval(() => {
+      void this.flush();
+    }, this.flushInterval);
+  }
+  /**
+   * Add an event to the buffer.
+   * Triggers an immediate flush if batch size is reached.
+   */
+  add(event) {
+    this.buffer.push(event);
+    if (this.buffer.length >= this.flushBatchSize) {
+      void this.flush();
+    }
+  }
+  /**
+   * Add multiple events to the buffer.
+   */
+  addBatch(events) {
+    this.buffer.push(...events);
+    if (this.buffer.length >= this.flushBatchSize) {
+      void this.flush();
+    }
+  }
+  /**
+   * Flush all buffered events to the adapter.
+   */
+  async flush() {
+    if (this.flushing || this.buffer.length === 0)
+      return;
+    this.flushing = true;
+    const events = this.buffer.splice(0, this.buffer.length);
+    try {
+      await this.adapter.store(events);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Failed to flush ${events.length} events: ${message}`);
+      this.buffer.unshift(...events);
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /**
+   * Stop the periodic flush timer and flush remaining events.
+   */
+  async shutdown() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    await this.flush();
+  }
+  /**
+   * Get the current buffer size.
+   */
+  get size() {
+    return this.buffer.length;
+  }
+};
+
+// libs/plugins/analytics/src/lib/collectors/collection-collector.ts
+import { randomUUID } from "node:crypto";
+function injectCollectionCollector(collections, emitter, options = {}) {
+  const excluded = new Set(options.excludeCollections ?? []);
+  for (const collection of collections) {
+    if (excluded.has(collection.slug))
+      continue;
+    collection.hooks = collection.hooks ?? {};
+    const afterChangeHook = (args) => {
+      const operation = args.operation ?? "create";
+      const doc = args.doc ?? args.data ?? {};
+      const event = {
+        id: randomUUID(),
+        category: "content",
+        name: operation === "create" ? "content_created" : "content_updated",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        properties: {
+          documentId: doc["id"]
+        },
+        context: {
+          source: "server",
+          collection: collection.slug,
+          operation
+        }
+      };
+      emitter(event);
+    };
+    const existingAfterChange = collection.hooks.afterChange ?? [];
+    collection.hooks.afterChange = [...existingAfterChange, afterChangeHook];
+    const afterDeleteHook = (args) => {
+      const doc = args.doc ?? {};
+      const event = {
+        id: randomUUID(),
+        category: "content",
+        name: "content_deleted",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        properties: {
+          documentId: doc["id"]
+        },
+        context: {
+          source: "server",
+          collection: collection.slug,
+          operation: "delete"
+        }
+      };
+      emitter(event);
+    };
+    const existingAfterDelete = collection.hooks.afterDelete ?? [];
+    collection.hooks.afterDelete = [...existingAfterDelete, afterDeleteHook];
+  }
+}
+
+// libs/plugins/analytics/src/lib/collectors/api-collector.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+
+// libs/plugins/analytics/src/lib/utils/parse-user-agent.ts
+function parseUserAgent(ua) {
+  if (!ua) {
+    return { device: "unknown", browser: "unknown", os: "unknown" };
+  }
+  return {
+    device: detectDevice(ua),
+    browser: detectBrowser(ua),
+    os: detectOS(ua)
+  };
+}
+function detectDevice(ua) {
+  if (/iPad|tablet|Kindle|PlayBook/i.test(ua))
+    return "tablet";
+  if (/Mobile|Android.*Mobile|iPhone|iPod|Opera Mini|IEMobile/i.test(ua))
+    return "mobile";
+  return "desktop";
+}
+function detectBrowser(ua) {
+  if (/Edg\//i.test(ua))
+    return "Edge";
+  if (/OPR\//i.test(ua) || /Opera/i.test(ua))
+    return "Opera";
+  if (/SamsungBrowser/i.test(ua))
+    return "Samsung Internet";
+  if (/UCBrowser/i.test(ua))
+    return "UC Browser";
+  if (/Firefox\//i.test(ua))
+    return "Firefox";
+  if (/Chrome\//i.test(ua) && !/Chromium/i.test(ua))
+    return "Chrome";
+  if (/Chromium\//i.test(ua))
+    return "Chromium";
+  if (/Safari\//i.test(ua) && !/Chrome/i.test(ua))
+    return "Safari";
+  if (/MSIE|Trident/i.test(ua))
+    return "IE";
+  return "unknown";
+}
+function detectOS(ua) {
+  if (/iPhone|iPad|iPod/i.test(ua))
+    return "iOS";
+  if (/Android/i.test(ua))
+    return "Android";
+  if (/Windows NT/i.test(ua))
+    return "Windows";
+  if (/Mac OS X|Macintosh/i.test(ua))
+    return "macOS";
+  if (/CrOS/i.test(ua))
+    return "ChromeOS";
+  if (/Linux/i.test(ua))
+    return "Linux";
+  return "unknown";
+}
+
+// libs/plugins/analytics/src/lib/collectors/api-collector.ts
+function createApiCollectorMiddleware(emitter) {
+  return (req, res, next) => {
+    const start = Date.now();
+    res.on("finish", () => {
+      const duration = Date.now() - start;
+      const ua = req.headers["user-agent"];
+      const parsed = parseUserAgent(ua);
+      const refHeader = req.headers["referer"] ?? req.headers["referrer"];
+      const referrer = Array.isArray(refHeader) ? refHeader[0] : refHeader;
+      const event = {
+        id: randomUUID2(),
+        category: "api",
+        name: "api_request",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        properties: {
+          method: req.method,
+          path: req.path,
+          route: req.route?.path
+        },
+        context: {
+          source: "server",
+          url: req.originalUrl,
+          referrer,
+          userAgent: ua,
+          ip: req.ip ?? req.socket.remoteAddress,
+          device: parsed.device,
+          browser: parsed.browser,
+          os: parsed.os,
+          duration,
+          statusCode: res.statusCode
+        }
+      };
+      emitter(event);
+    });
+    next();
+  };
+}
+
+// libs/plugins/analytics/src/lib/ingest-handler.ts
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { Router as createRouter } from "express";
+
+// libs/core/src/lib/collections/define-collection.ts
+function defineCollection(config) {
+  const collection = {
+    timestamps: true,
+    // Enable timestamps by default
+    ...config
+  };
+  if (!collection.slug) {
+    throw new Error("Collection must have a slug");
+  }
+  if (!collection.fields || collection.fields.length === 0) {
+    throw new Error(`Collection "${collection.slug}" must have at least one field`);
+  }
+  if (!/^[a-z][a-z0-9-]*$/.test(collection.slug)) {
+    throw new Error(
+      `Collection slug "${collection.slug}" must be kebab-case (lowercase letters, numbers, and hyphens, starting with a letter)`
+    );
+  }
+  return collection;
+}
+
+// libs/core/src/lib/fields/field-builders.ts
+function text(name, options = {}) {
+  return {
+    name,
+    type: "text",
+    ...options
+  };
+}
+function number(name, options = {}) {
+  return {
+    name,
+    type: "number",
+    ...options
+  };
+}
+function checkbox(name, options = {}) {
+  return {
+    name,
+    type: "checkbox",
+    ...options,
+    defaultValue: options.defaultValue ?? false
+  };
+}
+function select(name, options) {
+  return {
+    name,
+    type: "select",
+    ...options
+  };
+}
+function group(name, options) {
+  return {
+    name,
+    type: "group",
+    ...options
+  };
+}
+function json(name, options = {}) {
+  return {
+    name,
+    type: "json",
+    ...options
+  };
+}
+
+// libs/core/src/lib/collections/media.collection.ts
+var MediaCollection = defineCollection({
+  slug: "media",
+  labels: {
+    singular: "Media",
+    plural: "Media"
+  },
+  admin: {
+    useAsTitle: "filename",
+    defaultColumns: ["filename", "mimeType", "filesize", "createdAt"]
+  },
+  fields: [
+    text("filename", {
+      required: true,
+      label: "Filename",
+      description: "Original filename of the uploaded file"
+    }),
+    text("mimeType", {
+      required: true,
+      label: "MIME Type",
+      description: "File MIME type (e.g., image/jpeg, application/pdf)"
+    }),
+    number("filesize", {
+      label: "File Size",
+      description: "File size in bytes"
+    }),
+    text("path", {
+      required: true,
+      label: "Storage Path",
+      description: "Path/key where the file is stored",
+      admin: {
+        hidden: true
+      }
+    }),
+    text("url", {
+      label: "URL",
+      description: "Public URL to access the file"
+    }),
+    text("alt", {
+      label: "Alt Text",
+      description: "Alternative text for accessibility"
+    }),
+    number("width", {
+      label: "Width",
+      description: "Image width in pixels (for images only)"
+    }),
+    number("height", {
+      label: "Height",
+      description: "Image height in pixels (for images only)"
+    }),
+    json("focalPoint", {
+      label: "Focal Point",
+      description: "Focal point coordinates for image cropping",
+      admin: {
+        hidden: true
+      }
+    })
+  ],
+  access: {
+    // Media is readable by anyone by default
+    read: () => true,
+    // Only authenticated users can create/update/delete
+    create: ({ req }) => !!req?.user,
+    update: ({ req }) => !!req?.user,
+    delete: ({ req }) => !!req?.user
+  }
+});
+
+// libs/core/src/lib/access/access-helpers.ts
+function hasRole(role) {
+  return ({ req }) => req.user?.role === role;
+}
+
+// libs/server-core/src/lib/webhooks.ts
+var webhookLogger = createLogger("Webhook");
+
+// libs/server-core/src/lib/graphql-schema.ts
+import {
+  GraphQLSchema,
+  GraphQLObjectType,
+  GraphQLInputObjectType,
+  GraphQLString,
+  GraphQLInt,
+  GraphQLFloat,
+  GraphQLBoolean,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLID,
+  GraphQLUnionType,
+  GraphQLEnumType
+} from "graphql";
+
+// libs/server-core/src/lib/graphql-scalars.ts
+import { GraphQLScalarType, Kind } from "graphql";
+var GraphQLJSON = new GraphQLScalarType({
+  name: "JSON",
+  description: "Arbitrary JSON value",
+  serialize(value) {
+    return value;
+  },
+  parseValue(value) {
+    return value;
+  },
+  parseLiteral(ast) {
+    switch (ast.kind) {
+      case Kind.STRING:
+        return ast.value;
+      case Kind.BOOLEAN:
+        return ast.value;
+      case Kind.INT:
+        return parseInt(ast.value, 10);
+      case Kind.FLOAT:
+        return parseFloat(ast.value);
+      case Kind.OBJECT: {
+        const value = {};
+        for (const field of ast.fields) {
+          value[field.name.value] = GraphQLJSON.parseLiteral(field.value, void 0);
+        }
+        return value;
+      }
+      case Kind.LIST:
+        return ast.values.map((v) => GraphQLJSON.parseLiteral(v, void 0));
+      case Kind.NULL:
+        return null;
+      default:
+        return void 0;
+    }
+  }
+});
+
+// libs/server-core/src/lib/graphql-handler.ts
+import { graphql, parse, validate, GraphQLError } from "graphql";
+
+// libs/server-core/src/lib/rate-limiter.ts
+var RateLimiter = class _RateLimiter {
+  constructor(maxPerMinute, windowMs = 6e4) {
+    this.limits = /* @__PURE__ */ new Map();
+    this.lastCleanup = 0;
+    this.maxPerMinute = maxPerMinute;
+    this.windowMs = windowMs;
+  }
+  static {
+    this.CLEANUP_INTERVAL = 6e4;
+  }
+  /** Number of tracked entries (for monitoring/testing). */
+  get size() {
+    return this.limits.size;
+  }
+  /** Check if a request from the given key is allowed. */
+  isAllowed(key) {
+    const now = Date.now();
+    this.maybeCleanup(now);
+    const entry = this.limits.get(key);
+    if (!entry || now >= entry.resetAt) {
+      this.limits.set(key, { count: 1, resetAt: now + this.windowMs });
+      return true;
+    }
+    if (entry.count >= this.maxPerMinute) {
+      return false;
+    }
+    entry.count++;
+    return true;
+  }
+  /** Evict expired entries if enough time has passed since last cleanup. */
+  maybeCleanup(now) {
+    if (now - this.lastCleanup < _RateLimiter.CLEANUP_INTERVAL) {
+      return;
+    }
+    this.lastCleanup = now;
+    for (const [key, entry] of this.limits) {
+      if (now >= entry.resetAt) {
+        this.limits.delete(key);
+      }
+    }
+  }
+};
+
+// libs/plugins/analytics/src/lib/ingest-handler.ts
+var VALID_CATEGORIES = /* @__PURE__ */ new Set([
+  "admin",
+  "api",
+  "content",
+  "page",
+  "action",
+  "custom"
+]);
+function isValidClientEvent(event) {
+  if (event === null || typeof event !== "object")
+    return false;
+  const e = event;
+  if (typeof e["name"] !== "string" || e["name"].length === 0)
+    return false;
+  if (e["category"] && !VALID_CATEGORIES.has(e["category"]))
+    return false;
+  return true;
+}
+function createIngestRouter(options) {
+  const { eventStore, rateLimit = 100 } = options;
+  const limiter = new RateLimiter(rateLimit);
+  const logger = createLogger("Analytics:Ingest");
+  const router = createRouter();
+  router.post("/", (req, res) => {
+    const ip = req.ip ?? req.socket.remoteAddress ?? "unknown";
+    if (!limiter.isAllowed(ip)) {
+      res.status(429).json({ error: "Rate limit exceeded" });
+      return;
+    }
+    const body = req.body;
+    if (!body || !Array.isArray(body["events"])) {
+      res.status(400).json({ error: "Request body must contain an events array" });
+      return;
+    }
+    const rawEvents = body["events"];
+    const validEvents = [];
+    const ua = req.headers["user-agent"];
+    const parsed = parseUserAgent(ua);
+    const clientIp = req.ip ?? req.socket.remoteAddress;
+    for (const raw of rawEvents) {
+      if (!isValidClientEvent(raw)) {
+        continue;
+      }
+      const partial = raw;
+      const event = {
+        id: randomUUID3(),
+        category: partial.category ?? "custom",
+        name: partial.name ?? "unknown",
+        // Server-side timestamp (prevents client clock skew)
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        sessionId: typeof partial.sessionId === "string" ? partial.sessionId : void 0,
+        userId: typeof partial.userId === "string" ? partial.userId : void 0,
+        visitorId: typeof partial.visitorId === "string" ? partial.visitorId : void 0,
+        properties: typeof partial.properties === "object" && partial.properties !== null ? partial.properties : {},
+        context: {
+          source: "client",
+          url: typeof partial.context?.url === "string" ? partial.context.url : void 0,
+          referrer: typeof partial.context?.referrer === "string" ? partial.context.referrer : void 0,
+          userAgent: ua,
+          ip: clientIp,
+          device: parsed.device,
+          browser: parsed.browser,
+          os: parsed.os
+        }
+      };
+      validEvents.push(event);
+    }
+    if (validEvents.length === 0) {
+      res.status(400).json({ error: "No valid events in request" });
+      return;
+    }
+    eventStore.addBatch(validEvents);
+    logger.debug(`Ingested ${validEvents.length} client events`);
+    res.status(202).json({ accepted: validEvents.length });
+  });
+  return router;
+}
+
+// libs/plugins/analytics/src/lib/adapters/memory-adapter.ts
+var MemoryAnalyticsAdapter = class {
+  constructor() {
+    this.events = [];
+  }
+  async store(events) {
+    this.events.push(...events);
+  }
+  async query(options = {}) {
+    let filtered = [...this.events];
+    if (options.category) {
+      filtered = filtered.filter((e) => e.category === options.category);
+    }
+    if (options.name) {
+      filtered = filtered.filter((e) => e.name === options.name);
+    }
+    if (options.collection) {
+      filtered = filtered.filter((e) => e.context.collection === options.collection);
+    }
+    if (options.search) {
+      const term = options.search.toLowerCase();
+      filtered = filtered.filter(
+        (e) => e.name.toLowerCase().includes(term) || e.context.url && e.context.url.toLowerCase().includes(term) || e.context.collection && e.context.collection.toLowerCase().includes(term)
+      );
+    }
+    if (options.from) {
+      filtered = filtered.filter((e) => e.timestamp >= options.from);
+    }
+    if (options.to) {
+      filtered = filtered.filter((e) => e.timestamp <= options.to);
+    }
+    const total = filtered.length;
+    const limit = options.limit ?? 50;
+    const page = options.page ?? 1;
+    const start = (page - 1) * limit;
+    const paged = filtered.slice(start, start + limit);
+    return { events: paged, total, page, limit };
+  }
+};
+
+// libs/plugins/analytics/src/lib/adapters/postgres-adapter.ts
+function postgresAnalyticsAdapter(options) {
+  const logger = createLogger("Analytics:Postgres");
+  const tableName = options.tableName ?? "_momentum_analytics";
+  let pool = null;
+  async function getPool() {
+    if (!pool) {
+      const { Pool } = await import("pg");
+      pool = new Pool({
+        connectionString: options.connectionString,
+        max: options.poolSize ?? 5
+      });
+    }
+    return pool;
+  }
+  const adapter = {
+    async initialize() {
+      const p = await getPool();
+      await p.query(`
+				CREATE TABLE IF NOT EXISTS ${tableName} (
+					id TEXT PRIMARY KEY,
+					category TEXT NOT NULL,
+					name TEXT NOT NULL,
+					timestamp TIMESTAMPTZ NOT NULL,
+					session_id TEXT,
+					user_id TEXT,
+					visitor_id TEXT,
+					properties JSONB NOT NULL DEFAULT '{}',
+					context JSONB NOT NULL DEFAULT '{}'
+				)
+			`);
+      await p.query(`
+				CREATE INDEX IF NOT EXISTS idx_${tableName}_timestamp ON ${tableName} (timestamp DESC)
+			`);
+      await p.query(`
+				CREATE INDEX IF NOT EXISTS idx_${tableName}_category ON ${tableName} (category)
+			`);
+      await p.query(`
+				CREATE INDEX IF NOT EXISTS idx_${tableName}_name ON ${tableName} (name)
+			`);
+      logger.info(`Table "${tableName}" initialized`);
+    },
+    async store(events) {
+      if (events.length === 0)
+        return;
+      const p = await getPool();
+      const rows = [];
+      const values = [];
+      for (let i = 0; i < events.length; i++) {
+        const e = events[i];
+        const offset = i * 9;
+        rows.push(
+          `($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8}, $${offset + 9})`
+        );
+        values.push(
+          e.id,
+          e.category,
+          e.name,
+          e.timestamp,
+          e.sessionId ?? null,
+          e.userId ?? null,
+          e.visitorId ?? null,
+          JSON.stringify(e.properties),
+          JSON.stringify(e.context)
+        );
+      }
+      const sql = `
+				INSERT INTO ${tableName} (id, category, name, timestamp, session_id, user_id, visitor_id, properties, context)
+				VALUES ${rows.join(", ")}
+				ON CONFLICT (id) DO NOTHING
+			`;
+      await p.query(sql, values);
+    },
+    async query(queryOptions = {}) {
+      const p = await getPool();
+      const conditions = [];
+      const params = [];
+      let paramIdx = 1;
+      if (queryOptions.category) {
+        conditions.push(`category = $${paramIdx++}`);
+        params.push(queryOptions.category);
+      }
+      if (queryOptions.name) {
+        conditions.push(`name = $${paramIdx++}`);
+        params.push(queryOptions.name);
+      }
+      if (queryOptions.collection) {
+        conditions.push(`context->>'collection' = $${paramIdx++}`);
+        params.push(queryOptions.collection);
+      }
+      if (queryOptions.search) {
+        const searchPattern = `%${queryOptions.search}%`;
+        conditions.push(
+          `(name ILIKE $${paramIdx} OR context->>'url' ILIKE $${paramIdx} OR context->>'collection' ILIKE $${paramIdx})`
+        );
+        params.push(searchPattern);
+        paramIdx++;
+      }
+      if (queryOptions.from) {
+        conditions.push(`timestamp >= $${paramIdx++}`);
+        params.push(queryOptions.from);
+      }
+      if (queryOptions.to) {
+        conditions.push(`timestamp <= $${paramIdx++}`);
+        params.push(queryOptions.to);
+      }
+      const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+      const limit = Math.min(queryOptions.limit ?? 50, 1e4);
+      const page = queryOptions.page ?? 1;
+      const offset = (page - 1) * limit;
+      const countResult = await p.query(
+        `SELECT COUNT(*)::int AS count FROM ${tableName} ${where}`,
+        params
+      );
+      const total = countResult.rows[0].count;
+      const dataResult = await p.query(
+        `SELECT * FROM ${tableName} ${where} ORDER BY timestamp DESC LIMIT ${limit} OFFSET ${offset}`,
+        params
+      );
+      const events = dataResult.rows.map(rowToEvent);
+      return { events, total, page, limit };
+    },
+    async shutdown() {
+      if (pool) {
+        await pool.end();
+        pool = null;
+        logger.info("Connection pool closed");
+      }
+    }
+  };
+  return adapter;
+}
+function rowToEvent(row2) {
+  return {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- pg row fields
+    id: row2["id"],
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- pg row fields
+    category: row2["category"],
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- pg row fields
+    name: row2["name"],
+    timestamp: row2["timestamp"] instanceof Date ? row2["timestamp"].toISOString() : String(row2["timestamp"]),
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- pg row fields
+    sessionId: row2["session_id"] ?? void 0,
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- pg row fields
+    userId: row2["user_id"] ?? void 0,
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- pg row fields
+    visitorId: row2["visitor_id"] ?? void 0,
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- pg JSONB auto-parses
+    properties: row2["properties"] ?? {},
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- pg JSONB auto-parses
+    context: row2["context"] ?? { source: "server" }
+  };
+}
+
+// libs/plugins/analytics/src/lib/client/tracker.ts
+function getVisitorId() {
+  if (typeof localStorage === "undefined")
+    return "server";
+  let visitorId = localStorage.getItem("_m_vid");
+  if (!visitorId) {
+    visitorId = generateId();
+    localStorage.setItem("_m_vid", visitorId);
+  }
+  return visitorId;
+}
+function getSessionId() {
+  if (typeof sessionStorage === "undefined")
+    return "server";
+  let sessionId = sessionStorage.getItem("_m_sid");
+  if (!sessionId) {
+    sessionId = generateId();
+    sessionStorage.setItem("_m_sid", sessionId);
+  }
+  return sessionId;
+}
+function generateId() {
+  return Date.now().toString(36) + Math.random().toString(36).slice(2, 10);
+}
+function onDomReady(fn) {
+  if (typeof document === "undefined")
+    return;
+  if (document.readyState === "loading") {
+    document.addEventListener("DOMContentLoaded", fn, { once: true });
+  } else {
+    fn();
+  }
+}
+function createTracker(config = {}) {
+  const endpoint = config.endpoint ?? "/api/analytics/collect";
+  const flushInterval = config.flushInterval ?? 5e3;
+  const buffer = [];
+  let userId;
+  let _timer = null;
+  const cleanups = [];
+  const visitorId = getVisitorId();
+  const sessionId = getSessionId();
+  function addEvent(event) {
+    buffer.push({
+      ...event,
+      sessionId,
+      visitorId
+    });
+  }
+  function flush() {
+    if (buffer.length === 0)
+      return;
+    const events = buffer.splice(0, buffer.length).map((e) => ({
+      ...e,
+      userId
+    }));
+    const body = JSON.stringify({ events });
+    if (typeof navigator !== "undefined" && navigator.sendBeacon) {
+      const blob = new Blob([body], { type: "application/json" });
+      navigator.sendBeacon(endpoint, blob);
+    } else if (typeof fetch !== "undefined") {
+      void fetch(endpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body,
+        keepalive: true
+      });
+    }
+  }
+  if (typeof setInterval !== "undefined") {
+    _timer = setInterval(flush, flushInterval);
+    cleanups.push(() => {
+      if (_timer)
+        clearInterval(_timer);
+      _timer = null;
+    });
+  }
+  if (typeof addEventListener !== "undefined") {
+    addEventListener("beforeunload", flush);
+    cleanups.push(() => removeEventListener("beforeunload", flush));
+  }
+  const tracker = {
+    pageView(properties) {
+      addEvent({
+        name: "page_view",
+        category: "page",
+        properties,
+        context: {
+          url: typeof location !== "undefined" ? location.href : void 0,
+          referrer: typeof document !== "undefined" ? document.referrer : void 0
+        }
+      });
+    },
+    track(name, properties) {
+      addEvent({
+        name,
+        category: "action",
+        properties,
+        context: {
+          url: typeof location !== "undefined" ? location.href : void 0
+        }
+      });
+    },
+    identify(id, traits) {
+      userId = id;
+      addEvent({
+        name: "identify",
+        category: "custom",
+        properties: traits
+      });
+    },
+    flush,
+    destroy() {
+      flush();
+      for (const fn of cleanups)
+        fn();
+      cleanups.length = 0;
+    }
+  };
+  if (config.blockTracking) {
+    onDomReady(() => {
+      void Promise.resolve().then(() => (init_block_tracker(), block_tracker_exports)).then((m) => {
+        const blockCleanup = m.attachBlockTracking(tracker);
+        cleanups.push(blockCleanup);
+      });
+    });
+  }
+  if (config.trackingRules) {
+    const rulesEndpoint = typeof config.trackingRules === "object" ? config.trackingRules.endpoint : void 0;
+    onDomReady(() => {
+      void Promise.resolve().then(() => (init_rule_engine(), rule_engine_exports)).then((m) => {
+        const engine = m.createRuleEngine(tracker, { endpoint: rulesEndpoint });
+        void engine.start();
+        cleanups.push(() => engine.stop());
+      });
+    });
+  }
+  return tracker;
+}
+
+// libs/plugins/analytics/src/lib/collectors/block-field-injector.ts
+function createAnalyticsGroupField() {
+  return group("_analytics", {
+    label: "Analytics",
+    admin: { collapsible: true, defaultOpen: false },
+    fields: [
+      checkbox("trackImpressions", { label: "Track Impressions" }),
+      checkbox("trackHover", { label: "Track Hover" })
+    ]
+  });
+}
+function hasAnalyticsField(fields) {
+  return fields.some((f) => f.name === "_analytics" && f.type === "group");
+}
+function hasBlocks(field) {
+  return field.type === "blocks" && "blocks" in field;
+}
+function hasNestedFields(field) {
+  return "fields" in field && Array.isArray(field.fields);
+}
+function hasTabs(field) {
+  return field.type === "tabs" && "tabs" in field;
+}
+function injectIntoFields(fields) {
+  for (const field of fields) {
+    if (hasBlocks(field)) {
+      for (const blockConfig of field.blocks) {
+        if (!hasAnalyticsField(blockConfig.fields)) {
+          blockConfig.fields.push(createAnalyticsGroupField());
+        }
+      }
+    }
+    if ((field.type === "group" || field.type === "array" || field.type === "collapsible" || field.type === "row") && hasNestedFields(field)) {
+      injectIntoFields(field.fields);
+    }
+    if (hasTabs(field)) {
+      for (const tab of field.tabs) {
+        injectIntoFields(tab.fields);
+      }
+    }
+  }
+}
+function injectBlockAnalyticsFields(collections) {
+  for (const collection of collections) {
+    injectIntoFields(collection.fields);
+  }
+}
+
+// libs/plugins/analytics/src/lib/analytics-query-handler.ts
+import { Router } from "express";
+
+// libs/plugins/analytics/src/lib/analytics-auth.ts
+function isAuthenticated2(req) {
+  if (!("user" in req))
+    return false;
+  const user = req["user"];
+  return user != null && typeof user === "object" && "id" in user;
+}
+function isAdmin(req) {
+  if (!isAuthenticated2(req))
+    return false;
+  if (!("user" in req))
+    return false;
+  const user = req["user"];
+  return user != null && typeof user === "object" && "role" in user && user["role"] === "admin";
+}
+function requireAdmin(req, res, next) {
+  if (!isAuthenticated2(req)) {
+    res.status(401).json({ error: "Authentication required" });
+    return;
+  }
+  if (!isAdmin(req)) {
+    res.status(403).json({ error: "Admin access required" });
+    return;
+  }
+  next();
+}
+
+// libs/plugins/analytics/src/lib/analytics-query-handler.ts
+var VALID_CATEGORIES2 = ["admin", "api", "content", "page", "action", "custom"];
+function isValidCategory(value) {
+  return VALID_CATEGORIES2.includes(value);
+}
+function topPageEntries(record, limit) {
+  return Object.entries(record).sort(([, a], [, b]) => b - a).slice(0, limit).map(([url, count]) => ({ url, count }));
+}
+function topReferrerEntries(record, limit) {
+  return Object.entries(record).sort(([, a], [, b]) => b - a).slice(0, limit).map(([referrer, count]) => ({ referrer, count }));
+}
+function createAnalyticsQueryRouter(eventStore, adapter) {
+  const router = Router();
+  router.get("/query", requireAdmin, async (req, res) => {
+    try {
+      await eventStore.flush();
+      if (!adapter.query) {
+        res.status(501).json({ error: "Adapter does not support queries" });
+        return;
+      }
+      const options = {};
+      if (req.query["category"] && typeof req.query["category"] === "string") {
+        if (isValidCategory(req.query["category"])) {
+          options.category = req.query["category"];
+        }
+      }
+      if (req.query["name"] && typeof req.query["name"] === "string") {
+        options.name = req.query["name"];
+      }
+      if (req.query["collection"] && typeof req.query["collection"] === "string") {
+        options.collection = req.query["collection"];
+      }
+      if (req.query["search"] && typeof req.query["search"] === "string") {
+        options.search = req.query["search"];
+      }
+      if (req.query["from"] && typeof req.query["from"] === "string") {
+        options.from = req.query["from"];
+      }
+      if (req.query["to"] && typeof req.query["to"] === "string") {
+        options.to = req.query["to"];
+      }
+      if (req.query["limit"] && typeof req.query["limit"] === "string") {
+        const limit = parseInt(req.query["limit"], 10);
+        if (!isNaN(limit) && limit > 0 && limit <= 200) {
+          options.limit = limit;
+        }
+      }
+      if (req.query["page"] && typeof req.query["page"] === "string") {
+        const page = parseInt(req.query["page"], 10);
+        if (!isNaN(page) && page > 0) {
+          options.page = page;
+        }
+      }
+      const result = await adapter.query(options);
+      res.json(result);
+    } catch (error) {
+      console.error("Analytics query failed:", error);
+      res.status(500).json({ error: "Internal server error" });
+    }
+  });
+  router.get("/summary", requireAdmin, async (req, res) => {
+    try {
+      await eventStore.flush();
+      if (!adapter.query) {
+        res.status(501).json({ error: "Adapter does not support queries" });
+        return;
+      }
+      const queryOptions = { limit: 1e4 };
+      if (req.query["from"] && typeof req.query["from"] === "string") {
+        queryOptions.from = req.query["from"];
+      }
+      if (req.query["to"] && typeof req.query["to"] === "string") {
+        queryOptions.to = req.query["to"];
+      }
+      const allEvents = await adapter.query(queryOptions);
+      const events = allEvents.events;
+      const byCategory = {};
+      const byCollection = {};
+      const contentOps = { created: 0, updated: 0, deleted: 0 };
+      let apiRequests = 0;
+      let totalDuration = 0;
+      const sessions = /* @__PURE__ */ new Set();
+      const visitors = /* @__PURE__ */ new Set();
+      const pageCounts = {};
+      const referrerCounts = {};
+      const deviceCounts = {};
+      const browserCounts = {};
+      for (const event of events) {
+        byCategory[event.category] = (byCategory[event.category] ?? 0) + 1;
+        if (event.context.collection) {
+          byCollection[event.context.collection] = (byCollection[event.context.collection] ?? 0) + 1;
+        }
+        if (event.category === "content") {
+          if (event.name === "content_created")
+            contentOps.created++;
+          else if (event.name === "content_updated")
+            contentOps.updated++;
+          else if (event.name === "content_deleted")
+            contentOps.deleted++;
+        }
+        if (event.category === "api") {
+          apiRequests++;
+          if (event.context.duration != null) {
+            totalDuration += event.context.duration;
+          }
+        }
+        if (event.sessionId)
+          sessions.add(event.sessionId);
+        if (event.visitorId)
+          visitors.add(event.visitorId);
+        if (event.context.url) {
+          pageCounts[event.context.url] = (pageCounts[event.context.url] ?? 0) + 1;
+        }
+        if (event.context.referrer) {
+          referrerCounts[event.context.referrer] = (referrerCounts[event.context.referrer] ?? 0) + 1;
+        }
+        if (event.context.device) {
+          deviceCounts[event.context.device] = (deviceCounts[event.context.device] ?? 0) + 1;
+        }
+        if (event.context.browser) {
+          browserCounts[event.context.browser] = (browserCounts[event.context.browser] ?? 0) + 1;
+        }
+      }
+      const summary = {
+        totalEvents: allEvents.total,
+        byCategory,
+        byCollection,
+        contentOperations: contentOps,
+        apiMetrics: {
+          totalRequests: apiRequests,
+          avgDuration: apiRequests > 0 ? Math.round(totalDuration / apiRequests) : 0
+        },
+        activeSessions: sessions.size,
+        activeVisitors: visitors.size,
+        topPages: topPageEntries(pageCounts, 10),
+        topReferrers: topReferrerEntries(referrerCounts, 10),
+        deviceBreakdown: deviceCounts,
+        browserBreakdown: browserCounts
+      };
+      res.json(summary);
+    } catch (error) {
+      console.error("Analytics summary failed:", error);
+      res.status(500).json({ error: "Internal server error" });
+    }
+  });
+  return router;
+}
+
+// libs/plugins/analytics/src/lib/content-performance/content-performance-handler.ts
+import { Router as Router2 } from "express";
+function matchesDocumentUrl(eventUrl, documentPath) {
+  if (!eventUrl)
+    return false;
+  let pathname;
+  try {
+    pathname = new URL(eventUrl).pathname;
+  } catch {
+    pathname = eventUrl;
+  }
+  return pathname === documentPath || pathname === `${documentPath}/`;
+}
+function createContentPerformanceRouter(adapter) {
+  const router = Router2();
+  router.get("/content-performance", requireAdmin, async (req, res) => {
+    try {
+      const query = req.query;
+      const collection = typeof query["collection"] === "string" ? query["collection"] : void 0;
+      const documentId = typeof query["documentId"] === "string" ? query["documentId"] : void 0;
+      const from = typeof query["from"] === "string" ? query["from"] : void 0;
+      const to = typeof query["to"] === "string" ? query["to"] : void 0;
+      if (!collection || !documentId) {
+        res.status(400).json({ error: "collection and documentId are required" });
+        return;
+      }
+      if (!adapter.query) {
+        res.status(501).json({ error: "Analytics adapter does not support queries" });
+        return;
+      }
+      const documentPath = `/${collection}/${documentId}`;
+      const pageViewResult = await adapter.query({
+        category: "page",
+        name: "page_view",
+        search: documentPath,
+        from,
+        to,
+        limit: 1e3
+      });
+      const pageViewEvents = pageViewResult.events.filter(
+        (e) => matchesDocumentUrl(e.context.url, documentPath)
+      );
+      const visitorSet = /* @__PURE__ */ new Set();
+      const referrerMap = /* @__PURE__ */ new Map();
+      for (const event of pageViewEvents) {
+        const identifier = event.visitorId ?? event.sessionId;
+        if (identifier)
+          visitorSet.add(identifier);
+        const referrer = event.context.referrer;
+        if (referrer) {
+          referrerMap.set(referrer, (referrerMap.get(referrer) ?? 0) + 1);
+        }
+      }
+      let blockEngagement;
+      try {
+        const [impressionResult, hoverResult] = await Promise.all([
+          adapter.query({
+            name: "block_impression",
+            search: documentPath,
+            from,
+            to,
+            limit: 1e3
+          }),
+          adapter.query({
+            name: "block_hover",
+            search: documentPath,
+            from,
+            to,
+            limit: 1e3
+          })
+        ]);
+        const impressionEvents = impressionResult.events.filter(
+          (e) => matchesDocumentUrl(e.context.url, documentPath)
+        );
+        const hoverEvents = hoverResult.events.filter(
+          (e) => matchesDocumentUrl(e.context.url, documentPath)
+        );
+        const impressionMap = /* @__PURE__ */ new Map();
+        for (const event of impressionEvents) {
+          const bt = String(event.properties["blockType"] ?? "unknown");
+          impressionMap.set(bt, (impressionMap.get(bt) ?? 0) + 1);
+        }
+        const hoverMap = /* @__PURE__ */ new Map();
+        for (const event of hoverEvents) {
+          const bt = String(event.properties["blockType"] ?? "unknown");
+          hoverMap.set(bt, (hoverMap.get(bt) ?? 0) + 1);
+        }
+        const allTypes = /* @__PURE__ */ new Set([...impressionMap.keys(), ...hoverMap.keys()]);
+        if (allTypes.size > 0) {
+          blockEngagement = [];
+          for (const blockType of allTypes) {
+            blockEngagement.push({
+              blockType,
+              impressions: impressionMap.get(blockType) ?? 0,
+              hovers: hoverMap.get(blockType) ?? 0
+            });
+          }
+          blockEngagement.sort((a, b) => b.impressions - a.impressions);
+        }
+      } catch {
+      }
+      const topReferrers = [...referrerMap.entries()].map(([referrer, count]) => ({ referrer, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+      const data = {
+        pageViews: pageViewEvents.length,
+        uniqueVisitors: visitorSet.size,
+        topReferrers,
+        blockEngagement
+      };
+      res.json(data);
+    } catch (err) {
+      console.error("Content performance query failed:", err);
+      res.status(500).json({ error: "Internal server error" });
+    }
+  });
+  return router;
+}
+
+// libs/plugins/analytics/src/lib/tracking-rules/tracking-rules-endpoint.ts
+init_type_guards();
+init_selector_security();
+import { Router as Router3 } from "express";
+function isFindable(val) {
+  return val != null && typeof val === "object" && "find" in val;
+}
+var BLOCKED_EXTRACT_ATTRIBUTES = /* @__PURE__ */ new Set(["value", "password", "autocomplete", "autofill"]);
+var MAX_EXTRACT_VALUE_LENGTH = 200;
+function sanitizeExtractProperties(raw) {
+  const sanitized = [];
+  for (const entry of raw) {
+    if (!isRecord(entry))
+      continue;
+    const source = typeof entry["source"] === "string" ? entry["source"] : "";
+    const attr = typeof entry["attribute"] === "string" ? entry["attribute"] : "";
+    if (source === "attribute" && BLOCKED_EXTRACT_ATTRIBUTES.has(attr.toLowerCase())) {
+      continue;
+    }
+    sanitized.push({ ...entry, maxLength: MAX_EXTRACT_VALUE_LENGTH });
+  }
+  return sanitized.length > 0 ? sanitized : void 0;
+}
+function toClientRule(doc) {
+  if (!isRecord(doc))
+    return null;
+  if (typeof doc["name"] !== "string" || typeof doc["selector"] !== "string")
+    return null;
+  if (isSelectorBlocked(doc["selector"]))
+    return null;
+  return {
+    name: doc["name"],
+    selector: doc["selector"],
+    eventType: typeof doc["eventType"] === "string" ? doc["eventType"] : "click",
+    eventName: typeof doc["eventName"] === "string" ? doc["eventName"] : "",
+    urlPattern: typeof doc["urlPattern"] === "string" ? doc["urlPattern"] : "*",
+    properties: isRecord(doc["properties"]) ? doc["properties"] : {},
+    extractProperties: Array.isArray(doc["extractProperties"]) ? sanitizeExtractProperties(doc["extractProperties"]) : void 0,
+    active: doc["active"] === true,
+    rateLimit: typeof doc["rateLimit"] === "number" ? doc["rateLimit"] : void 0
+  };
+}
+function createTrackingRulesRouter(getApi, options = {}) {
+  const router = Router3();
+  const cacheTtl = options.cacheTtl ?? 6e4;
+  let cachedRules = null;
+  let cacheTimestamp = 0;
+  function invalidateCache() {
+    cachedRules = null;
+    cacheTimestamp = 0;
+  }
+  router.get("/tracking-rules", async (_req, res) => {
+    try {
+      const now = Date.now();
+      if (cachedRules && now - cacheTimestamp < cacheTtl) {
+        res.json({ rules: cachedRules });
+        return;
+      }
+      const api = getApi();
+      if (!api) {
+        res.json({ rules: [] });
+        return;
+      }
+      const ops = api.collection("tracking-rules");
+      if (!isFindable(ops)) {
+        res.json({ rules: [] });
+        return;
+      }
+      const result = await ops.find({
+        where: { active: { equals: true } },
+        limit: 500
+      });
+      const docs = Array.isArray(result.docs) ? result.docs : [];
+      const clientRules = docs.map(toClientRule).filter((rule) => rule != null);
+      cachedRules = clientRules;
+      cacheTimestamp = now;
+      res.json({ rules: clientRules });
+    } catch (err) {
+      console.error("Tracking rules query failed:", err);
+      res.status(500).json({ error: "Internal server error" });
+    }
+  });
+  return { router, invalidateCache };
+}
+
+// libs/plugins/analytics/src/lib/tracking-rules/tracking-rules-collection.ts
+init_selector_security();
+var TrackingRules = defineCollection({
+  slug: "tracking-rules",
+  labels: {
+    singular: "Tracking Rule",
+    plural: "Tracking Rules"
+  },
+  admin: {
+    useAsTitle: "name",
+    group: "Analytics",
+    defaultColumns: ["name", "selector", "eventType", "urlPattern", "active"]
+  },
+  fields: [
+    text("name", { required: true, label: "Rule Name" }),
+    text("selector", {
+      required: true,
+      label: "CSS Selector",
+      description: 'CSS selector to match elements (e.g., ".cta-button", "#signup-form"). Selectors targeting password, hidden, or credit card fields are blocked.',
+      validate: (value) => {
+        if (typeof value !== "string" || value.trim().length === 0) {
+          return "CSS Selector is required";
+        }
+        if (isSelectorBlocked(value)) {
+          return "Selectors targeting password, hidden, or credit card fields are not allowed";
+        }
+        return true;
+      }
+    }),
+    select("eventType", {
+      required: true,
+      label: "Event Type",
+      options: [
+        { label: "Click", value: "click" },
+        { label: "Submit", value: "submit" },
+        { label: "Scroll Into View", value: "scroll-into-view" },
+        { label: "Hover", value: "hover" },
+        { label: "Focus", value: "focus" }
+      ],
+      defaultValue: "click"
+    }),
+    text("eventName", {
+      required: true,
+      label: "Event Name",
+      description: 'Analytics event name to fire (e.g., "cta_click", "form_submit")'
+    }),
+    text("urlPattern", {
+      required: true,
+      label: "URL Pattern",
+      description: 'URL pattern to match pages. Use * for wildcards (e.g., "/blog/*", "*" for all)',
+      defaultValue: "*"
+    }),
+    json("properties", {
+      label: "Static Properties",
+      description: "Key-value pairs attached to every event"
+    }),
+    json("extractProperties", {
+      label: "Extract Properties",
+      description: 'Extract dynamic values from matched DOM elements. Extraction of "value", "password", and "autocomplete" attributes is blocked. Values are truncated to 200 characters.'
+    }),
+    checkbox("active", { label: "Active", defaultValue: true }),
+    number("rateLimit", {
+      label: "Rate Limit",
+      description: "Max events per minute per visitor (leave empty for unlimited)",
+      admin: { position: "sidebar" }
+    })
+  ],
+  access: {
+    read: () => true,
+    // Public: client-side rule engine fetches rules without auth
+    create: hasRole("admin"),
+    update: hasRole("admin"),
+    delete: hasRole("admin"),
+    admin: hasRole("admin")
+  }
+});
+
+// libs/plugins/analytics/src/lib/analytics-plugin.ts
+function resolveAdminRoutes(dashboardConfig) {
+  if (dashboardConfig === false)
+    return [];
+  const dashboardModule = "./dashboard/analytics-dashboard.page";
+  const defaultLoadComponent = () => import(dashboardModule).then((m) => m["AnalyticsDashboardPage"]);
+  const defaultRoute = {
+    path: "analytics",
+    label: "Analytics",
+    icon: "heroChartBarSquare",
+    loadComponent: defaultLoadComponent,
+    group: "Analytics"
+  };
+  if (dashboardConfig === void 0 || dashboardConfig === true) {
+    return [defaultRoute];
+  }
+  return [
+    {
+      ...defaultRoute,
+      loadComponent: dashboardConfig.loadComponent ?? defaultLoadComponent,
+      group: dashboardConfig.group ?? defaultRoute.group
+    }
+  ];
+}
+function analyticsPlugin(config) {
+  const eventStore = new EventStore({
+    adapter: config.adapter,
+    flushInterval: config.flushInterval,
+    flushBatchSize: config.flushBatchSize
+  });
+  const adminRoutes = resolveAdminRoutes(config.adminDashboard);
+  let momentumApi = null;
+  if (config.contentPerformance !== false && config.adminDashboard !== false) {
+    const contentPerfModule = "./dashboard/content-performance.page";
+    adminRoutes.push({
+      path: "analytics/content",
+      label: "Content Perf.",
+      icon: "heroDocumentText",
+      loadComponent: () => import(contentPerfModule).then((m) => m["ContentPerformancePage"]),
+      group: "Analytics"
+    });
+  }
+  if (config.trackingRules !== false && config.adminDashboard !== false) {
+    const trackingRulesModule = "./dashboard/tracking-rules.page";
+    adminRoutes.push({
+      path: "analytics/tracking-rules",
+      label: "Tracking Rules",
+      icon: "heroCursorArrowRays",
+      loadComponent: () => import(trackingRulesModule).then((m) => m["TrackingRulesPage"]),
+      group: "Analytics"
+    });
+  }
+  return {
+    name: "analytics",
+    eventStore,
+    analyticsConfig: config,
+    adminRoutes,
+    modifyCollections(collections) {
+      if (config.enabled !== false && config.blockTracking !== false) {
+        injectBlockAnalyticsFields(collections);
+      }
+    },
+    async onInit({ collections, logger, registerMiddleware }) {
+      if (config.enabled === false) {
+        logger.info("Analytics disabled");
+        return;
+      }
+      if (config.adapter.initialize) {
+        logger.info("Initializing analytics adapter...");
+        await config.adapter.initialize();
+      }
+      if (config.blockTracking !== false) {
+        injectBlockAnalyticsFields(collections);
+        logger.info("Block analytics fields injected");
+      }
+      if (config.trackCollections !== false) {
+        injectCollectionCollector(collections, (event) => eventStore.add(event), {
+          excludeCollections: config.excludeCollections
+        });
+        logger.info(`Collection tracking enabled for ${collections.length} collections`);
+      }
+      const ingestRouter = createIngestRouter({
+        eventStore,
+        rateLimit: config.ingestRateLimit
+      });
+      registerMiddleware({
+        path: config.ingestPath ?? "/analytics/collect",
+        handler: ingestRouter,
+        position: "before-api"
+      });
+      const queryRouter = createAnalyticsQueryRouter(eventStore, config.adapter);
+      registerMiddleware({
+        path: "/analytics",
+        handler: queryRouter,
+        position: "before-api"
+      });
+      if (config.trackApi !== false) {
+        const apiCollector = createApiCollectorMiddleware((event) => eventStore.add(event));
+        registerMiddleware({
+          path: "/",
+          handler: apiCollector,
+          position: "before-api"
+        });
+      }
+      if (config.contentPerformance !== false) {
+        const contentPerfRouter = createContentPerformanceRouter(config.adapter);
+        registerMiddleware({
+          path: "/analytics",
+          handler: contentPerfRouter,
+          position: "before-api"
+        });
+        logger.info("Content performance endpoint registered");
+      }
+      if (config.trackingRules !== false) {
+        const cacheTtl = typeof config.trackingRules === "object" ? config.trackingRules.cacheTtl : void 0;
+        const { router: trackingRulesRouter, invalidateCache } = createTrackingRulesRouter(
+          () => momentumApi,
+          cacheTtl != null ? { cacheTtl } : void 0
+        );
+        const rulesWithHooks = {
+          ...TrackingRules,
+          hooks: {
+            ...TrackingRules.hooks,
+            afterChange: [
+              ...TrackingRules.hooks?.afterChange ?? [],
+              () => {
+                invalidateCache();
+              }
+            ],
+            afterDelete: [
+              ...TrackingRules.hooks?.afterDelete ?? [],
+              () => {
+                invalidateCache();
+              }
+            ]
+          }
+        };
+        collections.push(rulesWithHooks);
+        registerMiddleware({
+          path: "/analytics",
+          handler: trackingRulesRouter,
+          position: "before-api"
+        });
+        logger.info("Tracking rules collection and endpoint registered");
+      }
+      if (adminRoutes.length > 0) {
+        logger.info("Analytics admin dashboard route declared");
+      }
+      logger.info("Analytics plugin initialized");
+    },
+    async onReady({ logger, api }) {
+      if (config.enabled === false)
+        return;
+      momentumApi = api;
+      eventStore.start();
+      logger.info("Analytics event flush timer started");
+    },
+    async onShutdown({ logger }) {
+      logger.info("Shutting down analytics...");
+      await eventStore.shutdown();
+      if (config.adapter.shutdown) {
+        await config.adapter.shutdown();
+      }
+      logger.info("Analytics shut down");
+    }
+  };
+}
+
+// libs/plugins/analytics/src/lib/analytics-middleware.ts
+function createAnalyticsMiddleware(plugin) {
+  const { eventStore, analyticsConfig } = plugin;
+  const ingestRouter = createIngestRouter({
+    eventStore,
+    rateLimit: analyticsConfig.ingestRateLimit
+  });
+  const apiCollector = createApiCollectorMiddleware((event) => eventStore.add(event));
+  return { ingestRouter, apiCollector };
+}
+
+// libs/plugins/analytics/src/index.ts
+init_block_tracker();
+init_rule_engine();
+export {
+  EventStore,
+  MemoryAnalyticsAdapter,
+  TrackingRules,
+  analyticsPlugin,
+  attachBlockTracking,
+  createAnalyticsMiddleware,
+  createAnalyticsQueryRouter,
+  createApiCollectorMiddleware,
+  createContentPerformanceRouter,
+  createIngestRouter,
+  createRuleEngine,
+  createTracker,
+  createTrackingRulesRouter,
+  injectBlockAnalyticsFields,
+  injectCollectionCollector,
+  parseUserAgent,
+  postgresAnalyticsAdapter
+};