Files
zeekay 75d32ffea4 observe: a page view reports its engaged time as $pageleave; replay compresses what would not fit
@hanzo/observe 0.1.15 times every page view: active milliseconds (visible,
focused, input in the last 60 s), each watched section's time in view, the
furthest scroll and the share of the page it showed, and the load's web vitals.
It reports in segments, when the page is hidden, unloaded, routed away from or
the engine stops, so the time on a view is the sum of $active_ms over its
$view_id and a phone that never fires pagehide still reports. A hidden or
unloaded page's segment goes at once by beacon; a route change's is filed under
the page left. deliver() is the one delivery every binding makes (React,
Svelte, Tauri).

@hanzo/event 0.3.64: capture() takes the page an event belongs to.

@hanzo/replay 0.1.4 gzips a full snapshot, and any mutation or style rule over
4 KiB, in the cv 2024-10 encoding the insights player decodes. The landing's
snapshot is 1.32 MB raw and was refused by the 512 KiB ingest; it now goes as
314 KB. /pricing, 541 KB raw, goes as 167 KB. The privacy tests read payloads as
the player does, so an absence cannot pass for being compressed.

The observe family names its siblings workspace:^ so a release of one is built
against the other.
2026-10-30 06:51:25 -07:00
..
2026-09-08 23:50:28 -07:00

@hanzo/observe-native

Native + desktop binding for @hanzo/observe. Makes @hanzo/gui (Tamagui) / React Native apps and Tauri desktop emit the same canonical Events as the web — same semantic hierarchy, same privacy gate, same ONE entry point (POST /v1/event via @hanzo/event).

Native has no DOM to walk, so the semantic hierarchy is composed from explicit per-element meta and the surrounding ObserveScope stack — the native equivalent of the web's DOM ancestry, auto-derived from the React tree.

Tamagui / React Native

import { createAnalytics } from '@hanzo/event'
import { ObserveProvider, ObserveScope, useObserve } from '@hanzo/observe-native'

function App() {
  return (
    <ObserveProvider client={createAnalytics({ product: 'app' })}>
      <ObserveScope name="Dashboard">
        <ObserveScope name="UserCard">
          <UserCard />
        </ObserveScope>
      </ObserveScope>
    </ObserveProvider>
  )
}

function UserCard() {
  const o = useObserve()
  return (
    <>
      <Button onPress={o.press('SaveButton', save)} />          {/* Dashboard/UserCard/SaveButton */}
      <Input onChangeText={o.changeText('email', setEmail)} />  {/* value redacted */}
    </>
  )
}

press wraps onPress, changeText wraps onChangeText (RN/Tamagui props) — the interaction is captured, then your handler runs. o.event(name) and o.screen(name) cover custom events and screen views. useEventStream() gives the live rolling window for session playback, same as the web.

Tauri desktop

A Tauri window is a webview, so the DOM lives — bindTauri runs the @hanzo/observe DOM engine to capture the in-webview UI exactly like the web, and forwards Tauri's native window/app events. The /tauri entry is React-free:

import { createAnalytics } from '@hanzo/event'
import { bindTauri } from '@hanzo/observe-native/tauri'

const bridge = bindTauri(createAnalytics({ product: 'desktop' }))
// … later
bridge.stop()

@tauri-apps/api is an optional peer loaded at runtime; calling bindTauri outside a Tauri runtime is safe (the native bridge no-ops, DOM capture still runs in any webview).

Privacy

Identical policy to the web, via the shared @hanzo/observe primitives: input values are withheld by default, sensitive fields (password / email / card / …) are always redacted, and everything is fail-soft. Pass redaction={{ … }} on ObserveProvider (or bindTauri) to tune it.

Same wire, everywhere

A native tap and a web click produce the identical event shape ($click, $el, $path, $component, $value, …) because both go through the one wireProps projection in @hanzo/observe. One vocabulary across web, mobile, and desktop.

License

MIT © Hanzo AI — see LICENSE.md. HIP-0137 (hanzoai/hips).