@hanzo/event 0.3.36 → 0.3.38

package/README.md

@@ -34,8 +34,8 @@ starve the other:
 ```
 
 That one line is the whole install, and it is the same line for a published site,
-hanzo.team and a customer's own page. The tag is served by the door that eats the
-events, so a caller allowlists ONE host and the tag can never drift from the wire
+hanzo.team and a customer's own page. The tag is served by the endpoint that eats
+the events, so a caller allowlists ONE host and the tag can never drift from the wire
 it posts to — `.js` is part of a segment rather than a child of one, so the tag
 sits UNDER `/v1/event` rather than beside it, and the old sibling `/v1/event.js`
 404s.
@@ -48,18 +48,18 @@ config from `/v1/projects/tags`, so a pixel is configured on the project rather
 than pasted into the page.
 
 > A bundled app should NOT add this tag. Both clients post pageviews to the same
-> door, so a page running `@hanzo/event` and the tag counts every pageview twice.
+> endpoint, so a page running `@hanzo/event` and the tag counts every pageview twice.
 > One surface, one client.
 
 > **`data-key` is a publishable `pk-`, and without one the tag is INERT.** A write
-> the door cannot attribute is refused (`401 ingest_key_required`) silently, so a
+> the edge cannot attribute is refused (`401 ingest_key_required`) silently, so a
 > keyless tag measures fine in the browser and files nothing. A project mints one
 > with itself: `POST /v1/projects`. A key that names no project is refused
-> `403 ingest_key_unknown` — the door fails closed rather than filing a write it
+> `403 ingest_key_unknown` — the edge fails closed rather than filing a write it
 > cannot attribute.
 
 This package is the client for a surface that **builds**. There is no second
-script-tag distribution here: one wire, one door, one tag.
+script-tag distribution here: one wire, one endpoint, one tag.
 
 It honours the same consent sources the bundled stack does: an explicit stored
 choice (`hz_consent`, the key a Hanzo consent banner writes) outranks the browser
@@ -72,8 +72,8 @@ refusals. A React app does not need this file — mount `<Hanzo analytics>` from
 > behind an identical path spelling, served by a second collector with its own
 > database. `POST api.hanzo.ai/v1/event {"batch":[]}` answered 200 while
 > `POST analytics.hanzo.ai/v1/event []` answered 204, and a client pointed at the
-> wrong host failed silently. Both the second door and the second collector are
-> deleted. One wire, one door, one client home — this package.
+> wrong host failed silently. Both the second endpoint and the second collector
+> are deleted. One wire, one endpoint, one client home — this package.
 
 - **Batched** with a size + interval flush, and **beacon-on-unload**
   (`sendBeacon` for cookie/publishable-key apps, `fetch(keepalive)` for token apps).

package/TAXONOMY.md

@@ -238,7 +238,7 @@ Verified against the trees at the time of writing. ✅ = emitting, ❌ = not emi
 4. **No org on hanzo.chat.** `group()` is absent because the chat session carries
    no org today; chat funnels are person-scoped only.
 5. **Logged-out reach depends on a publishable key.** Anonymous events need
-   `ingestKey` (`pk_…`, write-only) or they fail closed at the door.
+   `ingestKey` (`pk_…`, write-only) or they fail closed at the edge.
    `NEXT_PUBLIC_HANZO_INGEST_KEY` (hanzo.ai), `NEXT_PUBLIC_PUBLISHABLE_KEY`
    (hanzo.app), `VITE_HANZO_INGEST_KEY` (hanzo.chat) are read but must be
    provisioned per org via `POST /v1/ingest/keys`. Config, not code.

package/dist/attribution.d.ts

@@ -0,0 +1,14 @@
+import type { Attribution } from './types';
+/** parseAttribution reads UTM params + ref/refCode from a query string and pairs
+ *  them with the referrer. `search` is a location.search value ("?utm_source=…"). */
+export declare function parseAttribution(search: string, referrer: string): Attribution;
+/** deriveChannel classifies the visit: paid | referral | social | organic | direct. */
+export declare function deriveChannel(a: Attribution): string;
+/** hostOf extracts a bare lowercase host from a URL; "" when unparseable. */
+export declare function hostOf(raw?: string): string;
+/** hasAttribution reports whether anything was captured (so we don't persist an
+ *  empty first-touch that would shadow a later real one). */
+export declare function hasAttribution(a: Attribution): boolean;
+/** isoWeek returns the ISO-8601 week label, e.g. "2026-W28". */
+export declare function isoWeek(d: Date): string;
+//# sourceMappingURL=attribution.d.ts.map

package/dist/attribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribution.d.ts","sourceRoot":"","sources":["../src/attribution.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAQ1C;qFACqF;AACrF,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,CAmB9E;AAED,uFAAuF;AACvF,wBAAgB,aAAa,CAAC,CAAC,EAAE,WAAW,GAAG,MAAM,CAUpD;AAED,6EAA6E;AAC7E,wBAAgB,MAAM,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAY3C;AAED;6DAC6D;AAC7D,wBAAgB,cAAc,CAAC,CAAC,EAAE,WAAW,GAAG,OAAO,CAKtD;AAED,gEAAgE;AAChE,wBAAgB,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,MAAM,CAQvC"}

package/dist/core.d.ts

@@ -0,0 +1,102 @@
+import { getFirstTouch, getCohort } from './storage';
+import type { AnalyticsConfig, CaptureErrorOptions, Cohort, WireEvent } from './types';
+import { VERSION } from './version';
+export { VERSION };
+export 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
+     *  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
+     *      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. */
+export declare function createAnalytics(config: AnalyticsConfig): Analytics;
+export { getCohort, getFirstTouch };
+//# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AA2DA,OAAO,EAGL,aAAa,EAEb,SAAS,EAEV,MAAM,WAAW,CAAA;AAElB,OAAO,KAAK,EACV,eAAe,EAEf,mBAAmB,EACnB,MAAM,EAKN,SAAS,EACV,MAAM,SAAS,CAAA;AAChB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAEnC,OAAO,EAAE,OAAO,EAAE,CAAA;AA2KlB,qBAAa,SAAS;IACpB,OAAO,CAAC,GAAG,CAGM;IACjB,OAAO,CAAC,SAAS,CAAW;IAC5B,OAAO,CAAC,KAAK,CAAkB;IAC/B,OAAO,CAAC,KAAK,CAA6C;IAC1D,OAAO,CAAC,QAAQ,CAAC,CAAQ;IACzB,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,OAAO,CAAQ;IACvB,0DAA0D;IAC1D,OAAO,CAAC,OAAO,CAAC,CAAQ;IACxB,+DAA+D;IAC/D,OAAO,CAAC,GAAG,CAAY;IACvB,6EAA6E;IAC7E,OAAO,CAAC,SAAS,CAAQ;IAEzB,YAAY,MAAM,EAAE,eAAe,EAwClC;IAED;;;;8EAI0E;IAC1E,KAAK,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAQnC;IAED;;;mEAG+D;IAC/D,IAAI,iBAAiB,IAAI,OAAO,CAE/B;IAED;4CACwC;IACxC,IAAI,cAAc,IAAI,MAAM,GAAG,SAAS,CAEvC;IAED;;;kBAGc;IACd,IAAI,IAAI,IAAI,CAgCX;IAED,6EAA6E;IAC7E,QAAQ,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAGjE;IAED;6EACyE;IACzE,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAE7D;IAED;;oEAEgE;IAChE,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAclE;IAED;uFACmF;IACnF,OAAO,CACL,KAAK,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACpC,QAAQ,CAAC,EAAE,IAAI,CAAC,SAAS,EAAE,WAAW,GAAG,UAAU,GAAG,SAAS,GAAG,UAAU,CAAC,GAC5E,IAAI,CAEN;IAED;;;;;;;;;;;;;0BAasB;IACtB,YAAY,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAuD9D;IAED;kCAC8B;IAC9B,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAE7B;IAED;;;;;;;;;;OAUG;IACH,KAAK,CAAC,MAAM,UAAQ,GAAG,IAAI,CAmC1B;IAID;;;;;6CAKyC;IACzC,OAAO,CAAC,SAAS;IAiBjB;sEACkE;IAClE,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,OAAO;IAQf,OAAO,CAAC,KAAK;IA+Db,OAAO,CAAC,QAAQ;IAQhB,OAAO,CAAC,UAAU;CAMnB;AAiCD;;iEAEiE;AACjE,wBAAgB,eAAe,CAAC,MAAM,EAAE,eAAe,GAAG,SAAS,CAmBlE;AAID,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,CAAA"}

package/dist/dsn.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The product → Sentinel DSN registry.
+ *
+ * An app declares WHAT it is (`product: 'console'`); this module knows WHERE its
+ * errors go. That split is the whole point: no surface has to learn a DSN, carry
+ * a build argument, or grow a config file to report errors — declaring the
+ * product it already declares is enough.
+ *
+ * A Sentinel DSN is PUBLIC by construction. It ships inside the client bundle and
+ * is readable in devtools on any deployed page, and it grants exactly one
+ * capability: submitting new events. It cannot read issues, projects, or any
+ * other data. So committing it is not leaking a secret — it is recording a public
+ * identifier next to the code that needs it. (Contrast the server-side collector
+ * DSN in the `team-analytics-sentry` Secret, which is HMAC-derived and revocable
+ * precisely because a server-side credential is NOT public.)
+ *
+ * Why a literal map instead of deriving `hanzo-${product}`: the projects predate
+ * this registry and do not derive cleanly — `site` lives in `hanzo-ai`, not
+ * `hanzo-site`. An explicit map is honest about that; a derivation rule plus an
+ * exception table is the same data with a trap in it.
+ *
+ * Projects are org-scoped and named `<org>-<app>`. To add one: create the project
+ * (POST /v1/sentinel/projects with X-Org-Id), then add its `dsn` here keyed by the
+ * product name the app passes to `createAnalytics`.
+ */
+/** PRODUCT_PROJECT maps a `product` to its Sentinel project id. The DSN's KEY is no
+ *  longer a per-project secret — it is the ONE org publishable key (below), so a
+ *  surface's errors ride the SAME key its events do. The id only names WHICH
+ *  project the errors group under, and cloud auto-provisions that project on first
+ *  keyed ingest, so a new id needs nothing minted. `site` lives in the `hanzo-ai`
+ *  project — an explicit map, because the projects predate this and do not derive
+ *  cleanly from the product name. */
+export declare const PRODUCT_PROJECT: Readonly<Record<string, string>>;
+/** dsnForProduct builds the product's Sentinel DSN from the caller's resolved
+ *  publishable `key` and the product's project — the SAME key the event stream
+ *  carries, at the product's envelope endpoint. Returns undefined when there is no
+ *  key or no project for the product, leaving the error plane inert rather than
+ *  posting into the wrong one. The key is NOT baked here: it is the value the
+ *  surface resolved (an explicit `ingestKey`, or the KMS-sourced
+ *  NEXT_PUBLIC_PUBLISHABLE_KEY the build inlines) — the ONE live source, never a
+ *  literal committed beside the code. */
+export declare function dsnForProduct(product: string | undefined, key: string | undefined): string | undefined;
+//# sourceMappingURL=dsn.d.ts.map

package/dist/dsn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsn.d.ts","sourceRoot":"","sources":["../src/dsn.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;;qCAMqC;AACrC,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAI3D,CAAA;AAEF;;;;;;;yCAOyC;AACzC,wBAAgB,aAAa,CAC3B,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,GAAG,EAAE,MAAM,GAAG,SAAS,GACtB,MAAM,GAAG,SAAS,CAKpB"}

package/dist/events.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The vocabulary, re-exported from where it is now defined.
+ *
+ * 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 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.
+ *
+ * Nothing about the API moved. Every existing import keeps working, the names
+ * and their values are unchanged, and `pkgs/events/test/catalog.mjs` fails the
+ * build if a name and its meaning ever disagree.
+ *
+ * The naming convention lives with the names, in @hanzo/events and TAXONOMY.md:
+ * snake_case `<object>_<verb-past>`, a dimension is a PROPERTY and never part
+ * of the name, one name per user-visible moment shared by every surface.
+ */
+export { EVENTS, PAGEVIEW, EXCEPTION } from '@hanzo/events';
+export type { EventName } from '@hanzo/events';
+//# sourceMappingURL=events.d.ts.map

package/dist/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../src/events.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC3D,YAAY,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA"}

package/dist/exception.d.ts

@@ -0,0 +1,50 @@
+import type { ExceptionEntry, ExceptionProperties, SentryLevel } from './types';
+/**
+ * digest is a stable 32-hex-char (128-bit) content hash, computed synchronously.
+ *
+ * Grouping keys are needed on the capture path, which is synchronous and may be
+ * running inside an unload handler — SubtleCrypto is async and unavailable on
+ * insecure origins, so it cannot be used here. This is FNV-1a run over four seeds
+ * and concatenated. It is a GROUPING key, never a security boundary: it is not
+ * collision-resistant against a chosen-input adversary, and nothing authorizes or
+ * authenticates on it. The product treats the value as opaque.
+ */
+export declare function digest(s: string): string;
+/**
+ * exceptionEntry builds the single `$exception_list` entry for a throwable.
+ *
+ * One entry, not a chain: `Error.cause` chaining is a distinct fact with its own
+ * ordering rules, and emitting it wrongly is worse than not emitting it.
+ */
+export declare function exceptionEntry(err: unknown, opts: {
+    handled: boolean;
+    id: string;
+}): ExceptionEntry;
+/**
+ * fingerprint is the issue grouping key.
+ *
+ * Keyed on exception type plus each in-app frame's function and source — the same
+ * pieces the server-side grouper records ("Exception Type", "Resolved function
+ * name", "Source file name"). Deliberately NOT the message: `Loading chunk 3324
+ * failed` and `Loading chunk 998 failed` are one bug, and grouping on message is
+ * precisely the mistake that made every distinct error string its own event name.
+ *
+ * Falls back to the type alone when no in-app frame survived, which keeps
+ * stackless errors (`Script error.`, cross-origin) in one issue instead of
+ * scattering them.
+ */
+export declare function fingerprint(entry: ExceptionEntry): string;
+/**
+ * exceptionProperties builds the full `$exception_*` property bag for one captured
+ * throwable — everything Error Tracking reads off the event.
+ *
+ * The denormalized arrays are ordered like `frames`: last element is the throw
+ * site, which is the element the issue list indexes at -1 for its source/function
+ * columns.
+ */
+export declare function exceptionProperties(err: unknown, opts: {
+    handled: boolean;
+    id: string;
+    level?: SentryLevel;
+}): ExceptionProperties;
+//# sourceMappingURL=exception.d.ts.map

package/dist/exception.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exception.d.ts","sourceRoot":"","sources":["../src/exception.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EACV,cAAc,EAEd,mBAAmB,EAEnB,WAAW,EACZ,MAAM,SAAS,CAAA;AAQhB;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAYxC;AA6CD;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GACrC,cAAc,CAqBhB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAMzD;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,OAAO,EACZ,IAAI,EAAE;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,WAAW,CAAA;CAAE,GAC1D,mBAAmB,CAsBrB"}

package/dist/funnels.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The funnel registry, re-exported from where it is now defined.
+ *
+ * The funnels moved to @hanzo/events for the reason the names did: the read lens
+ * is Go and cannot import TypeScript, and that package already writes its data
+ * out as JSON. Defining a funnel beside the vocabulary also makes the anti-drift
+ * check local — a step naming an event that does not exist is caught where both
+ * are declared.
+ *
+ * Nothing about the API moved. Every existing import keeps working.
+ */
+export { FUNNELS, PRODUCTS, eventsOf } from '@hanzo/events';
+export type { FunnelDef, FunnelStep, FunnelId, ProductId } from '@hanzo/events';
+//# sourceMappingURL=funnels.d.ts.map

package/dist/funnels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"funnels.d.ts","sourceRoot":"","sources":["../src/funnels.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAC3D,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA"}

package/dist/goals.d.ts

@@ -0,0 +1,24 @@
+import { type FunnelId } from './funnels';
+export interface GoalDef {
+    /** Human label shown in Insights. */
+    label: string;
+    /** The event whose occurrence counts as the goal conversion. */
+    event: string;
+    /** The funnel leading to the goal — an id into FUNNELS (see funnels.ts). */
+    funnelId?: FunnelId;
+    /** The ordered event names of `funnelId`, derived — never hand-written. */
+    funnel?: string[];
+    /** Optional property equality filter that qualifies the conversion. */
+    filter?: {
+        property: string;
+        equals: string;
+    };
+}
+export declare const GOALS: Record<'signup' | 'sale' | 'upgradeIntent' | 'activation', GoalDef>;
+export interface CohortDef {
+    /** The hanzo.events column the cohort dimension maps to. */
+    field: string;
+    label: string;
+}
+export declare const COHORTS: Record<'signupWeek' | 'channel' | 'refCode', CohortDef>;
+//# sourceMappingURL=goals.d.ts.map

package/dist/goals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"goals.d.ts","sourceRoot":"","sources":["../src/goals.ts"],"names":[],"mappings":"AAUA,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAA;AAEnD,MAAM,WAAW,OAAO;IACtB,qCAAqC;IACrC,KAAK,EAAE,MAAM,CAAA;IACb,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAA;IACb,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,QAAQ,CAAA;IACnB,2EAA2E;IAC3E,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;IACjB,uEAAuE;IACvE,MAAM,CAAC,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAA;CAC9C;AAED,eAAO,MAAM,KAAK,EAAE,MAAM,CAAC,QAAQ,GAAG,MAAM,GAAG,eAAe,GAAG,YAAY,EAAE,OAAO,CA+BrF,CAAA;AAED,MAAM,WAAW,SAAS;IACxB,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,eAAO,MAAM,OAAO,EAAE,MAAM,CAAC,YAAY,GAAG,SAAS,GAAG,SAAS,EAAE,SAAS,CAI3E,CAAA"}

package/dist/index.cjs

@@ -120,12 +120,12 @@ var ORG_DOMAIN = Object.freeze({
     "lux.fund",
     "lux.id"
   ]),
-  zoo: Object.freeze(["zoo.ngo", "zoo.network", "zoolabs.id"])
+  zoo: Object.freeze(["zoo.ngo", "zoo.network", "zoolabs.id", "zoolabs.io"])
 });
 var ORG_KEY = 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"
 });
 var PUBLISHABLE = "pk-";
 var normalize = (host) => host.trim().toLowerCase().replace(/\.$/, "").split(":")[0] ?? "";
@@ -392,7 +392,7 @@ function uuidv7Time(id) {
 }
 
 // src/version.ts
-var VERSION = "0.3.36";
+var VERSION = "0.3.37";
 
 // src/sentry.ts
 var MAX_FRAMES = 50;
@@ -862,10 +862,10 @@ var Analytics = class {
       // 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()
     };
@@ -1003,7 +1003,7 @@ var Analytics = class {
     this.cohort = mergeCohort(patch);
   }
   /** 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
@@ -1200,15 +1200,15 @@ var COHORTS = {
  *
  * The two call sites:
  *   1. src/storage.ts        — the bundled npm client; IMPORTS this file.
- *   2. hanzoai/cloud apps/analytics/tag.js — the tag the door hosts at
+ *   2. hanzoai/cloud apps/analytics/tag.js — the tag served at
  *      /v1/event.js; vendors this file and its tag.go serves the marked region
- *      with the tag as one asset, so the door holds no second copy either.
+ *      with the tag as one asset, so cloud holds no second copy either.
  *
  * (2) has no bundler and cannot import anything, which is why the chain lives in a
  * file that is plain ES5 rather than in a .ts: the region between the BEGIN and END
  * markers is COPIED VERBATIM. Keep it ES5, dependency-free, `hz`-prefixed (it is
  * spliced into other people's scopes) and unformatted — a reformat here is a diff
- * against the vendored copy. After editing, resync the door:
+ * against the vendored copy. After editing, resync that copy:
  *
  *   curl -fsSL https://unpkg.com/@hanzo/event/src/anon.js -o apps/analytics/anon.js
  */