@hanzo/event 0.3.36 → 0.3.37

package/dist/org.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Which org owns a host's telemetry.
+ *
+ * A surface should not have to LEARN its key. It already knows the domain it is
+ * served from, and a domain belongs to exactly one brand, so the key is derivable
+ * and asking a surface to carry one is asking it to restate something already
+ * true. This module answers `orgOf(location.hostname)` and hands back that org's
+ * publishable key, which is what lets a static export report correctly while
+ * configuring nothing.
+ *
+ * This is the SAME question `hanzo.id` answers at runtime for the identity hosts
+ * (`pkgs/shared/src/ingest.ts`): one image serves every brand, so the key cannot
+ * be a property of the build. It was, and the bill is on record — Lux's, Zoo's,
+ * Osage's and Pars' visitors were all filed in HANZO's project, because one
+ * build-time key was inlined for every brand. That is the white-label boundary
+ * crossed in the direction that shows up latest. The marketing sites carry the
+ * identical defect in its other form: each commits its OWN key literal, so the
+ * fleet holds N copies of a value with one source, and a site added tomorrow
+ * reports nothing until somebody remembers to paste one in.
+ *
+ * A `pk-` is PUBLISHABLE: it authorizes a write into one org and mints no reading
+ * principal. It is readable in devtools on every deployed page that sends an
+ * event, so stating it here exposes nothing that serving the page did not. What
+ * it does buy is that correct attribution becomes the DEFAULT rather than
+ * something each surface opts into.
+ *
+ * Keyed by ORG, never by host: a brand's facts repeat on every alias it owns
+ * (`lux.id`, `id.lux.network`), and a key stated per host would have to be
+ * repeated too — so the day someone adds an alias and forgets the key, that host
+ * silently stops reporting. Stated once per org, a new alias inherits its brand's
+ * key by naming its brand's domain, which is all an alias ever says.
+ */
+/** One publishable key per org. */
+export type Keyring = Readonly<Record<string, string>>;
+/**
+ * Each org's registrable domains. A host matches a domain when it IS that domain
+ * or a subdomain of it, so `explore.lux.network` needs no entry of its own.
+ *
+ * An org absent from this table resolves to undefined, and that is deliberate:
+ * `osage`, `pars` and `bootnode` have no project of their own yet, and reporting
+ * NOTHING is the honest answer. Filing them under a brand that is not theirs is
+ * the defect this module exists to prevent — it is silent, it reads as working,
+ * and it is only visible later in someone else's warehouse.
+ */
+export declare const ORG_DOMAIN: Readonly<Record<string, readonly string[]>>;
+/**
+ * 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.
+ */
+export declare const ORG_KEY: Keyring;
+/**
+ * The org that owns a host, or undefined when no brand claims it.
+ *
+ * Longest match wins, so a brand owning both a domain and a subdomain of another
+ * brand's cannot be decided by table order. Pure and total.
+ */
+export declare function orgOf(host: string): string | undefined;
+/**
+ * The publishable key for a host, or undefined when there is not exactly one to
+ * give.
+ *
+ * Deliberately WITHOUT a fallback: returning Hanzo's key for an unrecognised host
+ * is precisely the defect described above. Undefined is the honest answer and the
+ * caller reports nothing.
+ *
+ * `keyring` is a parameter so the identity runtime — which receives its keyring
+ * from `/config.json` because one image serves every brand — resolves through
+ * this SAME function rather than a second copy of it.
+ */
+export declare function keyFor(host: string, keyring?: Keyring): string | undefined;
+/** The key for the page this code is running on; undefined off a browser. */
+export declare function keyForPage(keyring?: Keyring): string | undefined;
+//# sourceMappingURL=org.d.ts.map

package/dist/org.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"org.d.ts","sourceRoot":"","sources":["../src/org.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,mCAAmC;AACnC,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;AAEtD;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA6BjE,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,OAAO,EAAE,OAIpB,CAAA;AAWF;;;;;GAKG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CActD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,GAAE,OAAiB,GAAG,MAAM,GAAG,SAAS,CAOnF;AAED,6EAA6E;AAC7E,wBAAgB,UAAU,CAAC,OAAO,GAAE,OAAiB,GAAG,MAAM,GAAG,SAAS,CAGzE"}

package/dist/react.cjs

@@ -382,7 +382,7 @@ function hzAnonId() {
 }
 
 // src/version.ts
-var VERSION = "0.3.36";
+var VERSION = "0.3.37";
 
 // src/sentry.ts
 var MAX_FRAMES = 50;
@@ -852,10 +852,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()
     };
@@ -993,7 +993,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
@@ -1206,15 +1206,15 @@ ErrorBoundary.contextType = Ctx;
  *
  * 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
  */