@scalebun/react-native 1.10.7 → 1.11.1

package/lib/commonjs/public/ScaleBunFacade.js

@@ -259,6 +259,11 @@ class ScaleBunFacade {
           _internalLogger.logger.warn('[ScaleBun] A signing key is pinned but no signature verifier is available. ' + 'Signature checking is fail-closed: updates will be REJECTED until one exists. ' + 'Install the optional peers `@noble/ed25519` + `@noble/hashes` (no further ' + 'code needed), or supply `ota.verifySignature`.');
         }
       }
+      // `healthyAfterMs` is the field BootGuardConfig actually declares.
+      // This passed `healthyTimeoutMs`, which nothing reads, so a host that
+      // tuned the boot-guard window silently got the 10s default instead.
+      // Both spellings are accepted so the older one keeps working.
+      const healthyAfterMs = typeof ota.healthyAfterMs === 'number' ? ota.healthyAfterMs : typeof ota.healthyTimeoutMs === 'number' ? ota.healthyTimeoutMs : undefined;
       otaOrchestrator.init({
         ...(signingRequested ? {
           signature: {
@@ -268,15 +273,123 @@ class ScaleBunFacade {
             verifier
           }
         } : {}),
-        ...(typeof ota.healthyTimeoutMs === 'number' ? {
-          healthyTimeoutMs: ota.healthyTimeoutMs
+        ...(healthyAfterMs !== undefined ? {
+          healthyAfterMs
         } : {})
       });
       _internalLogger.logger.info('[ScaleBun] OTA enabled from init config.');
+
+      // Run the checks the config asked for. Until this existed, `ota.enabled`
+      // initialised the orchestrator and then never checked anything: the
+      // documented `checkOnForeground` and `channelOverride` options were read
+      // by no code at all, and an app following the documented config received
+      // updates only if it ALSO drove `useOtaUpdate` or the CodePush shim by
+      // hand. Nothing logged, because "no update available" and "never asked"
+      // look identical from the outside.
+      this._startOtaChecks(ota);
     } catch (err) {
       _internalLogger.logger.warn(`[ScaleBun] OTA init failed: ${err?.message ?? err}`);
     }
   }
+
+  /** Guards against overlapping config-driven OTA checks. */
+  _otaCheckInFlight = false;
+  /** Wall clock of the last config-driven check, for the foreground floor. */
+  _otaLastCheckAt = 0;
+  _otaForegroundListener = null;
+
+  /**
+   * Minimum gap between config-driven checks.
+   *
+   * A foreground transition is cheap to trigger — app switchers, permission
+   * dialogs and share sheets all produce one — so an unthrottled check would
+   * put a request on the hot path every time the user glanced away. Ten
+   * minutes is well below any realistic release cadence and well above that
+   * noise. A host that wants a check on demand calls `useOtaUpdate().sync()`,
+   * which is never throttled.
+   */
+  static OTA_MIN_CHECK_INTERVAL_MS = 10 * 60 * 1000;
+
+  /**
+   * Drive OTA checks from init config: once at startup, then on each
+   * foreground when `checkOnForeground` is on (the schema default).
+   *
+   * `appVersion` is resolved from the native bridge rather than asked of the
+   * integrator, because it gates the server's `targetAppVersion` semver check
+   * — sending a wrong or invented value is worse than sending none, and there
+   * is no honest default. If it cannot be resolved, the check is skipped with
+   * a warning instead of guessing.
+   */
+  _startOtaChecks(ota) {
+    // Never in a debug build. `ScaleBunOtaModule.getJSBundleFile()` returns null
+    // there on purpose so Metro keeps ownership of the bundle — so a bundle
+    // downloaded in dev is installed into a slot that will never be loaded, and
+    // the identity check on the next launch then correctly observes that the
+    // running code is not what was installed and reports APPLY_FAILED. Checking
+    // at all in dev buys nothing and manufactures that false alarm. A developer
+    // testing the OTA path drives `useOtaUpdate().sync()` explicitly.
+    if (__DEV__) {
+      _internalLogger.logger.info('[ScaleBun] OTA checks are skipped in debug builds (Metro owns the bundle).');
+      return;
+    }
+    const runCheck = async trigger => {
+      if (this._otaCheckInFlight) return;
+      if (trigger === 'foreground' && Date.now() - this._otaLastCheckAt < ScaleBunFacade.OTA_MIN_CHECK_INTERVAL_MS) {
+        return;
+      }
+      const clientKey = this._clientKey;
+      const apiUrl = this._apiBaseUrl;
+      if (!clientKey || !apiUrl) return;
+      this._otaCheckInFlight = true;
+      try {
+        const info = await _bridgeAdapter.bridgeAdapter.getDeviceInfo();
+        const appVersion = info?.appVersion;
+        if (!appVersion) {
+          _internalLogger.logger.warn('[ScaleBun] OTA check skipped — the app version could not be read from the ' + 'native bridge. Rebuild the native app, or drive checks yourself with ' + 'useOtaUpdate({ appVersion }).');
+          return;
+        }
+        this._otaLastCheckAt = Date.now();
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const {
+          otaOrchestrator
+        } = require('../features/ota/OtaOrchestrator');
+        await otaOrchestrator.sync({
+          apiUrl,
+          clientKey,
+          appVersion,
+          // The documented option, finally connected. Omitted means the
+          // server's `default` channel, exactly as before.
+          channelName: typeof ota.channelOverride === 'string' ? ota.channelOverride : undefined
+          // Never forced from config: the release's own installMode
+          // decides when the app restarts, and yanking the screen out
+          // from under a user is not a decision this switch should make.
+        });
+      } catch (err) {
+        _internalLogger.logger.warn(`[ScaleBun] OTA check failed: ${err?.message ?? err}`);
+      } finally {
+        this._otaCheckInFlight = false;
+      }
+    };
+    void runCheck('startup');
+    if (ota.checkOnForeground === false) return;
+    if (this._otaForegroundListener) return; // idempotent across repeated init()
+    try {
+      // Through `appLifecycle`, not a second AppState subscription: the SDK
+      // already owns one and fanning out from it keeps every consumer on the
+      // same transition sequence.
+      // eslint-disable-next-line @typescript-eslint/no-var-requires
+      const {
+        appLifecycle
+      } = require('../core/lifecycle/appLifecycle');
+      this._otaForegroundListener = state => {
+        if (state === 'active') void runCheck('foreground');
+      };
+      appLifecycle.addListener(this._otaForegroundListener);
+    } catch {
+      // Lifecycle unavailable (tests, exotic hosts) — the startup check stands.
+      this._otaForegroundListener = null;
+    }
+  }
   _autoEnableDebug(debugConfig) {
     try {
       const dbgConfig = (0, _debug.buildDebugConfigFromInitConfig)(debugConfig);

package/lib/module/analytics/EventTracker.js

@@ -98,7 +98,7 @@ export class EventTracker {
     this.started = true;
     if (this.cfg.automaticEventTracking) {
       this.automaticEventsUnsubscribe = subscribeAutomaticEvents(event => {
-        this.track(event.name, event.properties);
+        this.track(event.name, event.properties, event.timestamp);
       });
     }
     if (this.cfg.autoLifecycleEvents) {
@@ -221,9 +221,9 @@ export class EventTracker {
 
   // ─── tracking ────────────────────────────────────────────────────────────
 
-  track(eventName, properties) {
+  track(eventName, properties, timestamp) {
     try {
-      this.enqueue(this.buildEnvelope(eventName, properties));
+      this.enqueue(this.buildEnvelope(eventName, properties, timestamp));
       try {
         this.cfg.onEvent?.(eventName);
       } catch {/* no-throw */}
@@ -360,7 +360,7 @@ export class EventTracker {
 
   // ─── internals ─────────────────────────────────────────────────────────────
 
-  buildEnvelope(eventName, properties) {
+  buildEnvelope(eventName, properties, timestamp) {
     const ctx = this.cfg.context ?? {};
     let canonicalSessionId;
     try {
@@ -371,7 +371,7 @@ export class EventTracker {
     const env = {
       event_id: uuid(),
       event_name: eventName,
-      event_time: Date.now(),
+      event_time: timestamp ?? Date.now(),
       app_id: this.cfg.appId,
       platform: this.cfg.platform ?? resolveEventPlatform(),
       installation_id: this.installationId,

package/lib/module/analytics/automaticEvents.js

@@ -19,10 +19,11 @@ function compactProperties(properties) {
   }
   return out;
 }
-export function emitAutomaticEvent(name, properties) {
+export function emitAutomaticEvent(name, properties, timestamp) {
   const event = {
     name,
-    properties: compactProperties(properties)
+    properties: compactProperties(properties),
+    timestamp
   };
   if (listeners.size === 0) {
     pending.push(event);

package/lib/module/core/constants/version.js

@@ -1,7 +1,12 @@
 /**
  * ScaleBun SDK version. Sent with the session-start envelope so the dashboard
  * can attribute telemetry to the SDK build that produced it.
- * Keep in sync with package.json "version".
+ * Keep in sync with package.json "version" — `version.test.ts` fails when they drift.
+ *
+ * Why the test matters: the 1.11.0 bump missed this line, so the build would have reported itself as
+ * 1.10.6. Every "is the release live, and on what share of traffic" question is answered from this
+ * value, so a stale one makes a rollout unobservable — which is the exact problem sending an SDK
+ * version was introduced to solve.
  */
-export const SDK_VERSION = '1.10.7';
+export const SDK_VERSION = '1.11.1';
 //# sourceMappingURL=version.js.map

package/lib/module/features/journey/ScaleBunDebugRoot.js

@@ -22,9 +22,9 @@
 
 import React, { useEffect, useRef, createContext, useContext } from 'react';
 import { View, NativeEventEmitter, NativeModules } from 'react-native';
-import { emitAutomaticEvent } from '../../analytics/automaticEvents';
 import { resolveTouchTarget, describeTouchTarget } from './touchTarget';
 import { resolvePlatformOS } from '../../core/context/device';
+import { INTERACTION_PROTOCOL_VERSION, generateInteractionId, nearestInteractionStart } from './interactionProtocol';
 
 // ─── Lazy imports to avoid native module cascade at load time ────────────────
 // We only import TYPE references at the top level; actual modules are require()'d
@@ -256,7 +256,9 @@ export function ScaleBunDebugRoot({
   // and forwards them to SessionManager as USER_ACTION events.
   const lastNativeTouchTsRef = useRef(0);
   const nativeTrackingConfirmedRef = useRef(false);
-  const pendingJsEmitRef = useRef(null);
+  const touchStartRef = useRef(null);
+  const interactionStartsRef = useRef([]);
+  const pendingJsEmitsRef = useRef(new Map());
   useEffect(() => {
     let subscription = null;
     try {
@@ -268,11 +270,15 @@ export function ScaleBunDebugRoot({
           // Record timestamp to suppress duplicate JS touch events
           lastNativeTouchTsRef.current = Date.now();
           nativeTrackingConfirmedRef.current = true;
-
-          // Cancel any pending JS emission — native event wins
-          if (pendingJsEmitRef.current !== null) {
-            clearTimeout(pendingJsEmitRef.current);
-            pendingJsEmitRef.current = null;
+          const nativeOccurredAt = typeof event.occurredAt === 'number' ? event.occurredAt : (typeof event.timestamp === 'number' ? event.timestamp : Date.now()) - (typeof event.durationMs === 'number' ? event.durationMs : 0);
+          const start = nearestInteractionStart(interactionStartsRef.current, nativeOccurredAt);
+
+          // Cancel only this physical touch's fallback. A single timer used to cancel a
+          // previous rapid tap and silently lose it on devices without native tracking.
+          if (start) {
+            const pending = pendingJsEmitsRef.current.get(start.interactionId);
+            if (pending !== undefined) clearTimeout(pending);
+            pendingJsEmitsRef.current.delete(start.interactionId);
           }
           const {
             SessionManager
@@ -294,6 +300,15 @@ export function ScaleBunDebugRoot({
             _diagWinH = _d.height;
           } catch {/* no-throw */}
           sm.onGestureDetected(event.gestureType || 'tap', {
+            interactionId: event.interactionId || start?.interactionId || generateInteractionId(),
+            interactionProtocol: event.interactionProtocol || INTERACTION_PROTOCOL_VERSION,
+            occurredAt: nativeOccurredAt,
+            ui: start?.ui,
+            stateStatus: start?.stateStatus ?? 'not_captured',
+            target: start?.target,
+            targetId: start?.targetId,
+            screenName: start?.screenName,
+            emitAutomaticAnalytics: start?.emitAutomaticAnalytics ?? captureAutomaticInteractions,
             x: event.rawX,
             y: event.rawY,
             // Use the actual native end coords when present, not the down
@@ -323,11 +338,12 @@ export function ScaleBunDebugRoot({
       try {
         subscription?.remove();
       } catch {/* no-throw */}
+      for (const timer of pendingJsEmitsRef.current.values()) clearTimeout(timer);
+      pendingJsEmitsRef.current.clear();
     };
-  }, []);
+  }, [captureAutomaticInteractions]);
 
   // ─── Touch Tracking State ───────────────────────────────────────────
-  const touchStartRef = useRef(null);
 
   // On-screen rect of the root view — the EXACT view the native screenshot
   // captures. Normalizing pageX/pageY against this rect makes JS-fallback taps
@@ -371,11 +387,37 @@ export function ScaleBunDebugRoot({
   const handleTouchStart = e => {
     try {
       const touch = e.nativeEvent;
-      touchStartRef.current = {
+      const target = resolveTouchTarget(e);
+      let ui;
+      let screenName;
+      try {
+        const {
+          uiStateSignature
+        } = require('./uiState');
+        ui = uiStateSignature();
+      } catch {/* no-throw */}
+      try {
+        const {
+          AutoScreenDetector
+        } = require('../navigation/AutoScreenDetector');
+        screenName = AutoScreenDetector.getInstance().getCurrentScreen() || undefined;
+      } catch {/* no-throw */}
+      const start = {
+        interactionId: generateInteractionId(),
+        occurredAt: Date.now(),
         x: touch.pageX,
         y: touch.pageY,
-        ts: Date.now()
+        locationX: touch.locationX,
+        locationY: touch.locationY,
+        target: describeTouchTarget(target),
+        targetId: target?.testID,
+        screenName,
+        ui,
+        stateStatus: ui ? 'captured_nonempty' : 'not_instrumented',
+        emitAutomaticAnalytics: captureAutomaticInteractions
       };
+      touchStartRef.current = start;
+      interactionStartsRef.current = interactionStartsRef.current.filter(candidate => start.occurredAt - candidate.occurredAt < 5000).concat(start).slice(-8);
     } catch {/* no-throw */}
   };
   const handleTouchEnd = e => {
@@ -414,15 +456,23 @@ export function ScaleBunDebugRoot({
       // WHAT was tapped, resolved from the React fiber on the touch event. Without this the tap
       // carries only coordinates, so every tap in the app groups into one row per gesture type.
       // Defensive by construction — returns undefined rather than throwing (see touchTarget.ts).
-      const tapped = describeTouchTarget(resolveTouchTarget(e));
+      const tapped = start?.target ?? describeTouchTarget(resolveTouchTarget(e));
       const gestureDetails = {
         target: tapped,
-        x: touch.pageX,
-        y: touch.pageY,
-        pageX: touch.pageX,
-        pageY: touch.pageY,
-        locationX: touch.locationX,
-        locationY: touch.locationY,
+        interactionId: start?.interactionId ?? generateInteractionId(),
+        interactionProtocol: INTERACTION_PROTOCOL_VERSION,
+        occurredAt: start?.occurredAt ?? Date.now(),
+        ui: start?.ui,
+        stateStatus: start?.stateStatus ?? 'not_captured',
+        targetId: start?.targetId,
+        screenName: start?.screenName,
+        emitAutomaticAnalytics: start?.emitAutomaticAnalytics ?? captureAutomaticInteractions,
+        x: start?.x ?? touch.pageX,
+        y: start?.y ?? touch.pageY,
+        pageX: start?.x ?? touch.pageX,
+        pageY: start?.y ?? touch.pageY,
+        locationX: start?.locationX ?? touch.locationX,
+        locationY: start?.locationY ?? touch.locationY,
         viewportWidth: vpW > 0 ? vpW : undefined,
         viewportHeight: vpH > 0 ? vpH : undefined
       };
@@ -434,8 +484,8 @@ export function ScaleBunDebugRoot({
       // measureInWindow returns rootRect.y = statusBarHeight, so subtracting it
       // double-counts the status bar and pushes every marker upward.
       if (rootRect && rootRect.w > 0 && rootRect.h > 0) {
-        const nx = Math.max(0, Math.min(1, touch.pageX / rootRect.w));
-        const ny = Math.max(0, Math.min(1, touch.pageY / rootRect.h));
+        const nx = Math.max(0, Math.min(1, (start?.x ?? touch.pageX) / rootRect.w));
+        const ny = Math.max(0, Math.min(1, (start?.y ?? touch.pageY) / rootRect.h));
         gestureDetails.normalizedX = nx;
         gestureDetails.normalizedY = ny;
         gestureDetails.normalizedPrecomputed = true;
@@ -467,7 +517,7 @@ export function ScaleBunDebugRoot({
         const dx = touch.pageX - start.x;
         const dy = touch.pageY - start.y;
         const dist = Math.sqrt(dx * dx + dy * dy);
-        const duration = Date.now() - start.ts;
+        const duration = Date.now() - start.occurredAt;
         gestureDetails.duration = duration;
         if (dist >= 15) {
           // Movement gesture: swipe or scroll
@@ -486,52 +536,6 @@ export function ScaleBunDebugRoot({
           gestureType = 'long_press';
         }
       }
-      const targetInfo = _extractTarget(e);
-      gestureDetails.target = targetInfo?.testId || targetInfo?.accessibilityLabel;
-      if (captureAutomaticInteractions) {
-        let screen;
-        try {
-          const {
-            AutoScreenDetector
-          } = require('../navigation/AutoScreenDetector');
-          screen = AutoScreenDetector.getInstance().getCurrentScreen() || undefined;
-        } catch {/* no-throw */}
-        /**
-         * UI STATE, read HERE and not later.
-         *
-         * A tap belongs to the surface that was on screen when the finger landed: tapping the
-         * filter button while the sheet is DOWN belongs to `closed`, because that is what the
-         * user was looking at when they reached for it. Reading it after the handler has run
-         * moves every "open the thing" tap into the state it created — the one state it
-         * certainly does not belong to.
-         *
-         * Declared-only on this platform (see uiState.ts): absent means not captured, which
-         * the dashboard keeps distinct from "nothing was open".
-         */
-        let ui;
-        try {
-          const {
-            uiStateSignature
-          } = require('./uiState');
-          ui = uiStateSignature();
-        } catch {/* no-throw: a tap must never be lost to state capture */}
-        emitAutomaticEvent('element_interacted', {
-          gesture_type: gestureType,
-          screen_name: screen,
-          /* THIS MAP ENUMERATES. A field added to the payload and forgotten here reaches the
-             backend as undefined with no error anywhere — the recurring defect class in this
-             codebase. `ui` is the key the grid aggregate reads for state, byte-identical to
-             the web SDK's, so one dashboard control queries both platforms. */
-          ui,
-          // testID/nativeID is an author-controlled stable identifier.
-          // Accessibility labels and rendered text are deliberately omitted.
-          target_id: targetInfo?.testId,
-          normalized_x: gestureDetails.normalizedX,
-          normalized_y: gestureDetails.normalizedY,
-          direction: gestureDetails.direction,
-          duration_ms: gestureDetails.duration
-        });
-      }
 
       // Feed the Engage gesture detector (rage_tap / dead_tap) — only committed
       // taps, not swipes/scrolls/long-presses. Pure JS, cross-platform; emits the
@@ -541,18 +545,11 @@ export function ScaleBunDebugRoot({
           const {
             gestureTriggerDetector
           } = require('../engage/gestureTriggerDetector');
-          let screen;
-          try {
-            const {
-              AutoScreenDetector
-            } = require('../navigation/AutoScreenDetector');
-            screen = AutoScreenDetector.getInstance().getCurrentScreen() || undefined;
-          } catch {/* no-throw */}
           gestureTriggerDetector.recordTap({
-            x: touch.pageX,
-            y: touch.pageY,
-            hasTarget: !!(targetInfo?.testId || targetInfo?.accessibilityLabel),
-            screen
+            x: start?.x ?? touch.pageX,
+            y: start?.y ?? touch.pageY,
+            hasTarget: !!(start?.targetId || start?.target),
+            screen: start?.screenName
           });
         } catch {/* no-throw */}
       }
@@ -567,7 +564,7 @@ export function ScaleBunDebugRoot({
       // screenshot capture view). Three-tier suppression:
       //   1. Native confirmed active → skip JS entirely (native handles all touches)
       //   2. Native event within 300ms → skip (existing dedup)
-      //   3. First touch (native not yet confirmed) → defer 200ms to let native arrive
+      //   3. First touch (native not yet confirmed) → defer 600ms to let native arrive
       const sinceNative = Date.now() - lastNativeTouchTsRef.current;
       if (nativeTrackingConfirmedRef.current) {
         // Native tracker is active — skip JS path entirely
@@ -580,11 +577,9 @@ export function ScaleBunDebugRoot({
         const capturedDetails = {
           ...gestureDetails
         };
-        if (pendingJsEmitRef.current !== null) {
-          clearTimeout(pendingJsEmitRef.current);
-        }
-        pendingJsEmitRef.current = setTimeout(() => {
-          pendingJsEmitRef.current = null;
+        const interactionId = capturedDetails.interactionId;
+        const timer = setTimeout(() => {
+          pendingJsEmitsRef.current.delete(interactionId);
           if (nativeTrackingConfirmedRef.current) return;
           try {
             const {
@@ -608,6 +603,7 @@ export function ScaleBunDebugRoot({
           // devices with no native tracker at all it merely delays a background emission,
           // which nothing user-visible waits on.
         }, 600);
+        pendingJsEmitsRef.current.set(interactionId, timer);
       }
       touchStartRef.current = null;
     } catch {/* no-throw */}
@@ -722,25 +718,6 @@ export function useScaleBunScreen(name) {
   }, [name, manager]);
 }
 
-// ─── Helpers ────────────────────────────────────────────────────────────────
-
-function _extractTarget(e) {
-  try {
-    const target = e?.target;
-    if (!target) return undefined;
-
-    // React Native nativeEvent target properties
-    const props = target._internalFiberInstanceHandleDEV?.memoizedProps ?? {};
-    return {
-      testId: props.testID || props.nativeID || undefined,
-      accessibilityLabel: props.accessibilityLabel || undefined,
-      text: undefined
-    };
-  } catch {
-    return undefined;
-  }
-}
-
 // ─── Styles ─────────────────────────────────────────────────────────────────
 // IMPORTANT: Do NOT use StyleSheet.create() here.
 // In RN 0.84 bridgeless mode, StyleSheet.create() calls

package/lib/module/features/journey/interactionProtocol.js

@@ -0,0 +1,38 @@
+/** One physical interaction, shared by replay and analytics projections. */
+export const INTERACTION_PROTOCOL_VERSION = 1;
+export function generateInteractionId() {
+  return `ixj-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+}
+
+/** Match a native bridge event to the JS evidence sampled at the same finger-down. */
+export function nearestInteractionStart(starts, occurredAt, toleranceMs = 1500) {
+  let best;
+  let bestDelta = toleranceMs + 1;
+  for (const start of starts) {
+    const delta = Math.abs(start.occurredAt - occurredAt);
+    if (delta < bestDelta) {
+      best = start;
+      bestDelta = delta;
+    }
+  }
+  return bestDelta <= toleranceMs ? best : undefined;
+}
+
+/** Analytics is a projection of the same evidence; no second click is invented. */
+export function automaticInteractionProperties(payload, screenName, canonicalMirror) {
+  return {
+    gesture_type: payload.gestureType,
+    screen_name: screenName,
+    interaction_id: payload.interaction_id,
+    interaction_protocol: payload.interaction_protocol,
+    state_status: payload.state_status,
+    ui: payload.ui,
+    target_id: payload.target_id,
+    normalized_x: payload.normalizedX,
+    normalized_y: payload.normalizedY,
+    direction: payload.direction,
+    duration_ms: payload.durationMs,
+    canonical_mirror: canonicalMirror || undefined
+  };
+}
+//# sourceMappingURL=interactionProtocol.js.map

package/lib/module/features/journey/uiState.js

@@ -74,6 +74,13 @@ export function uiStateSignature() {
   if (!declared.size) return undefined;
   /* SORTED, or the same surface produces different signatures depending on the order the host happened
      to declare things in, and every count fragments into several that mean nothing. */
-  return [...declared.keys()].sort().map(k => `${k}:${declared.get(k)}`).join(';').slice(0, 96);
+  const pairs = [...declared.keys()].sort().map(k => `${k}:${declared.get(k)}`);
+  let signature = '';
+  for (const pair of pairs) {
+    const next = signature ? `${signature};${pair}` : pair;
+    if (next.length > 96) break;
+    signature = next;
+  }
+  return signature || undefined;
 }
 //# sourceMappingURL=uiState.js.map