@hanzo/event 0.3.42 → 0.3.44

package/src/link.test.ts

@@ -0,0 +1,222 @@
+// Cross-domain continuity: a link between Hanzo hosts carries the visitor, the
+// destination adopts it before its first pageview and cleans the address bar.
+
+import { describe, it, expect, vi, afterEach } from 'vitest'
+import { linkUrl, readLink, stripLink, encodeFirstTouch } from './link'
+import { keyFor, keyForPage } from './org'
+import type { Attribution, Transport, WireEvent } from './types'
+
+const AID = '01920000-0000-7000-8000-0000000000aa'
+const SID = '01920000-0000-7000-8000-0000000000bb'
+const LOCAL = '01920000-0000-7000-8000-0000000000cc'
+const FT: Attribution = {
+  utm: { source: 'x', medium: 'cpc', campaign: 'launch' },
+  refCode: 'r1',
+  referrer: 'https://t.co/abc',
+  channel: 'paid',
+}
+
+const g = globalThis as Record<string, unknown>
+
+function browser(href: string, storage: Record<string, string> = {}) {
+  const url = new URL(href)
+  const store = new Map(Object.entries(storage))
+  const jar = new Map<string, string>()
+  const replaced: string[] = []
+  const location = {
+    href: url.href,
+    hostname: url.hostname,
+    protocol: url.protocol,
+    pathname: url.pathname,
+    search: url.search,
+  }
+  g.window = {
+    location,
+    history: {
+      state: null,
+      replaceState: (_s: unknown, _t: string, next: string) => {
+        replaced.push(next)
+        const u = new URL(next, url)
+        location.href = u.href
+        location.search = u.search
+      },
+    },
+    localStorage: {
+      getItem: (k: string) => store.get(k) ?? null,
+      setItem: (k: string, v: string) => void store.set(k, v),
+    },
+    addEventListener: () => {},
+  }
+  g.document = {
+    get cookie() {
+      return [...jar].map(([k, v]) => `${k}=${v}`).join('; ')
+    },
+    set cookie(raw: string) {
+      const kv = raw.split(';')[0]
+      const eq = kv.indexOf('=')
+      jar.set(kv.slice(0, eq).trim(), kv.slice(eq + 1))
+    },
+    referrer: 'https://hanzo.ai/',
+    visibilityState: 'visible',
+  }
+  return { store, jar, replaced, location }
+}
+
+class Tx implements Transport {
+  all: WireEvent[] = []
+  send(_u: string, body: string) {
+    try {
+      this.all.push(...(JSON.parse(body) as { batch: WireEvent[] }).batch)
+    } catch {
+      /* not JSON */
+    }
+  }
+}
+
+const load = async () => {
+  vi.resetModules()
+  return await import('./core')
+}
+
+afterEach(() => {
+  delete g.window
+  delete g.document
+})
+
+describe('linkUrl', () => {
+  const state = { anonId: AID, sessionId: SID, firstTouch: FT }
+
+  it('appends id, session and first touch for Hanzo-owned hosts', () => {
+    for (const host of ['hanzo.id', 'hanzo.app', 'hanzo.team', 'hanzo.bot', 'id.lux.network', 'zoo.ngo']) {
+      const u = new URL(linkUrl(`https://${host}/login`, state, 'hanzo.ai'))
+      expect(u.searchParams.get('hz_aid')).toBe(AID)
+      expect(u.searchParams.get('hz_sid')).toBe(SID)
+      expect(readLink(u.search).firstTouch).toEqual(FT)
+    }
+  })
+
+  it('leaves foreign hosts and same-host links alone', () => {
+    expect(linkUrl('https://example.com/x', state, 'hanzo.ai')).toBe('https://example.com/x')
+    expect(linkUrl('https://hanzo.ai/x', state, 'hanzo.ai')).toBe('https://hanzo.ai/x')
+    expect(linkUrl('mailto:z@hanzo.ai', state, 'hanzo.ai')).toBe('mailto:z@hanzo.ai')
+    expect(linkUrl('https://evilhanzo.id/x', state, 'hanzo.ai')).toBe('https://evilhanzo.id/x')
+  })
+
+  it('keeps existing query and hash, and refuses a non-UUID id', () => {
+    const out = linkUrl('https://hanzo.id/login/oauth/authorize?client_id=a&x=1#h', { anonId: 'nope' }, 'hanzo.ai')
+    expect(out).toBe('https://hanzo.id/login/oauth/authorize?client_id=a&x=1#h')
+    const ok = new URL(linkUrl('https://hanzo.id/a?client_id=a#h', state, 'hanzo.ai'))
+    expect(ok.searchParams.get('client_id')).toBe('a')
+    expect(ok.hash).toBe('#h')
+  })
+
+  it('round-trips first touch and rejects garbage', () => {
+    expect(readLink('?hz_ft=' + encodeURIComponent(encodeFirstTouch(FT))).firstTouch).toEqual(FT)
+    expect(readLink('?hz_ft=%5B1%5D&hz_aid=zzz').firstTouch).toBeUndefined()
+    expect(readLink('?hz_aid=zzz').anonId).toBeUndefined()
+  })
+
+  it('stripLink removes only its own params', () => {
+    expect(stripLink(`https://hanzo.id/a?hz_aid=${AID}&keep=1&hz_sid=${SID}#f`)).toBe('/a?keep=1#f')
+    expect(stripLink('https://hanzo.id/a?keep=1')).toBeUndefined()
+  })
+})
+
+describe('Analytics adopts a link on init', () => {
+  const href = `https://hanzo.id/login?client_id=c&hz_aid=${AID}&hz_sid=${SID}&hz_ft=${encodeURIComponent(encodeFirstTouch(FT))}`
+
+  it('first pageview carries the linked ids, first touch and a clean address bar', async () => {
+    const b = browser(href, { 'iam-anon-id': LOCAL })
+    const { Analytics } = await load()
+    const tx = new Tx()
+    const a = new Analytics({ product: 't', host: '', transport: tx })
+    a.pageview()
+    a.flush()
+    const e = tx.all[0]
+    expect(e.anonymousId).toBe(AID)
+    expect(e.sessionId).toBe(SID)
+    expect(e.channel).toBe('paid')
+    expect(e.utm?.campaign).toBe('launch')
+    expect(e.url).not.toContain('hz_aid')
+    expect(b.replaced).toEqual(['/login?client_id=c'])
+    expect(b.location.search).toBe('?client_id=c')
+    expect(b.jar.get('iam-anon-id')).toBe(AID)
+    expect(b.store.get('iam-anon-id')).toBe(AID)
+  })
+
+  it('an existing first touch is not overwritten by a link', async () => {
+    browser(href, { hz_first_touch: JSON.stringify({ utm: { source: 'old' }, channel: 'organic' }) })
+    const { Analytics } = await load()
+    const tx = new Tx()
+    const a = new Analytics({ product: 't', host: '', transport: tx })
+    a.pageview()
+    a.flush()
+    expect(tx.all[0].utm?.source).toBe('old')
+    expect(tx.all[0].anonymousId).toBe(AID)
+  })
+
+  it('a link with a bad id changes nothing but is still stripped', async () => {
+    const b = browser('https://hanzo.id/x?hz_aid=evil', { 'iam-anon-id': LOCAL })
+    const { Analytics } = await load()
+    const tx = new Tx()
+    new Analytics({ product: 't', host: '', transport: tx }).pageview()
+    expect(b.replaced).toEqual(['/x'])
+    expect(b.store.get('iam-anon-id')).toBe(LOCAL)
+  })
+})
+
+describe('Analytics.link / authorize / identify', () => {
+  it('link decorates an IAM authorize URL with the current visitor', async () => {
+    browser('https://hanzo.ai/chat?utm_source=news', { 'iam-anon-id': LOCAL })
+    const { Analytics } = await load()
+    const a = new Analytics({ product: 't', host: '', transport: new Tx() })
+    const u = new URL(a.link('https://hanzo.id/login/oauth/authorize?client_id=c&state=s'))
+    expect(u.searchParams.get('client_id')).toBe('c')
+    expect(u.searchParams.get('hz_aid')).toBe(LOCAL)
+    expect(u.searchParams.get('hz_sid')).toMatch(/^[0-9a-f-]{36}$/)
+    expect(readLink(u.search).firstTouch?.utm.source).toBe('news')
+    expect(a.link('https://example.com/x')).toBe('https://example.com/x')
+  })
+
+  it('authorize decorates and flushes what is queued before unload', async () => {
+    browser('https://hanzo.ai/chat', { 'iam-anon-id': LOCAL })
+    const { Analytics } = await load()
+    const tx = new Tx()
+    const a = new Analytics({ product: 't', host: '', transport: tx, flushIntervalMs: 999999 })
+    a.capture('chat_started')
+    const out = a.authorize('https://hanzo.id/login/oauth/authorize?client_id=c')
+    expect(out).toContain('hz_aid=' + LOCAL)
+    expect(tx.all.map((e) => e.event)).toEqual(['chat_started'])
+  })
+
+  it('identify emits the anonymous id and the person id together', async () => {
+    browser('https://hanzo.ai/', { 'iam-anon-id': LOCAL })
+    const { Analytics } = await load()
+    const tx = new Tx()
+    const a = new Analytics({ product: 't', host: '', transport: tx })
+    a.identify('person-1')
+    a.flush()
+    const e = tx.all[0]
+    expect(e.type).toBe('identify')
+    expect(e.anonymousId).toBe(LOCAL)
+    expect(e.personId).toBe('person-1')
+    expect(e.distinctId).toBe('person-1')
+  })
+})
+
+describe('one ingest key across the journey', () => {
+  it('hanzo.ai, hanzo.id, hanzo.app resolve to the same org key', () => {
+    const k = keyFor('hanzo.ai')
+    expect(k).toBeTruthy()
+    for (const h of ['www.hanzo.ai', 'hanzo.id', 'hanzo.app', 'hanzo.team', 'hanzo.bot']) expect(keyFor(h)).toBe(k)
+    const ring = { hanzo: 'pk-runtime' }
+    expect(keyFor('hanzo.id', ring)).toBe(keyFor('hanzo.ai', ring))
+  })
+
+  it('keyForPage on either host names the same project', () => {
+    browser('https://hanzo.id/login')
+    const id = keyForPage()
+    browser('https://hanzo.ai/')
+    expect(keyForPage()).toBe(id)
+  })
+})

package/src/link.ts

@@ -0,0 +1,103 @@
+// Cross-domain visitor continuity.
+//
+// Cookies and localStorage stop at the registrable domain, so a visitor who goes
+// hanzo.ai -> hanzo.id (sign-in) -> back arrived as separate people on each host, and
+// the journey across the sign-in redirect could not be read. A link between two
+// Hanzo hosts therefore carries the visitor's identity in three short query
+// parameters, and the destination adopts them before its first pageview and
+// removes them from the address bar.
+//
+//   hz_aid  anonymous id      hz_sid  session id      hz_ft  first-touch attribution
+//
+// They are appended ONLY when the destination host belongs to a brand in ORG_DOMAIN:
+// an id handed to a host outside the table would be handed to a stranger.
+
+import { orgOf } from './org'
+import type { Attribution } from './types'
+
+export const LINK_PARAMS = { anon: 'hz_aid', session: 'hz_sid', firstTouch: 'hz_ft' } as const
+
+/** Ids are v7 UUIDs; anything else in a URL is someone else's input and is refused. */
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+export const isId = (v: string | null | undefined): v is string => !!v && UUID.test(v)
+
+/** What a link carries. Any field may be absent. */
+export interface LinkState {
+  anonId?: string
+  sessionId?: string
+  firstTouch?: Attribution
+}
+
+/** First touch as a compact tuple: utm source, medium, campaign, term, content, refCode,
+ *  referrer, channel. Short because it rides a URL; a tuple because keys cost bytes. */
+export function encodeFirstTouch(a: Attribution): string {
+  return JSON.stringify([
+    a.utm.source, a.utm.medium, a.utm.campaign, a.utm.term, a.utm.content,
+    a.refCode, a.referrer, a.channel,
+  ].map((v) => v ?? ''))
+}
+
+export function decodeFirstTouch(raw: string | null | undefined): Attribution | undefined {
+  if (!raw || raw.length > 1024) return undefined
+  try {
+    const t: unknown = JSON.parse(raw)
+    if (!Array.isArray(t) || t.length !== 8 || t.some((v) => typeof v !== 'string')) return undefined
+    const [source, medium, campaign, term, content, refCode, referrer, channel] = t as string[]
+    const u = (v: string) => v || undefined
+    return {
+      utm: { source: u(source), medium: u(medium), campaign: u(campaign), term: u(term), content: u(content) },
+      refCode: u(refCode),
+      referrer: u(referrer),
+      channel: u(channel),
+    }
+  } catch {
+    return undefined
+  }
+}
+
+/** linkUrl returns `url` with the visitor's identity appended when its host is
+ *  Hanzo-owned and is not `fromHost`; otherwise `url` unchanged. Relative URLs
+ *  resolve against `base`. Never throws. */
+export function linkUrl(url: string, state: LinkState, fromHost: string, base?: string): string {
+  let u: URL
+  try {
+    u = new URL(url, base)
+  } catch {
+    return url
+  }
+  if (u.protocol !== 'https:' && u.protocol !== 'http:') return url
+  if (!orgOf(u.hostname) || u.hostname === fromHost) return url
+  const set = (k: string, v: string | undefined) => v && u.searchParams.set(k, v)
+  if (isId(state.anonId)) set(LINK_PARAMS.anon, state.anonId)
+  if (isId(state.sessionId)) set(LINK_PARAMS.session, state.sessionId)
+  if (state.firstTouch) set(LINK_PARAMS.firstTouch, encodeFirstTouch(state.firstTouch))
+  return u.toString()
+}
+
+/** readLink parses what a link carried out of a location.search value. Invalid
+ *  values are dropped, not repaired. */
+export function readLink(search: string): LinkState {
+  const q = new URLSearchParams(search || '')
+  const a = q.get(LINK_PARAMS.anon)
+  const s = q.get(LINK_PARAMS.session)
+  return {
+    anonId: isId(a) ? a : undefined,
+    sessionId: isId(s) ? s : undefined,
+    firstTouch: decodeFirstTouch(q.get(LINK_PARAMS.firstTouch)),
+  }
+}
+
+/** stripLink returns the path, query and hash of `href` without the link parameters, or
+ *  undefined when there were none. */
+export function stripLink(href: string): string | undefined {
+  const u = new URL(href)
+  let hit = false
+  for (const k of Object.values(LINK_PARAMS)) {
+    if (u.searchParams.has(k)) {
+      u.searchParams.delete(k)
+      hit = true
+    }
+  }
+  return hit ? u.pathname + u.search + u.hash : undefined
+}

package/src/storage.ts

@@ -6,7 +6,7 @@
 // the one value the OTHER two distributions must agree with, so its chain lives in
 // ./anon.js and this file only calls it. Everything else here stays origin-local.
 
-import { hzAnonId } from './anon.js'
+import { hzAnonAdopt, hzAnonId } from './anon.js'
 import type { Attribution, Cohort } from './types'
 import { uuidv7 } from './uid'
 
@@ -75,6 +75,19 @@ export function sessionId(now = Date.now()): string | undefined {
   return state.id
 }
 
+/** Make `id` the current session, as if it had begun now. The session a link
+ *  carries is the one the visitor is already in, so the journey stays one session
+ *  across the hop instead of splitting at the host boundary. */
+export function adoptSession(id: string, now = Date.now()): void {
+  const s = ls()
+  if (s) s.setItem(KEY.session, JSON.stringify({ id, last: now }))
+}
+
+/** Make `id` the browser's anonymous id, replacing the one it held. */
+export function adoptAnonId(id: string): void {
+  hzAnonAdopt(id)
+}
+
 /** Read the persisted first-touch attribution. */
 export function getFirstTouch(): Attribution | undefined {
   const s = ls()

package/src/tags.test.ts

@@ -0,0 +1,187 @@
+// The tag manager: nothing loads before consent, everything loads after, and an
+// event reaches each platform under one id and the names the platform table gives.
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const g = globalThis as Record<string, unknown>
+const original = {
+  navigator: Object.getOwnPropertyDescriptor(globalThis, 'navigator'),
+  Intl: Object.getOwnPropertyDescriptor(globalThis, 'Intl'),
+}
+const put = (k: string, value: unknown) => Object.defineProperty(globalThis, k, { value, configurable: true, writable: true })
+
+const TAGS = {
+  tags: [
+    { platform: 'ga4', type: 'ga', id: 'G-TEST' },
+    { platform: 'google-ads', type: 'gads', id: 'AW-1', events: { order_completed: 'AW-1/abc' } },
+    { platform: 'meta', type: 'meta', id: '111' },
+    { platform: 'linkedin', type: 'linkedin', id: '555', events: { order_completed: '9876' } },
+    { platform: 'x', type: 'x', id: 'o1abc', events: { order_completed: 'tw-o1abc-buy' } },
+    { platform: 'tiktok', type: 'tiktok', id: 'TT1' },
+  ],
+}
+
+function browser(zone: string, jar = new Map<string, string>()) {
+  const scripts: string[] = []
+  const listeners = new Map<string, Array<() => void>>()
+  const requests: string[] = []
+  put('navigator', { globalPrivacyControl: false, userAgent: 'UA' })
+  put('Intl', { DateTimeFormat: () => ({ resolvedOptions: () => ({ timeZone: zone }) }) })
+  g.Event = class {
+    constructor(public type: string) {}
+  }
+  g.window = {
+    location: { hostname: 'hanzo.ai', protocol: 'https:', search: '', href: 'https://hanzo.ai/' },
+    dispatchEvent: (e: { type: string }) => listeners.get(e.type)?.forEach((f) => f()),
+    addEventListener: (t: string, f: () => void) => listeners.set(t, [...(listeners.get(t) ?? []), f]),
+    removeEventListener: () => undefined,
+  }
+  g.addEventListener = (g.window as { addEventListener: unknown }).addEventListener
+  g.removeEventListener = () => undefined
+  g.document = {
+    get cookie() {
+      return [...jar].map(([k, v]) => `${k}=${encodeURIComponent(v)}`).join('; ')
+    },
+    set cookie(line: string) {
+      const [pair] = line.split(';')
+      const i = pair.indexOf('=')
+      jar.set(pair.slice(0, i), decodeURIComponent(pair.slice(i + 1)))
+    },
+    createElement: () => ({}) as Record<string, unknown>,
+    head: { appendChild: (s: { src: string; onload?: () => void }) => (scripts.push(s.src), setTimeout(() => s.onload?.(), 0)) },
+  }
+  put('fetch', async (url: string) => {
+    requests.push(url)
+    return { ok: true, json: async () => TAGS }
+  })
+  let n = 0
+  put('crypto', { randomUUID: () => `id-${++n}` })
+  return { jar, scripts, requests }
+}
+
+beforeEach(() => vi.resetModules())
+afterEach(() => {
+  for (const k of ['window', 'document', 'Event', 'addEventListener', 'removeEventListener', 'fetch', 'crypto']) delete g[k]
+  for (const [k, d] of Object.entries(original)) if (d) Object.defineProperty(globalThis, k, d)
+})
+
+const tick = () => new Promise((r) => setTimeout(r, 10))
+
+describe('before consent', () => {
+  it('an EU visitor makes no request to any platform', async () => {
+    const b = browser('Europe/Berlin')
+    const { startTags } = await import('./index')
+    startTags({ key: 'pk-x' })
+    await tick()
+    expect(b.requests).toHaveLength(1)
+    expect(b.requests[0]).toContain('/v1/project/tags')
+    expect(b.scripts).toEqual([])
+  })
+
+  it('a US visitor is presumed to allow, and every tag loads', async () => {
+    const b = browser('America/New_York')
+    const { startTags } = await import('./index')
+    startTags({ key: 'pk-x' })
+    await tick()
+    expect(b.scripts.map((s) => new URL(s).hostname).sort()).toEqual(
+      ['analytics.tiktok.com', 'connect.facebook.net', 'snap.licdn.com', 'static.ads-twitter.com', 'www.googletagmanager.com'].sort(),
+    )
+  })
+})
+
+describe('after accepting', () => {
+  it('loads Google, Meta, LinkedIn, X and TikTok with no reload', async () => {
+    const b = browser('Europe/Berlin')
+    const { startTags, acceptAll } = await import('./index')
+    startTags({ key: 'pk-x' })
+    await tick()
+    acceptAll()
+    await tick()
+    expect(b.scripts).toHaveLength(5)
+  })
+
+  it('sets Consent Mode v2 denied before any Google script, then updates it', async () => {
+    const b = browser('Europe/Berlin')
+    const { startTags, acceptAll } = await import('./index')
+    startTags({ key: 'pk-x' })
+    await tick()
+    expect(b.scripts).toEqual([])
+    acceptAll()
+    await tick()
+    const layer = (g.window as { dataLayer: IArguments[] }).dataLayer.map((a) => Array.from(a))
+    const dflt = layer.findIndex((a) => a[0] === 'consent' && a[1] === 'default')
+    const js = layer.findIndex((a) => a[0] === 'js')
+    expect(dflt).toBeGreaterThanOrEqual(0)
+    expect(dflt).toBeLessThan(js)
+    expect(layer[dflt][2]).toMatchObject({ analytics_storage: 'denied', ad_storage: 'denied', ad_user_data: 'denied', ad_personalization: 'denied' })
+    const update = layer.find((a) => a[0] === 'consent' && a[1] === 'update')
+    expect(update?.[2]).toMatchObject({ analytics_storage: 'granted', ad_storage: 'granted', ad_user_data: 'granted', ad_personalization: 'granted' })
+  })
+
+  it('analytics alone loads only Google, cookieless for ads', async () => {
+    const b = browser('Europe/Berlin')
+    const { startTags, saveConsent } = await import('./index')
+    startTags({ key: 'pk-x' })
+    await tick()
+    saveConsent({ analytics: true, marketing: false, ads: false })
+    await tick()
+    expect(b.scripts.map((s) => new URL(s).hostname)).toEqual(['www.googletagmanager.com'])
+  })
+})
+
+describe('one event, every tag', () => {
+  it('sends purchase under one id to each platform, with the names the table gives', async () => {
+    browser('America/New_York')
+    const { startTags, track } = await import('./index')
+    const captured: Array<{ name: string; props: Record<string, unknown> }> = []
+    startTags({ key: 'pk-x' })
+    await tick()
+    const w = g.window as unknown as Record<string, unknown>
+    const gtag: unknown[][] = []
+    const fbq: unknown[][] = []
+    const ttq: unknown[][] = []
+    const twq: unknown[][] = []
+    const lintrk: unknown[][] = []
+    w.gtag = (...a: unknown[]) => gtag.push(a)
+    w.fbq = (...a: unknown[]) => fbq.push(a)
+    w.ttq = { track: (...a: unknown[]) => ttq.push(a) }
+    w.twq = (...a: unknown[]) => twq.push(a)
+    w.lintrk = (...a: unknown[]) => lintrk.push(a)
+    const items = [{ item_id: 'dev', item_name: 'Dev', price: 19, quantity: 1 }]
+    track({ capture: (name: string, props: Record<string, unknown>) => captured.push({ name, props }) } as never, 'order_completed', {
+      order_id: 'ord-1', value: 19, currency: 'USD', items,
+    })
+    await tick()
+
+    expect(captured).toHaveLength(1)
+    const id = captured[0].props.event_id
+    expect(id).toBe('id-1')
+    expect(String(captured[0].props.tags).split(',').sort()).toEqual(['ga', 'gads', 'linkedin', 'meta', 'tiktok', 'x'])
+
+    const ga = gtag.find((a) => a[0] === 'event' && a[1] === 'purchase')
+    expect(ga?.[2]).toMatchObject({ transaction_id: 'ord-1', event_id: id, items, value: 19 })
+    expect(gtag.find((a) => a[1] === 'conversion')?.[2]).toMatchObject({ send_to: 'AW-1/abc', value: 19 })
+    expect(fbq.map((a) => [a[0], a[1], (a[3] as { eventID: string }).eventID])).toEqual([
+      ['track', 'Purchase', id],
+      ['track', 'Subscribe', id],
+    ])
+    expect(ttq[0][0]).toBe('CompletePayment')
+    expect(ttq[0][2]).toEqual({ event_id: id })
+    expect(twq[0][1]).toBe('tw-o1abc-buy')
+    expect(lintrk[0]).toEqual(['track', { conversion_id: 9876 }])
+  })
+
+  it('a test order is debug traffic', async () => {
+    browser('America/New_York')
+    const { startTags, mirror } = await import('./index')
+    startTags({ key: 'pk-x' })
+    await tick()
+    const w = g.window as unknown as Record<string, unknown>
+    const gtag: unknown[][] = []
+    w.gtag = (...a: unknown[]) => gtag.push(a)
+    mirror('order_completed', { test: true, order_id: 'o', value: 19, items: [{ item_id: 'dev', price: 19 }] }, 'id-9', 'ga')
+    const sent = gtag.find((a) => a[1] === 'purchase')?.[2] as { value: number; items: Array<{ price: number }> }
+    expect(sent).toMatchObject({ debug_mode: true, value: 0 })
+    expect(sent.items[0].price).toBe(0)
+  })
+})