@snapback/cli 1.1.12 → 1.1.15

package/dist/chunk-ICKSHS3A.js

@@ -0,0 +1,2264 @@
+#!/usr/bin/env node --no-warnings=ExperimentalWarning
+import { logger } from './chunk-PL4HF4M2.js';
+import { FEATURE_FLAGS, validateTelemetryEvent, FeatureManager } from './chunk-WS36HDEU.js';
+import { __commonJS, __name, __export } from './chunk-7ADPL4Q3.js';
+import { neonConfig, neon } from '@neondatabase/serverless';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { PostHog } from 'posthog-node';
+import client from 'prom-client';
+import { trace, context, SpanStatusCode, propagation, ROOT_CONTEXT } from '@opentelemetry/api';
+import { OTLPTraceExporter } from '@opentelemetry/exporter-trace-otlp-http';
+import { PgInstrumentation } from '@opentelemetry/instrumentation-pg';
+import { PinoInstrumentation } from '@opentelemetry/instrumentation-pino';
+import { resourceFromAttributes } from '@opentelemetry/resources';
+import { BatchSpanProcessor, ConsoleSpanExporter, TraceIdRatioBasedSampler } from '@opentelemetry/sdk-trace-base';
+import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
+import { ATTR_SERVICE_VERSION, ATTR_SERVICE_NAME } from '@opentelemetry/semantic-conventions';
+
+process.env.SNAPBACK_CLI='true';
+
+// ../../packages/infrastructure/package.json
+var require_package = __commonJS({
+  "../../packages/infrastructure/package.json"(exports$1, module) {
+    module.exports = {
+      name: "@snapback/infrastructure",
+      version: "0.2.0",
+      license: "Apache-2.0",
+      author: "SnapBack Team",
+      repository: {
+        type: "git",
+        url: "https://github.com/snapback-dev.git",
+        directory: "packages/infrastructure"
+      },
+      files: [
+        "dist"
+      ],
+      dependencies: {
+        "@neondatabase/serverless": "catalog:",
+        "@opentelemetry/api": "catalog:",
+        "@opentelemetry/exporter-trace-otlp-http": "catalog:",
+        "@opentelemetry/instrumentation-pg": "catalog:",
+        "@opentelemetry/instrumentation-pino": "catalog:",
+        "@opentelemetry/resources": "catalog:",
+        "@opentelemetry/sdk-trace-base": "catalog:",
+        "@opentelemetry/sdk-trace-node": "catalog:",
+        "@opentelemetry/semantic-conventions": "catalog:",
+        "@snapback/contracts": "workspace:*",
+        bullmq: "catalog:",
+        nanoid: "catalog:",
+        pino: "catalog:",
+        "posthog-node": "catalog:",
+        opossum: "catalog:",
+        "p-queue": "catalog:",
+        "p-retry": "catalog:",
+        "lru-cache": "catalog:",
+        chokidar: "catalog:",
+        "prom-client": "catalog:"
+      },
+      optionalDependencies: {
+        "@sentry/node": "catalog:",
+        "@sentry/profiling-node": "catalog:"
+      },
+      devDependencies: {
+        "@snapback/tsconfig": "workspace:*",
+        "@types/node": "catalog:",
+        "posthog-js": "catalog:",
+        tsup: "catalog:",
+        typescript: "catalog:",
+        vitest: "catalog:"
+      },
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          default: "./dist/index.js"
+        },
+        "./logging/logger": {
+          types: "./dist/logging/logger.d.ts",
+          default: "./dist/logging/logger.js"
+        },
+        "./metrics": {
+          types: "./dist/metrics/index.d.ts",
+          default: "./dist/metrics/index.js"
+        },
+        "./tracing": {
+          types: "./dist/tracing/index.d.ts",
+          default: "./dist/tracing/index.js"
+        },
+        "./health": {
+          types: "./dist/health/index.d.ts",
+          default: "./dist/health/index.js"
+        },
+        "./resiliency": {
+          types: "./dist/resiliency/index.d.ts",
+          default: "./dist/resiliency/index.js"
+        },
+        "./cache": {
+          types: "./dist/cache/index.d.ts",
+          default: "./dist/cache/index.js"
+        },
+        "./files": {
+          types: "./dist/files/watcher.d.ts",
+          default: "./dist/files/watcher.js"
+        },
+        "./sqlite": {
+          types: "./dist/sqlite/index.d.ts",
+          default: "./dist/sqlite/index.js"
+        },
+        "./neon": {
+          types: "./dist/neon/index.d.ts",
+          default: "./dist/neon/index.js"
+        },
+        "./prometheus": {
+          types: "./dist/prometheus/index.d.ts",
+          default: "./dist/prometheus/index.js"
+        }
+      },
+      publishConfig: {
+        exports: {
+          ".": {
+            types: "./dist/logging/logger.d.ts",
+            default: "./dist/logging/logger.js"
+          },
+          "./logging/logger": {
+            types: "./dist/logging/logger.d.ts",
+            default: "./dist/logging/logger.js"
+          },
+          "./health": {
+            types: "./dist/health/index.d.ts",
+            default: "./dist/health/index.js"
+          },
+          "./tracing": {
+            types: "./dist/tracing/index.d.ts",
+            default: "./dist/tracing/index.js"
+          },
+          "./metrics": {
+            types: "./dist/metrics/index.d.ts",
+            default: "./dist/metrics/index.js"
+          },
+          "./resiliency": {
+            types: "./dist/resiliency/index.d.ts",
+            default: "./dist/resiliency/index.js"
+          },
+          "./cache": {
+            types: "./dist/cache/index.d.ts",
+            default: "./dist/cache/index.js"
+          },
+          "./files": {
+            types: "./dist/files/watcher.d.ts",
+            default: "./dist/files/watcher.js"
+          },
+          "./sqlite": {
+            types: "./dist/sqlite/index.d.ts",
+            default: "./dist/sqlite/index.js"
+          },
+          "./neon": {
+            types: "./dist/neon/index.d.ts",
+            default: "./dist/neon/index.js"
+          }
+        }
+      },
+      main: "dist/index.js",
+      private: true,
+      scripts: {
+        build: "tsup && tsc --build tsconfig.build.json --force && node ../../scripts/build-utils/add-js-extensions.mjs",
+        "build:docker": "tsup --no-dts && node ../../scripts/build-utils/add-js-extensions.mjs",
+        dev: "tsup --watch",
+        check: "biome check .",
+        format: "biome format --write .",
+        lint: "biome lint .",
+        "lint:fix": "biome lint --fix .",
+        postbuild: "test -f dist/index.d.ts && node scripts/patch-dts.cjs || echo 'Warning: Type declarations not fully generated'",
+        test: "vitest run",
+        "test:coverage": "vitest run --coverage",
+        "test:watch": "vitest",
+        "type-check": "tsc --noEmit"
+      },
+      type: "module",
+      types: "dist/index.d.ts"
+    };
+  }
+});
+
+// ../../packages/infrastructure/dist/environment/index.js
+function isDevelopment() {
+  return getDeploymentEnv() === "development";
+}
+__name(isDevelopment, "isDevelopment");
+function isProduction() {
+  return getDeploymentEnv() === "production";
+}
+__name(isProduction, "isProduction");
+function getDeploymentEnv() {
+  const explicitEnv = process.env.DEPLOYMENT_ENV;
+  if (explicitEnv === "development" || explicitEnv === "staging" || explicitEnv === "production") {
+    return explicitEnv;
+  }
+  if (process.env.VERCEL || process.env.VERCEL_ENV || process.env.FLY_ALLOC_ID) {
+    return "production";
+  }
+  const authUrl = process.env.BETTER_AUTH_URL || process.env.APP_URL || "";
+  if (authUrl.includes("localhost") || authUrl.includes("127.0.0.1")) {
+    return "development";
+  }
+  if (typeof window !== "undefined") {
+    const hostname = window.location.hostname;
+    if (hostname === "localhost" || hostname === "127.0.0.1" || hostname.endsWith(".local") || hostname.endsWith(".test")) {
+      return "development";
+    }
+  }
+  if (process.env.CI) {
+    return "production";
+  }
+  return "production";
+}
+__name(getDeploymentEnv, "getDeploymentEnv");
+function getAnalyticsEnv() {
+  return getDeploymentEnv() === "development" ? "dev" : "prod";
+}
+__name(getAnalyticsEnv, "getAnalyticsEnv");
+function getEnvironmentInfo() {
+  const deployment = getDeploymentEnv();
+  return {
+    deployment,
+    analytics: deployment === "development" ? "dev" : "prod",
+    nodeEnv: process.env.NODE_ENV,
+    isCi: !!process.env.CI,
+    isVercel: !!(process.env.VERCEL || process.env.VERCEL_ENV),
+    isFly: !!process.env.FLY_ALLOC_ID,
+    isLocalhost: (process.env.BETTER_AUTH_URL?.includes("localhost") ?? false) || typeof window !== "undefined" && (window.location.hostname === "localhost" || window.location.hostname === "127.0.0.1")
+  };
+}
+__name(getEnvironmentInfo, "getEnvironmentInfo");
+function detectSurface() {
+  if (process.env.VSCODE_EXTENSION || typeof process.env.VSCODE_PID !== "undefined") {
+    return "vscode";
+  }
+  if (process.env.SNAPBACK_CLI || process.argv[1]?.includes("cli")) {
+    return "cli";
+  }
+  if (process.env.MCP_SERVER || process.env.MCP_MODE) {
+    return "mcp";
+  }
+  if (process.env.DAEMON_MODE || process.env.LOCAL_SERVICE) {
+    return "daemon";
+  }
+  if (process.env.API_SERVER || typeof process.env.PORT !== "undefined") {
+    return "api";
+  }
+  if (typeof window !== "undefined") {
+    return "web";
+  }
+  return "api";
+}
+__name(detectSurface, "detectSurface");
+function getAnalyticsSuperProperties(surface) {
+  return {
+    env: getAnalyticsEnv(),
+    surface: surface ?? detectSurface()
+  };
+}
+__name(getAnalyticsSuperProperties, "getAnalyticsSuperProperties");
+
+// ../../packages/infrastructure/dist/graceful-shutdown/index.js
+function createGracefulShutdown(options) {
+  const { logger: logger2, timeoutMs = 25e3, healthMarkerPath } = options;
+  const cleanupHandlers = [];
+  let isShuttingDown = false;
+  let isReady = false;
+  function updateReadiness(ready) {
+    isReady = ready;
+    if (healthMarkerPath) {
+      try {
+        if (ready) {
+          globalThis.Bun?.write?.(healthMarkerPath, process.pid.toString());
+        } else {
+          globalThis.Bun?.write?.(healthMarkerPath, "");
+        }
+      } catch (error) {
+        logger2.debug("Health marker file operation failed", {
+          error
+        });
+      }
+    }
+  }
+  __name(updateReadiness, "updateReadiness");
+  async function shutdown(signal) {
+    if (isShuttingDown) {
+      logger2.warn("Shutdown already in progress, ignoring signal", {
+        signal
+      });
+      return;
+    }
+    isShuttingDown = true;
+    logger2.info("Shutdown initiated", {
+      signal,
+      pid: process.pid
+    });
+    updateReadiness(false);
+    logger2.info("Service marked as not ready, stopping new traffic");
+    const drainTimeout = Math.min(5e3, timeoutMs / 5);
+    logger2.info("Waiting for in-flight requests to complete", {
+      drainTimeoutMs: drainTimeout
+    });
+    await new Promise((resolve) => setTimeout(resolve, drainTimeout));
+    logger2.info("Running cleanup handlers", {
+      count: cleanupHandlers.length
+    });
+    const cleanupTimeout = timeoutMs - drainTimeout - 2e3;
+    const cleanupStart = Date.now();
+    for (let i = cleanupHandlers.length - 1; i >= 0; i--) {
+      const remainingTime = cleanupTimeout - (Date.now() - cleanupStart);
+      if (remainingTime <= 0) {
+        logger2.warn("Cleanup timeout reached, some handlers may not have completed");
+        break;
+      }
+      try {
+        const handler = cleanupHandlers[i];
+        const handlerTimeout = Math.min(remainingTime, 5e3);
+        await Promise.race([
+          handler(),
+          new Promise((_, reject) => setTimeout(() => reject(new Error("Handler timeout")), handlerTimeout))
+        ]);
+      } catch (error) {
+        logger2.error("Cleanup handler error", {
+          error,
+          handlerIndex: i
+        });
+      }
+    }
+    logger2.info("Shutdown complete", {
+      durationMs: Date.now() - cleanupStart + drainTimeout
+    });
+    process.exit(0);
+  }
+  __name(shutdown, "shutdown");
+  const forceExit = /* @__PURE__ */ __name(() => {
+    logger2.error("Forced exit due to timeout", {
+      timeoutMs
+    });
+    process.exit(1);
+  }, "forceExit");
+  return {
+    register(handler) {
+      cleanupHandlers.push(handler);
+    },
+    setReady() {
+      updateReadiness(true);
+    },
+    setNotReady() {
+      updateReadiness(false);
+    },
+    init() {
+      const handleShutdown = /* @__PURE__ */ __name((signal) => {
+        shutdown(signal).catch((error) => {
+          logger2.error("Shutdown error", {
+            error
+          });
+          process.exit(1);
+        });
+        setTimeout(forceExit, timeoutMs);
+      }, "handleShutdown");
+      process.on("SIGTERM", () => handleShutdown("SIGTERM"));
+      process.on("SIGINT", () => handleShutdown("SIGINT"));
+      process.on("uncaughtException", (error) => {
+        logger2.error("Uncaught exception, initiating shutdown", {
+          error
+        });
+        handleShutdown("uncaughtException");
+      });
+      process.on("unhandledRejection", (reason) => {
+        logger2.error("Unhandled rejection, initiating shutdown", {
+          reason
+        });
+        if (process.env.NODE_ENV !== "production") {
+          handleShutdown("unhandledRejection");
+        }
+      });
+      logger2.info("Graceful shutdown handler initialized", {
+        timeoutMs
+      });
+    },
+    isReady() {
+      return isReady;
+    },
+    isShuttingDown() {
+      return isShuttingDown;
+    }
+  };
+}
+__name(createGracefulShutdown, "createGracefulShutdown");
+async function drainAndCloseServer(server, logger2) {
+  logger2.info("Closing server...");
+  const closePromise = server.close();
+  if (server.closeIdleConnections) {
+    logger2.info("Closing idle connections...");
+    server.closeIdleConnections();
+  }
+  const timeout = 1e4;
+  await Promise.race([
+    closePromise,
+    new Promise((resolve) => setTimeout(resolve, timeout))
+  ]);
+  if (server.closeAllConnections) {
+    logger2.info("Force closing remaining connections...");
+    server.closeAllConnections();
+  }
+  logger2.info("Server closed");
+}
+__name(drainAndCloseServer, "drainAndCloseServer");
+async function preStopDelay(ms = 5e3) {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+__name(preStopDelay, "preStopDelay");
+
+// ../../packages/infrastructure/dist/health/index.js
+function createHealthCheck(options) {
+  return async () => {
+    const checks = {};
+    checks.system = {
+      status: "healthy",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      latency: 0
+    };
+    const memoryUsage = process.memoryUsage();
+    checks.memory = {
+      status: memoryUsage.heapUsed < 0.8 * memoryUsage.heapTotal ? "healthy" : "degraded",
+      message: `Memory usage: ${Math.round(memoryUsage.heapUsed / 1024 / 1024 * 100) / 100} MB`,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    const uptime = process.uptime();
+    if (options.dependencies) {
+      for (const dep of options.dependencies) {
+        try {
+          const depStartTime = Date.now();
+          const result = await dep.check();
+          const latency = Date.now() - depStartTime;
+          checks[dep.name] = {
+            status: result.status,
+            message: result.message,
+            latency,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        } catch (error) {
+          checks[dep.name] = {
+            status: "unhealthy",
+            message: error instanceof Error ? error.message : "Unknown error",
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+      }
+    }
+    let overallStatus = "healthy";
+    for (const check of Object.values(checks)) {
+      if (check.status === "unhealthy") {
+        overallStatus = "unhealthy";
+        break;
+      }
+      if (check.status === "degraded" && overallStatus === "healthy") {
+        overallStatus = "degraded";
+      }
+    }
+    const response = {
+      status: overallStatus,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      service: options.service,
+      checks,
+      uptime,
+      memoryUsage: {
+        heapUsed: memoryUsage.heapUsed,
+        heapTotal: memoryUsage.heapTotal,
+        rss: memoryUsage.rss
+      }
+    };
+    if (options.version) {
+      response.version = options.version;
+    }
+    return response;
+  };
+}
+__name(createHealthCheck, "createHealthCheck");
+async function checkDatabaseConnection(_connectionString) {
+  try {
+    const startTime = Date.now();
+    await new Promise((resolve) => setTimeout(resolve, Math.random() * 50));
+    const latency = Date.now() - startTime;
+    if (latency > 1e3) {
+      return {
+        status: "degraded",
+        message: `Database connection is slow (${latency}ms)`
+      };
+    }
+    return {
+      status: "healthy",
+      message: `Database connection successful (${latency}ms)`
+    };
+  } catch (error) {
+    return {
+      status: "unhealthy",
+      message: error instanceof Error ? error.message : "Database connection failed"
+    };
+  }
+}
+__name(checkDatabaseConnection, "checkDatabaseConnection");
+async function checkRedisConnection(_redisUrl) {
+  try {
+    const startTime = Date.now();
+    await new Promise((resolve) => setTimeout(resolve, Math.random() * 30));
+    const latency = Date.now() - startTime;
+    if (latency > 200) {
+      return {
+        status: "degraded",
+        message: `Redis connection is slow (${latency}ms)`
+      };
+    }
+    return {
+      status: "healthy",
+      message: `Redis connection successful (${latency}ms)`
+    };
+  } catch (error) {
+    return {
+      status: "unhealthy",
+      message: error instanceof Error ? error.message : "Redis connection failed"
+    };
+  }
+}
+__name(checkRedisConnection, "checkRedisConnection");
+async function checkHttpService(_url) {
+  try {
+    const startTime = Date.now();
+    await new Promise((resolve) => setTimeout(resolve, Math.random() * 100));
+    const latency = Date.now() - startTime;
+    if (latency > 1e3) {
+      return {
+        status: "degraded",
+        message: `HTTP service is slow (${latency}ms)`
+      };
+    }
+    return {
+      status: "healthy",
+      message: `HTTP service check successful (${latency}ms)`
+    };
+  } catch (error) {
+    return {
+      status: "unhealthy",
+      message: error instanceof Error ? error.message : "HTTP service check failed"
+    };
+  }
+}
+__name(checkHttpService, "checkHttpService");
+
+// ../../packages/infrastructure/dist/metrics/core/events.js
+var AnalyticsEvents = {
+  // ===== Authentication Events (6) =====
+  AUTH_SIGNUP_COMPLETED: "auth_signup_completed",
+  AUTH_LOGIN_COMPLETED: "auth_login_completed",
+  AUTH_LOGOUT_COMPLETED: "auth_logout_completed",
+  AUTH_EMAIL_VERIFIED: "auth_email_verified",
+  AUTH_PASSWORD_RESET_REQUESTED: "auth_password_reset_requested",
+  AUTH_PASSWORD_RESET_COMPLETED: "auth_password_reset_completed",
+  // ===== Snapshot Events (20) =====
+  SNAPSHOT_CREATED: "snapshot_created",
+  SNAPSHOT_RESTORED: "snapshot_restored",
+  SNAPSHOT_DELETED: "snapshot_deleted",
+  SNAPSHOT_SEARCHED: "snapshot_searched",
+  SNAPSHOT_LIMIT_HIT: "snapshot_limit_hit",
+  SNAPSHOT_AUTO_CREATED: "snapshot_auto_created",
+  SNAPSHOT_SHARED: "snapshot_shared",
+  SNAPSHOT_EXPORTED: "snapshot_exported",
+  SNAPSHOT_VIEWED: "snapshot_viewed",
+  SNAPSHOT_DIFF_VIEWED: "snapshot_diff_viewed",
+  // Removed duplicate snapshot_checkpoint_* events to maintain consistent terminology
+  // ===== Billing/Monetization Events (12) =====
+  BILLING_UPGRADE_PROMPT_SHOWN: "billing_upgrade_prompt_shown",
+  BILLING_UPGRADE_PROMPT_CLICKED: "billing_upgrade_prompt_clicked",
+  BILLING_PRICING_VIEWED: "billing_pricing_viewed",
+  BILLING_CHECKOUT_STARTED: "billing_checkout_started",
+  BILLING_CHECKOUT_COMPLETED: "billing_checkout_completed",
+  BILLING_CHECKOUT_ABANDONED: "billing_checkout_abandoned",
+  BILLING_SUBSCRIPTION_UPGRADED: "billing_subscription_upgraded",
+  BILLING_SUBSCRIPTION_DOWNGRADED: "billing_subscription_downgraded",
+  BILLING_SUBSCRIPTION_CANCELLED: "billing_subscription_cancelled",
+  BILLING_PAYMENT_FAILED: "billing_payment_failed",
+  BILLING_COUPON_APPLIED: "billing_coupon_applied",
+  BILLING_INVOICE_VIEWED: "billing_invoice_viewed",
+  // ===== Extension Events (8) =====
+  EXTENSION_INSTALLED: "extension_installed",
+  EXTENSION_ACTIVATED: "extension_activated",
+  EXTENSION_COMMAND_USED: "extension_command_used",
+  EXTENSION_SETTINGS_CHANGED: "extension_settings_changed",
+  EXTENSION_ERROR_OCCURRED: "extension_error_occurred",
+  EXTENSION_UPDATED: "extension_updated",
+  EXTENSION_UNINSTALLED: "extension_uninstalled",
+  EXTENSION_FEEDBACK_SUBMITTED: "extension_feedback_submitted",
+  // ===== Dashboard Events (8) =====
+  DASHBOARD_VIEWED: "dashboard_viewed",
+  DASHBOARD_API_KEY_CREATED: "dashboard_api_key_created",
+  DASHBOARD_API_KEY_REVOKED: "dashboard_api_key_revoked",
+  DASHBOARD_USAGE_CHART_VIEWED: "dashboard_usage_chart_viewed",
+  DASHBOARD_SETTINGS_UPDATED: "dashboard_settings_updated",
+  DASHBOARD_SEARCH_PERFORMED: "dashboard_search_performed",
+  DASHBOARD_EXPORT_TRIGGERED: "dashboard_export_triggered",
+  DASHBOARD_HELP_ACCESSED: "dashboard_help_accessed",
+  // ===== Team Collaboration Events (6) =====
+  TEAM_CREATED: "team_created",
+  TEAM_MEMBER_INVITED: "team_member_invited",
+  TEAM_MEMBER_JOINED: "team_member_joined",
+  TEAM_SNAPSHOT_SHARED: "team_snapshot_shared",
+  TEAM_SETTINGS_CHANGED: "team_settings_changed",
+  TEAM_MEMBER_REMOVED: "team_member_removed",
+  // ===== AI Features Events (5) =====
+  AI_SUGGESTION_SHOWN: "ai_suggestion_shown",
+  AI_SUGGESTION_ACCEPTED: "ai_suggestion_accepted",
+  AI_SUGGESTION_REJECTED: "ai_suggestion_rejected",
+  AI_RISK_DETECTED: "ai_risk_detected",
+  AI_RISK_PREVENTED: "ai_risk_prevented",
+  // ===== API Usage Events (5) =====
+  API_CALL_MADE: "api_call_made",
+  API_RATE_LIMIT_HIT: "api_rate_limit_hit",
+  API_ERROR_OCCURRED: "api_error_occurred",
+  API_KEY_ROTATED: "api_key_rotated",
+  API_WEBHOOK_CONFIGURED: "api_webhook_configured",
+  // ===== Intelligence Layer: Prediction & Learning (6) =====
+  PREDICTION_MADE: "prediction_made",
+  PREDICTION_OUTCOME_RECORDED: "prediction_outcome_recorded",
+  TRUST_SCORE_UPDATED: "trust_score_updated",
+  PATTERN_DETECTED: "pattern_detected",
+  PATTERN_CONFIRMED: "pattern_confirmed",
+  MODEL_CALIBRATION_TRIGGERED: "model_calibration_triggered",
+  // ===== Intelligence Layer: Cross-Repo Intelligence (4) =====
+  WORKSPACE_CONNECTED: "workspace_connected",
+  CROSS_REPO_PATTERN_DETECTED: "cross_repo_pattern_detected",
+  REPO_PERSONALITY_UPDATED: "repo_personality_updated",
+  GLOBAL_INSIGHT_APPLIED: "global_insight_applied",
+  // ===== Intelligence Layer: GitHub Integration (5) =====
+  GITHUB_REPO_CONNECTED: "github_repo_connected",
+  GITHUB_PR_ANALYZED: "github_pr_analyzed",
+  GITHUB_COMMIT_SCANNED: "github_commit_scanned",
+  GITHUB_AI_CONTRIBUTION_DETECTED: "github_ai_contribution_detected",
+  GITHUB_CHECK_POSTED: "github_check_posted",
+  // ===== Intelligence Layer: MCP Tools (3) =====
+  MCP_TOOL_CALLED: "mcp_tool_called",
+  MCP_CONTEXT_PROVIDED: "mcp_context_provided",
+  MCP_AGENT_SELF_CHECK: "mcp_agent_self_check",
+  // ===== Intelligence Layer: Community & Engagement (6) =====
+  DISASTER_STORY_SHARED: "disaster_story_shared",
+  FEEDBACK_SUBMITTED: "feedback_submitted",
+  COMMUNITY_ACTION_COMPLETED: "community_action_completed",
+  BETA_ELIGIBILITY_CALCULATED: "beta_eligibility_calculated",
+  REFERRAL_LINK_GENERATED: "referral_link_generated",
+  REFERRAL_CONVERTED: "referral_converted",
+  // ===== Activation Funnel Events (2) =====
+  AUTH_COMPLETED: "auth_completed",
+  FIRST_SNAPSHOT_CREATED: "first_snapshot_created"
+};
+
+// ../../packages/infrastructure/dist/neon/index.js
+var neon_exports = {};
+__export(neon_exports, {
+  NeonDocClient: () => NeonDocClient,
+  runMigration: () => runMigration,
+  verifySchema: () => verifySchema
+});
+var NeonDocClient = class {
+  static {
+    __name(this, "NeonDocClient");
+  }
+  sql;
+  constructor(config) {
+    if (config.enableCache !== false) {
+      neonConfig.fetchConnectionCache = true;
+    }
+    this.sql = neon(config.connectionString);
+  }
+  /**
+   * Execute hybrid search against doc_embeddings
+   *
+   * @param queryEmbedding - 768-dim vector from text-embedding-3-small
+   * @param options - Search filters and limits
+   * @returns Ranked search results with similarity scores
+   */
+  async hybridSearch(queryEmbedding, options = {}) {
+    if (queryEmbedding.length !== 768) {
+      throw new Error(`Expected 768-dim embedding, got ${queryEmbedding.length}`);
+    }
+    const { library = null, version = null, limit = 5, similarityThreshold = 0.75 } = options;
+    const embeddingStr = `[${queryEmbedding.join(",")}]`;
+    const results = await this.sql`
+      SELECT * FROM hybrid_search(
+        ${embeddingStr}::vector(768),
+        ${library},
+        ${version},
+        ${limit},
+        ${similarityThreshold}
+      )
+    `;
+    return results;
+  }
+  /**
+   * Insert a single doc embedding
+   *
+   * @param doc - Document embedding record
+   * @returns Inserted record ID
+   */
+  async insertDoc(doc) {
+    if (doc.embedding.length !== 768) {
+      throw new Error(`Expected 768-dim embedding, got ${doc.embedding.length}`);
+    }
+    const embeddingStr = `[${doc.embedding.join(",")}]`;
+    const result = await this.sql`
+      INSERT INTO doc_embeddings (library, version, doc_type, chunk_text, embedding, metadata, source_url)
+      VALUES (
+        ${doc.library},
+        ${doc.version},
+        ${doc.doc_type},
+        ${doc.chunk_text},
+        ${embeddingStr}::vector(768),
+        ${JSON.stringify(doc.metadata)},
+        ${doc.source_url}
+      )
+      ON CONFLICT (library, version, chunk_text)
+      DO UPDATE SET
+        embedding = EXCLUDED.embedding,
+        metadata = EXCLUDED.metadata,
+        indexed_at = NOW()
+      RETURNING id
+    `;
+    return result[0]?.id ?? "";
+  }
+  /**
+   * Batch insert doc embeddings (optimized for bulk ingestion)
+   *
+   * @param docs - Array of document embeddings
+   * @returns Count of inserted/updated records
+   */
+  async batchInsertDocs(docs) {
+    if (docs.length === 0) {
+      return 0;
+    }
+    for (const doc of docs) {
+      if (doc.embedding.length !== 768) {
+        throw new Error(`Expected 768-dim embedding, got ${doc.embedding.length}`);
+      }
+    }
+    let count = 0;
+    for (const doc of docs) {
+      await this.insertDoc(doc);
+      count++;
+    }
+    return count;
+  }
+  /**
+   * Get embedding stats (total chunks, by library, etc.)
+   */
+  async getStats() {
+    const totalResult = await this.sql`SELECT COUNT(*) as count FROM doc_embeddings`;
+    const total = Number(totalResult[0]?.count ?? 0);
+    const byLibraryResult = await this.sql`
+      SELECT library, COUNT(*) as count 
+      FROM doc_embeddings 
+      GROUP BY library
+    `;
+    const byDocTypeResult = await this.sql`
+      SELECT doc_type, COUNT(*) as count 
+      FROM doc_embeddings 
+      GROUP BY doc_type
+    `;
+    return {
+      total,
+      byLibrary: Object.fromEntries(byLibraryResult.map((r) => [
+        r.library,
+        Number(r.count)
+      ])),
+      byDocType: Object.fromEntries(byDocTypeResult.map((r) => [
+        r.doc_type,
+        Number(r.count)
+      ]))
+    };
+  }
+};
+var __filename$1 = fileURLToPath(import.meta.url);
+var __dirname$1 = dirname(__filename$1);
+async function runMigration(connectionString) {
+  try {
+    const sql = neon(connectionString);
+    const schemaPath = join(__dirname$1, "schema.sql");
+    const schemaSql = readFileSync(schemaPath, "utf-8");
+    await sql(schemaSql);
+    return {
+      success: true
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+__name(runMigration, "runMigration");
+async function verifySchema(connectionString) {
+  try {
+    const sql = neon(connectionString);
+    const tableCheck = await sql`
+      SELECT EXISTS (
+        SELECT FROM information_schema.tables 
+        WHERE table_name = 'doc_embeddings'
+      ) as exists
+    `;
+    const tableExists = tableCheck[0]?.exists === true;
+    const indexCheck = await sql`
+      SELECT EXISTS (
+        SELECT FROM pg_indexes 
+        WHERE indexname = 'doc_embeddings_hnsw_idx'
+      ) as exists
+    `;
+    const hnswIndexExists = indexCheck[0]?.exists === true;
+    const functionCheck = await sql`
+      SELECT EXISTS (
+        SELECT FROM pg_proc 
+        WHERE proname = 'hybrid_search'
+      ) as exists
+    `;
+    const hybridSearchFunctionExists = functionCheck[0]?.exists === true;
+    const valid = tableExists && hnswIndexExists && hybridSearchFunctionExists;
+    return {
+      valid,
+      checks: {
+        tableExists,
+        hnswIndexExists,
+        hybridSearchFunctionExists
+      }
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      checks: {
+        tableExists: false,
+        hnswIndexExists: false,
+        hybridSearchFunctionExists: false
+      },
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+__name(verifySchema, "verifySchema");
+async function createAlert(config) {
+  try {
+    logger.info({
+      alert: config
+    }, "PostHog Alert Configuration (Manual Setup Required)");
+    return `alert_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+  } catch (error) {
+    logger.error({
+      error,
+      config
+    }, "Failed to create PostHog alert");
+    throw new Error("Failed to create PostHog alert");
+  }
+}
+__name(createAlert, "createAlert");
+async function getAlerts() {
+  try {
+    return [];
+  } catch (error) {
+    logger.error({
+      error
+    }, "Failed to fetch PostHog alerts");
+    throw new Error("Failed to fetch PostHog alerts");
+  }
+}
+__name(getAlerts, "getAlerts");
+async function toggleAlert(alertId, enabled) {
+  try {
+    logger.info({
+      alertId,
+      enabled
+    }, "Toggling PostHog alert");
+    return true;
+  } catch (error) {
+    logger.error({
+      error,
+      alertId,
+      enabled
+    }, "Failed to toggle PostHog alert");
+    throw new Error("Failed to toggle PostHog alert");
+  }
+}
+__name(toggleAlert, "toggleAlert");
+async function deleteAlert(alertId) {
+  try {
+    logger.info({
+      alertId
+    }, "Deleting PostHog alert");
+    return true;
+  } catch (error) {
+    logger.error({
+      error,
+      alertId
+    }, "Failed to delete PostHog alert");
+    throw new Error("Failed to delete PostHog alert");
+  }
+}
+__name(deleteAlert, "deleteAlert");
+var KEY_METRIC_ALERTS = [
+  {
+    name: "TTFV p75 Alert",
+    insightId: "ttfv_insight",
+    series: "ttfv_p75",
+    type: "value",
+    threshold: 7,
+    thresholdType: "absolute",
+    frequency: "daily",
+    recipients: [
+      "engineering-team@snapback.ai"
+    ]
+  },
+  {
+    name: "Onboarding Completion Rate Alert",
+    insightId: "onboarding_insight",
+    series: "completion_rate",
+    type: "value",
+    threshold: 60,
+    thresholdType: "absolute",
+    frequency: "daily",
+    recipients: [
+      "product-team@snapback.ai"
+    ]
+  },
+  {
+    name: "Crash-free Sessions Alert",
+    insightId: "crash_insight",
+    series: "crash_free_rate",
+    type: "value",
+    threshold: 95,
+    thresholdType: "absolute",
+    frequency: "daily",
+    recipients: [
+      "engineering-team@snapback.ai"
+    ]
+  },
+  {
+    name: "Replay Budget Alert",
+    insightId: "replay_insight",
+    series: "replay_budget",
+    type: "value",
+    threshold: 80,
+    thresholdType: "percentage",
+    frequency: "weekly",
+    recipients: [
+      "analytics-team@snapback.ai"
+    ]
+  },
+  {
+    name: "D7 Retention Alert",
+    insightId: "retention_insight",
+    series: "d7_retention",
+    type: "decrease",
+    threshold: 5,
+    thresholdType: "percentage",
+    frequency: "weekly",
+    recipients: [
+      "growth-team@snapback.ai"
+    ]
+  }
+];
+var posthogClient = null;
+var posthogApiKey = null;
+var posthogHost = null;
+function getPostHog() {
+  if (!posthogClient) {
+    const posthogKey = process.env.POSTHOG_PERSONAL_API_KEY;
+    if (!posthogKey) {
+      throw new Error("PostHog personal API key not configured");
+    }
+    const host = process.env.POSTHOG_HOST || "https://app.posthog.com";
+    posthogClient = new PostHog(posthogKey, {
+      host
+    });
+    posthogApiKey = posthogKey;
+    posthogHost = host;
+  }
+  return posthogClient;
+}
+__name(getPostHog, "getPostHog");
+function getPostHogConfig() {
+  if (!posthogApiKey || !posthogHost) {
+    getPostHog();
+  }
+  if (!posthogApiKey || !posthogHost) {
+    throw new Error("PostHog configuration not initialized");
+  }
+  return {
+    apiKey: posthogApiKey,
+    host: posthogHost
+  };
+}
+__name(getPostHogConfig, "getPostHogConfig");
+async function createCohort(config) {
+  try {
+    getPostHog();
+    const phConfig = getPostHogConfig();
+    const response = await fetch(`${phConfig.host}/api/projects/@current/cohorts/`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${phConfig.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        name: config.name,
+        description: config.description,
+        filters: config.filters,
+        is_static: config.is_static
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to create cohort: ${response.statusText}`);
+    }
+    const cohort = await response.json();
+    logger.info({
+      cohort
+    }, "Created PostHog cohort");
+    return cohort;
+  } catch (error) {
+    logger.error({
+      error,
+      config
+    }, "Failed to create PostHog cohort");
+    throw new Error(`Failed to create PostHog cohort: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+__name(createCohort, "createCohort");
+async function getCohorts() {
+  try {
+    getPostHog();
+    const phConfig = getPostHogConfig();
+    const response = await fetch(`${phConfig.host}/api/projects/@current/cohorts/`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${phConfig.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch cohorts: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.results || [];
+  } catch (error) {
+    logger.error({
+      error
+    }, "Failed to fetch PostHog cohorts");
+    throw new Error(`Failed to fetch PostHog cohorts: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+__name(getCohorts, "getCohorts");
+async function getCohort(cohortId) {
+  try {
+    getPostHog();
+    const phConfig = getPostHogConfig();
+    const response = await fetch(`${phConfig.host}/api/projects/@current/cohorts/${cohortId}/`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${phConfig.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch cohort: ${response.statusText}`);
+    }
+    const cohort = await response.json();
+    return cohort;
+  } catch (error) {
+    logger.error({
+      error,
+      cohortId
+    }, "Failed to fetch PostHog cohort");
+    throw new Error(`Failed to fetch PostHog cohort: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+__name(getCohort, "getCohort");
+async function updateCohort(cohortId, config) {
+  try {
+    getPostHog();
+    const phConfig = getPostHogConfig();
+    const response = await fetch(`${phConfig.host}/api/projects/@current/cohorts/${cohortId}/`, {
+      method: "PATCH",
+      headers: {
+        Authorization: `Bearer ${phConfig.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(config)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to update cohort: ${response.statusText}`);
+    }
+    const cohort = await response.json();
+    logger.info({
+      cohort
+    }, "Updated PostHog cohort");
+    return cohort;
+  } catch (error) {
+    logger.error({
+      error,
+      cohortId,
+      config
+    }, "Failed to update PostHog cohort");
+    throw new Error(`Failed to update PostHog cohort: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+__name(updateCohort, "updateCohort");
+async function deleteCohort(cohortId) {
+  try {
+    getPostHog();
+    const phConfig = getPostHogConfig();
+    const response = await fetch(`${phConfig.host}/api/projects/@current/cohorts/${cohortId}/`, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${phConfig.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to delete cohort: ${response.statusText}`);
+    }
+    logger.info({
+      cohortId
+    }, "Deleted PostHog cohort");
+  } catch (error) {
+    logger.error({
+      error,
+      cohortId
+    }, "Failed to delete PostHog cohort");
+    throw new Error(`Failed to delete PostHog cohort: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+__name(deleteCohort, "deleteCohort");
+async function getCohortMembers(cohortId) {
+  try {
+    getPostHog();
+    const phConfig = getPostHogConfig();
+    const response = await fetch(`${phConfig.host}/api/projects/@current/cohorts/${cohortId}/persons/`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${phConfig.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch cohort members: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data.results || [];
+  } catch (error) {
+    logger.error({
+      error,
+      cohortId
+    }, "Failed to fetch PostHog cohort members");
+    throw new Error(`Failed to fetch PostHog cohort members: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+__name(getCohortMembers, "getCohortMembers");
+var RETENTION_COHORTS = [
+  {
+    name: "D7 Retention",
+    description: "Users who return within 7 days of their first activity",
+    filters: {
+      properties: [
+        {
+          key: "first_seen",
+          value: "7 days",
+          operator: "within",
+          type: "event"
+        }
+      ]
+    }
+  },
+  {
+    name: "D30 Retention",
+    description: "Users who return within 30 days of their first activity",
+    filters: {
+      properties: [
+        {
+          key: "first_seen",
+          value: "30 days",
+          operator: "within",
+          type: "event"
+        }
+      ]
+    }
+  },
+  {
+    name: "Onboarding Completion Cohort",
+    description: "Users who completed the onboarding process",
+    filters: {
+      properties: [
+        {
+          key: "onboarding_completed",
+          value: true,
+          operator: "exact",
+          type: "event"
+        }
+      ]
+    }
+  },
+  {
+    name: "High Engagement Users",
+    description: "Users with high engagement (5+ sessions in 7 days)",
+    filters: {
+      properties: [
+        {
+          key: "session_count",
+          value: 5,
+          operator: "gt",
+          type: "event"
+        },
+        {
+          key: "activity_period",
+          value: "7 days",
+          operator: "within",
+          type: "event"
+        }
+      ]
+    }
+  }
+];
+var CORRELATION_COHORTS = [
+  {
+    name: "Feature Power Users",
+    description: "Users who use advanced features regularly",
+    filters: {
+      properties: [
+        {
+          key: "advanced_feature_usage",
+          value: true,
+          operator: "exact",
+          type: "event"
+        }
+      ]
+    }
+  },
+  {
+    name: "At-Risk Churn",
+    description: "Users showing signs of disengagement",
+    filters: {
+      properties: [
+        {
+          key: "days_since_last_activity",
+          value: 14,
+          operator: "gt",
+          type: "event"
+        }
+      ]
+    }
+  },
+  {
+    name: "Free to Paid Converters",
+    description: "Users who upgraded from free to paid plan",
+    filters: {
+      properties: [
+        {
+          key: "plan_upgrade",
+          value: "free_to_paid",
+          operator: "exact",
+          type: "event"
+        }
+      ]
+    }
+  }
+];
+var posthogClient2 = null;
+function getPostHog2() {
+  if (!posthogClient2) {
+    const posthogKey = process.env.POSTHOG_PERSONAL_API_KEY;
+    if (!posthogKey) {
+      throw new Error("PostHog personal API key not configured");
+    }
+    const posthogHost2 = process.env.POSTHOG_HOST || "https://app.posthog.com";
+    posthogClient2 = new PostHog(posthogKey, {
+      host: posthogHost2
+    });
+  }
+  return posthogClient2;
+}
+__name(getPostHog2, "getPostHog");
+async function performCorrelationAnalysis(config) {
+  try {
+    const _posthog = getPostHog2();
+    logger.info({
+      config
+    }, "Performing correlation analysis");
+    const results = config.propertyNames.map((property, _index) => ({
+      property,
+      correlation: Math.random() * 2 - 1,
+      count: Math.floor(Math.random() * 1e3) + 100,
+      relativeFrequency: Math.random()
+    }));
+    results.sort((a, b) => Math.abs(b.correlation) - Math.abs(a.correlation));
+    const analysis = {
+      id: `correlation_${Date.now()}`,
+      name: config.name,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+      results: results.slice(0, 10)
+    };
+    logger.info({
+      analysis
+    }, "Correlation analysis completed");
+    return analysis;
+  } catch (error) {
+    logger.error({
+      error,
+      config
+    }, "Failed to perform correlation analysis");
+    throw new Error(`Failed to perform correlation analysis: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+__name(performCorrelationAnalysis, "performCorrelationAnalysis");
+async function getCorrelationAnalysis(analysisId) {
+  try {
+    throw new Error("Correlation analysis persistence not implemented");
+  } catch (error) {
+    logger.error({
+      error,
+      analysisId
+    }, "Failed to fetch correlation analysis");
+    throw new Error(`Failed to fetch correlation analysis: ${error instanceof Error ? error.message : "Unknown error"}`);
+  }
+}
+__name(getCorrelationAnalysis, "getCorrelationAnalysis");
+var CORRELATION_ANALYSES = [
+  {
+    name: "Onboarding Completion Factors",
+    eventName: "onboarding_completed",
+    propertyNames: [
+      "signup_source",
+      "device_type",
+      "browser",
+      "utm_campaign",
+      "time_to_complete",
+      "steps_completed",
+      "help_articles_viewed"
+    ]
+  },
+  {
+    name: "Feature Adoption Correlations",
+    eventName: "feature_used",
+    propertyNames: [
+      "user_plan",
+      "account_age_days",
+      "session_frequency",
+      "support_tickets",
+      "documentation_views",
+      "community_posts"
+    ]
+  },
+  {
+    name: "Churn Risk Indicators",
+    eventName: "account_deactivated",
+    propertyNames: [
+      "days_since_last_activity",
+      "feature_usage_count",
+      "support_ticket_count",
+      "billing_issues",
+      "plan_downgrade",
+      "session_duration_avg"
+    ]
+  },
+  {
+    name: "High Value User Characteristics",
+    eventName: "plan_upgraded",
+    propertyNames: [
+      "initial_plan",
+      "signup_source",
+      "feature_discovery_rate",
+      "engagement_score",
+      "referral_count",
+      "content_creation"
+    ]
+  }
+];
+
+// ../../packages/infrastructure/dist/prometheus/index.js
+var prometheus_exports = {};
+__export(prometheus_exports, {
+  client: () => client,
+  dbConnections: () => dbConnections,
+  dbQueryDurationSeconds: () => dbQueryDurationSeconds,
+  getContentType: () => getContentType,
+  getMetrics: () => getMetrics,
+  healthCheckDurationSeconds: () => healthCheckDurationSeconds,
+  healthCheckFailuresTotal: () => healthCheckFailuresTotal,
+  healthCheckLastSuccessTimestamp: () => healthCheckLastSuccessTimestamp,
+  healthCheckStatus: () => healthCheckStatus,
+  httpRequestDurationSeconds: () => httpRequestDurationSeconds,
+  httpRequestsTotal: () => httpRequestsTotal,
+  mcpActiveSessions: () => mcpActiveSessions,
+  mcpProxyErrorsTotal: () => mcpProxyErrorsTotal,
+  readinessProbeLastSuccessTimestamp: () => readinessProbeLastSuccessTimestamp,
+  readinessProbeStatus: () => readinessProbeStatus,
+  recordHealthCheck: () => recordHealthCheck,
+  recordReadinessProbe: () => recordReadinessProbe,
+  recordStartupComplete: () => recordStartupComplete,
+  registry: () => registry,
+  sseConnectionsTotal: () => sseConnectionsTotal,
+  startupProbeDurationSeconds: () => startupProbeDurationSeconds,
+  startupProbeFailuresTotal: () => startupProbeFailuresTotal
+});
+var registry = new client.Registry();
+var defaultMetrics = client.collectDefaultMetrics;
+defaultMetrics({
+  register: registry
+});
+var healthCheckStatus = new client.Gauge({
+  name: "health_check_status",
+  help: "Current health check status (1=healthy, 0=unhealthy)",
+  labelNames: [
+    "service",
+    "check"
+  ],
+  registers: [
+    registry
+  ]
+});
+var healthCheckFailuresTotal = new client.Counter({
+  name: "health_check_failures_total",
+  help: "Total number of health check failures",
+  labelNames: [
+    "service",
+    "check",
+    "reason"
+  ],
+  registers: [
+    registry
+  ]
+});
+var healthCheckDurationSeconds = new client.Histogram({
+  name: "health_check_duration_seconds",
+  help: "Duration of health check execution in seconds",
+  labelNames: [
+    "service",
+    "check"
+  ],
+  buckets: [
+    1e-3,
+    5e-3,
+    0.01,
+    0.025,
+    0.05,
+    0.1,
+    0.25,
+    0.5,
+    1,
+    2.5,
+    5,
+    10
+  ],
+  registers: [
+    registry
+  ]
+});
+var healthCheckLastSuccessTimestamp = new client.Gauge({
+  name: "health_check_last_success_timestamp_seconds",
+  help: "Unix timestamp of the last successful health check",
+  labelNames: [
+    "service",
+    "check"
+  ],
+  registers: [
+    registry
+  ]
+});
+var startupProbeFailuresTotal = new client.Counter({
+  name: "startup_probe_failures_total",
+  help: "Total number of startup probe failures",
+  labelNames: [
+    "service"
+  ],
+  registers: [
+    registry
+  ]
+});
+var startupProbeDurationSeconds = new client.Gauge({
+  name: "startup_probe_duration_seconds",
+  help: "Time taken for service startup in seconds",
+  labelNames: [
+    "service"
+  ],
+  registers: [
+    registry
+  ]
+});
+var readinessProbeStatus = new client.Gauge({
+  name: "readiness_probe_status",
+  help: "Current readiness probe status (1=ready, 0=not_ready)",
+  labelNames: [
+    "service"
+  ],
+  registers: [
+    registry
+  ]
+});
+var readinessProbeLastSuccessTimestamp = new client.Gauge({
+  name: "readiness_probe_last_success_timestamp_seconds",
+  help: "Unix timestamp of the last successful readiness probe",
+  labelNames: [
+    "service"
+  ],
+  registers: [
+    registry
+  ]
+});
+var httpRequestDurationSeconds = new client.Histogram({
+  name: "http_request_duration_seconds",
+  help: "Duration of HTTP requests in seconds",
+  labelNames: [
+    "method",
+    "path",
+    "status"
+  ],
+  buckets: [
+    1e-3,
+    5e-3,
+    0.01,
+    0.025,
+    0.05,
+    0.1,
+    0.25,
+    0.5,
+    1,
+    2.5,
+    5
+  ],
+  registers: [
+    registry
+  ]
+});
+var httpRequestsTotal = new client.Counter({
+  name: "http_requests_total",
+  help: "Total number of HTTP requests",
+  labelNames: [
+    "method",
+    "path",
+    "status"
+  ],
+  registers: [
+    registry
+  ]
+});
+var dbConnections = new client.Gauge({
+  name: "db_connections",
+  help: "Current number of database connections",
+  labelNames: [
+    "pool",
+    "state"
+  ],
+  registers: [
+    registry
+  ]
+});
+var dbQueryDurationSeconds = new client.Histogram({
+  name: "db_query_duration_seconds",
+  help: "Duration of database queries in seconds",
+  labelNames: [
+    "operation",
+    "table"
+  ],
+  buckets: [
+    1e-3,
+    5e-3,
+    0.01,
+    0.025,
+    0.05,
+    0.1,
+    0.25,
+    0.5,
+    1
+  ],
+  registers: [
+    registry
+  ]
+});
+var mcpActiveSessions = new client.Gauge({
+  name: "mcp_active_sessions",
+  help: "Current number of active MCP sessions",
+  registers: [
+    registry
+  ]
+});
+var mcpProxyErrorsTotal = new client.Counter({
+  name: "mcp_proxy_errors_total",
+  help: "Total number of MCP proxy errors",
+  labelNames: [
+    "endpoint",
+    "error_type"
+  ],
+  registers: [
+    registry
+  ]
+});
+var sseConnectionsTotal = new client.Gauge({
+  name: "sse_connections_total",
+  help: "Current number of SSE connections",
+  labelNames: [
+    "service"
+  ],
+  registers: [
+    registry
+  ]
+});
+function recordHealthCheck(service, check, status, durationMs) {
+  const isHealthy = status === "healthy" ? 1 : 0;
+  healthCheckStatus.set({
+    service,
+    check
+  }, isHealthy);
+  healthCheckDurationSeconds.observe({
+    service,
+    check
+  }, durationMs / 1e3);
+  if (status === "healthy") {
+    healthCheckLastSuccessTimestamp.set({
+      service,
+      check
+    }, Date.now() / 1e3);
+  }
+  if (status === "unhealthy") {
+    healthCheckFailuresTotal.inc({
+      service,
+      check,
+      reason: "check_failed"
+    });
+  }
+}
+__name(recordHealthCheck, "recordHealthCheck");
+function recordReadinessProbe(service, isReady) {
+  readinessProbeStatus.set({
+    service
+  }, isReady ? 1 : 0);
+  if (isReady) {
+    readinessProbeLastSuccessTimestamp.set({
+      service
+    }, Date.now() / 1e3);
+  }
+}
+__name(recordReadinessProbe, "recordReadinessProbe");
+function recordStartupComplete(service, durationSeconds) {
+  startupProbeDurationSeconds.set({
+    service
+  }, durationSeconds);
+}
+__name(recordStartupComplete, "recordStartupComplete");
+async function getMetrics() {
+  return registry.metrics();
+}
+__name(getMetrics, "getMetrics");
+function getContentType() {
+  return registry.contentType;
+}
+__name(getContentType, "getContentType");
+
+// ../../packages/infrastructure/dist/sentry/index.js
+var Sentry = null;
+var ProfilingIntegration = null;
+async function loadSentry() {
+  if (Sentry) {
+    return {
+      Sentry,
+      ProfilingIntegration
+    };
+  }
+  if (process.env.DISABLE_SENTRY === "true") {
+    return null;
+  }
+  try {
+    Sentry = await import('@sentry/node');
+    ProfilingIntegration = await import('@sentry/profiling-node');
+    return {
+      Sentry,
+      ProfilingIntegration
+    };
+  } catch (error) {
+    console.warn("\u26A0\uFE0F  Failed to load Sentry:", error instanceof Error ? error.message : String(error));
+    return null;
+  }
+}
+__name(loadSentry, "loadSentry");
+async function initSentry(options) {
+  if (process.env.DISABLE_SENTRY === "true" || options?.enabled === false) {
+    console.log("\u2139\uFE0F  Sentry is disabled");
+    return;
+  }
+  const dsn = options?.dsn || process.env.SENTRY_DSN;
+  if (!dsn) {
+    console.warn("\u26A0\uFE0F  SENTRY_DSN not configured. Error tracking disabled.");
+    return;
+  }
+  const modules = await loadSentry();
+  if (!modules) {
+    return;
+  }
+  const { Sentry: SentryModule, ProfilingIntegration: ProfilingIntegration2 } = modules;
+  SentryModule.init({
+    dsn,
+    environment: options?.environment || process.env.NODE_ENV || "development",
+    release: options?.release || process.env.GIT_SHA || process.env.RELEASE || void 0,
+    tracesSampleRate: options?.tracesSampleRate ?? (process.env.NODE_ENV === "production" ? 0.1 : 1),
+    profilesSampleRate: options?.profilesSampleRate ?? 0.1,
+    debug: options?.debug || process.env.DEBUG_SENTRY === "true",
+    integrations: [
+      new SentryModule.HttpIntegration({
+        tracing: true,
+        request: true
+      }),
+      ...ProfilingIntegration2 ? [
+        ProfilingIntegration2.nodeProfilingIntegration()
+      ] : []
+    ],
+    // Filter out sensitive data
+    beforeSend: /* @__PURE__ */ __name((event) => {
+      if (event?.exception?.values?.[0]?.value?.includes?.("404") || event?.request?.url?.includes?.("/favicon.ico")) {
+        return null;
+      }
+      if (event?.request?.headers) {
+        delete event.request.headers.authorization;
+        delete event.request.headers.cookie;
+      }
+      return event;
+    }, "beforeSend")
+  });
+  console.log("\u2705 Sentry initialized for error tracking");
+}
+__name(initSentry, "initSentry");
+function createSentryMiddleware() {
+  if (!Sentry) {
+    return {
+      requestHandler: /* @__PURE__ */ __name((_c, next) => next(), "requestHandler"),
+      errorHandler: /* @__PURE__ */ __name((_c, next) => next(), "errorHandler")
+    };
+  }
+  return {
+    requestHandler: Sentry.Handlers?.requestHandler?.() || ((_c, next) => next()),
+    errorHandler: Sentry.Handlers?.errorHandler?.() || ((_c, next) => next())
+  };
+}
+__name(createSentryMiddleware, "createSentryMiddleware");
+function captureError(error, context2) {
+  if (process.env.DISABLE_SENTRY === "true" || !Sentry) {
+    return;
+  }
+  Sentry.withScope((scope) => {
+    if (context2) {
+      if (context2.userId) {
+        scope.setUser({
+          id: context2.userId
+        });
+      }
+      if (context2.organizationId) {
+        scope.setTag("organization_id", context2.organizationId);
+      }
+      if (context2.tags) {
+        Object.entries(context2.tags).forEach(([key, value]) => {
+          scope.setTag(key, value);
+        });
+      }
+      if (context2.extra) {
+        scope.setContext("extra", context2.extra);
+      }
+    }
+    if (Sentry) {
+      Sentry.captureException(typeof error === "string" ? new Error(error) : error);
+    }
+  });
+}
+__name(captureError, "captureError");
+function captureMessage(message, level = "info", context2) {
+  if (process.env.DISABLE_SENTRY === "true" || !Sentry) {
+    return;
+  }
+  Sentry.captureMessage(message, level);
+  if (context2) {
+    Sentry.withScope((scope) => {
+      if (context2.userId) {
+        scope.setUser({
+          id: context2.userId
+        });
+      }
+      if (context2.tags) {
+        Object.entries(context2.tags).forEach(([key, value]) => {
+          scope.setTag(key, value);
+        });
+      }
+      if (context2.extra) {
+        scope.setContext("extra", context2.extra);
+      }
+    });
+  }
+}
+__name(captureMessage, "captureMessage");
+function setSentryUser(userId, userInfo) {
+  if (process.env.DISABLE_SENTRY === "true" || !Sentry) {
+    return;
+  }
+  Sentry.setUser({
+    id: userId,
+    email: userInfo?.email,
+    username: userInfo?.username,
+    organization_id: userInfo?.organizationId
+  });
+}
+__name(setSentryUser, "setSentryUser");
+function clearSentryUser() {
+  if (process.env.DISABLE_SENTRY === "true" || !Sentry) {
+    return;
+  }
+  Sentry.setUser(null);
+}
+__name(clearSentryUser, "clearSentryUser");
+function addSentryBreadcrumb(message, data, level = "info") {
+  if (process.env.DISABLE_SENTRY === "true" || !Sentry) {
+    return;
+  }
+  Sentry.addBreadcrumb({
+    message,
+    level,
+    data,
+    timestamp: Date.now() / 1e3
+  });
+}
+__name(addSentryBreadcrumb, "addSentryBreadcrumb");
+function startSentryTransaction(name, op) {
+  if (process.env.DISABLE_SENTRY === "true") {
+    return null;
+  }
+  return Sentry.startTransaction?.({
+    name,
+    op: op || "operation"
+  }) || null;
+}
+__name(startSentryTransaction, "startSentryTransaction");
+async function flushSentry(timeout = 2e3) {
+  if (process.env.DISABLE_SENTRY === "true" || !Sentry) {
+    return true;
+  }
+  return await Sentry.close(timeout);
+}
+__name(flushSentry, "flushSentry");
+
+// ../../packages/infrastructure/dist/tracing/error-budget.js
+var ERROR_BUDGET = 0.01;
+var ALERT_THRESHOLD = 5e-3;
+var errorMetrics = {
+  totalRequests: 0,
+  errorCount: 0,
+  lastAlertTime: 0
+};
+function recordSuccess() {
+  errorMetrics.totalRequests++;
+}
+__name(recordSuccess, "recordSuccess");
+function recordError() {
+  errorMetrics.totalRequests++;
+  errorMetrics.errorCount++;
+}
+__name(recordError, "recordError");
+function getErrorRate() {
+  if (errorMetrics.totalRequests === 0) {
+    return 0;
+  }
+  return errorMetrics.errorCount / errorMetrics.totalRequests;
+}
+__name(getErrorRate, "getErrorRate");
+async function checkErrorBudget() {
+  const errorRate = getErrorRate();
+  if (errorRate > ALERT_THRESHOLD && Date.now() - errorMetrics.lastAlertTime > 6e4) {
+    logger.warn({
+      errorRate: `${(errorRate * 100).toFixed(2)}%`,
+      threshold: `${(ALERT_THRESHOLD * 100).toFixed(2)}%`,
+      errorCount: errorMetrics.errorCount,
+      totalRequests: errorMetrics.totalRequests
+    }, "Error rate approaching budget threshold");
+    errorMetrics.lastAlertTime = Date.now();
+  }
+  if (errorRate > ERROR_BUDGET) {
+    logger.error({
+      errorRate: `${(errorRate * 100).toFixed(2)}%`,
+      budget: `${(ERROR_BUDGET * 100).toFixed(2)}%`,
+      errorCount: errorMetrics.errorCount,
+      totalRequests: errorMetrics.totalRequests,
+      recommendation: "Investigate root cause immediately and consider rolling back"
+    }, "\u{1F6A8} Error budget exceeded!");
+    await sendAlert({
+      channel: "#alerts",
+      message: `\u{1F6A8} Error budget exceeded! Current error rate: ${(errorRate * 100).toFixed(2)}% (Budget: ${(ERROR_BUDGET * 100).toFixed(2)}%)`
+    });
+  }
+}
+__name(checkErrorBudget, "checkErrorBudget");
+async function sendAlert(alert) {
+  logger.info(alert, "Alert sent");
+}
+__name(sendAlert, "sendAlert");
+function resetMetrics() {
+  errorMetrics.totalRequests = 0;
+  errorMetrics.errorCount = 0;
+  errorMetrics.lastAlertTime = 0;
+}
+__name(resetMetrics, "resetMetrics");
+function getMetrics2() {
+  return {
+    ...errorMetrics,
+    errorRate: getErrorRate()
+  };
+}
+__name(getMetrics2, "getMetrics");
+var OTelSpanAdapter = class OTelSpanAdapter2 {
+  static {
+    __name(this, "OTelSpanAdapter");
+  }
+  otelSpan;
+  constructor(otelSpan) {
+    this.otelSpan = otelSpan;
+  }
+  setAttribute(key, value) {
+    this.otelSpan.setAttribute(key, value);
+  }
+  setAttributes(attributes) {
+    this.otelSpan.setAttributes(attributes);
+  }
+  addEvent(name, attributes) {
+    this.otelSpan.addEvent(name, attributes);
+  }
+  setStatus(status) {
+    this.otelSpan.setStatus({
+      code: status.code,
+      message: status.message
+    });
+  }
+  recordException(error) {
+    this.otelSpan.recordException(error);
+  }
+  end() {
+    this.otelSpan.end();
+  }
+  isRecording() {
+    return this.otelSpan.isRecording();
+  }
+};
+var OTelInstrumentationProvider = class {
+  static {
+    __name(this, "OTelInstrumentationProvider");
+  }
+  tracer;
+  provider;
+  constructor(config) {
+    const resource = resourceFromAttributes({
+      [ATTR_SERVICE_NAME]: config.serviceName,
+      [ATTR_SERVICE_VERSION]: config.serviceVersion || "unknown",
+      "deployment.environment": config.environment || "development",
+      "service.instance.id": process.pid.toString(),
+      "host.name": process.env.HOSTNAME || "unknown",
+      "process.pid": process.pid
+    });
+    const spanProcessors = [];
+    if (config.collectorUrl) {
+      const otlpExporter = new OTLPTraceExporter({
+        url: config.collectorUrl
+      });
+      spanProcessors.push(new BatchSpanProcessor(otlpExporter));
+    }
+    if (config.enableConsole) {
+      const consoleExporter = new ConsoleSpanExporter();
+      spanProcessors.push(new BatchSpanProcessor(consoleExporter));
+    }
+    const samplingRate = config.sampleRate ?? 1;
+    const sampler = new TraceIdRatioBasedSampler(samplingRate);
+    this.provider = new NodeTracerProvider({
+      resource,
+      sampler,
+      spanProcessors
+    });
+    this.provider.register();
+    const pinoInstrumentation = new PinoInstrumentation({
+      // Keep default log keys: trace_id, span_id, trace_flags
+      // These match standard OTel semantic conventions
+      disableLogSending: true,
+      disableLogCorrelation: false
+    });
+    const pgInstrumentation = new PgInstrumentation({
+      // Add database query attributes to spans
+      requireParentSpan: false,
+      enhancedDatabaseReporting: true
+    });
+    try {
+      pinoInstrumentation.enable();
+      pgInstrumentation.enable();
+    } catch {
+    }
+    this.tracer = trace.getTracer(config.serviceName, config.serviceVersion);
+  }
+  startSpan(name, options) {
+    const otelSpan = this.tracer.startSpan(name, {
+      kind: options?.kind,
+      attributes: options?.attributes,
+      startTime: options?.startTime
+    });
+    return new OTelSpanAdapter(otelSpan);
+  }
+  async withSpan(name, fn, options) {
+    const parentCtx = options?.parent ? options.parent : context.active();
+    return await this.tracer.startActiveSpan(name, {
+      kind: options?.kind,
+      attributes: options?.attributes,
+      startTime: options?.startTime
+    }, parentCtx, async (otelSpan) => {
+      const span = new OTelSpanAdapter(otelSpan);
+      try {
+        const result = await fn(span);
+        otelSpan.setStatus({
+          code: SpanStatusCode.OK
+        });
+        return result;
+      } catch (error) {
+        otelSpan.recordException(error);
+        otelSpan.setStatus({
+          code: SpanStatusCode.ERROR,
+          message: error instanceof Error ? error.message : String(error)
+        });
+        throw error;
+      } finally {
+        otelSpan.end();
+      }
+    });
+  }
+  injectContext(carrier) {
+    propagation.inject(context.active(), carrier);
+  }
+  extractContext(carrier) {
+    const extractedContext = propagation.extract(ROOT_CONTEXT, carrier);
+    const span = trace.getSpan(extractedContext);
+    if (span?.spanContext().traceId) {
+      return extractedContext;
+    }
+    return null;
+  }
+  recordMetric(_name, _value, _attributes) {
+  }
+  recordEvent(_name, _attributes) {
+  }
+  async shutdown() {
+    await this.provider.shutdown();
+  }
+};
+
+// ../../packages/infrastructure/dist/tracing/telemetry-client.js
+var TelemetryClient = class {
+  static {
+    __name(this, "TelemetryClient");
+  }
+  environment;
+  flags = /* @__PURE__ */ new Map();
+  eventQueue = [];
+  flushInterval = 5e3;
+  maxQueueSize = 100;
+  rateLimitWindow = 6e4;
+  eventCounts = /* @__PURE__ */ new Map();
+  lastRateLimitReset = Date.now();
+  proxyUrl;
+  offlineMode = false;
+  constructor(_apiKey, proxyHost, environment) {
+    this.environment = environment;
+    this.proxyUrl = `${proxyHost}/api/telemetry/events`;
+    this.generateAnonymousId();
+    setInterval(() => this.flush(), this.flushInterval);
+  }
+  async initialize() {
+    console.warn("Feature flags not supported in proxy mode");
+  }
+  /**
+   * Set offline mode
+   * @param enabled Whether offline mode is enabled
+   */
+  setOfflineMode(enabled) {
+    this.offlineMode = enabled;
+  }
+  /**
+   * Check if offline mode is enabled
+   * @returns Whether offline mode is enabled
+   */
+  isOfflineMode() {
+    return this.offlineMode;
+  }
+  isEnabled(flag) {
+    const value = this.flags.get(flag) ?? FEATURE_FLAGS[flag];
+    return Boolean(value);
+  }
+  async reloadFlags() {
+    console.warn("Feature flags not supported in proxy mode");
+  }
+  /**
+   * Track a telemetry event with strict typing and validation
+   * @param event The event name (must be from the whitelist)
+   * @param properties The event properties (validated at runtime)
+   */
+  trackEvent(event) {
+    if (!validateTelemetryEvent(event)) {
+      console.warn("Invalid telemetry event, skipping:", event);
+      return;
+    }
+    if (this.offlineMode) {
+      return;
+    }
+    const featureManager = FeatureManager.getInstance();
+    if (!featureManager.isEnabled("telemetry.detailed_events")) {
+      if (![
+        "checkpoint.created",
+        "risk.high",
+        "error"
+      ].includes(event.event)) {
+        return;
+      }
+    }
+    const samplingRate = featureManager.getValue("telemetry.sampling_rate") ?? 1;
+    if (Math.random() > samplingRate) {
+      return;
+    }
+    if (this.isRateLimited(event.event)) {
+      return;
+    }
+    this.eventQueue.push({
+      event: event.event,
+      properties: {
+        ...this.sanitizeProperties(event.properties || {}),
+        environment: this.environment,
+        timestamp: event.timestamp
+      },
+      timestamp: event.timestamp
+    });
+    if (this.eventQueue.length >= this.maxQueueSize) {
+      this.flush();
+    }
+  }
+  /**
+   * Track a telemetry event with string-based event name (legacy compatibility)
+   * @param event The event name
+   * @param properties The event properties
+   */
+  track(event, properties) {
+    const typedEvent = {
+      event,
+      properties,
+      timestamp: Date.now()
+    };
+    this.trackEvent(typedEvent);
+  }
+  isRateLimited(event) {
+    const now = Date.now();
+    if (now - this.lastRateLimitReset > this.rateLimitWindow) {
+      this.eventCounts.clear();
+      this.lastRateLimitReset = now;
+    }
+    const count = this.eventCounts.get(event) || 0;
+    const maxEventsPerWindow = 10;
+    if (count >= maxEventsPerWindow) {
+      return true;
+    }
+    this.eventCounts.set(event, count + 1);
+    return false;
+  }
+  /**
+   * Sanitize properties to remove PII before sending
+   */
+  sanitizeProperties(properties) {
+    const sanitized = {};
+    if (!properties) {
+      return sanitized;
+    }
+    const allowedProps = [
+      "version",
+      "platform",
+      "duration",
+      "success",
+      "filesCount",
+      "method",
+      "trigger",
+      "feature",
+      "viewId",
+      "command"
+    ];
+    for (const key of allowedProps) {
+      if (key in properties) {
+        sanitized[key] = properties[key];
+      }
+    }
+    return sanitized;
+  }
+  generateAnonymousId() {
+    return `${this.environment}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+  /**
+   * Get current package version
+   * @returns The current version string
+   */
+  getVersion() {
+    try {
+      const packageJson = require_package();
+      return packageJson.version || "unknown";
+    } catch (_error) {
+      return process.env.SNAPBACK_VERSION || "1.0.0";
+    }
+  }
+  /**
+   * Custom transport layer - routes all events through proxy
+   */
+  async customTransport(batch) {
+    if (this.offlineMode) {
+      return;
+    }
+    try {
+      const response = await fetch(this.proxyUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "X-SnapBack-Platform": this.environment,
+          "X-SnapBack-Version": this.getVersion()
+        },
+        body: JSON.stringify({
+          events: batch.map((event) => ({
+            event: event.event,
+            properties: this.sanitizeProperties(event.properties || {}),
+            timestamp: event.timestamp
+          }))
+        })
+      });
+      if (!response.ok) {
+        const error = await response.text();
+        console.warn("Telemetry proxy rejected events", {
+          status: response.status,
+          error
+        });
+      }
+    } catch (error) {
+      console.error("Failed to send telemetry through proxy", error);
+    }
+  }
+  async flush() {
+    if (this.offlineMode) {
+      return;
+    }
+    if (this.eventQueue.length === 0) {
+      return;
+    }
+    const eventsToFlush = [
+      ...this.eventQueue
+    ];
+    this.eventQueue = [];
+    try {
+      await this.customTransport(eventsToFlush);
+    } catch (error) {
+      console.warn("Failed to send telemetry events:", error);
+      this.eventQueue.unshift(...eventsToFlush);
+    }
+  }
+};
+
+export { AnalyticsEvents, CORRELATION_ANALYSES, CORRELATION_COHORTS, KEY_METRIC_ALERTS, OTelInstrumentationProvider, RETENTION_COHORTS, TelemetryClient, addSentryBreadcrumb, captureError, captureMessage, checkDatabaseConnection, checkErrorBudget, checkHttpService, checkRedisConnection, clearSentryUser, createAlert, createCohort, createGracefulShutdown, createHealthCheck, createSentryMiddleware, deleteAlert, deleteCohort, detectSurface, drainAndCloseServer, flushSentry, getAlerts, getAnalyticsEnv, getAnalyticsSuperProperties, getCohort, getCohortMembers, getCohorts, getCorrelationAnalysis, getDeploymentEnv, getEnvironmentInfo, getErrorRate, getMetrics2 as getMetrics, initSentry, isDevelopment, isProduction, neon_exports, performCorrelationAnalysis, preStopDelay, prometheus_exports, recordError, recordSuccess, resetMetrics, setSentryUser, startSentryTransaction, toggleAlert, updateCohort };