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

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,235 @@
+diff --git a/bundledNativeModules.json b/bundledNativeModules.json
+index e2b8941923b274b1c5c9bda2269d28cf574aff7f..355deae878b654e1e1d9db114ee88c1e7e504276 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
+--- a/src/async-require/hmr.ts
++++ b/src/async-require/hmr.ts
+@@ -17,6 +17,7 @@
+   handleCompileError,
+   hideLoading,
+   resetErrorOverlay,
++  reload,
+   showLoading,
+ } from './hmrUtils';
+ 
+@@ -29,6 +30,20 @@
+ let hmrUnavailableReason: string | null = null;
+ const buildErrorQueue = new Set<unknown>();
+ let didConnect: boolean = false;
++// Agent pause is separate from the user's native Fast Refresh preference.
++let miaodaPaused = false;
++let fastRefreshRequested = false;
++const MIAODA_HMR_POLL_INTERVAL_MS = 2000;
++type MiaodaStatusProtocol = 'http' | 'https';
++let miaodaStatusHost: string | null = null;
++let miaodaStatusInitialProtocol: MiaodaStatusProtocol = 'http';
++let miaodaStatusProtocol: MiaodaStatusProtocol | null = null;
++let miaodaStatusPollingStopped = false;
++let miaodaPollTimer: ReturnType<typeof setTimeout> | null = null;
++let miaodaStateVersion: number | null = null;
++let miaodaLastControlVersion: number | null = null;
++let miaodaObservedPaused = false;
++let miaodaWebSocketDisconnected = false;
+ const pendingLogs: [LogLevel, any[]][] = [];
+ 
+ type LogLevel =
+@@ -42,6 +57,86 @@
+   | 'groupEnd'
+   | 'debug';
+ 
++function scheduleMiaodaStatusPoll() {
++  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 {
++      // Devices may reject development certificates and need HTTP, while other
++      // environments expose HTTPS only. Switch only after a network/SSL failure.
++      protocol = alternateMiaodaStatusProtocol(protocol);
++      response = await fetch(miaodaStatusUrl(protocol), {headers: {'Cache-Control': 'no-cache'}});
++    }
++
++    if (response.status === 404) {
++      // A 404 is a definitive signal that this Metro instance has no control route.
++      // Stop probing until the WebSocket reconnects, which may point at a new server.
++      miaodaStatusPollingStopped = true;
++      if (miaodaPollTimer != null) {
++        clearTimeout(miaodaPollTimer);
++        miaodaPollTimer = null;
++      }
++      return;
++    }
++    if (!response.ok) {
++      // 5xx and other temporary HTTP failures are retried on the next interval.
++      return;
++    }
++
++    // Remember the protocol that reached the server for subsequent polls.
++    miaodaStatusProtocol = protocol;
++    const state = (await response.json()) as {
++      paused?: boolean; reloadPending?: boolean; stateVersion?: number; lastMode?: string | null;
++    };
++    const version = Number.isInteger(state.stateVersion) ? state.stateVersion : null;
++    const firstObservation = miaodaStateVersion === null;
++    miaodaStateVersion = version;
++    if (state.paused) {
++      miaodaObservedPaused = true;
++      miaodaPaused = true;
++      hmrClient?.disable();
++      // The observed pause is now our local baseline. A later version without a
++      // matching WebSocket message requires a full Bundle reload.
++      miaodaLastControlVersion = version;
++    } else {
++      const missedControl = !firstObservation && version !== null && version !== miaodaLastControlVersion;
++      const shouldReload = !firstObservation && (state.lastMode === 'reload' || (missedControl && (miaodaObservedPaused || miaodaWebSocketDisconnected)));
++      miaodaObservedPaused = false;
++      miaodaPaused = false;
++      miaodaLastControlVersion = version;
++      if (shouldReload) {
++        reload();
++        return;
++      }
++      if (fastRefreshRequested) HMRClient.enable();
++    }
++  } catch {
++    // Network, timeout and invalid-response failures must not release the edit gate.
++  } finally {
++    scheduleMiaodaStatusPoll();
++  }
++}
++
+ function assert(foo: any, msg: string): asserts foo {
+   if (!foo) throw new Error(msg);
+ }
+@@ -52,6 +147,8 @@
+  */
+ const HMRClient = {
+   enable() {
++    fastRefreshRequested = true;
++    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 +184,7 @@
+   },
+ 
+   disable() {
++    fastRefreshRequested = false;
+     assert(hmrClient, 'Expected HMRClient.setup() call at startup.');
+     hmrClient.disable();
+   },
+@@ -180,6 +278,13 @@
+     const origin = `${serverScheme}://${serverHost}`;
+     const client = new MetroHMRClient(`${origin}/hot`);
+     hmrClient = client;
++    if (process.env.EXPO_OS !== 'web') {
++      // Native clients may receive HTTPS bundle URLs with invalid development certificates,
++      // while some deployments expose only HTTPS. Probe the bundle protocol first, then
++      // remember the protocol that succeeds for subsequent polls.
++      miaodaStatusHost = serverHost;
++      miaodaStatusInitialProtocol = serverScheme === 'https' || serverScheme === 'wss' ? 'https' : 'http';
++    }
+ 
+     pendingEntryPoints.push(
+       // HMRServer understands regular bundle URLs, so prefer that in case
+@@ -192,6 +297,45 @@
+         platform: typeof platformOrOptions === 'string' ? platformOrOptions : undefined,
+       })
+     );
++
++    client.on('open', () => {
++      miaodaWebSocketDisconnected = false;
++      // A reconnect may target a Metro process with HMR control enabled.
++      miaodaStatusPollingStopped = false;
++      scheduleMiaodaStatusPoll();
++    });
++
++    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)) {
++        miaodaStateVersion = message.stateVersion!;
++        miaodaLastControlVersion = message.stateVersion!;
++      }
++      switch (message.action) {
++        case 'pause':
++          miaodaPaused = true;
++          client.disable();
++          hideLoading();
++          client.send(JSON.stringify({type: 'miaoda-hmr-ack', version: 1, id: message.id}));
++          break;
++        case 'resume':
++          miaodaPaused = false;
++          if (fastRefreshRequested) HMRClient.enable();
++          break;
++        case 'reload':
++          miaodaPaused = true;
++          client.disable();
++          reload();
++          break;
++        case 'error':
++          // Final compilation failure is actionable even while the edit gate stays closed.
++          hideLoading();
++          handleCompileError(message.error);
++          break;
++      }
++    });
+ 
+     client.on('connection-error', (e: Error) => {
+       setHMRUnavailableReason(getConnectionError(serverHost, e));
+@@ -234,6 +378,8 @@
+     client.on('error', (data) => this._onMetroError(data));
+ 
+     client.on('close', (closeEvent?: { code: number; reason: string }) => {
++      miaodaWebSocketDisconnected = true;
++      scheduleMiaodaStatusPoll();
+       hideLoading();
+       const reason = closeEvent?.reason;
+       const code = closeEvent?.code || 1000;
+@@ -326,6 +472,7 @@
+     client?.send(
+       JSON.stringify({
+         type: 'register-entrypoints',
++        miaodaHmr: 1,
+         entryPoints: pendingEntryPoints,
+       })
+     );

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

@@ -0,0 +1,24 @@
+diff --git a/src/index.js b/src/index.js
+--- a/src/index.js
++++ b/src/index.js
+@@ -670,6 +670,20 @@
+           );
+         });
+     };
++    // Miaoda edit-batch barrier. The cookie fences watcher delivery; drain file
++    // processing before emitting the changes used by DeltaCalculator.
++    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,13 @@
+diff --git a/src/modules/HMRClient.js b/src/modules/HMRClient.js
+--- a/src/modules/HMRClient.js
++++ b/src/modules/HMRClient.js
+@@ -35,6 +35,9 @@
+     this._ws.onmessage = (message) => {
+       const data = JSON.parse(String(message.data));
+       switch (data.type) {
++        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)
+     }
+ }