@canonry/canonry 7.84.0 → 7.85.0

package/dist/{chunk-B42R2SPU.js → chunk-2X6UAPAC.js}

@@ -1,36 +1,47 @@
 import {
   createLogger
-} from "./chunk-WJITVHAU.js";
+} from "./chunk-6SGHSSWQ.js";
 import {
   addLikelyFakeAgentHits,
+  correctBackgroundCallJourneys,
+  mergeSplitJourneyVisitors,
   writeUnrecognizedAgentBuckets
-} from "./chunk-6SVAUILQ.js";
+} from "./chunk-JVO5GQZH.js";
 import {
+  AGENT_TRUST_RULES_VERSION,
   BROWSER_SHAPED_AGENT_MARKERS,
   DEFAULT_AI_CRAWLER_RULES,
   GENERIC_HTTP_CLIENTS,
+  JOURNEY_RULES_VERSION,
+  SCANNER_BURST_WINDOW_MS,
   SELF_TRAFFIC_USER_AGENT_PATTERNS,
   UNLISTED_AGENT_SKIPPED_EXTENSIONS,
   UNRECOGNIZED_AGENT_NAMING_VERSION,
   classifyAiUserFetch,
   classifyCrawler,
+  isScannerPath,
   isSelfTraffic,
+  normalizeTrafficPathPattern,
   unrecognizedAgentName
-} from "./chunk-O7TWL6ZH.js";
+} from "./chunk-2R6WI237.js";
 import {
   RawEventSampleEventTypes,
+  agentJourneyCaptureDays,
+  agentJourneyEvents,
   aiUserFetchEventsHourly,
+  aiUserFetchVerificationManifestsHourly,
   crawlerEventsHourly,
   migrationsTable,
   parseJsonColumn,
   rawEventSamples,
   trafficReclassificationState,
   unrecognizedAgentEventsHourly
-} from "./chunk-BIGIIVGV.js";
+} from "./chunk-L5R5S57T.js";
 import {
   AI_ENGINE_DOMAINS,
   AI_ENGINE_SELF_DOMAINS,
   AgentTrustLevels,
+  AgentTrustReasons,
   AnchoredSpanSources,
   OPENROUTER_MODEL_PATTERN,
   OPENROUTER_ROUTE_FAMILY,
@@ -44,6 +55,7 @@ import {
   TrafficSourceTypes,
   UNRECORDED_TRAFFIC_PATH,
   VERTEX_AI_SEARCH_PROXY_DOMAIN,
+  VerificationStatuses,
   asRecord,
   describeError,
   hostMatchesAnyDomain,
@@ -57,7 +69,7 @@ import {
   retryAfterDelayMs,
   usageCount,
   withRetry
-} from "./chunk-K3OY52MI.js";
+} from "./chunk-KNKOTLVW.js";
 
 // ../provider-openai/src/normalize.ts
 import OpenAI from "openai";
@@ -2929,7 +2941,7 @@ function extractStoredAnswerAnchors(provider, rawResponse) {
 // src/traffic-reclassify.ts
 import { createHash } from "crypto";
 import { setImmediate as yieldToEventLoop } from "timers/promises";
-import { and, eq, inArray, sql } from "drizzle-orm";
+import { and, eq, gte, inArray, lte, ne, sql } from "drizzle-orm";
 var log = createLogger("TrafficReclassify");
 var STATE_ID = "default";
 var BATCH_SIZE = 200;
@@ -2947,6 +2959,8 @@ function trafficClassificationFingerprint() {
     })),
     self: SELF_TRAFFIC_USER_AGENT_PATTERNS.map(pattern),
     naming: UNRECOGNIZED_AGENT_NAMING_VERSION,
+    trust: AGENT_TRUST_RULES_VERSION,
+    journeys: JOURNEY_RULES_VERSION,
     genericClients: GENERIC_HTTP_CLIENTS,
     browserMarkers: BROWSER_SHAPED_AGENT_MARKERS,
     skippedExtensions: UNLISTED_AGENT_SKIPPED_EXTENSIONS
@@ -3178,6 +3192,163 @@ async function reclassifyUnknownSamples(db, opts) {
   }
   return result;
 }
+function hourlyAgentRow(key) {
+  const table = aiUserFetchEventsHourly;
+  return and(
+    eq(table.projectId, key.projectId),
+    eq(table.sourceId, key.sourceId),
+    eq(table.tsHour, key.tsHour),
+    eq(table.botId, key.botId),
+    eq(table.verificationStatus, key.verificationStatus),
+    eq(table.pathNormalized, key.pathNormalized),
+    eq(table.status, key.status)
+  );
+}
+async function reassessAgentHits(db, opts) {
+  const result = { examined: 0, moved: 0, movedHits: 0 };
+  const table = aiUserFetchEventsHourly;
+  const lastStartingRowid = Number(db.select({ max: sql`max(rowid)` }).from(table).get()?.max ?? 0);
+  let lastRowid = 0;
+  for (; ; ) {
+    if (opts.shouldStop()) break;
+    const rows = db.select({
+      rowid: sql`rowid`,
+      projectId: table.projectId,
+      sourceId: table.sourceId,
+      tsHour: table.tsHour,
+      botId: table.botId,
+      operator: table.operator,
+      verificationStatus: table.verificationStatus,
+      pathNormalized: table.pathNormalized,
+      status: table.status
+    }).from(table).where(and(
+      sql`rowid > ${lastRowid}`,
+      sql`rowid <= ${lastStartingRowid}`,
+      ne(table.verificationStatus, VerificationStatuses.verified),
+      opts.projectIds ? inArray(table.projectId, [...opts.projectIds]) : void 0
+    )).orderBy(sql`rowid`).limit(BATCH_SIZE).all();
+    if (rows.length === 0) break;
+    lastRowid = rows[rows.length - 1].rowid;
+    result.examined += rows.length;
+    const probes = rows.filter((row) => isScannerPath(row.pathNormalized));
+    if (probes.length > 0) {
+      db.transaction((tx) => {
+        for (const row of probes) {
+          const current = tx.select({ hits: table.hits }).from(table).where(hourlyAgentRow(row)).get();
+          if (!current) continue;
+          result.moved++;
+          result.movedHits += current.hits;
+          if (opts.dryRun) continue;
+          addLikelyFakeAgentHits(tx, {
+            projectId: row.projectId,
+            sourceId: row.sourceId,
+            buckets: [{ tsHour: row.tsHour, botId: row.botId, operator: row.operator, reason: AgentTrustReasons["scanner-path"], hits: current.hits }],
+            now: opts.now
+          });
+          tx.delete(table).where(hourlyAgentRow(row)).run();
+        }
+      }, { behavior: "immediate" });
+    }
+    await yieldToEventLoop();
+  }
+  return result;
+}
+function moveAgentHitToBurst(tx, row, now) {
+  const key = {
+    projectId: row.projectId,
+    sourceId: row.sourceId,
+    tsHour: hourOf(row.ts),
+    botId: row.agentId,
+    verificationStatus: row.verificationStatus,
+    pathNormalized: normalizeTrafficPathPattern(row.path),
+    status: row.status ?? 0
+  };
+  const table = aiUserFetchEventsHourly;
+  const taken = tx.update(table).set({ hits: sql`${table.hits} - 1`, updatedAt: now }).where(and(hourlyAgentRow(key), sql`${table.hits} > 0`)).run();
+  if (taken.changes === 0) return;
+  const manifests = aiUserFetchVerificationManifestsHourly;
+  if (row.verificationManifest) {
+    const manifestRow = and(
+      eq(manifests.projectId, key.projectId),
+      eq(manifests.sourceId, key.sourceId),
+      eq(manifests.tsHour, key.tsHour),
+      eq(manifests.botId, key.botId),
+      eq(manifests.verificationStatus, key.verificationStatus),
+      eq(manifests.pathNormalized, key.pathNormalized),
+      eq(manifests.status, key.status),
+      eq(manifests.manifestId, row.verificationManifest.id)
+    );
+    tx.update(manifests).set({ hits: sql`${manifests.hits} - 1`, updatedAt: now }).where(and(manifestRow, sql`${manifests.hits} > 0`)).run();
+    tx.delete(manifests).where(and(manifestRow, sql`${manifests.hits} <= 0`)).run();
+  }
+  tx.delete(table).where(and(hourlyAgentRow(key), sql`${table.hits} <= 0`)).run();
+  addLikelyFakeAgentHits(tx, {
+    projectId: row.projectId,
+    sourceId: row.sourceId,
+    buckets: [{ tsHour: key.tsHour, botId: row.agentId, operator: row.operator, reason: AgentTrustReasons["scanner-burst"], hits: 1 }],
+    now
+  });
+}
+async function reassessAgentRequests(db, opts) {
+  const result = { examined: 0, probes: 0, removed: 0 };
+  const table = agentJourneyEvents;
+  const clients = /* @__PURE__ */ new Map();
+  const lastStartingRowid = Number(db.select({ max: sql`max(rowid)` }).from(table).get()?.max ?? 0);
+  let lastRowid = 0;
+  for (; ; ) {
+    if (opts.shouldStop()) return result;
+    const rows = db.select({ rowid: sql`rowid`, projectId: table.projectId, sourceId: table.sourceId, correlationKey: table.correlationKey, ts: table.ts, path: table.path }).from(table).where(and(
+      sql`rowid > ${lastRowid}`,
+      sql`rowid <= ${lastStartingRowid}`,
+      ne(table.trust, AgentTrustLevels.verified),
+      opts.projectIds ? inArray(table.projectId, [...opts.projectIds]) : void 0
+    )).orderBy(sql`rowid`).limit(BATCH_SIZE).all();
+    if (rows.length === 0) break;
+    lastRowid = rows[rows.length - 1].rowid;
+    result.examined += rows.length;
+    for (const row of rows) {
+      if (!isScannerPath(row.path)) continue;
+      result.probes++;
+      const id = JSON.stringify([row.projectId, row.sourceId, row.correlationKey]);
+      const client = clients.get(id) ?? { projectId: row.projectId, sourceId: row.sourceId, correlationKey: row.correlationKey, probes: [] };
+      client.probes.push(Date.parse(row.ts));
+      clients.set(id, client);
+    }
+    await yieldToEventLoop();
+  }
+  for (const client of clients.values()) {
+    if (opts.shouldStop()) break;
+    const probes = client.probes.sort((a, b) => a - b);
+    const from = new Date(probes[0] - SCANNER_BURST_WINDOW_MS).toISOString();
+    const to = new Date(probes.at(-1) + SCANNER_BURST_WINDOW_MS).toISOString();
+    db.transaction((tx) => {
+      const rows = tx.select().from(table).where(and(
+        eq(table.projectId, client.projectId),
+        eq(table.sourceId, client.sourceId),
+        eq(table.correlationKey, client.correlationKey),
+        gte(table.ts, from),
+        lte(table.ts, to),
+        ne(table.trust, AgentTrustLevels.verified)
+      )).all();
+      for (const row of rows) {
+        const probe = isScannerPath(row.path);
+        const at = Date.parse(row.ts);
+        if (!probe && !probes.some((t) => Math.abs(at - t) <= SCANNER_BURST_WINDOW_MS)) continue;
+        result.removed++;
+        if (opts.dryRun) continue;
+        tx.delete(table).where(eq(table.id, row.id)).run();
+        tx.update(agentJourneyCaptureDays).set({ storedEvents: sql`max(${agentJourneyCaptureDays.storedEvents} - 1, 0)` }).where(and(
+          eq(agentJourneyCaptureDays.projectId, row.projectId),
+          eq(agentJourneyCaptureDays.sourceId, row.sourceId),
+          eq(agentJourneyCaptureDays.day, row.ts.slice(0, 10))
+        )).run();
+        if (!probe) moveAgentHitToBurst(tx, row, opts.now);
+      }
+    }, { behavior: "immediate" });
+    await yieldToEventLoop();
+  }
+  return result;
+}
 async function reclassifyStoredTraffic(db, opts = {}) {
   const shared = {
     projectIds: opts.projectIds,
@@ -3187,7 +3358,11 @@ async function reclassifyStoredTraffic(db, opts = {}) {
   };
   const samples = await reclassifyUnknownSamples(db, shared);
   const unrecognized = shared.shouldStop() ? { examined: 0, moved: 0, movedHits: 0, renamed: 0, removed: 0, byBot: {} } : await reclassifyUnrecognizedRows(db, shared);
-  return { dryRun: shared.dryRun, samples, unrecognized };
+  const agentHits = shared.shouldStop() ? { examined: 0, moved: 0, movedHits: 0 } : await reassessAgentHits(db, shared);
+  const agentRequests = shared.shouldStop() ? { examined: 0, probes: 0, removed: 0 } : await reassessAgentRequests(db, shared);
+  const journeys = shared.shouldStop() ? { visitors: 0, visitorsRemoved: 0, visitsRemoved: 0, visitsRelanded: 0 } : correctBackgroundCallJourneys(db, shared);
+  const journeyMerges = shared.shouldStop() ? { visitorsMerged: 0, visitsJoined: 0 } : mergeSplitJourneyVisitors(db, shared);
+  return { dryRun: shared.dryRun, samples, unrecognized, agentHits, agentRequests, journeys, journeyMerges };
 }
 async function reclassifyStoredTrafficIfRulesChanged(db, opts = {}) {
   const fingerprint = trafficClassificationFingerprint();
@@ -3209,7 +3384,7 @@ function startTrafficReclassification(opts) {
   const timer = setTimeout(() => {
     reclassifyStoredTrafficIfRulesChanged(opts.db, { shouldStop: () => stopped }).then((outcome) => {
       if (!outcome.ran || !outcome.result) return;
-      const { samples, unrecognized } = outcome.result;
+      const { samples, unrecognized, agentHits, agentRequests, journeys, journeyMerges } = outcome.result;
       log.info("traffic-reclassify.completed", {
         samplesReclassified: samples.reclassified,
         samplesCounted: samples.counted,
@@ -3217,7 +3392,14 @@ function startTrafficReclassification(opts) {
         unrecognizedMoved: unrecognized.moved,
         unrecognizedMovedHits: unrecognized.movedHits,
         unrecognizedRenamed: unrecognized.renamed,
-        unrecognizedRemoved: unrecognized.removed
+        unrecognizedRemoved: unrecognized.removed,
+        agentHitsMoved: agentHits.movedHits,
+        agentRequestsRemoved: agentRequests.removed,
+        journeyVisitorsRemoved: journeys.visitorsRemoved,
+        journeyVisitsRemoved: journeys.visitsRemoved,
+        journeyVisitsRelanded: journeys.visitsRelanded,
+        journeyVisitorsMerged: journeyMerges.visitorsMerged,
+        journeyVisitsJoined: journeyMerges.visitsJoined
       });
     }).catch((err) => {
       if (!stopped) log.error("traffic-reclassify.failed", { error: describeError(err) });

package/dist/{chunk-VCUNNS4R.js → chunk-4KK3OTHE.js}

@@ -5,7 +5,7 @@ import {
   AppError,
   parseWindowIn,
   resolveDateRange
-} from "./chunk-K3OY52MI.js";
+} from "./chunk-KNKOTLVW.js";
 
 // src/cli-access.ts
 var CLI_ACCESS_BY_ID = Object.freeze({

package/dist/{chunk-6TLHA6XA.js → chunk-5NEZO3SC.js}

@@ -3,7 +3,7 @@ import {
   resolveCliAccess,
   resolveCliAccessForInvocation,
   windowOptions
-} from "./chunk-VCUNNS4R.js";
+} from "./chunk-4KK3OTHE.js";
 import {
   emitJsonl
 } from "./chunk-Z7IUAJOF.js";
@@ -14,7 +14,7 @@ import {
 } from "./chunk-HGMYEDAQ.js";
 import {
   OperationAccesses
-} from "./chunk-K3OY52MI.js";
+} from "./chunk-KNKOTLVW.js";
 
 // src/cli-catalog.ts
 import { createRequire } from "module";
@@ -111,7 +111,7 @@ async function dispatchRegisteredCommand(args, fallbackFormat, specs) {
     const accessValue = accessFilterFromArgs(argsWithoutHelp);
     validateAccessFilter(accessValue);
     if (fallbackFormat !== "text") {
-      const { printCliCatalog: printCliCatalog2 } = await import("./cli-catalog-JTIC72BY.js");
+      const { printCliCatalog: printCliCatalog2 } = await import("./cli-catalog-QVCJWPCI.js");
       const group2 = argsWithoutHelp.find((arg) => !arg.startsWith("--"));
       printCliCatalog2(specs, fallbackFormat, group2, accessValue);
       return true;

package/dist/{chunk-WJITVHAU.js → chunk-6SGHSSWQ.js}

@@ -1,11 +1,11 @@
 import {
   getRequestContext
-} from "./chunk-D37PJYLD.js";
+} from "./chunk-PX2KVGOJ.js";
 import {
   diagnosticIdentity,
   redactLogString,
   redactLogValue
-} from "./chunk-K3OY52MI.js";
+} from "./chunk-KNKOTLVW.js";
 
 // ../api-routes/src/runtime-logger.ts
 import { format } from "util";

package/dist/{chunk-Q57GN464.js → chunk-AICFUZ6X.js}

@@ -28,7 +28,7 @@ import {
   unknownUsageObservation,
   usdToMicros,
   withRetry
-} from "./chunk-K3OY52MI.js";
+} from "./chunk-KNKOTLVW.js";
 
 // ../provider-answer-services/src/core/http.ts
 var MAX_RESPONSE_BYTES = 8 * 1024 * 1024;

package/dist/{chunk-2MROJL32.js → chunk-BQTXXXUG.js}

@@ -1,6 +1,6 @@
 import {
   cloudflareQueueNameSchema
-} from "./chunk-K3OY52MI.js";
+} from "./chunk-KNKOTLVW.js";
 
 // src/cloudflare-traffic-config.ts
 function unsupportedDeliveryMode(deliveryMode) {