@hanzo/event 0.3.36 → 0.3.38

package/src/core.ts

@@ -2,7 +2,7 @@
 // planes, sharing one session and one identity:
 //
 //   1. EVENT STREAM — buffered pageview/event/identify/group, flushed as ONE
-//      batch to the Hanzo Cloud front door:
+//      batch to the Hanzo Cloud entry point:
 //        POST {host}/v1/event   body: { batch: [Event, …] }  -> { accepted, dropped }
 //      Cloud resolves the tenant server-side (validated session, or the signed
 //      publishable key) and stamps it; the client NEVER sends the org.
@@ -17,20 +17,20 @@
 // GET /v1/errors) — that is product signal, not error tracking. There is no
 // server-side fan-out from /v1/event into Sentry; without the envelope below,
 // nothing ever reaches sentry.hanzo.ai. An earlier revision of this file claimed
-// the one door was "lensed server-side into … error tracking (sentry)". It was
+// the one entry point was "lensed server-side into … error tracking (sentry)". It was
 // wrong, and it silently cost the fleet all of its error telemetry.
 //
 // The error plane is inert (fail-safe) when no DSN is configured: nothing is
 // sent, nothing throws, and the event stream is unaffected.
 //
-// Auth is orthogonal — the SAME body to the SAME door, differing only in how the
+// Auth is orthogonal — the SAME body to the SAME endpoint, differing only in how the
 // caller proves its tenant:
 //
 //   • cookie/session app (host:'')  — same-origin credentials ride the request.
 //   • bearer app (getToken)         — Authorization: Bearer <jwt>.
 //   • publishable-key app (ingestKey: 'pk-…') — ?ingest_key=pk-… on the query, on
 //     the fetch and the beacon alike, with a text/plain body. Write-only and safe
-//     to ship in a bundle; the door resolves it to an org server-side. The query
+//     to ship in a bundle; the endpoint resolves it to an org server-side. The query
 //     is the carrier neither send needs a header for, which is what keeps both
 //     CORS-simple and therefore sendable from a customer's own origin.
 //
@@ -81,13 +81,13 @@ import { VERSION } from './version'
 
 export { VERSION }
 
-const EVENT_PATH = '/v1/event' // the ONE canonical ingestion front door
+const EVENT_PATH = '/v1/event' // the ONE canonical ingestion entry point
 const DEFAULT_HOST = 'https://api.hanzo.ai' // the one edge; cookie apps pass host:''
 const ENVELOPE_CONTENT_TYPE = 'application/x-sentry-envelope'
 // The beacon body's type. text/plain is CORS-SAFELISTED, which is the whole
 // property: a safelisted type makes the POST a SIMPLE request, and a simple
 // request needs no preflight. An unloading document does not get a second round
-// trip, so cross-origin a preflighted beacon is never sent at all. The door reads
+// trip, so cross-origin a preflighted beacon is never sent at all. The endpoint reads
 // the raw body and dispatches on its first non-space byte, so the type names the
 // CORS class and nothing else.
 const BEACON_CONTENT_TYPE = 'text/plain'
@@ -292,10 +292,10 @@ export class Analytics {
       // so before this the only way to report was to commit a key literal, and the
       // fleet grew one copy per site of a value with a single source.
       //
-      // A surface no brand claims still has no key, and the door REFUSES an
+      // A surface no brand claims still has no key, and the edge REFUSES an
       // unattributed event (401 `ingest_key_required`) — the reserved `$public`
       // tenant that once caught keyless beacons is retired, and anonymous ingest is
-      // refused at every door on every brand host. So there is no quiet fallback to
+      // refused at every edge on every brand host. So there is no quiet fallback to
       // rely on: an event lands in the org a credential names, or it does not land.
       ingestKey:
         config.ingestKey ?? readEnv('NEXT_PUBLIC_PUBLISHABLE_KEY') ?? keyForPage(),
@@ -497,7 +497,7 @@ export class Analytics {
   }
 
   /** flush drains the buffer to the server as ONE batch through the ONE ingest
-   *  front door POST /v1/event, body { batch: [Event…] }. beacon=true selects the
+   *  endpoint POST /v1/event, body { batch: [Event…] }. beacon=true selects the
    *  unload-safe transport. Auth is orthogonal to the wire:
    *
    *    • publishable key set → rides ?ingest_key=pk-… on both sends, keeping each
@@ -513,7 +513,7 @@ export class Analytics {
     this.queue = []
     this.clearTimer()
 
-    // A publishable key and a bearer JWT are mutually exclusive doors, and the
+    // A publishable key and a bearer JWT are mutually exclusive credentials, and the
     // BEARER WINS. It names a real principal and resolves to THAT person's org;
     // a pk- names one org for everybody holding it. So the key is what attributes
     // a visitor nobody has vouched for, and it must never displace someone who
@@ -672,7 +672,7 @@ export class Analytics {
 //
 // A page has ONE event stream per (host, product): one queue, one anon id, one
 // credential. Two clients on it split the batch and double the pageview, and
-// the half built by the caller that had no key is refused at the door — so the
+// the half built by the caller that had no key is refused at the edge — so the
 // same page is both over- and under-counted, and neither number says so.
 //
 // Two callers ask for that stream on any real page and both are right to: the

package/src/events.ts

@@ -4,7 +4,7 @@
  * These names used to be declared here. They moved to @hanzo/events — the
  * plural package is the catalog (many events, what each means, what each
  * carries), this one is the client (one call sends one event). Splitting them
- * that way is what lets the ingest door read the same catalog: the door is Go
+ * that way is what lets the ingest endpoint read the same catalog: it is Go
  * and cannot import TypeScript, so @hanzo/events also ships the data as JSON,
  * and there is still exactly one definition.
  *

package/src/exception.ts

@@ -12,7 +12,7 @@
 // WHY THE FULLY-DERIVED SHAPE. Upstream, a server stage (Cymbal) symbolicates
 // frames and computes `$exception_fingerprint`, `$exception_types`, `_values`,
 // `_sources`, `_functions`, then REPLACES the property bag. That stage is not in
-// Hanzo's path: the door writes `event.fact` and a materialized view projects it
+// Hanzo's path: the ingest endpoint writes `event.fact` and a materialized view projects it
 // into `insights.events`, so nothing between the client and the warehouse derives
 // anything. Whatever the product reads, the client has to have sent. Two
 // consequences are load-bearing rather than cosmetic:

package/src/org.ts

@@ -72,18 +72,21 @@ export const ORG_DOMAIN: Readonly<Record<string, readonly string[]>> = Object.fr
     'lux.fund',
     'lux.id',
   ]),
-  zoo: Object.freeze(['zoo.ngo', 'zoo.network', 'zoolabs.id']),
+  zoo: Object.freeze(['zoo.ngo', 'zoo.network', 'zoolabs.id', 'zoolabs.io']),
 })
 
 /**
  * Each org's publishable key — the same values `universe`'s `SPA_INGEST_KEYRING`
  * serves to the identity hosts, which are each brand's own insights team token.
  * Add an org here the day its project exists, never before.
+ *
+ * A key is only as real as the project it names: recreate the project and this
+ * file moves with it, or every beacon answers 403 and reports nowhere.
  */
 export const ORG_KEY: Keyring = Object.freeze({
-  hanzo: 'pk-rM_CdaF2MQckGCrla113SrR1oH4zvqN8xh2I95Z9tY8',
-  lux: 'pk-gUZp6ZVfhJzSwK-rb4oLbVkpCnMBx5uSCpxf_5yEhQk',
-  zoo: 'pk-3TKpKnERV9AQSsBUERWkZejC1O1mUxc1jRzsP3MPbs4',
+  hanzo: 'pk-bCcNBDOLwdIovV349jVGH1ShEOq7rAcaKLsX_bLnRMo',
+  lux: 'pk-GxCDhpEn89qajMyuMdMs6mcE4UVQBkv8F2swEKHC67Y',
+  zoo: 'pk-bS-xKESMhuhK_wfSmpRf1H_IH8A3x6Y5NV70TD7ycWE',
 })
 
 /** `pk-` is publishable; `sk-` is not, and there is no third thing. Checked at the

package/src/stack.ts

@@ -4,7 +4,7 @@
 //
 // These frames ride the error Event to POST /v1/event so the warehouse stores
 // WHERE a crash happened, not just that one did. Nothing here talks to Sentry:
-// the client has one door and one credential. The frame shape is deliberately the
+// the client has one entry point and one credential. The frame shape is deliberately the
 // conventional one (function/filename/abs_path/lineno/colno/in_app) because it is
 // what every stack tool already speaks — including a future grouper built over
 // the warehouse.

package/src/types.ts

@@ -100,7 +100,7 @@ export interface Cohort {
 
 /** One event as sent on the wire — the canonical Hanzo Cloud event. Maps 1:1 to
  *  the cloud `CaptureEvent` (camelCase JSON keys); a batch of these is POSTed to
- *  the ONE front door `/v1/event` as `{ batch: [WireEvent, …] }`. tenant/org is
+ *  the ONE entry point `/v1/event` as `{ batch: [WireEvent, …] }`. tenant/org is
  *  NEVER a field here — the server stamps it from the validated session/key. */
 export interface WireEvent {
   messageId: string
@@ -168,7 +168,7 @@ export interface AnalyticsConfig {
    *  (the client then relies on same-origin credentials). */
   getToken?: () => string | undefined | null
   /** Publishable ingest key (pk-…). When set, the client attributes writes to the
-   *  ONE front door `/v1/event` with this key instead of a bearer/cookie: it rides
+   *  ONE entry point `/v1/event` with this key instead of a bearer/cookie: it rides
    *  Authorization: Bearer pk-… on fetch and ?ingest_key=pk-… on a headerless
    *  page-unload beacon, so ANONYMOUS traffic is attributed and unload beacons work
    *  without a bearer. The key is write-only — it attributes a write and never mints
@@ -184,7 +184,7 @@ export interface AnalyticsConfig {
    *
    *  A surface with no key at all still reports for whoever is SIGNED IN (the
    *  session credential attributes them), and drops every logged-out visitor: the
-   *  door refuses an unattributable write rather than filing it where its owner
+   *  edge refuses an unattributable write rather than filing it where its owner
    *  cannot read it. That failure is invisible from the page, which is why the key
    *  belongs in the env next to the DSN and not in a checklist.
    *

package/src/uid.ts

@@ -3,7 +3,7 @@
 // The implementation is `hzUuidv7` in ./anon.js and this file only re-exports it.
 // It lives there because the anonymous-id chain has to mint too, and that chain is
 // inlined verbatim by the distribution that has no bundler (the tag
-// the door hosts) — a minter here as well would be a second implementation, and
+// served at /v1/event.js) — a minter here as well would be a second implementation, and
 // the version nibble it produces is exactly the thing that must never diverge.
 //
 // WHY NOT crypto.randomUUID(): it mints v4, whose 122 bits are pure entropy and
@@ -12,7 +12,7 @@
 // `fromUnixTimestamp(intDiv(toUInt64(bitShiftRight(session_id_v7, 80)), 1000))` —
 // so they admit only ids whose version nibble is 7
 // (`bitAnd(bitShiftRight(toUInt128(session_id), 76), 15) = 7`). A v4 session id is
-// not merely unordered there: it is DISCARDED at the door, silently, and the
+// not merely unordered there: it is DISCARDED by that predicate, silently, and the
 // rollup stays empty forever. Minting v7 is the whole reason those rollups can
 // exist; it also clusters index writes by time instead of scattering them across
 // the keyspace.

package/src/version.ts

@@ -1,4 +1,4 @@
 // The library version, stamped on every event (`libraryVersion`) and on the
 // Sentry `sdk` block. It lives alone so `sentry.ts` can read it without importing
 // `core.ts` — core imports sentry, so the reverse would be an import cycle.
-export const VERSION = '0.3.36'
+export const VERSION = '0.3.37'

package/dist/core-CIhI2R7S.d.ts

@@ -1,380 +0,0 @@
-/** The event kinds — the closed set the server understands. `error` marks the
- *  breadcrumb an exception leaves on the event stream (Cloud stamps
- *  event_type='error' for the warehouse, GET /v1/errors). It does NOT reach the
- *  Sentry dashboard — the envelope on the error plane does that. */
-type EventKind = 'pageview' | 'event' | 'identify' | 'group' | 'error';
-/** A captured exception as it rides the EVENT STREAM — Cloud folds it into
- *  properties.$exception for the warehouse. The richer copy (parsed stack frames,
- *  grouping, release) travels on the error plane as a Sentry envelope; see
- *  AnalyticsConfig.dsn. */
-interface Exception {
-    /** Constructor/class name, e.g. "TypeError". */
-    type?: string;
-    /** The error message. */
-    message: string;
-    /** Stack trace when available. */
-    stack?: string;
-    /** false = an unhandled/global error (window.onerror, unhandledrejection);
-     *  true = a caught error the app chose to report. Defaults true. */
-    handled?: boolean;
-}
-/** One stack frame as Error Tracking renders it. The key names are the product's
- *  POST-symbolication vocabulary (`mangled_name`/`source`/`line`/`column`), which
- *  is what the issue view reads straight off `$exception_list`. */
-interface ExceptionFrame {
-    /** "<hash>/<part>" — stable per code location; the frame's identity. */
-    raw_id: string;
-    /** The function name as it appears in the shipped bundle. */
-    mangled_name: string;
-    /** File/URL the frame is in. */
-    source: string;
-    line: number;
-    column: number;
-    /** First-party code. Frames without this are hidden by default in the product. */
-    in_app: boolean;
-    lang: string;
-    /** Whether a symbol set mapped this frame back to original source. */
-    resolved: boolean;
-    resolve_failure?: string;
-    resolved_name?: string | null;
-    module?: string | null;
-}
-/** One exception in `$exception_list`. */
-interface ExceptionEntry {
-    id: string;
-    type: string;
-    value: string;
-    mechanism?: {
-        type: 'generic';
-        handled: boolean;
-        synthetic?: boolean;
-    };
-    /** `type` MUST be 'resolved' — the renderer draws frames on no other value. */
-    stacktrace?: {
-        type: 'resolved';
-        frames: ExceptionFrame[];
-    };
-}
-/** The `$exception_*` property bag Error Tracking reads off a `$exception` event. */
-interface ExceptionProperties {
-    $exception_list: ExceptionEntry[];
-    /** Issue grouping key. An event without one is dropped by the issue query. */
-    $exception_fingerprint: string;
-    $exception_fingerprint_record: {
-        type: 'manual';
-    }[];
-    $exception_type: string;
-    $exception_message: string;
-    $exception_level: SentryLevel;
-    $exception_handled: boolean;
-    $exception_synthetic: boolean;
-    $exception_types: string[];
-    $exception_values: string[];
-    $exception_sources: string[];
-    $exception_functions: string[];
-}
-/** First-touch marketing attribution, parsed once and persisted. */
-interface Attribution {
-    utm: {
-        source?: string;
-        medium?: string;
-        campaign?: string;
-        term?: string;
-        content?: string;
-    };
-    referrer?: string;
-    refCode?: string;
-    /** Derived acquisition channel: direct | organic | paid | social | referral. */
-    channel?: string;
-}
-/** Cohort dimensions carried on every event once known (see goals.ts COHORTS). */
-interface Cohort {
-    /** ISO week the person first signed up, e.g. "2026-W28". */
-    signupWeek?: string;
-    channel?: string;
-    refCode?: string;
-}
-/** One event as sent on the wire — the canonical Hanzo Cloud event. Maps 1:1 to
- *  the cloud `CaptureEvent` (camelCase JSON keys); a batch of these is POSTed to
- *  the ONE front door `/v1/event` as `{ batch: [WireEvent, …] }`. tenant/org is
- *  NEVER a field here — the server stamps it from the validated session/key. */
-interface WireEvent {
-    messageId: string;
-    type: EventKind;
-    event?: string;
-    timestamp: string;
-    distinctId?: string;
-    anonymousId?: string;
-    personId?: string;
-    sessionId?: string;
-    product?: string;
-    url?: string;
-    path?: string;
-    referrer?: string;
-    utm?: Attribution['utm'];
-    refCode?: string;
-    channel?: string;
-    groupId?: string;
-    signupWeek?: string;
-    productId?: string;
-    quantity?: number;
-    revenue?: number;
-    currency?: string;
-    /** Set on `type:'error'` events — the captured exception. Cloud lifts it into
-     *  properties.$exception (foldException) for the event warehouse. Not a Sentry
-     *  path: the envelope on the error plane is what feeds the dashboard. */
-    error?: Exception;
-    properties?: Record<string, unknown>;
-    library?: string;
-    libraryVersion?: string;
-}
-/** Injectable transports — overridden in tests; the default in core.ts uses fetch
- *  (keepalive) and sendBeacon. A bearer JWT or a publishable pk_ key rides
- *  Authorization on fetch; on a headerless beacon a publishable key rides the
- *  ?ingest_key query. */
-interface Transport {
-    /** Durable POST usable during page unload (fetch keepalive / sendBeacon).
-     *  `contentType` names the FETCH request's Content-Type — it defaults to
-     *  application/json, and the error plane sets application/x-sentry-envelope. A
-     *  beacon body carries a CORS-safelisted type so the POST stays a simple request;
-     *  that is a property of the transport, not a caller's choice. */
-    send(url: string, body: string, opts: {
-        beacon: boolean;
-        token?: string;
-        ingestKey?: string;
-        contentType?: string;
-        /** Surface non-OK / failed ingest on the console. Never on by default. */
-        debug?: boolean;
-    }): void;
-}
-interface AnalyticsConfig {
-    /** Cloud base URL. Defaults to "https://api.hanzo.ai" (the one edge). Set to
-     *  same-origin ("") for cookie-auth apps served behind the same edge
-     *  (console/admin/chat), so the browser rides the session cookie. */
-    host?: string;
-    /** Emitting surface: console | chat | app | site | admin. */
-    product: string;
-    /** Bearer token provider for token-auth apps. Omit for cookie/session apps
-     *  (the client then relies on same-origin credentials). */
-    getToken?: () => string | undefined | null;
-    /** Publishable ingest key (pk-…). When set, the client attributes writes to the
-     *  ONE front door `/v1/event` with this key instead of a bearer/cookie: it rides
-     *  Authorization: Bearer pk-… on fetch and ?ingest_key=pk-… on a headerless
-     *  page-unload beacon, so ANONYMOUS traffic is attributed and unload beacons work
-     *  without a bearer. The key is write-only — it attributes a write and never mints
-     *  a reading principal — so it is safe to ship in a bundle. Mint one per org with
-     *  POST /v1/keys {"type":"publishable"}.
-     *
-     *  Omit it and the client reads NEXT_PUBLIC_PUBLISHABLE_KEY from the inlined
-     *  build env, the same way `dsn` falls back — so a surface declares BOTH planes
-     *  in its build and neither needs code to switch on. That is the ONE spelling
-     *  the fleet already carries: KMS holds deploy/PUBLISHABLE_KEY, and each
-     *  Dockerfile takes PUBLISHABLE_KEY as a build-arg and re-exports it with the
-     *  NEXT_PUBLIC_ prefix that makes Next inline it.
-     *
-     *  A surface with no key at all still reports for whoever is SIGNED IN (the
-     *  session credential attributes them), and drops every logged-out visitor: the
-     *  door refuses an unattributable write rather than filing it where its owner
-     *  cannot read it. That failure is invisible from the page, which is why the key
-     *  belongs in the env next to the DSN and not in a checklist.
-     *
-     *  This attributes the EVENT STREAM only — the error plane authenticates
-     *  independently with `dsn`, and one does not stand in for the other. */
-    ingestKey?: string;
-    /** Max events buffered before an automatic flush. */
-    batchSize?: number;
-    /** Auto-flush cadence in ms. */
-    flushIntervalMs?: number;
-    /** Turn the client off entirely (e.g. opt-out / DNT). Defaults to enabled. */
-    enabled?: boolean;
-    /** Auto-capture unhandled errors + promise rejections (window.onerror,
-     *  unhandledrejection). Browser-only, defaults to enabled. Together with `dsn`
-     *  this is what makes the client a drop-in @sentry replacement — without a
-     *  `dsn` the captures never reach the Sentry dashboard. */
-    captureErrors?: boolean;
-    /** Override the transport (tests). */
-    transport?: Transport;
-    /** Debug logging. */
-    debug?: boolean;
-    /** Hanzo-minted Sentry DSN: "https://<version>:<hmac>@<host>/v1/event/<projectId>".
-     *  Publishable — the key authorizes writes to ONE project and can read nothing,
-     *  so it is safe in a browser bundle (same trust class as `ingestKey`). When
-     *  absent the client reads NEXT_PUBLIC_HANZO_EVENT_DSN; when neither is set the
-     *  error plane is inert (fail-safe: nothing sent, nothing thrown, analytics
-     *  unaffected). Mint one per property: POST /v1/sentry/projects. */
-    dsn?: string;
-    /** Release stamped on error events (a git SHA / app version). */
-    release?: string;
-    /** Deployment environment for error events (production | staging | …). */
-    environment?: string;
-    /** Retain end-user PII (emails/IPs) in error text. Default false = scrub
-     *  client-side before anything leaves the device (the server scrubs again). */
-    capturePII?: boolean;
-}
-type SentryLevel = 'fatal' | 'error' | 'warning' | 'info' | 'debug';
-interface SentryFrame {
-    filename?: string;
-    function?: string;
-    module?: string;
-    abs_path?: string;
-    lineno?: number;
-    colno?: number;
-    in_app?: boolean;
-}
-interface SentryExceptionValue {
-    type?: string;
-    value?: string;
-    module?: string;
-    stacktrace?: {
-        frames: SentryFrame[];
-    };
-}
-interface SentryUser {
-    /** Stable subject id (OIDC sub / anon id). NEVER email/username/ip. */
-    id?: string;
-}
-interface SentryEvent {
-    event_id: string;
-    timestamp: number;
-    platform: 'javascript';
-    level: SentryLevel;
-    logger?: string;
-    environment?: string;
-    release?: string;
-    transaction?: string;
-    fingerprint?: string[];
-    message?: string;
-    exception?: {
-        values: SentryExceptionValue[];
-    };
-    tags?: Record<string, string>;
-    user?: SentryUser;
-    contexts?: Record<string, Record<string, unknown>>;
-    sdk?: {
-        name: string;
-        version: string;
-    };
-}
-/** Parsed DSN — the public key + the derived ingest URL. */
-interface Dsn {
-    /** "<version>:<hmac>" public key presented via ?sentry_key= (beacon-safe). */
-    publicKey: string;
-    /** Ingest origin, e.g. "https://sentry.hanzo.ai". */
-    origin: string;
-    /** Project id segment. */
-    projectId: string;
-    /** The DSN's own origin + path, e.g. "https://api.hanzo.ai/v1/event/<projectId>".
-     *  Every URL below is derived from this, so the ingest address is named once —
-     *  in dsnForProduct — and nowhere else. */
-    base: string;
-    /** Fully-derived envelope ingest URL incl. ?sentry_key=. */
-    ingestUrl: string;
-}
-/** Options for Analytics.captureError. */
-interface CaptureErrorOptions {
-    /** false => uncaught (window.onerror / unhandledrejection / render crash). */
-    handled?: boolean;
-    /** Severity + free-form context; merged into the event's tags. */
-    properties?: Record<string, unknown>;
-    /** Override the event level (default: error, or fatal when handled === false). */
-    level?: SentryLevel;
-}
-
-declare class Analytics {
-    private cfg;
-    private transport;
-    private queue;
-    private timer;
-    private personId?;
-    private attribution;
-    private cohort;
-    private started;
-    /** The view pageview() last counted — path + location. */
-    private counted?;
-    /** Parsed error-plane DSN, or null when the plane is inert. */
-    private dsn;
-    /** Guards against an error thrown *inside* the error path re-entering it. */
-    private reentrant;
-    constructor(config: AnalyticsConfig);
-    /** adopt gives this client a credential it does not have. The key belongs to
-     *  the stream, not to whichever caller happened to ask for the handle first,
-     *  so a later caller carrying one hands it over. The error plane derives from
-     *  the key, so it comes up here too when it was inert for want of one.
-     *  Present fields are never overwritten: the first caller's key stays. */
-    adopt(config: AnalyticsConfig): void;
-    /** errorPlaneEnabled reports whether captured exceptions can actually reach the
-     *  error host. False means a DSN was never configured — the documented
-     *  fail-safe. Exposed so an app (or a test) can assert its wiring instead of
-     *  discovering months later that nothing was ever reported. */
-    get errorPlaneEnabled(): boolean;
-    /** errorIngestUrl is the fully-derived envelope endpoint, or undefined when the
-     *  plane is inert. Diagnostics only. */
-    get errorIngestUrl(): string | undefined;
-    /** init is idempotent and browser-only for its side effects: capture first-touch
-     *  attribution, hydrate cohort, register the unload flush, and (unless opted out)
-     *  auto-capture unhandled errors. Safe to call from a React effect on every
-     *  render. */
-    init(): void;
-    /** identify binds the current visitor to a stable person id (post-login). */
-    identify(personId: string, traits?: Record<string, unknown>): void;
-    /** group associates the visitor with an org/team (analytics grouping, not the
-     *  server tenant — the server still derives tenant from the session). */
-    group(groupId: string, traits?: Record<string, unknown>): void;
-    /** pageview records a $pageview for the current (or given) location, once per
-     *  view. A view is the path plus the full location, so a query or hash change
-     *  is a new one and a repeat call for the same place is not. */
-    pageview(path?: string, properties?: Record<string, unknown>): void;
-    /** capture records a named product event with optional properties. Commerce
-     *  fields (productId/quantity/revenue/currency) may be passed for order events. */
-    capture(event: string, properties?: Record<string, unknown>, commerce?: Pick<WireEvent, 'productId' | 'quantity' | 'revenue' | 'currency'>): void;
-    /** captureError reports a caught error, an unhandled rejection, a React render
-     *  error, or a manual report to BOTH planes, from one call:
-     *
-     *    - the ERROR PLANE — a real Sentry envelope to the DSN host. This is the one
-     *      that produces an issue in sentry.hanzo.ai (grouping, stack frames, AST).
-     *      Inert when no DSN is configured.
-     *    - the EVENT STREAM — a `type:'error'` row in the cloud event warehouse, so
-     *      an error stays correlated with the session's pageviews for product
-     *      analysis (readable via GET /v1/errors).
-     *
-     *  Both carry the SAME session and subject id, so an error and the pageview
-     *  before it join up. Never throws back into the app; errors are higher-signal
-     *  than pageviews, so both planes flush promptly (a crash may unload the page
-     *  moments later). */
-    captureError(err: unknown, context?: CaptureErrorOptions): void;
-    /** setCohort persists cohort dimensions (e.g. signupWeek at signup) so they ride
-     *  every subsequent event. */
-    setCohort(patch: Cohort): void;
-    /** flush drains the buffer to the server as ONE batch through the ONE ingest
-     *  front door POST /v1/event, body { batch: [Event…] }. beacon=true selects the
-     *  unload-safe transport. Auth is orthogonal to the wire:
-     *
-     *    • publishable key set → rides ?ingest_key=pk-… on both sends, keeping each
-     *      a CORS-simple request that any origin may send.
-     *    • else a bearer JWT rides Authorization (fetch only — sendBeacon cannot
-     *      carry a header, so token apps fall back to keepalive fetch on unload).
-     *    • else a cookie app rides same-origin credentials (beacon carries the
-     *      cookie fine).
-     */
-    flush(beacon?: boolean): void;
-    /** sendError frames one exception as a Sentry envelope and posts it to the DSN's
-     *  ingest URL. The DSN's own key rides ?sentry_key= (the credential channel the
-     *  server trusts, and the only one a headerless beacon can carry), so NO bearer
-     *  or publishable key is attached here — the two planes authenticate
-     *  independently. Errors are sent one envelope per event, immediately: batching
-     *  a crash report is how you lose it. */
-    private sendError;
-    /** errorIdentity is the SAME identity the event stream stamps — the OIDC subject
-     *  once identify() has run, else the anon id. Never email/PII. */
-    private errorIdentity;
-    private enqueue;
-    private build;
-    private schedule;
-    private clearTimer;
-}
-/** createAnalytics returns the client for a stream, building it on first ask.
- *  This is the ONE way to get a client: `new Analytics` bypasses the registry
- *  and is for tests and for a deliberately separate instance. */
-declare function createAnalytics(config: AnalyticsConfig): Analytics;
-
-export { type Attribution as A, type Cohort as C, type Dsn as D, type ExceptionEntry as E, type SentryEvent as S, type Transport as T, type WireEvent as W, type CaptureErrorOptions as a, type SentryFrame as b, type SentryLevel as c, type ExceptionProperties as d, Analytics as e, type AnalyticsConfig as f, type EventKind as g, type Exception as h, type ExceptionFrame as i, createAnalytics as j };