mcp-scraper 0.47.0 → 0.49.0

package/dist/chunk-YW2LXLDU.js

@@ -0,0 +1,2865 @@
+// src/api/analytics-repository.ts
+import { createHash, createHmac as createHmac2, randomBytes, randomUUID } from "crypto";
+import { Pool } from "pg";
+
+// src/api/session.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var isProduction = () => process.env.NODE_ENV === "production" || process.env.VERCEL === "1";
+function getSessionSecret() {
+  const configured = process.env.SESSION_SECRET?.trim();
+  if (configured) return configured;
+  if (isProduction()) throw new Error("SESSION_SECRET is not set \u2014 add it to your Vercel env vars (see src/api/env.ts)");
+  return "dev-secret-change-me";
+}
+var secret = () => getSessionSecret();
+function safeEqualHex(a, b) {
+  if (a.length !== b.length) return false;
+  try {
+    return timingSafeEqual(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
+  } catch {
+    return false;
+  }
+}
+function signSession(userId) {
+  const payload = String(userId);
+  const sig = createHmac("sha256", secret()).update(payload).digest("hex");
+  return `${payload}.${sig}`;
+}
+function verifySession(token) {
+  const dot = token.lastIndexOf(".");
+  if (dot === -1) return null;
+  const payload = token.slice(0, dot);
+  const sig = token.slice(dot + 1);
+  const expected = createHmac("sha256", secret()).update(payload).digest("hex");
+  if (!safeEqualHex(sig, expected)) return null;
+  const id = parseInt(payload);
+  return isNaN(id) ? null : id;
+}
+
+// src/api/analytics-attribution.ts
+var aliases = [
+  [/perplexity/i, "llm", "Perplexity"],
+  [/chatgpt|chat\.openai|openai/i, "llm", "ChatGPT"],
+  [/claude|anthropic/i, "llm", "Claude"],
+  [/\bgrok\b|xai/i, "llm", "Grok"],
+  [/ai[ _-]?overview|google[ _-]?ai|\bsge\b|gemini/i, "llm", "Google AI Overview"],
+  [/instagram/i, "social", "Instagram"],
+  [/facebook|\bfb\b|meta/i, "social", "Facebook"],
+  [/linkedin/i, "social", "LinkedIn"],
+  [/tiktok/i, "social", "TikTok"],
+  [/youtube|youtu\.be/i, "social", "YouTube"],
+  [/twitter|x\.com/i, "social", "X"],
+  [/\bg2\b|g2\.com/i, "review", "G2"],
+  [/trustpilot/i, "review", "Trustpilot"],
+  [/\bbbb\b|better business bureau/i, "review", "BBB"],
+  [/capterra/i, "review", "Capterra"],
+  [/yelp/i, "review", "Yelp"],
+  [/google|bing|duckduckgo|yahoo/i, "search", "Search"]
+];
+function clean(value, max = 240) {
+  return typeof value === "string" && value.trim() ? value.trim().slice(0, max) : null;
+}
+function referrerHost(referrer) {
+  try {
+    return referrer ? new URL(referrer).hostname.replace(/^www\./, "") : "";
+  } catch {
+    return "";
+  }
+}
+function resolveAnalyticsAttribution(input) {
+  const properties = input.properties ?? {};
+  const source = clean(input.source, 180) || referrerHost(input.referrer) || "(direct)";
+  const medium = clean(input.medium, 180) || (source === "(direct)" ? "(none)" : "referral");
+  const clickIds = input.clickIds ?? {};
+  const haystack = `${source} ${medium} ${referrerHost(input.referrer)}`;
+  let channelFamily = source === "(direct)" ? "direct" : /email|newsletter/i.test(medium) ? "email" : "referral";
+  let platform = source === "(direct)" ? "Direct" : source;
+  for (const [pattern, family, label] of aliases) if (pattern.test(haystack)) {
+    channelFamily = family;
+    platform = label;
+    break;
+  }
+  if (clickIds.fbclid) {
+    channelFamily = "social";
+    platform = /instagram/i.test(haystack) ? "Instagram" : "Facebook";
+  } else if (clickIds.ttclid) {
+    channelFamily = "social";
+    platform = "TikTok";
+  } else if (clickIds.rdt_cid) {
+    channelFamily = "social";
+    platform = "Reddit";
+  } else if (clickIds.gclid || clickIds.gbraid || clickIds.wbraid) {
+    channelFamily = "search";
+    platform = "Google";
+  } else if (clickIds.msclkid) {
+    channelFamily = "search";
+    platform = "Microsoft Ads";
+  }
+  return {
+    channelFamily,
+    platform,
+    source,
+    medium,
+    campaign: clean(input.campaign),
+    campaignId: clean(properties.campaign_id ?? properties.utm_id),
+    adSetId: clean(properties.adset_id ?? properties.ad_set_id ?? properties.adgroup_id ?? properties.ad_group_id),
+    adId: clean(properties.ad_id),
+    creativeId: clean(properties.creative_id),
+    placement: clean(properties.placement),
+    term: clean(properties.utm_term),
+    content: clean(properties.utm_content)
+  };
+}
+
+// src/api/analytics-repository.ts
+var AnalyticsRepositoryError = class extends Error {
+  constructor(code, message, status = 400) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "AnalyticsRepositoryError";
+  }
+  code;
+  status;
+};
+var pool = null;
+function databaseUrl() {
+  const value = process.env.ANALYTICS_DATABASE_URL?.trim();
+  if (!value) {
+    throw new AnalyticsRepositoryError(
+      "analytics_database_unavailable",
+      "Site Analytics is not configured.",
+      503
+    );
+  }
+  return value;
+}
+function getAnalyticsPool() {
+  if (!pool) pool = new Pool({ connectionString: databaseUrl(), max: 8 });
+  return pool;
+}
+async function closeAnalyticsPool() {
+  if (!pool) return;
+  const current = pool;
+  pool = null;
+  await current.end();
+}
+async function migrateAnalytics() {
+  const db = getAnalyticsPool();
+  const client = await db.connect();
+  await client.query("BEGIN");
+  try {
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_schema_migrations (
+        version text PRIMARY KEY,
+        applied_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_sites (
+        id uuid PRIMARY KEY,
+        slug text NOT NULL,
+        name text NOT NULL,
+        owner_user_id bigint NOT NULL,
+        timezone text NOT NULL DEFAULT 'UTC',
+        status text NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'disabled')),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(owner_user_id, slug)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_site_grants (
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        user_id bigint NOT NULL,
+        role text NOT NULL CHECK (role IN ('viewer', 'editor', 'owner')),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        PRIMARY KEY(site_id, user_id)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_pixels (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        public_id text NOT NULL UNIQUE,
+        name text NOT NULL,
+        environment text NOT NULL DEFAULT 'production',
+        status text NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'disabled')),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        disabled_at timestamptz
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_pixel_domains (
+        id uuid PRIMARY KEY,
+        pixel_id uuid NOT NULL REFERENCES analytics_pixels(id) ON DELETE CASCADE,
+        hostname text NOT NULL,
+        state text NOT NULL DEFAULT 'observed_unverified'
+          CHECK (state IN ('observed_unverified', 'approved', 'rejected', 'revoked')),
+        first_seen_at timestamptz NOT NULL DEFAULT now(),
+        last_seen_at timestamptz NOT NULL DEFAULT now(),
+        accepted_count bigint NOT NULL DEFAULT 0,
+        rejected_count bigint NOT NULL DEFAULT 0,
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(pixel_id, hostname)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_events (
+        id uuid PRIMARY KEY,
+        event_id text NOT NULL,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        pixel_id uuid NOT NULL REFERENCES analytics_pixels(id) ON DELETE CASCADE,
+        hostname text NOT NULL,
+        visitor_id text,
+        session_id text,
+        event_name text NOT NULL,
+        occurred_at timestamptz NOT NULL,
+        received_at timestamptz NOT NULL DEFAULT now(),
+        path text NOT NULL DEFAULT '/',
+        canonical_url text,
+        title text,
+        referrer text,
+        source text,
+        medium text,
+        campaign text,
+        device_class text,
+        properties jsonb NOT NULL DEFAULT '{}'::jsonb,
+        bot_status text NOT NULL DEFAULT 'unknown',
+        UNIQUE(site_id, event_id)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_conversions (
+        id uuid PRIMARY KEY,
+        source_event_id text NOT NULL,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        pixel_id uuid REFERENCES analytics_pixels(id) ON DELETE SET NULL,
+        session_id text,
+        conversion_kind text NOT NULL,
+        value_minor bigint NOT NULL DEFAULT 0,
+        currency text NOT NULL DEFAULT 'USD',
+        occurred_at timestamptz NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(site_id, source_event_id)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_ingestion_receipts (
+        id uuid PRIMARY KEY,
+        request_id text NOT NULL UNIQUE,
+        site_id uuid REFERENCES analytics_sites(id) ON DELETE SET NULL,
+        pixel_id uuid REFERENCES analytics_pixels(id) ON DELETE SET NULL,
+        hostname text,
+        accepted_count integer NOT NULL DEFAULT 0,
+        rejected_count integer NOT NULL DEFAULT 0,
+        reason_codes jsonb NOT NULL DEFAULT '[]'::jsonb,
+        created_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_rollups_daily (
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        pixel_id uuid NOT NULL REFERENCES analytics_pixels(id) ON DELETE CASCADE,
+        hostname text NOT NULL,
+        bucket date NOT NULL,
+        source text NOT NULL DEFAULT '(direct)',
+        medium text NOT NULL DEFAULT '(none)',
+        campaign text NOT NULL DEFAULT '(none)',
+        pageviews integer NOT NULL DEFAULT 0,
+        events integer NOT NULL DEFAULT 0,
+        visitors integer NOT NULL DEFAULT 0,
+        sessions integer NOT NULL DEFAULT 0,
+        refreshed_at timestamptz NOT NULL DEFAULT now(),
+        PRIMARY KEY(site_id, pixel_id, hostname, bucket, source, medium, campaign)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_rollup_runs (
+        id uuid PRIMARY KEY,
+        window_start timestamptz NOT NULL,
+        window_end timestamptz NOT NULL,
+        status text NOT NULL CHECK (status IN ('running', 'complete', 'failed')),
+        row_count integer NOT NULL DEFAULT 0,
+        started_at timestamptz NOT NULL DEFAULT now(),
+        completed_at timestamptz,
+        error_code text
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_exports (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        requested_by_user_id bigint NOT NULL,
+        idempotency_key text,
+        report text NOT NULL,
+        format text NOT NULL CHECK (format IN ('csv', 'json', 'markdown')),
+        filters jsonb NOT NULL,
+        content text NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_campaign_links (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        pixel_id uuid REFERENCES analytics_pixels(id) ON DELETE SET NULL,
+        name text NOT NULL,
+        destination_url text NOT NULL,
+        short_code text NOT NULL UNIQUE,
+        utm_source text NOT NULL,
+        utm_medium text NOT NULL,
+        utm_campaign text NOT NULL,
+        utm_term text,
+        utm_content text,
+        ad_group text,
+        ad_name text,
+        creative_id text,
+        status text NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'archived')),
+        created_by_user_id bigint NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_campaign_clicks (
+        id uuid PRIMARY KEY,
+        link_id uuid NOT NULL REFERENCES analytics_campaign_links(id) ON DELETE CASCADE,
+        occurred_at timestamptz NOT NULL DEFAULT now(),
+        referrer text
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_forms (
+        id uuid PRIMARY KEY,
+        public_id text NOT NULL UNIQUE,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        pixel_id uuid NOT NULL REFERENCES analytics_pixels(id) ON DELETE RESTRICT,
+        name text NOT NULL,
+        slug text NOT NULL,
+        fields jsonb NOT NULL,
+        brand jsonb NOT NULL,
+        submit_label text NOT NULL DEFAULT 'Submit',
+        success_message text NOT NULL DEFAULT 'Thank you. Your response was received.',
+        redirect_url text,
+        consent_text text,
+        status text NOT NULL DEFAULT 'draft' CHECK (status IN ('draft', 'published', 'archived')),
+        version integer NOT NULL DEFAULT 1,
+        created_by_user_id bigint NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(site_id, slug)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_form_submissions (
+        id uuid PRIMARY KEY,
+        form_id uuid NOT NULL REFERENCES analytics_forms(id) ON DELETE CASCADE,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        pixel_id uuid NOT NULL REFERENCES analytics_pixels(id) ON DELETE RESTRICT,
+        visitor_id text,
+        session_id text,
+        crm_person_ref text,
+        source text,
+        medium text,
+        campaign text,
+        occurred_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await client.query(
+      `ALTER TABLE analytics_form_submissions ADD COLUMN IF NOT EXISTS crm_delivery_status text NOT NULL DEFAULT 'pending'`
+    );
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_form_delivery_jobs (
+        id uuid PRIMARY KEY,
+        submission_id uuid NOT NULL UNIQUE REFERENCES analytics_form_submissions(id) ON DELETE CASCADE,
+        owner_user_id bigint NOT NULL,
+        payload_ciphertext text NOT NULL,
+        status text NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'delivered', 'failed', 'expired')),
+        attempts integer NOT NULL DEFAULT 0,
+        last_error_code text,
+        next_attempt_at timestamptz NOT NULL DEFAULT now(),
+        expires_at timestamptz NOT NULL DEFAULT now() + interval '7 days',
+        created_at timestamptz NOT NULL DEFAULT now(),
+        delivered_at timestamptz
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_people (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        crm_person_ref text NOT NULL,
+        first_seen_at timestamptz NOT NULL DEFAULT now(),
+        last_seen_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(site_id, crm_person_ref)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_identity_nodes (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        kind text NOT NULL CHECK (kind IN ('visitor_id','session_id','email','phone','customer_id','click_id','device_signal','network_signal')),
+        value_hmac text NOT NULL,
+        first_seen_at timestamptz NOT NULL DEFAULT now(),
+        last_seen_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(site_id, kind, value_hmac)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_identity_edges (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        person_id uuid NOT NULL REFERENCES analytics_people(id) ON DELETE CASCADE,
+        identity_node_id uuid NOT NULL REFERENCES analytics_identity_nodes(id) ON DELETE CASCADE,
+        evidence_kind text NOT NULL,
+        confidence numeric(4,3) NOT NULL CHECK (confidence >= 0 AND confidence <= 1),
+        consent_scope text NOT NULL DEFAULT 'analytics',
+        first_seen_at timestamptz NOT NULL DEFAULT now(),
+        last_seen_at timestamptz NOT NULL DEFAULT now(),
+        UNIQUE(person_id, identity_node_id, evidence_kind)
+      )
+    `);
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS click_ids jsonb NOT NULL DEFAULT '{}'::jsonb`
+    );
+    await client.query(
+      `ALTER TABLE analytics_form_submissions ADD COLUMN IF NOT EXISTS click_ids jsonb NOT NULL DEFAULT '{}'::jsonb`
+    );
+    await client.query(
+      `ALTER TABLE analytics_form_submissions ADD COLUMN IF NOT EXISTS person_id uuid REFERENCES analytics_people(id) ON DELETE SET NULL`
+    );
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS person_id uuid REFERENCES analytics_people(id) ON DELETE SET NULL`
+    );
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS channel_family text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS platform text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS campaign_id text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS ad_set_id text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS ad_id text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS creative_id text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS placement text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS utm_term text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS utm_content text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_conversions ADD COLUMN IF NOT EXISTS person_id uuid REFERENCES analytics_people(id) ON DELETE SET NULL`
+    );
+    await client.query(
+      `ALTER TABLE analytics_sites ADD COLUMN IF NOT EXISTS business_model text NOT NULL DEFAULT 'leadgen' CHECK (business_model IN ('leadgen','saas','ecommerce'))`
+    );
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_ad_spend_daily (
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        bucket date NOT NULL,
+        platform text NOT NULL,
+        campaign text NOT NULL DEFAULT '(all)',
+        spend_minor bigint NOT NULL CHECK (spend_minor >= 0),
+        currency text NOT NULL DEFAULT 'USD',
+        source_ref text,
+        updated_at timestamptz NOT NULL DEFAULT now(),
+        PRIMARY KEY(site_id, bucket, platform, campaign)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_crm_imports (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        requested_by_user_id bigint NOT NULL,
+        source_system text NOT NULL,
+        filename text NOT NULL,
+        status text NOT NULL DEFAULT 'queued' CHECK (status IN ('queued','processing','complete','partial','failed')),
+        accepted_count integer NOT NULL DEFAULT 0,
+        rejected_count integer NOT NULL DEFAULT 0,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        completed_at timestamptz
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_crm_import_rows (
+        id uuid PRIMARY KEY,
+        import_id uuid NOT NULL REFERENCES analytics_crm_imports(id) ON DELETE CASCADE,
+        crm_person_ref text NOT NULL,
+        payload_ciphertext text NOT NULL,
+        delivery_status text NOT NULL DEFAULT 'pending' CHECK (delivery_status IN ('pending','delivered','failed','expired')),
+        attempts integer NOT NULL DEFAULT 0,
+        last_error_code text,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        delivered_at timestamptz,
+        UNIQUE(import_id, crm_person_ref)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_activation_destinations (
+        id uuid PRIMARY KEY,
+        site_id uuid NOT NULL REFERENCES analytics_sites(id) ON DELETE CASCADE,
+        platform text NOT NULL CHECK (platform IN ('meta','google','tiktok','reddit')),
+        name text NOT NULL,
+        connection_ref text,
+        external_dataset_id text,
+        status text NOT NULL DEFAULT 'active' CHECK (status IN ('active','paused','archived')),
+        event_mapping jsonb NOT NULL DEFAULT '{}'::jsonb,
+        created_by_user_id bigint NOT NULL,
+        created_at timestamptz NOT NULL DEFAULT now(),
+        updated_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_activation_jobs (
+        id uuid PRIMARY KEY,
+        destination_id uuid NOT NULL REFERENCES analytics_activation_destinations(id) ON DELETE CASCADE,
+        conversion_id uuid NOT NULL REFERENCES analytics_conversions(id) ON DELETE CASCADE,
+        person_id uuid REFERENCES analytics_people(id) ON DELETE SET NULL,
+        payload_ciphertext text NOT NULL,
+        status text NOT NULL DEFAULT 'pending' CHECK (status IN ('pending','delivered','failed','expired')),
+        attempts integer NOT NULL DEFAULT 0,
+        last_error_code text,
+        next_attempt_at timestamptz NOT NULL DEFAULT now(),
+        created_at timestamptz NOT NULL DEFAULT now(),
+        delivered_at timestamptz,
+        UNIQUE(destination_id, conversion_id)
+      )
+    `);
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_thorbit_entitlements (
+        user_id bigint PRIMARY KEY,
+        thorbit_org_id text,
+        connection_source text NOT NULL DEFAULT 'trial' CHECK (connection_source IN ('trial','api_key','thorbit_session')),
+        eligible boolean NOT NULL DEFAULT false,
+        reason text NOT NULL,
+        plan_id text,
+        subscription_status text,
+        monthly_recurring_revenue_cents integer NOT NULL DEFAULT 0,
+        minimum_monthly_recurring_revenue_cents integer NOT NULL DEFAULT 5000,
+        verified_at timestamptz NOT NULL,
+        refresh_after timestamptz NOT NULL,
+        access_expires_at timestamptz NOT NULL,
+        trial_started_at timestamptz NOT NULL DEFAULT now(),
+        trial_ends_at timestamptz NOT NULL DEFAULT (now() + interval '30 days'),
+        last_refresh_error text,
+        updated_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await client.query(
+      `ALTER TABLE analytics_thorbit_entitlements ALTER COLUMN thorbit_org_id DROP NOT NULL`
+    );
+    await client.query(
+      `ALTER TABLE analytics_thorbit_entitlements ADD COLUMN IF NOT EXISTS trial_started_at timestamptz NOT NULL DEFAULT now()`
+    );
+    await client.query(
+      `ALTER TABLE analytics_thorbit_entitlements ADD COLUMN IF NOT EXISTS trial_ends_at timestamptz NOT NULL DEFAULT (now() + interval '30 days')`
+    );
+    await client.query(
+      `ALTER TABLE analytics_thorbit_entitlements DROP CONSTRAINT IF EXISTS analytics_thorbit_entitlements_connection_source_check`
+    );
+    await client.query(
+      `ALTER TABLE analytics_thorbit_entitlements ADD CONSTRAINT analytics_thorbit_entitlements_connection_source_check CHECK (connection_source IN ('trial','api_key','thorbit_session'))`
+    );
+    await client.query(`
+      CREATE TABLE IF NOT EXISTS analytics_thorbit_connect_states (
+        state_hash text PRIMARY KEY,
+        user_id bigint NOT NULL,
+        expires_at timestamptz NOT NULL,
+        consumed_at timestamptz,
+        created_at timestamptz NOT NULL DEFAULT now()
+      )
+    `);
+    await client.query(
+      `ALTER TABLE analytics_exports ADD COLUMN IF NOT EXISTS idempotency_key text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS country_code text`
+    );
+    await client.query(
+      `ALTER TABLE analytics_events ADD COLUMN IF NOT EXISTS region_code text`
+    );
+    await client.query(`CREATE UNIQUE INDEX IF NOT EXISTS analytics_exports_owner_idempotency
+      ON analytics_exports(requested_by_user_id, idempotency_key) WHERE idempotency_key IS NOT NULL`);
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_events_site_time ON analytics_events(site_id, occurred_at DESC)"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_events_pixel_time ON analytics_events(pixel_id, occurred_at DESC)"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_events_site_hostname_time ON analytics_events(site_id, hostname, occurred_at DESC)"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_events_acquisition ON analytics_events(site_id, source, medium, campaign, occurred_at DESC)"
+    );
+    await client.query(
+      "CREATE INDEX IF NOT EXISTS analytics_conversions_site_time ON analytics_conversions(site_id, occurred_at DESC)"
+    );
+    await client.query(`
+      INSERT INTO analytics_schema_migrations(version)
+      VALUES ('2026-08-05.1'), ('2026-08-05.2'), ('2026-08-05.3'), ('2026-08-05.4'), ('2026-08-05.5'), ('2026-08-05.6'), ('2026-08-05.7'), ('2026-08-05.8'), ('2026-08-05.9'), ('2026-08-05.10'), ('2026-08-05.11'), ('2026-08-05.12'), ('2026-08-05.13'), ('2026-08-05.14')
+      ON CONFLICT (version) DO NOTHING
+    `);
+    await client.query("COMMIT");
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+function normalizeSlug(value) {
+  const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
+  return slug || `site-${randomBytes(4).toString("hex")}`;
+}
+function normalizeObservedHostname(origin) {
+  if (!origin || origin === "null") return null;
+  try {
+    const url = new URL(origin);
+    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
+    return url.hostname.toLowerCase().replace(/\.$/, "");
+  } catch {
+    return null;
+  }
+}
+function publicPixelId() {
+  return `px_${randomBytes(18).toString("base64url")}`;
+}
+function mapRows(rows) {
+  return rows;
+}
+async function accessFor(client, siteId, userId) {
+  const result = await client.query(
+    `SELECT role FROM analytics_site_grants WHERE site_id = $1 AND user_id = $2`,
+    [siteId, userId]
+  );
+  const role = result.rows[0]?.role;
+  if (!role)
+    throw new AnalyticsRepositoryError(
+      "analytics_site_not_found",
+      "Site not found.",
+      404
+    );
+  return role;
+}
+async function requireEditor(client, siteId, userId) {
+  const role = await accessFor(client, siteId, userId);
+  if (role === "viewer")
+    throw new AnalyticsRepositoryError(
+      "analytics_forbidden",
+      "Editor access is required.",
+      403
+    );
+  return role;
+}
+async function createAnalyticsSite(input) {
+  const db = getAnalyticsPool();
+  const client = await db.connect();
+  const id = randomUUID();
+  const baseSlug = normalizeSlug(input.slug || input.name);
+  try {
+    await client.query("BEGIN");
+    let slug = baseSlug;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      try {
+        await client.query(
+          `INSERT INTO analytics_sites(id, slug, name, owner_user_id, timezone)
+           VALUES ($1, $2, $3, $4, $5)`,
+          [id, slug, input.name.trim(), input.userId, input.timezone || "UTC"]
+        );
+        break;
+      } catch (error) {
+        const code = error.code;
+        if (code !== "23505" || attempt === 2) throw error;
+        slug = `${baseSlug}-${randomBytes(2).toString("hex")}`;
+      }
+    }
+    await client.query(
+      `INSERT INTO analytics_site_grants(site_id, user_id, role) VALUES ($1, $2, 'owner')`,
+      [id, input.userId]
+    );
+    await client.query("COMMIT");
+    return {
+      id,
+      slug,
+      name: input.name.trim(),
+      timezone: input.timezone || "UTC",
+      status: "active",
+      role: "owner",
+      pixel_count: 0,
+      last_event_at: null,
+      business_model: "leadgen"
+    };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function listAnalyticsSites(userId) {
+  const result = await getAnalyticsPool().query(
+    `SELECT s.id, s.slug, s.name, s.timezone, s.status, s.business_model, g.role,
+            count(DISTINCT p.id)::int AS pixel_count,
+            max(e.occurred_at)::text AS last_event_at
+       FROM analytics_sites s
+       JOIN analytics_site_grants g ON g.site_id = s.id AND g.user_id = $1
+       LEFT JOIN analytics_pixels p ON p.site_id = s.id
+       LEFT JOIN analytics_events e ON e.site_id = s.id
+      GROUP BY s.id, g.role
+      ORDER BY s.created_at ASC`,
+    [userId]
+  );
+  return mapRows(result.rows);
+}
+async function updateAnalyticsBusinessModel(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  await db.query(
+    "UPDATE analytics_sites SET business_model = $1, updated_at = now() WHERE id = $2",
+    [input.businessModel, input.siteId]
+  );
+}
+async function upsertAnalyticsAdSpend(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  for (const row of input.rows) {
+    await db.query(
+      `INSERT INTO analytics_ad_spend_daily(site_id, bucket, platform, campaign, spend_minor, currency, source_ref)
+       VALUES ($1,$2::date,$3,$4,$5,$6,$7)
+       ON CONFLICT(site_id,bucket,platform,campaign) DO UPDATE SET spend_minor=EXCLUDED.spend_minor,currency=EXCLUDED.currency,source_ref=EXCLUDED.source_ref,updated_at=now()`,
+      [
+        input.siteId,
+        row.date,
+        row.platform.slice(0, 80),
+        row.campaign?.slice(0, 240) || "(all)",
+        row.spendMinor,
+        (row.currency || "USD").toUpperCase(),
+        row.sourceRef?.slice(0, 500) || null
+      ]
+    );
+  }
+  return { accepted: input.rows.length };
+}
+async function analyticsBusinessMetrics(siteId, userId, start, end) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const site = await db.query("SELECT business_model FROM analytics_sites WHERE id=$1", [siteId]);
+  const result = await db.query(
+    `SELECT count(*)::int AS conversions, count(DISTINCT person_id)::int AS customers,
+            count(*) FILTER (WHERE conversion_kind IN ('form_submitted','lead','qualified_lead'))::int AS leads,
+            count(*) FILTER (WHERE conversion_kind IN ('purchase','order_completed'))::int AS purchases,
+            count(*) FILTER (WHERE conversion_kind IN ('trial_started','demo_started'))::int AS trials,
+            count(*) FILTER (WHERE conversion_kind IN ('subscription_started','subscription_renewed'))::int AS subscriptions,
+            count(*) FILTER (WHERE conversion_kind IN ('subscription_cancelled','churned'))::int AS churns,
+            COALESCE(sum(value_minor),0)::bigint AS revenue_minor,
+            (SELECT count(*)::int FROM (SELECT person_id FROM analytics_conversions WHERE site_id=$1 AND person_id IS NOT NULL AND conversion_kind IN ('purchase','order_completed') AND occurred_at >= $2 AND occurred_at < $3 GROUP BY person_id HAVING count(*) > 1) r) AS repeat_customers
+       FROM analytics_conversions WHERE site_id=$1 AND occurred_at >= $2 AND occurred_at < $3`,
+    [siteId, start, end]
+  );
+  const spend = await db.query(
+    "SELECT COALESCE(sum(spend_minor),0)::bigint AS spend_minor FROM analytics_ad_spend_daily WHERE site_id=$1 AND bucket >= $2::date AND bucket < $3::date",
+    [siteId, start, end]
+  );
+  const row = result.rows[0];
+  const spendMinor = Number(spend.rows[0]?.spend_minor || 0);
+  const revenueMinor = Number(row.revenue_minor || 0);
+  return {
+    businessModel: site.rows[0]?.business_model || "leadgen",
+    period: { start, end },
+    metrics: {
+      ...row,
+      revenue_minor: revenueMinor,
+      spend_minor: spendMinor,
+      roas: spendMinor > 0 ? revenueMinor / spendMinor : null,
+      cost_per_lead: spendMinor > 0 && row.leads > 0 ? spendMinor / row.leads : null,
+      average_order_value: row.purchases > 0 ? revenueMinor / row.purchases : null,
+      repeat_customer_rate: row.customers > 0 ? row.repeat_customers / row.customers : null,
+      churn_rate: row.subscriptions > 0 ? row.churns / row.subscriptions : null
+    },
+    missingInputs: spendMinor > 0 ? [] : ["ad_spend"]
+  };
+}
+async function analyticsForecast(siteId, userId, horizonMonths = 12) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const rows = await db.query(
+    `WITH months AS (SELECT generate_series(date_trunc('month', now()) - interval '11 months', date_trunc('month', now()), interval '1 month') AS month)
+     SELECT m.month::date::text AS month,
+            COALESCE((SELECT sum(value_minor) FROM analytics_conversions c WHERE c.site_id=$1 AND c.occurred_at >= m.month AND c.occurred_at < m.month+interval '1 month'),0)::bigint AS revenue_minor,
+            COALESCE((SELECT sum(spend_minor) FROM analytics_ad_spend_daily s WHERE s.site_id=$1 AND s.bucket >= m.month::date AND s.bucket < (m.month+interval '1 month')::date),0)::bigint AS spend_minor
+       FROM months m ORDER BY m.month`,
+    [siteId]
+  );
+  const history = rows.rows.map((row) => ({
+    month: row.month,
+    revenueMinor: Number(row.revenue_minor),
+    spendMinor: Number(row.spend_minor)
+  }));
+  const nonEmpty = history.filter(
+    (row) => row.revenueMinor > 0 || row.spendMinor > 0
+  );
+  if (nonEmpty.length < 3)
+    return {
+      status: "insufficient_data",
+      history,
+      forecast: [],
+      horizonMonths,
+      missingInputs: ["at_least_3_months_of_revenue_or_spend"]
+    };
+  const values = history.map((row) => row.revenueMinor);
+  const n = values.length;
+  const meanX = (n - 1) / 2;
+  const meanY = values.reduce((a, b) => a + b, 0) / n;
+  const slope = values.reduce(
+    (sum, value, index) => sum + (index - meanX) * (value - meanY),
+    0
+  ) / values.reduce((sum, _value, index) => sum + (index - meanX) ** 2, 0);
+  const intercept = meanY - slope * meanX;
+  const residual = Math.sqrt(
+    values.reduce(
+      (sum, value, index) => sum + (value - (intercept + slope * index)) ** 2,
+      0
+    ) / n
+  );
+  const spendMonths = history.filter((row) => row.spendMinor > 0);
+  const avgSpend = spendMonths.length ? spendMonths.reduce((sum, row) => sum + row.spendMinor, 0) / spendMonths.length : 0;
+  const lastMonth = /* @__PURE__ */ new Date(`${history.at(-1)?.month}T00:00:00Z`);
+  const forecast = Array.from(
+    { length: Math.min(Math.max(horizonMonths, 1), 36) },
+    (_, offset) => {
+      const date = new Date(
+        Date.UTC(
+          lastMonth.getUTCFullYear(),
+          lastMonth.getUTCMonth() + offset + 1,
+          1
+        )
+      );
+      const base = Math.max(0, intercept + slope * (n + offset));
+      return {
+        month: date.toISOString().slice(0, 10),
+        lowerRevenueMinor: Math.max(0, Math.round(base - residual)),
+        baseRevenueMinor: Math.round(base),
+        upperRevenueMinor: Math.round(base + residual),
+        projectedSpendMinor: Math.round(avgSpend),
+        baseRoas: avgSpend > 0 ? base / avgSpend : null
+      };
+    }
+  );
+  return {
+    status: "modeled",
+    method: "monthly_linear_trend_v1",
+    history,
+    forecast,
+    horizonMonths: forecast.length,
+    missingInputs: avgSpend > 0 ? [] : ["ad_spend"],
+    caveats: [
+      "Scenario range reflects historical residual variation, not a guarantee."
+    ]
+  };
+}
+async function deleteAnalyticsSite(input) {
+  const db = getAnalyticsPool();
+  const role = await accessFor(db, input.siteId, input.userId);
+  if (role !== "owner")
+    throw new AnalyticsRepositoryError(
+      "analytics_forbidden",
+      "Owner access is required.",
+      403
+    );
+  const result = await db.query(
+    `DELETE FROM analytics_sites WHERE id = $1 AND owner_user_id = $2`,
+    [input.siteId, input.userId]
+  );
+  if (!result.rowCount)
+    throw new AnalyticsRepositoryError(
+      "analytics_site_not_found",
+      "Site not found.",
+      404
+    );
+}
+async function createAnalyticsPixel(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  const row = await db.query(
+    `INSERT INTO analytics_pixels(id, site_id, public_id, name, environment)
+     VALUES ($1, $2, $3, $4, $5)
+     RETURNING id, site_id, public_id, name, environment, status, created_at::text, NULL::text AS last_event_at`,
+    [
+      randomUUID(),
+      input.siteId,
+      publicPixelId(),
+      input.name.trim(),
+      input.environment || "production"
+    ]
+  );
+  return { ...row.rows[0], domains: [] };
+}
+async function listAnalyticsPixels(siteId, userId) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const [pixels, domains] = await Promise.all([
+    db.query(
+      `SELECT p.id, p.site_id, p.public_id, p.name, p.environment, p.status,
+              p.created_at::text, max(e.occurred_at)::text AS last_event_at
+         FROM analytics_pixels p
+         LEFT JOIN analytics_events e ON e.pixel_id = p.id
+        WHERE p.site_id = $1
+        GROUP BY p.id
+        ORDER BY p.created_at ASC`,
+      [siteId]
+    ),
+    db.query(
+      `SELECT pixel_id, hostname, state, first_seen_at::text, last_seen_at::text,
+              accepted_count::int, rejected_count::int
+         FROM analytics_pixel_domains
+        WHERE pixel_id IN (SELECT id FROM analytics_pixels WHERE site_id = $1)
+        ORDER BY last_seen_at DESC`,
+      [siteId]
+    )
+  ]);
+  return pixels.rows.map((pixel) => ({
+    ...pixel,
+    domains: domains.rows.filter((domain) => domain.pixel_id === pixel.id).map(({ pixel_id: _pixelId, ...domain }) => domain)
+  }));
+}
+async function updateAnalyticsPixel(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  const result = await db.query(
+    `UPDATE analytics_pixels
+        SET name = COALESCE($3, name),
+            environment = COALESCE($4, environment),
+            status = COALESCE($5, status),
+            disabled_at = CASE WHEN $5 = 'disabled' THEN now() WHEN $5 = 'active' THEN NULL ELSE disabled_at END,
+            updated_at = now()
+      WHERE id = $1 AND site_id = $2`,
+    [
+      input.pixelId,
+      input.siteId,
+      input.name ?? null,
+      input.environment ?? null,
+      input.status ?? null
+    ]
+  );
+  if (!result.rowCount)
+    throw new AnalyticsRepositoryError(
+      "analytics_pixel_not_found",
+      "Pixel not found.",
+      404
+    );
+}
+async function setAnalyticsPixelDomainState(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  const hostname = normalizeObservedHostname(`https://${input.hostname}`);
+  if (!hostname)
+    throw new AnalyticsRepositoryError(
+      "invalid_hostname",
+      "Enter a valid hostname."
+    );
+  const result = await db.query(
+    `INSERT INTO analytics_pixel_domains(id, pixel_id, hostname, state)
+     SELECT $1, p.id, $4, $5 FROM analytics_pixels p WHERE p.id = $2 AND p.site_id = $3
+     ON CONFLICT(pixel_id, hostname) DO UPDATE SET state = EXCLUDED.state, updated_at = now()
+     RETURNING id`,
+    [randomUUID(), input.pixelId, input.siteId, hostname, input.state]
+  );
+  if (!result.rowCount)
+    throw new AnalyticsRepositoryError(
+      "analytics_pixel_not_found",
+      "Pixel not found.",
+      404
+    );
+}
+var blockedPropertyName = /(email|phone|password|token|secret|authorization|cookie|name|address|form|body)/i;
+function normalizeAnalyticsPath(value) {
+  if (!value) return "/";
+  try {
+    const parsed = new URL(value, "https://analytics.invalid");
+    return parsed.pathname.slice(0, 2e3) || "/";
+  } catch {
+    return "/";
+  }
+}
+function normalizeAnalyticsUrl(value) {
+  if (!value) return null;
+  try {
+    const parsed = new URL(value);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+      return null;
+    parsed.search = "";
+    parsed.hash = "";
+    return parsed.toString().slice(0, 3e3);
+  } catch {
+    return null;
+  }
+}
+function sanitizeAnalyticsProperties(value) {
+  const output = {};
+  for (const [key, property] of Object.entries(value ?? {}).slice(0, 24)) {
+    if (!/^[a-z][a-z0-9_]{0,63}$/i.test(key) || blockedPropertyName.test(key))
+      continue;
+    if (property === null || typeof property === "boolean" || typeof property === "number")
+      output[key] = property;
+    else if (typeof property === "string") output[key] = property.slice(0, 300);
+  }
+  return output;
+}
+async function ingestAnalyticsEvents(input) {
+  const db = getAnalyticsPool();
+  const requestId = `air_${randomUUID()}`;
+  const hostname = normalizeObservedHostname(input.origin);
+  const pixelResult = await db.query(
+    `SELECT p.id, p.site_id, p.status,
+            COALESCE(
+              (e.eligible AND e.access_expires_at > now()) OR e.trial_ends_at > now(),
+              false
+            ) AS entitled
+       FROM analytics_pixels p
+       JOIN analytics_sites s ON s.id = p.site_id
+       LEFT JOIN analytics_thorbit_entitlements e ON e.user_id = s.owner_user_id
+      WHERE p.public_id = $1`,
+    [input.publicPixelId]
+  );
+  const pixel = pixelResult.rows[0];
+  if (!pixel || pixel.status !== "active") {
+    const reasons = [pixel ? "pixel_disabled" : "pixel_unknown"];
+    await db.query(
+      `INSERT INTO analytics_ingestion_receipts(id, request_id, site_id, pixel_id, hostname, rejected_count, reason_codes)
+       VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)`,
+      [
+        randomUUID(),
+        requestId,
+        pixel?.site_id ?? null,
+        pixel?.id ?? null,
+        hostname,
+        input.events.length,
+        JSON.stringify(reasons)
+      ]
+    );
+    return {
+      requestId,
+      accepted: 0,
+      rejected: input.events.length,
+      reasonCodes: reasons,
+      hostname,
+      siteId: pixel?.site_id ?? null,
+      pixelId: pixel?.id ?? null
+    };
+  }
+  if (!pixel.entitled) {
+    const reasons = ["thorbit_entitlement_required"];
+    await db.query(
+      `INSERT INTO analytics_ingestion_receipts(id, request_id, site_id, pixel_id, hostname, rejected_count, reason_codes)
+       VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)`,
+      [
+        randomUUID(),
+        requestId,
+        pixel.site_id,
+        pixel.id,
+        hostname,
+        input.events.length,
+        JSON.stringify(reasons)
+      ]
+    );
+    return {
+      requestId,
+      accepted: 0,
+      rejected: input.events.length,
+      reasonCodes: reasons,
+      hostname,
+      siteId: pixel.site_id,
+      pixelId: pixel.id
+    };
+  }
+  if (!hostname) {
+    const reasons = ["origin_missing_or_invalid"];
+    await db.query(
+      `INSERT INTO analytics_ingestion_receipts(id, request_id, site_id, pixel_id, rejected_count, reason_codes)
+       VALUES ($1, $2, $3, $4, $5, $6::jsonb)`,
+      [
+        randomUUID(),
+        requestId,
+        pixel.site_id,
+        pixel.id,
+        input.events.length,
+        JSON.stringify(reasons)
+      ]
+    );
+    return {
+      requestId,
+      accepted: 0,
+      rejected: input.events.length,
+      reasonCodes: reasons,
+      hostname,
+      siteId: pixel.site_id,
+      pixelId: pixel.id
+    };
+  }
+  const domainResult = await db.query(
+    `INSERT INTO analytics_pixel_domains(id, pixel_id, hostname, state, rejected_count)
+     VALUES ($1, $2, $3, 'observed_unverified', 0)
+     ON CONFLICT(pixel_id, hostname) DO UPDATE
+       SET last_seen_at = now(), updated_at = now()
+     RETURNING state`,
+    [randomUUID(), pixel.id, hostname]
+  );
+  if (domainResult.rows[0]?.state !== "approved") {
+    await db.query(
+      `UPDATE analytics_pixel_domains
+          SET rejected_count = rejected_count + $3, last_seen_at = now(), updated_at = now()
+        WHERE pixel_id = $1 AND hostname = $2`,
+      [pixel.id, hostname, input.events.length]
+    );
+    const reasons = ["domain_unapproved"];
+    await db.query(
+      `INSERT INTO analytics_ingestion_receipts(id, request_id, site_id, pixel_id, hostname, rejected_count, reason_codes)
+       VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb)`,
+      [
+        randomUUID(),
+        requestId,
+        pixel.site_id,
+        pixel.id,
+        hostname,
+        input.events.length,
+        JSON.stringify(reasons)
+      ]
+    );
+    return {
+      requestId,
+      accepted: 0,
+      rejected: input.events.length,
+      reasonCodes: reasons,
+      hostname,
+      siteId: pixel.site_id,
+      pixelId: pixel.id
+    };
+  }
+  const client = await db.connect();
+  let accepted = 0;
+  let rejected = 0;
+  const reasonCodes = /* @__PURE__ */ new Set();
+  try {
+    await client.query("BEGIN");
+    for (const event of input.events) {
+      try {
+        const attribution = resolveAnalyticsAttribution(event);
+        const resolvedPerson = event.visitorId || event.sessionId ? await client.query(
+          `SELECT e.person_id FROM analytics_identity_nodes n JOIN analytics_identity_edges e ON e.identity_node_id = n.id
+              WHERE n.site_id = $1 AND ((n.kind = 'visitor_id' AND n.value_hmac = $2) OR (n.kind = 'session_id' AND n.value_hmac = $3))
+              ORDER BY e.confidence DESC, e.last_seen_at DESC LIMIT 1`,
+          [
+            pixel.site_id,
+            event.visitorId ? identityHmac("visitor_id", event.visitorId) : "",
+            event.sessionId ? identityHmac("session_id", event.sessionId) : ""
+          ]
+        ) : { rows: [] };
+        const inserted = await client.query(
+          `INSERT INTO analytics_events(
+             id, event_id, site_id, pixel_id, hostname, visitor_id, session_id, event_name,
+             occurred_at, path, canonical_url, title, referrer, source, medium, campaign,
+             device_class, properties, country_code, region_code, click_ids, person_id,
+             channel_family, platform, campaign_id, ad_set_id, ad_id, creative_id, placement, utm_term, utm_content
+           ) VALUES (
+             $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17, $18::jsonb, $19, $20, $21::jsonb, $22,
+             $23, $24, $25, $26, $27, $28, $29, $30, $31
+           ) ON CONFLICT(site_id, event_id) DO NOTHING`,
+          [
+            randomUUID(),
+            event.eventId,
+            pixel.site_id,
+            pixel.id,
+            hostname,
+            event.visitorId ?? null,
+            event.sessionId ?? null,
+            event.eventName,
+            event.occurredAt,
+            normalizeAnalyticsPath(event.path || event.canonicalUrl),
+            normalizeAnalyticsUrl(event.canonicalUrl),
+            event.title?.slice(0, 500) ?? null,
+            normalizeAnalyticsUrl(event.referrer),
+            event.source?.slice(0, 180) ?? null,
+            event.medium?.slice(0, 180) ?? null,
+            event.campaign?.slice(0, 240) ?? null,
+            event.deviceClass ?? null,
+            JSON.stringify(sanitizeAnalyticsProperties(event.properties)),
+            normalizeGeographyCode(input.geography?.countryCode, 2),
+            normalizeGeographyCode(input.geography?.regionCode, 8),
+            JSON.stringify(sanitizeClickIds(event.clickIds)),
+            resolvedPerson.rows[0]?.person_id ?? null,
+            attribution.channelFamily,
+            attribution.platform,
+            attribution.campaignId,
+            attribution.adSetId,
+            attribution.adId,
+            attribution.creativeId,
+            attribution.placement,
+            attribution.term,
+            attribution.content
+          ]
+        );
+        if (inserted.rowCount) accepted += 1;
+        else {
+          rejected += 1;
+          reasonCodes.add("duplicate_event");
+        }
+      } catch {
+        rejected += 1;
+        reasonCodes.add("event_insert_failed");
+      }
+    }
+    await client.query(
+      `UPDATE analytics_pixel_domains
+          SET accepted_count = accepted_count + $3,
+              rejected_count = rejected_count + $4,
+              last_seen_at = now(), updated_at = now()
+        WHERE pixel_id = $1 AND hostname = $2`,
+      [pixel.id, hostname, accepted, rejected]
+    );
+    await client.query(
+      `INSERT INTO analytics_ingestion_receipts(
+         id, request_id, site_id, pixel_id, hostname, accepted_count, rejected_count, reason_codes
+       ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8::jsonb)`,
+      [
+        randomUUID(),
+        requestId,
+        pixel.site_id,
+        pixel.id,
+        hostname,
+        accepted,
+        rejected,
+        JSON.stringify([...reasonCodes])
+      ]
+    );
+    await client.query("COMMIT");
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+  return {
+    requestId,
+    accepted,
+    rejected,
+    reasonCodes: [...reasonCodes],
+    hostname,
+    siteId: pixel.site_id,
+    pixelId: pixel.id
+  };
+}
+function normalizeGeographyCode(value, max) {
+  const normalized = value?.trim().toUpperCase();
+  return normalized && /^[A-Z0-9-]+$/.test(normalized) ? normalized.slice(0, max) : null;
+}
+function pageFingerprint(scope, siteId, filters) {
+  return createHash("sha256").update(JSON.stringify({ scope, siteId, filters })).digest("base64url").slice(0, 18);
+}
+function decodePageOffset(cursor, fingerprint) {
+  if (!cursor) return 0;
+  try {
+    const parsed = JSON.parse(
+      Buffer.from(cursor, "base64url").toString("utf8")
+    );
+    if (parsed.v !== 1 || parsed.f !== fingerprint || !Number.isInteger(parsed.o) || Number(parsed.o) < 0)
+      throw new Error("invalid");
+    return Number(parsed.o);
+  } catch {
+    throw new AnalyticsRepositoryError(
+      "invalid_cursor",
+      "The pagination cursor is invalid for these filters."
+    );
+  }
+}
+function paginateRows(rows, input, fingerprint) {
+  if (!input)
+    return { items: rows, pageInfo: { hasNextPage: false, nextCursor: null } };
+  const limit = Math.min(100, Math.max(1, Math.trunc(input?.limit ?? 25)));
+  const offset = decodePageOffset(input?.cursor, fingerprint);
+  const items = rows.slice(offset, offset + limit);
+  const hasNextPage = offset + items.length < rows.length;
+  return {
+    items,
+    pageInfo: {
+      hasNextPage,
+      nextCursor: hasNextPage ? Buffer.from(
+        JSON.stringify({ v: 1, f: fingerprint, o: offset + items.length })
+      ).toString("base64url") : null
+    }
+  };
+}
+async function createAnalyticsConversion(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  if (input.pixelId) {
+    const pixel = await db.query(
+      `SELECT 1 FROM analytics_pixels WHERE id = $1 AND site_id = $2`,
+      [input.pixelId, input.siteId]
+    );
+    if (!pixel.rowCount)
+      throw new AnalyticsRepositoryError(
+        "analytics_pixel_not_found",
+        "Pixel not found.",
+        404
+      );
+  }
+  const id = randomUUID();
+  const resolvedPerson = input.sessionId ? await db.query(
+    `SELECT e.person_id FROM analytics_identity_nodes n JOIN analytics_identity_edges e ON e.identity_node_id = n.id
+        WHERE n.site_id = $1 AND n.kind = 'session_id' AND n.value_hmac = $2 ORDER BY e.confidence DESC LIMIT 1`,
+    [input.siteId, identityHmac("session_id", input.sessionId)]
+  ) : { rows: [] };
+  const result = await db.query(
+    `INSERT INTO analytics_conversions(
+       id, source_event_id, site_id, pixel_id, session_id, conversion_kind, value_minor, currency, occurred_at, person_id
+     ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
+     ON CONFLICT(site_id, source_event_id) DO NOTHING
+     RETURNING id`,
+    [
+      id,
+      input.sourceEventId,
+      input.siteId,
+      input.pixelId ?? null,
+      input.sessionId ?? null,
+      input.conversionKind,
+      input.valueMinor ?? 0,
+      (input.currency || "USD").toUpperCase(),
+      input.occurredAt,
+      resolvedPerson.rows[0]?.person_id ?? null
+    ]
+  );
+  return { id: result.rows[0]?.id ?? id, created: Boolean(result.rowCount) };
+}
+function eventFilterSql(siteId, filters) {
+  const values = [siteId, filters.start, filters.end];
+  const clauses = [
+    "e.site_id = $1",
+    "e.occurred_at >= $2::timestamptz",
+    "e.occurred_at < $3::timestamptz"
+  ];
+  const add = (sql, value) => {
+    values.push(value);
+    clauses.push(sql.replace("?", `$${values.length}`));
+  };
+  if (filters.pixelIds?.length)
+    add("e.pixel_id = ANY(?::uuid[])", filters.pixelIds);
+  if (filters.hostnames?.length)
+    add("e.hostname = ANY(?::text[])", filters.hostnames);
+  if (filters.source) add(`COALESCE(e.source, '(direct)') = ?`, filters.source);
+  if (filters.medium) add(`COALESCE(e.medium, '(none)') = ?`, filters.medium);
+  if (filters.campaign)
+    add(`COALESCE(e.campaign, '(none)') = ?`, filters.campaign);
+  if (filters.eventName) add("e.event_name = ?", filters.eventName);
+  if (filters.channelFamily)
+    add(`COALESCE(e.channel_family, 'other') = ?`, filters.channelFamily);
+  if (filters.platform)
+    add(`COALESCE(e.platform, e.source, '(direct)') = ?`, filters.platform);
+  if (filters.referrer)
+    add(`COALESCE(e.referrer, '') ILIKE '%' || ? || '%'`, filters.referrer);
+  if (filters.path) add(`e.path = ?`, filters.path);
+  if (filters.deviceClass)
+    add(`COALESCE(e.device_class, 'unknown') = ?`, filters.deviceClass);
+  if (filters.countryCode)
+    add(
+      `COALESCE(e.country_code, 'unknown') = ?`,
+      filters.countryCode.toUpperCase()
+    );
+  if (filters.regionCode)
+    add(
+      `COALESCE(e.region_code, 'unknown') = ?`,
+      filters.regionCode.toUpperCase()
+    );
+  return { where: clauses.join(" AND "), values };
+}
+function conversionFilterSql(siteId, filters) {
+  const values = [siteId, filters.start, filters.end];
+  const clauses = [
+    "c.site_id = $1",
+    "c.occurred_at >= $2::timestamptz",
+    "c.occurred_at < $3::timestamptz"
+  ];
+  const add = (sql, value) => {
+    values.push(value);
+    clauses.push(sql.replaceAll("?", `$${values.length}`));
+  };
+  if (filters.pixelIds?.length)
+    add("c.pixel_id = ANY(?::uuid[])", filters.pixelIds);
+  if (filters.hostnames?.length)
+    add(
+      "EXISTS (SELECT 1 FROM analytics_events ce WHERE ce.site_id = c.site_id AND ce.session_id = c.session_id AND ce.hostname = ANY(?::text[]))",
+      filters.hostnames
+    );
+  if (filters.source)
+    add(`COALESCE(first_event.source, '(direct)') = ?`, filters.source);
+  if (filters.medium)
+    add(`COALESCE(first_event.medium, '(none)') = ?`, filters.medium);
+  if (filters.campaign)
+    add(`COALESCE(first_event.campaign, '(none)') = ?`, filters.campaign);
+  if (filters.eventName)
+    add(
+      "EXISTS (SELECT 1 FROM analytics_events ce WHERE ce.site_id = c.site_id AND ce.session_id = c.session_id AND ce.event_name = ?)",
+      filters.eventName
+    );
+  if (filters.channelFamily)
+    add(
+      `EXISTS (SELECT 1 FROM analytics_events ce WHERE ce.site_id = c.site_id AND ce.session_id = c.session_id AND COALESCE(ce.channel_family, 'other') = ?)`,
+      filters.channelFamily
+    );
+  if (filters.platform)
+    add(
+      `EXISTS (SELECT 1 FROM analytics_events ce WHERE ce.site_id = c.site_id AND ce.session_id = c.session_id AND COALESCE(ce.platform, ce.source, '(direct)') = ?)`,
+      filters.platform
+    );
+  if (filters.referrer)
+    add(
+      `EXISTS (SELECT 1 FROM analytics_events ce WHERE ce.site_id = c.site_id AND ce.session_id = c.session_id AND COALESCE(ce.referrer, '') ILIKE '%' || ? || '%')`,
+      filters.referrer
+    );
+  if (filters.path)
+    add(
+      `EXISTS (SELECT 1 FROM analytics_events ce WHERE ce.site_id = c.site_id AND ce.session_id = c.session_id AND ce.path = ?)`,
+      filters.path
+    );
+  if (filters.deviceClass)
+    add(
+      `EXISTS (SELECT 1 FROM analytics_events ce WHERE ce.site_id = c.site_id AND ce.session_id = c.session_id AND COALESCE(ce.device_class, 'unknown') = ?)`,
+      filters.deviceClass
+    );
+  if (filters.countryCode)
+    add(
+      `EXISTS (SELECT 1 FROM analytics_events ce WHERE ce.site_id = c.site_id AND ce.session_id = c.session_id AND COALESCE(ce.country_code, 'unknown') = ?)`,
+      filters.countryCode.toUpperCase()
+    );
+  if (filters.regionCode)
+    add(
+      `EXISTS (SELECT 1 FROM analytics_events ce WHERE ce.site_id = c.site_id AND ce.session_id = c.session_id AND COALESCE(ce.region_code, 'unknown') = ?)`,
+      filters.regionCode.toUpperCase()
+    );
+  if (filters.conversionKind)
+    add(`c.conversion_kind = ?`, filters.conversionKind);
+  return { where: clauses.join(" AND "), values };
+}
+async function analyticsOverview(siteId, userId, filters) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const query = eventFilterSql(siteId, filters);
+  const result = await db.query(
+    `SELECT count(DISTINCT visitor_id)::int AS visitors,
+            count(DISTINCT session_id)::int AS sessions,
+            count(*) FILTER (WHERE event_name = 'page_view')::int AS pageviews,
+            count(*)::int AS events,
+            min(occurred_at)::text AS first_event_at,
+            max(occurred_at)::text AS last_event_at
+       FROM analytics_events e WHERE ${query.where}`,
+    query.values
+  );
+  const conversionQuery = conversionFilterSql(siteId, filters);
+  const conversions = await db.query(
+    `SELECT count(*)::int AS conversions, COALESCE(sum(c.value_minor), 0)::int AS revenue_minor
+       FROM analytics_conversions c
+       LEFT JOIN LATERAL (
+         SELECT e.source, e.medium, e.campaign FROM analytics_events e
+          WHERE e.site_id = c.site_id AND e.session_id = c.session_id
+          ORDER BY e.occurred_at ASC LIMIT 1
+       ) first_event ON true
+      WHERE ${conversionQuery.where}`,
+    conversionQuery.values
+  );
+  const row = result.rows[0];
+  const conversion = conversions.rows[0];
+  return {
+    ...row,
+    conversions: conversion.conversions,
+    revenueMinor: conversion.revenue_minor,
+    conversionRate: row.sessions > 0 ? conversion.conversions / row.sessions : 0,
+    dataFreshThrough: row.last_event_at
+  };
+}
+async function analyticsTimeseries(siteId, userId, filters) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const query = eventFilterSql(siteId, filters);
+  const timezone = filters.timezone || "UTC";
+  const timezoneParameter = `$${query.values.length + 1}`;
+  const result = await db.query(
+    `SELECT date_trunc('day', e.occurred_at AT TIME ZONE ${timezoneParameter})::date::text AS date,
+            count(DISTINCT e.visitor_id)::int AS visitors,
+            count(DISTINCT e.session_id)::int AS sessions,
+            count(*) FILTER (WHERE e.event_name = 'page_view')::int AS pageviews,
+            count(*)::int AS events
+       FROM analytics_events e
+      WHERE ${query.where}
+      GROUP BY 1 ORDER BY 1`,
+    [...query.values, timezone]
+  );
+  const conversionQuery = conversionFilterSql(siteId, filters);
+  const conversionTimezoneParameter = `$${conversionQuery.values.length + 1}`;
+  const conversions = await db.query(
+    `SELECT date_trunc('day', c.occurred_at AT TIME ZONE ${conversionTimezoneParameter})::date::text AS date,
+            count(*)::int AS conversions,
+            COALESCE(sum(c.value_minor), 0)::bigint AS revenue_minor
+       FROM analytics_conversions c
+       LEFT JOIN LATERAL (
+         SELECT e.source, e.medium, e.campaign FROM analytics_events e
+          WHERE e.site_id = c.site_id AND e.session_id = c.session_id
+          ORDER BY e.occurred_at ASC LIMIT 1
+       ) first_event ON true
+      WHERE ${conversionQuery.where}
+      GROUP BY 1 ORDER BY 1`,
+    [...conversionQuery.values, timezone]
+  );
+  const byDate = /* @__PURE__ */ new Map();
+  for (const row of result.rows)
+    byDate.set(String(row.date), { ...row, conversions: 0, revenueMinor: 0 });
+  for (const row of conversions.rows) {
+    const current = byDate.get(row.date) ?? {
+      date: row.date,
+      visitors: 0,
+      sessions: 0,
+      pageviews: 0,
+      events: 0
+    };
+    byDate.set(row.date, {
+      ...current,
+      conversions: row.conversions,
+      revenueMinor: Number(row.revenue_minor)
+    });
+  }
+  const points = [...byDate.values()].sort(
+    (left, right) => String(left.date).localeCompare(String(right.date))
+  );
+  return { points, timezone, dataFreshThrough: points.at(-1)?.date ?? null };
+}
+async function analyticsAcquisition(siteId, userId, filters, page) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const query = eventFilterSql(siteId, filters);
+  const result = await db.query(
+    `SELECT COALESCE(e.source, '(direct)') AS source,
+            COALESCE(e.medium, '(none)') AS medium,
+            COALESCE(e.campaign, '(none)') AS campaign,
+            count(DISTINCT e.visitor_id)::int AS visitors,
+            count(DISTINCT e.session_id)::int AS sessions,
+            count(*) FILTER (WHERE e.event_name = 'page_view')::int AS pageviews
+       FROM analytics_events e
+      WHERE ${query.where}
+      GROUP BY 1, 2, 3
+      ORDER BY sessions DESC, visitors DESC
+      LIMIT 1000`,
+    query.values
+  );
+  const values = [siteId, filters.start, filters.end];
+  const touchClauses = [
+    "c.site_id = $1",
+    "c.occurred_at >= $2::timestamptz",
+    "c.occurred_at < $3::timestamptz"
+  ];
+  const addTouch = (sql, value) => {
+    values.push(value);
+    touchClauses.push(sql.replace("?", `$${values.length}`));
+  };
+  if (filters.pixelIds?.length)
+    addTouch("touch.pixel_id = ANY(?::uuid[])", filters.pixelIds);
+  if (filters.hostnames?.length)
+    addTouch("touch.hostname = ANY(?::text[])", filters.hostnames);
+  if (filters.source)
+    addTouch(`COALESCE(touch.source, '(direct)') = ?`, filters.source);
+  if (filters.medium)
+    addTouch(`COALESCE(touch.medium, '(none)') = ?`, filters.medium);
+  if (filters.campaign)
+    addTouch(`COALESCE(touch.campaign, '(none)') = ?`, filters.campaign);
+  if (filters.channelFamily)
+    addTouch(
+      `COALESCE(touch.channel_family, 'other') = ?`,
+      filters.channelFamily
+    );
+  if (filters.platform)
+    addTouch(
+      `COALESCE(touch.platform, touch.source, '(direct)') = ?`,
+      filters.platform
+    );
+  if (filters.referrer)
+    addTouch(
+      `COALESCE(touch.referrer, '') ILIKE '%' || ? || '%'`,
+      filters.referrer
+    );
+  if (filters.path) addTouch(`touch.path = ?`, filters.path);
+  if (filters.deviceClass)
+    addTouch(
+      `COALESCE(touch.device_class, 'unknown') = ?`,
+      filters.deviceClass
+    );
+  if (filters.countryCode)
+    addTouch(
+      `COALESCE(touch.country_code, 'unknown') = ?`,
+      filters.countryCode.toUpperCase()
+    );
+  if (filters.regionCode)
+    addTouch(
+      `COALESCE(touch.region_code, 'unknown') = ?`,
+      filters.regionCode.toUpperCase()
+    );
+  if (filters.conversionKind)
+    addTouch(`c.conversion_kind = ?`, filters.conversionKind);
+  const direction = filters.attributionModel === "last_touch" ? "DESC" : "ASC";
+  const attributed = await db.query(
+    `SELECT COALESCE(touch.source, '(direct)') AS source,
+             COALESCE(touch.medium, '(none)') AS medium,
+             COALESCE(touch.campaign, '(none)') AS campaign,
+             count(*)::int AS conversions, COALESCE(sum(c.value_minor), 0)::bigint AS revenue_minor
+        FROM analytics_conversions c
+        JOIN LATERAL (
+          SELECT e.* FROM analytics_events e
+           WHERE e.site_id = c.site_id AND e.occurred_at <= c.occurred_at
+             AND ((c.person_id IS NOT NULL AND e.person_id = c.person_id)
+               OR (c.person_id IS NULL AND e.session_id = c.session_id))
+           ORDER BY e.occurred_at ${direction} LIMIT 1
+        ) touch ON true
+       WHERE ${touchClauses.join(" AND ")}
+       GROUP BY 1,2,3`,
+    values
+  );
+  const outcomes = new Map(
+    attributed.rows.map((row) => [
+      `${row.source}\0${row.medium}\0${row.campaign}`,
+      row
+    ])
+  );
+  const rows = result.rows.map((row) => {
+    const outcome = outcomes.get(
+      `${row.source}\0${row.medium}\0${row.campaign}`
+    );
+    const conversions = Number(outcome?.conversions ?? 0);
+    return {
+      ...row,
+      conversions,
+      conversionRate: row.sessions > 0 ? conversions / row.sessions : 0,
+      revenueMinor: Number(outcome?.revenue_minor ?? 0)
+    };
+  });
+  for (const outcome of attributed.rows) {
+    const key = `${outcome.source}\0${outcome.medium}\0${outcome.campaign}`;
+    if (!result.rows.some(
+      (row) => `${row.source}\0${row.medium}\0${row.campaign}` === key
+    )) {
+      rows.push({
+        source: outcome.source,
+        medium: outcome.medium,
+        campaign: outcome.campaign,
+        visitors: 0,
+        sessions: 0,
+        pageviews: 0,
+        conversions: Number(outcome.conversions),
+        conversionRate: 0,
+        revenueMinor: Number(outcome.revenue_minor)
+      });
+    }
+  }
+  rows.sort(
+    (a, b) => Number(b.sessions) - Number(a.sessions) || Number(b.conversions) - Number(a.conversions)
+  );
+  const paged = paginateRows(
+    rows,
+    page,
+    pageFingerprint("acquisition", siteId, filters)
+  );
+  return {
+    channels: paged.items,
+    pageInfo: paged.pageInfo,
+    dataFreshThrough: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+var inferredFamilySql = `COALESCE(e.channel_family, CASE
+  WHEN lower(COALESCE(e.source,'') || ' ' || COALESCE(e.referrer,'')) ~ '(perplexity|chatgpt|openai|claude|anthropic|grok|xai|ai[_ -]?overview|google[_ -]?ai|gemini)' THEN 'llm'
+  WHEN lower(COALESCE(e.source,'') || ' ' || COALESCE(e.referrer,'')) ~ '(facebook|instagram|linkedin|tiktok|youtube|youtu\\.be|twitter|x\\.com)' THEN 'social'
+  WHEN lower(COALESCE(e.source,'') || ' ' || COALESCE(e.referrer,'')) ~ '(^|[^a-z])(g2|bbb)([^a-z]|$)|trustpilot|capterra|yelp|better business bureau' THEN 'review'
+  WHEN COALESCE(e.source,'') = '' THEN 'direct'
+  WHEN lower(COALESCE(e.medium,'')) ~ 'email|newsletter' THEN 'email'
+  ELSE 'other' END)`;
+async function analyticsChannelBreakdown(siteId, userId, filters) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const query = eventFilterSql(siteId, filters);
+  const result = await db.query(
+    `
+    SELECT ${inferredFamilySql} AS family,
+           COALESCE(e.platform, NULLIF(e.source,''), '(direct)') AS platform,
+           COALESCE(NULLIF(e.campaign,''), '(none)') AS campaign,
+           COALESCE(NULLIF(e.campaign_id,''), '(unknown)') AS campaign_id,
+           COALESCE(NULLIF(e.ad_set_id,''), '(unknown)') AS ad_set_id,
+           COALESCE(NULLIF(e.ad_id,''), '(unknown)') AS ad_id,
+           COALESCE(NULLIF(e.creative_id,''), '(unknown)') AS creative_id,
+           count(DISTINCT e.visitor_id)::int AS visitors,
+           count(DISTINCT e.session_id)::int AS sessions,
+           count(*) FILTER (WHERE e.event_name = 'page_view')::int AS pageviews,
+           count(*)::int AS events
+      FROM analytics_events e
+     WHERE ${query.where}
+     GROUP BY 1,2,3,4,5,6,7
+     ORDER BY sessions DESC, events DESC
+     LIMIT 2000`,
+    query.values
+  );
+  const families = ["llm", "social", "review"];
+  const sections = Object.fromEntries(
+    families.map((family) => [
+      family,
+      result.rows.filter((row) => row.family === family)
+    ])
+  );
+  return {
+    sections,
+    rows: result.rows,
+    dataFreshThrough: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function analyticsContent(siteId, userId, filters, page) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const query = eventFilterSql(siteId, filters);
+  const result = await db.query(
+    `WITH filtered AS (
+       SELECT e.* FROM analytics_events e WHERE ${query.where}
+     ), page_metrics AS (
+       SELECT path, count(DISTINCT visitor_id)::int AS visitors,
+              count(DISTINCT session_id)::int AS sessions,
+              count(*) FILTER (WHERE event_name = 'page_view')::int AS pageviews,
+              count(*) FILTER (WHERE event_name <> 'page_view')::int AS engagement_events,
+              count(*)::int AS events
+         FROM filtered GROUP BY path
+     ), session_bounds AS (
+       SELECT session_id,
+              (array_agg(path ORDER BY occurred_at ASC, id ASC))[1] AS entrance_path,
+              (array_agg(path ORDER BY occurred_at DESC, id DESC))[1] AS exit_path
+         FROM filtered WHERE session_id IS NOT NULL GROUP BY session_id
+     ), entrances AS (
+       SELECT entrance_path AS path, count(*)::int AS entrances FROM session_bounds GROUP BY entrance_path
+     ), exits AS (
+       SELECT exit_path AS path, count(*)::int AS exits FROM session_bounds GROUP BY exit_path
+     ), assisted AS (
+       SELECT f.path, count(DISTINCT c.id)::int AS conversions
+         FROM analytics_conversions c JOIN filtered f ON f.session_id = c.session_id
+        WHERE c.site_id = $1 AND c.occurred_at >= $2::timestamptz AND c.occurred_at < $3::timestamptz
+        GROUP BY f.path
+     )
+     SELECT metrics.*, COALESCE(entrances.entrances, 0)::int AS entrances,
+            COALESCE(exits.exits, 0)::int AS exits,
+            COALESCE(assisted.conversions, 0)::int AS conversions
+       FROM page_metrics metrics
+       LEFT JOIN entrances USING(path)
+       LEFT JOIN exits USING(path)
+       LEFT JOIN assisted USING(path)
+      ORDER BY metrics.pageviews DESC, metrics.events DESC, metrics.path ASC
+      LIMIT 1000`,
+    query.values
+  );
+  const paged = paginateRows(
+    result.rows,
+    page,
+    pageFingerprint("content", siteId, filters)
+  );
+  return {
+    content: paged.items,
+    pageInfo: paged.pageInfo,
+    dataFreshThrough: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function analyticsEventCounts(siteId, userId, filters, page) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const query = eventFilterSql(siteId, filters);
+  const [result, samples] = await Promise.all([
+    db.query(
+      `SELECT e.event_name AS name, count(*)::int AS count, max(e.occurred_at)::text AS last_seen_at
+       FROM analytics_events e
+      WHERE ${query.where}
+      GROUP BY e.event_name ORDER BY count DESC, e.event_name ASC
+      LIMIT 1000`,
+      query.values
+    ),
+    db.query(
+      `SELECT e.event_id, e.event_name, e.path, e.hostname,
+            COALESCE(e.source, '(direct)') AS source,
+            COALESCE(e.campaign, '(none)') AS campaign,
+            e.occurred_at::text
+       FROM analytics_events e WHERE ${query.where}
+       ORDER BY e.occurred_at DESC, e.id DESC LIMIT 25`,
+      query.values
+    )
+  ]);
+  const receiptValues = [siteId, filters.start, filters.end];
+  const receiptClauses = [
+    "r.site_id = $1",
+    "r.created_at >= $2::timestamptz",
+    "r.created_at < $3::timestamptz"
+  ];
+  const addReceipt = (clause, value) => {
+    receiptValues.push(value);
+    receiptClauses.push(clause.replace("?", `$${receiptValues.length}`));
+  };
+  if (filters.pixelIds?.length)
+    addReceipt("r.pixel_id = ANY(?::uuid[])", filters.pixelIds);
+  if (filters.hostnames?.length)
+    addReceipt("r.hostname = ANY(?::text[])", filters.hostnames);
+  const rejections = await db.query(
+    `SELECT reason.code, count(*)::int AS requests,
+            COALESCE(sum(r.rejected_count), 0)::int AS rejected_events,
+            max(r.created_at)::text AS last_seen_at
+       FROM analytics_ingestion_receipts r
+       CROSS JOIN LATERAL jsonb_array_elements_text(r.reason_codes) AS reason(code)
+      WHERE ${receiptClauses.join(" AND ")} AND r.rejected_count > 0
+      GROUP BY reason.code ORDER BY rejected_events DESC, reason.code ASC`,
+    receiptValues
+  );
+  const paged = paginateRows(
+    result.rows,
+    page,
+    pageFingerprint("events", siteId, filters)
+  );
+  return {
+    events: paged.items,
+    samples: samples.rows,
+    rejections: rejections.rows,
+    pageInfo: paged.pageInfo,
+    dataFreshThrough: samples.rows[0]?.occurred_at ?? null
+  };
+}
+async function analyticsConversions(siteId, userId, filters, page) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const query = conversionFilterSql(siteId, filters);
+  const result = await db.query(
+    `SELECT c.id, c.source_event_id, c.pixel_id, c.session_id, c.conversion_kind,
+            c.value_minor::int, c.currency, c.occurred_at::text,
+            COALESCE(first_event.source, '(direct)') AS source,
+            COALESCE(first_event.medium, '(none)') AS medium,
+            COALESCE(first_event.campaign, '(none)') AS campaign
+       FROM analytics_conversions c
+       LEFT JOIN LATERAL (
+         SELECT e.source, e.medium, e.campaign
+           FROM analytics_events e
+          WHERE e.site_id = c.site_id AND e.session_id = c.session_id
+          ORDER BY e.occurred_at ASC LIMIT 1
+       ) first_event ON true
+      WHERE ${query.where}
+      ORDER BY c.occurred_at DESC
+      LIMIT 1000`,
+    query.values
+  );
+  const summary = result.rows.reduce(
+    (current, row) => ({
+      count: current.count + 1,
+      valueMinor: current.valueMinor + Number(row.value_minor ?? 0)
+    }),
+    { count: 0, valueMinor: 0 }
+  );
+  const paged = paginateRows(
+    result.rows,
+    page,
+    pageFingerprint("conversions", siteId, filters)
+  );
+  return {
+    conversions: paged.items,
+    pageInfo: paged.pageInfo,
+    summary,
+    dataFreshThrough: result.rows[0]?.occurred_at ?? null
+  };
+}
+async function analyticsPaths(siteId, userId, filters, page) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const query = conversionFilterSql(siteId, filters);
+  const result = await db.query(
+    `SELECT c.session_id, c.person_id,
+            string_agg(COALESCE(path_event.platform, path_event.source, '(direct)') || ' / ' || COALESCE(path_event.medium, '(none)') ||
+              CASE WHEN path_event.campaign IS NOT NULL THEN ' / ' || path_event.campaign ELSE '' END ||
+              CASE WHEN path_event.ad_id IS NOT NULL THEN ' / ad:' || path_event.ad_id ELSE '' END,
+              ' \u2192 ' ORDER BY path_event.occurred_at) AS path,
+            count(path_event.id)::int AS touchpoints,
+            1::int AS conversions,
+            c.value_minor::int AS value_minor
+       FROM analytics_conversions c
+       LEFT JOIN LATERAL (
+         SELECT e.source, e.medium, e.campaign FROM analytics_events e
+          WHERE e.site_id = c.site_id AND e.session_id = c.session_id
+          ORDER BY e.occurred_at ASC LIMIT 1
+       ) first_event ON true
+       JOIN analytics_events path_event ON path_event.site_id = c.site_id AND
+         ((c.person_id IS NOT NULL AND path_event.person_id = c.person_id) OR (c.person_id IS NULL AND path_event.session_id = c.session_id))
+      WHERE ${query.where}
+      GROUP BY c.id
+      ORDER BY conversions DESC, value_minor DESC
+      LIMIT 1000`,
+    query.values
+  );
+  const paged = paginateRows(
+    result.rows,
+    page,
+    pageFingerprint("paths", siteId, filters)
+  );
+  return {
+    paths: paged.items,
+    pageInfo: paged.pageInfo,
+    dataFreshThrough: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function analyticsDimensions(siteId, userId, filters, dimension, page) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const query = eventFilterSql(siteId, filters);
+  const select = dimension === "device" ? `COALESCE(NULLIF(e.device_class, ''), 'unknown') AS key, COALESCE(NULLIF(e.device_class, ''), 'Unknown') AS label` : dimension === "source" ? `COALESCE(NULLIF(e.source, ''), '(direct)') AS key, COALESCE(NULLIF(e.source, ''), '(direct)') AS label` : dimension === "country" ? `COALESCE(NULLIF(e.country_code, ''), 'unknown') AS key, COALESCE(NULLIF(e.country_code, ''), 'Unknown') AS label` : dimension === "region" ? `COALESCE(NULLIF(e.region_code, ''), 'unknown') AS key, COALESCE(NULLIF(e.region_code, ''), 'Unknown') AS label` : `extract(dow from e.occurred_at)::int::text || '-' || extract(hour from e.occurred_at)::int::text AS key,
+             to_char(e.occurred_at, 'Dy') || ' ' || lpad(extract(hour from e.occurred_at)::int::text, 2, '0') || ':00' AS label`;
+  const result = await db.query(
+    `SELECT ${select},
+            count(DISTINCT e.visitor_id)::int AS visitors,
+            count(DISTINCT e.session_id)::int AS sessions,
+            count(*) FILTER (WHERE e.event_name = 'page_view')::int AS pageviews,
+            count(*)::int AS events,
+            count(*)::int AS value
+       FROM analytics_events e
+      WHERE ${query.where}
+      GROUP BY 1, 2
+      ORDER BY value DESC, key ASC
+      LIMIT 1000`,
+    query.values
+  );
+  const paged = paginateRows(
+    result.rows,
+    page,
+    pageFingerprint(`dimension:${dimension}`, siteId, filters)
+  );
+  const chartRecommendation = dimension === "device" ? "donut" : dimension === "weekday_hour" ? "heatmap" : dimension === "country" || dimension === "region" ? "choropleth_or_bar" : "horizontal_bar";
+  return {
+    dimension,
+    unit: "events",
+    chartRecommendation,
+    rows: paged.items,
+    pageInfo: paged.pageInfo,
+    dataFreshThrough: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function buildTaggedCampaignUrl(row) {
+  const url = new URL(row.destination_url);
+  for (const [key, value] of [
+    ["utm_source", row.utm_source],
+    ["utm_medium", row.utm_medium],
+    ["utm_campaign", row.utm_campaign],
+    ["utm_term", row.utm_term],
+    ["utm_content", row.utm_content],
+    ["ad_group", row.ad_group],
+    ["ad_name", row.ad_name],
+    ["creative_id", row.creative_id]
+  ])
+    if (value) url.searchParams.set(key, value);
+  return url.toString();
+}
+function campaignLinkWithUrl(row) {
+  return { ...row, tagged_url: buildTaggedCampaignUrl(row) };
+}
+async function createAnalyticsCampaignLink(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  let destination;
+  try {
+    destination = new URL(input.destinationUrl);
+  } catch {
+    throw new AnalyticsRepositoryError(
+      "invalid_destination_url",
+      "Enter a valid destination URL."
+    );
+  }
+  if (!["http:", "https:"].includes(destination.protocol))
+    throw new AnalyticsRepositoryError(
+      "invalid_destination_url",
+      "Destination URL must use HTTP or HTTPS."
+    );
+  if (input.pixelId) {
+    const pixel = await db.query(
+      "SELECT 1 FROM analytics_pixels WHERE id = $1 AND site_id = $2",
+      [input.pixelId, input.siteId]
+    );
+    if (!pixel.rowCount)
+      throw new AnalyticsRepositoryError(
+        "analytics_pixel_not_found",
+        "Pixel not found.",
+        404
+      );
+  }
+  const shortCode = (input.shortCode?.trim().toLowerCase().replace(/[^a-z0-9_-]/g, "-") || randomBytes(5).toString("base64url").toLowerCase()).slice(0, 48);
+  try {
+    const result = await db.query(
+      `INSERT INTO analytics_campaign_links(
+         id, site_id, pixel_id, name, destination_url, short_code, utm_source, utm_medium,
+         utm_campaign, utm_term, utm_content, ad_group, ad_name, creative_id, created_by_user_id
+       ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15)
+       RETURNING *, 0::int AS click_count`,
+      [
+        randomUUID(),
+        input.siteId,
+        input.pixelId ?? null,
+        input.name.trim(),
+        destination.toString(),
+        shortCode,
+        input.source.trim(),
+        input.medium.trim(),
+        input.campaign.trim(),
+        input.term?.trim() || null,
+        input.content?.trim() || null,
+        input.adGroup?.trim() || null,
+        input.adName?.trim() || null,
+        input.creativeId?.trim() || null,
+        input.userId
+      ]
+    );
+    return campaignLinkWithUrl(result.rows[0]);
+  } catch (error) {
+    if (error.code === "23505")
+      throw new AnalyticsRepositoryError(
+        "campaign_short_code_taken",
+        "That short code is already in use.",
+        409
+      );
+    throw error;
+  }
+}
+async function listAnalyticsCampaignLinks(siteId, userId, page) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const result = await db.query(
+    `SELECT l.*, count(c.id)::int AS click_count
+       FROM analytics_campaign_links l LEFT JOIN analytics_campaign_clicks c ON c.link_id = l.id
+      WHERE l.site_id = $1
+      GROUP BY l.id ORDER BY l.created_at DESC, l.id DESC LIMIT 1000`,
+    [siteId]
+  );
+  const rows = result.rows.map(campaignLinkWithUrl);
+  const filters = { start: "all", end: "all" };
+  const paged = paginateRows(
+    rows,
+    page,
+    pageFingerprint("campaign-links", siteId, filters)
+  );
+  return { links: paged.items, pageInfo: paged.pageInfo };
+}
+async function archiveAnalyticsCampaignLink(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  const result = await db.query(
+    `UPDATE analytics_campaign_links SET status = 'archived', updated_at = now() WHERE id = $1 AND site_id = $2`,
+    [input.linkId, input.siteId]
+  );
+  if (!result.rowCount)
+    throw new AnalyticsRepositoryError(
+      "campaign_link_not_found",
+      "Campaign link not found.",
+      404
+    );
+}
+async function resolveAnalyticsCampaignLink(shortCode, referrer) {
+  const db = getAnalyticsPool();
+  const result = await db.query(
+    `SELECT l.*, 0::int AS click_count FROM analytics_campaign_links l WHERE l.short_code = $1 AND l.status = 'active'`,
+    [shortCode]
+  );
+  const row = result.rows[0];
+  if (!row) return null;
+  await db.query(
+    `INSERT INTO analytics_campaign_clicks(id, link_id, referrer) VALUES ($1, $2, $3)`,
+    [randomUUID(), row.id, normalizeAnalyticsUrl(referrer || void 0)]
+  );
+  return buildTaggedCampaignUrl(row);
+}
+async function createAnalyticsForm(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  const pixel = await db.query(
+    "SELECT 1 FROM analytics_pixels WHERE id = $1 AND site_id = $2",
+    [input.pixelId, input.siteId]
+  );
+  if (!pixel.rowCount)
+    throw new AnalyticsRepositoryError(
+      "analytics_pixel_not_found",
+      "Pixel not found.",
+      404
+    );
+  const baseSlug = normalizeSlug(input.name);
+  const slug = `${baseSlug}-${randomBytes(3).toString("hex")}`;
+  const publicId = `form_${randomBytes(18).toString("base64url")}`;
+  const result = await db.query(
+    `INSERT INTO analytics_forms(id, public_id, site_id, pixel_id, name, slug, fields, brand, submit_label, success_message, redirect_url, consent_text, status, created_by_user_id)
+     VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,$8::jsonb,$9,$10,$11,$12,$13,$14)
+     RETURNING *, 0::int AS submission_count`,
+    [
+      randomUUID(),
+      publicId,
+      input.siteId,
+      input.pixelId,
+      input.name.trim(),
+      slug,
+      JSON.stringify(input.fields),
+      JSON.stringify(input.brand),
+      input.submitLabel?.trim() || "Submit",
+      input.successMessage?.trim() || "Thank you. Your response was received.",
+      input.redirectUrl?.trim() || null,
+      input.consentText?.trim() || null,
+      input.publish ? "published" : "draft",
+      input.userId
+    ]
+  );
+  return result.rows[0];
+}
+async function listAnalyticsForms(siteId, userId, page) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const result = await db.query(
+    `SELECT f.*, count(s.id)::int AS submission_count FROM analytics_forms f
+     LEFT JOIN analytics_form_submissions s ON s.form_id = f.id
+     WHERE f.site_id = $1 GROUP BY f.id ORDER BY f.created_at DESC, f.id DESC LIMIT 1000`,
+    [siteId]
+  );
+  const paged = paginateRows(
+    result.rows,
+    page,
+    pageFingerprint("forms", siteId, { start: "all", end: "all" })
+  );
+  return { forms: paged.items, pageInfo: paged.pageInfo };
+}
+async function getPublicAnalyticsForm(publicId) {
+  const result = await getAnalyticsPool().query(
+    `SELECT f.*, s.owner_user_id, p.public_id AS pixel_public_id,
+            (SELECT count(*)::int FROM analytics_form_submissions fs WHERE fs.form_id = f.id) AS submission_count
+       FROM analytics_forms f JOIN analytics_sites s ON s.id = f.site_id JOIN analytics_pixels p ON p.id = f.pixel_id
+      WHERE f.public_id = $1 AND f.status = 'published'`,
+    [publicId]
+  );
+  return result.rows[0] ?? null;
+}
+async function recordAnalyticsFormSubmission(input) {
+  const id = randomUUID();
+  await getAnalyticsPool().query(
+    `INSERT INTO analytics_form_submissions(id, form_id, site_id, pixel_id, visitor_id, session_id, crm_person_ref, source, medium, campaign, crm_delivery_status, click_ids)
+     VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12::jsonb)`,
+    [
+      id,
+      input.form.id,
+      input.form.site_id,
+      input.form.pixel_id,
+      input.visitorId ?? null,
+      input.sessionId ?? null,
+      input.crmPersonRef ?? null,
+      input.source?.slice(0, 180) ?? null,
+      input.medium?.slice(0, 180) ?? null,
+      input.campaign?.slice(0, 240) ?? null,
+      input.crmDeliveryStatus ?? "pending",
+      JSON.stringify(sanitizeClickIds(input.clickIds))
+    ]
+  );
+  return { submissionId: id };
+}
+var clickIdKeys = /* @__PURE__ */ new Set([
+  "fbclid",
+  "gclid",
+  "gbraid",
+  "wbraid",
+  "ttclid",
+  "rdt_cid",
+  "msclkid"
+]);
+function sanitizeClickIds(value) {
+  const output = {};
+  for (const [key, raw] of Object.entries(value ?? {})) {
+    if (!clickIdKeys.has(key) || typeof raw !== "string") continue;
+    const normalized = raw.trim();
+    if (normalized) output[key] = normalized.slice(0, 500);
+  }
+  return output;
+}
+function identityHmac(kind, value) {
+  return createHmac2("sha256", getSessionSecret()).update(`${kind}:${value.trim().toLowerCase()}`).digest("hex");
+}
+async function linkAnalyticsFormIdentity(input) {
+  const client = await getAnalyticsPool().connect();
+  try {
+    await client.query("BEGIN");
+    const person = await client.query(
+      `INSERT INTO analytics_people(id, site_id, crm_person_ref) VALUES ($1,$2,$3)
+       ON CONFLICT(site_id, crm_person_ref) DO UPDATE SET last_seen_at = now() RETURNING id`,
+      [randomUUID(), input.siteId, input.crmPersonRef]
+    );
+    const personId = person.rows[0].id;
+    const signals = [];
+    if (input.visitorId)
+      signals.push({
+        kind: "visitor_id",
+        value: input.visitorId,
+        evidence: "first_party_form",
+        confidence: 0.98
+      });
+    if (input.sessionId)
+      signals.push({
+        kind: "session_id",
+        value: input.sessionId,
+        evidence: "first_party_form",
+        confidence: 0.95
+      });
+    if (input.email)
+      signals.push({
+        kind: "email",
+        value: input.email,
+        evidence: "submitted_email",
+        confidence: 1
+      });
+    if (input.phone)
+      signals.push({
+        kind: "phone",
+        value: input.phone,
+        evidence: "submitted_phone",
+        confidence: 0.99
+      });
+    for (const [platform, clickId] of Object.entries(
+      sanitizeClickIds(input.clickIds)
+    )) {
+      signals.push({
+        kind: "click_id",
+        value: `${platform}:${clickId}`,
+        evidence: platform,
+        confidence: 0.9
+      });
+    }
+    for (const signal of signals) {
+      const node = await client.query(
+        `INSERT INTO analytics_identity_nodes(id, site_id, kind, value_hmac) VALUES ($1,$2,$3,$4)
+         ON CONFLICT(site_id, kind, value_hmac) DO UPDATE SET last_seen_at = now() RETURNING id`,
+        [
+          randomUUID(),
+          input.siteId,
+          signal.kind,
+          identityHmac(signal.kind, signal.value)
+        ]
+      );
+      await client.query(
+        `INSERT INTO analytics_identity_edges(id, site_id, person_id, identity_node_id, evidence_kind, confidence)
+         VALUES ($1,$2,$3,$4,$5,$6)
+         ON CONFLICT(person_id, identity_node_id, evidence_kind) DO UPDATE SET last_seen_at = now(), confidence = greatest(analytics_identity_edges.confidence, EXCLUDED.confidence)`,
+        [
+          randomUUID(),
+          input.siteId,
+          personId,
+          node.rows[0].id,
+          signal.evidence,
+          signal.confidence
+        ]
+      );
+    }
+    if (input.submissionId)
+      await client.query(
+        "UPDATE analytics_form_submissions SET person_id = $1 WHERE id = $2 AND site_id = $3",
+        [personId, input.submissionId, input.siteId]
+      );
+    if (input.visitorId || input.sessionId) {
+      await client.query(
+        `UPDATE analytics_events SET person_id = $1 WHERE site_id = $2 AND person_id IS NULL
+          AND (($3::text IS NOT NULL AND visitor_id = $3) OR ($4::text IS NOT NULL AND session_id = $4))`,
+        [
+          personId,
+          input.siteId,
+          input.visitorId ?? null,
+          input.sessionId ?? null
+        ]
+      );
+      await client.query(
+        `UPDATE analytics_conversions SET person_id = $1 WHERE site_id = $2 AND person_id IS NULL AND $3::text IS NOT NULL AND session_id = $3`,
+        [personId, input.siteId, input.sessionId ?? null]
+      );
+    }
+    await client.query("COMMIT");
+    return { personId, linkedSignals: signals.length };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function listAnalyticsPeople(siteId, userId, page) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const result = await db.query(
+    `SELECT p.id, p.first_seen_at, p.last_seen_at, true AS crm_linked,
+            (SELECT count(*)::int FROM analytics_identity_edges e WHERE e.person_id = p.id) AS signal_count,
+            (SELECT count(*)::int FROM analytics_form_submissions f WHERE f.person_id = p.id) AS form_submission_count,
+            (SELECT count(*)::int FROM analytics_conversions c WHERE c.person_id = p.id) AS conversion_count,
+            (SELECT COALESCE(sum(c.value_minor), 0)::bigint FROM analytics_conversions c WHERE c.person_id = p.id) AS revenue_minor
+       FROM analytics_people p WHERE p.site_id = $1 ORDER BY p.last_seen_at DESC, p.id DESC LIMIT 1000`,
+    [siteId]
+  );
+  const paged = paginateRows(
+    result.rows,
+    page,
+    pageFingerprint("people", siteId, { start: "all", end: "all" })
+  );
+  return { people: paged.items, pageInfo: paged.pageInfo };
+}
+async function getAnalyticsPersonJourney(siteId, personId, userId, page) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const exists = await db.query(
+    "SELECT 1 FROM analytics_people WHERE id = $1 AND site_id = $2",
+    [personId, siteId]
+  );
+  if (!exists.rowCount)
+    throw new AnalyticsRepositoryError(
+      "analytics_person_not_found",
+      "Attributed person not found.",
+      404
+    );
+  const result = await db.query(
+    `SELECT * FROM (
+       SELECT e.occurred_at, 'event'::text AS kind, e.event_name AS label, e.source, e.medium, e.campaign, e.path, 0::bigint AS value_minor, NULL::text AS currency
+         FROM analytics_events e WHERE e.site_id = $1 AND e.person_id = $2
+       UNION ALL
+       SELECT f.occurred_at, 'form_submission', af.name, f.source, f.medium, f.campaign, NULL, 0, NULL
+         FROM analytics_form_submissions f JOIN analytics_forms af ON af.id = f.form_id WHERE f.site_id = $1 AND f.person_id = $2
+       UNION ALL
+       SELECT c.occurred_at, 'conversion', c.conversion_kind, NULL, NULL, NULL, NULL, c.value_minor, c.currency
+         FROM analytics_conversions c WHERE c.site_id = $1 AND c.person_id = $2
+     ) journey ORDER BY occurred_at DESC LIMIT 1000`,
+    [siteId, personId]
+  );
+  const paged = paginateRows(
+    result.rows,
+    page,
+    pageFingerprint("person_journey", siteId, {
+      start: personId,
+      end: personId
+    })
+  );
+  return { personId, touchpoints: paged.items, pageInfo: paged.pageInfo };
+}
+async function createAnalyticsCrmImport(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  const client = await db.connect();
+  const id = randomUUID();
+  try {
+    await client.query("BEGIN");
+    await client.query(
+      `INSERT INTO analytics_crm_imports(id, site_id, requested_by_user_id, source_system, filename, accepted_count, rejected_count)
+       VALUES ($1,$2,$3,$4,$5,$6,$7)`,
+      [
+        id,
+        input.siteId,
+        input.userId,
+        input.sourceSystem.slice(0, 80),
+        input.filename.slice(0, 240),
+        input.rows.length,
+        input.rejectedCount
+      ]
+    );
+    for (const row of input.rows) {
+      await client.query(
+        `INSERT INTO analytics_crm_import_rows(id, import_id, crm_person_ref, payload_ciphertext)
+         VALUES ($1,$2,$3,$4) ON CONFLICT(import_id, crm_person_ref) DO NOTHING`,
+        [randomUUID(), id, row.crmPersonRef, row.payloadCiphertext]
+      );
+    }
+    await client.query("COMMIT");
+    return {
+      id,
+      status: "queued",
+      acceptedCount: input.rows.length,
+      rejectedCount: input.rejectedCount
+    };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function listAnalyticsCrmImports(siteId, userId, page) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const result = await db.query(
+    `SELECT id, source_system, filename, status, accepted_count, rejected_count, created_at, completed_at
+       FROM analytics_crm_imports WHERE site_id = $1 ORDER BY created_at DESC, id DESC LIMIT 1000`,
+    [siteId]
+  );
+  const paged = paginateRows(
+    result.rows,
+    page,
+    pageFingerprint("crm_imports", siteId, { start: "all", end: "all" })
+  );
+  return { imports: paged.items, pageInfo: paged.pageInfo };
+}
+async function createAnalyticsActivationDestination(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  const result = await db.query(
+    `INSERT INTO analytics_activation_destinations(id, site_id, platform, name, connection_ref, external_dataset_id, event_mapping, created_by_user_id)
+     VALUES ($1,$2,$3,$4,$5,$6,$7::jsonb,$8) RETURNING *`,
+    [
+      randomUUID(),
+      input.siteId,
+      input.platform,
+      input.name.trim(),
+      input.connectionRef?.trim() || null,
+      input.externalDatasetId?.trim() || null,
+      JSON.stringify(input.eventMapping ?? {}),
+      input.userId
+    ]
+  );
+  return result.rows[0];
+}
+async function listAnalyticsActivationDestinations(siteId, userId) {
+  const db = getAnalyticsPool();
+  await accessFor(db, siteId, userId);
+  const result = await db.query(
+    `SELECT d.*, count(j.id)::int AS delivery_count,
+            count(j.id) FILTER (WHERE j.status = 'pending')::int AS pending_count,
+            count(j.id) FILTER (WHERE j.status = 'delivered')::int AS delivered_count,
+            count(j.id) FILTER (WHERE j.status = 'failed')::int AS failed_count
+       FROM analytics_activation_destinations d LEFT JOIN analytics_activation_jobs j ON j.destination_id = d.id
+      WHERE d.site_id = $1 AND d.status <> 'archived' GROUP BY d.id ORDER BY d.created_at DESC`,
+    [siteId]
+  );
+  return result.rows;
+}
+async function archiveAnalyticsActivationDestination(input) {
+  const db = getAnalyticsPool();
+  await requireEditor(db, input.siteId, input.userId);
+  const result = await db.query(
+    `UPDATE analytics_activation_destinations SET status = 'archived', updated_at = now() WHERE id = $1 AND site_id = $2`,
+    [input.destinationId, input.siteId]
+  );
+  if (!result.rowCount)
+    throw new AnalyticsRepositoryError(
+      "analytics_activation_destination_not_found",
+      "Activation destination not found.",
+      404
+    );
+}
+async function queueAnalyticsActivation(input) {
+  const db = getAnalyticsPool();
+  const destinations = await db.query(
+    `SELECT id FROM analytics_activation_destinations WHERE site_id = $1 AND status = 'active'`,
+    [input.siteId]
+  );
+  let queued = 0;
+  for (const destination of destinations.rows) {
+    const result = await db.query(
+      `INSERT INTO analytics_activation_jobs(id, destination_id, conversion_id, person_id, payload_ciphertext)
+       VALUES ($1,$2,$3,$4,$5) ON CONFLICT(destination_id, conversion_id) DO NOTHING`,
+      [
+        randomUUID(),
+        destination.id,
+        input.conversionId,
+        input.personId ?? null,
+        input.payloadCiphertext
+      ]
+    );
+    queued += result.rowCount ?? 0;
+  }
+  return queued;
+}
+async function queueAnalyticsFormDelivery(input) {
+  const id = randomUUID();
+  await getAnalyticsPool().query(
+    `INSERT INTO analytics_form_delivery_jobs(id, submission_id, owner_user_id, payload_ciphertext, last_error_code)
+     VALUES ($1,$2,$3,$4,$5)`,
+    [
+      id,
+      input.submissionId,
+      input.ownerUserId,
+      input.payloadCiphertext,
+      input.errorCode ?? null
+    ]
+  );
+  return id;
+}
+async function claimAnalyticsFormDeliveryJobs(limit = 10) {
+  const result = await getAnalyticsPool().query(
+    `WITH due AS (
+       SELECT id FROM analytics_form_delivery_jobs
+        WHERE status = 'pending' AND next_attempt_at <= now() AND expires_at > now()
+        ORDER BY next_attempt_at, created_at
+        FOR UPDATE SKIP LOCKED LIMIT $1
+     )
+     UPDATE analytics_form_delivery_jobs j
+        SET attempts = j.attempts + 1,
+            next_attempt_at = now() + interval '5 minutes'
+       FROM due WHERE j.id = due.id
+     RETURNING j.id, j.submission_id, j.owner_user_id, j.payload_ciphertext, j.attempts`,
+    [Math.min(Math.max(limit, 1), 50)]
+  );
+  return result.rows.map((row) => ({
+    id: row.id,
+    submissionId: row.submission_id,
+    ownerUserId: Number(row.owner_user_id),
+    payloadCiphertext: row.payload_ciphertext,
+    attempts: row.attempts
+  }));
+}
+async function completeAnalyticsFormDelivery(jobId, submissionId) {
+  const db = getAnalyticsPool();
+  const client = await db.connect();
+  try {
+    await client.query("BEGIN");
+    await client.query(
+      `UPDATE analytics_form_delivery_jobs SET status='delivered', delivered_at=now(), last_error_code=NULL WHERE id=$1`,
+      [jobId]
+    );
+    await client.query(
+      `UPDATE analytics_form_submissions SET crm_delivery_status='delivered' WHERE id=$1`,
+      [submissionId]
+    );
+    await client.query("COMMIT");
+  } catch (error) {
+    await client.query("ROLLBACK");
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function deferAnalyticsFormDelivery(jobId, attempts, errorCode) {
+  const terminal = attempts >= 8;
+  const delayMinutes = Math.min(5 * 2 ** Math.max(0, attempts - 1), 360);
+  await getAnalyticsPool().query(
+    `UPDATE analytics_form_delivery_jobs
+        SET status = CASE WHEN expires_at <= now() THEN 'expired' WHEN $2 THEN 'failed' ELSE 'pending' END,
+            last_error_code = $3,
+            next_attempt_at = now() + ($4::text || ' minutes')::interval
+      WHERE id = $1`,
+    [jobId, terminal, errorCode.slice(0, 80), String(delayMinutes)]
+  );
+}
+async function isAnalyticsFormPlacementApproved(pixelId, placementUrl) {
+  if (!placementUrl) return false;
+  let hostname = null;
+  try {
+    hostname = new URL(placementUrl).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  const result = await getAnalyticsPool().query(
+    `SELECT 1 FROM analytics_pixel_domains WHERE pixel_id = $1 AND hostname = $2 AND state = 'approved'`,
+    [pixelId, hostname]
+  );
+  return Boolean(result.rowCount);
+}
+async function analyticsHealth(siteId, userId) {
+  const db = getAnalyticsPool();
+  const pixels = await listAnalyticsPixels(siteId, userId);
+  const lastEventAt = pixels.map((pixel) => pixel.last_event_at).filter(Boolean).sort().at(-1) ?? null;
+  const [conversion, rollup, receipts] = await Promise.all([
+    db.query(
+      `SELECT max(occurred_at)::text AS last_conversion_at FROM analytics_conversions WHERE site_id = $1`,
+      [siteId]
+    ),
+    db.query(
+      `SELECT max(refreshed_at)::text AS last_rollup_at FROM analytics_rollups_daily WHERE site_id = $1`,
+      [siteId]
+    ),
+    db.query(
+      `SELECT COALESCE(sum(accepted_count), 0)::int AS accepted,
+              COALESCE(sum(rejected_count), 0)::int AS rejected
+         FROM analytics_ingestion_receipts WHERE site_id = $1 AND created_at >= now() - interval '24 hours'`,
+      [siteId]
+    )
+  ]);
+  const recent = receipts.rows[0];
+  const totalRecent = recent.accepted + recent.rejected;
+  const rejectionRate = totalRecent ? recent.rejected / totalRecent : 0;
+  const stale = Boolean(
+    lastEventAt && Date.now() - Date.parse(lastEventAt) > 48 * 60 * 60 * 1e3
+  );
+  const hasMismatch = pixels.some(
+    (pixel) => pixel.domains.some((domain) => domain.state === "observed_unverified")
+  );
+  return {
+    status: pixels.length === 0 ? "not_installed" : hasMismatch && !lastEventAt ? "domain_mismatch" : rejectionRate > 0.25 ? "rejecting" : stale ? "stale" : lastEventAt ? "healthy" : "waiting",
+    pixels,
+    lastEventAt,
+    lastConversionAt: conversion.rows[0]?.last_conversion_at ?? null,
+    lastRollupAt: rollup.rows[0]?.last_rollup_at ?? null,
+    acceptedLast24Hours: recent.accepted,
+    rejectedLast24Hours: recent.rejected,
+    rejectionRate,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function refreshAnalyticsDailyRollups(input) {
+  const db = getAnalyticsPool();
+  const runId = randomUUID();
+  await db.query(
+    `INSERT INTO analytics_rollup_runs(id, window_start, window_end, status) VALUES ($1, $2, $3, 'running')`,
+    [runId, input.start, input.end]
+  );
+  const client = await db.connect();
+  try {
+    await client.query("BEGIN");
+    await client.query(
+      `DELETE FROM analytics_rollups_daily WHERE bucket >= $1::date AND bucket < $2::date`,
+      [input.start, input.end]
+    );
+    const inserted = await client.query(
+      `INSERT INTO analytics_rollups_daily(
+         site_id, pixel_id, hostname, bucket, source, medium, campaign,
+         pageviews, events, visitors, sessions, refreshed_at
+       )
+       SELECT site_id, pixel_id, hostname, occurred_at::date,
+              COALESCE(source, '(direct)'), COALESCE(medium, '(none)'), COALESCE(campaign, '(none)'),
+              count(*) FILTER (WHERE event_name = 'page_view')::int,
+              count(*)::int,
+              count(DISTINCT visitor_id)::int,
+              count(DISTINCT session_id)::int,
+              now()
+         FROM analytics_events
+        WHERE occurred_at >= $1::timestamptz AND occurred_at < $2::timestamptz
+        GROUP BY 1, 2, 3, 4, 5, 6, 7`,
+      [input.start, input.end]
+    );
+    await client.query("COMMIT");
+    const rows = inserted.rowCount ?? 0;
+    await db.query(
+      `UPDATE analytics_rollup_runs SET status = 'complete', row_count = $2, completed_at = now() WHERE id = $1`,
+      [runId, rows]
+    );
+    return { runId, rows };
+  } catch (error) {
+    await client.query("ROLLBACK");
+    await db.query(
+      `UPDATE analytics_rollup_runs SET status = 'failed', completed_at = now(), error_code = 'rollup_failed' WHERE id = $1`,
+      [runId]
+    );
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+async function refreshAnalyticsDailyRollupsIfDue(now = /* @__PURE__ */ new Date()) {
+  const db = getAnalyticsPool();
+  const lockClient = await db.connect();
+  const advisoryLockId = 2026080501;
+  let locked = false;
+  try {
+    const lock = await lockClient.query(
+      "SELECT pg_try_advisory_lock($1) AS acquired",
+      [advisoryLockId]
+    );
+    locked = Boolean(lock.rows[0]?.acquired);
+    if (!locked) return { status: "already_running", rows: 0 };
+    const recent = await lockClient.query(
+      `SELECT completed_at FROM analytics_rollup_runs
+       WHERE status = 'complete' AND completed_at > $1::timestamptz
+       ORDER BY completed_at DESC LIMIT 1`,
+      [new Date(now.getTime() - 55 * 6e4).toISOString()]
+    );
+    if (recent.rows[0]) return { status: "not_due", rows: 0 };
+    const end = new Date(now);
+    const start = new Date(end.getTime() - 3 * 24 * 60 * 60 * 1e3);
+    const result = await refreshAnalyticsDailyRollups({
+      start: start.toISOString(),
+      end: end.toISOString()
+    });
+    return { status: "complete", ...result };
+  } finally {
+    if (locked)
+      await lockClient.query("SELECT pg_advisory_unlock($1)", [advisoryLockId]).catch(() => void 0);
+    lockClient.release();
+  }
+}
+function csvCell(value) {
+  const text = value == null ? "" : String(value);
+  return /[\n\r,\"]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
+}
+function rowsToCsv(rows) {
+  const columns = [...new Set(rows.flatMap((row) => Object.keys(row)))];
+  if (!columns.length) return "";
+  return [
+    columns.join(","),
+    ...rows.map(
+      (row) => columns.map((column) => csvCell(row[column])).join(",")
+    )
+  ].join("\n");
+}
+async function createAnalyticsExport(input) {
+  const site = (await listAnalyticsSites(input.userId)).find(
+    (candidate) => candidate.id === input.siteId
+  );
+  if (!site)
+    throw new AnalyticsRepositoryError(
+      "analytics_site_not_found",
+      "Site not found.",
+      404
+    );
+  const describeArtifact = (artifact2) => {
+    const extension = artifact2.format === "markdown" ? "md" : artifact2.format;
+    return {
+      ...artifact2,
+      mediaType: artifact2.format === "csv" ? "text/csv" : artifact2.format === "json" ? "application/json" : "text/markdown",
+      filename: `${site.slug}-${artifact2.report}.${extension}`
+    };
+  };
+  if (input.idempotencyKey) {
+    const existing = await getAnalyticsPool().query(
+      `SELECT id, report, format, content FROM analytics_exports
+        WHERE requested_by_user_id = $1 AND idempotency_key = $2`,
+      [input.userId, input.idempotencyKey]
+    );
+    const artifact2 = existing.rows[0];
+    if (artifact2) return describeArtifact(artifact2);
+  }
+  const data = input.report === "overview" ? await analyticsOverview(input.siteId, input.userId, input.filters) : input.report === "acquisition" ? await analyticsAcquisition(input.siteId, input.userId, input.filters) : input.report === "content" ? await analyticsContent(input.siteId, input.userId, input.filters) : await analyticsConversions(
+    input.siteId,
+    input.userId,
+    input.filters
+  );
+  const rows = input.report === "overview" ? [data] : input.report === "acquisition" ? data.channels : input.report === "content" ? data.content : data.conversions;
+  let content;
+  if (input.format === "json") {
+    content = JSON.stringify(
+      {
+        version: 1,
+        site: { id: site.id, name: site.name },
+        report: input.report,
+        filters: input.filters,
+        data
+      },
+      null,
+      2
+    );
+  } else if (input.format === "csv") {
+    content = rowsToCsv(rows);
+  } else {
+    const overview = await analyticsOverview(
+      input.siteId,
+      input.userId,
+      input.filters
+    );
+    content = [
+      `# ${site.name} Site Analytics`,
+      "",
+      `Report: ${input.report}`,
+      `Window: ${input.filters.start} to ${input.filters.end}`,
+      `Fresh through: ${overview.dataFreshThrough ?? "No accepted events"}`,
+      "",
+      `- Visitors: ${overview.visitors}`,
+      `- Sessions: ${overview.sessions}`,
+      `- Pageviews: ${overview.pageviews}`,
+      `- Verified conversions: ${overview.conversions}`,
+      `- Verified revenue: ${(overview.revenueMinor / 100).toFixed(2)}`,
+      "",
+      `Generated ${(/* @__PURE__ */ new Date()).toISOString()} from the governed ${input.report} report contract.`
+    ].join("\n");
+  }
+  const id = randomUUID();
+  const inserted = await getAnalyticsPool().query(
+    `INSERT INTO analytics_exports(id, site_id, requested_by_user_id, idempotency_key, report, format, filters, content)
+     VALUES ($1, $2, $3, $4, $5, $6, $7::jsonb, $8)
+     ON CONFLICT (requested_by_user_id, idempotency_key) WHERE idempotency_key IS NOT NULL DO NOTHING
+     RETURNING id, report, format, content`,
+    [
+      id,
+      input.siteId,
+      input.userId,
+      input.idempotencyKey ?? null,
+      input.report,
+      input.format,
+      JSON.stringify(input.filters),
+      content
+    ]
+  );
+  const artifact = inserted.rows[0];
+  if (artifact) return describeArtifact(artifact);
+  const replay = await getAnalyticsPool().query(
+    `SELECT id, report, format, content FROM analytics_exports
+      WHERE requested_by_user_id = $1 AND idempotency_key = $2`,
+    [input.userId, input.idempotencyKey]
+  );
+  if (!replay.rows[0]) {
+    throw new AnalyticsRepositoryError(
+      "analytics_export_conflict",
+      "The export could not be created or replayed.",
+      409
+    );
+  }
+  return describeArtifact(replay.rows[0]);
+}
+
+export {
+  getSessionSecret,
+  signSession,
+  verifySession,
+  AnalyticsRepositoryError,
+  getAnalyticsPool,
+  closeAnalyticsPool,
+  migrateAnalytics,
+  normalizeObservedHostname,
+  createAnalyticsSite,
+  listAnalyticsSites,
+  updateAnalyticsBusinessModel,
+  upsertAnalyticsAdSpend,
+  analyticsBusinessMetrics,
+  analyticsForecast,
+  deleteAnalyticsSite,
+  createAnalyticsPixel,
+  listAnalyticsPixels,
+  updateAnalyticsPixel,
+  setAnalyticsPixelDomainState,
+  normalizeAnalyticsPath,
+  normalizeAnalyticsUrl,
+  sanitizeAnalyticsProperties,
+  ingestAnalyticsEvents,
+  createAnalyticsConversion,
+  analyticsOverview,
+  analyticsTimeseries,
+  analyticsAcquisition,
+  analyticsChannelBreakdown,
+  analyticsContent,
+  analyticsEventCounts,
+  analyticsConversions,
+  analyticsPaths,
+  analyticsDimensions,
+  createAnalyticsCampaignLink,
+  listAnalyticsCampaignLinks,
+  archiveAnalyticsCampaignLink,
+  resolveAnalyticsCampaignLink,
+  createAnalyticsForm,
+  listAnalyticsForms,
+  getPublicAnalyticsForm,
+  recordAnalyticsFormSubmission,
+  sanitizeClickIds,
+  linkAnalyticsFormIdentity,
+  listAnalyticsPeople,
+  getAnalyticsPersonJourney,
+  createAnalyticsCrmImport,
+  listAnalyticsCrmImports,
+  createAnalyticsActivationDestination,
+  listAnalyticsActivationDestinations,
+  archiveAnalyticsActivationDestination,
+  queueAnalyticsActivation,
+  queueAnalyticsFormDelivery,
+  claimAnalyticsFormDeliveryJobs,
+  completeAnalyticsFormDelivery,
+  deferAnalyticsFormDelivery,
+  isAnalyticsFormPlacementApproved,
+  analyticsHealth,
+  refreshAnalyticsDailyRollups,
+  refreshAnalyticsDailyRollupsIfDue,
+  createAnalyticsExport
+};
+//# sourceMappingURL=chunk-YW2LXLDU.js.map