miaoda-expo-devkit 0.1.1-beta.99 → 0.1.1-dev.development-build.2

package/pnpm-patches/@expo__cli@55.0.22.patch

@@ -0,0 +1,218 @@
+diff --git a/build/src/start/server/metro/instantiateMetro.js b/build/src/start/server/metro/instantiateMetro.js
+--- a/build/src/start/server/metro/instantiateMetro.js
++++ b/build/src/start/server/metro/instantiateMetro.js
+@@ -90,6 +90,7 @@
+ const _attachAtlas = require("./debugging/attachAtlas");
+ const _createDebugMiddleware = require("./debugging/createDebugMiddleware");
+ const _createMetroMiddleware = require("./dev-server/createMetroMiddleware");
++const _aiErrorCollector = require("./aiErrorCollector");
+ const _runServerfork = require("./runServer-fork");
+ const _withMetroMultiPlatform = require("./withMetroMultiPlatform");
+ const _events = require("../../../events");
+@@ -274,6 +275,7 @@
+     const { middleware, messagesSocket, eventsSocket, websocketEndpoints } = (0, _createMetroMiddleware.createMetroMiddleware)(metroConfig, {
+         getMetroBundler
+     });
++    const aiErrorCollector = !isExporting ? (0, _aiErrorCollector.createAiErrorCollector)(projectRoot) : null;
+     // Get local URL to Metro bundler server (typically configured as 127.0.0.1:8081)
+     const serverBaseUrl = metroBundler.getUrlCreator().constructUrl({
+         scheme: 'http',
+@@ -348,7 +350,10 @@
+             }
+         }), fileBuffer);
+     };
+-    setEventReporter(eventsSocket.reportMetroEvent);
++    setEventReporter((event)=>{
++        eventsSocket.reportMetroEvent(event);
++        aiErrorCollector == null ? void 0 : aiErrorCollector.handleMetroEvent(event);
++    });
+     // This function ensures that modules in source maps are sorted in the same
+     // order as in a plain JS bundle.
+     metro._getSortedModules = function(graph) {
+@@ -493,1 +498,1 @@
+-//# sourceMappingURL=instantiateMetro.js.map
+
++//# sourceMappingURL=instantiateMetro.js.map
+diff --git a/build/src/start/server/metro/aiErrorCollector.js b/build/src/start/server/metro/aiErrorCollector.js
+new file mode 100644
+--- /dev/null
++++ b/build/src/start/server/metro/aiErrorCollector.js
+@@ -0,0 +1,178 @@
++"use strict";
++Object.defineProperty(exports, "__esModule", {
++    value: true
++});
++Object.defineProperty(exports, "createAiErrorCollector", {
++    enumerable: true,
++    get: function() {
++        return createAiErrorCollector;
++    }
++});
++const fs = require("fs");
++const os = require("os");
++const path = require("path");
++
++const MAX_VALUE_DEPTH = 4;
++const MAX_STRING_LENGTH = 20000;
++
++function isEnabled() {
++    return process.env.EXPO_AI_ERROR_COLLECTOR === '1';
++}
++
++function getOutputPath(projectRoot) {
++    const configured = process.env.EXPO_AI_ERROR_FILE;
++    if (!configured) return path.join(projectRoot, 'node_modules', '.miaoda-expo', 'ai-error.json');
++    return path.isAbsolute(configured) ? configured : path.resolve(projectRoot, configured);
++}
++
++function toSerializable(value, depth = 0, seen = new Set()) {
++    if (value == null || typeof value === 'boolean' || typeof value === 'number') return value;
++    if (typeof value === 'string') return value.length > MAX_STRING_LENGTH ? value.slice(0, MAX_STRING_LENGTH) + '...[truncated]' : value;
++    if (depth >= MAX_VALUE_DEPTH) return '[truncated]';
++    if (typeof value === 'function' || typeof value === 'symbol') return String(value);
++    if (seen.has(value)) return '[circular]';
++    seen.add(value);
++    if (value instanceof Error) {
++        const error = {
++            name: value.name,
++            message: value.message,
++            stack: value.stack
++        };
++        for (const key of Object.keys(value)) error[key] = toSerializable(value[key], depth + 1, seen);
++        seen.delete(value);
++        return error;
++    }
++    if (Array.isArray(value)) {
++        const result = value.map((item)=>toSerializable(item, depth + 1, seen));
++        seen.delete(value);
++        return result;
++    }
++    if (typeof value === 'object') {
++        const result = {};
++        for (const key of Object.keys(value)) result[key] = toSerializable(value[key], depth + 1, seen);
++        seen.delete(value);
++        return result;
++    }
++    return String(value);
++}
++
++function normalizeError(error, projectRoot, buildID) {
++    const raw = error && typeof error === 'object' ? error : {
++        message: String(error ?? 'Metro bundling failed')
++    };
++    const message = String(raw.message ?? raw.reason ?? error ?? 'Metro bundling failed');
++    const record = {
++        schemaVersion: 1,
++        id: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
++        timestamp: new Date().toISOString(),
++        source: 'metro',
++        eventType: 'bundling_error',
++        buildID: buildID ?? undefined,
++        projectRoot,
++        type: String(raw.type ?? raw.name ?? 'MetroError'),
++        name: raw.name == null ? undefined : String(raw.name),
++        message,
++        filename: raw.filename == null ? undefined : String(raw.filename),
++        lineNumber: typeof raw.lineNumber === 'number' ? raw.lineNumber : undefined,
++        column: typeof raw.column === 'number' ? raw.column : undefined,
++        errors: Array.isArray(raw.errors) ? toSerializable(raw.errors) : [],
++        stack: raw.stack == null ? undefined : String(raw.stack),
++        cause: raw.cause == null ? undefined : toSerializable(raw.cause)
++    };
++    const extra = {};
++    for (const key of Object.keys(raw)) {
++        if (!['type', 'name', 'message', 'filename', 'lineNumber', 'column', 'errors', 'stack', 'cause'].includes(key)) {
++            extra[key] = toSerializable(raw[key]);
++        }
++    }
++    if (Object.keys(extra).length) record.extra = extra;
++    return omitUndefined(record);
++}
++
++function omitUndefined(value) {
++    if (!value || typeof value !== 'object') return value;
++    if (Array.isArray(value)) return value.map(omitUndefined);
++    const result = {};
++    for (const [key, item] of Object.entries(value)) {
++        if (item !== undefined) result[key] = omitUndefined(item);
++    }
++    return result;
++}
++
++function createAiErrorCollector(projectRoot) {
++    if (!isEnabled()) return null;
++    const outputFile = getOutputPath(projectRoot);
++    let activeBuildID = null;
++    let lastFailedBuildID = null;
++    let state = {
++        schemaVersion: 1,
++        status: 'compiling',
++        buildID: null,
++        updatedAt: new Date().toISOString(),
++        error: null
++    };
++    let warned = false;
++    const publish = (nextState)=>{
++        state = omitUndefined({ ...nextState, updatedAt: new Date().toISOString() });
++        let temporaryFile;
++        try {
++            fs.mkdirSync(path.dirname(outputFile), { recursive: true });
++            temporaryFile = `${outputFile}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
++            fs.writeFileSync(temporaryFile, JSON.stringify(state, null, 2) + os.EOL, 'utf8');
++            fs.renameSync(temporaryFile, outputFile);
++        } catch (error) {
++            try {
++                if (temporaryFile) fs.rmSync(temporaryFile, { force: true });
++            } catch {}
++            if (!warned) {
++                warned = true;
++                console.warn(`[expo-ai-error] Could not write ${outputFile}: ${error.message}`);
++            }
++        }
++    };
++    const isCurrentBuild = (buildID, allowMissing = false)=>buildID == null ? allowMissing || activeBuildID == null : activeBuildID == null || buildID === activeBuildID;
++    return {
++        getState() {
++            return state;
++        },
++        handleMetroEvent(event) {
++            if (!event || typeof event !== 'object') return;
++            const type = event.type;
++            const buildID = event.buildID ?? event.bundleDetails?.buildID ?? null;
++            if (type === 'bundle_build_started') {
++                activeBuildID = buildID;
++                lastFailedBuildID = null;
++                publish({ schemaVersion: 1, status: 'compiling', buildID, error: null });
++                return;
++            }
++            if (type === 'bundle_build_failed') {
++                if (!isCurrentBuild(buildID)) return;
++                lastFailedBuildID = buildID ?? activeBuildID;
++                publish({
++                    schemaVersion: 1,
++                    status: 'failed',
++                    buildID: lastFailedBuildID,
++                    error: normalizeError(event.error ?? { type: 'MetroBundleError', message: 'Metro bundling failed' }, projectRoot, lastFailedBuildID)
++                });
++                return;
++            }
++            if (type === 'bundling_error') {
++                const errorBuildID = buildID ?? lastFailedBuildID ?? activeBuildID;
++                if (!isCurrentBuild(errorBuildID, true)) return;
++                publish({
++                    schemaVersion: 1,
++                    status: 'failed',
++                    buildID: errorBuildID,
++                    error: normalizeError(event.error, projectRoot, errorBuildID)
++                });
++                return;
++            }
++            if (type === 'bundle_build_done') {
++                if (!isCurrentBuild(buildID)) return;
++                publish({ schemaVersion: 1, status: 'succeeded', buildID: buildID ?? activeBuildID, error: null });
++            }
++        }
++    };
++}
++
++//# sourceMappingURL=aiErrorCollector.js.map

package/pnpm-patches/@shopify__react-native-skia@2.4.18.patch

@@ -0,0 +1,14 @@
+diff --git a/scripts/install-skia.mjs b/scripts/install-skia.mjs
+index ac4e945f9acb611c43f60a38aaada1ca2b695bb2..d502637ac0e09d8016b2b174c08265237bf4085f 100644
+--- a/scripts/install-skia.mjs
++++ b/scripts/install-skia.mjs
+@@ -484,7 +484,8 @@ const main = async () => {
+   for (const artifactName of names) {
+     const assetName = `${artifactName}-${releaseTag}.tar.gz`;
+     const extractDir = path.join(artifactsDir, artifactName);
+-    const downloadUrl = `https://github.com/${repo}/releases/download/${releaseTag}/${assetName}`;
++    const baseUrl = process.env.SKIA_DOWNLOAD_BASE_URL || `https://github.com/${repo}/releases/download`;
++    const downloadUrl = `${baseUrl}/${releaseTag}/${assetName}`;
+ 
+     console.log(`   Downloading ${assetName}...`);
+     try {

package/pnpm-patches/expo-modules-core@55.0.15.patch

@@ -0,0 +1,21 @@
+--- a/android/cmake/main.cmake
++++ b/android/cmake/main.cmake
+@@ -73,15 +73,17 @@
+ 
+   if (${CMAKE_BUILD_TYPE} MATCHES "Debug")
+     set(BUILD_TYPE "debug")
++    set(MERGE_NATIVE_LIBS_DIR "mergeDebugNativeLibs")
+   else ()
+     set(BUILD_TYPE "release")
++    set(MERGE_NATIVE_LIBS_DIR "mergeReleaseNativeLibs")
+   endif ()
+ 
+   set_target_properties(
+     worklets
+     PROPERTIES
+     IMPORTED_LOCATION
+-    "${REACT_NATIVE_WORKLETS_DIR}/android/build/intermediates/cmake/${BUILD_TYPE}/obj/${ANDROID_ABI}/libworklets.so"
++    "${REACT_NATIVE_WORKLETS_DIR}/android/build/intermediates/merged_native_libs/${BUILD_TYPE}/${MERGE_NATIVE_LIBS_DIR}/out/lib/${ANDROID_ABI}/libworklets.so"
+   )
+ 
+   target_link_libraries(

package/pnpm-patches/expo@55.0.6.patch

@@ -0,0 +1,283 @@
+diff --git a/bundledNativeModules.json b/bundledNativeModules.json
+index e2b8941..355deae 100644
+--- a/bundledNativeModules.json
++++ b/bundledNativeModules.json
+@@ -19,7 +19,7 @@
+   "expo-apple-authentication": "~55.0.8",
+   "expo-application": "~55.0.9",
+   "expo-asset": "~55.0.8",
+-  "expo-audio": "~55.0.8",
++  "expo-audio": "55.0.6",
+   "expo-auth-session": "~55.0.8",
+   "expo-background-fetch": "~55.0.9",
+   "expo-background-task": "~55.0.9",
+@@ -90,7 +90,7 @@
+   "expo-tracking-transparency": "~55.0.8",
+   "expo-updates": "~55.0.13",
+   "expo-video-thumbnails": "~55.0.10",
+-  "expo-video": "~55.0.10",
++  "expo-video": "55.0.5",
+   "expo-web-browser": "~55.0.9",
+   "jest-expo": "~55.0.9",
+   "lottie-react-native": "~7.3.4",
+diff --git a/src/async-require/hmr.ts b/src/async-require/hmr.ts
+index c0ea71e..953cf53 100644
+--- a/src/async-require/hmr.ts
++++ b/src/async-require/hmr.ts
+@@ -17,6 +17,7 @@ import {
+   handleCompileError,
+   hideLoading,
+   resetErrorOverlay,
++  reload,
+   showLoading,
+ } from './hmrUtils';
+ 
+@@ -29,6 +30,38 @@ let hmrClient: MetroHMRClient | null = null;
+ let hmrUnavailableReason: string | null = null;
+ const buildErrorQueue = new Set<unknown>();
+ let didConnect: boolean = false;
++// ---- Miaoda HMR 批量编辑控制（客户端侧）----
++// miaodaPaused 是 Agent 的编辑闸门，与用户自己的 Fast Refresh 开关
++// （fastRefreshRequested）相互独立：放行后只有用户开着 Fast Refresh 才恢复更新。
++let miaodaPaused = false;
++let fastRefreshRequested = false;
++// 断线兜底轮询间隔。控制消息走 /hot WebSocket，轮询只用于 socket 断开期间的
++// 状态同步，不需要很频繁。
++const MIAODA_HMR_POLL_INTERVAL_MS = 2000;
++type MiaodaStatusProtocol = 'http' | 'https';
++let miaodaStatusHost: string | null = null;
++// 首次探测使用的协议，取 bundle URL 的 scheme（设备怎么加载 bundle 就先试什么协议）。
++let miaodaStatusInitialProtocol: MiaodaStatusProtocol = 'http';
++// 自适应成功后记住的协议；null 表示还没有成功过，每轮都先试初始协议。
++let miaodaStatusProtocol: MiaodaStatusProtocol | null = null;
++// 收到明确 404（服务端未启用控制路由）后停止轮询；WebSocket 重连时重置，
++// 因为重连对面的 Metro 可能换了一个开启了控制的进程。
++let miaodaStatusPollingStopped = false;
++let miaodaPollTimer: ReturnType<typeof setTimeout> | null = null;
++// 轮询最近一次见到的服务端状态版本。
++let miaodaStateVersion: number | null = null;
++// 已通过 WebSocket 控制消息同步到的版本。轮询发现比它新的版本，说明 socket
++// 断开期间错过了控制消息，增量 revision 的连续性无法证明，必须完整 reload。
++let miaodaLastControlVersion: number | null = null;
++// 本次 JS 会话首次观察到的服务端版本（WebSocket 或轮询，谁先到用谁），此后
++// 不再更新。新会话的 bundle 刚从服务器取回，内容本身就对应该时刻的服务端
++// 状态，因此它是「当前运行代码已知完好」的锚点：之后版本号超过它且
++// lastMode 为 reload，才说明本会话错过了一次必须完整加载的迁移。
++let miaodaSessionBaseVersion: number | null = null;
++// 轮询曾观察到 paused=true：之后的版本变化即使 lastMode 不是 reload
++// 也要按 reload 处理（暂停期间错过的批量编辑不能靠增量补齐）。
++let miaodaObservedPaused = false;
++let miaodaWebSocketDisconnected = false;
+ const pendingLogs: [LogLevel, any[]][] = [];
+ 
+ type LogLevel =
+@@ -42,6 +75,100 @@ type LogLevel =
+   | 'groupEnd'
+   | 'debug';
+ 
++function scheduleMiaodaStatusPoll() {
++  // Web 端不轮询（跨域响应会被浏览器拦截，且没有必要）；无 host、已 404 停止、
++  // 或已有定时器在跑时都直接跳过。unref 避免定时器阻止进程退出（如 Jest 环境）。
++  if (process.env.EXPO_OS === 'web' || !miaodaStatusHost || miaodaStatusPollingStopped || miaodaPollTimer != null) return;
++  miaodaPollTimer = setTimeout(() => {
++    miaodaPollTimer = null;
++    void pollMiaodaStatus();
++  }, MIAODA_HMR_POLL_INTERVAL_MS);
++  (miaodaPollTimer as any).unref?.();
++}
++
++function miaodaStatusUrl(protocol: MiaodaStatusProtocol) {
++  return `${protocol}://${miaodaStatusHost}/innerapi/v1/sourcecode/__hmr_status`;
++}
++
++function alternateMiaodaStatusProtocol(protocol: MiaodaStatusProtocol): MiaodaStatusProtocol {
++  return protocol === 'https' ? 'http' : 'https';
++}
++
++async function pollMiaodaStatus() {
++  if (process.env.EXPO_OS === 'web' || !miaodaStatusHost || miaodaStatusPollingStopped) return;
++  let protocol = miaodaStatusProtocol ?? miaodaStatusInitialProtocol;
++  try {
++    let response;
++    try {
++      response = await fetch(miaodaStatusUrl(protocol), {headers: {'Cache-Control': 'no-cache'}});
++    } catch {
++      // 协议自适应：部分开发环境的 HTTPS 证书无效、设备会拒绝，需要降级 HTTP；
++      // 也有环境只暴露 HTTPS。只有网络/证书类失败（fetch reject）才换协议重试，
++      // HTTP 状态码不算——那是服务器给出的确定答复。
++      protocol = alternateMiaodaStatusProtocol(protocol);
++      response = await fetch(miaodaStatusUrl(protocol), {headers: {'Cache-Control': 'no-cache'}});
++    }
++
++    if (response.status === 404) {
++      // 404 是确定性信号：这个 Metro 实例没有挂载控制路由（未开启
++      // EXPO_MIAODA_HMR_CONTROL）。停止探测直到 WebSocket 重连，
++      // 避免对普通开发服务器永久空轮询。注意不要在 404 时换协议重试。
++      miaodaStatusPollingStopped = true;
++      if (miaodaPollTimer != null) {
++        clearTimeout(miaodaPollTimer);
++        miaodaPollTimer = null;
++      }
++      return;
++    }
++    if (!response.ok) {
++      // 5xx 等暂时性 HTTP 失败不停止轮询，下一轮继续重试。
++      return;
++    }
++
++    // 记住本次到达服务器的协议，后续轮询固定使用它。
++    miaodaStatusProtocol = protocol;
++    const state = (await response.json()) as {
++      paused?: boolean; reloadPending?: boolean; stateVersion?: number; lastMode?: string | null;
++    };
++    // Number.isInteger 不是 TS 类型守卫，先收窄 number 再判整数，
++    // 使 version 的类型收敛为 number | null。
++    const version = typeof state.stateVersion === 'number' && Number.isInteger(state.stateVersion) ? state.stateVersion : null;
++    const firstObservation = miaodaStateVersion === null;
++    miaodaStateVersion = version;
++    if (miaodaSessionBaseVersion === null && version !== null) miaodaSessionBaseVersion = version;
++    if (state.paused) {
++      miaodaObservedPaused = true;
++      miaodaPaused = true;
++      hmrClient?.disable();
++      // 把观察到的这次暂停作为本地基线版本。之后若出现没有对应 WebSocket
++      // 控制消息的新版本，说明错过了状态迁移，必须完整 Bundle reload。
++      miaodaLastControlVersion = version;
++    } else {
++      // 错过控制消息且（曾处于暂停或 socket 断连中）→ 增量连续性无法证明，
++      // 只能 reload。lastMode === 'reload' 则必须再满足「版本号相对本次会话
++      // 基线前进过」才视为未执行的 reload 指令：服务端会把 lastMode 持久化并
++      // 一直原样返回，若不做版本门控，已经执行过 reload 的客户端重连后会反复
++      // 执行同一条指令，陷入无限重载循环。
++      const missedControl = !firstObservation && version !== null && version !== miaodaLastControlVersion;
++      const missedReload = version !== null && miaodaSessionBaseVersion !== null && version > miaodaSessionBaseVersion && state.lastMode === 'reload';
++      const shouldReload = missedReload || (missedControl && (miaodaObservedPaused || miaodaWebSocketDisconnected));
++      miaodaObservedPaused = false;
++      miaodaPaused = false;
++      miaodaLastControlVersion = version;
++      if (shouldReload) {
++        reload();
++        return;
++      }
++      if (fastRefreshRequested) HMRClient.enable();
++    }
++  } catch {
++    // 网络错误、超时、响应解析失败都属于暂时故障：不解除编辑闸门，
++    // 也不停止轮询，下一轮继续。
++  } finally {
++    scheduleMiaodaStatusPoll();
++  }
++}
++
+ function assert(foo: any, msg: string): asserts foo {
+   if (!foo) throw new Error(msg);
+ }
+@@ -52,6 +179,9 @@ function assert(foo: any, msg: string): asserts foo {
+  */
+ const HMRClient = {
+   enable() {
++    fastRefreshRequested = true;
++    // Agent 编辑闸门优先于用户操作：暂停期间只记录意图，等 resume 再恢复。
++    if (miaodaPaused) return;
+     if (hmrUnavailableReason !== null) {
+       // If HMR became unavailable while you weren't using it,
+       // explain why when you try to turn it on.
+@@ -87,6 +217,7 @@ const HMRClient = {
+   },
+ 
+   disable() {
++    fastRefreshRequested = false;
+     assert(hmrClient, 'Expected HMRClient.setup() call at startup.');
+     hmrClient.disable();
+   },
+@@ -180,6 +311,13 @@ const HMRClient = {
+     const origin = `${serverScheme}://${serverHost}`;
+     const client = new MetroHMRClient(`${origin}/hot`);
+     hmrClient = client;
++    if (process.env.EXPO_OS !== 'web') {
++      // 仅 native 客户端启用状态轮询。初始协议跟随 bundle URL 的 scheme：
++      // 设备可能拿到证书无效的 HTTPS 开发地址，也有环境只暴露 HTTPS，
++      // 因此先按 bundle 协议探测，成功后记住可用的那个协议。
++      miaodaStatusHost = serverHost;
++      miaodaStatusInitialProtocol = serverScheme === 'https' || serverScheme === 'wss' ? 'https' : 'http';
++    }
+ 
+     pendingEntryPoints.push(
+       // HMRServer understands regular bundle URLs, so prefer that in case
+@@ -193,6 +331,55 @@ const HMRClient = {
+       })
+     );
+ 
++    client.on('open', () => {
++      miaodaWebSocketDisconnected = false;
++      // 重连对面的 Metro 可能是另一个进程（例如这次开启了 HMR 控制），
++      // 重置 404 停止标志，重新探测一次。
++      miaodaStatusPollingStopped = false;
++      scheduleMiaodaStatusPoll();
++    });
++
++    // 服务端编辑闸门控制消息（协议 v1）。stateVersion 随每条消息捎带，
++    // 收到即同步本地版本基线，轮询兜底据此判断有没有丢消息。
++    client.on('miaoda-hmr-control', (message: {
++      version: number; action: string; id?: number; error?: any; stateVersion?: number;
++    }) => {
++      if (message.version !== 1) return;
++      if (Number.isInteger(message.stateVersion)) {
++        if (miaodaSessionBaseVersion === null) miaodaSessionBaseVersion = message.stateVersion!;
++        miaodaStateVersion = message.stateVersion!;
++        miaodaLastControlVersion = message.stateVersion!;
++      }
++      switch (message.action) {
++        case 'pause':
++          // 立即闸住 HMR 并隐藏刷新提示，然后回 ack——服务端要等所有客户端
++          // ack 后才认为暂停完成，ack 之前 Agent 不会开始写文件。
++          miaodaPaused = true;
++          client.disable();
++          hideLoading();
++          client.send(JSON.stringify({type: 'miaoda-hmr-ack', version: 1, id: message.id}));
++          break;
++        case 'resume':
++          // 解除 Agent 闸门；用户自己的 Fast Refresh 开关保持独立，
++          // 只有它开着才真正恢复更新。
++          miaodaPaused = false;
++          if (fastRefreshRequested) HMRClient.enable();
++          break;
++        case 'reload':
++          // 完整加载前也保持闸门，避免 reload 完成前又有增量进来。
++          miaodaPaused = true;
++          client.disable();
++          reload();
++          break;
++        case 'error':
++          // 批次最终编译失败：闸门仍然关着（服务端等 Agent 修好重试），
++          // 但错误本身要展示出来，因为它在设备端是可行动的。
++          hideLoading();
++          handleCompileError(message.error);
++          break;
++      }
++    });
++
+     client.on('connection-error', (e: Error) => {
+       setHMRUnavailableReason(getConnectionError(serverHost, e));
+     });
+@@ -234,6 +421,10 @@ const HMRClient = {
+     client.on('error', (data) => this._onMetroError(data));
+ 
+     client.on('close', (closeEvent?: { code: number; reason: string }) => {
++      // 控制通道断开：之后的版本变化都无法通过 socket 同步，
++      // 启动轮询兜底直到重连。
++      miaodaWebSocketDisconnected = true;
++      scheduleMiaodaStatusPoll();
+       hideLoading();
+       const reason = closeEvent?.reason;
+       const code = closeEvent?.code || 1000;
+@@ -326,6 +517,9 @@ function registerBundleEntryPoints(client: MetroHMRClient | null) {
+     client?.send(
+       JSON.stringify({
+         type: 'register-entrypoints',
++        // Miaoda 控制协议 v1 的协商标记：带此标记的客户端才会收到
++        // miaoda-hmr-control 消息；不带标记的老客户端会触发服务端 409。
++        miaodaHmr: 1,
+         entryPoints: pendingEntryPoints,
+       })
+     );

package/pnpm-patches/metro-file-map@0.83.3.patch

@@ -0,0 +1,28 @@
+diff --git a/src/index.js b/src/index.js
+index ec21a55..b8a8f68 100644
+--- a/src/index.js
++++ b/src/index.js
+@@ -670,6 +670,23 @@ class FileMap extends _events.default {
+           );
+         });
+     };
++    // Miaoda 批量编辑栅栏：resume 时用来证明「watcher 已经看到了 Agent 的
++    // 最后一次写入」。checkHealth 的 cookie 沿 watcher 通道走一遍，返回即代表
++    // 此前所有文件事件都已投递到本进程；再把 changeQueue 排空（处理中的事件
++    // 可能继续入队新任务，所以循环到队列不再变化）；最后 emitChange() 立即
++    // 发出累积的变更，让 DeltaCalculator 不等 CHANGE_INTERVAL 就能看到它们。
++    this.miaodaFlushChanges = async (timeout = 5000) => {
++      const result = await this._watcher.checkHealth(timeout);
++      if (result.type !== "success") {
++        throw new Error("Metro watcher barrier failed: " + result.type);
++      }
++      let pending;
++      do {
++        pending = changeQueue;
++        await pending;
++      } while (pending !== changeQueue);
++      emitChange();
++    };
+     this._changeInterval = setInterval(emitChange, CHANGE_INTERVAL);
+     (0, _invariant.default)(
+       this._watcher != null,

package/pnpm-patches/metro-runtime@0.83.3.patch

@@ -0,0 +1,17 @@
+diff --git a/src/modules/HMRClient.js b/src/modules/HMRClient.js
+index 3e2652d..8225714 100644
+--- a/src/modules/HMRClient.js
++++ b/src/modules/HMRClient.js
+@@ -35,6 +35,12 @@ class HMRClient extends EventEmitter {
+     this._ws.onmessage = (message) => {
+       const data = JSON.parse(String(message.data));
+       switch (data.type) {
++        // Miaoda HMR 批量编辑控制：服务端复用这条 /hot socket 下发
++        // 控制消息。HMRClient 只做透传转发，具体处理在 expo 包的
++        // async-require/hmr.ts（该补丁同时加了版本协商，version !== 1 直接忽略）。
++        case "miaoda-hmr-control":
++          if (data.version === 1) this.emit("miaoda-hmr-control", data);
++          break;
+         case "bundle-registered":
+           this.emit("bundle-registered");
+           break;

package/pnpm-patches/react-native-css-interop@0.2.6.patch

@@ -0,0 +1,12 @@
+diff --git a/dist/css-to-rn/parseDeclaration.js b/dist/css-to-rn/parseDeclaration.js
+index 59ea66e459dbf6922bcd80a6ac014408ca13c2af..088149d6f92dfb8f48bb979f5239c2a420f0dc2d 100644
+--- a/dist/css-to-rn/parseDeclaration.js
++++ b/dist/css-to-rn/parseDeclaration.js
+@@ -918,6 +918,7 @@ function parseDeclaration(declaration, options) {
+             return addStyleProp(declaration.property, parseTextAlign(declaration.value, parseOptions));
+         case "box-shadow": {
+             parseBoxShadow(declaration.value, parseOptions);
++            return;
+         }
+         case "aspect-ratio": {
+             return addStyleProp(declaration.property, parseAspectRatio(declaration.value));

package/pnpm-patches/react-native-reanimated@4.2.1.patch

@@ -0,0 +1,53 @@
+--- a/android/CMakeLists.txt
++++ b/android/CMakeLists.txt
+@@ -76,8 +76,10 @@
+ 
+ if(${CMAKE_BUILD_TYPE} MATCHES "Debug")
+   set(BUILD_TYPE "debug")
++  set(MERGE_NATIVE_LIBS_DIR "mergeDebugNativeLibs")
+ else()
+   set(BUILD_TYPE "release")
++  set(MERGE_NATIVE_LIBS_DIR "mergeReleaseNativeLibs")
+ endif()
+ 
+ add_library(worklets SHARED IMPORTED)
+@@ -86,7 +88,7 @@
+   worklets
+   PROPERTIES
+     IMPORTED_LOCATION
+-    "${REACT_NATIVE_WORKLETS_DIR}/android/build/intermediates/cmake/${BUILD_TYPE}/obj/${ANDROID_ABI}/libworklets.so"
++    "${REACT_NATIVE_WORKLETS_DIR}/android/build/intermediates/merged_native_libs/${BUILD_TYPE}/${MERGE_NATIVE_LIBS_DIR}/out/lib/${ANDROID_ABI}/libworklets.so"
+ )
+ 
+ set_target_properties(reanimated PROPERTIES LINKER_LANGUAGE CXX)
+--- a/android/build.gradle
++++ b/android/build.gradle
+@@ -350,7 +350,26 @@
+     evaluationDependsOn(":react-native-worklets")
+ 
+     afterEvaluate {
+-        tasks.getByName("externalNativeBuildDebug").dependsOn(findProject(":react-native-worklets").tasks.getByName("externalNativeBuildDebug"))
+-        tasks.getByName("externalNativeBuildRelease").dependsOn(findProject(":react-native-worklets").tasks.getByName("externalNativeBuildRelease"))
++        def workletsTasks = findProject(":react-native-worklets").tasks
++        def workletsDebugNativeLibs = workletsTasks.getByName("mergeDebugNativeLibs")
++        def workletsReleaseNativeLibs = workletsTasks.getByName("mergeReleaseNativeLibs")
++
++        // CMakeLists.txt imports libworklets.so from the `merged_native_libs` output of
++        // `:react-native-worklets:merge<Variant>NativeLibs`. ninja resolves that file while the
++        // per-ABI `buildCMake<NativeBuildType>[<abi>][<target>]` tasks run, and those tasks are
++        // *upstream* of the `externalNativeBuild<Variant>` umbrella task, so ordering declared on
++        // the umbrella task alone lands too late and the link fails with
++        // "libworklets.so ... missing and no known rule to make it".
++        // Release variants build with CMAKE_BUILD_TYPE=RelWithDebInfo, so their task name is
++        // `buildCMakeRelWithDebInfo[...]`; match on "Debug" and treat every other build type as
++        // release, mirroring the CMAKE_BUILD_TYPE check in CMakeLists.txt.
++        tasks.matching { it.name.startsWith("buildCMake") }.configureEach { nativeBuildTask ->
++            nativeBuildTask.dependsOn(
++                nativeBuildTask.name.contains("Debug") ? workletsDebugNativeLibs : workletsReleaseNativeLibs
++            )
++        }
++
++        tasks.getByName("externalNativeBuildDebug").dependsOn(workletsDebugNativeLibs)
++        tasks.getByName("externalNativeBuildRelease").dependsOn(workletsReleaseNativeLibs)
+     }
+ }