@hanzo/event 0.3.32 → 0.3.34

package/README.md

@@ -27,29 +27,27 @@ starve the other:
 > plane is **inert**: nothing is sent, nothing throws, analytics is unaffected.
 > Assert `client.errorPlaneEnabled` if you want to know which you have.
 
-### No bundler? Use the `hz.js` tag — same client, same wire
+### No bundler? Use the hosted tag
 
 ```html
-<script async src="https://unpkg.com/@hanzo/event/hz.js"
-        data-product="hanzo.ai"
-        data-ingest-key="pk-…"
-        data-capture="1"></script>
+<script defer src="https://api.hanzo.ai/v1/event.js" data-key="pk-…"></script>
 ```
 
-> **`data-ingest-key` is required off the door's own origin**, and through
-> 0.3.11 this file could not present one at all — no header, no query. A keyed
-> static surface therefore sent UNATTRIBUTED writes, which the door refuses
-> (`401 ingest_key_required`) silently, because nothing here reads the response.
-> The tag measured fine in the browser and filed nothing. It now rides
-> `Authorization: Bearer pk-…` on fetch and `?ingest_key=pk-…` on a headerless
-> unload beacon — the same pair the npm client uses.
-
-`hz.js` (in this package) is the **script-tag distribution** of this client, for
-surfaces with no build step. It posts the SAME `{ batch: [WireEvent, …] }` to the
-SAME `POST {host}/v1/event`, and adds DOM **autocapture** — `$click` (with an
-element locator), `$outbound`, `$scroll`, `$form`, `$vitals` — which a bundled app
-does not need and a plain page cannot get. Manual API: `window.hanzo.track()` /
-`identify()` / `page()`.
+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
+it posts to. It adds DOM **autocapture** — `$click` (with an element locator),
+`$outbound`, `$scroll`, `$form`, `$vitals` — which a bundled app does not need and
+a plain page cannot get, and it carries the site's tag config from `/v1/tags`, so a
+pixel is configured on the project rather than pasted into the page.
+
+> **`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
+> keyless tag measures fine in the browser and files nothing. Mint one with
+> `POST /v1/keys {"type":"publishable"}`.
+
+This package is the client for a surface that **builds**. There is no second
+script-tag distribution here: one wire, one door, 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

package/dist/index.cjs

@@ -91,6 +91,56 @@ function dsnForProduct(product, key) {
   return `https://${key}@api.hanzo.ai/v1/event/${projectId}`;
 }
 
+// src/org.ts
+var ORG_DOMAIN = Object.freeze({
+  hanzo: Object.freeze(["hanzo.ai", "hanzo.app", "hanzo.chat", "hanzo.id", "hanzo.bot", "hanzo.sh"]),
+  lux: Object.freeze([
+    "lux.network",
+    "lux.exchange",
+    "lux.market",
+    "lux.finance",
+    "lux.financial",
+    "lux.credit",
+    "lux.fund",
+    "lux.id"
+  ]),
+  zoo: Object.freeze(["zoo.ngo", "zoo.network", "zoolabs.id"])
+});
+var ORG_KEY = Object.freeze({
+  hanzo: "pk-rM_CdaF2MQckGCrla113SrR1oH4zvqN8xh2I95Z9tY8",
+  lux: "pk-gUZp6ZVfhJzSwK-rb4oLbVkpCnMBx5uSCpxf_5yEhQk",
+  zoo: "pk-3TKpKnERV9AQSsBUERWkZejC1O1mUxc1jRzsP3MPbs4"
+});
+var PUBLISHABLE = "pk-";
+var normalize = (host) => host.trim().toLowerCase().replace(/\.$/, "").split(":")[0] ?? "";
+function orgOf(host) {
+  const h = normalize(host);
+  if (!h) return void 0;
+  let best;
+  let bestLen = 0;
+  for (const [org, domains] of Object.entries(ORG_DOMAIN)) {
+    for (const d of domains) {
+      if ((h === d || h.endsWith(`.${d}`)) && d.length > bestLen) {
+        best = org;
+        bestLen = d.length;
+      }
+    }
+  }
+  return best;
+}
+function keyFor(host, keyring = ORG_KEY) {
+  const org = orgOf(host);
+  if (!org) return void 0;
+  const key = keyring[org];
+  if (typeof key !== "string") return void 0;
+  const trimmed = key.trim();
+  return trimmed.startsWith(PUBLISHABLE) ? trimmed : void 0;
+}
+function keyForPage(keyring = ORG_KEY) {
+  if (typeof location === "undefined") return void 0;
+  return keyFor(location.hostname, keyring);
+}
+
 // src/scrub.ts
 var REDACTED = "[redacted]";
 var EMAIL_MARK = "[email]";
@@ -212,8 +262,8 @@ function scrubText(s, capturePII = false) {
 }
 
 // src/anon.js
-var HZ_ANON_KEY = "hz_anon_id";
-var HZ_ANON_LEGACY_KEY = "hz_id";
+var HZ_ANON_KEY = "iam-anon-id";
+var HZ_ANON_ADOPT = ["hz_anon_id", "hz_id"];
 var HZ_ANON_DOMAIN = "hanzo.ai";
 var HZ_ANON_MAX_AGE = 2 * 365 * 24 * 60 * 60;
 var hzAnonMemo;
@@ -300,10 +350,17 @@ function hzAnonWrite(name, value) {
   } catch (e) {
   }
 }
+function hzAnonAdopted(s) {
+  for (var i = 0; i < HZ_ANON_ADOPT.length; i++) {
+    var id = hzAnonCookie(HZ_ANON_ADOPT[i]) || hzAnonItem(s, HZ_ANON_ADOPT[i]);
+    if (id) return id;
+  }
+  return "";
+}
 function hzAnonId() {
   if (typeof window === "undefined") return "";
   var s = hzAnonStore();
-  var id = hzAnonCookie(HZ_ANON_KEY) || hzAnonItem(s, HZ_ANON_KEY) || hzAnonItem(s, HZ_ANON_LEGACY_KEY) || hzAnonMemo || hzUuidv7();
+  var id = hzAnonCookie(HZ_ANON_KEY) || hzAnonItem(s, HZ_ANON_KEY) || hzAnonAdopted(s) || hzAnonMemo || hzUuidv7();
   hzAnonMemo = id;
   hzAnonWrite(HZ_ANON_KEY, id);
   try {
@@ -319,7 +376,7 @@ function uuidv7Time(id) {
 }
 
 // src/version.ts
-var VERSION = "0.3.32";
+var VERSION = "0.3.34";
 
 // src/sentry.ts
 var MAX_FRAMES = 50;
@@ -781,12 +838,20 @@ var Analytics = class {
       //      carries end to end — KMS `deploy/PUBLISHABLE_KEY` -> the PUBLISHABLE_KEY
       //      build-arg -> the NEXT_PUBLIC_ prefix Next inlines.
       //
-      // A surface that provides neither has no key, and its anonymous traffic
-      // files under `$public` (which drops track/identify/group and answers 200);
-      // the fix is to give it the KMS-sourced env, not to hardcode the org key
-      // here. The key is a credential-class value: its home is KMS, and the ONE
-      // build reads it from there.
-      ingestKey: config.ingestKey ?? readEnv("NEXT_PUBLIC_PUBLISHABLE_KEY")
+      //   3. the org that owns the HOST this page is served from (`org.ts`).
+      //
+      // Step 3 fires only when a surface configured NOTHING, so it never overrides
+      // the KMS chain above — it replaces going dark with reporting to the right
+      // brand. That is what a static export needs: `output: export` inlines no env,
+      // 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
+      // 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
+      // 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()
     };
     this.transport = config.transport ?? new DefaultTransport();
     this.dsn = parseDsn(
@@ -1110,26 +1175,26 @@ var COHORTS = {
   channel: { field: "channel", label: "Acquisition channel" },
   refCode: { field: "ref_code", label: "Referral code" }
 };
-/*! anon.js — THE anonymous-identity chain. ONE implementation, three distributions.
+/*! anon.js — THE anonymous-identity chain. ONE implementation, two distributions.
  *
  * One browser is ONE person on every Hanzo surface, whichever client a page
- * happens to have loaded. There were three implementations writing TWO keys —
- * `hz_anon_id` (the npm client, the hosted tag) and `hz_id` (hz.js) — so the same
- * visitor was several people depending on which snippet the surface shipped.
+ * happens to have loaded. There were once three implementations writing TWO keys —
+ * `hz_anon_id` and `hz_id` — so the same visitor was several people depending on
+ * which snippet the surface shipped.
  *
- * The three call sites:
+ * The two call sites:
  *   1. src/storage.ts        — the bundled npm client; IMPORTS this file.
- *   2. hz.js                 — the no-build script tag; INLINES the marked region.
- *   3. hanzoai/cloud apps/analytics/tag.js — the tag the door hosts at
+ *   2. hanzoai/cloud apps/analytics/tag.js — the tag the door hosts 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.
  *
- * (2) and (3) have 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, and src/anon.test.ts fails if hz.js's
- * copy is so much as a byte different. Keep the region ES5, dependency-free,
- * `hz`-prefixed (it is spliced into other people's scopes) and unformatted — a
- * reformat of one copy is a diff against the other.
+ * (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:
+ *
+ *   curl -fsSL https://unpkg.com/@hanzo/event/src/anon.js -o apps/analytics/anon.js
  */
 
 Object.defineProperty(exports, "EVENTS", {
@@ -1159,6 +1224,8 @@ Object.defineProperty(exports, "eventsOf", {
 exports.Analytics = Analytics;
 exports.COHORTS = COHORTS;
 exports.GOALS = GOALS;
+exports.ORG_DOMAIN = ORG_DOMAIN;
+exports.ORG_KEY = ORG_KEY;
 exports.PRODUCT_PROJECT = PRODUCT_PROJECT;
 exports.VERSION = VERSION;
 exports.buildEnvelope = buildEnvelope;
@@ -1176,6 +1243,9 @@ exports.getFirstTouch = getFirstTouch;
 exports.hasAttribution = hasAttribution;
 exports.hostOf = hostOf;
 exports.isoWeek = isoWeek;
+exports.keyFor = keyFor;
+exports.keyForPage = keyForPage;
+exports.orgOf = orgOf;
 exports.parseAttribution = parseAttribution;
 exports.parseDsn = parseDsn;
 exports.redactSecrets = redactSecrets;