@use-voltra/ios-client 2.2.0 → 2.3.1

package/ios/ui/Views/VoltraChart.swift

@@ -161,6 +161,103 @@ public struct VoltraChart: VoltraView {
     }
   }
 
+  // MARK: - Y scale
+
+  /// Y-axis bounds pinned by the `yScale` prop; either side may be left to the data.
+  private struct YScale {
+    let min: Double?
+    let max: Double?
+  }
+
+  private func parseYScale(from raw: String?) -> YScale? {
+    guard let raw,
+          let data = raw.data(using: .utf8),
+          let dict = try? JSONSerialization.jsonObject(with: data) as? [String: Any]
+    else { return nil }
+
+    let props = dict.compactMapValues { jsonValue(from: $0) }
+    let min = (props["mn"] ?? props["min"]).flatMap(num)
+    let max = (props["mx"] ?? props["max"]).flatMap(num)
+    if min == nil, max == nil {
+      return nil
+    }
+    return YScale(min: min, max: max)
+  }
+
+  /// Domain to hand SwiftUI when `yScale` pins a bound. The open side follows the data exactly as
+  /// `computeYDomain` in Android's ChartBitmapRenderer.kt frames it, so both platforms agree.
+  private func yScaleDomain(_ marks: [WireMark], pinned: YScale) -> ClosedRange<Double> {
+    let auto = autoYDomain(marks)
+    var lower = pinned.min ?? auto.lowerBound
+    var upper = pinned.max ?? auto.upperBound
+
+    if upper <= lower {
+      // A pin that inverts the domain still has to leave something to draw in: keep the span the
+      // data asked for on the side the caller left open, and ignore a pair that cannot be drawn.
+      let span = auto.upperBound - auto.lowerBound
+      if pinned.max == nil {
+        upper = lower + span
+      } else if pinned.min == nil {
+        lower = upper - span
+      } else {
+        return auto
+      }
+      if upper <= lower {
+        upper = lower + 1
+      }
+    }
+
+    return lower ... upper
+  }
+
+  private func autoYDomain(_ marks: [WireMark]) -> ClosedRange<Double> {
+    var values = marks.flatMap { mark -> [Double] in
+      guard mark.type != "sector" else { return [] }
+      return (mark.data ?? []).map { xy($0).y }
+    }
+    values += marks.compactMap { $0.type == "rule" ? $0.props["yv"].flatMap(num) : nil }
+
+    let finite = values.filter(\.isFinite)
+    guard let dataMin = finite.min(), let dataMax = finite.max() else { return 0 ... 1 }
+
+    // Bars and areas measure their value against the baseline, so zero stays in range.
+    if marks.contains(where: { $0.type == "bar" || $0.type == "area" }) {
+      let lower = Swift.min(dataMin, 0)
+      let upper = Swift.max(dataMax, 0)
+      return upper > lower ? lower ... upper : lower ... (lower + 1)
+    }
+
+    guard dataMax > dataMin else {
+      let padding = dataMin == 0 ? 1 : abs(dataMin) * Self.yDomainPaddingRatio
+      return (dataMin - padding) ... (dataMax + padding)
+    }
+
+    let padding = (dataMax - dataMin) * Self.yDomainPaddingRatio
+    var lower = dataMin - padding
+    var upper = dataMax + padding
+
+    // Padding must not invent values on the other side of the baseline, and data that almost
+    // reaches zero keeps it in view.
+    if dataMin >= 0, lower < 0 {
+      lower = 0
+    }
+    if dataMax <= 0, upper > 0 {
+      upper = 0
+    }
+    let span = upper - lower
+    if lower > 0, lower < span * Self.zeroSnapRatio {
+      lower = 0
+    }
+    if upper < 0, -upper < span * Self.zeroSnapRatio {
+      upper = 0
+    }
+
+    return lower ... upper
+  }
+
+  private static let yDomainPaddingRatio = 0.1
+  private static let zeroSnapRatio = 0.25
+
   // MARK: - body
 
   public var body: some View {
@@ -171,10 +268,12 @@ public struct VoltraChart: VoltraView {
     let yAxisGridStyle = parseAxisGridStyle(from: params.yAxisGridStyle)
     let legendVis = visibility(params.legendVisibility)
     let legendItems = parseLegendItems(from: params.foregroundStyleScale)
+    let yDomain = parseYScale(from: params.yScale).map { yScaleDomain(wireMarks, pinned: $0) }
 
     Chart {
       buildAll(wireMarks)
     }
+    .applyChartYScale(domain: yDomain)
     .applyForegroundStyleScale(params.foregroundStyleScale)
     .applyChartStyle(
       element.style,
@@ -734,6 +833,15 @@ private extension View {
     }
   }
 
+  @ViewBuilder
+  func applyChartYScale(domain: ClosedRange<Double>?) -> some View {
+    if let domain {
+      chartYScale(domain: domain)
+    } else {
+      self
+    }
+  }
+
   @ViewBuilder
   func applyChartClipping(decoration: DecorationStyle, hasClipping: Bool) -> some View {
     if hasClipping {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@use-voltra/ios-client",
-  "version": "2.2.0",
+  "version": "2.3.1",
   "description": "Client-only Voltra APIs for iOS",
   "main": "./build/commonjs/index.js",
   "module": "./build/module/index.js",
@@ -39,9 +39,9 @@
     "@expo/plist": "^0.3.5",
     "dedent": "^1.7.1",
     "xcode": "^3.0.1",
-    "@use-voltra/compiler": "^2.2.0",
-    "@use-voltra/expo-plugin": "^2.2.0",
-    "@use-voltra/ios": "^2.2.0"
+    "@use-voltra/compiler": "^2.3.1",
+    "@use-voltra/expo-plugin": "^2.3.1",
+    "@use-voltra/ios": "^2.3.1"
   },
   "peerDependencies": {
     "expo": "*",

package/src/events.ts

@@ -30,15 +30,28 @@ export type VoltraInteractionEvent = BasicVoltraEvent & {
   payload: string
 }
 
+export type VoltraDynamicLiveActivityRenderFailedEvent = BasicVoltraEvent & {
+  type: 'dynamicLiveActivityRenderFailed'
+  activityName: string
+  definitionId: string
+  message: string
+}
+
 const noopSubscription: EventSubscription = {
   remove: () => {},
 }
 
+// Codegen EventEmitter subscriptions do not tell native code when their last
+// JavaScript listener goes away. Keep this count at the public API boundary so
+// the App Group queue is drained only while it can actually be delivered.
+let dynamicRenderFailureListenerCount = 0
+
 export type VoltraEventMap = {
   activityTokenReceived: VoltraActivityTokenReceivedEvent
   activityPushToStartTokenReceived: VoltraActivityPushToStartTokenReceivedEvent
   stateChange: VoltraActivityUpdateEvent
   interaction: VoltraInteractionEvent
+  dynamicLiveActivityRenderFailed: VoltraDynamicLiveActivityRenderFailedEvent
 }
 
 export function addVoltraListener<K extends keyof VoltraEventMap>(
@@ -63,6 +76,27 @@ export function addVoltraListener<K extends keyof VoltraEventMap>(
       return voltraModule.onStateChanged(listener as (arg: VoltraActivityUpdateEvent) => void)
     case 'interaction':
       return voltraModule.onInteraction(listener as (arg: VoltraInteractionEvent) => void)
+    case 'dynamicLiveActivityRenderFailed':
+      const subscription = voltraModule.onDynamicLiveActivityRenderFailed(
+        listener as (arg: VoltraDynamicLiveActivityRenderFailedEvent) => void
+      )
+      dynamicRenderFailureListenerCount += 1
+      if (dynamicRenderFailureListenerCount === 1) {
+        voltraModule.setDynamicLiveActivityRenderFailureListenerActive(true)
+      }
+
+      let removed = false
+      return {
+        remove: () => {
+          if (removed) return
+          removed = true
+          subscription.remove()
+          dynamicRenderFailureListenerCount -= 1
+          if (dynamicRenderFailureListenerCount === 0) {
+            voltraModule.setDynamicLiveActivityRenderFailureListenerActive(false)
+          }
+        },
+      }
     default:
       console.warn(`[Voltra] Event '${event}' is not supported. Returning no-op subscription.`)
       return noopSubscription

package/src/index.ts

@@ -23,6 +23,18 @@ export {
   type UseLiveActivityOptions,
   type UseLiveActivityResult,
 } from './live-activity/api.js'
+export {
+  getDynamicLiveActivityDefinitionIds,
+  startDynamicLiveActivity,
+  type StartDynamicLiveActivityOptions,
+  updateDynamicLiveActivity,
+  type UpdateDynamicLiveActivityOptions,
+  useDynamicLiveActivity,
+  type UseDynamicLiveActivityOptions,
+  type UseDynamicLiveActivityResult,
+  type DynamicLiveActivityProps,
+  type DynamicLiveActivityPropsValue,
+} from './live-activity/dynamic-api.js'
 export type { DismissalPolicy, LiveActivityVariants } from '@use-voltra/ios'
 export {
   clearPreloadedImages,
@@ -33,9 +45,19 @@ export {
 } from './preload.js'
 export { assertRunningOnApple } from './utils/assertRunningOnApple.js'
 export { enableWidgetHotReload } from './utils/enableWidgetHotReload.js'
+export { enableDynamicLiveActivityHotReload } from './utils/enableDynamicLiveActivityHotReload.js'
 export { useUpdateOnHMR } from './utils/useUpdateOnHMR.js'
 export * from './utils/helpers.js'
 export type { VoltraElementJson, VoltraNodeJson } from './types.js'
+export {
+  clearWidgetServerUpdate,
+  getWidgetServerUpdate,
+  setWidgetServerUpdate,
+  type WidgetServerUpdateBody,
+  type WidgetServerUpdateOptions,
+  type WidgetServerUpdateSettings,
+  type WidgetServerUpdateSnapshot,
+} from './widgets/server-update.js'
 export {
   clearWidgetServerCredentials,
   setWidgetServerCredentials,

package/src/live-activity/api.ts

@@ -40,7 +40,7 @@ export type UseLiveActivityResult = {
   isActive: boolean
 }
 
-const normalizeSharedLiveActivityOptions = (
+export const normalizeSharedLiveActivityOptions = (
   options?: SharedLiveActivityOptions
 ): SharedLiveActivityOptions | undefined => {
   if (!options) return undefined
@@ -66,7 +66,7 @@ const normalizeSharedLiveActivityOptions = (
   return Object.keys(normalizedOptions).length > 0 ? normalizedOptions : undefined
 }
 
-const normalizeEndLiveActivityOptions = (
+export const normalizeEndLiveActivityOptions = (
   options?: EndLiveActivityOptions
 ): { dismissalPolicy?: { type: 'immediate' | 'after'; date?: number } } | undefined => {
   if (!options?.dismissalPolicy) return undefined

package/src/live-activity/dynamic-api.ts

@@ -0,0 +1,240 @@
+import { useCallback, useEffect, useRef, useState } from 'react'
+
+import { addVoltraListener } from '../events.js'
+import { assertRunningOnApple, useUpdateOnHMR } from '../utils/index.js'
+import { getNativeVoltra } from '../VoltraModule.js'
+import {
+  isLiveActivityActive,
+  normalizeSharedLiveActivityOptions,
+  stopLiveActivity,
+  type EndLiveActivityOptions,
+  type SharedLiveActivityOptions,
+} from './api.js'
+
+/** @experimental A JSON-compatible value accepted as Dynamic Live Activity props. */
+export type DynamicLiveActivityPropsValue =
+  | string
+  | number
+  | boolean
+  | null
+  | ReadonlyArray<DynamicLiveActivityPropsValue>
+  | Readonly<{ [key: string]: DynamicLiveActivityPropsValue }>
+
+/** @experimental A complete JSON-compatible props record for a Dynamic Live Activity update. */
+export type DynamicLiveActivityProps = Readonly<{ [key: string]: DynamicLiveActivityPropsValue }>
+
+/** @experimental Options used to start a Dynamic Live Activity. */
+export type StartDynamicLiveActivityOptions = {
+  activityName?: string
+  deepLinkUrl?: string
+  channelId?: string
+} & SharedLiveActivityOptions
+
+/** @experimental Options used to update a Dynamic Live Activity. */
+export type UpdateDynamicLiveActivityOptions = SharedLiveActivityOptions
+
+/** @experimental Options for `useDynamicLiveActivity`. */
+export type UseDynamicLiveActivityOptions = StartDynamicLiveActivityOptions & {
+  autoStart?: boolean
+  autoUpdate?: boolean
+}
+
+/** @experimental Lifecycle controls returned by `useDynamicLiveActivity`. */
+export type UseDynamicLiveActivityResult = {
+  start: (options?: StartDynamicLiveActivityOptions) => Promise<void>
+  update: (options?: UpdateDynamicLiveActivityOptions) => Promise<void>
+  end: (options?: EndLiveActivityOptions) => Promise<void>
+  isActive: boolean
+}
+
+function serializeDynamicLiveActivityProps(props: DynamicLiveActivityProps): string {
+  const ancestors = new Set<object>()
+
+  const validate = (value: unknown, path: string): void => {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') return
+
+    if (typeof value === 'number') {
+      if (!Number.isFinite(value)) {
+        throw new TypeError(`Dynamic Live Activity props must be JSON-compatible; ${path} is not a finite number.`)
+      }
+      return
+    }
+
+    if (Array.isArray(value)) {
+      if (ancestors.has(value)) {
+        throw new TypeError(
+          `Dynamic Live Activity props must be JSON-compatible; ${path} contains a circular reference.`
+        )
+      }
+      ancestors.add(value)
+      value.forEach((item, index) => validate(item, `${path}[${index}]`))
+      ancestors.delete(value)
+      return
+    }
+
+    if (typeof value === 'object') {
+      const prototype = Object.getPrototypeOf(value)
+      if (prototype !== Object.prototype && prototype !== null) {
+        throw new TypeError(`Dynamic Live Activity props must be JSON-compatible; ${path} must be a plain object.`)
+      }
+      if (ancestors.has(value)) {
+        throw new TypeError(
+          `Dynamic Live Activity props must be JSON-compatible; ${path} contains a circular reference.`
+        )
+      }
+      ancestors.add(value)
+      for (const [key, item] of Object.entries(value as Record<string, unknown>)) {
+        validate(item, `${path}.${key}`)
+      }
+      ancestors.delete(value)
+      return
+    }
+
+    throw new TypeError(
+      `Dynamic Live Activity props must be JSON-compatible; ${path} has unsupported type ${typeof value}.`
+    )
+  }
+
+  if (props === null || Array.isArray(props) || typeof props !== 'object') {
+    throw new TypeError('Dynamic Live Activity props must be a JSON-compatible record.')
+  }
+
+  validate(props, 'props')
+  return JSON.stringify(props)
+}
+
+/**
+ * Starts a bundled Dynamic Live Activity with a complete opaque props record.
+ * @experimental
+ */
+export async function startDynamicLiveActivity(
+  definitionId: string,
+  props: DynamicLiveActivityProps,
+  options?: StartDynamicLiveActivityOptions
+): Promise<string> {
+  if (!assertRunningOnApple()) return ''
+
+  const propsJson = serializeDynamicLiveActivityProps(props)
+  const normalizedSharedOptions = normalizeSharedLiveActivityOptions(options)
+  return getNativeVoltra().startDynamicLiveActivity(definitionId, propsJson, {
+    target: 'liveActivity',
+    deepLinkUrl: options?.deepLinkUrl,
+    activityName: options?.activityName,
+    channelId: options?.channelId,
+    ...normalizedSharedOptions,
+  })
+}
+
+/**
+ * Replaces a Dynamic Live Activity's complete opaque props record.
+ * @experimental
+ */
+export async function updateDynamicLiveActivity(
+  activityName: string,
+  props: DynamicLiveActivityProps,
+  options?: UpdateDynamicLiveActivityOptions
+): Promise<void> {
+  if (!assertRunningOnApple()) return
+
+  const propsJson = serializeDynamicLiveActivityProps(props)
+  return getNativeVoltra().updateDynamicLiveActivity(
+    activityName,
+    propsJson,
+    normalizeSharedLiveActivityOptions(options) ?? {}
+  )
+}
+
+/**
+ * Returns the Dynamic Live Activity definition IDs bundled in the installed app.
+ * @experimental
+ */
+export async function getDynamicLiveActivityDefinitionIds(): Promise<string[]> {
+  if (!assertRunningOnApple()) return []
+  return getNativeVoltra().getDynamicLiveActivityDefinitionIds()
+}
+
+/**
+ * Manages the lifecycle of one Dynamic Live Activity definition.
+ *
+ * Complete props are sent on every update. In development, call
+ * `enableDynamicLiveActivityHotReload()` once in the app host to reload only
+ * the definition changed by Fast Refresh.
+ * @experimental
+ */
+export function useDynamicLiveActivity<Props extends DynamicLiveActivityProps = DynamicLiveActivityProps>(
+  definitionId: string,
+  props: Props,
+  options?: UseDynamicLiveActivityOptions
+): UseDynamicLiveActivityResult {
+  const [activityName, setActivityName] = useState<string | null>(() => {
+    if (options?.activityName) {
+      return isLiveActivityActive(options.activityName) ? options.activityName : null
+    }
+    return null
+  })
+  const propsRef = useRef(props)
+  const optionsRef = useRef(options)
+  const lastUpdateOptionsRef = useRef<UpdateDynamicLiveActivityOptions | undefined>(undefined)
+
+  useEffect(() => {
+    propsRef.current = props
+  }, [props])
+
+  useEffect(() => {
+    optionsRef.current = options
+  }, [options])
+
+  useUpdateOnHMR()
+
+  const start = useCallback(
+    async (startOptions?: StartDynamicLiveActivityOptions) => {
+      const id = await startDynamicLiveActivity(definitionId, propsRef.current, {
+        ...optionsRef.current,
+        ...startOptions,
+      })
+      setActivityName(id)
+    },
+    [definitionId]
+  )
+
+  const update = useCallback(
+    async (updateOptions?: UpdateDynamicLiveActivityOptions) => {
+      if (!activityName) return
+
+      const mergedOptions = { ...optionsRef.current, ...updateOptions }
+      lastUpdateOptionsRef.current = mergedOptions
+      await updateDynamicLiveActivity(activityName, propsRef.current, mergedOptions)
+    },
+    [activityName]
+  )
+
+  const end = useCallback(
+    async (endOptions?: EndLiveActivityOptions) => {
+      if (!activityName) return
+
+      await stopLiveActivity(activityName, endOptions)
+      setActivityName(null)
+    },
+    [activityName]
+  )
+
+  useEffect(() => {
+    if (options?.autoStart) void start()
+  }, [options?.autoStart, start])
+
+  useEffect(() => {
+    if (options?.autoUpdate) void update(lastUpdateOptionsRef.current)
+  }, [options?.autoUpdate, props, update])
+
+  useEffect(() => {
+    if (!activityName) return
+
+    const subscription = addVoltraListener('stateChange', (event) => {
+      if (event.activityName !== activityName) return
+      if (event.activityState === 'dismissed' || event.activityState === 'ended') setActivityName(null)
+    })
+    return () => subscription.remove()
+  }, [activityName])
+
+  return { start, update, end, isActive: activityName !== null }
+}

package/src/native/NativeVoltra.ts

@@ -32,6 +32,15 @@ type VoltraInteractionEvent = Readonly<{
   payload: string
 }>
 
+type VoltraDynamicLiveActivityRenderFailedEvent = Readonly<{
+  source: string
+  timestamp: number
+  type: 'dynamicLiveActivityRenderFailed'
+  activityName: string
+  definitionId: string
+  message: string
+}>
+
 type StartVoltraOptions = Readonly<{
   target?: string
   deepLinkUrl?: string
@@ -86,19 +95,26 @@ type WidgetServerCredentials = Readonly<{
 
 export interface Spec extends TurboModule {
   readonly onInteraction: CodegenTypes.EventEmitter<VoltraInteractionEvent>
+  readonly onDynamicLiveActivityRenderFailed: CodegenTypes.EventEmitter<VoltraDynamicLiveActivityRenderFailedEvent>
   readonly onStateChanged: CodegenTypes.EventEmitter<VoltraActivityUpdateEvent>
   readonly onActivityTokenReceived: CodegenTypes.EventEmitter<VoltraActivityTokenReceivedEvent>
   readonly onActivityPushToStartTokenReceived: CodegenTypes.EventEmitter<VoltraActivityPushToStartTokenReceivedEvent>
+  drainDynamicLiveActivityRenderFailures(): void
+  setDynamicLiveActivityRenderFailureListenerActive(active: boolean): void
   startLiveActivity(jsonString: string, options: StartVoltraOptions): Promise<string>
   updateLiveActivity(activityId: string, jsonString: string, options: UpdateVoltraOptions): Promise<void>
+  startDynamicLiveActivity(definitionId: string, propsJson: string, options: StartVoltraOptions): Promise<string>
+  updateDynamicLiveActivity(activityId: string, propsJson: string, options: UpdateVoltraOptions): Promise<void>
   endLiveActivity(activityId: string, options: EndVoltraOptions): Promise<void>
   endAllLiveActivities(): Promise<void>
   getLatestVoltraActivityId(): Promise<string | null>
   listVoltraActivityIds(): Promise<string[]>
+  getDynamicLiveActivityDefinitionIds(): Promise<string[]>
   isLiveActivityActive(activityName: string): boolean
   isHeadless(): boolean
   preloadImages(images: PreloadImageOptions[]): Promise<PreloadImagesResult>
   reloadLiveActivities(activityNames?: string[] | null): Promise<void>
+  reloadDynamicLiveActivities(definitionIds?: string[] | null): Promise<void>
   clearPreloadedImages(keys?: string[] | null): Promise<void>
   updateDynamicWidget(dynamicWidgetId: string, dynamicWidgetPropsJson: string): Promise<void>
   updateWidget(widgetId: string, jsonString: string, options: UpdateWidgetOptions): Promise<void>
@@ -107,6 +123,11 @@ export interface Spec extends TurboModule {
   clearWidget(widgetId: string): Promise<void>
   clearAllWidgets(): Promise<void>
   getActiveWidgets<T = unknown>(): Promise<T[]>
+  /** Settings are passed as JSON so an arbitrary `body` survives the bridge unchanged. */
+  setWidgetServerUpdate(settingsJson: string, widgetId?: string | null): Promise<void>
+  clearWidgetServerUpdate(widgetId?: string | null): Promise<void>
+  /** Result is JSON so an arbitrary `body` survives the bridge unchanged, or null. */
+  getWidgetServerUpdate(widgetId?: string | null): Promise<string | null>
   setWidgetServerCredentials(credentials: WidgetServerCredentials): Promise<void>
   clearWidgetServerCredentials(): Promise<void>
 }

package/src/types.ts

@@ -9,4 +9,8 @@ export type {
   VoltraNodeJson,
   VoltraPropValue,
   WidgetServerCredentials,
+  WidgetServerUpdateBody,
+  WidgetServerUpdateOptions,
+  WidgetServerUpdateSettings,
+  WidgetServerUpdateSnapshot,
 } from '@use-voltra/ios'

package/src/utils/enableDynamicLiveActivityHotReload.ts

@@ -0,0 +1,50 @@
+import { getFastRefreshHub } from '@use-voltra/ios'
+
+import { getNativeVoltra } from '../VoltraModule.js'
+
+declare global {
+  var __voltraDynamicLiveActivityDefinitionUpdated: ((definitionId: string) => void) | undefined
+}
+
+/**
+ * Reload Dynamic Live Activities after a Metro Fast Refresh patch. When Metro
+ * re-evaluates a generated definition entry, only that definition is reloaded.
+ * Component-only refresh boundaries do not re-evaluate their importer, so those
+ * patches fall back to reloading every Dynamic Live Activity definition.
+ * Legacy activities and Dynamic Widgets are unaffected.
+ *
+ * Subscribes to the shared {@link getFastRefreshHub} so multiple `__accept`
+ * calls from one save collapse into a single native reload.
+ */
+export function enableDynamicLiveActivityHotReload(): () => void {
+  if (!__DEV__) return () => {}
+
+  const hub = getFastRefreshHub()
+  const previousDefinitionUpdated = global.__voltraDynamicLiveActivityDefinitionUpdated
+  const updatedDefinitionIds = new Set<string>()
+
+  global.__voltraDynamicLiveActivityDefinitionUpdated = (definitionId) => {
+    // A generated entry re-evaluated inside a patch: batch it so the debounced
+    // flush reloads each changed definition exactly once. A signal that arrives
+    // outside a patch (the first require of a definition) has no flush coming,
+    // so reload it immediately.
+    if (hub.isAccepting) {
+      updatedDefinitionIds.add(definitionId)
+      return
+    }
+    void getNativeVoltra().reloadDynamicLiveActivities([definitionId])
+  }
+
+  const unsubscribe = hub.onPatch(() => {
+    const definitionIds = Array.from(updatedDefinitionIds)
+    updatedDefinitionIds.clear()
+    // No definition re-evaluated during this patch: a component-only boundary
+    // changed, so fall back to reloading every definition (null).
+    void getNativeVoltra().reloadDynamicLiveActivities(definitionIds.length > 0 ? definitionIds : null)
+  })
+
+  return () => {
+    unsubscribe()
+    global.__voltraDynamicLiveActivityDefinitionUpdated = previousDefinitionUpdated
+  }
+}

package/src/utils/enableWidgetHotReload.ts

@@ -1,14 +1,13 @@
-import { reloadWidgets } from '../widgets/widget-api.js'
+import { getFastRefreshHub } from '@use-voltra/ios'
 
-declare global {
-  var __accept: (...args: unknown[]) => void
-}
+import { reloadWidgets } from '../widgets/widget-api.js'
 
 /**
  * Trigger `reloadWidgets()` on every Metro Fast Refresh patch (DEV only).
  *
- * Hooks the global `__accept` callback Metro fires when a Fast Refresh patch
- * lands in the host app's JS runtime. When fired, calls
+ * Subscribes to the shared {@link getFastRefreshHub}, which wraps the global
+ * `__accept` callback Metro fires when a Fast Refresh patch lands in the host
+ * app's JS runtime. On each debounced patch it calls
  * `WidgetCenter.shared.reloadAllTimelines()` so WidgetKit re-invokes each widget
  * Provider, which re-fetches the freshest bundle from Metro and renders the
  * updated UI.
@@ -19,21 +18,15 @@ declare global {
  * workflow the dev still relies on WidgetKit's natural lifecycle refresh on
  * app foreground.
  *
- * Call once at app startup. Returns `dispose()` to restore the prior
- * `__accept` (rarely needed in practice). No-op in release builds.
+ * Call once at app startup. Returns `dispose()` to unsubscribe (rarely needed
+ * in practice). No-op in release builds.
  */
 export function enableWidgetHotReload(): () => void {
   if (!__DEV__) {
     return () => {}
   }
 
-  const oldAccept = global['__accept']
-  global['__accept'] = (...args) => {
+  return getFastRefreshHub().onPatch(() => {
     void reloadWidgets()
-    oldAccept?.(...args)
-  }
-
-  return () => {
-    global['__accept'] = oldAccept
-  }
+  })
 }