wiki-formant 0.27.1 → 0.29.0

package/README.md

@@ -148,7 +148,7 @@ handler: async (args, ctx) => {
 }
 ```
 
-`config.gate` is envelope-level middleware: it may withhold entries before dispatch and merge its own responses back afterwards. A payment gate has to sit there rather than in a handler, because the demand *replaces* the call and the receipt rides on the envelope.
+`config.gate` is envelope-level middleware: it may withhold entries before dispatch and merge its own responses back afterwards. A payment gate has to sit there rather than in a handler, because the demand *replaces* the call and the receipt rides on the envelope. `RpcRequest` and `toolText` are exported for a gate to build with; acuiq2's x402 gate is the one that does.
 
 ### Tool arguments and the corpus tool
 
@@ -213,6 +213,13 @@ export async function GET(request: Request) {
 }
 ```
 
+`corpusValidatorsFrom(seed, stamps)` is that pair from an aggregate: the newest of `stamps` (the epoch when every one is null), appended to `seed` for the tag. `corpusRoute(validators, build)` is the whole handler, and skips the build on a 304.
+
+```ts
+const agg = await prisma.page.aggregate({ _count: true, _max: { updatedAt: true } });
+corpusValidatorsFrom([depth, agg._count], [agg._max.updatedAt]);
+```
+
 ## Pagination and versioning
 
 `parsePagination` clamps `page ≥ 1` and `pageSize` to 1–100; `paginatedResponse` always carries `totalPages`. Reshaping that response is a breaking change to every client that pages, which is why it lives here rather than being re-typed per repo.
@@ -311,14 +318,6 @@ import Link from 'next/link';
 
 There is no `next` peer dependency here and there is not going to be one, but a rail that falls back to a bare `<a>` turns every press into a full page load — which is the whole reason a wiki has a persistent rail. So the router arrives through the door.
 
-## Payment gating
-
-`wiki-formant/x402` gates an MCP envelope on payment, for a wiki that charges for a bulk export over HTTP and would otherwise hand the same bytes over free through the equivalent MCP tool. Payment travels in-band — `params._meta["x402/payment"]` in, `result._meta["x402/payment-response"]` out — because one HTTP 402 cannot answer a batch of twenty in which one call is priced and nineteen are not.
-
-`gatePaidCalls` returns what `handleMcp` should dispatch and a `finish` that puts the answer back together. The ordering is the part worth owning once: verify before dispatch, settle only after a non-error answer, splice the challenges back into the caller's original order. A tool that raises cancels rather than settles — the caller pays for an answer, not an attempt.
-
-It imports nothing. `@x402/core`, `@x402/evm`, `@x402/extensions`, `@x402/next` and `viem` are optional peers, and the resource server arrives as a structural port instead of an import, so a wiki that never imports this subpath never resolves any of them. Which surfaces cost what, the prices and the terms text stay with the caller: those are policy, and this is the envelope surgery.
-
 ## AI crawlers
 
 Every wiki kept this roster twice — once in the proxy, keyed by user-agent, to
@@ -490,6 +489,27 @@ leafBlocks(blocks, BLOCK_SHAPE.containers);
 
 The dispatch over a repo's own block union stays in that repo; the bodies come from here. `wiki-formant/text` has a prose body for every core leaf — `statsToText`, `linkGridToText` and `pageListToText` joined the originals when two of the three wikis turned out to extract nothing from them, so their MCP `get_page` answered a hub page as nearly empty.
 
+The core leaves — `content`, `codeTabs`, `banner`, `references`, `stats`, `linkGrid`, `recentPages`, `pageList` — had the same case bodies in every wiki's text export, markdown twin, validator and new-block record. A repo's switch hands those cases over and keeps its own, so it stays exhaustive over its union:
+
+```ts
+import { coreAtomicText, coreAtomicToMarkdown, coreBlockDefaults } from 'wiki-formant/blocks';
+import { coreAtomicValidator } from 'wiki-formant/validation';
+
+switch (block.type) {
+  case 'content': case 'codeTabs': case 'banner': case 'references':
+  case 'stats': case 'linkGrid': case 'recentPages': case 'pageList':
+    return coreAtomicToMarkdown(block, { siteUrl: SITE_URL, referencesTitle: 'Sources' });
+  case 'corpusStats':
+    return block.resolvedHtml ? htmlToMarkdown(block.resolvedHtml) : '';
+}
+
+const BLOCK_DEFAULTS = { ...coreBlockDefaults({ stats }), daoTimeline: () => ({ type: 'daoTimeline', limit: 25 }) };
+const core = coreAtomicValidator({ pageId: id => /^\d{1,9}$/.test(id) });
+// validateAtomic: b => { switch (b.type) { case 'daoTimeline': …; default: return core(b); } }
+```
+
+`coreAtomicToMarkdown` joins a resolved page's site-relative `href` to `siteUrl`, because a twin is read off-site; a wiki whose lists hold its own page rows keeps those two cases. `coreAtomicValidator` caps `recentPages.limit` and `pageIds` at `MAX_BLOCK_ROWS`, a whole number of rows, because both end in a database `take:`; `blockLimit` is the same bound on the read side.
+
 `createBlockValidator` returns `blockIssues` beside the boolean validators: the same walk, reporting where each failure is.
 
 ```ts
@@ -504,7 +524,7 @@ A `codeTabs` tab's `code` is source text in every wiki here, and every view trea
 
 ## Dates
 
-`relativeTime(then, now, { style })` is `compact` (`3h`), `short` (`3h ago`) or `long` (`3 days ago`, day-grained for pages cached for hours), with `absoluteAfterDays` to hand over to the date itself. `now` is always passed in, never read, so a server render and its hydration agree. `formatDay` is always UTC: a stored day formatted in the server's zone, or the browser's, is the previous day for half the world. Both are in `wiki-formant/freshness`, with `isoDate`.
+`relativeTime(then, now, { style })` is `compact` (`3h`), `short` (`3h ago`) or `long` (`3 days ago`, day-grained for pages cached for hours), with `absoluteAfterDays` to hand over to the date itself. `now` is always passed in, never read, so a server render and its hydration agree. `formatDay` is always UTC: a stored day formatted in the server's zone, or the browser's, is the previous day for half the world. It reads `en-US` unless given a `locale`: `formatDay(day, { locale: 'en-GB', month: 'long' })` is `19 September 2026`. Both are in `wiki-formant/freshness`, with `isoDate`.
 
 ## Sanitising stored HTML
 
@@ -551,27 +571,66 @@ export const GET = resolveMapHandler({ authorize: async () => !!(await currentUs
 
 ## Analytics
 
-Two lanes, one events helper. `mcpCallProps` reads a tool name out of a JSON-RPC
-envelope that is untrusted and may be a batch; `searchQueryProps` normalises a
-search box's free text so the same question aggregates as one row. Sending stays
-with the caller — `plausibleEvent` builds the request, and the framework's own
-deferral (`after()` in a route or server action, `event.waitUntil` in a proxy)
-decides when it goes, so this package keeps its zero-dependency guarantee.
+Page views and events, counted in the site's own Postgres instead of a hosted
+service. No cookie is set and no address is kept: a visitor is a hash of the
+address and browser under a salt that is replaced every UTC day, and the old
+salt is deleted, so a visitor is told apart within a day and never followed
+into the next. Rows are kept 400 days. The package owns the SQL and the app
+owns the connection: `Sql` is one function that runs a statement with `$1, $2…`
+placeholders, and the three tables it needs are stated as Prisma models at the
+top of `src/analytics.ts`.
+
+```ts
+// src/lib/track.ts
+const sql: Sql = (query, ...values) => prisma.$queryRawUnsafe(query, ...values);
+export const { trackEvent, trackMcpCall, trackSearch, viewRoute } =
+  createTracker({ sql, defer: after, siteUrl: SITE_URL });
+
+// src/app/api/view/route.ts – the whole beacon route
+export const POST = viewRoute();
+
+// the root layout, once
+<Beacon />
+```
+
+`createTracker` records only on a Vercel production deployment unless told
+otherwise (`enabled`), because dev and previews write to production's
+database. `trackMcpCall(request, body, server?)` fits `McpServerConfig.onCall`;
+`trackSearch(headers, query, results, surface?)` takes the headers or Next's
+`headers` itself, which it reads inside the deferred write. `viewRoute({ site })`
+passes a site resolver to `collect`. The module that builds the tracker
+imports the app's database client, so a proxy reaches it through a dynamic
+`import()` inside `event.waitUntil`, never a static one.
+
+`<Beacon>` (`wiki-formant/react`) sends a view each time the path changes,
+client-side moves included, and a click on a link to another host as an
+"Outbound Link: Click" event; `track(name, props)` (`wiki-formant/dom`) sends
+any other browser event. Underneath the tracker, server code calls
+`recordEvent` and leaves the deferral to the framework, so this package keeps
+its zero-dependency guarantee:
 
 ```ts
 const props = searchQueryProps({ query, results: rows.length, surface: 'wiki' });
 // null for an empty field, so a blank search cannot fire an event
-if (props) after(() => plausibleEvent({ domain }, 'Search Query', url, props, headers, {
-  // a person triggered this, so it joins their session rather than landing
-  // as the fixed bot-tracker pseudo-visitor
-  userAgent: headers.get('user-agent') ?? undefined,
-}));
+if (props) after(() => recordEvent(sql, { name: 'Search Query', props, url, headers }));
 ```
 
+`mcpCallProps` reads a tool name out of a JSON-RPC envelope that is untrusted
+and may be a batch; `searchQueryProps` normalises a search box's free text so
+the same question aggregates as one row. Pass the request's headers and the
+event joins whoever sent it, person or agent.
+
+`digest(sql, { days })` reads a site back as one JSON object: visitors, page
+views, bounce rate, visit length, sources (a link's `utm_source`, else the
+referring host), top and entry pages, countries, devices, visitors by day, MCP
+tool calls, and the searches that found nothing. A visit is a run of one
+visitor's views with no gap over 30 minutes. A multi-tenant app passes a `site`
+key to every call and a `site` resolver to `collect`.
+
 Instrumenting the agent lane and not the human one is the easy mistake: it
 leaves a wiki able to say what every crawler asked for and nothing about what
-its readers asked for. The queries that return zero rows are the valuable ones —
-they name a gap in the corpus in the reader's own words.
+its readers asked for. The queries that return zero rows are the valuable ones
+– they name a gap in the corpus in the reader's own words.
 
 ## Base stylesheet
 
@@ -585,15 +644,23 @@ No view emits a Tailwind utility any more — `ColumnsView` states its gap and a
 
 ## API
 
-Every module has a subpath — `wiki-formant/taxonomy`, `wiki-formant/mcp`, and so on.
-The emitted `.d.ts` files are the reference. There is no hand-maintained symbol list
-here, because the one that used to be here drifted from them.
+Every module has a subpath — `wiki-formant/taxonomy`, `wiki-formant/mcp`, and so on —
+and there is no root export: `import … from 'wiki-formant'` does not resolve. A
+barrel loads every module it names for the one symbol a route wanted, and had
+already re-exported one module twice. The emitted `.d.ts` files are the reference.
+There is no hand-maintained symbol list here, because the one that used to be here
+drifted from them.
 
-The package root re-exports the runtime modules that need no peer dependency and no
-client boundary, so `import … from 'wiki-formant'` stays importable from a route
-handler with nothing else installed. Everything that reaches for React, a browser
-global, tiptap or a wallet — and the tooling modules, which no route imports — is
-subpath-only.
+`wiki-formant/db` holds `pgPoolConfig(url)`, the options every app here hands to
+`new pg.Pool()`: ten clients on Supabase's 6543 transaction pooler, three on the
+5432 session pooler, whose fifteen-client cap a build's workers share.
+
+`rateLimit` takes `blockMs` (and a `blockKey`, default the bucket's own) for a
+caller already shown to be abusive: running dry blocks the key outright for that
+long, across every bucket that names it, rather than letting the refill trickle
+one token through at a time. `clientIp` reads `x-real-ip` first — Vercel sets it
+and overwrites any inbound copy — and the leftmost `x-forwarded-for` only where no
+`x-real-ip` was set, since a proxy that appends hands the client that slot.
 
 ## A bin
 
@@ -605,6 +672,14 @@ npx check-classes --warn         # report and exit 0
 npx check-classes --compositions # also fail on the inline compositions
 ```
 
+`analytics-digest` prints a site's `digest` as JSON for a script outside the app. Run it from the app's root, where `pg` is installed and `.env` holds `DATABASE_URL`:
+
+```sh
+npx analytics-digest --days 7
+npx analytics-digest --days 30 --handle radixwiki --siblings caper.network,acuiq.com
+npx analytics-digest --days 7 --gap "Symptom Miss:term"   # adds an event to the search gaps
+```
+
 ## Licence
 
 MIT.

package/bin/analytics-digest.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+// bin/analytics-digest.mjs – print one site's `digest` (`wiki-formant/analytics`)
+// as JSON, for a script that reads traffic from outside the app.
+//
+// Run from the app's root, where `pg` is installed and `.env` holds
+// DATABASE_URL (read from the environment first). The SQL is the package's, so
+// a report reads the figures the app's own pages read.
+//
+//   npx analytics-digest --days 7
+//   npx analytics-digest --days 30 --handle radixwiki --siblings caper.network,acuiq.com
+//   npx analytics-digest --days 7 --site <id>             # a multi-tenant app's site
+//   npx analytics-digest --days 7 --gap "Symptom Miss:term"   # adds to the search gaps
+import pg from 'pg';
+import { digest, SEARCH_GAPS } from '../dist/analytics.js';
+
+const args = process.argv.slice(2);
+const arg = name => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const all = name => args.flatMap((a, i) => (a === name && args[i + 1] ? [args[i + 1]] : []));
+
+if (!process.env.DATABASE_URL) {
+  try {
+    process.loadEnvFile('.env');
+  } catch {
+    // reported below
+  }
+}
+if (!process.env.DATABASE_URL) {
+  console.log(JSON.stringify({ error: 'no DATABASE_URL in the environment or ./.env' }));
+  process.exit(0);
+}
+
+const client = new pg.Client({ connectionString: process.env.DATABASE_URL });
+try {
+  await client.connect();
+  const sql = (query, ...values) => client.query(query, values).then(r => r.rows);
+  const result = await digest(sql, {
+    site: arg('--site') ?? '',
+    days: Number(arg('--days') ?? 7),
+    handle: arg('--handle'),
+    siblings: arg('--siblings')?.split(',').filter(Boolean) ?? [],
+    gaps: [
+      SEARCH_GAPS,
+      ...all('--gap').map(g => {
+        const [event, prop] = g.split(':');
+        return { event, prop };
+      }),
+    ],
+  });
+  console.log(JSON.stringify(result));
+} catch (e) {
+  console.log(JSON.stringify({ error: e.message }));
+} finally {
+  await client.end().catch(() => {});
+}

package/dist/analytics.d.ts

@@ -1,36 +1,125 @@
-import type { HeaderReader } from './rate-limit.js';
-export interface PlausibleConfig {
-    /** The hostname the Plausible property is registered under. */
-    domain: string;
-    /** Override for self-hosted Plausible. */
-    endpoint?: string;
+import { type HeaderReader, type RateLimitOptions } from './rate-limit.js';
+/**
+ * Runs one statement with `$1, $2…` placeholders and resolves to its rows.
+ * Prisma: `(query, ...values) => prisma.$queryRawUnsafe(query, ...values)`.
+ */
+export type Sql = (query: string, ...values: unknown[]) => Promise<unknown>;
+/** iPadOS reports itself as a Mac, so its views count as a computer's. */
+export declare const deviceOf: (ua: string) => "phone" | "tablet" | "computer";
+/**
+ * Where a visit came from: its `utm_source` when the link carried one, else the
+ * referring host, and null for a referrer that is this site or none.
+ */
+export declare function sourceOf(referrer: unknown, utm: unknown, host: string): string | null;
+/** A browser path as stored: decoded, one leading slash, no trailing one. Null when it will not decode. */
+export declare function normalisePath(path: string): string | null;
+export interface ViewInput {
+    /** The beacon request's headers: the address, browser, host and country come from them. */
+    headers: HeaderReader;
+    path: string;
+    referrer?: unknown;
+    /** The page URL's `utm_source`. */
+    utm?: unknown;
+    site?: string;
+}
+/** Count one page view, unless a bot sent it. Never rejects. */
+export declare function recordView(sql: Sql, { headers, path, referrer, utm, site }: ViewInput): Promise<void>;
+export interface EventInput {
+    name: string;
+    props?: Record<string, string | number>;
+    /** The page it happened on, as a URL or a path. */
+    url?: string;
+    /** The request of whoever caused it, so the event joins their visitor. Omit for an event no visitor caused. */
+    headers?: HeaderReader;
+    site?: string;
+}
+/** Record one named event. Never rejects. */
+export declare function recordEvent(sql: Sql, { name, props, url, headers, site }: EventInput): Promise<void>;
+/** What a page sends: a view, or with `name` an event. */
+export interface Beacon {
+    path: string;
+    referrer?: string;
+    utm?: string;
+    name?: string;
+    props?: Record<string, string | number>;
+}
+export interface CollectOptions {
+    sql: Sql;
+    /** `after` in a Next route: the write runs once the 204 has gone. */
+    defer: (task: () => Promise<unknown>) => void;
+    /** The site a beacon counts toward, or null to drop it. A single-site app omits it. */
+    site?: (request: Request, path: string) => string | null | Promise<string | null>;
+    rateLimit?: RateLimitOptions;
 }
-export interface PlausibleExtra {
-    /** Revenue goal payload; accepted and ignored on plans without revenue goals. */
-    revenue?: {
-        currency: string;
-        amount: number;
-    };
+/**
+ * The whole beacon route: `export const POST = (r: Request) => collect(r, { sql, defer: after })`.
+ * Answers 204 whatever happens, before anything is written, so a reader never waits on it.
+ */
+export declare function collect(request: Request, { sql, defer, site, rateLimit: limit }: CollectOptions): Promise<Response>;
+export interface Gap {
+    event: string;
+    /** The prop holding the reader's words. */
+    prop: string;
+    /** Props the event must carry, e.g. `{ results: '0' }`. */
+    where?: Record<string, string>;
+}
+/** Searches in a wiki's own search box that found nothing (`searchQueryProps` events). */
+export declare const SEARCH_GAPS: Gap;
+export interface DigestOptions {
+    site?: string;
+    /** How far back, in whole days from now. */
+    days: number;
+    /** The site's own X handle: `follow_clicks` counts clicks on links to it. */
+    handle?: string;
+    /** Hosts of sibling sites: `sibling_referrals` counts the visits they sent. */
+    siblings?: string[];
+    gaps?: Gap[];
     /**
-     * Send the visitor's own user agent so the event joins their session rather
-     * than landing as the fixed bot-tracker pseudo-visitor. Right for an event
-     * a person triggered; wrong for one a crawler did.
+     * MCP callers left out of `agent_tool_calls`, matched inside the user agent.
+     * The default is the conformance suites (`<repo>-mcp-test`) and the studio's own tools.
      */
-    userAgent?: string;
+    ownAgents?: string[];
+}
+type Ranked<K extends string, M extends string> = Array<Record<K, string> & Record<M, number>>;
+export interface Digest {
+    visitors: number;
+    pageviews: number;
+    /** Percent of visits that saw one page; null with no visits. */
+    bounce_rate: number | null;
+    /** Mean seconds from a visit's first view to its last; null with no visits. */
+    visit_duration: number | null;
+    /** Visitors plus every agent that sent an event, such as an MCP call. */
+    visitors_incl_agents: number;
+    /** Visitors in the same number of days before. */
+    previous_visitors: number;
+    top_sources: Ranked<'source', 'visitors'>;
+    top_pages: Ranked<'page', 'visitors'>;
+    entry_pages: Ranked<'page', 'visitors'>;
+    /** Entry pages of visits from links tagged `utm_source=x`. */
+    from_posts: Ranked<'page', 'visitors'>;
+    sibling_referrals: Ranked<'source', 'visitors'>;
+    countries: Ranked<'country', 'visitors'>;
+    devices: Ranked<'device', 'visitors'>;
+    by_day: Ranked<'date', 'visitors'>;
+    follow_clicks: {
+        events: number;
+        visitors: number;
+    } | null;
+    agent_tool_calls: Ranked<'tool', 'events'>;
+    gaps: Ranked<'query', 'events'>;
 }
 /**
- * The exact request shape Plausible's events API expects.
- *
- * Never rejects: analytics must not be able to fail a response the reader is
- * waiting on.
+ * Everything a report needs about one site's last `days` days, in one query.
+ * Visitor figures count distinct visitors, so a person who comes back on
+ * another day counts once for each day.
  */
-export declare function plausibleEvent(config: PlausibleConfig, name: string, url: string, props: Record<string, string>, headers: HeaderReader, extra?: PlausibleExtra): Promise<unknown>;
+export declare function digest(sql: Sql, { site, days, handle, siblings, gaps, ownAgents }: DigestOptions): Promise<Digest>;
 /**
  * Props for an "MCP Call" event, read out of the JSON-RPC envelope.
  *
  * The body is untrusted and may be a batch, a notification, or malformed
  * entirely, so every extraction is defensive and the result is always a
- * complete props object. A batch is attributed to its first member — the
+ * complete props object. A batch is attributed to its first member – the
  * alternative is one event per member, which would make a fan-out look like
  * traffic it is not.
  */
@@ -47,7 +136,7 @@ export interface SearchQueryInput {
     surface?: string;
 }
 /**
- * Props for a "Search Query" event — the human-side twin of `mcpCallProps`.
+ * Props for a "Search Query" event – the human-side twin of `mcpCallProps`.
  *
  * A wiki instruments its agent surface and then counts every question an agent
  * asks while recording none of the questions a person asks. The queries that
@@ -56,9 +145,60 @@ export interface SearchQueryInput {
  *
  * Returns `null` for a query with no content, so an empty field cannot fire an
  * event. The text is untrusted, so it is collapsed, lowercased for aggregation
- * and truncated — the same 64-character bound search itself applies, which
+ * and truncated – the same 64-character bound search itself applies, which
  * keeps the prop and the query that produced it the same string.
  */
 export declare function searchQueryProps({ query, results, surface, }: SearchQueryInput): Record<string, string> | null;
-/** The hostname of a site URL, for the `domain` a Plausible property is filed under. */
-export declare function plausibleDomain(siteUrl: string | undefined, fallback: string): string;
+export interface TrackerOptions {
+    sql: Sql;
+    /** `after` in Next: the write runs once the response has gone. */
+    defer: (task: () => Promise<unknown>) => void;
+    /**
+     * Whether anything is recorded. Default: only on a Vercel production
+     * deployment, because dev and previews write to production's database.
+     */
+    enabled?: boolean;
+    /** Where an event with no page of its own is filed: a search with no referer. Default `/`. */
+    siteUrl?: string;
+}
+/** Headers in hand, or a reader for them run inside the deferred write: Next's `headers`. */
+export type HeaderSource = HeaderReader | (() => HeaderReader | Promise<HeaderReader>);
+export interface Tracker {
+    /**
+     * Record one event. `headers` are the request of whoever caused it, so the
+     * event joins their visitor, an agent's included; omit them for an event no
+     * visitor caused. Never rejects, and the caller defers it: `event.waitUntil`
+     * in a proxy, `after` in a route.
+     */
+    trackEvent(name: string, url: string, props: Record<string, string | number>, headers?: HeaderReader): Promise<void>;
+    /**
+     * An "MCP Call" event, deferred. The signature is `McpServerConfig.onCall`'s
+     * plus a server name, so a one-server site passes it as `onCall` as it is.
+     */
+    trackMcpCall(request: Request, body: unknown, server?: string): void;
+    /**
+     * A "Search Query" event, deferred, filed against the page the reader
+     * searched from. A function for `headers` is called inside the deferred
+     * write, and a failure there drops the event rather than the response.
+     */
+    trackSearch(headers: HeaderSource, query: string, results: number, surface?: string): void;
+    /**
+     * The beacon route: `export const POST = tracker.viewRoute()`. `site` is
+     * `collect`'s resolver, for an app that serves many sites or drops a path.
+     */
+    viewRoute(opts?: Pick<CollectOptions, 'site' | 'rateLimit'>): (request: Request) => Promise<Response>;
+}
+/**
+ * Everything an app's `track.ts` had written around the functions above: the
+ * production gate, the deferral and the three named events. Four apps carried
+ * it, two with a search signature of their own.
+ *
+ * The tracker holds `sql`, so the module that builds it imports the app's
+ * database client. A proxy must keep reaching it through a dynamic import
+ * inside `waitUntil`, never a static one, or every request the proxy sees
+ * loads Prisma:
+ *
+ *   event.waitUntil(import('@/lib/track').then(m => m.trackEvent('AI Bot Visit', url, { bot }, request.headers)));
+ */
+export declare function createTracker({ sql, defer, enabled, siteUrl, }: TrackerOptions): Tracker;
+export {};