Bump Babel, TypeScript, React Native and assorted dependencies; refresh lockfile (#1606)

* Update dependency versions

* Fix gesture handler Android dependency (#1611)

* Patch screens codegen type (#1609)

* Downgrade Sentry React Native (#1612)

* fix patches and packages

* downgrade versions for gesture handler and screens

* agent feedback

* fix ios building

* allow ios tets to pass

* formatting

* make cache more resilient

* Address CodeRabbitAI review comments

This commit addresses all 7 unresolved CodeRabbitAI comments on PR #1606:

Patch-package error handling (comments #1, #2, #3):
- stderr capture already implemented in both root and workspace patch runs
- Add CI warning when patches fail silently instead of exiting with 0
- Log completion status in CI mode for visibility

Critical Mixpanel dependency fix (comment #5):
- Add explicit Mixpanel-swift pod declaration to fix E2E build failures
- Ensures Mixpanel is available even when NFCPassportReader is skipped during E2E testing

React-native-web validation (comment #4):
- Verified no usage of deprecated findNodeHandle, pointerEvents: 'box-none', or createPortal
- Safe to upgrade from 0.19 to 0.21.2

CI workflow improvements (comments #6, #7):
- Create cache-sdk-build composite action for consistent SDK build artifact caching
- Replace all direct actions/cache@v4 usage with cache-yarn composite action
- Replace all direct actions/cache/restore@v4 and save@v4 with cache-sdk-build
- Add nested require() validation step before tests to fail fast on problematic patterns

All changes follow repository coding guidelines for CI caching and test memory optimization.

* Extend cache composite actions to all SDK workflows

This commit extends the caching standardization from PR #1606 to include
mobile-sdk-ci.yml and core-sdk-ci.yml workflows.

New composite actions created:
- cache-mobile-sdk-build: For mobile SDK build artifacts
- cache-core-sdk-build: For core SDK build artifacts

Workflow updates:
- mobile-sdk-ci.yml: Replaced 5 instances of direct actions/cache with cache-mobile-sdk-build
- core-sdk-ci.yml: Replaced 4 instances of direct actions/cache with cache-core-sdk-build

All SDK CI workflows now use consistent caching patterns via composite actions,
following the AGENTS.md guideline: "Use shared composite actions from .github/actions
for CI caching instead of calling actions/cache directly."

Benefits:
- Consistent caching across all SDK workflows (qrcode, mobile, core)
- Centralized cache configuration - easier to maintain
- Follows established patterns from qrcode-sdk-ci.yml

* downgrade react-native-svg

* update pod lock file

* sort

scripts/run-patch-package.cjs

@@ -88,30 +88,45 @@ if (!isExecutableAvailableOnPath('patch-package')) {
   process.exit(0);
 }
 
+// Workspaces with isolated node_modules due to nmHoistingLimits: workspaces
+// Most packages are in workspace node_modules, not root
+const workspaceRoots = [
+  { name: 'app', path: path.join(repositoryRootPath, 'app') },
+  { name: 'contracts', path: path.join(repositoryRootPath, 'contracts') }
+];
+
 // Run patch-package with better error handling
 try {
-  const rootPatchRun = spawnSync('patch-package', ['--patch-dir', 'patches'], {
-    cwd: repositoryRootPath,
-    shell: true,
-    stdio: isCI ? 'pipe' : 'inherit',
-    timeout: 30000
-  });
-  if (rootPatchRun.status === 0) {
-    if (!isCI) console.log('✓ Patches applied to root workspace');
-  } else {
-    const errorOutput = rootPatchRun.stderr?.toString() || rootPatchRun.stdout?.toString() || '';
-    console.error(`patch-package failed for root workspace (exit code ${rootPatchRun.status})`);
-    if (errorOutput) console.error(errorOutput);
-    if (!isCI) process.exit(1);
+  let anyPatchApplied = false;
+  let anyPatchFailed = false;
+
+  // Try root node_modules first (some packages may be hoisted here)
+  const rootNodeModules = path.join(repositoryRootPath, 'node_modules');
+  if (fs.existsSync(rootNodeModules)) {
+    const rootPatchRun = spawnSync('patch-package', ['--patch-dir', 'patches'], {
+      cwd: repositoryRootPath,
+      shell: true,
+      stdio: 'pipe', // Always capture output to check for real errors vs missing packages
+      timeout: 30000
+    });
+    const output = rootPatchRun.stdout?.toString() || '';
+    const stderrOutput = rootPatchRun.stderr?.toString() || '';
+    const hasRealError = (output.includes('**ERROR**') && !output.includes('which is not present at')) ||
+                         (stderrOutput.length > 0 && rootPatchRun.status !== 0);
+    
+    if (rootPatchRun.status === 0) {
+      if (!isCI) console.log('✓ Patches applied to root workspace');
+      anyPatchApplied = true;
+    } else if (hasRealError) {
+      console.error(`patch-package failed for root workspace`);
+      console.error(output);
+      if (stderrOutput) console.error(stderrOutput);
+      anyPatchFailed = true;
+    }
+    // If packages are just missing (not hoisted to root), that's expected - continue to workspace patches
   }
 
-  // Also patch app/node_modules if it exists
-  // Workspaces with isolated node_modules due to limited hoisting
-  const workspaceRoots = [
-    { name: 'app', path: path.join(repositoryRootPath, 'app') },
-    { name: 'contracts', path: path.join(repositoryRootPath, 'contracts') }
-  ];
-
+  // Apply patches to workspace node_modules (where most packages are with nmHoistingLimits)
   for (const workspace of workspaceRoots) {
     const workspaceNodeModules = path.join(workspace.path, 'node_modules');
     if (!fs.existsSync(workspaceNodeModules)) continue;
@@ -119,19 +134,41 @@ try {
     const workspacePatchRun = spawnSync('patch-package', ['--patch-dir', '../patches'], {
       cwd: workspace.path,
       shell: true,
-      stdio: isCI ? 'pipe' : 'inherit',
+      stdio: 'pipe',
       timeout: 30000
     });
 
+    const output = workspacePatchRun.stdout?.toString() || '';
+    const stderrOutput = workspacePatchRun.stderr?.toString() || '';
+    const hasRealError = (output.includes('**ERROR**') && !output.includes('which is not present at')) ||
+                         (stderrOutput.length > 0 && workspacePatchRun.status !== 0);
+
     if (workspacePatchRun.status === 0) {
       if (!isCI) console.log(`✓ Patches applied to ${workspace.name} workspace`);
-    } else {
-      const errorOutput = workspacePatchRun.stderr?.toString() || workspacePatchRun.stdout?.toString() || '';
-      console.error(`patch-package failed for ${workspace.name} workspace (exit code ${workspacePatchRun.status})`);
-      if (errorOutput) console.error(errorOutput);
-      if (!isCI) process.exit(1);
+      anyPatchApplied = true;
+    } else if (hasRealError) {
+      console.error(`patch-package failed for ${workspace.name} workspace`);
+      console.error(output);
+      if (stderrOutput) console.error(stderrOutput);
+      anyPatchFailed = true;
     }
   }
+
+  if (anyPatchFailed && !isCI) {
+    console.error('Some patches failed to apply. Check if patch versions match installed package versions.');
+    process.exit(1);
+  }
+  if (anyPatchFailed && isCI) {
+    console.warn('⚠️  CI Warning: Some patches failed to apply. Review patch compatibility.');
+  }
+
+  if (anyPatchApplied) {
+    if (!isCI) console.log('✓ patch-package completed');
+    else console.log('patch-package completed');
+  } else {
+    if (!isCI) console.log('patch-package: no patches applied (packages may be in different locations)');
+    else console.log('patch-package: no patches applied');
+  }
 } catch (error) {
   if (isCI) {
     console.log('patch-package: error during execution (CI mode):', error.message);