@wireai/activation 0.13.0 → 0.13.2

package/AGENTS.md

@@ -48,6 +48,7 @@ subpaths are optional secondary feature modules; import one only if you use it.
 - `themeFromBrand({ primary })`: derive a full theme from one brand color.
 - `mergeTheme`, `defaultOnboardingTheme`, `OnboardingThemeProvider`, `useOnboardingTheme`.
 - `defaultIllustrations`: dependency-free fallback art; spread your own over it.
+- `WIRE_PERMISSION_EVENTS`, `resolvePermissionCopy(...)`: the canonical permission-funnel names and the shipped rationale copy behind `permissionScreens` (see the prop below). The kit imports no native permission module; the host injects `request`.
 - `createRevenueCatBridge({ analytics, entitlementId })`: the RevenueCat purchase funnel (see "RevenueCat" below).
 - `activationJoinContext(deviceKey)`: builds the `userContext` value that joins an onboarding session to the app's later events. Every `<WireOnboarding>` needs it (see step 7).
 - `resolveAutoDeviceKey({ appId, storage })`: the kit's own persisted per-install `device_key`, for a host that owns none.
@@ -65,9 +66,10 @@ subpaths are optional secondary feature modules; import one only if you use it.
 | `illustrations` | `Record<string, ReactNode>` | no | Host artwork for `InterstitialCard`, keyed by name. `{ ...defaultIllustrations, ...myArt }`. |
 | `icons` | `Record<string, ReactNode>` | no | Host icon nodes keyed by the semantic vocabulary name the AI emits (`{ instagram: <BrandIg/> }`). Checked FIRST: use it to brand an icon, to add names of your own, or to supply icons without installing `@expo/vector-icons`. Unlisted names fall back to that optional peer, then to no icon. |
 | `validators` | `Record<string, StepValidator>` | no | Per base-question key (e.g. `username`). Blocks advance + inline error. |
+| `permissionScreens` | `PermissionScreenConfig[]` | no | Priming screens injected mid-flow (notifications first). `{ permission, placement?, request, getStatus?, openSettings?, copy?, illustration?, onResult? }`. The OS dialog opens ONLY on the primary tap, never on mount; "Maybe later" advances without spending the one native prompt. `placement` is `"start"`, `{ afterCard: n }` or `"beforeEnd"` (default), and an `afterCard` past the end of the stream clamps to `"beforeEnd"`. Zero new dependencies: the host injects `request`, the kit imports no native permission module. Shown once per session and, with `storage`, across an app kill. Not a question: no `key`/`slot_id`, nothing in `answers`, completion never blocks on a grant. |
 | `onSkip` | `() => void` | no | Retained for back-compat. Per-question Skip is now internal (the kit advances one question on `skippable` screens), so this is no longer wired to that control. |
 | `onError` | `(err) => void` | no | Backend error/timeout after retries. Host recovery (e.g. static onboarding). `fallbackFlow` takes precedence over it. |
-| `onEvent` | `(e: OnboardingEvent) => void` | no | Lifecycle events for analytics (kit owns the loop). Variants: `started`, `resumed`, `turn`, `error`, `retry`, `fallback` (see `OnboardingEvent`). |
+| `onEvent` | `(e: OnboardingEvent) => void` | no | Lifecycle events for analytics (kit owns the loop). Variants: `started`, `resumed`, `turn`, `error`, `retry`, `fallback`, `permission` (see `OnboardingEvent`). |
 | `copy` | `Partial<OnboardingCopy>` | no | Localize built-in English strings. |
 | `approxScreens` | `number` | no | Paces the bar; backend `progress.total` wins, so usually unneeded. |
 | `startMessage` | `string` | no | First backend message. Default `"start"`. |

package/CHANGELOG.md

@@ -3,6 +3,116 @@
 All notable changes to `@wireai/activation` (formerly `wireai-onboarding`).
 Historical entries below the rename keep the old package name on purpose.
 
+## [0.13.2] — 2026-07-31
+
+The headline is a fix: every `track()` / `screen()` `app_event` was being silently discarded by the
+server behind an HTTP 200, on every kit version since 0.11.0. This release also ships the injectable
+mid-flow permission screens below, and it is the FIRST version whose published tarball is clean of
+the banned client name — the 0.13.0 publish-surface scrub now rides a build-time canary that fails
+the pack if the name ever reappears.
+
+### Fixed
+
+- **`ts` crosses the wire as ISO8601, so `app_event`s actually land.**
+  (`analytics/reportClientEvent.ts`) The server's event model declares `ts: str | None` and pydantic
+  v2 does not coerce a number into it, while the offline queue has stamped `ts = Date.now()` (epoch
+  ms) on every queued event since 0.11.0 — so `POST /v1/events` answered HTTP 200 with
+  `{written: 0, skipped: N, errors: [{field: "ts", reason: "validation_error"}]}` and 100% of
+  `track()` / `screen()` analytics evaporated behind a green response. `buildEventsRequest` — the
+  single choke point all four send paths share (offline queue, fire-and-forget, awaitable,
+  session-start) — now serializes a numeric `ts` to an ISO8601 UTC string on its way out. The queue
+  keeps its numeric stamp (the identical-JSON de-dup signature depends on it), a persisted 0.13.0
+  backlog is converted as it drains, a caller-set ISO string passes through untouched, and a
+  non-finite or out-of-range number drops the field from that one event instead of killing the batch.
+- **The discard warning names the field the server refused.** (`readEventsAck`) The server's
+  `errors[]` entries carry a `field` alongside `reason`; the ack reader threw it away, so a dev build
+  warned `validation_error` with no address. It now prints `validation_error (field: ts)` — the
+  difference between a one-line fix and an investigation.
+
+### Added
+
+Injectable mid-flow permission screens, starting with notifications.
+
+Onboarding is where apps ask for notifications and where most of them lose the ask: iOS grants an
+app exactly ONE native prompt for its entire lifetime, so firing it from a mount effect on screen
+one spends it on a user who has been told nothing, and the only route back is a Settings trip almost
+nobody makes. This release ships the priming pattern as a first-class part of the flow. You declare
+a screen, it explains why in your words, and the OS dialog opens only on the user's primary tap.
+"Maybe later" advances the flow with the prompt unspent.
+
+Nothing changes for a host that configures no screen: the prop is optional and every path around it
+is byte-identical.
+
+- **`permissionScreens` on `<WireOnboarding>`** (`permissions/types.ts`, `cards/PermissionCard.tsx`) -
+  one or more priming screens injected into the server-driven card stream at a position you choose.
+  The screen carries customizable rationale copy, kit-quality defaults for notifications, optional
+  artwork through the existing illustrations registry, and an `onResult` callback per screen.
+  **DEPENDENCY-FREE, the RevenueCat-bridge idiom:** the kit imports no `expo-notifications`, no
+  `react-native-permissions`, nothing native. The host injects `request` and optionally `getStatus`
+  and `openSettings`, exactly the way it hands the RevenueCat bridge real RevenueCat objects. The
+  README shows the five-line wiring.
+- **The priming rule, enforced in code and pinned by a canary.** There is no path from mount, from
+  an effect, from a timer or from render to the host's `request`; only the primary press handler
+  reaches it. The optional `getStatus` probe is a READ that never prompts, and all it decides is
+  which primary the screen offers: ask, open settings (status `blocked`, where an ask would show
+  nothing at all), or a plain continue (already granted, or a host that supplied no `request`, where
+  the kit declines rather than fabricating a button that does nothing).
+- **A watchdog on the host's `request`, which fabricates nothing.** Asking sets a busy state that
+  disables both controls, which is right while an OS dialog may be open and fatal if the host's
+  `request` never settles at all (a swallowed native callback, a promise nobody resolves): the
+  screen would be a dead end with nothing tappable, and completion could never fire. A generous 90
+  second ceiling now hands the controls back so the user can retry or skip. On expiry it records NO
+  outcome and emits NO event, only a dev warning, because a pending request is not a denial and a
+  person can legitimately sit on a permission dialog for minutes. First settlement wins: if the
+  original request answers late, after the controls were handed back and possibly after a second
+  attempt already resolved, it advances nothing and emits nothing.
+- **Placement semantics with a clamp** (`DEFAULT_PERMISSION_PLACEMENT`, `selectDuePermissionScreen`)
+  - `"start"`, `{ afterCard: n }` and `"beforeEnd"` (the default), resolved against the card about
+  to render, because the stream length is server-driven and varies per user. An `afterCard` the flow
+  never reaches degrades to `"beforeEnd"` instead of silently never showing, which is the failure
+  mode that raises no error anywhere and leaves the host looking at a funnel that reads zero.
+- **`WIRE_PERMISSION_EVENTS`** plus `permissionEventName`, `permissionEventProps` and
+  `normalizePermissionStatus` (`permissions/permissionEvents.ts`) - the canonical funnel names
+  (`wire_permission_screen_shown`, `wire_permission_primer_accepted`, `wire_permission_granted`,
+  `wire_permission_denied`, `wire_permission_skipped`, `wire_permission_settings_opened`), mirroring
+  `WIRE_PURCHASE_EVENTS`. They land as `app_event` `question_key` values on the same `/v1/events`
+  path, carrying the same device snapshot and `user_context`, so the `device_key` join that makes
+  every other number real covers these too. Each moment is also surfaced on `onEvent` as
+  `{ type: "permission", ... }`.
+- **`resolvePermissionCopy`, `NOTIFICATIONS_PERMISSION_COPY`, `GENERIC_PERMISSION_COPY`,
+  `DEFAULT_PERMISSION_COPY`** - the shipped English plus per-line overrides. An override that is
+  `undefined` or empty is IGNORED rather than allowed to blank a button, because hosts build this
+  object from an i18n layer where a missing translation resolves to `undefined`.
+- **Once per session, kept true across an app KILL** (`permissionStorageKey`,
+  `loadSettledPermissions`, `saveSettledPermissions`, `readSettledPermissions`,
+  `clearSettledPermissions`). The kit resumes a killed onboarding into the SAME backend session, so
+  without a persisted record the resumed mount would re-show a screen the user already answered,
+  which on the ask path means a second attempt at the one prompt iOS grants. The record is scoped to
+  the session id, one entry, so a genuinely new onboarding still starts clean with nothing having to
+  expire it. Same host-injected `storage`, same read ceiling, same best-effort discipline: a
+  rejecting adapter costs a re-ask on resume, never a broken or gated flow.
+- **`PermissionCard` and `PERMISSION_CARD_NAME`** - the screen registered as an SDK component, so a
+  later server-emitted placement (AI-chosen timing) adopts this exact screen with no rewrite.
+  Deliberately NOT part of `onboardingComponents`: that array is what the device advertises as
+  renderable, and a backend told it may emit a permission screen could emit one into a host that
+  injected no `request`.
+- **A `notifications` entry in `defaultIllustrations`** so a notification screen is never a blank
+  box with no host wiring. Register your own under the same name to override it.
+
+### Changed
+
+- **`OnboardingEvent` gains a `permission` variant** and `toAnalyticsEvent` maps it to its own
+  canonical `wire_permission_*` name rather than folding it into an onboarding one. Additive: a host
+  that ignores the new variant is unaffected, and every existing variant maps exactly as before.
+- **A permission screen is NOT a question, structurally.** It sends nothing to the backend, appends
+  nothing to the thread, mints no `key` and no `slot_id`, and never touches the progress step, so
+  `deriveAnswers`, `readProgress` and the completion semantics cannot tell it happened. Completion
+  never blocks on a grant: grant, deny, skip and blocked all continue the flow, and a host callback
+  that throws (a native module blowing up, a failed scheduling call) is caught rather than allowed
+  to strand the user on the screen.
+- **Notification SCHEDULING is deliberately out of scope.** `onResult` is the seam: schedule your
+  first local reminder there, with your own call, the moment a grant lands.
+
 ## [0.13.0] — 2026-07-27
 
 The identity-provenance release. Every id-layer defect fixed here is one omission wearing five faces:
@@ -35,8 +145,11 @@ direction: the kit now declines and says so, where it used to fabricate and retu
   `props.progress` by `readProgress` and preferred over `key` by `deriveAnswers`. `key` is authored from
   the question's prompt text (tenant flows slugify it and cut at 32 chars), so re-wording a question mints
   a NEW key and a host reading `answers.interests` silently starts reading `undefined`.
-  ⚠️ **INERT UNTIL THE SERVER EMITS IT.** No deployed server sends `slot_id` today. Against a server that
-  never sends it, every path degrades to byte-identical 0.12.2 behaviour. Every fallback is decided
+  ⚠️ ~~**INERT UNTIL THE SERVER EMITS IT.** No deployed server sends `slot_id` today.~~
+  ✅ **CORRECTED 2026-07-28: this is LIVE.** The deployed server (`47dae92`) sends `slot_id` on
+  `progress` for every AI-generated question, as `adaptive_<n>`, and for a configured question
+  whenever the tenant set one. Where no slot is configured the field is absent and
+  every path degrades to byte-identical 0.12.2 behaviour. Every fallback is decided
   PER CARD, never cached as a per-session "this backend supports slots" verdict, so a thread that mixes
   slotted and unslotted cards — the real shape during a rollout — keys each card correctly.
 - **`allowAppSessionFallback` on `identifyOnboarding`** — the opt-in switch for the tier-3 behaviour
@@ -280,7 +393,7 @@ or a client-side default.
 
 ## [0.12.0] — 2026-07-27
 
-The release Myelino 2.2.0 pins. Ships the RevenueCat path (#52), the identity/counting audit,
+The release the first production consumer pins. Ships the RevenueCat path (#52), the identity/counting audit,
 the session-id fallback contract, and the transport/config fixes behind a silently dead lifecycle
 stream (a consumer's `first_open` read 6 all-time while the emitting code was deployed).
 

package/README.md

@@ -235,6 +235,7 @@ import { WireOnboarding } from "@wireai/activation";
 | `theme` | `Partial<OnboardingTheme>` | Brand colors/fonts/radius/spacing, deep-merged over a neutral default. |
 | `illustrations` | `Record<string, ReactNode>` | App artwork for `InterstitialCard`, keyed by name. |
 | `validators` | `Record<string, StepValidator>` | Per-step, keyed by base-question key (e.g. `username`). Blocks advance + shows an inline error. When the backend sends a `progress.slot_id` for a screen, the kit looks up that slot FIRST and falls back to the question key, so a validator map written against today's keys keeps working. |
+| `permissionScreens` | `PermissionScreenConfig[]` | Priming screens injected mid-flow, starting with notifications. The screen explains why, and the OS dialog opens **only** on the primary tap, never on mount. Zero new dependencies: you inject `request`. See [Permission screens](#permission-screens-the-priming-pattern). |
 | `onSkip` | `() => void` | User skipped. |
 | `onError` | `(err) => void` | Backend error/timeout — host owns recovery (e.g. route to a static flow). Without it, the kit shows an inline retry. |
 | `onEvent` | `(e: OnboardingEvent) => void` | `started` / `turn` / `error` — recover per-turn analytics since the kit owns the loop. |
@@ -608,6 +609,87 @@ icons={{
 Icons are decorative: the label carries the meaning, so an icon stays hidden from screen readers
 and never becomes an option's accessible name.
 
+## Permission screens (the priming pattern)
+
+Onboarding is where apps ask for notifications, and it is where most of them lose the ask. iOS gives an app **one** native notification prompt for its entire lifetime. Fire it from a mount effect on screen one and you have spent it on a user who has been told nothing, and the only route back is a trip through the Settings app that almost nobody makes.
+
+So the kit ships the priming pattern. You inject a screen into the flow, it explains why in your words, and the OS dialog opens **only** when the user taps the primary button. "Maybe later" advances the flow with the prompt still unspent, so you can ask again in a better moment.
+
+```tsx
+import * as Notifications from "expo-notifications";
+import { WireOnboarding } from "@wireai/activation";
+
+<WireOnboarding
+  config={config}
+  onComplete={persist}
+  permissionScreens={[
+    {
+      permission: "notifications",
+      placement: "beforeEnd",
+      request: async () => {
+        const { status, canAskAgain } = await Notifications.requestPermissionsAsync();
+        return status === "granted" ? "granted" : canAskAgain ? "denied" : "blocked";
+      },
+      getStatus: async () => {
+        const { status, canAskAgain } = await Notifications.getPermissionsAsync();
+        return status === "granted" ? "granted" : canAskAgain ? "denied" : "blocked";
+      },
+      onResult: (_permission, outcome) => {
+        if (outcome === "granted") scheduleFirstReminder();
+      },
+    },
+  ]}
+/>
+```
+
+That is the whole integration, and **the kit adds no dependency for it**. It imports no `expo-notifications`, no `react-native-permissions`, nothing native, the same way the RevenueCat bridge takes real RevenueCat objects without depending on `react-native-purchases`. You own the native call; the kit owns the screen, the timing, and the funnel.
+
+### Where the screen lands
+
+The stream is server-driven, so its length changes per user. A placement is therefore resolved against the card about to render, not against a fixed index:
+
+| `placement` | Where it shows |
+|---|---|
+| `"beforeEnd"` (default) | Right before the terminal recap, once the user has invested in the flow. |
+| `"start"` | Before the first question. |
+| `{ afterCard: 2 }` | After two questions, so between card 2 and card 3. |
+
+An `afterCard` the flow never reaches **clamps to `"beforeEnd"`** instead of silently never showing. That matters more than it sounds: a screen that never appears raises no error anywhere, and the only evidence is a permission funnel that reads zero forever.
+
+### What it guarantees
+
+- **The dialog is only ever reached from the primary tap.** No mount effect, no timer, no auto-fire. `getStatus` is a read and never prompts; it only decides which primary the screen offers.
+- **Already blocked?** The primary becomes "Open settings", because an `ask` there would open nothing at all.
+- **Once per session, and it survives an app kill.** With `storage`, a resumed session does not re-ask (the record is keyed to the session id, so a genuinely new onboarding still starts clean).
+- **Completion never blocks on a grant.** Grant, deny, skip and blocked all continue the flow.
+- **It is not a question.** Nothing is sent to the backend, nothing enters the thread, no `key` or `slot_id` is minted, and `onComplete`'s `answers` are identical to the same flow with no screen configured.
+
+### Copy and artwork
+
+The kit ships English good enough to ship. Override any single line and the rest of the default stays:
+
+```tsx
+copy: { title: "Never miss a session", primaryLabel: "Turn on reminders" }
+```
+
+Artwork comes from the same `illustrations` registry the cards use, keyed by the permission name, so `illustrations={{ notifications: <MyBell /> }}` is enough. The kit's dependency-free default is used when you register nothing.
+
+### The numbers
+
+Each screen reports through the same `/v1/events` path and the same `device_key` join as the rest of the funnel, and every moment is also surfaced on `onEvent` as `{ type: "permission", ... }`:
+
+| Event | Fires when |
+|---|---|
+| `wire_permission_screen_shown` | The primer became visible. The denominator. |
+| `wire_permission_primer_accepted` | The primary was tapped, so the OS dialog is about to open. |
+| `wire_permission_granted` / `wire_permission_denied` | What the OS answered (a permanently blocked answer reports as denied with `status: "blocked"`). |
+| `wire_permission_skipped` | "Maybe later". The one native prompt was not spent. |
+| `wire_permission_settings_opened` | A blocked user was sent to Settings. |
+
+The gap between `wire_permission_screen_shown` and `wire_permission_primer_accepted` is the number worth watching: it tells you whether your rationale copy works, and it costs nothing to be wrong about, because a user who does not tap has not burned anything.
+
+**Scheduling notifications is deliberately out of scope.** `onResult` is the seam: schedule your first local reminder there, with your own `expo-notifications` call, the moment a grant lands.
+
 ## Backend coupling
 
 The backend (`wire-rn/examples/dynamic-onboarding/server`) is the source of truth

package/dist/analytics/index.d.mts

@@ -1,6 +1,6 @@
 export { R as ReportAppEventOptions, r as reportAppEvent } from '../transport-CF_eHwzC.mjs';
-import { W as WireUserContext, E as EventQueueOptions } from '../currentSession-_GynvhzT.mjs';
-export { A as AUTO_DEVICE_ID_PREFIX, a as AnalyticsEvent, C as ClearUserContextOptions, b as ClientEvent, c as ClientEventTarget, d as ClientEventType, e as ContextEnvelope, f as ContextEnvelopeInput, D as DeviceKeyStorage, g as EnvelopeSource, h as EventQueue, R as ResolveAutoDeviceKeyOptions, i as WIRE_ONBOARDING_EVENTS, j as WireOnboardingEventName, k as analyticsUserIdStorageKey, l as buildContextEnvelope, m as clearPiiFromContext, n as clearUserContext, o as createEventQueue, p as deviceIdStorageKey, q as ensureCurrentSessionId, r as getCurrentSessionId, s as looksLikeEmail, t as makeSessionId, u as reportClientEvent, v as reportClientEventAwait, w as reportClientEvents, x as reportClientEventsAwait, y as resetAutoDeviceKeys, z as resetCurrentSessionId, B as resetEventQueueKeys, F as resolveAutoDeviceKey, G as setCurrentSessionId, H as toAnalyticsEvent } from '../currentSession-_GynvhzT.mjs';
+import { W as WireUserContext, E as EventQueueOptions } from '../currentSession-ClkLjcJ0.mjs';
+export { A as AUTO_DEVICE_ID_PREFIX, a as AnalyticsEvent, C as ClearUserContextOptions, b as ClientEvent, c as ClientEventTarget, d as ClientEventType, e as ContextEnvelope, f as ContextEnvelopeInput, D as DeviceKeyStorage, g as EnvelopeSource, h as EventQueue, R as ResolveAutoDeviceKeyOptions, i as WIRE_ONBOARDING_EVENTS, j as WireOnboardingEventName, k as analyticsUserIdStorageKey, l as buildContextEnvelope, m as clearPiiFromContext, n as clearUserContext, o as createEventQueue, p as deviceIdStorageKey, q as ensureCurrentSessionId, r as getCurrentSessionId, s as looksLikeEmail, t as makeSessionId, u as reportClientEvent, v as reportClientEventAwait, w as reportClientEvents, x as reportClientEventsAwait, y as resetAutoDeviceKeys, z as resetCurrentSessionId, B as resetEventQueueKeys, F as resolveAutoDeviceKey, G as setCurrentSessionId, H as toAnalyticsEvent } from '../currentSession-ClkLjcJ0.mjs';
 import '../types-CNUqMK0D.mjs';
 import '../types-BKfpdZzX.mjs';
 import '../types-BcmagF6K.mjs';

package/dist/analytics/index.d.ts

@@ -1,6 +1,6 @@
 export { R as ReportAppEventOptions, r as reportAppEvent } from '../transport-DsRe4epC.js';
-import { W as WireUserContext, E as EventQueueOptions } from '../currentSession-D7zabMXK.js';
-export { A as AUTO_DEVICE_ID_PREFIX, a as AnalyticsEvent, C as ClearUserContextOptions, b as ClientEvent, c as ClientEventTarget, d as ClientEventType, e as ContextEnvelope, f as ContextEnvelopeInput, D as DeviceKeyStorage, g as EnvelopeSource, h as EventQueue, R as ResolveAutoDeviceKeyOptions, i as WIRE_ONBOARDING_EVENTS, j as WireOnboardingEventName, k as analyticsUserIdStorageKey, l as buildContextEnvelope, m as clearPiiFromContext, n as clearUserContext, o as createEventQueue, p as deviceIdStorageKey, q as ensureCurrentSessionId, r as getCurrentSessionId, s as looksLikeEmail, t as makeSessionId, u as reportClientEvent, v as reportClientEventAwait, w as reportClientEvents, x as reportClientEventsAwait, y as resetAutoDeviceKeys, z as resetCurrentSessionId, B as resetEventQueueKeys, F as resolveAutoDeviceKey, G as setCurrentSessionId, H as toAnalyticsEvent } from '../currentSession-D7zabMXK.js';
+import { W as WireUserContext, E as EventQueueOptions } from '../currentSession-DOVZEWJl.js';
+export { A as AUTO_DEVICE_ID_PREFIX, a as AnalyticsEvent, C as ClearUserContextOptions, b as ClientEvent, c as ClientEventTarget, d as ClientEventType, e as ContextEnvelope, f as ContextEnvelopeInput, D as DeviceKeyStorage, g as EnvelopeSource, h as EventQueue, R as ResolveAutoDeviceKeyOptions, i as WIRE_ONBOARDING_EVENTS, j as WireOnboardingEventName, k as analyticsUserIdStorageKey, l as buildContextEnvelope, m as clearPiiFromContext, n as clearUserContext, o as createEventQueue, p as deviceIdStorageKey, q as ensureCurrentSessionId, r as getCurrentSessionId, s as looksLikeEmail, t as makeSessionId, u as reportClientEvent, v as reportClientEventAwait, w as reportClientEvents, x as reportClientEventsAwait, y as resetAutoDeviceKeys, z as resetCurrentSessionId, B as resetEventQueueKeys, F as resolveAutoDeviceKey, G as setCurrentSessionId, H as toAnalyticsEvent } from '../currentSession-DOVZEWJl.js';
 import '../types-Buj9Lw9t.js';
 import '../types-BKfpdZzX.js';
 import '../types-BcmagF6K.js';

package/dist/analytics/index.js

@@ -402,13 +402,24 @@ var init_Constants = __esm({
 
 // src/analytics/reportClientEvent.ts
 var makeSessionId = () => `wire_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 10)}`;
+var toWireEvents = (events) => events.map((event) => {
+  if (typeof event.ts !== "number") return event;
+  const { ts, ...rest } = event;
+  if (!Number.isFinite(ts)) return rest;
+  try {
+    return { ...rest, ts: new Date(ts).toISOString() };
+  } catch {
+    return rest;
+  }
+});
 var buildEventsRequest = (target, events) => {
   if (!(target == null ? void 0 : target.serverUrl) || events.length === 0) return null;
   try {
     const url = `${target.serverUrl.replace(/\/$/, "")}/v1/events`;
     const headers = { "Content-Type": "application/json" };
     if (target.apiKey) headers.Authorization = `Bearer ${target.apiKey}`;
-    return { url, init: { method: "POST", headers, body: JSON.stringify({ events }) } };
+    const body = JSON.stringify({ events: toWireEvents(events) });
+    return { url, init: { method: "POST", headers, body } };
   } catch {
     return null;
   }
@@ -420,7 +431,13 @@ var readEventsAck = async (res) => {
     const body = await Promise.resolve(json.call(res));
     const skipped = body == null ? void 0 : body.skipped;
     if (typeof skipped !== "number" || !Number.isFinite(skipped)) return void 0;
-    const reasons = Array.isArray(body == null ? void 0 : body.errors) ? body.errors.map((e) => e == null ? void 0 : e.reason).filter((r) => typeof r === "string") : [];
+    const reasons = Array.isArray(body == null ? void 0 : body.errors) ? body.errors.map((e) => {
+      const entry = e;
+      const reason = entry == null ? void 0 : entry.reason;
+      if (typeof reason !== "string") return void 0;
+      const field = entry == null ? void 0 : entry.field;
+      return typeof field === "string" && field.length > 0 ? `${reason} (field: ${field})` : reason;
+    }).filter((r) => typeof r === "string") : [];
     return { written: typeof (body == null ? void 0 : body.written) === "number" ? body.written : void 0, skipped, reasons };
   } catch {
     return void 0;
@@ -598,6 +615,43 @@ var useScreenTracking = (navigationRef, options = {}) => {
   }, [navigationRef]);
 };
 
+// src/permissions/permissionEvents.ts
+var WIRE_PERMISSION_EVENTS = {
+  /** The priming screen became visible. The denominator for every rate below. */
+  screenShown: "wire_permission_screen_shown",
+  /** The user tapped the primary, so the OS dialog is about to open. The rationale worked. */
+  primerAccepted: "wire_permission_primer_accepted",
+  /** The OS granted it. */
+  granted: "wire_permission_granted",
+  /** The OS refused it (a permanently blocked answer reports here too, with `status: "blocked"`). */
+  denied: "wire_permission_denied",
+  /** The user took the secondary. The one native prompt was NOT spent. */
+  skipped: "wire_permission_skipped",
+  /** A blocked user was redirected to the OS settings page. */
+  settingsOpened: "wire_permission_settings_opened"
+};
+var permissionEventName = (stage) => {
+  switch (stage) {
+    case "shown":
+      return WIRE_PERMISSION_EVENTS.screenShown;
+    case "accepted":
+      return WIRE_PERMISSION_EVENTS.primerAccepted;
+    case "granted":
+      return WIRE_PERMISSION_EVENTS.granted;
+    case "denied":
+      return WIRE_PERMISSION_EVENTS.denied;
+    case "skipped":
+      return WIRE_PERMISSION_EVENTS.skipped;
+    case "settings":
+      return WIRE_PERMISSION_EVENTS.settingsOpened;
+    default: {
+      const _exhaustive = stage;
+      return _exhaustive;
+    }
+  }
+};
+var permissionEventProps = (permission, status) => status ? { permission, status } : { permission };
+
 // src/analytics/analyticsEvent.ts
 var WIRE_ONBOARDING_EVENTS = {
   started: "wire_onboarding_started",
@@ -630,6 +684,11 @@ var toAnalyticsEvent = (event) => {
       };
     case "fallback":
       return { name: WIRE_ONBOARDING_EVENTS.fallback, params: { reason: event.reason } };
+    case "permission":
+      return {
+        name: permissionEventName(event.stage),
+        params: permissionEventProps(event.permission, event.status)
+      };
     default: {
       const _exhaustive = event;
       return _exhaustive;