@aguacerowx/react-native 0.0.46 → 0.0.49

package/src/dispatchViewManagerCommandCompat.js

@@ -0,0 +1,100 @@
+import { satBridgeWarn } from './satelliteBridgeDiag';
+
+/**
+ * Dispatches native view-manager commands on both the New Architecture (Fabric `HostInstance`)
+ * and the legacy Paper renderer (`reactTag` from {@code findNodeHandle}).
+ *
+ * Codegen views that only used {@code UIManager.dispatchViewManagerCommand(findNodeHandle(...))}
+ * silently no-op on Fabric when {@code findNodeHandle} returns null — satellite/NEXRAD/grid
+ * commands never reach native.
+ *
+ * @param {React.RefObject | { current: unknown }} nativeRef
+ * @param {string} viewManagerName e.g. `'SatelliteLayer'`
+ * @param {string} commandName e.g. `'syncSatellite'` (must match native Commands export)
+ * @param {Array<unknown>} args
+ * @returns {boolean} true if a dispatch path ran
+ */
+export function dispatchViewManagerCommandCompat(nativeRef, viewManagerName, commandName, args) {
+    const node = nativeRef?.current;
+    const nodeDesc =
+        node == null
+            ? 'null'
+            : `${typeof node}${node?.constructor?.name ? ':' + node.constructor.name : ''}`;
+    if (node == null) {
+        satBridgeWarn(`dispatch:${commandName}:abort`, {
+            reason: 'nativeRef.current is null — SatelliteLayer native view never mounted or ref not attached',
+            viewManagerName,
+        });
+        return false;
+    }
+
+    const { UIManager, findNodeHandle } = require('react-native');
+    let cmdId;
+    let commandsKeys = [];
+    try {
+        const cfg = UIManager.getViewManagerConfig(viewManagerName);
+        commandsKeys = cfg?.Commands ? Object.keys(cfg.Commands) : [];
+        cmdId = cfg?.Commands?.[commandName];
+    } catch (e) {
+        cmdId = null;
+        satBridgeWarn(`dispatch:${commandName}:uimanager-error`, { viewManagerName, message: String(e) });
+    }
+
+    satBridgeWarn(`dispatch:${commandName}:try-paper`, {
+        viewManagerName,
+        nodeDesc,
+        cmdId: cmdId ?? 'MISSING',
+        commandsKeys,
+        argsSummary:
+            commandName === 'syncSatellite' && args?.[0]
+                ? `jsonLen=${String(args[0]).length}`
+                : `argsLen=${args?.length ?? 0}`,
+    });
+
+    // Prefer legacy Paper dispatch when we have a react tag — matches Grid/NEXRAD paths that still work on bridge mode.
+    if (cmdId != null) {
+        const tag = findNodeHandle(node);
+        if (tag != null) {
+            try {
+                UIManager.dispatchViewManagerCommand(tag, cmdId, args);
+                satBridgeWarn(`dispatch:${commandName}:ok-paper`, { reactTag: tag, cmdId });
+                return true;
+            } catch (e) {
+                satBridgeWarn(`dispatch:${commandName}:paper-threw`, { message: String(e), reactTag: tag });
+            }
+        } else {
+            satBridgeWarn(`dispatch:${commandName}:paper-skip`, {
+                reason: 'findNodeHandle(node) is null (typical on Fabric — will try RendererProxy.dispatchCommand)',
+            });
+        }
+    } else {
+        satBridgeWarn(`dispatch:${commandName}:no-cmdId`, {
+            reason: 'UIManager has no Commands entry — view manager name mismatch or pod not linked',
+            viewManagerName,
+        });
+    }
+
+    // Fabric / bridgeless: HostInstance + command name (string). Required when findNodeHandle is null.
+    try {
+        const RendererProxy = require('react-native/Libraries/ReactNative/RendererProxy');
+        if (typeof RendererProxy.dispatchCommand === 'function') {
+            RendererProxy.dispatchCommand(node, commandName, args);
+            satBridgeWarn(`dispatch:${commandName}:ok-fabric`, {
+                note: 'dispatched via RendererProxy.dispatchCommand(string name)',
+            });
+            return true;
+        }
+        satBridgeWarn(`dispatch:${commandName}:no-rendererProxy`, {
+            reason: 'RendererProxy.dispatchCommand missing',
+        });
+    } catch (e) {
+        satBridgeWarn(`dispatch:${commandName}:fabric-threw`, { message: String(e) });
+    }
+
+    satBridgeWarn(`dispatch:${commandName}:FAILED`, {
+        viewManagerName,
+        nodeDesc,
+        hadCmdId: cmdId != null,
+    });
+    return false;
+}

package/src/index.js

@@ -0,0 +1,7 @@
+export { MapManager } from './MapManager';
+export { WeatherLayerManager } from './WeatherLayerManager';
+export { default as GridRenderLayer } from './GridRenderLayerNativeComponent';
+export {
+  AGUACERO_NEXRAD_MAP_LAYER_ID,
+  AGUACERO_SATELLITE_MAP_LAYER_ID,
+} from './nws/nwsAndroidConstants';

package/src/nexrad/nexradAndroidController.js

@@ -8,6 +8,7 @@ import {
     objectKeyToUrl,
     setNexradArchiveApiKey,
     setNexradArchiveBundleId,
+    setNexradArchiveSiteOrigin,
     setNexradSitesJsonUrl,
     setNexradSitesFetchAuth,
 } from './radarArchiveCore.bundled.js';
@@ -15,7 +16,8 @@ import { prepareRadarFrameForGpuReadout } from './radarFrameGpuMatch.bundled.js'
 import { mapboxFrameUploadOptionsForNexradState } from './nexradMapboxFrameOpts.bundled.js';
 import { sampleNexradFrameAtLatLon } from './nexradCrossSectionSampleAtLatLon.bundled.js';
 import { buildNexradLutRgba } from './nexradLutBuild.js';
-import { nexradDiag, nexradDiagBootSnapshot, nexradDiagGateTextureSummary, nexradPerfSpan } from './nexradDiag.js';
+import { Platform } from 'react-native';
+import { nexradDiagBootSnapshot, nexradDiagGateTextureSummary, nexradPerfSpan } from './nexradDiag.js';
 
 nexradDiagBootSnapshot({
     archiveExports: {
@@ -33,15 +35,6 @@ function ensureRadarArchiveBindings(label) {
         typeof setNexradArchiveBundleId === 'function' &&
         typeof objectKeyToUrl === 'function' &&
         typeof fetchAndParseArchive === 'function';
-    if (!ok) {
-        nexradDiag('archive.bindings.missing', {
-            where: label,
-            setNexradArchiveApiKey: typeof setNexradArchiveApiKey,
-            setNexradArchiveBundleId: typeof setNexradArchiveBundleId,
-            objectKeyToUrl: typeof objectKeyToUrl,
-            fetchAndParseArchive: typeof fetchAndParseArchive,
-        });
-    }
     return ok;
 }
 
@@ -178,7 +171,8 @@ function formatNexradInspectNumeric(raw, radarVariable) {
 }
 
 /** Keep low so Level-2 decode stays off the critical path for touches/animations (was 4). */
-const PRELOAD_CONCURRENCY = 1;
+/** iOS Metal uploads benefit from overlapping fetches; keep Android at 1 for steadier radio/CPU. */
+const PRELOAD_CONCURRENCY = Platform.OS === 'ios' ? 2 : 1;
 
 function yieldToJsEventLoop() {
     return new Promise((resolve) => setTimeout(resolve, 0));
@@ -251,27 +245,19 @@ export class NexradAndroidController {
                     const k = e && e.nativeGpuCacheKey;
                     if (typeof k === 'string' && k.length > 0) {
                         this._nativeGpuReadyKeys.add(k);
-                        this._trimNativeGpuReadyKeys(32);
-                        nexradDiag('gpuReady.event', { keyTail: k.slice(-80), setSize: this._nativeGpuReadyKeys.size });
+                        this._trimNativeGpuReadyKeys(96);
                     }
                 });
             }
         } catch (err) {
-            nexradDiag('gpuReady.subscribeFailed', { message: err?.message || String(err) });
+            /* ignore */
         }
         const base = typeof core?.baseGridUrl === 'string' ? core.baseGridUrl.replace(/\/$/, '') : '';
         if (base && typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
             setNexradSitesJsonUrl(`${base}/data/nexrad.json`);
             setNexradSitesFetchAuth(core.apiKey || '', core.bundleId || '');
         }
-        nexradDiag('controller.construct', {
-            hasCore: !!core,
-            apiKeyLen: (core?.apiKey || '').length,
-            bundleIdLen: (core?.bundleId || '').length,
-            interpolateColormap: this._interpolateColormap,
-            gateSmoothing: this._gateSmoothing,
-            rnSitesUrl: base ? `${base}/data/nexrad.json` : '(unset)',
-        });
+        setNexradArchiveSiteOrigin(core.gridRequestSiteOrigin || '');
     }
 
     _trimNativeGpuReadyKeys(max) {
@@ -301,7 +287,6 @@ export class NexradAndroidController {
     }
 
     destroy() {
-        nexradDiag('controller.destroy');
         try {
             this._gpuReadyEventSub?.remove();
         } catch (_) {
@@ -403,6 +388,34 @@ export class NexradAndroidController {
         return `${syncKey}|o:${state.opacity ?? 1}|g:${this._gateSmoothing ? 1 : 0}|i:${this._interpolateColormap ? 1 : 0}`;
     }
 
+    /**
+     * After JS decoded a frame into `_frameCache`, optionally push it through the native bridge.
+     * During timeline preload we **only** upload the **currently displayed** unix to Metal; other
+     * volumes stay in the JS cache until {@link sync} needs them (avoids 40+ full decodes on load).
+     */
+    _primeNativeGpuUploadIfNeeded(snapshot, unix, p, frame, abortSignal) {
+        if (!frame || !p || (abortSignal && abortSignal.aborted)) return;
+        try {
+            const displayUx =
+                snapshot.nexradTimestamp != null && Number.isFinite(Number(snapshot.nexradTimestamp))
+                    ? Number(snapshot.nexradTimestamp)
+                    : NaN;
+            if (Number.isFinite(displayUx) && Number(unix) !== displayUx) {
+                return;
+            }
+            const syncKey = this._syncIdentity(snapshot, p, unix);
+            if (this._nativeGpuReadyKeys.has(syncKey)) {
+                return;
+            }
+            if (!this._native()?.uploadNexradFrame) {
+                return;
+            }
+            this._uploadFrameToNative(snapshot, frame, p, unix);
+        } catch (err) {
+            /* ignore */
+        }
+    }
+
     /**
      * @param {*} state
      * @param {*} frame - decoded archive frame
@@ -415,10 +428,6 @@ export class NexradAndroidController {
         );
         const n = this._native();
         if (!n?.uploadNexradFrame) {
-            nexradDiag('native.uploadSkipped', {
-                reason: !n ? 'noLayerRef' : 'noUploadNexradFrameMethod',
-                site: state.nexradSite,
-            });
             uploadTotal.end({ outcome: 'skippedNoNative' });
             return;
         }
@@ -430,11 +439,6 @@ export class NexradAndroidController {
             this._lastUploadMeta = { valueScale: lruHit.valueScale, valueOffset: lruHit.valueOffset };
             this._rememberUploadMetaForSyncKey(syncKey, lruHit.valueScale, lruHit.valueOffset);
             if (n.activateNexradCachedFrame && this._nativeGpuReadyKeys.has(syncKey)) {
-                nexradDiag('native.uploadFrame.gpuActivateOnly', {
-                    site: state.nexradSite,
-                    syncKeyTail: syncKey.slice(-80),
-                    jsonCharsSkipped: lruHit.json.length,
-                });
                 const tAct = nexradPerfSpan('uploadFrame.nativeGpuActivateOnly');
                 n.activateNexradCachedFrame(syncKey);
                 tAct.end({ keyLen: syncKey.length });
@@ -445,10 +449,6 @@ export class NexradAndroidController {
                 uploadTotal.end({ outcome: 'gpuActivateOnly', jsonCharsSkipped: lruHit.json.length });
                 return;
             }
-            nexradDiag('native.uploadFrame.jsonLruHit', {
-                site: state.nexradSite,
-                jsonChars: lruHit.json.length,
-            });
             const bridge = nexradPerfSpan('uploadFrame.nativeJsonLru.bridgeDispatch');
             n.uploadNexradFrame(lruHit.json);
             bridge.end({ jsonChars: lruHit.json.length, path: 'jsonLruHit' });
@@ -535,17 +535,6 @@ export class NexradAndroidController {
             style.lutMin,
             style.lutMax,
         );
-        nexradDiag('native.uploadFrame.dispatch', {
-            site: state.nexradSite,
-            nGates: rawFrame.nGates,
-            nRays: rawFrame.nRays,
-            jsonChars: json.length,
-            uploadOpts: uploadOpts ?? null,
-            rayBoundaryLen: rayBoundaries.length,
-            firstGateKm: rawFrame.firstGateKm,
-            gateWidthKm: rawFrame.gateWidthKm,
-            gateSummary,
-        });
 
         const tBridge = nexradPerfSpan('uploadFrame.nativeBridge_uploadNexradFrame');
         n.uploadNexradFrame(json);
@@ -622,13 +611,6 @@ export class NexradAndroidController {
         const { timeToKeyMap, motionMap } = this._resolveListingContext(state);
         const objectKey = timeToKeyMap[String(unix)];
         if (!objectKey) {
-            nexradDiag('fetchParams.noObjectKeyForUnix', {
-                unix,
-                radarVar,
-                radarSource,
-                timeToKeyMapSize: Object.keys(timeToKeyMap || {}).length,
-                sampleUnixKeys: Object.keys(timeToKeyMap || {}).slice(0, 12),
-            });
             return null;
         }
 
@@ -703,8 +685,21 @@ export class NexradAndroidController {
 
         if (!ensureRadarArchiveBindings('preloadAllAvailable')) return;
 
+        const times = [...(state.availableNexradTimestamps || [])]
+            .map(Number)
+            .filter((t) => Number.isFinite(t));
+        if (!times.length) {
+            // Important: do not touch `_preloadTimelineSig` or the frame cache here — callers
+            // sometimes pass `core.state` before `availableNexradTimestamps` is committed; an
+            // empty list must not poison the signature or wipe the LRU (see WeatherLayerManager
+            // preload kick merging subscription snapshot).
+            return;
+        }
+
         const sig = this._preloadTimelineSignature(state);
-        if (sig === this._preloadTimelineSig) return;
+        if (sig === this._preloadTimelineSig) {
+            return;
+        }
 
         this._preloadTimelineSig = sig;
         this._preloadAbort?.abort();
@@ -718,40 +713,33 @@ export class NexradAndroidController {
             state.nexradTimestamp != null && Number.isFinite(Number(state.nexradTimestamp))
                 ? Number(state.nexradTimestamp)
                 : NaN;
-        const curP = Number.isFinite(curUnix) ? this._buildFetchParamsForUnix(state, curUnix) : null;
-        let preservedFetchKey = null;
-        let preservedFrame = null;
-        if (curP && this._frameCache.has(curP.fetchKey)) {
-            preservedFetchKey = curP.fetchKey;
-            preservedFrame = this._frameCache.get(curP.fetchKey);
+
+        // Keep frames that are still in the new timeline (or the currently displayed one)
+        // to avoid re-fetching them when expanding the duration window.
+        const validFetchKeys = new Set();
+        for (const unix of times) {
+            const p = this._buildFetchParamsForUnix(state, unix);
+            if (p) validFetchKeys.add(p.fetchKey);
         }
+        
+        const curP = Number.isFinite(curUnix) ? this._buildFetchParamsForUnix(state, curUnix) : null;
+        if (curP) validFetchKeys.add(curP.fetchKey);
 
-        this._frameCache.clear();
-        if (preservedFetchKey && preservedFrame) {
-            this._frameCache.set(preservedFetchKey, preservedFrame);
+        for (const key of this._frameCache.keys()) {
+            if (!validFetchKeys.has(key)) {
+                this._frameCache.delete(key);
+            }
         }
-        this._nativeUploadJsonLru.clear();
-        this._nativeGpuReadyKeys.clear();
-        this._uploadMetaBySyncKey.clear();
+        // Do NOT clear `_nativeGpuReadyKeys` / JSON LRU / upload meta here: that forced a full
+        // ~1MB JSON parse + native decode on every timeline scrub after prefetch. GPU cache keys
+        // stay valid while Metal still holds the slot; `sync` falls back to full upload if needed.
+        // (Controller `destroy()` still clears everything on site/mode teardown.)
 
         setNexradArchiveApiKey(this.core.apiKey || '');
         setNexradArchiveBundleId(this.core.bundleId || '');
+        setNexradArchiveSiteOrigin(this.core.gridRequestSiteOrigin || '');
         setNexradSitesFetchAuth(this.core.apiKey || '', this.core.bundleId || '');
 
-        const times = [...(state.availableNexradTimestamps || [])]
-            .map(Number)
-            .filter((t) => Number.isFinite(t));
-        if (!times.length) {
-            nexradDiag('preload.skipNoTimestamps', { site: state.nexradSite });
-            return;
-        }
-
-        nexradDiag('preload.start', {
-            site: state.nexradSite,
-            timesCount: times.length,
-            firstUnix: times[0],
-            lastUnix: times[times.length - 1],
-        });
 
         const snapshot = { ...state };
         const preloadBatch = nexradPerfSpan(`preload.batch site=${state.nexradSite} times=${times.length}`);
@@ -760,6 +748,22 @@ export class NexradAndroidController {
         let preloadSkippedCached = 0;
 
         const run = async () => {
+            // Prime the visible unix first so the active frame hits GPU before background slots.
+            const curUx =
+                snapshot.nexradTimestamp != null && Number.isFinite(Number(snapshot.nexradTimestamp))
+                    ? Number(snapshot.nexradTimestamp)
+                    : NaN;
+            if (Number.isFinite(curUx)) {
+                const p0 = this._buildFetchParamsForUnix(snapshot, curUx);
+                if (p0) {
+                    const fr0 = this._frameCache.get(p0.fetchKey);
+                    if (fr0) {
+                        this._primeNativeGpuUploadIfNeeded(snapshot, curUx, p0, fr0, signal);
+                        await yieldToJsEventLoop();
+                    }
+                }
+            }
+
             let cursor = 0;
             const work = async () => {
                 while (cursor < times.length && !signal.aborted) {
@@ -771,6 +775,9 @@ export class NexradAndroidController {
                         slot.end({ outcome: 'noParamsOrAborted' });
                     } else if (this._frameCache.has(p.fetchKey)) {
                         preloadSkippedCached++;
+                        const cachedFrame = this._frameCache.get(p.fetchKey);
+                        this._primeNativeGpuUploadIfNeeded(snapshot, unix, p, cachedFrame, signal);
+                        await yieldToJsEventLoop();
                         slot.end({ outcome: 'alreadyCached', fetchKeyTail: p.fetchKey.slice(-64) });
                     } else {
                         try {
@@ -781,6 +788,8 @@ export class NexradAndroidController {
                             if (frame && !signal.aborted) {
                                 this._frameCache.set(p.fetchKey, frame);
                                 preloadCompleted++;
+                                this._primeNativeGpuUploadIfNeeded(snapshot, unix, p, frame, signal);
+                                await yieldToJsEventLoop();
                                 slot.end({
                                     outcome: 'cachedFrame',
                                     fetchKeyTail: p.fetchKey.slice(-64),
@@ -791,10 +800,6 @@ export class NexradAndroidController {
                             }
                         } catch (err) {
                             preloadFailed++;
-                            nexradDiag('preload.fetchFailed', {
-                                unix,
-                                message: err?.message || String(err),
-                            });
                             slot.end({ outcome: 'error', message: err?.message || String(err) });
                         }
                     }
@@ -802,12 +807,29 @@ export class NexradAndroidController {
                 }
             };
             await Promise.all(Array.from({ length: PRELOAD_CONCURRENCY }, () => work()));
+
+            // Catch-up: any unix still missing a GPU slot (e.g. layer mounted mid-preload) gets one upload pass.
+            if (!signal.aborted) {
+                for (let i = 0; i < times.length && !signal.aborted; i++) {
+                    const unix = times[i];
+                    const p = this._buildFetchParamsForUnix(snapshot, unix);
+                    if (!p) continue;
+                    const frame = this._frameCache.get(p.fetchKey);
+                    if (!frame) continue;
+                    const syncKey = this._syncIdentity(snapshot, p, unix);
+                    if (this._nativeGpuReadyKeys.has(syncKey)) continue;
+                    this._primeNativeGpuUploadIfNeeded(snapshot, unix, p, frame, signal);
+                    await yieldToJsEventLoop();
+                }
+            }
+
             preloadBatch.end({
                 outcome: signal.aborted ? 'aborted' : 'complete',
                 completed: preloadCompleted,
                 failed: preloadFailed,
                 skippedCached: preloadSkippedCached,
                 finalCacheSize: this._frameCache.size,
+                gpuReadyCount: this._nativeGpuReadyKeys.size,
             });
         };
 
@@ -821,11 +843,6 @@ export class NexradAndroidController {
         );
 
         if (!state.isNexrad || !state.nexradSite || state.nexradTimestamp == null) {
-            nexradDiag('sync.skipped', {
-                isNexrad: state.isNexrad,
-                site: state.nexradSite,
-                nexradTimestamp: state.nexradTimestamp,
-            });
             this.destroy();
             syncTotal.end({ outcome: 'skippedNotNexradOrMissing' });
             return;
@@ -839,30 +856,17 @@ export class NexradAndroidController {
         const tAuth = nexradPerfSpan('sync.setArchiveAuth');
         setNexradArchiveApiKey(this.core.apiKey || '');
         setNexradArchiveBundleId(this.core.bundleId || '');
+        setNexradArchiveSiteOrigin(this.core.gridRequestSiteOrigin || '');
         setNexradSitesFetchAuth(this.core.apiKey || '', this.core.bundleId || '');
         tAuth.end({});
 
         const unix = Number(state.nexradTimestamp);
-        nexradDiag('sync.enter', {
-            site: state.nexradSite,
-            unix,
-            product: state.nexradProduct,
-            source: state.nexradDataSource,
-            apiKeyLen: (this.core.apiKey || '').length,
-        });
 
         const tParams = nexradPerfSpan('sync.buildFetchParams');
         const p = this._buildFetchParamsForUnix(state, unix);
         tParams.end({ ok: !!p });
         if (!p) {
             const ctx = this._resolveListingContext(state);
-            nexradDiag('sync.abortedNoFetchParams', {
-                site: state.nexradSite,
-                unix,
-                cacheKey: ctx.nk,
-                timeToKeyMapSize: Object.keys(ctx.timeToKeyMap || {}).length,
-                sampleTimeKeys: Object.keys(ctx.timeToKeyMap || {}).slice(0, 8),
-            });
             syncTotal.end({ outcome: 'noFetchParams' });
             return;
         }
@@ -873,7 +877,6 @@ export class NexradAndroidController {
 
         const jsCachedForShortCircuit = this._frameCache.get(p.fetchKey);
         if (syncKey === this._lastSyncKey && this._nativeFrameUploaded && jsCachedForShortCircuit) {
-            nexradDiag('sync.styleOnlyShortCircuit', { site: state.nexradSite });
             const tStyle = nexradPerfSpan('sync.shortCircuit_styleOnly');
             this.applyStyleFromState(state);
             tStyle.end({});
@@ -889,12 +892,6 @@ export class NexradAndroidController {
         if (cached && this._nativeGpuReadyKeys.has(syncKey)) {
             const n = this._native();
             if (n?.activateNexradCachedFrame) {
-                nexradDiag('sync.gpuCacheActivate.enter', {
-                    site: state.nexradSite,
-                    unix,
-                    syncKeyTail: syncKey.slice(-80),
-                    gpuReadySetSize: this._nativeGpuReadyKeys.size,
-                });
                 const tAct = nexradPerfSpan('sync.dispatchActivateCachedFrame');
                 n.activateNexradCachedFrame(syncKey);
                 tAct.end({ keyLen: syncKey.length });
@@ -920,7 +917,6 @@ export class NexradAndroidController {
         });
 
         if (cached) {
-            nexradDiag('sync.uploadFromCache', { fetchKeyTail: p.fetchKey.slice(-80) });
             const tUpload = nexradPerfSpan('sync.uploadFromMemoryCache_toNative');
             this._uploadFrameToNative(state, cached, p, unix);
             tUpload.end({});
@@ -932,7 +928,6 @@ export class NexradAndroidController {
         this._abort?.abort();
         this._abort = new AbortController();
 
-        nexradDiag('fetch.start', { objectKey: p.objectKey, radarVar: p.radarVar, radarSource: p.radarSource });
 
         let frame;
         try {
@@ -941,13 +936,11 @@ export class NexradAndroidController {
                 priority: 'display',
             });
         } catch (err) {
-            nexradDiag('fetch.error', { message: err?.message || String(err) });
             syncTotal.end({ outcome: 'fetchThrew', message: err?.message || String(err) });
             return;
         }
 
         if (!frame || this._abort.signal.aborted) {
-            nexradDiag('fetch.noFrame', { aborted: this._abort.signal.aborted, hadFrame: !!frame });
             syncTotal.end({
                 outcome: 'fetchNoFrame',
                 aborted: this._abort.signal.aborted,
@@ -960,7 +953,6 @@ export class NexradAndroidController {
         this._frameCache.set(p.fetchKey, frame);
         tPut.end({ cacheSizeAfter: this._frameCache.size });
 
-        nexradDiag('fetch.ok', { fetchKeyTail: p.fetchKey.slice(-80) });
         const tUploadFetched = nexradPerfSpan('sync.uploadFetchedFrame_toNative');
         this._uploadFrameToNative(state, frame, p, unix);
         tUploadFetched.end({});

package/src/nexrad/nexradDiag.js

@@ -1,14 +1,38 @@
 /**
  * NEXRAD pipeline diagnostics (Android / Metro).
  *
- * All output is off unless you set {@code global.__AGUACERO_NEXRAD_DEBUG = true}
- * (then filter {@code [Aguacero][NEXRAD]} and {@code [Aguacero][NEXRAD][PERF]}).
+ * Verbose phases / perf: off unless {@code global.__AGUACERO_NEXRAD_DEBUG = true}
+ * (filter {@code [Aguacero][NEXRAD]} and {@code [Aguacero][NEXRAD][PERF]}).
+ *
+ * Legacy pipe line-by-line bridge logs: only if {@code global.__AGUACERO_NEXRAD_PIPE_TRACE = true}.
  */
 
 export function nexradDiagEnabled() {
     return typeof globalThis !== 'undefined' && globalThis.__AGUACERO_NEXRAD_DEBUG === true;
 }
 
+/**
+ * Opt-in only — line-by-line bridge logs.
+ * @param {string} tag
+ * @param {Record<string, unknown>} [detail]
+ */
+export function nexradPipeTrace(tag, detail) {
+    if (typeof globalThis === 'undefined' || globalThis.__AGUACERO_NEXRAD_PIPE_TRACE !== true) {
+        return;
+    }
+    try {
+        const msg =
+            detail !== undefined && detail !== null && typeof detail === 'object'
+                ? JSON.stringify(detail)
+                : detail === undefined || detail === null
+                  ? ''
+                  : String(detail);
+        console.warn(`[Aguacero][NEXRAD][PIPE] ${tag}`, msg);
+    } catch {
+        console.warn(`[Aguacero][NEXRAD][PIPE] ${tag}`, '(unserializable detail)');
+    }
+}
+
 export function nexradDiag(phase, detail) {
     if (!nexradDiagEnabled()) return;
     if (detail !== undefined) {

package/src/nexrad/nexradNativeCommandIds.js

@@ -0,0 +1,44 @@
+/**
+ * Resolves the second argument to {@code UIManager.dispatchViewManagerCommand}.
+ *
+ * - **Android**: prefers {@code UIManager.getViewManagerConfig('NexradRadarLayer').Commands}
+ *   then numeric fallback matching {@code NexradRadarManager.java} {@code getCommandsMap}.
+ *
+ * - **iOS New Architecture (Fabric)**: numeric IDs do **not** map to {@code receiveCommand:}.
+ *   {@code RCTLegacyViewManagerInteropCoordinator} indexes {@code RCT_EXPORT_METHOD} by
+ *   integer **or** resolves by **string name**. NexradRadarLayer uses {@code codegenNativeComponent};
+ *   we dispatch **string command names** so native resolves via {@code methodsByName} (see
+ *   {@code NexradRadarManager.mm} {@code RCT_EXPORT_METHOD} entries).
+ */
+import { Platform, UIManager } from 'react-native';
+
+const COMPONENT_NAME = 'NexradRadarLayer';
+
+/** @type {Record<string, number>} */
+const ANDROID_COMMAND_FALLBACK = Object.freeze({
+    uploadNexradFrame: 1,
+    uploadNexradStyleOnly: 2,
+    clearNexrad: 3,
+    activateNexradCachedFrame: 4,
+});
+
+/**
+ * @param {keyof typeof ANDROID_COMMAND_FALLBACK} commandName
+ * @returns {number | string | null}
+ */
+export function resolveNexradCommandId(commandName) {
+    if (Platform.OS === 'ios') {
+        return commandName;
+    }
+    try {
+        const config = UIManager.getViewManagerConfig(COMPONENT_NAME);
+        const fromRegistry = config?.Commands?.[commandName];
+        if (fromRegistry != null && fromRegistry !== undefined) {
+            return fromRegistry;
+        }
+    } catch {
+        /* bridge not ready */
+    }
+    const fb = ANDROID_COMMAND_FALLBACK[commandName];
+    return fb !== undefined ? fb : null;
+}