my-mini-program/
├── app.js               // 小程序逻辑入口文件，用于初始化全局配置
├── app.json             // 项目的全局配置文件，如页面路径、窗口表现等
├── app.wxss             // 全局样式表，影响所有页面的样式
├── project.config.json  // 项目配置文件，包含开发者工具相关设置
├── pages/               // 存放各个页面的目录
│   ├── index/           // 首页
│   │   ├── index.wxml   // 页面结构文件
│   │   ├── index.wxss   // 页面样式表
│   │   ├── index.js     // 页面逻辑文件
│   │   └── index.json   // 页面配置文件(可选)
│   ├── logs/            // 日志页面
│   │   ├── logs.wxml
│   │   ├── logs.wxss
│   │   ├── logs.js
│   │   └── logs.json    // (可选)
│   └── ...              // 更多页面
├── utils/               // 工具类库或公共函数
│   └── util.js          // 提供一些常用的工具方法
├── images/              // 图片资源
│   └── logo.png         // 示例图片
└── components/          // 自定义组件
    └── my-component/    // 示例自定义组件
        ├── my-component.wxml
        ├── my-component.wxss
        ├── my-component.js
        └── my-component.json

<view class="container">
  <text>{{message}}</text>
  <button bindtap="handleTap">点击我</button>
</view>

.container {
  display: flex;
  justify-content: center;
  align-items: center;
  padding: 20rpx;
}

button {
  background-color: #1aad19;
  color: white;
  border: none;
  padding: 10rpx 20rpx;
  border-radius: 5rpx;
}

Page({
  data: {
    message: 'Hello, World!'
  },

  onLoad: function() {
    // 页面加载时执行的初始化操作
    console.log('Page loaded');
  },

  handleTap: function() {
    // 处理按钮点击事件
    wx.showToast({
      title: '你点击了按钮',
      icon: 'none'
    });
  }
});

┌─────────────────────────────────────────────────────────────┐
│ Header (14 bytes)                                           │
│   ┌───────────────────────────────────────────────────────┐ │
│   │ 0x00: 0xBE (Magic Start)                              │ │
│   │ 0x01-0x04: Version (4 bytes, Big-Endian)              │ │
│   │ 0x05-0x08: Info Length (4 bytes, BE)                  │ │
│   │ 0x09-0x0C: Data Length (4 bytes, BE)                  │ │
│   │ 0x0D: 0xED (Magic End)                                │ │
│   └───────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────┤
│ File Count (4 bytes)                                        │
│   ┌───────────────────────────────────────────────────────┐ │
│   │ 0x0E-0x11: File Count (4 bytes, BE)                   │ │
│   └───────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────┤
│ File Index Section                                          │
│   ┌───────────────────────────────────────────────────────┐ │
│   │ For each file:                                        │ │
│   │   [4 bytes] Name Length                               │ │
│   │   [N bytes] Name (UTF-8 string)                       │ │
│   │   [4 bytes] Offset (absolute offset in package)       │ │
│   │   [4 bytes] Length                                    │ │
│   └───────────────────────────────────────────────────────┘ │
├─────────────────────────────────────────────────────────────┤
│ Data Section                                                │
│   ┌───────────────────────────────────────────────────────┐ │
│   │ File 1 Data                                           │ │
│   │ File 2 Data                                           │ │
│   │ ...                                                   │ │
│   └───────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘

[4 bytes]  Name Length      - 文件名字节长度
[N bytes]  Name             - 文件名 (UTF-8 编码)
[4 bytes]  Offset           - 文件数据在包文件中的绝对偏移（相对 0x00）
[4 bytes]  Length           - 文件数据长度

const wxid = process.argv[2];
const iv = 'the iv: 16 bytes';
const salt = 'saltiest';
const wxapkgPath = '__APP__.wxapkg';
const decWxapkgPath = 'dec.wxapkg';

const data = fs.readFileSync(wxapkgPath);
// 生成密钥
const dk = crypto.pbkdf2Sync(Buffer.from(wxid), Buffer.from(salt), 1000, 32, 'sha1');
// 创建AES解密器
const decipher = crypto.createDecipheriv('aes-256-cbc', dk, Buffer.from(iv, 'utf8'));
// 解密前1024字节
let originData = decipher.update(data.slice(6, 1024 + 6));
// 处理剩余部分
const xorKey = wxid.length >= 2 ? wxid.charCodeAt(wxid.length - 2) : 0x66;
const afData = data.slice(1024 + 6).map(b => b ^ xorKey);
// 合并解密数据
originData = Buffer.concat([originData, Buffer.from(afData)]);
// 写入解密后的文件
fs.writeFileSync(decWxapkgPath, originData);

// 拦截 AccountService 的 GetEncryptKey 方法
function interceptAccountService(accountService: NativePointer) {
    Interceptor.attach(accountService.implementation, {
        onLeave: (ret: NativePointer) => {
            const keyObject = new ObjC.Object(ret);
            const key = keyObject.bytes().readByteArray(keyObject.length());
            console.log(hexdump(key, { offset: 0, length: 16, header: true, ansi: false })); 
        }
    });
}

const accountService = ObjC.classes.AccountService['- GetEncryptKey'];
interceptAccountService(accountService);

# 安卓 需root
/data/data/com.tencent.mm/MicroMsg/{用户ID}/appbrand/pkg/ # 旧版
/data/data/com.tencent.mm/MicroMsg/appbrand/pkg/general # 新版
# IOS 需越狱
/var/mobile/Containers/Data/Application/{微信App的UUID}/Library/WechatPrivate/{用户ID}/WeApp/LocalCache/release/{小程序AppID}/
# windows
C:\Users\{UserName}\Documents\WeChat Files\Applet\{小程序AppID}\
# mac
/Users/{UserName}/Library/Group Containers/xxxx.com.tencent.xinWeChat/Library/Caches/xinWeChat/{用户ID}/WeApp/LocalCache/release/# 旧版
/Users/{UserName}/Library/Containers/com.tencent.xinWeChat/Data/.wxapplet/packages/ # 新版

libappbrandcommon.so
libcronet.119.0.6045.214.so
libilink_protobuf.so
libmmj2v8.so
libMMProtocalJni.so
libmmv8.so
libwxa-runtime-binding.so
libmmwcwss.so

AppBrandRuntimeContainer -> AppBrandRuntimeContainerLU -> AppBrandRuntimeContainerStandaloneImpl -> WxaRuntimeContainer    # 管理AppBrandRuntime，包括创建、查找、销毁等
    AppBrandRuntime -> AppBrandRuntimeLU                            # 代表单个小程序
        AppBrandService -> AppBrandServiceLU -> AppBrandServiceWC   # Service上下文
        AppBrandPageContainer -> WxaPageContainer                   # 所有页面
            AppBrandPageView -> AppBrandPageViewLU                  # 单个Page上下文

V8JsEngine: # V8引擎实现，也就是服务层的JS引擎
Lcom/tencent/mm/plugin/appbrand/jsruntime/V8JsEngine
    │
    └── extends AbstractMultiContextJsEngine # 新增多上下文管理(上下文的创建、销毁、获取等)，自定义异常处理器、控制台输出重定向、配置状态管理等
            │
            └── extends AppBrandJ2V8Context # 抽象V8上下文基类，封装了V8引擎的底层调用，如生命周期管理、调试与回调处理、JS线程管理等
                    │
                    └── implements:
                       • AppBrandJsRuntime # JS运行时主接口，提供JS执行和生命周期管理
                       • AppBrandJsRuntimeAddonDestroyListener # 销毁监听器Addon，在引擎销毁时释放资源
                       • AppBrandJsRuntimeAddonV8 # V8引擎Addon，提供V8特有的JS执行能力，比如批量执行，还暴露出了isolate/context/uvlooper等供其他模块使用
                       • NativeBufferManager (extends AppBrandJsRuntimeAddon) # Native缓冲区管理Addon，负责JS与Native间的高效二进制数据传递
                       • InitializationListener (extends AppBrandJsRuntimeAddon) # 初始化监听Addon，在JS环境初始化完成时回调
                       • MultiContextManager (extends AppBrandJsRuntimeAddon) # 多上下文管理Addon，管理多个独立的JS执行上下文，比如新的SDK支持主上下文，Worker和插件在单独的上下文
                       • PausableInterface (extends AppBrandJsRuntimeAddon) # 暂停/恢复Addon，支持暂停JS引擎执行



RemoteDebugJsEngine: # 远程调试引擎，这应该是老版的真机调试引擎，会将常规js发给开发者工具执行，真机只执行JS Bridge以下的
Lcom/tencent/mm/plugin/appbrand/debugger/RemoteDebugJsEngine
    │
    └── implements AppBrandJsRuntime
        │
        └── 包含:
            • RemoteDebugSocket - WebSocket管理
            • RemoteDebugMessageManager - 消息管理
            • RemoteDebugView - 调试视图
            • DebugEnvironment - 调试环境

public class LuggageStartParams {
    private final String appId; // 小程序的唯一标识符
    private final boolean isGame; // 是否为小游戏 (true: 小游戏, false: 小程序)
    private final int versionType; // 版本类型 (0: 正式版, 1: 开发版, 2: 体验版)
}

public final class WxaStartParams extends LuggageStartParams {
    private final WxaAttrSyncRequest action; // 核心启动动作请求，包含版本、场景、调试等详细配置
    private final AppBrandLaunchReferrer referrer; // 启动来源信息，描述了"从哪里来" (如从另一个小程序跳转、从扫码等)
    private final AppBrandStatObject statObject; // 统计对象，用于数据上报和分析
}

public class WxaAttrSyncRequest extends ZPVZX {
    public String appId; // 小程序 AppID
    public boolean needVersionInfo;  // 是否需要后台返回版本信息
    public String lastVersion; // 本地缓存的最后一个版本号 (用于增量更新)
    public String instanceId;  // 运行实例 ID (区分同一 AppID 的不同运行实例)，实例管理用的，多开找它附近
    public int scene; // 启动场景值 (如 1001: 发现栏小程序)
    public LinkedList moduleList; // 需要加载的模块列表 (分包加载用)
    public boolean isDev; // 是否为开发版环境
    public boolean isDebug; // 是否开启调试模式
    public int clientVersion; // 客户端版本号
    public int netType; // 网络类型 (如 WiFi, 4G)
    public String extInfo; // 扩展信息 JSON 字符串 (包含远程调试配置、第三方平台配置等)
}

public final class AppBrandLaunchReferrer implements Parcelable {
    public int launchScene; // 启动来源场景值
    public String appId; // 来源 AppID (例如从 A 小程序跳转到 B 小程序，这里是 A 的 AppID)
    public String extraData; // 来源携带的公开额外数据
    public String privateExtraData; // 来源携带的私有额外数据
    public String messageExtraData;// 消息相关的额外数据 (如从聊天消息卡片启动)
    public String url;// 来源 URL (如从 H5 页面跳转)
    public int sourceType;// 来源类型
    public String businessType;// 业务类型标识
    public String transitiveData;// 传递性数据 (可能需要透传给下一个页面)
}

public final class AppBrandStatObject implements Parcelable {
    public int preScene; // 上一个场景值 (用户进入当前场景之前的场景)
    public String preSceneNote; // 上一个场景的备注信息
    public int scene; // 当前启动场景值
    public int sceneType; // 场景类型
    public String sceneNote; // 当前场景备注信息
    public String appId; // 小程序 AppID
    public int actionType; // 动作类型
    public String extraInfo; // 额外统计信息
    public AppBrandRecommendStatObj recommendStatObj; // 推荐相关的统计对象 (如从推荐列表启动)
}

ContainerActivityLifecycleDispatcherImpl.onCreate(Bundle)
├── AppBrandRuntimeContainerStandaloneImpl.performLaunch(Intent, "onCreate")
│   ├── WxaLaunchParameters.toLaunchParcel(WxaAttrSyncRequest)  # 解析启动参数
│   ├── getRuntimeByAppId(appId)                                # 尝试获取已存在的 Runtime，这里如果存在下面会走loadExisted
│   ├── WxaLaunchPreconditionProcess.start()                    # 启动预加载流程(获取属性、检查封禁等)
│   │   └── loadStandaloneImpl(AppBrandInitConfigLU, ...)       # 预加载成功回调
│   │       ├── new AppBrandInitConfig(config)                  # 创建独立运行时配置
│   │       └── AppBrandRuntimeContainerLU.load(config, stat)   # 加载运行时
│   │           └── runOnUiThread
│   │               ├── createRuntime(config)                   # 这是运行时不存在的情况，会创建新的Runtime
│   │               └── loadNew(null, runtime, config)          # 加载新Runtime
│   │                   └── AppBrandRuntimeContainer.loadNew(old, new, config)
│   │                       ├── AppBrandRuntime.init(config)    # 初始化 Runtime 状态
│   │                       │   ├── mInitConfig = config
│   │                       │   └── mRunningStateController.start()
│   │                       ├── mRuntimeStack.push(newRuntime)  # 入栈
│   │                       ├── attachRuntimeViewToTree(view)   # 挂载视图
│   │                       └── AppBrandRuntime.launch()        # 启动 Runtime
│   │                           ├── onLaunch()
│   │                           ├── onCreatePrivate()           # 注册核心服务
│   │                           │   ├── IPCInvoker.register...  # 注册跨进程通信
│   │                           │   ├── registerService(...)    # 注册基础服务(ImageLoader等)
│   │                           │   └── AppBrandLifeCycle.notifyOnCreate()
│   │                           ├── prepare(PrepareAllDoneInitNotify) # 执行异步准备任务
│   │                           └── showSplash()                # 显示启动页
│   │                               └── PrepareAllDoneInitNotify.done() # 准备完成回调
│   │                                   └── initRuntime()       # 初始化运行时核心组件

AppBrandRuntime.initRuntime()
├── initRuntimeImpl()
│   ├── installFileSystem(false)                    # 安装文件系统，它实现了自己的VFS，每个小程序读写文件会透过它
│   ├── onInitBeforeComponentsInstalled()           # 组件安装前初始化
│   ├── createService()                             # 创建AppBrandService
│   │   └── new AppBrandService()                   # 创建逻辑层，下面会马上初始化它
│   ├── attachService(mService)                     # 绑定服务到运行时
│   │   ├── onPreAttachService(appBrandService0)    # 服务预绑定，它采用的是服务注册机制，之后会根据接口找是否存在某个服务并调用，且采用后进先出的优先级来支持功能重写
│   │   │   ├── registerService(IImageReaderUrlBuilder.class, ...)
│   │   │   ├── registerService(IImageLoader.class, ...)
│   │   │   └── 注册其他服务配置
│   │   └── mService.attachRuntime(this)            # 服务绑定运行时，现在实现了双向绑定了，你中有我我中有你(笑
│   │       └── onRuntimeReady(appBrandRuntime0)    # 运行时就绪回调
│   │           ├── installJsRuntime()              # 安装JS运行时
│   │           │   └── createJsRuntime()           # 创建JS运行时
│   │           │       ├── createCustomJsRuntime() # 优先尝试自定义创建运行时
│   │           │       │   ├── AppBrandMiniProgramServiceLogicImp → new V8JsEngine(null, null)
│   │           │       │   └── MPRemoteDebugServiceLogic → new RemoteDebugJsEngine()
│   │           │       └── new V8JsEngine(null, null) # 默认创建，注意这里的图有问题：createCustomJsRuntime和默认创建是二选一，不会创建多个
│   │           ├── installWorkerContainer()        # 安装Worker容器
│   │           │   └── createWorkerContainer()     # 创建Worker容器
│   │           │       └── new AppBrandWorkerContainer(this)
│   │           └── WorkerContainer.onRuntimeReady() # Worker容器就绪
│   │               ├── workerEngineManager.onRuntimeReady()
│   │               └── dispatchConfigToWorker()    # 下发配置到Worker
│   ├── performInitService()                        # 初始化服务
│   │   └── mService.init()                         # 服务初始化
│   │       ├── super(AppBrandComponentImpl).init() # 父类初始化
│   │       │   ├── installJsRuntime()              # 安装JS运行时
│   │       │   │   ├── createJsRuntime()           # 创建JS运行时
│   │       │   │   ├── addJavascriptInterface(this.mJsInterface, "WeixinJSCore")
│   │       │   │   └── postJsRuntimeCreated()      # JS运行时创建后处理
│   │       │   │       ├── postCreateJsRuntime()   # 子类后处理
│   │       │   │       │   └── notifyCreate()      # 通知创建完成，这是在AppBrandCommonBindingJni里哦～
│   │       │   │       └── run pending tasks       # 执行等待任务
│   │       │   ├── installJsApis()                 # 安装JS API
│   │       │   │   └── createJsApiPool()           # 创建JS API池
│   │       │   │       ├── createForAppService()   # 为应用服务创建
│   │       │   │       └── createForPage()         # 为页面创建
│   │       │   └── installWorkerContainer()        # 安装Worker容器
│   │       ├── attachConfig(configStore)           # 附加配置
│   │       └── onInit()                            # 初始化完成回调
│   │           ├── injectConfig()                  # 注入配置
|   |           |      ├── super.injectConfig() 
│   │           │          ├── generateWxConfig()          # 生成WX配置
│   │           │          ├── attachCommonConfig()    # 附加通用配置
│   │           │          └── mRuntime.getAppConfig().getInjectConfig()
│   │           │          ├── subscribeHandler("__native_custom_event__wxConfig_inject", ...)    # 这里会用两种方式注入配置，包括订阅事件和直接注入js代码
│   │           │          └── evaluateJavascript("__wxConfig=%s", ...)
│   │           │      ├── initDebugger()            # 如果启用了远程调试，则在这里会初始化

│   │           └── clearEventQueue()               # 清空事件队列
│   ├── performInitPageContainer()                  # 初始化页面容器
│   │   ├── createPageContainer()                   # 创建页面容器
│   │   │   └── new AppBrandPageContainer(context, this)
│   │   └── mPageContainer.init(enterPath)         # 初始化页面容器
│   ├── 创建PIP管理器和其他组件                        # 即画中画管理
│   └── onPostInit()                                # 初始化后处理
├── mInitialized = true                             # 标记为已初始化
└── runPendingTasksOnRuntimeInitialized()           # 执行运行时初始化后的等待任务

;if (this.setTimeout && this.clearTimeout && this.setInterval && this.clearInterval && this.NativeGlobal) {
    this.NativeGlobal.setTimeout = this.setTimeout; 
    // ... 如果当前环境已经注入了 setTimeout/clearTimeout 等定时器方法和 NativeGlobal，则将这些方法挂载回 NativeGlobal，确保原生侧能通过 NativeGlobal 调用 JS 的定时器。
};
// 封装 WeixinJSCore 接口，用于调用原生 API(bridge)
var WeixinJSCore = (function(global) {
    var _WeixinJSCore = global.WeixinJSCore
        // 优先使用更现代的 invokeHandler(来自 NativeGlobal 或 workerInvokeJsApi)
    var __invokeHandler__ = _WeixinJSCore.invokeHandler
    var __invokeHandler2__ = _WeixinJSCore.invokeHandler2
    // 优先级：NativeGlobal.invokeHandler > workerInvokeJsApi > 原始 invokeHandler
    if (global.NativeGlobal && global.NativeGlobal.invokeHandler) { 
        __invokeHandler2__ = global.NativeGlobal.invokeHandler
    } else if (global.workerInvokeJsApi) {
        __invokeHandler2__ = global.workerInvokeJsApi
    }
    var ret = {};
    ret.publishHandler = function(event, data, dst) {_WeixinJSCore.publishHandler(event, data, dst)} // // 事件发布接口直接用weixinjscore(用于原生向 JS 发送事件)
    ret.invokeHandler = function(api, args, callbackId, privateArgs) {/*..*/} // 这两个调用js api的根据上面的优先级，实际会走NativeGlobal的invokeHandler
    if (global.workerInvokeJsApi) { /*..*/ } 
    return ret
})(this);

// 封装 Android 平台特有的回调和事件订阅处理
var WeixinJSCoreAndroid = (function(global) {
    var ret = {};
    ret.invokeCallbackHandler = function(callbackId, data, ext) {  // 原生调用 JS 回调的入口
            WeixinJSBridge.invokeCallbackHandler(callbackId, data, ext);
    };
    ret.subscribeHandler = function(event, data, src, ext) {// 原生向 JS 发送事件(如配置注入、错误等)
        if ('__native_custom_event__wxConfig_inject' === event) { // 这个事件会特殊处理，在下面的微信网关部分会再提到
            global.NativeGlobal.hasInitializedWxConfig = true;
            Object.assign(global.__wxConfig, JSON.parse(data))
            return
        }
                // 其它事件解析参数后发送
        WeixinJSBridge.subscribeHandler(event, data, src, ext);
    };
    return ret;
})(this);

//  修复 WeixinWorker.create 的多参调用兼容性
if (typeof this.WeixinWorker !== 'undefined') {/*...*/};
// 删除 NativeGlobal 上的 invokeHandler，防止被意外使用
;(function(global){ delete global.NativeGlobal.invokeHandler; })(this);
// 封装共享内存缓冲区接口(用于高性能数据传输，如音视频)
var WeixinSharedBuffer = (function(global) {/*...*/})(this);;
// 为多个大型原生模块(如 Canvas、WebRTC、AR 等)实现懒加载，即进行封装，在访问时才会调用NativeGlobal.initModule去实际加载
if (this.NativeGlobal && this.NativeGlobal.initModule) {/*...*/};;
// 为构造函数类模块(如 WXAUDIO、TCP、UDP)实现懒加载代理
(function(globalThis) {/**/})(this);

void __fastcall Java_com_tencent_mm_appbrand_commonjni_AppBrandCommonBindingJni_nativeBindTo(int a1,int a2,AppBrandRuntime *a3,v8::Isolate *a4,_QWORD **a5,const void *a6)
{
  BindTo(a3, v11, (unsigned __int64)a6);
}
void __fastcall BindTo(AppBrandRuntime *a1, char *a2, unsigned __int64 a3)
{

  InstallNativeGlobal(v5, a1, &v14);
  BindClass(v5, a1, &v14);
}

__int64 __fastcall BindClass(v8::Isolate *a1, AppBrandRuntime *a2, __int64 *a3)
{
  WeixinJSContext_init(&v24);  // 初始化WeixinJSContext类定义结构体，v24是一个ClassDefinition结构体，用于定义JavaScript类的属性和方法
  // 添加多个方法到类定义
  ClassDefinition_AddMethod(&v24, "allocEmpty", AllocEmptyCallback);
  ClassDefinition_AddMethod(&v24, "loadLibFiles", LoadLibFilesCallback);
  ClassDefinition_AddMethod(&v24, "loadJsFiles", LoadJsFilesCallback);
  InitClassTemplate(&v24, "WeixinJSContext"); // 初始化类模板
  CurrentContext = v8::Isolate::GetCurrentContext(a1);
  v8 = v8::External::New(a1, (v8::Isolate *)a2, v6);
  v9 = v8::FunctionTemplate::New(a1, WeixinJSContextConstructorCallback, v8, 0LL, 0LL, 1LL, 0LL, 0LL, v21, v22, v23); // 创建WeixinJSContext类的实例对象
  Function = v8::FunctionTemplate::GetFunction(v9, CurrentContext); 
  v11 = v8::Function::NewInstance(Function, CurrentContext, 0LL, &v24.padding);
  v12 = *a3;
  // 将WeixinJSContext类添加到全局对象
  v13 = v8::Isolate::GetCurrentContext(a1);
  v14 = v8::String::NewFromUtf8(a1, "WeixinJSContext");
  v15 = (v8::api_internal *)v8::Object::Set(v12, v13, v14, v11);
}
/* for NativeGlobal */
__int64 __fastcall InstallNativeGlobal(v8::Isolate *a1, v8::Isolate *a2, __int64 *a3)
{
  // 检查是否存在，存在则不新建
  native_global_property = (v8::Value *)get_native_global_property(a1, *a3, "NativeGlobal");   
  if ( native_global_property && (v8 = (__int64)native_global_property, (v8::Value::IsObject(native_global_property) & 1) != 0) )  {  }  else
  {
    v8 = v8::Object::New(a1, v9);
  }
  v16[0] = v8;
  // 注册各种功能：Signal/Worker和invokeHandler initModule等方法
  registerFunction_43E38(a1, v8, "invokeHandler", (__int64)js_to_native_invoke_handler_wrapper, a2);
  registerFunction_43E38(a1, v8, "initModule", (__int64)init_module_callback, a2);
  registerFunction_43E38(a1, v8, "testV8Crash", (__int64)test_v8_crash_callback, a2);
  init_reporter_binding(a1, a2, v16);
  init_native_buffer_binding(a1, a2, v16);
  if ( *((int *)a2 + 84) <= 0 )
  {
    init_worker_binding(a1);
    init_runtime_binding();
    registerFunction_43E38(a1, v16[0], "getCurrentThreadTime", (__int64)get_current_thread_time_callback, a2);
    registerFunction_43E38(a1, v16[0], "createSignal", (__int64)create_signal_callback, a2);
  }
  v10 = *a3;
  v11 = v16[0];
  // 设置为全局对象
  CurrentContext = v8::Isolate::GetCurrentContext(a1);
  v13 = v8::String::NewFromUtf8(a1, "NativeGlobal");
  v14 = (v8::api_internal *)v8::Object::Set(v10, CurrentContext, v13, v11);
}

__int64 __fastcall Java_com_tencent_mm_appbrand_commonjni_AppBrandJsBridgeBinding_nativeCreateRuntime(JNIEnv *a1, __int64 a2, v8::Isolate *a3, _QWORD **a4, void *a5, char a6)
{

    // 获取 Java 传入的 Bridge 名称 (参数 a5, 例如 "WeixinJSCoreAndroid")
    const char *bridge_name_cstr = env->GetStringUTFChars(a5, 0);
    // 将 C 字符串转换为 C++ std::string
    std::string bridge_name_cpp_str(bridge_name_cstr); 
    // 分配 AppBrandJsBridgeBinding 对象的内存 (大小 0x38 字节)
    AppBrandJsBridgeBinding *binding_instance = (AppBrandJsBridgeBinding *)operator new(0x38);
    // 调用核心构造函数进行初始化
    AppBrandJsBridgeBinding_ctor(binding_instance, isolate, context, bridge_name_cpp_str, jni_manager);
    return (jlong)binding_instance;
}

void AppBrandJsBridgeBinding_ctor(AppBrandJsBridgeBinding* this_ptr, v8::Isolate* isolate, void* context_holder, std::string* bridge_name_str, void* jni_mgr) {

    // 初始化结构体成员
    this_ptr->jni_manager = jni_mgr;       // Offset 0x20
    this_ptr->isolate = isolate;           // Offset 0x28
    this_ptr->context = context_holder;    // Offset 0x30

    // 进入 V8 环境 (标准 V8 嵌入流程) ... 获取 JS 全局对象 (Global Object)
    v8::Local<v8::Object> global = context->Global();

    const char* name = bridge_name_str->is_long() ? bridge_name_str->ptr : bridge_name_str->buf; // 处理 std::string 的短字符串优化(SSO)逻辑以获取 char*
    v8::Local<v8::Value> bridge_obj = get_native_global_property(isolate, global, name); // 调用辅助函数在 Global 中查找属性
    this_ptr->bridge_ref = CreatePersistentRef(isolate, bridge_obj); // 持久化 Bridge 对象引用: 创建一个包装结构 { Isolate*, GlobalRef } 并存入 this_ptr

    // 查找并绑定invokeCallbackHandler / subscribeHandler
    v8::Local<v8::Value> invoke_func = get_native_global_property(isolate, bridge_obj, "invokeCallbackHandler");
    this_ptr->invoke_handler_ref = CreatePersistentRef(isolate, invoke_func);
    v8::Local<v8::Value> sub_func = get_native_global_property(isolate, bridge_obj, "subscribeHandler");
    this_ptr->subscribe_handler_ref = CreatePersistentRef(isolate, sub_func);

    // 退出V8环境，析构Scope对象，释放局部句柄...
}

public class JsApiPool {
    private Map pageAPIs;
    private Map serviceAPIs;

    protected void addToServicePool(AppBrandJsApi appBrandJsApi0) {
        if(appBrandJsApi0 != null && !Util.isNullOrNil(appBrandJsApi0.getName())) {
            this.serviceAPIs.put(appBrandJsApi0.getName(), appBrandJsApi0);
        }
    }
    public Map createForAppService() {
        this.serviceAPIs = new HashMap();
        this.initServicePool();
        return this.serviceAPIs;
    }
    // 这是为渲染层注入的Js API，主要供渲染层框架使用，开发者好像是用不了
    protected void initPagePool() {
        this.addToPagePool(new JsApiShowStatusBar());
        this.addToPagePool(new JsApiHideStatusBar());
        // ... 
    }
    // 这是逻辑层的，为开发者使用的
    protected void initServicePool() {
        this.addToServicePool(new JsApiBatchGetStorage());
        this.addToServicePool(new JsApiBatchGetStorageSync());
        // ...
    }
}

BaseJsApi (抽象类，实现ConstantsAppBrandJsApiMsg接口，该接口定义了常见的错误字符串)
  ↑
AppBrandJsApi (抽象类，提供结果生成和错误处理，比如去打包为json等)
  ├── AppBrandSyncJsApi (抽象类，同步API基类)
  │     └── 同步API实现类，比如JsApiBatchGetStorageSync继承自它
  └── AppBrandAsyncJsApi (抽象类，异步API基类)
        └── 异步API实现类，比如JsApiBatchGetStorage继承自它

public class AppBrandJSInterface {
    private volatile AppBrandComponentImpl mEnv;

    public AppBrandJSInterface(AppBrandComponentImpl appBrandComponentImpl0) { this.mEnv = appBrandComponentImpl0; }
    public void cleanup() { his.mEnv = null; }
    private int[] extractJsonArray(String s) {/**/ }

    // 下面三个是暴露给JS的函数(当然了其实不会被调用，它走的是native的路子)
    @JavascriptInterface // 这是Android Webview的JS Bridge注入方式
    public String invokeHandler(String apiName, String data, int callbackId) {
        return this.mEnv == null ? "" : this.mEnv.invoke(apiName, data, "", callbackId);
    }
    @JavascriptInterface
    public String invokeHandler2(String apiName, String data, int callbackId, String privateData) {
        return this.mEnv == null ? "" : this.mEnv.invoke(apiName, data, privateData, callbackId);
    }
    @JavascriptInterface
    public void publishHandler(String eventName, String eventData, String targetIdsJson) {
        this.mEnv.publish(eventName, eventData, this.parseIntArrayFromJson(targetIdsJson));
    }
}

public class AppBrandCommonBindingJni {
    @Keep
    protected String nativeInvokeHandler(String apiName, String data, String privateData, int callbackId, boolean isAsyncThread) { // 还有两个x,y参数未知
        return this.mAppBrandDelegate.nativeInvokeHandler(apiName, data, privateData, callbackId, isAsyncThread);
    }
}
public class AppBrandCommonBinding {
        @Override  // 从Native调过来的
        public String nativeInvokeHandler(String apiName, String data, String privateData, int callbackId, boolean isAsyncThread) {
            return ((AppBrandComponentImpl)this.appBrandComponentImpl.get()).invoke(apiName, data, privateData, callbackId, isAsyncThread, null);
        }
    }
}

// 创建加载助手
WcWssNativeInstallHelper wcWssNativeInstallHelper0 = new WcWssNativeInstallHelper();
this.mWcWssNativeInstallHelper = wcWssNativeInstallHelper0;
// 建立绑定：加载owl、ssl、crypto、wcwss(核心实现)等库，创建WebSocket绑定，设置回调监听器
wcWssNativeInstallHelper0.createWcWssBinding(((AppBrandServiceLU)this.getComponent()).getJsRuntime(), this.getComponent(), 0);
// 处理证书验证和网络配置
this.mWcWssNativeInstallHelper.initConfigWcWss(this.getJsRuntime(), ((AppBrandComponentWithExtra)this.getComponent()));

initDebugger
    initRemoteDebug # 这之前会检查 AppBrandRuntimeLU.isRemoteDebug && RemoteDebugUtils.isNewRemoteDebugType 即调试类型为1
        new RemoteDebugJsEngine # 在主线程运行
        new DebugEnvironment()
        mRemoteDebugEnv.init
            RemoteDebugUtils.setUin                     # 设置uin
            RemoteDebugUtils.parseRemoteDebugInfo       # 解析调试信息
            appBrandSysConfigLU0.isRemoteDebug          # 设置远程调试标志
            appBrandNetworkConfig0.shouldCheckDomains   # 根据调试配置禁用url/域名检查
        mRemoteDebugEnv.setDebugId
        mRemoteDebugJsEngine.init
            new RemoteDebugView                         # 设置调试视图(显示在UI上)
            connect                                     # 连接调试器，根据配置去通过局域网直连还是通过腾讯服务器做中转
                new RemoteDebugSocket       
                mSocketMrg.connectSocket
        debugJSContextInterface.setupDebugEngine        # 为DebuggerConnection设置调试RemoteDebugJsEngine，js就能调sendCustomMessage向它发消息了
    V8.setBreakOnStart(Boolean.FALSE)                   # 不要暂停否则不会执行到正确流程
    JsValidationInjectorWC.waitForDebug                 # 等待调试器连接
    JsValidationInjectorWC.breakProgram                 # 执行"breakprogram();

// request -> WY -> Z -> Y

Y = (e)=>{
    var a = new K({ args: t, options: e });
    if ((a.catch((e) => {s.YG("request",t,e.message || e.errMsg,e.errno);})
        .use(normalizeParams(r))    // 将请求头转小写，方法转大些，body序列化，初始化时间戳重试次数等
        .use(parseUrl({options}) // 将 URL 字符串拆解为结构化数据，方便后续 DNS 解析和连接
        .use(checkHttpDNSPolyfill) // 针对 iOS 等特定环境，检查是否需要开启 DNS Polyfill，必要时还会发预检
        .use(validateHost) // 检查 Host 是否合法，例如不能以 "." 开头，不能包含连续的 ".."
        .use(skipDNS) // 如果用户在 wx.request 中直接传入了 'ip' 参数并且配置了 skipDNSRequest，可用IP直连，绕过系统DNS解析
        .use(determineAcceleration) // 智能判断是否将请求路由到微信的加速网关
        .use(handleFreeHttpDNS) // 如果之前的请求失败了，或者配置了 __retryHttpDNS__这里会尝试获取 IP
        .use(resolveHttpDNS)    // 如果开启了enableHttpDNS，使用微信的 HttpDNS 服务解析域名，防止DNS 劫持
        .use(forceCellular)  // 强制使用蜂窝网络，比如在Wi-Fi差时
        .use(tryGateway)    // 这里是一个核心，尝试使用微信网关加速/加固
        .useAfterAsyncTasks(S.rk),
      a.catchFn)
    )
      return a.execute(t); // 执行请求
}

v8::Isolate *__fastcall InitNetworkJSEnv(__int64 cronetJsContext,int a2,__int64 a3,v8::Isolate *a4,_QWORD *a5,__int64 isInit)
{
  // 获取/创建NativeGlobal
  CurrentContext = (v8::Context *)v8::Isolate::GetCurrentContext(a4);
  v19 = v8::Context::Global(CurrentContext);
  Property = JS_GetProperty(a4, v19, "NativeGlobal");
  if ( !Property )
  {
    Property = v8::Object::New(a4, v20);
    JS_SetProperty(a4, v19, "NativeGlobal", Property);
  }
  // 获取Cronet配置，创建Cronet对象管理器等
  CronetJsConfigBuilder_Constructor(v26, (__int64)v105, &v104, (__int64)&v108, (__int64)v107, (__int64)v106);
  v27 = BuildAndConsume_CronetJsConfig((__int64 *)&v99);
  CronetJsContext_Constructor(v29, JsObjectManager, ArrayBufferAllocator, v27, (__int64)&v108);
  if ( isInit )
  {
    // 开始定义任务相关的三个类，并将其放到 NativeGlobal 里 
    JS_Define_RequestTask_Class();        // 定义类，各种属性/方法访问器等
    JS_Define_DownloadTask_Class();
    JS_Define_UploadTask_Class();
    JS_RegisterRequestTask(a4, Property, (__int64)"RequestTask", (v8::Isolate *)v29); // 注册类，里面有它的构造函数
    JS_RegisterDownloadTask(a4, Property, (__int64)"DownloadTask", (v8::Isolate *)v29);
    JS_RegisterUploadTask(a4, Property, (__int64)"UploadTask", (v8::Isolate *)v29);
  }
  // ...
}

__int64 __fastcall RequestTask_Init(RequestTask *a1, v8::Isolate *a2, __int64 a3)
{
  // ...
  if ( *(int *)(a3 + 16) <= 0 )
    v14 = *(_QWORD *)(*(_QWORD *)a3 + 8LL) + 632LL;
  else
    v14 = *(_QWORD *)(a3 + 8);
  // 开始一个一个读对象的属性，即构造函数的参数
  v8_url = JS_GetProperty_Value(a2, v14, "url", v54);
  V8_Value_ToString(&url, a2, v8_url);
  // ...
}

function tryGateWay(ctx) {
  const globalRuntimeConfig = i; // 运行时配置 (auth_info, prefetch_ip 等)
  const projectConfig = n;       // 项目配置 (domain, env_version 等)
  const systemInfo = l.default;  // 系统信息 (envVersion 等)
  const libInfo = t;             // 基础库信息 (version)
  const liteGatewayRules = o;    // Lite Gateway 规则配置
  const isCloudGatewayEnabled = P; // 是否启用云/网关特性
  let hasGlobalRetryFallback = A;  // 全局重试标记

  if (ctx.args.disableGateway) { // 如果请求参数明确禁用了网关，直接退出
    return;
  }

  if (liteGatewayRules) { // 如果有加速规则会尝试匹配，本文不关注这种情况，简单说下
    try {
      const accelerationResult = tryCalculateLiteGatewayOptions(ctx); // 尝试计算加速配置，它会匹配当前url的转发规则，检查是否满足加速条件(大量检查)，如果都满足则会构造加速请求(修改url，注入header等)
      if (accelerationResult && accelerationResult.accelerateOptions.accelerateType === 'liteGatewayAcc') { // 如果成功生成了 Lite Gateway 加速选项，直接返回修改后的请求配置I.JL.liteGatewayAcc
        return accelerationResult;
      }
    } catch (err) {
      // 加速逻辑出错时不阻断流程，静默失败降级
    }
  }

  if (!isCloudGatewayEnabled) { // 如果全局未启用云/网关特性，直接退出
    return;
  }

  if (ctx.host !== projectConfig.domain) { // 分支 A: 请求目标不是网关域名 (可能是云函数或其他请求)
    if (!ctx.options.__skipDomainCheck__ && typeof __cloudSDKMain__ !== "undefined") { // 如果没有跳过域名检查，且云开发SDK(W)存在
      const cloudMiddleware = __cloudSDKMain__.getRequestMiddleware?.(systemInfo)(ctx.args); // 尝试获取云开发的请求中间件

      if (cloudMiddleware) { // 如果中间件返回了处理函数，将其包装为 Promise 返回，用于拦截 wx.request 并转为云函数调用
        return new Promise((resolve, reject) => cloudMiddleware(resolve, reject));
      }
    }
    return;
  }

{
  "appContactInfo": {
    "passThroughInfo": {
      "wxcloud_gateway": { "user_selected": true },
      "realtime_wxa_report_ob_config": {
        "partital_config_list": [],
        "gateway_config": {
          "auth_info": {
            "key": "8n...Ssw==",
            "token": "99_Tqn...Q",
            "iat": 0,
            "exp": 0,
            "rid": 3388496851
          }
        }
      }
    }
    "stablePassThroughInfo": {
      "wxcloud_gateway_conf": {
        "enabled": true,
        "gateway_info": {
          "space_appid": "wx621112590b635086",
          "gateway_id": "1d5e",
          "access_id": "33a7"
        },
        "access_mode": 1,
        "domain": "a1d5e33a7-wx621112590b635086.sh.wxgateway.com",
        "url_prefixes": ["https://api.m.jd.com"],
        "enable_http2": true,
        "enable_quic": true,
        "env_version": "release",
        "gray_scale": 1000,
        "conf_version": "1767076878",
        "use_high_performance_mode": true,
        "url_prefix_configs": [],
        "user_ctrl_list": [],
        "gray_type": "kGrayTypeScale",
        "expt": { "name": "", "value": "" },
        "disable_timeout_retry": true,
        "mini_lib_ver": "3.7.4"
      }
    }
  }
}

// getRequestMiddleware: () => Zd
function Zd(e) {
    // 先判断是否开启了网关(enabled)、环境(开发/正式/体验版)匹配、基础库版本满足、请求的URL前缀匹配
    // 调用LP(e) => { Gateway: { initRequired: !1, fn: ah(e) } }; 
    Jd = Lp(Yd).Gateway.fn({ ...t, authorization: d })
    // 
}
//  // ah调了sh，sh是微信网关的主要实现
class sh extends tu {
    constructor(e) { } // 初始化网关实例，创建 Token 管理器，配置导出 API 和初始授权信息
    refreshToken(e) {} // 刷新网关会话 (Session) 或 Token，通常在 Token 过期或失效时触发
    callV2(e) { } // 使用 V2 协议(隧道模式)发起请求，通过 operateWXData 走微信底层通道透传数据
    callV3(e, t) { } // 使用 V3 协议(直连模式)发起请求，直接向网关 URL (/__wx__/call) 发送封装后的数据
    runDeferTasks() { } // 执行在网关初始化期间或等待 Token 时被挂起(Defer)的任务队列
    formatErrorMessage(e, t) { } // 格式化错误信息，在错误消息后附加当前网关的状态机状态 (FSM) 以便调试
    initGateway() { } // 启动网关初始化流程，包括获取初始 Token、建立 Keepalive 保活连接和预取资源
    call(e) { } // 网关请求的统一入口，根据配置(除非明确指定否则默认v3)和 Token 状态(不存在则v2)智能选择使用 V2 或 V3 协议
    connectSocket(e, t) { } // 通过网关建立 WebSocket 连接 (/__wx__/wss)，处理握手鉴权及数据帧的封装与解包
}

// 在callV2里继续跟pn->An->gn->vn->i.request 这里的requets是Je({ cloud: this }))，它会调用标准云开发We函数发包，即调用operatewxdata

// JsApiOperateWXData.java
public class JsApiOperateWXData extends BaseAuthJsApi {
    public static final String NAME = "operateWXData";

    @Override
    public void handleAuthRequest(JsInvokeContext ce0, AuthQueueCallback o0) {
        boolean z;
        String s;
        AppBrandComponentBase y0 = (AppBrandComponentBase)ce0.invokeEnv;
        JSONObject jSONObject0 = ce0.data;
        int v = ce0.callbackId;
        try {
            jSONObject0.put("wxdataDequeueTimestamp", System.currentTimeMillis());
            s = jSONObject0.getString("data");
        }
        catch(Exception exception0) {
            n2.e("MicroMsg.AppBrand.JsApiOperateWXData", "Exception %s", new Object[]{exception0.getMessage()});
            y0.a(v, this.o("fail"));
            o0.onQueueStopped();
            return;
        }

        RequestRouteType c0 = RequestRouteType.parseRequestRoutType(jSONObject0);
        // 创建跨进程任务
        JsApiOperateWXData.OperateWXDataTask jsApiOperateWXData$OperateWXDataTask0 = new JsApiOperateWXData.OperateWXDataTask();
        jsApiOperateWXData$OperateWXDataTask0.appId = y0.getAppId();
        jsApiOperateWXData$OperateWXDataTask0.methodName = "operateWXData";
        o0 o00 = y0.getRuntime().g0();
        if(o00 != null) {
            jsApiOperateWXData$OperateWXDataTask0.debugType = o00.r.d;
        }

        AppBrandRuntime appBrandRuntime0 = y0.getRuntime();
        try {
            z = appBrandRuntime0.t0(new JSONObject(s).optString("api_name"));
        }
        catch(JSONException unused_ex) {
            n2.e("MicroMsg.AppBrand.JsApiOperateWXData", "illegal arguments", null);
            z = false;
        }

        jsApiOperateWXData$OperateWXDataTask0.isAsync = z;
        jsApiOperateWXData$OperateWXDataTask0.responseBuilder = this;
        jsApiOperateWXData$OperateWXDataTask0.appBrandContext = y0;
        jsApiOperateWXData$OperateWXDataTask0.data = s;
        jsApiOperateWXData$OperateWXDataTask0.requestRouteType = c0;
        jsApiOperateWXData$OperateWXDataTask0.callbackId = v;
        jsApiOperateWXData$OperateWXDataTask0.taskCallback = new OperateWXDataTaskCallback(jsApiOperateWXData$OperateWXDataTask0, o0);
        jsApiOperateWXData$OperateWXDataTask0.dataMap = new HashMap();
        AppBrandStatObject appBrandStatObject0 = AppBrandBridge.getStatObject(jsApiOperateWXData$OperateWXDataTask0.appId);
        if(appBrandStatObject0 != null) {
            jsApiOperateWXData$OperateWXDataTask0.versionCode = appBrandStatObject0.scene;
        }
        // 根据调用环境：小程序/H5设置客户端版本
        if(y0 instanceof AppBrandService) {
            jsApiOperateWXData$OperateWXDataTask0.clientVersion = 1;
        }
        else if(y0 instanceof AppBrandPageView) {
            jsApiOperateWXData$OperateWXDataTask0.clientVersion = 2;
        }

        int v1 = jSONObject0.optInt("queueLength", -1);
        long v2 = jSONObject0.optLong("wxdataQueueTimestamp", 0x7FFFFFFFFFFFFFFFL);
        long v3 = jSONObject0.optLong("wxdataDequeueTimestamp", 0x7FFFFFFFFFFFFFFFL);
        jsApiOperateWXData$OperateWXDataTask0.queueLength = v1;
        jsApiOperateWXData$OperateWXDataTask0.wxdataQueueTimestamp = v2;
        jsApiOperateWXData$OperateWXDataTask0.wxdataDequeueTimestamp = v3;     
        // 执行跨进程任务
        jsApiOperateWXData$OperateWXDataTask0.executeAsync();
    }
}

// OperateWXDataTask.java - runTask() 中的网络调用
@Override
public void runTask() {
    // 记录开始时间
    if (this.isConfirmOperation) {
        this.beginCgiTimestampAfterConfirm = System.currentTimeMillis();
    } else {
        this.beginCgiTimestamp = System.currentTimeMillis();
    }

    // 创建回调
    OperateWXDataCallbackImpl callback = new OperateWXDataCallbackImpl(this);

    // 执行网络请求
    if (this.methodName.equals("operateWXData")) {
        this.executeNetScene(this.appId, this.data, "", this.debugType, 
                            this.param2, 0, callback, this.requestRouteType, 
                            this.isSecure, this.isAsync);
    } else if (this.methodName.equals("operateWXDataConfirm")) {
        this.executeNetScene(this.appId, this.data, this.confirmData, 
                            this.debugType, this.param2, this.confirmStatus, 
                            callback, this.requestRouteType, this.isSecure, 
                            this.isAsync);
    }
}

public void executeNetScene(String appId, String data, String confirmData, 
                           int debugType, int param1, int param2, 
                           OperateWXDataCallback callback, 
                           RequestRouteType routeType, 
                           boolean isSecure, boolean isAsync) {
    // 1. 创建网络场景
    NetSceneJSOperateWxData scene = new NetSceneJSOperateWxData(
        appId, data, confirmData, debugType, param2, param1, 
        this.versionCode, routeType, this.sessionId, this.userId, 
        isSecure, isAsync, new OperateWxDataSceneCallback(this, data, callback));

    // 2. 设置客户端版本
    int clientVersion = this.clientVersion;
    JSOperateWxDataRequest request = (JSOperateWxDataRequest)
        scene.request.requestWrapper.requestData;

    if (request.header == null) {
        request.header = new JSRequestHeader();
    }
    request.header.clientVersion = clientVersion;

    // 3. 提交到网络队列
    MMKernel.getNetSceneQueue().doScene(scene);
}