@jayfarei/lazyanalytics 0.1.0 → 0.3.0

package/dist/worker.js

@@ -1,4 +1,4 @@
-// worker/node_modules/hono/dist/compose.js
+// node_modules/hono/dist/compose.js
 var compose = (middleware, onError, onNotFound) => {
   return (context, next) => {
     let index = -1;
@@ -42,10 +42,10 @@ var compose = (middleware, onError, onNotFound) => {
   };
 };
 
-// worker/node_modules/hono/dist/request/constants.js
+// node_modules/hono/dist/request/constants.js
 var GET_MATCH_RESULT = /* @__PURE__ */ Symbol();
 
-// worker/node_modules/hono/dist/utils/body.js
+// node_modules/hono/dist/utils/body.js
 var parseBody = async (request, options = /* @__PURE__ */ Object.create(null)) => {
   const { all = false, dot = false } = options;
   const headers = request instanceof HonoRequest ? request.raw.headers : request.headers;
@@ -117,7 +117,7 @@ var handleParsingNestedValues = (form, key, value) => {
   });
 };
 
-// worker/node_modules/hono/dist/utils/url.js
+// node_modules/hono/dist/utils/url.js
 var splitPath = (path) => {
   const paths = path.split("/");
   if (paths[0] === "") {
@@ -321,7 +321,7 @@ var getQueryParams = (url, key) => {
 };
 var decodeURIComponent_ = decodeURIComponent;
 
-// worker/node_modules/hono/dist/request.js
+// node_modules/hono/dist/request.js
 var tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
 var HonoRequest = class {
   /**
@@ -466,6 +466,21 @@ var HonoRequest = class {
   arrayBuffer() {
     return this.#cachedBody("arrayBuffer");
   }
+  /**
+   * `.bytes()` parses the request body as a `Uint8Array`.
+   *
+   * @see {@link https://hono.dev/docs/api/request#bytes}
+   *
+   * @example
+   * ```ts
+   * app.post('/entry', async (c) => {
+   *   const body = await c.req.bytes()
+   * })
+   * ```
+   */
+  bytes() {
+    return this.#cachedBody("arrayBuffer").then((buffer) => new Uint8Array(buffer));
+  }
   /**
    * Parses the request body as a `Blob`.
    * @example
@@ -589,7 +604,7 @@ var HonoRequest = class {
   }
 };
 
-// worker/node_modules/hono/dist/utils/html.js
+// node_modules/hono/dist/utils/html.js
 var HtmlEscapedCallbackPhase = {
   Stringify: 1,
   BeforeStream: 2,
@@ -631,7 +646,7 @@ var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) =>
   }
 };
 
-// worker/node_modules/hono/dist/context.js
+// node_modules/hono/dist/context.js
 var TEXT_PLAIN = "text/plain; charset=UTF-8";
 var setDefaultContentType = (contentType, headers) => {
   return {
@@ -1038,7 +1053,7 @@ var Context = class {
   };
 };
 
-// worker/node_modules/hono/dist/router.js
+// node_modules/hono/dist/router.js
 var METHOD_NAME_ALL = "ALL";
 var METHOD_NAME_ALL_LOWERCASE = "all";
 var METHODS = ["get", "post", "put", "delete", "options", "patch"];
@@ -1046,10 +1061,10 @@ var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is
 var UnsupportedPathError = class extends Error {
 };
 
-// worker/node_modules/hono/dist/utils/constants.js
+// node_modules/hono/dist/utils/constants.js
 var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
 
-// worker/node_modules/hono/dist/hono-base.js
+// node_modules/hono/dist/hono-base.js
 var notFoundHandler = (c) => {
   return c.text("404 Not Found", 404);
 };
@@ -1164,7 +1179,7 @@ var Hono = class _Hono {
         handler = async (c, next) => (await compose([], app2.errorHandler)(c, () => r.handler(c, next))).res;
         handler[COMPOSED_HANDLER] = r.handler;
       }
-      subApp.#addRoute(r.method, r.path, handler);
+      subApp.#addRoute(r.method, r.path, handler, r.basePath);
     });
     return this;
   }
@@ -1288,7 +1303,7 @@ var Hono = class _Hono {
       const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
       return (request) => {
         const url = new URL(request.url);
-        url.pathname = url.pathname.slice(pathPrefixLength) || "/";
+        url.pathname = this.getPath(request).slice(pathPrefixLength) || "/";
         return new Request(url, request);
       };
     })();
@@ -1302,10 +1317,15 @@ var Hono = class _Hono {
     this.#addRoute(METHOD_NAME_ALL, mergePath(path, "*"), handler);
     return this;
   }
-  #addRoute(method, path, handler) {
+  #addRoute(method, path, handler, baseRoutePath) {
     method = method.toUpperCase();
     path = mergePath(this._basePath, path);
-    const r = { basePath: this._basePath, path, method, handler };
+    const r = {
+      basePath: baseRoutePath !== void 0 ? mergePath(this._basePath, baseRoutePath) : this._basePath,
+      path,
+      method,
+      handler
+    };
     this.router.add(method, path, [handler, r]);
     this.routes.push(r);
   }
@@ -1420,7 +1440,7 @@ var Hono = class _Hono {
   };
 };
 
-// worker/node_modules/hono/dist/router/reg-exp-router/matcher.js
+// node_modules/hono/dist/router/reg-exp-router/matcher.js
 var emptyParam = [];
 function match(method, path) {
   const matchers = this.buildAllMatchers();
@@ -1441,7 +1461,7 @@ function match(method, path) {
   return match2(method, path);
 }
 
-// worker/node_modules/hono/dist/router/reg-exp-router/node.js
+// node_modules/hono/dist/router/reg-exp-router/node.js
 var LABEL_REG_EXP_STR = "[^/]+";
 var ONLY_WILDCARD_REG_EXP_STR = ".*";
 var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
@@ -1549,7 +1569,7 @@ var Node = class _Node {
   }
 };
 
-// worker/node_modules/hono/dist/router/reg-exp-router/trie.js
+// node_modules/hono/dist/router/reg-exp-router/trie.js
 var Trie = class {
   #context = { varIndex: 0 };
   #root = new Node();
@@ -1605,7 +1625,7 @@ var Trie = class {
   }
 };
 
-// worker/node_modules/hono/dist/router/reg-exp-router/router.js
+// node_modules/hono/dist/router/reg-exp-router/router.js
 var nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
 var wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
 function buildWildcardRegExp(path) {
@@ -1784,7 +1804,7 @@ var RegExpRouter = class {
   }
 };
 
-// worker/node_modules/hono/dist/router/smart-router/router.js
+// node_modules/hono/dist/router/smart-router/router.js
 var SmartRouter = class {
   name = "SmartRouter";
   #routers = [];
@@ -1839,7 +1859,7 @@ var SmartRouter = class {
   }
 };
 
-// worker/node_modules/hono/dist/router/trie-router/node.js
+// node_modules/hono/dist/router/trie-router/node.js
 var emptyParams = /* @__PURE__ */ Object.create(null);
 var hasChildren = (children) => {
   for (const _ in children) {
@@ -2014,7 +2034,7 @@ var Node2 = class _Node2 {
   }
 };
 
-// worker/node_modules/hono/dist/router/trie-router/router.js
+// node_modules/hono/dist/router/trie-router/router.js
 var TrieRouter = class {
   name = "TrieRouter";
   #node;
@@ -2036,7 +2056,7 @@ var TrieRouter = class {
   }
 };
 
-// worker/node_modules/hono/dist/hono.js
+// node_modules/hono/dist/hono.js
 var Hono2 = class extends Hono {
   /**
    * Creates an instance of the Hono class.
@@ -2051,24 +2071,18 @@ var Hono2 = class extends Hono {
   }
 };
 
-// worker/node_modules/hono/dist/middleware/cors/index.js
+// node_modules/hono/dist/middleware/cors/index.js
 var cors = (options) => {
-  const defaults = {
+  const opts = {
     origin: "*",
     allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
     allowHeaders: [],
-    exposeHeaders: []
-  };
-  const opts = {
-    ...defaults,
+    exposeHeaders: [],
     ...options
   };
   const findAllowOrigin = ((optsOrigin) => {
     if (typeof optsOrigin === "string") {
       if (optsOrigin === "*") {
-        if (opts.credentials) {
-          return (origin) => origin || null;
-        }
         return () => optsOrigin;
       } else {
         return (origin) => optsOrigin === origin ? origin : null;
@@ -2103,7 +2117,7 @@ var cors = (options) => {
       set("Access-Control-Expose-Headers", opts.exposeHeaders.join(","));
     }
     if (c.req.method === "OPTIONS") {
-      if (opts.origin !== "*" || opts.credentials) {
+      if (opts.origin !== "*") {
         set("Vary", "Origin");
       }
       if (opts.maxAge != null) {
@@ -2133,7 +2147,7 @@ var cors = (options) => {
       });
     }
     await next();
-    if (opts.origin !== "*" || opts.credentials) {
+    if (opts.origin !== "*") {
       c.header("Vary", "Origin", { append: true });
     }
   };
@@ -2182,8 +2196,31 @@ async function hashVisitor(site, ip, ua, date, salt) {
 function todayUTC() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
 }
+function sessionWindow(epochMs, slotMs = 30 * 60 * 1e3) {
+  return String(Math.floor(epochMs / slotMs));
+}
 
-// worker/src/lib/bot.ts
+// worker/src/lib/crawlers.ts
+var AI_RULES = [
+  { pattern: /chatgpt-user/i, name: "ChatGPT-User", operator: "OpenAI", type: "user" },
+  { pattern: /oai-searchbot/i, name: "OAI-SearchBot", operator: "OpenAI", type: "search" },
+  { pattern: /gptbot/i, name: "GPTBot", operator: "OpenAI", type: "train" },
+  { pattern: /claude-user/i, name: "Claude-User", operator: "Anthropic", type: "user" },
+  { pattern: /claude-searchbot/i, name: "Claude-SearchBot", operator: "Anthropic", type: "search" },
+  { pattern: /claude-web/i, name: "Claude-Web", operator: "Anthropic", type: "agent" },
+  { pattern: /claudebot/i, name: "ClaudeBot", operator: "Anthropic", type: "train" },
+  { pattern: /anthropic-ai/i, name: "Anthropic-AI", operator: "Anthropic", type: "train" },
+  { pattern: /perplexity-user/i, name: "Perplexity-User", operator: "Perplexity", type: "user" },
+  { pattern: /perplexitybot/i, name: "PerplexityBot", operator: "Perplexity", type: "search" },
+  { pattern: /meta-externalfetcher/i, name: "meta-externalfetcher", operator: "Meta", type: "user" },
+  { pattern: /meta-externalagent/i, name: "meta-externalagent", operator: "Meta", type: "agent" },
+  { pattern: /google-extended/i, name: "Google-Extended", operator: "Google", type: "train" },
+  { pattern: /googleother/i, name: "GoogleOther", operator: "Google", type: "train" },
+  { pattern: /gemini/i, name: "Gemini", operator: "Google", type: "agent" },
+  { pattern: /copilot/i, name: "Copilot", operator: "Microsoft", type: "coding" },
+  { pattern: /bytespider/i, name: "Bytespider", operator: "ByteDance", type: "train" },
+  { pattern: /ccbot/i, name: "CCBot", operator: "Common Crawl", type: "train" }
+];
 var BOT_PATTERNS = [
   /bot/i,
   /crawl/i,
@@ -2210,10 +2247,6 @@ var BOT_PATTERNS = [
   /puppeteer/i,
   /lighthouse/i,
   /pagespeed/i,
-  /gptbot/i,
-  /claudebot/i,
-  /anthropic/i,
-  /chatgpt/i,
   /prerender/i,
   /preview/i,
   /wget/i,
@@ -2224,9 +2257,87 @@ var BOT_PATTERNS = [
   /node-fetch/i,
   /go-http-client/i
 ];
-function isBot(ua) {
-  if (!ua || ua.length < 10) return true;
-  return BOT_PATTERNS.some((pattern) => pattern.test(ua));
+var BOT = { kind: "bot", name: "", operator: "", type: "" };
+var HUMAN = { kind: "human", name: "", operator: "", type: "" };
+function classifyCrawler(ua) {
+  try {
+    const value = typeof ua === "string" ? ua : String(ua);
+    if (!value || value.length < 10) return BOT;
+    for (const rule of AI_RULES) {
+      if (rule.pattern.test(value)) {
+        return { kind: "ai", name: rule.name, operator: rule.operator, type: rule.type };
+      }
+    }
+    if (BOT_PATTERNS.some((pattern) => pattern.test(value))) return BOT;
+    return HUMAN;
+  } catch {
+    return BOT;
+  }
+}
+
+// worker/src/lib/channels.ts
+var SEARCH_DOMAINS = [
+  "google.",
+  "bing.com",
+  "duckduckgo.com",
+  "yahoo.",
+  "baidu.com",
+  "yandex.",
+  "ecosia.org",
+  "brave.com",
+  "search.aol.",
+  "naver.com",
+  "seznam.",
+  "qwant.com"
+];
+var SOCIAL_DOMAINS = [
+  "facebook.com",
+  "instagram.com",
+  "threads.net",
+  "twitter.com",
+  "x.com",
+  "linkedin.com",
+  "t.co",
+  "reddit.com",
+  "pinterest.",
+  "youtube.com",
+  "tiktok.com",
+  "bsky.app",
+  "mastodon."
+];
+var AI_DOMAINS = [
+  "chatgpt.com",
+  "openai.com",
+  "claude.ai",
+  "anthropic.com",
+  "perplexity.ai",
+  "gemini.google.com",
+  "copilot.microsoft.com"
+];
+var EMAIL_SOURCES = ["mailchimp", "sendgrid", "postmark", "customer.io", "convertkit", "substack"];
+var PAID_MEDIUM_RE = /^(.*cp.*|ppc|retargeting|paid.*)$/i;
+function includesAny(value, needles) {
+  return needles.some((needle) => value.includes(needle));
+}
+function classifyChannel(referrerDomain, utmSource = "", utmMedium = "") {
+  try {
+    const ref = String(referrerDomain || "").toLowerCase();
+    const source = String(utmSource || "").toLowerCase();
+    const medium = String(utmMedium || "").toLowerCase();
+    const joined = `${ref} ${source}`;
+    if (includesAny(joined, AI_DOMAINS)) return "AI Assistants";
+    if (medium === "email" || includesAny(source, EMAIL_SOURCES)) return "Email";
+    if (PAID_MEDIUM_RE.test(medium) && (includesAny(joined, SEARCH_DOMAINS) || medium.includes("search"))) {
+      return "Paid Search";
+    }
+    if (includesAny(joined, SEARCH_DOMAINS)) return "Organic Search";
+    if (PAID_MEDIUM_RE.test(medium) && includesAny(joined, SOCIAL_DOMAINS)) return "Paid Social";
+    if (includesAny(joined, SOCIAL_DOMAINS)) return "Organic Social";
+    if (ref || medium === "referral" || medium === "link") return "Referral";
+    return "Direct";
+  } catch {
+    return "Direct";
+  }
 }
 
 // worker/src/collect.ts
@@ -2235,7 +2346,11 @@ async function collect(c) {
     return c.text("Method not allowed", 405);
   }
   const ua = c.req.header("User-Agent") || "";
-  if (isBot(ua)) {
+  const cls = classifyCrawler(ua);
+  if (cls.kind === "bot") {
+    return c.newResponse(null, 204);
+  }
+  if (cls.kind === "ai" && c.env.TRACK_AI_CRAWLERS !== "true") {
     return c.newResponse(null, 204);
   }
   let payload;
@@ -2278,7 +2393,12 @@ async function collect(c) {
   const ip = c.req.header("CF-Connecting-IP") || c.req.header("X-Forwarded-For") || "unknown";
   const country = c.req.header("CF-IPCountry") || "XX";
   const parsed = parseUA(ua);
+  const channel = classifyChannel(referrerDomain, payload.us || "", payload.um || "");
+  const now = Date.now();
   const visitorHash = await hashVisitor(payload.sid, ip, ua, todayUTC(), c.env.HASH_SALT);
+  const sessionHash = await hashVisitor(payload.sid, ip, ua, sessionWindow(now), c.env.HASH_SALT);
+  const eventType = payload.t === "eng" ? "eng" : "pv";
+  const engagementMs = Math.max(0, Math.round(Number(payload.em) || 0));
   c.env.ANALYTICS.writeDataPoint({
     indexes: [visitorHash],
     blobs: [
@@ -2298,14 +2418,32 @@ async function collect(c) {
       // blob7: device type
       payload.us || "",
       // blob8: utm_source
-      payload.um || ""
+      payload.um || "",
       // blob9: utm_medium
+      cls.kind === "ai" ? "ai" : "",
+      // blob10: traffic_class
+      channel,
+      // blob11: channel
+      sessionHash,
+      // blob12: session_id
+      cls.name || "",
+      // blob13: crawler_name
+      cls.operator || "",
+      // blob14: crawler_operator
+      cls.type || "",
+      // blob15: crawler_type
+      eventType
+      // blob16: event_type
     ],
     doubles: [
       1,
       // double1: count
-      payload.sw || 0
+      payload.sw || 0,
       // double2: screen width
+      0,
+      // double3: reserved
+      engagementMs
+      // double4: engagement_ms
     ]
   });
   return c.newResponse(null, 204);
@@ -2314,7 +2452,7 @@ async function collect(c) {
 // worker/src/tracker.ts
 var TRACKER_SCRIPT = `(function(){
   "use strict";
-  var d=document,w=window,l=d.currentScript;
+  var d=document,w=window,l=d.currentScript,t0=0,sent=0,last="";
   if(!l)return;
   var sid=l.getAttribute("data-site-id");
   if(!sid)return;
@@ -2349,9 +2487,12 @@ var TRACKER_SCRIPT = `(function(){
   }
 
   function track(){
+    t0=performance&&performance.now?performance.now():Date.now();
+    sent=0;
+    last=stripUrl(w.location.href);
     send({
       sid:sid,
-      url:stripUrl(w.location.href),
+      url:last,
       ref:stripRef(d.referrer),
       sw:w.screen?w.screen.width:0,
       us:getUTM("utm_source"),
@@ -2359,6 +2500,13 @@ var TRACKER_SCRIPT = `(function(){
     });
   }
 
+  function dwell(){
+    if(sent||!last)return;
+    sent=1;
+    var now=performance&&performance.now?performance.now():Date.now();
+    send({sid:sid,url:last,em:Math.max(0,Math.round(now-t0)),t:"eng"});
+  }
+
   // Track on page load
   if(d.readyState==="complete"){
     track();
@@ -2373,6 +2521,8 @@ var TRACKER_SCRIPT = `(function(){
     setTimeout(track,10);
   };
   w.addEventListener("popstate",function(){setTimeout(track,10);});
+  w.addEventListener("pagehide",dwell);
+  d.addEventListener("visibilitychange",function(){if(d.visibilityState==="hidden")dwell();});
 })();`;
 function serveTracker(c) {
   return c.newResponse(TRACKER_SCRIPT, 200, {
@@ -2968,14 +3118,20 @@ async function queryAE(env, sql) {
 function formatTimestamp(d) {
   return d.toISOString().replace("T", " ").replace(/\.\d{3}Z$/, "");
 }
-function buildWhereClause(opts) {
+var HUMAN_TRAFFIC_PREDICATE = "(blob10 = '' OR blob10 IS NULL)";
+var PAGEVIEW_EVENT_PREDICATE = "(blob16 = 'pv' OR blob16 = '' OR blob16 IS NULL)";
+function buildWhereClause(opts, filters = {}) {
   const site = opts.site.replace(/'/g, "''");
   const start = formatTimestamp(opts.startAt);
   const end = formatTimestamp(opts.endAt);
-  return `WHERE blob1 = '${site}' AND timestamp >= toDateTime('${start}') AND timestamp <= toDateTime('${end}')`;
+  const trafficClass = filters.trafficClass ?? "human";
+  const trafficClause = trafficClass === "human" ? ` AND ${HUMAN_TRAFFIC_PREDICATE}` : trafficClass === "ai" ? " AND blob10 = 'ai'" : "";
+  const eventType = filters.eventType ?? "pv";
+  const eventClause = eventType === "pv" ? ` AND ${PAGEVIEW_EVENT_PREDICATE}` : "";
+  return `WHERE blob1 = '${site}' AND timestamp >= toDateTime('${start}') AND timestamp <= toDateTime('${end}')${trafficClause}${eventClause}`;
 }
-function envelope(data, site, period, sampled) {
-  return { data, meta: { site, period, sampled } };
+function envelope(data, site, period, sampled, extraMeta) {
+  return { data, meta: { site, period, sampled, ...extraMeta || {} } };
 }
 function extractSampled(rows) {
   let sampled = false;
@@ -2996,6 +3152,52 @@ function extractParams(c, env) {
   const { startAt, endAt } = parsePeriod(period);
   return { site, period, limit, opts: { site, startAt, endAt } };
 }
+function parseLongPeriod(params, now = /* @__PURE__ */ new Date()) {
+  if (params.from || params.to) {
+    if (!params.from || !params.to) {
+      throw new Error("History requires both from and to when either is provided");
+    }
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(params.from) || !/^\d{4}-\d{2}-\d{2}$/.test(params.to)) {
+      throw new Error("History from/to must be YYYY-MM-DD");
+    }
+    const startAt2 = /* @__PURE__ */ new Date(`${params.from}T00:00:00.000Z`);
+    const endAt2 = /* @__PURE__ */ new Date(`${params.to}T23:59:59.999Z`);
+    if (Number.isNaN(startAt2.getTime()) || Number.isNaN(endAt2.getTime()) || startAt2 > endAt2) {
+      throw new Error("Invalid history date range");
+    }
+    return { startAt: startAt2, endAt: endAt2, period: `${params.from}..${params.to}` };
+  }
+  const days = params.days ? parseInt(params.days, 10) : 90;
+  if (!Number.isFinite(days) || days < 1 || days > 3650) {
+    throw new Error(`History days must be between 1 and 3650. Got: ${params.days}`);
+  }
+  const endAt = now;
+  const startAt = new Date(Date.UTC(
+    now.getUTCFullYear(),
+    now.getUTCMonth(),
+    now.getUTCDate() - days + 1
+  ));
+  return { startAt, endAt, period: `${days}d` };
+}
+function utcDayKey(date) {
+  return date.toISOString().slice(0, 10);
+}
+function utcDayBounds(day) {
+  return {
+    startAt: /* @__PURE__ */ new Date(`${day}T00:00:00.000Z`),
+    endAt: /* @__PURE__ */ new Date(`${day}T23:59:59.999Z`)
+  };
+}
+function dayKeys(startAt, endAt) {
+  const keys = [];
+  const cursor = new Date(Date.UTC(startAt.getUTCFullYear(), startAt.getUTCMonth(), startAt.getUTCDate()));
+  const last = new Date(Date.UTC(endAt.getUTCFullYear(), endAt.getUTCMonth(), endAt.getUTCDate()));
+  while (cursor <= last) {
+    keys.push(utcDayKey(cursor));
+    cursor.setUTCDate(cursor.getUTCDate() + 1);
+  }
+  return keys;
+}
 
 // worker/src/api/stats.ts
 async function statsHandler(c) {
@@ -3196,8 +3398,466 @@ async function sitesHandler(c) {
   });
 }
 
+// worker/src/api/active.ts
+function parseWindow(raw2) {
+  const parsed = raw2 ? parseInt(raw2, 10) : 5;
+  if (!Number.isFinite(parsed)) return 5;
+  return Math.min(Math.max(parsed, 1), 60);
+}
+async function activeHandler(c) {
+  try {
+    const site = c.req.query("site");
+    if (!site) throw new Error("Missing required parameter: site");
+    if (!validateSite(site, c.env.ALLOWED_SITES)) throw new Error(`Unknown site: ${site}`);
+    const windowMinutes = parseWindow(c.req.query("window"));
+    const endAt = /* @__PURE__ */ new Date();
+    const startAt = new Date(endAt.getTime() - windowMinutes * 60 * 1e3);
+    const where = buildWhereClause({ site, startAt, endAt });
+    const sql = `
+      SELECT
+        COUNT(DISTINCT index1) as active_visitors,
+        SUM(_sample_interval) as recent_pageviews,
+        MAX(_sample_interval) as max_interval
+      FROM ${DATASET}
+      ${where}
+    `;
+    const result = await queryAE(c.env, sql);
+    const { rows, sampled } = extractSampled(result.data);
+    const row = rows[0] || { active_visitors: 0, recent_pageviews: 0 };
+    return c.json(envelope({ ...row, window_minutes: windowMinutes }, site, `${windowMinutes}m`, sampled));
+  } catch (e) {
+    const msg = e instanceof Error && !e.message.includes("Analytics Engine") ? e.message : "Internal query error";
+    return c.json({ error: msg }, 400);
+  }
+}
+
+// worker/src/api/crawlers.ts
+var COLUMNS = {
+  name: { column: "blob13", alias: "name" },
+  operator: { column: "blob14", alias: "operator" },
+  class: { column: "blob15", alias: "class" }
+};
+async function crawlersHandler(c) {
+  try {
+    const { site, period, limit, opts } = extractParams(c, c.env);
+    const requested = c.req.query("type") || "name";
+    const selected = COLUMNS[requested] || COLUMNS.name;
+    const where = buildWhereClause(opts, { trafficClass: "ai" });
+    const sql = `
+      SELECT
+        ${selected.column} as ${selected.alias},
+        SUM(_sample_interval) as hits,
+        COUNT(DISTINCT index1) as approx_instances,
+        MAX(_sample_interval) as max_interval
+      FROM ${DATASET}
+      ${where}
+        AND ${selected.column} != ''
+      GROUP BY ${selected.column}
+      ORDER BY hits DESC
+      LIMIT ${limit}
+    `;
+    const result = await queryAE(c.env, sql);
+    const { rows, sampled } = extractSampled(result.data);
+    return c.json(envelope(rows, site, period, sampled));
+  } catch (e) {
+    const msg = e instanceof Error && !e.message.includes("Analytics Engine") ? e.message : "Internal query error";
+    return c.json({ error: msg }, 400);
+  }
+}
+
+// worker/src/api/channels.ts
+async function channelsHandler(c) {
+  try {
+    const { site, period, opts } = extractParams(c, c.env);
+    const where = buildWhereClause(opts);
+    const sql = `
+      SELECT
+        blob11 as channel,
+        SUM(_sample_interval) as pageviews,
+        COUNT(DISTINCT index1) as approx_visitors,
+        MAX(_sample_interval) as max_interval
+      FROM ${DATASET}
+      ${where}
+      GROUP BY blob11
+      ORDER BY pageviews DESC
+      LIMIT 50
+    `;
+    const result = await queryAE(c.env, sql);
+    const { rows, sampled } = extractSampled(result.data);
+    const data = rows.map((row) => ({
+      ...row,
+      channel: row.channel === "" || row.channel == null ? "unknown" : row.channel
+    }));
+    return c.json(envelope(data, site, period, sampled));
+  } catch (e) {
+    const msg = e instanceof Error && !e.message.includes("Analytics Engine") ? e.message : "Internal query error";
+    return c.json({ error: msg }, 400);
+  }
+}
+
+// worker/src/api/bounce.ts
+async function bounceHandler(c) {
+  try {
+    const { site, period, opts } = extractParams(c, c.env);
+    const where = buildWhereClause(opts);
+    const sql = `
+      SELECT
+        blob12 as session_key,
+        SUM(_sample_interval) as pv_weight,
+        SUM(double1) as pv_rows,
+        MAX(_sample_interval) as max_interval
+      FROM ${DATASET}
+      ${where}
+        AND blob12 != ''
+      GROUP BY blob12
+      ORDER BY pv_weight DESC
+      LIMIT 100000
+    `;
+    const result = await queryAE(c.env, sql);
+    const sampled = result.data.some((row) => Number(row.max_interval) > 1);
+    const approxSessions = result.data.length;
+    const bouncedSessions = result.data.filter((row) => Number(row.pv_rows) === 1).length;
+    const data = {
+      bounce_rate: approxSessions > 0 && !sampled ? bouncedSessions / approxSessions : null,
+      approx_sessions: approxSessions,
+      bounced_sessions: bouncedSessions
+    };
+    if (sampled) data.warning = "bounce rate unreliable when sampled";
+    return c.json(envelope(data, site, period, sampled));
+  } catch (e) {
+    const msg = e instanceof Error && !e.message.includes("Analytics Engine") ? e.message : "Internal query error";
+    return c.json({ error: msg }, 400);
+  }
+}
+
+// worker/src/api/duration.ts
+async function durationHandler(c) {
+  try {
+    const { site, period, opts } = extractParams(c, c.env);
+    const where = buildWhereClause(opts, { eventType: "all" });
+    const sql = `
+      SELECT
+        blob12 as session_key,
+        toUInt32(MAX(timestamp)) - toUInt32(MIN(timestamp)) as span_s,
+        MAX(double4) as dwell_ms,
+        MAX(_sample_interval) as w,
+        MAX(_sample_interval) as max_interval
+      FROM ${DATASET}
+      ${where}
+        AND blob12 != ''
+      GROUP BY blob12
+      ORDER BY w DESC
+      LIMIT 100000
+    `;
+    const result = await queryAE(c.env, sql);
+    const sampled = result.data.some((row) => Number(row.max_interval) > 1);
+    let weightedSeconds = 0;
+    let totalWeight = 0;
+    for (const row of result.data) {
+      const weight = Number(row.w) || 1;
+      const spanSeconds = Number(row.span_s) || 0;
+      const dwellSeconds = (Number(row.dwell_ms) || 0) / 1e3;
+      weightedSeconds += Math.max(spanSeconds, dwellSeconds) * weight;
+      totalWeight += weight;
+    }
+    const data = {
+      avg_session_seconds: totalWeight > 0 ? weightedSeconds / totalWeight : 0,
+      approx_sessions: result.data.length
+    };
+    return c.json(envelope(data, site, period, sampled));
+  } catch (e) {
+    const msg = e instanceof Error && !e.message.includes("Analytics Engine") ? e.message : "Internal query error";
+    return c.json({ error: msg }, 400);
+  }
+}
+
+// worker/src/lib/rollup.ts
+var DIMENSION_COLUMNS = {
+  pages: "blob2",
+  referrers: "blob3",
+  geo: "blob4",
+  browsers: "blob5",
+  os: "blob6",
+  device: "blob7"
+};
+function asNumber(value) {
+  return Number(value) || 0;
+}
+function capRows(rows, cap = 100) {
+  if (rows.length <= cap) return rows;
+  const head = rows.slice(0, cap);
+  const tail = rows.slice(cap);
+  head.push({
+    name: "other",
+    views: tail.reduce((sum, row) => sum + row.views, 0),
+    approx_visitors: tail.reduce((sum, row) => sum + row.approx_visitors, 0)
+  });
+  return head;
+}
+async function rollupDimension(env, site, day, dimension) {
+  const { startAt, endAt } = utcDayBounds(day);
+  const where = buildWhereClause({ site, startAt, endAt });
+  const column = DIMENSION_COLUMNS[dimension];
+  const sql = `
+    SELECT
+      ${column} as name,
+      SUM(_sample_interval) as views,
+      COUNT(DISTINCT index1) as approx_visitors,
+      MAX(_sample_interval) as max_interval
+    FROM ${DATASET}
+    ${where}
+      AND ${column} != ''
+    GROUP BY ${column}
+    ORDER BY views DESC
+    LIMIT 1000
+  `;
+  const result = await queryAE(env, sql);
+  const { rows, sampled } = extractSampled(result.data);
+  return {
+    rows: capRows(rows.map((row) => ({
+      name: String(row.name || ""),
+      views: asNumber(row.views),
+      approx_visitors: asNumber(row.approx_visitors)
+    }))),
+    sampled
+  };
+}
+async function buildDailyRollup(env, site, day) {
+  const { startAt, endAt } = utcDayBounds(day);
+  const where = buildWhereClause({ site, startAt, endAt });
+  const totalsSql = `
+    SELECT
+      SUM(_sample_interval) as views,
+      COUNT(DISTINCT index1) as approx_daily_visitors,
+      SUM(_sample_interval * double2) / (SUM(_sample_interval) + 0.0001) as avg_screen_width,
+      MAX(_sample_interval) as max_interval
+    FROM ${DATASET}
+    ${where}
+  `;
+  const totalsResult = await queryAE(env, totalsSql);
+  const totalsSampled = extractSampled(totalsResult.data);
+  const totalsRow = totalsSampled.rows[0] || {};
+  const dimensions = await Promise.all(
+    Object.keys(DIMENSION_COLUMNS).map(async (dimension) => [
+      dimension,
+      await rollupDimension(env, site, day, dimension)
+    ])
+  );
+  const rollup = {
+    date: day,
+    site,
+    sampled: totalsSampled.sampled || dimensions.some(([, value]) => value.sampled),
+    totals: {
+      views: asNumber(totalsRow.views),
+      approx_daily_visitors: asNumber(totalsRow.approx_daily_visitors),
+      avg_screen_width: asNumber(totalsRow.avg_screen_width)
+    },
+    pages: [],
+    referrers: [],
+    geo: [],
+    browsers: [],
+    os: [],
+    device: []
+  };
+  for (const [dimension, value] of dimensions) {
+    rollup[dimension] = value.rows;
+  }
+  return rollup;
+}
+var ROLLUP_BACKFILL_WINDOW_DAYS = 5;
+var MAX_BUILDS_PER_RUN = 4;
+async function rollupYesterday(env, now = /* @__PURE__ */ new Date()) {
+  if (!env.ARCHIVE || !env.CF_ACCOUNT_ID || !env.CF_API_TOKEN) return;
+  const sites = parseAllowedSites(env.ALLOWED_SITES);
+  const yesterday = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() - 1));
+  const oldest = new Date(yesterday.getTime() - (ROLLUP_BACKFILL_WINDOW_DAYS - 1) * 24 * 60 * 60 * 1e3);
+  let builds = 0;
+  for (const site of sites) {
+    const days = dayKeys(oldest, yesterday).reverse();
+    for (const day of days) {
+      if (builds >= MAX_BUILDS_PER_RUN) return;
+      const key = `rollups/${site}/${day}.json`;
+      try {
+        const existing = await env.ARCHIVE.head(key);
+        if (existing) continue;
+        const rollup = await buildDailyRollup(env, site, day);
+        await env.ARCHIVE.put(key, JSON.stringify(rollup));
+        builds += 1;
+      } catch {
+      }
+    }
+  }
+}
+function isLiveRetentionDay(day, now = /* @__PURE__ */ new Date()) {
+  const { startAt } = utcDayBounds(day);
+  const cutoff = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate() - 90));
+  return startAt >= cutoff && day <= utcDayKey(now);
+}
+
+// worker/src/api/history.ts
+var LIVE_DIMENSIONS = {
+  pages: { column: "blob2", alias: "page" },
+  referrers: { column: "blob3", alias: "referrer" },
+  geo: { column: "blob4", alias: "country" },
+  browsers: { column: "blob5", alias: "browser" }
+};
+function asNumber2(value) {
+  return Number(value) || 0;
+}
+async function readRollup(env, site, day) {
+  if (!env.ARCHIVE) return null;
+  const object = await env.ARCHIVE.get(`rollups/${site}/${day}.json`);
+  if (!object) return null;
+  return object.json();
+}
+async function readRollups(env, site, days) {
+  const found = /* @__PURE__ */ new Map();
+  const chunkSize = 40;
+  for (let i = 0; i < days.length; i += chunkSize) {
+    const chunk = days.slice(i, i + chunkSize);
+    const results = await Promise.all(chunk.map(async (day) => [day, await readRollup(env, site, day)]));
+    for (const [day, rollup] of results) {
+      if (rollup) found.set(day, rollup);
+    }
+  }
+  return found;
+}
+async function fetchLiveRange(env, site, startAt, endAt, dimension) {
+  const where = buildWhereClause({ site, startAt, endAt });
+  if (dimension === "totals") {
+    const sql2 = `
+      SELECT
+        SUM(_sample_interval) as views,
+        COUNT(DISTINCT index1) as approx_daily_visitors,
+        SUM(_sample_interval * double2) / (SUM(_sample_interval) + 0.0001) as avg_screen_width,
+        MAX(_sample_interval) as max_interval
+      FROM ${DATASET}
+      ${where}
+    `;
+    const result2 = await queryAE(env, sql2);
+    const { rows: rows2, sampled: sampled2 } = extractSampled(result2.data);
+    const row = rows2[0] || {};
+    return {
+      sampled: sampled2,
+      totals: {
+        views: asNumber2(row.views),
+        approx_daily_visitors: asNumber2(row.approx_daily_visitors),
+        avg_screen_width: asNumber2(row.avg_screen_width)
+      },
+      rows: []
+    };
+  }
+  const selected = LIVE_DIMENSIONS[dimension];
+  const sql = `
+    SELECT
+      ${selected.column} as name,
+      SUM(_sample_interval) as views,
+      COUNT(DISTINCT index1) as approx_visitors,
+      MAX(_sample_interval) as max_interval
+    FROM ${DATASET}
+    ${where}
+      AND ${selected.column} != ''
+    GROUP BY ${selected.column}
+    ORDER BY views DESC
+    LIMIT 1000
+  `;
+  const result = await queryAE(env, sql);
+  const { rows, sampled } = extractSampled(result.data);
+  return {
+    sampled,
+    totals: null,
+    rows: rows.map((row) => ({
+      name: String(row.name || ""),
+      views: asNumber2(row.views),
+      approx_visitors: asNumber2(row.approx_visitors)
+    }))
+  };
+}
+function mergeRows(target, rows) {
+  for (const row of rows) {
+    const key = row.name || "unknown";
+    const existing = target.get(key) || { name: key, views: 0, approx_visitors: 0 };
+    existing.views += row.views;
+    existing.approx_visitors += row.approx_visitors;
+    target.set(key, existing);
+  }
+}
+async function historyHandler(c) {
+  try {
+    const site = c.req.query("site");
+    if (!site) throw new Error("Missing required parameter: site");
+    if (!validateSite(site, c.env.ALLOWED_SITES)) throw new Error(`Unknown site: ${site}`);
+    const dimension = c.req.query("dimension") || "totals";
+    if (!["totals", "pages", "referrers", "geo", "browsers"].includes(dimension)) {
+      throw new Error("Invalid dimension. Supported: totals, pages, referrers, geo, browsers");
+    }
+    const { startAt, endAt, period } = parseLongPeriod({
+      days: c.req.query("days"),
+      from: c.req.query("from"),
+      to: c.req.query("to")
+    });
+    const days = dayKeys(startAt, endAt);
+    const liveDays = days.filter((day) => isLiveRetentionDay(day));
+    const archiveDayList = days.filter((day) => !isLiveRetentionDay(day));
+    const rollups = await readRollups(c.env, site, archiveDayList);
+    const rows = /* @__PURE__ */ new Map();
+    const totals = { views: 0, approx_daily_visitors: 0, avg_screen_width: 0 };
+    let screenWeight = 0;
+    let sampled = false;
+    let archivedDaysMissing = 0;
+    let archiveDays = 0;
+    for (const day of archiveDayList) {
+      const rollup = rollups.get(day) || null;
+      if (!rollup) {
+        archivedDaysMissing += 1;
+        continue;
+      }
+      archiveDays += 1;
+      sampled ||= !!rollup.sampled;
+      if (dimension === "totals") {
+        totals.views += rollup.totals.views;
+        totals.approx_daily_visitors += rollup.totals.approx_daily_visitors;
+        screenWeight += rollup.totals.avg_screen_width * rollup.totals.views;
+      } else {
+        mergeRows(rows, rollup[dimension]);
+      }
+    }
+    if (liveDays.length > 0) {
+      const liveStart = utcDayBounds(liveDays[0]).startAt;
+      const liveEnd = utcDayBounds(liveDays[liveDays.length - 1]).endAt;
+      const live = await fetchLiveRange(c.env, site, liveStart, liveEnd, dimension);
+      sampled ||= live.sampled;
+      if (dimension === "totals" && live.totals) {
+        totals.views += live.totals.views;
+        totals.approx_daily_visitors += live.totals.approx_daily_visitors;
+        screenWeight += live.totals.avg_screen_width * live.totals.views;
+      } else {
+        mergeRows(rows, live.rows);
+      }
+    }
+    const source = liveDays.length > 0 && archiveDays > 0 ? "blended" : archiveDays > 0 ? "archive" : "live";
+    const data = dimension === "totals" ? {
+      views: totals.views,
+      approx_daily_visitors: totals.approx_daily_visitors,
+      avg_screen_width: totals.views > 0 ? screenWeight / totals.views : 0
+    } : Array.from(rows.values()).sort((a, b) => b.views - a.views).slice(0, 100);
+    return c.json(envelope(data, site, period, sampled, {
+      source,
+      archived_days_missing: archivedDaysMissing
+    }));
+  } catch (e) {
+    const msg = e instanceof Error && !e.message.includes("Analytics Engine") ? e.message : "Internal query error";
+    return c.json({ error: msg }, 400);
+  }
+}
+
+// worker/src/scheduled.ts
+async function scheduled(_event, env, ctx) {
+  ctx.waitUntil(rollupYesterday(env));
+}
+
 // worker/src/version.ts
-var VERSION = true ? "0.1.0" : "0.1.0";
+var VERSION = true ? "0.3.0" : "0.3.0";
 
 // worker/src/index.ts
 var app = new Hono2();
@@ -3214,8 +3874,20 @@ app.get("/api/geo", geoHandler);
 app.get("/api/browsers", browsersHandler);
 app.get("/api/timeseries", timeseriesHandler);
 app.get("/api/sites", sitesHandler);
+app.get("/api/active", activeHandler);
+app.get("/api/crawlers", crawlersHandler);
+app.get("/api/channels", channelsHandler);
+app.get("/api/bounce", bounceHandler);
+app.get("/api/duration", durationHandler);
+app.get("/api/history", historyHandler);
 app.get("/health", (c) => c.json({ status: "ok", version: VERSION, timestamp: (/* @__PURE__ */ new Date()).toISOString() }));
-var index_default = app;
+var worker = {
+  fetch: app.fetch,
+  scheduled,
+  request: app.request.bind(app)
+};
+var index_default = worker;
 export {
+  app,
   index_default as default
 };