From 5b3fa6c1d0a248784771eee89f3cde5c08378dcd Mon Sep 17 00:00:00 2001
From: Marc Rousavy <me@mrousavy.com>
Date: Wed, 18 Dec 2024 16:51:54 +0100
Subject: [PATCH] =?UTF-8?q?feat:=20Implement=20Swift=20errors=20?=
 =?UTF-8?q?=F0=9F=A5=B3=20(#430)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* chore: Use C++ 23

* feat: Add `ResultWrappingType`

* feat: Add C++ `ResultWrappingType` bridge

* feat: Use C++ result wrapper

* feat: Use `std::expected` for Swift return types

* Bump to 23

* Downgrade to C++ 20 again

* fix: Use `Result<T>` instead of expected

* fix: Return even if void

* fix: Explicitly say type

* extra line for debugging

* fix: Fix double args

* fix: Bridge directly to C++ target for return values

* feat: THROW SWIFT ERROR WOOHOOO

* feat: Make it work

* feat: Add test that uses `Result<complex type>` and throws before

* Update getTests.ts

* Update HybridTestObjectKotlin.kt

* extra line

* perf: Use `assert` for `value()`

* docs: Remove error swift limitation as it now works
---
 docs/docs/errors.md                           |   5 -
 example/ios/Podfile.lock                      |   2 +-
 example/src/getTests.ts                       |   7 +
 packages/nitrogen/src/syntax/createType.ts    |  12 +
 .../src/syntax/swift/SwiftCxxBridgedType.ts   |   4 +
 .../src/syntax/swift/SwiftCxxTypeHelper.ts    |  56 ++
 .../syntax/swift/SwiftHybridObjectBridge.ts   |  57 ++-
 .../src/syntax/types/ResultWrappingType.ts    |  49 ++
 packages/nitrogen/src/syntax/types/Type.ts    |   1 +
 .../nitro/image/HybridTestObjectKotlin.kt     |   4 +
 .../cpp/HybridTestObjectCpp.cpp               |   4 +
 .../cpp/HybridTestObjectCpp.hpp               |   1 +
 .../ios/HybridTestObjectSwift.swift           |  15 +-
 .../c++/JHybridTestObjectSwiftKotlinSpec.cpp  |  15 +
 .../c++/JHybridTestObjectSwiftKotlinSpec.hpp  |   1 +
 .../image/HybridTestObjectSwiftKotlinSpec.kt  |   4 +
 .../ios/NitroImage-Swift-Cxx-Bridge.hpp       | 341 ++++++++++---
 .../ios/NitroImage-Swift-Cxx-Umbrella.hpp     |   1 +
 .../ios/c++/HybridImageFactorySpecSwift.hpp   |  24 +-
 .../ios/c++/HybridImageSpecSwift.hpp          |  11 +-
 .../HybridTestObjectSwiftKotlinSpecSwift.hpp  | 260 ++++++++--
 .../swift/HybridImageFactorySpec_cxx.swift    |  44 +-
 .../ios/swift/HybridImageSpec_cxx.swift       |  21 +-
 .../HybridTestObjectSwiftKotlinSpec.swift     |   1 +
 .../HybridTestObjectSwiftKotlinSpec_cxx.swift | 483 ++++++++++--------
 .../shared/c++/HybridTestObjectCppSpec.cpp    |   1 +
 .../shared/c++/HybridTestObjectCppSpec.hpp    |   3 +-
 .../c++/HybridTestObjectSwiftKotlinSpec.cpp   |   1 +
 .../c++/HybridTestObjectSwiftKotlinSpec.hpp   |   3 +-
 .../src/specs/TestObject.nitro.ts             |   1 +
 .../NitroModules.podspec                      |   1 +
 .../ios/utils/Result.hpp                      | 193 +++++++
 32 files changed, 1237 insertions(+), 389 deletions(-)
 create mode 100644 packages/nitrogen/src/syntax/types/ResultWrappingType.ts
 create mode 100644 packages/react-native-nitro-modules/ios/utils/Result.hpp

diff --git a/docs/docs/errors.md b/docs/docs/errors.md
index f2d554684..ba5c3cefd 100644
--- a/docs/docs/errors.md
+++ b/docs/docs/errors.md
@@ -113,8 +113,3 @@ try {
   console.log(error)
 }
 ```
-
-## Swift Errors
-
-Due to a Swift compiler bug, Swift Hybrid Objects can currently not throw errors. Instead, they will raise a `fatalError(..)` which can only be seen if the app is running in Xcode (debugger).
-This should be fixed in the next Xcode version.
diff --git a/example/ios/Podfile.lock b/example/ios/Podfile.lock
index 4d9556b45..c73f2e2c5 100644
--- a/example/ios/Podfile.lock
+++ b/example/ios/Podfile.lock
@@ -1895,7 +1895,7 @@ SPEC CHECKSUMS:
   glog: 08b301085f15bcbb6ff8632a8ebaf239aae04e6a
   hermes-engine: 06a9c6900587420b90accc394199527c64259db4
   NitroImage: df6e7bc6d5cc2be5d3c47aec9e88d2af8498da88
-  NitroModules: d5e3886c34fc5c5ebab18327e52f35460c039e2d
+  NitroModules: bc157840c2fbc711c282025d3964b16d857cb9eb
   RCT-Folly: bf5c0376ffe4dd2cf438dcf86db385df9fdce648
   RCTDeprecation: fb7d408617e25d7f537940000d766d60149c5fea
   RCTRequired: 9aaf0ffcc1f41f0c671af863970ef25c422a9920
diff --git a/example/src/getTests.ts b/example/src/getTests.ts
index 9a5822c9c..45da2fb77 100644
--- a/example/src/getTests.ts
+++ b/example/src/getTests.ts
@@ -428,6 +428,13 @@ export function getTests(
         `Error: ${testObject.name}.funcThatThrows(...): This function will only work after sacrificing seven lambs!`
       )
     ),
+    createTest('funcThatThrowsBeforePromise() throws', async () =>
+      (
+        await it(async () => await testObject.funcThatThrowsBeforePromise())
+      ).didThrow(
+        `Error: ${testObject.name}.funcThatThrowsBeforePromise(...): This function will only work after sacrificing eight lambs!`
+      )
+    ),
     createTest('throwError(error) throws same message from JS', () =>
       it(() => {
         const error = new Error('rethrowing a JS error from native!')
diff --git a/packages/nitrogen/src/syntax/createType.ts b/packages/nitrogen/src/syntax/createType.ts
index f4e63a450..967c3a5b8 100644
--- a/packages/nitrogen/src/syntax/createType.ts
+++ b/packages/nitrogen/src/syntax/createType.ts
@@ -154,6 +154,18 @@ function getTypeId(type: TSMorphType, isOptional: boolean): string {
   return key
 }
 
+export function addKnownType(
+  key: string,
+  type: Type,
+  language: Language
+): void {
+  if (knownTypes[language].has(key)) {
+    // type is already known
+    return
+  }
+  knownTypes[language].set(key, type)
+}
+
 /**
  * Create a new type (or return it from cache if it is already known)
  */
diff --git a/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts b/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts
index df2644730..e335d02c3 100644
--- a/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts
+++ b/packages/nitrogen/src/syntax/swift/SwiftCxxBridgedType.ts
@@ -103,6 +103,9 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> {
       case 'map':
         // AnyMapHolder <> AnyMap
         return true
+      case 'result-wrapper':
+        // Result<T> <> T
+        return true
       default:
         return false
     }
@@ -223,6 +226,7 @@ export class SwiftCxxBridgedType implements BridgedType<'swift', 'c++'> {
       case 'variant':
       case 'tuple':
       case 'record':
+      case 'result-wrapper':
       case 'promise': {
         const bridge = this.getBridgeOrThrow()
         switch (language) {
diff --git a/packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts b/packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts
index d28262c13..68e406b2c 100644
--- a/packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts
+++ b/packages/nitrogen/src/syntax/swift/SwiftCxxTypeHelper.ts
@@ -18,6 +18,7 @@ import { getUmbrellaHeaderName } from '../../autolinking/ios/createSwiftUmbrella
 import { VoidType } from '../types/VoidType.js'
 import { NamedWrappingType } from '../types/NamedWrappingType.js'
 import { ErrorType } from '../types/ErrorType.js'
+import { ResultWrappingType } from '../types/ResultWrappingType.js'
 
 export interface SwiftCxxHelper {
   cxxHeader: {
@@ -52,6 +53,10 @@ export function createSwiftCxxHelpers(type: Type): SwiftCxxHelper | undefined {
       return createCxxTupleSwiftHelper(getTypeAs(type, TupleType))
     case 'promise':
       return createCxxPromiseSwiftHelper(getTypeAs(type, PromiseType))
+    case 'result-wrapper':
+      return createCxxResultWrapperSwiftHelper(
+        getTypeAs(type, ResultWrappingType)
+      )
     default:
       return undefined
   }
@@ -504,6 +509,57 @@ inline ${actualType} create_${name}(${typesSignature}) {
   }
 }
 
+/**
+ * Create a C++ `create_result` function that can be called from Swift to create a `Result<T>`.
+ */
+function createCxxResultWrapperSwiftHelper(
+  type: ResultWrappingType
+): SwiftCxxHelper {
+  const actualType = type.getCode('c++')
+  const name = escapeCppName(type.getCode('c++'))
+  const funcName = `create_${name}`
+
+  const functions: string[] = []
+  if (type.result.kind === 'void') {
+    functions.push(
+      `
+inline ${name} ${funcName}() {
+  return ${actualType}::withValue();
+}`.trim()
+    )
+  } else {
+    const typeParam = type.result.canBePassedByReference
+      ? `const ${type.result.getCode('c++')}&`
+      : type.result.getCode('c++')
+    functions.push(
+      `
+inline ${name} ${funcName}(${typeParam} value) {
+  return ${actualType}::withValue(${type.result.canBePassedByReference ? 'value' : 'std::move(value)'});
+}`.trim()
+    )
+  }
+  functions.push(
+    `
+inline ${name} ${funcName}(const ${type.error.getCode('c++')}& error) {
+  return ${actualType}::withError(error);
+}`.trim()
+  )
+
+  return {
+    cxxType: actualType,
+    specializationName: name,
+    funcName: funcName,
+    cxxHeader: {
+      code: `
+using ${name} = ${actualType};
+${functions.join('\n')}
+      `.trim(),
+      requiredIncludes: type.getRequiredImports(),
+    },
+    dependencies: [],
+  }
+}
+
 /**
  * Creates a C++ `create_promise_T()` function that can be called from Swift to create a `std::shared_ptr<Promise<T>>`.
  */
diff --git a/packages/nitrogen/src/syntax/swift/SwiftHybridObjectBridge.ts b/packages/nitrogen/src/syntax/swift/SwiftHybridObjectBridge.ts
index 2e6380d04..51caaa07d 100644
--- a/packages/nitrogen/src/syntax/swift/SwiftHybridObjectBridge.ts
+++ b/packages/nitrogen/src/syntax/swift/SwiftHybridObjectBridge.ts
@@ -15,6 +15,8 @@ import { NitroConfig } from '../../config/NitroConfig.js'
 import { includeHeader } from '../c++/includeNitroHeader.js'
 import { getUmbrellaHeaderName } from '../../autolinking/ios/createSwiftUmbrellaHeader.js'
 import { HybridObjectType } from '../types/HybridObjectType.js'
+import { addKnownType } from '../createType.js'
+import { ResultWrappingType } from '../types/ResultWrappingType.js'
 
 export function getBridgeNamespace() {
   return NitroConfig.getCxxNamespace('swift', 'bridge', 'swift')
@@ -231,19 +233,26 @@ return ${bridged.parseFromSwiftToCpp('__result', 'c++')};
           }
         })
         .join(', ')
-      const bridgedReturnType = new SwiftCxxBridgedType(m.returnType)
+      const bridgedReturnType = new SwiftCxxBridgedType(m.returnType, true)
       const hasResult = m.returnType.kind !== 'void'
       let body: string
       if (hasResult) {
         // func returns something
         body = `
 auto __result = _swiftPart.${m.name}(${params});
-return ${bridgedReturnType.parseFromSwiftToCpp('__result', 'c++')};
+if (__result.hasError()) [[unlikely]] {
+  std::rethrow_exception(__result.error());
+}
+auto __value = std::move(__result.value());
+return ${bridgedReturnType.parseFromSwiftToCpp('__value', 'c++')};
         `.trim()
       } else {
         // void func
         body = `
-_swiftPart.${m.name}(${params});
+auto __result = _swiftPart.${m.name}(${params});
+if (__result.hasError()) [[unlikely]] {
+  std::rethrow_exception(__result.error());
+}
         `.trim()
       }
 
@@ -419,7 +428,18 @@ public var ${property.name}: ${bridgedType.getTypeCode('swift')} {
 }
 
 function getMethodForwardImplementation(method: Method): string {
-  const returnType = new SwiftCxxBridgedType(method.returnType)
+  // wrapped return in a std::expected
+  const resultType = new ResultWrappingType(method.returnType)
+  addKnownType(`expected_${resultType.getCode('c++')}`, resultType, 'swift')
+  const bridgedResultType = new SwiftCxxBridgedType(resultType, true)
+  const resultBridge = bridgedResultType.getRequiredBridge()
+  if (resultBridge == null)
+    throw new Error(
+      `Result type (${bridgedResultType.getTypeCode('c++')}) does not have a bridge!`
+    )
+  const bridgedErrorType = new SwiftCxxBridgedType(resultType.error, true)
+
+  const returnType = new SwiftCxxBridgedType(method.returnType, true)
   const params = method.parameters.map((p) => {
     const bridgedType = new SwiftCxxBridgedType(p.type)
     return `${p.name}: ${bridgedType.getTypeCode('swift')}`
@@ -428,19 +448,28 @@ function getMethodForwardImplementation(method: Method): string {
     const bridgedType = new SwiftCxxBridgedType(p.type)
     return `${p.name}: ${bridgedType.parseFromCppToSwift(p.name, 'swift')}`
   })
-  const resultValue = returnType.hasType ? `let __result = ` : ''
-  const returnValue = returnType.hasType
-    ? `${returnType.parseFromSwiftToCpp('__result', 'swift')}`
-    : ''
+  let body: string
+  if (returnType.hasType) {
+    body = `
+let __result = try self.__implementation.${method.name}(${passParams.join(', ')})
+let __resultCpp = ${returnType.parseFromSwiftToCpp('__result', 'swift')}
+return bridge.${resultBridge.funcName}(__resultCpp)
+`.trim()
+  } else {
+    body = `
+try self.__implementation.${method.name}(${passParams.join(', ')})
+return bridge.${resultBridge.funcName}()
+`.trim()
+  }
+
   return `
 @inline(__always)
-public func ${method.name}(${params.join(', ')}) -> ${returnType.getTypeCode('swift')} {
+public func ${method.name}(${params.join(', ')}) -> ${bridgedResultType.getTypeCode('swift')} {
   do {
-    ${resultValue}try self.__implementation.${method.name}(${indent(passParams.join(', '), '    ')})
-    return ${indent(returnValue, '    ')}
-  } catch {
-    let __message = "\\(error.localizedDescription)"
-    fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \\(__message))")
+    ${indent(body, '    ')}
+  } catch (let __error) {
+    let __exceptionPtr = ${indent(bridgedErrorType.parseFromSwiftToCpp('__error', 'swift'), '    ')}
+    return bridge.${resultBridge.funcName}(__exceptionPtr)
   }
 }
   `.trim()
diff --git a/packages/nitrogen/src/syntax/types/ResultWrappingType.ts b/packages/nitrogen/src/syntax/types/ResultWrappingType.ts
new file mode 100644
index 000000000..33fabe720
--- /dev/null
+++ b/packages/nitrogen/src/syntax/types/ResultWrappingType.ts
@@ -0,0 +1,49 @@
+import type { Language } from '../../getPlatformSpecs.js'
+import { type SourceFile, type SourceImport } from '../SourceFile.js'
+import { ErrorType } from './ErrorType.js'
+import type { Type, TypeKind } from './Type.js'
+
+export class ResultWrappingType implements Type {
+  readonly result: Type
+  readonly error: Type
+
+  constructor(result: Type) {
+    this.result = result
+    this.error = new ErrorType()
+  }
+
+  get canBePassedByReference(): boolean {
+    return this.result.canBePassedByReference
+  }
+
+  get kind(): TypeKind {
+    return 'result-wrapper'
+  }
+
+  getCode(language: Language): string {
+    switch (language) {
+      case 'c++':
+        return `Result<${this.result.getCode(language)}>`
+      case 'swift':
+        return this.result.getCode(language)
+      default:
+        throw new Error(
+          `Language ${language} is not yet supported for VariantType!`
+        )
+    }
+  }
+  getExtraFiles(): SourceFile[] {
+    return [...this.result.getExtraFiles(), ...this.error.getExtraFiles()]
+  }
+  getRequiredImports(): SourceImport[] {
+    return [
+      {
+        language: 'c++',
+        name: 'NitroModules/Result.hpp',
+        space: 'system',
+      },
+      ...this.result.getRequiredImports(),
+      ...this.error.getRequiredImports(),
+    ]
+  }
+}
diff --git a/packages/nitrogen/src/syntax/types/Type.ts b/packages/nitrogen/src/syntax/types/Type.ts
index 818f016e7..17a5fb70a 100644
--- a/packages/nitrogen/src/syntax/types/Type.ts
+++ b/packages/nitrogen/src/syntax/types/Type.ts
@@ -21,6 +21,7 @@ export type TypeKind =
   | 'struct'
   | 'tuple'
   | 'variant'
+  | 'result-wrapper'
   | 'void'
 
 /**
diff --git a/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt b/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt
index 20eac13a5..50bb43feb 100644
--- a/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt
+++ b/packages/react-native-nitro-image/android/src/main/java/com/margelo/nitro/image/HybridTestObjectKotlin.kt
@@ -93,6 +93,10 @@ class HybridTestObjectKotlin: HybridTestObjectSwiftKotlinSpec() {
         throw Error("This function will only work after sacrificing seven lambs!")
     }
 
+    override fun funcThatThrowsBeforePromise(): Promise<Unit> {
+        throw Error("This function will only work after sacrificing eight lambs!")
+    }
+
     override fun throwError(error: Throwable): Unit {
         throw error
     }
diff --git a/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.cpp b/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.cpp
index 2c946cbd4..6c0752a60 100644
--- a/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.cpp
+++ b/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.cpp
@@ -190,6 +190,10 @@ double HybridTestObjectCpp::funcThatThrows() {
   throw std::runtime_error("This function will only work after sacrificing seven lambs!");
 }
 
+std::shared_ptr<Promise<void>> HybridTestObjectCpp::funcThatThrowsBeforePromise() {
+  throw std::runtime_error("This function will only work after sacrificing eight lambs!");
+}
+
 void HybridTestObjectCpp::throwError(const std::exception_ptr& error) {
   std::rethrow_exception(error);
 }
diff --git a/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.hpp b/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.hpp
index 387cc48c2..0f78b5380 100644
--- a/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.hpp
+++ b/packages/react-native-nitro-image/cpp/HybridTestObjectCpp.hpp
@@ -80,6 +80,7 @@ class HybridTestObjectCpp : public HybridTestObjectCppSpec {
   std::shared_ptr<AnyMap> createMap() override;
   std::shared_ptr<AnyMap> mapRoundtrip(const std::shared_ptr<AnyMap>& map) override;
   double funcThatThrows() override;
+  std::shared_ptr<Promise<void>> funcThatThrowsBeforePromise() override;
   void throwError(const std::exception_ptr& error) override;
   std::string tryOptionalParams(double num, bool boo, const std::optional<std::string>& str) override;
   std::string tryMiddleParam(double num, std::optional<bool> boo, const std::string& str) override;
diff --git a/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift b/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift
index c741f668c..cb167e94c 100644
--- a/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift
+++ b/packages/react-native-nitro-image/ios/HybridTestObjectSwift.swift
@@ -56,14 +56,14 @@ class HybridTestObjectSwift : HybridTestObjectSwiftKotlinSpec {
   func callWithOptional(value: Double?, callback: @escaping ((_ maybe: Double?) -> Void)) throws -> Void {
     callback(value)
   }
-  
+
   func getValueFromJSCallbackAndWait(getValue: @escaping (() -> Promise<Double>)) throws -> Promise<Double> {
     return .async {
       let jsResult = try await getValue().await()
       return jsResult
     }
   }
-  
+
   func getValueFromJsCallback(callback: @escaping (() -> Promise<String>), andThenCall: @escaping ((_ valueFromJs: String) -> Void)) throws -> Promise<Void> {
     return .async {
       let jsResult = try await callback().await()
@@ -125,14 +125,15 @@ class HybridTestObjectSwift : HybridTestObjectSwiftKotlinSpec {
   }
 
   func funcThatThrows() throws -> Double {
-    // TODO: Swift functions can not throw yet! Errors are not propagated up to C++.
-    // throw RuntimeError.error(withMessage: "This function will only work after sacrificing seven lambs!")
-    return 55
+    throw RuntimeError.error(withMessage: "This function will only work after sacrificing seven lambs!")
+  }
+
+  func funcThatThrowsBeforePromise() throws -> Promise<Void> {
+    throw RuntimeError.error(withMessage: "This function will only work after sacrificing eight lambs!")
   }
 
   func throwError(error: Error) throws -> Void {
-    // TODO: Swift functions can not throw yet! Errors are not propagated up to C++.
-    // throw error
+    throw error
   }
 
   func tryOptionalParams(num: Double, boo: Bool, str: String?) throws -> String {
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
index d4fa2eee0..086cb79c4 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.cpp
@@ -344,6 +344,21 @@ namespace margelo::nitro::image {
     auto __result = method(_javaPart);
     return __result;
   }
+  std::shared_ptr<Promise<void>> JHybridTestObjectSwiftKotlinSpec::funcThatThrowsBeforePromise() {
+    static const auto method = _javaPart->getClass()->getMethod<jni::local_ref<JPromise::javaobject>()>("funcThatThrowsBeforePromise");
+    auto __result = method(_javaPart);
+    return [&]() {
+      auto __promise = Promise<void>::create();
+      __result->cthis()->addOnResolvedListener([=](const jni::alias_ref<jni::JObject>& __boxedResult) {
+        __promise->resolve();
+      });
+      __result->cthis()->addOnRejectedListener([=](const jni::alias_ref<jni::JThrowable>& __throwable) {
+        jni::JniException __jniError(__throwable);
+        __promise->reject(std::make_exception_ptr(__jniError));
+      });
+      return __promise;
+    }();
+  }
   void JHybridTestObjectSwiftKotlinSpec::throwError(const std::exception_ptr& error) {
     static const auto method = _javaPart->getClass()->getMethod<void(jni::alias_ref<jni::JThrowable> /* error */)>("throwError");
     method(_javaPart, jni::getJavaExceptionForCppException(error));
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
index 1594402b9..990a405d4 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/c++/JHybridTestObjectSwiftKotlinSpec.hpp
@@ -88,6 +88,7 @@ namespace margelo::nitro::image {
     std::shared_ptr<AnyMap> createMap() override;
     std::shared_ptr<AnyMap> mapRoundtrip(const std::shared_ptr<AnyMap>& map) override;
     double funcThatThrows() override;
+    std::shared_ptr<Promise<void>> funcThatThrowsBeforePromise() override;
     void throwError(const std::exception_ptr& error) override;
     std::string tryOptionalParams(double num, bool boo, const std::optional<std::string>& str) override;
     std::string tryMiddleParam(double num, std::optional<bool> boo, const std::string& str) override;
diff --git a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt
index 2c87b8934..b810d0032 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt
+++ b/packages/react-native-nitro-image/nitrogen/generated/android/kotlin/com/margelo/nitro/image/HybridTestObjectSwiftKotlinSpec.kt
@@ -174,6 +174,10 @@ abstract class HybridTestObjectSwiftKotlinSpec: HybridObject() {
   @Keep
   abstract fun funcThatThrows(): Double
   
+  @DoNotStrip
+  @Keep
+  abstract fun funcThatThrowsBeforePromise(): Promise<Unit>
+  
   @DoNotStrip
   @Keep
   abstract fun throwError(error: Throwable): Unit
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp
index b4af390cf..b73a81870 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Bridge.hpp
@@ -8,6 +8,8 @@
 #pragma once
 
 // Forward declarations of C++ defined types
+// Forward declaration of `AnyMap` to properly resolve imports.
+namespace NitroModules { class AnyMap; }
 // Forward declaration of `ArrayBufferHolder` to properly resolve imports.
 namespace NitroModules { class ArrayBufferHolder; }
 // Forward declaration of `ArrayBuffer` to properly resolve imports.
@@ -53,9 +55,11 @@ namespace NitroImage { class HybridTestObjectSwiftKotlinSpec_cxx; }
 #include "OldEnum.hpp"
 #include "Person.hpp"
 #include "Powertrain.hpp"
+#include <NitroModules/AnyMap.hpp>
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/ArrayBufferHolder.hpp>
 #include <NitroModules/Promise.hpp>
+#include <NitroModules/Result.hpp>
 #include <exception>
 #include <functional>
 #include <memory>
@@ -110,6 +114,24 @@ namespace margelo::nitro::image::bridge::swift {
   using std__weak_ptr_margelo__nitro__image__HybridImageSpec_ = std::weak_ptr<margelo::nitro::image::HybridImageSpec>;
   inline std__weak_ptr_margelo__nitro__image__HybridImageSpec_ weakify_std__shared_ptr_margelo__nitro__image__HybridImageSpec_(const std::shared_ptr<margelo::nitro::image::HybridImageSpec>& strong) { return strong; }
   
+  // pragma MARK: Result<double>
+  using Result_double_ = Result<double>;
+  inline Result_double_ create_Result_double_(double value) {
+    return Result<double>::withValue(std::move(value));
+  }
+  inline Result_double_ create_Result_double_(const std::exception_ptr& error) {
+    return Result<double>::withError(error);
+  }
+  
+  // pragma MARK: Result<void>
+  using Result_void_ = Result<void>;
+  inline Result_void_ create_Result_void_() {
+    return Result<void>::withValue();
+  }
+  inline Result_void_ create_Result_void_(const std::exception_ptr& error) {
+    return Result<void>::withError(error);
+  }
+  
   // pragma MARK: std::shared_ptr<margelo::nitro::image::HybridImageFactorySpec>
   /**
    * Specialized version of `std::shared_ptr<margelo::nitro::image::HybridImageFactorySpec>`.
@@ -122,6 +144,15 @@ namespace margelo::nitro::image::bridge::swift {
   using std__weak_ptr_margelo__nitro__image__HybridImageFactorySpec_ = std::weak_ptr<margelo::nitro::image::HybridImageFactorySpec>;
   inline std__weak_ptr_margelo__nitro__image__HybridImageFactorySpec_ weakify_std__shared_ptr_margelo__nitro__image__HybridImageFactorySpec_(const std::shared_ptr<margelo::nitro::image::HybridImageFactorySpec>& strong) { return strong; }
   
+  // pragma MARK: Result<std::shared_ptr<margelo::nitro::image::HybridImageSpec>>
+  using Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ = Result<std::shared_ptr<margelo::nitro::image::HybridImageSpec>>;
+  inline Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(const std::shared_ptr<margelo::nitro::image::HybridImageSpec>& value) {
+    return Result<std::shared_ptr<margelo::nitro::image::HybridImageSpec>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<margelo::nitro::image::HybridImageSpec>>::withError(error);
+  }
+  
   // pragma MARK: std::shared_ptr<margelo::nitro::image::HybridTestObjectSwiftKotlinSpec>
   /**
    * Specialized version of `std::shared_ptr<margelo::nitro::image::HybridTestObjectSwiftKotlinSpec>`.
@@ -251,6 +282,71 @@ namespace margelo::nitro::image::bridge::swift {
     return std::make_shared<Func_void_std__vector_Powertrain__Wrapper>(value);
   }
   
+  // pragma MARK: std::shared_ptr<Promise<void>>
+  /**
+   * Specialized version of `std::shared_ptr<Promise<void>>`.
+   */
+  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
+  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() {
+    return Promise<void>::create();
+  }
+  
+  // pragma MARK: std::function<void()>
+  /**
+   * Specialized version of `std::function<void()>`.
+   */
+  using Func_void = std::function<void()>;
+  /**
+   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
+   */
+  class Func_void_Wrapper final {
+  public:
+    explicit Func_void_Wrapper(const std::function<void()>& func): _function(func) {}
+    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::move(func)) {}
+    inline void call() const {
+      _function();
+    }
+  private:
+    std::function<void()> _function;
+  };
+  inline Func_void create_Func_void(void* _Nonnull closureHolder, void(* _Nonnull call)(void* _Nonnull /* closureHolder */), void(* _Nonnull destroy)(void* _Nonnull)) {
+    std::shared_ptr<void> sharedClosureHolder(closureHolder, destroy);
+    return Func_void([sharedClosureHolder, call]() -> void {
+      call(sharedClosureHolder.get());
+    });
+  }
+  inline std::shared_ptr<Func_void_Wrapper> share_Func_void(const Func_void& value) {
+    return std::make_shared<Func_void_Wrapper>(value);
+  }
+  
+  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
+  /**
+   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
+   */
+  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
+  /**
+   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
+   */
+  class Func_void_std__exception_ptr_Wrapper final {
+  public:
+    explicit Func_void_std__exception_ptr_Wrapper(const std::function<void(const std::exception_ptr& /* error */)>& func): _function(func) {}
+    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::move(func)) {}
+    inline void call(std::exception_ptr error) const {
+      _function(error);
+    }
+  private:
+    std::function<void(const std::exception_ptr& /* error */)> _function;
+  };
+  inline Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull closureHolder, void(* _Nonnull call)(void* _Nonnull /* closureHolder */, std::exception_ptr), void(* _Nonnull destroy)(void* _Nonnull)) {
+    std::shared_ptr<void> sharedClosureHolder(closureHolder, destroy);
+    return Func_void_std__exception_ptr([sharedClosureHolder, call](const std::exception_ptr& error) -> void {
+      call(sharedClosureHolder.get(), error);
+    });
+  }
+  inline std::shared_ptr<Func_void_std__exception_ptr_Wrapper> share_Func_void_std__exception_ptr(const Func_void_std__exception_ptr& value) {
+    return std::make_shared<Func_void_std__exception_ptr_Wrapper>(value);
+  }
+  
   // pragma MARK: std::optional<bool>
   /**
    * Specialized version of `std::optional<bool>`.
@@ -326,71 +422,6 @@ namespace margelo::nitro::image::bridge::swift {
     return std::make_shared<Func_void_int64_t_Wrapper>(value);
   }
   
-  // pragma MARK: std::function<void(const std::exception_ptr& /* error */)>
-  /**
-   * Specialized version of `std::function<void(const std::exception_ptr&)>`.
-   */
-  using Func_void_std__exception_ptr = std::function<void(const std::exception_ptr& /* error */)>;
-  /**
-   * Wrapper class for a `std::function<void(const std::exception_ptr& / * error * /)>`, this can be used from Swift.
-   */
-  class Func_void_std__exception_ptr_Wrapper final {
-  public:
-    explicit Func_void_std__exception_ptr_Wrapper(const std::function<void(const std::exception_ptr& /* error */)>& func): _function(func) {}
-    explicit Func_void_std__exception_ptr_Wrapper(std::function<void(const std::exception_ptr& /* error */)>&& func): _function(std::move(func)) {}
-    inline void call(std::exception_ptr error) const {
-      _function(error);
-    }
-  private:
-    std::function<void(const std::exception_ptr& /* error */)> _function;
-  };
-  inline Func_void_std__exception_ptr create_Func_void_std__exception_ptr(void* _Nonnull closureHolder, void(* _Nonnull call)(void* _Nonnull /* closureHolder */, std::exception_ptr), void(* _Nonnull destroy)(void* _Nonnull)) {
-    std::shared_ptr<void> sharedClosureHolder(closureHolder, destroy);
-    return Func_void_std__exception_ptr([sharedClosureHolder, call](const std::exception_ptr& error) -> void {
-      call(sharedClosureHolder.get(), error);
-    });
-  }
-  inline std::shared_ptr<Func_void_std__exception_ptr_Wrapper> share_Func_void_std__exception_ptr(const Func_void_std__exception_ptr& value) {
-    return std::make_shared<Func_void_std__exception_ptr_Wrapper>(value);
-  }
-  
-  // pragma MARK: std::shared_ptr<Promise<void>>
-  /**
-   * Specialized version of `std::shared_ptr<Promise<void>>`.
-   */
-  using std__shared_ptr_Promise_void__ = std::shared_ptr<Promise<void>>;
-  inline std::shared_ptr<Promise<void>> create_std__shared_ptr_Promise_void__() {
-    return Promise<void>::create();
-  }
-  
-  // pragma MARK: std::function<void()>
-  /**
-   * Specialized version of `std::function<void()>`.
-   */
-  using Func_void = std::function<void()>;
-  /**
-   * Wrapper class for a `std::function<void()>`, this can be used from Swift.
-   */
-  class Func_void_Wrapper final {
-  public:
-    explicit Func_void_Wrapper(const std::function<void()>& func): _function(func) {}
-    explicit Func_void_Wrapper(std::function<void()>&& func): _function(std::move(func)) {}
-    inline void call() const {
-      _function();
-    }
-  private:
-    std::function<void()> _function;
-  };
-  inline Func_void create_Func_void(void* _Nonnull closureHolder, void(* _Nonnull call)(void* _Nonnull /* closureHolder */), void(* _Nonnull destroy)(void* _Nonnull)) {
-    std::shared_ptr<void> sharedClosureHolder(closureHolder, destroy);
-    return Func_void([sharedClosureHolder, call]() -> void {
-      call(sharedClosureHolder.get());
-    });
-  }
-  inline std::shared_ptr<Func_void_Wrapper> share_Func_void(const Func_void& value) {
-    return std::make_shared<Func_void_Wrapper>(value);
-  }
-  
   // pragma MARK: std::shared_ptr<Promise<double>>
   /**
    * Specialized version of `std::shared_ptr<Promise<double>>`.
@@ -643,5 +674,185 @@ namespace margelo::nitro::image::bridge::swift {
   // pragma MARK: std::weak_ptr<margelo::nitro::image::HybridChildSpec>
   using std__weak_ptr_margelo__nitro__image__HybridChildSpec_ = std::weak_ptr<margelo::nitro::image::HybridChildSpec>;
   inline std__weak_ptr_margelo__nitro__image__HybridChildSpec_ weakify_std__shared_ptr_margelo__nitro__image__HybridChildSpec_(const std::shared_ptr<margelo::nitro::image::HybridChildSpec>& strong) { return strong; }
+  
+  // pragma MARK: Result<std::shared_ptr<margelo::nitro::image::HybridTestObjectSwiftKotlinSpec>>
+  using Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__ = Result<std::shared_ptr<margelo::nitro::image::HybridTestObjectSwiftKotlinSpec>>;
+  inline Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__(const std::shared_ptr<margelo::nitro::image::HybridTestObjectSwiftKotlinSpec>& value) {
+    return Result<std::shared_ptr<margelo::nitro::image::HybridTestObjectSwiftKotlinSpec>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<margelo::nitro::image::HybridTestObjectSwiftKotlinSpec>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::string>
+  using Result_std__string_ = Result<std::string>;
+  inline Result_std__string_ create_Result_std__string_(const std::string& value) {
+    return Result<std::string>::withValue(value);
+  }
+  inline Result_std__string_ create_Result_std__string_(const std::exception_ptr& error) {
+    return Result<std::string>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::vector<std::string>>
+  using Result_std__vector_std__string__ = Result<std::vector<std::string>>;
+  inline Result_std__vector_std__string__ create_Result_std__vector_std__string__(const std::vector<std::string>& value) {
+    return Result<std::vector<std::string>>::withValue(value);
+  }
+  inline Result_std__vector_std__string__ create_Result_std__vector_std__string__(const std::exception_ptr& error) {
+    return Result<std::vector<std::string>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::vector<double>>
+  using Result_std__vector_double__ = Result<std::vector<double>>;
+  inline Result_std__vector_double__ create_Result_std__vector_double__(const std::vector<double>& value) {
+    return Result<std::vector<double>>::withValue(value);
+  }
+  inline Result_std__vector_double__ create_Result_std__vector_double__(const std::exception_ptr& error) {
+    return Result<std::vector<double>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::vector<Person>>
+  using Result_std__vector_Person__ = Result<std::vector<Person>>;
+  inline Result_std__vector_Person__ create_Result_std__vector_Person__(const std::vector<Person>& value) {
+    return Result<std::vector<Person>>::withValue(value);
+  }
+  inline Result_std__vector_Person__ create_Result_std__vector_Person__(const std::exception_ptr& error) {
+    return Result<std::vector<Person>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::vector<Powertrain>>
+  using Result_std__vector_Powertrain__ = Result<std::vector<Powertrain>>;
+  inline Result_std__vector_Powertrain__ create_Result_std__vector_Powertrain__(const std::vector<Powertrain>& value) {
+    return Result<std::vector<Powertrain>>::withValue(value);
+  }
+  inline Result_std__vector_Powertrain__ create_Result_std__vector_Powertrain__(const std::exception_ptr& error) {
+    return Result<std::vector<Powertrain>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<AnyMap>>
+  using Result_std__shared_ptr_AnyMap__ = Result<std::shared_ptr<AnyMap>>;
+  inline Result_std__shared_ptr_AnyMap__ create_Result_std__shared_ptr_AnyMap__(const std::shared_ptr<AnyMap>& value) {
+    return Result<std::shared_ptr<AnyMap>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_AnyMap__ create_Result_std__shared_ptr_AnyMap__(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<AnyMap>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<void>>>
+  using Result_std__shared_ptr_Promise_void___ = Result<std::shared_ptr<Promise<void>>>;
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::shared_ptr<Promise<void>>& value) {
+    return Result<std::shared_ptr<Promise<void>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_void___ create_Result_std__shared_ptr_Promise_void___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<void>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<Powertrain>>
+  using Result_std__optional_Powertrain__ = Result<std::optional<Powertrain>>;
+  inline Result_std__optional_Powertrain__ create_Result_std__optional_Powertrain__(std::optional<Powertrain> value) {
+    return Result<std::optional<Powertrain>>::withValue(std::move(value));
+  }
+  inline Result_std__optional_Powertrain__ create_Result_std__optional_Powertrain__(const std::exception_ptr& error) {
+    return Result<std::optional<Powertrain>>::withError(error);
+  }
+  
+  // pragma MARK: Result<int64_t>
+  using Result_int64_t_ = Result<int64_t>;
+  inline Result_int64_t_ create_Result_int64_t_(int64_t value) {
+    return Result<int64_t>::withValue(std::move(value));
+  }
+  inline Result_int64_t_ create_Result_int64_t_(const std::exception_ptr& error) {
+    return Result<int64_t>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<int64_t>>>
+  using Result_std__shared_ptr_Promise_int64_t___ = Result<std::shared_ptr<Promise<int64_t>>>;
+  inline Result_std__shared_ptr_Promise_int64_t___ create_Result_std__shared_ptr_Promise_int64_t___(const std::shared_ptr<Promise<int64_t>>& value) {
+    return Result<std::shared_ptr<Promise<int64_t>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_int64_t___ create_Result_std__shared_ptr_Promise_int64_t___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<int64_t>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<double>>>
+  using Result_std__shared_ptr_Promise_double___ = Result<std::shared_ptr<Promise<double>>>;
+  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::shared_ptr<Promise<double>>& value) {
+    return Result<std::shared_ptr<Promise<double>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_double___ create_Result_std__shared_ptr_Promise_double___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<double>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<Car>>>
+  using Result_std__shared_ptr_Promise_Car___ = Result<std::shared_ptr<Promise<Car>>>;
+  inline Result_std__shared_ptr_Promise_Car___ create_Result_std__shared_ptr_Promise_Car___(const std::shared_ptr<Promise<Car>>& value) {
+    return Result<std::shared_ptr<Promise<Car>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_Car___ create_Result_std__shared_ptr_Promise_Car___(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<Car>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<Car>
+  using Result_Car_ = Result<Car>;
+  inline Result_Car_ create_Result_Car_(const Car& value) {
+    return Result<Car>::withValue(value);
+  }
+  inline Result_Car_ create_Result_Car_(const std::exception_ptr& error) {
+    return Result<Car>::withError(error);
+  }
+  
+  // pragma MARK: Result<bool>
+  using Result_bool_ = Result<bool>;
+  inline Result_bool_ create_Result_bool_(bool value) {
+    return Result<bool>::withValue(std::move(value));
+  }
+  inline Result_bool_ create_Result_bool_(const std::exception_ptr& error) {
+    return Result<bool>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::optional<Person>>
+  using Result_std__optional_Person__ = Result<std::optional<Person>>;
+  inline Result_std__optional_Person__ create_Result_std__optional_Person__(const std::optional<Person>& value) {
+    return Result<std::optional<Person>>::withValue(value);
+  }
+  inline Result_std__optional_Person__ create_Result_std__optional_Person__(const std::exception_ptr& error) {
+    return Result<std::optional<Person>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<ArrayBuffer>>
+  using Result_std__shared_ptr_ArrayBuffer__ = Result<std::shared_ptr<ArrayBuffer>>;
+  inline Result_std__shared_ptr_ArrayBuffer__ create_Result_std__shared_ptr_ArrayBuffer__(const std::shared_ptr<ArrayBuffer>& value) {
+    return Result<std::shared_ptr<ArrayBuffer>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_ArrayBuffer__ create_Result_std__shared_ptr_ArrayBuffer__(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<ArrayBuffer>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>
+  using Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ = Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>;
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(const std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>& value) {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<margelo::nitro::image::HybridChildSpec>>
+  using Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__ = Result<std::shared_ptr<margelo::nitro::image::HybridChildSpec>>;
+  inline Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(const std::shared_ptr<margelo::nitro::image::HybridChildSpec>& value) {
+    return Result<std::shared_ptr<margelo::nitro::image::HybridChildSpec>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<margelo::nitro::image::HybridChildSpec>>::withError(error);
+  }
+  
+  // pragma MARK: Result<std::shared_ptr<margelo::nitro::image::HybridBaseSpec>>
+  using Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ = Result<std::shared_ptr<margelo::nitro::image::HybridBaseSpec>>;
+  inline Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(const std::shared_ptr<margelo::nitro::image::HybridBaseSpec>& value) {
+    return Result<std::shared_ptr<margelo::nitro::image::HybridBaseSpec>>::withValue(value);
+  }
+  inline Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(const std::exception_ptr& error) {
+    return Result<std::shared_ptr<margelo::nitro::image::HybridBaseSpec>>::withError(error);
+  }
 
 } // namespace margelo::nitro::image::bridge::swift
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Umbrella.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Umbrella.hpp
index be7d243d5..693b60e3a 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Umbrella.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/NitroImage-Swift-Cxx-Umbrella.hpp
@@ -53,6 +53,7 @@ namespace margelo::nitro::image { enum class Powertrain; }
 #include <NitroModules/AnyMap.hpp>
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/Promise.hpp>
+#include <NitroModules/Result.hpp>
 #include <exception>
 #include <functional>
 #include <memory>
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageFactorySpecSwift.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageFactorySpecSwift.hpp
index a550d3efc..25eb95c0b 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageFactorySpecSwift.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageFactorySpecSwift.hpp
@@ -58,19 +58,35 @@ namespace margelo::nitro::image {
     // Methods
     inline std::shared_ptr<margelo::nitro::image::HybridImageSpec> loadImageFromFile(const std::string& path) override {
       auto __result = _swiftPart.loadImageFromFile(path);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<margelo::nitro::image::HybridImageSpec> loadImageFromURL(const std::string& path) override {
       auto __result = _swiftPart.loadImageFromURL(path);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<margelo::nitro::image::HybridImageSpec> loadImageFromSystemName(const std::string& path) override {
       auto __result = _swiftPart.loadImageFromSystemName(path);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<margelo::nitro::image::HybridImageSpec> bounceBack(const std::shared_ptr<margelo::nitro::image::HybridImageSpec>& image) override {
       auto __result = _swiftPart.bounceBack(image);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
 
   private:
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageSpecSwift.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageSpecSwift.hpp
index 5e5600cd9..d414a6daf 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageSpecSwift.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridImageSpecSwift.hpp
@@ -77,10 +77,17 @@ namespace margelo::nitro::image {
     // Methods
     inline double toArrayBuffer(ImageFormat format) override {
       auto __result = _swiftPart.toArrayBuffer(static_cast<int>(format));
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline void saveToFile(const std::string& path, const std::function<void(const std::string& /* path */)>& onFinished) override {
-      _swiftPart.saveToFile(path, onFinished);
+      auto __result = _swiftPart.saveToFile(path, onFinished);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
     }
 
   private:
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp
index 460fd40a2..1f9c171c6 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/c++/HybridTestObjectSwiftKotlinSpecSwift.hpp
@@ -44,8 +44,8 @@ namespace margelo::nitro::image { class HybridBaseSpec; }
 #include "Person.hpp"
 #include <functional>
 #include <NitroModules/AnyMap.hpp>
-#include <exception>
 #include <NitroModules/Promise.hpp>
+#include <exception>
 #include "Car.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include <NitroModules/ArrayBufferHolder.hpp>
@@ -175,167 +175,339 @@ namespace margelo::nitro::image {
     // Methods
     inline std::shared_ptr<margelo::nitro::image::HybridTestObjectSwiftKotlinSpec> newTestObject() override {
       auto __result = _swiftPart.newTestObject();
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline void simpleFunc() override {
-      _swiftPart.simpleFunc();
+      auto __result = _swiftPart.simpleFunc();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
     }
     inline double addNumbers(double a, double b) override {
       auto __result = _swiftPart.addNumbers(std::forward<decltype(a)>(a), std::forward<decltype(b)>(b));
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::string addStrings(const std::string& a, const std::string& b) override {
       auto __result = _swiftPart.addStrings(a, b);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline void multipleArguments(double num, const std::string& str, bool boo) override {
-      _swiftPart.multipleArguments(std::forward<decltype(num)>(num), str, std::forward<decltype(boo)>(boo));
+      auto __result = _swiftPart.multipleArguments(std::forward<decltype(num)>(num), str, std::forward<decltype(boo)>(boo));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
     }
     inline std::vector<std::string> bounceStrings(const std::vector<std::string>& array) override {
       auto __result = _swiftPart.bounceStrings(array);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::vector<double> bounceNumbers(const std::vector<double>& array) override {
       auto __result = _swiftPart.bounceNumbers(array);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::vector<Person> bounceStructs(const std::vector<Person>& array) override {
       auto __result = _swiftPart.bounceStructs(array);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::vector<Powertrain> bounceEnums(const std::vector<Powertrain>& array) override {
       auto __result = _swiftPart.bounceEnums(array);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline void complexEnumCallback(const std::vector<Powertrain>& array, const std::function<void(const std::vector<Powertrain>& /* array */)>& callback) override {
-      _swiftPart.complexEnumCallback(array, callback);
+      auto __result = _swiftPart.complexEnumCallback(array, callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
     }
     inline std::shared_ptr<AnyMap> createMap() override {
       auto __result = _swiftPart.createMap();
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<AnyMap> mapRoundtrip(const std::shared_ptr<AnyMap>& map) override {
       auto __result = _swiftPart.mapRoundtrip(map);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline double funcThatThrows() override {
       auto __result = _swiftPart.funcThatThrows();
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
+    }
+    inline std::shared_ptr<Promise<void>> funcThatThrowsBeforePromise() override {
+      auto __result = _swiftPart.funcThatThrowsBeforePromise();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline void throwError(const std::exception_ptr& error) override {
-      _swiftPart.throwError(error);
+      auto __result = _swiftPart.throwError(error);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
     }
     inline std::string tryOptionalParams(double num, bool boo, const std::optional<std::string>& str) override {
       auto __result = _swiftPart.tryOptionalParams(std::forward<decltype(num)>(num), std::forward<decltype(boo)>(boo), str);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::string tryMiddleParam(double num, std::optional<bool> boo, const std::string& str) override {
       auto __result = _swiftPart.tryMiddleParam(std::forward<decltype(num)>(num), boo, str);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::optional<Powertrain> tryOptionalEnum(std::optional<Powertrain> value) override {
       auto __result = _swiftPart.tryOptionalEnum(value);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline int64_t calculateFibonacciSync(double value) override {
       auto __result = _swiftPart.calculateFibonacciSync(std::forward<decltype(value)>(value));
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<Promise<int64_t>> calculateFibonacciAsync(double value) override {
       auto __result = _swiftPart.calculateFibonacciAsync(std::forward<decltype(value)>(value));
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<Promise<void>> wait(double seconds) override {
       auto __result = _swiftPart.wait(std::forward<decltype(seconds)>(seconds));
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<Promise<void>> promiseThrows() override {
       auto __result = _swiftPart.promiseThrows();
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<Promise<double>> awaitAndGetPromise(const std::shared_ptr<Promise<double>>& promise) override {
       auto __result = _swiftPart.awaitAndGetPromise(promise);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<Promise<Car>> awaitAndGetComplexPromise(const std::shared_ptr<Promise<Car>>& promise) override {
       auto __result = _swiftPart.awaitAndGetComplexPromise(promise);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<Promise<void>> awaitPromise(const std::shared_ptr<Promise<void>>& promise) override {
       auto __result = _swiftPart.awaitPromise(promise);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline void callCallback(const std::function<void()>& callback) override {
-      _swiftPart.callCallback(callback);
+      auto __result = _swiftPart.callCallback(callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
     }
     inline void callAll(const std::function<void()>& first, const std::function<void()>& second, const std::function<void()>& third) override {
-      _swiftPart.callAll(first, second, third);
+      auto __result = _swiftPart.callAll(first, second, third);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
     }
     inline void callWithOptional(std::optional<double> value, const std::function<void(std::optional<double> /* maybe */)>& callback) override {
-      _swiftPart.callWithOptional(value, callback);
+      auto __result = _swiftPart.callWithOptional(value, callback);
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
     }
     inline std::shared_ptr<Promise<double>> getValueFromJSCallbackAndWait(const std::function<std::shared_ptr<Promise<double>>()>& getValue) override {
       auto __result = _swiftPart.getValueFromJSCallbackAndWait(getValue);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<Promise<void>> getValueFromJsCallback(const std::function<std::shared_ptr<Promise<std::string>>()>& callback, const std::function<void(const std::string& /* valueFromJs */)>& andThenCall) override {
       auto __result = _swiftPart.getValueFromJsCallback(callback, andThenCall);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline Car getCar() override {
       auto __result = _swiftPart.getCar();
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline bool isCarElectric(const Car& car) override {
       auto __result = _swiftPart.isCarElectric(car);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::optional<Person> getDriver(const Car& car) override {
       auto __result = _swiftPart.getDriver(car);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<ArrayBuffer> createArrayBuffer() override {
       auto __result = _swiftPart.createArrayBuffer();
-      return __result.getArrayBuffer();
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline double getBufferLastItem(const std::shared_ptr<ArrayBuffer>& buffer) override {
       auto __result = _swiftPart.getBufferLastItem(ArrayBufferHolder(buffer));
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline void setAllValuesTo(const std::shared_ptr<ArrayBuffer>& buffer, double value) override {
-      _swiftPart.setAllValuesTo(ArrayBufferHolder(buffer), std::forward<decltype(value)>(value));
+      auto __result = _swiftPart.setAllValuesTo(ArrayBufferHolder(buffer), std::forward<decltype(value)>(value));
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
     }
     inline std::shared_ptr<Promise<std::shared_ptr<ArrayBuffer>>> createArrayBufferAsync() override {
       auto __result = _swiftPart.createArrayBufferAsync();
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<margelo::nitro::image::HybridChildSpec> createChild() override {
       auto __result = _swiftPart.createChild();
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<margelo::nitro::image::HybridBaseSpec> createBase() override {
       auto __result = _swiftPart.createBase();
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<margelo::nitro::image::HybridBaseSpec> createBaseActualChild() override {
       auto __result = _swiftPart.createBaseActualChild();
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<margelo::nitro::image::HybridChildSpec> bounceChild(const std::shared_ptr<margelo::nitro::image::HybridChildSpec>& child) override {
       auto __result = _swiftPart.bounceChild(child);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<margelo::nitro::image::HybridBaseSpec> bounceBase(const std::shared_ptr<margelo::nitro::image::HybridBaseSpec>& base) override {
       auto __result = _swiftPart.bounceBase(base);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<margelo::nitro::image::HybridBaseSpec> bounceChildBase(const std::shared_ptr<margelo::nitro::image::HybridChildSpec>& child) override {
       auto __result = _swiftPart.bounceChildBase(child);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
     inline std::shared_ptr<margelo::nitro::image::HybridChildSpec> castBase(const std::shared_ptr<margelo::nitro::image::HybridBaseSpec>& base) override {
       auto __result = _swiftPart.castBase(base);
-      return __result;
+      if (__result.hasError()) [[unlikely]] {
+        std::rethrow_exception(__result.error());
+      }
+      auto __value = std::move(__result.value());
+      return __value;
     }
 
   private:
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageFactorySpec_cxx.swift b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageFactorySpec_cxx.swift
index 88d081ad9..aa8b997b7 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageFactorySpec_cxx.swift
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageFactorySpec_cxx.swift
@@ -101,62 +101,66 @@ public class HybridImageFactorySpec_cxx {
 
   // Methods
   @inline(__always)
-  public func loadImageFromFile(path: std.string) -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ {
+  public func loadImageFromFile(path: std.string) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ {
     do {
       let __result = try self.__implementation.loadImageFromFile(path: String(path))
-      return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in
         let __cxxWrapped = __result.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func loadImageFromURL(path: std.string) -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ {
+  public func loadImageFromURL(path: std.string) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ {
     do {
       let __result = try self.__implementation.loadImageFromURL(path: String(path))
-      return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in
         let __cxxWrapped = __result.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func loadImageFromSystemName(path: std.string) -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ {
+  public func loadImageFromSystemName(path: std.string) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ {
     do {
       let __result = try self.__implementation.loadImageFromSystemName(path: String(path))
-      return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in
         let __cxxWrapped = __result.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func bounceBack(image: bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_) -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ {
+  public func bounceBack(image: bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__ {
     do {
       let __result = try self.__implementation.bounceBack(image: { () -> HybridImageSpec in
         let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__image__HybridImageSpec_(image)
         let __instance = HybridImageSpec_cxx.fromUnsafe(__unsafePointer)
         return __instance.getHybridImageSpec()
       }())
-      return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridImageSpec_ in
         let __cxxWrapped = __result.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridImageSpec__(__exceptionPtr)
     }
   }
 }
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageSpec_cxx.swift b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageSpec_cxx.swift
index 83d122d8d..6a7c906d6 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageSpec_cxx.swift
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridImageSpec_cxx.swift
@@ -124,18 +124,19 @@ public class HybridImageSpec_cxx {
 
   // Methods
   @inline(__always)
-  public func toArrayBuffer(format: Int32) -> Double {
+  public func toArrayBuffer(format: Int32) -> bridge.Result_double_ {
     do {
       let __result = try self.__implementation.toArrayBuffer(format: margelo.nitro.image.ImageFormat(rawValue: format)!)
-      return __result
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_double_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func saveToFile(path: std.string, onFinished: bridge.Func_void_std__string) -> Void {
+  public func saveToFile(path: std.string, onFinished: bridge.Func_void_std__string) -> bridge.Result_void_ {
     do {
       try self.__implementation.saveToFile(path: String(path), onFinished: { () -> ((String) -> Void) in
         let __sharedClosure = bridge.share_Func_void_std__string(onFinished)
@@ -143,10 +144,10 @@ public class HybridImageSpec_cxx {
           __sharedClosure.pointee.call(std.string(__path))
         }
       }())
-      return 
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
     }
   }
 }
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift
index 786b2d89c..3f2faddb1 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec.swift
@@ -39,6 +39,7 @@ public protocol HybridTestObjectSwiftKotlinSpec_protocol: AnyObject {
   func createMap() throws -> AnyMapHolder
   func mapRoundtrip(map: AnyMapHolder) throws -> AnyMapHolder
   func funcThatThrows() throws -> Double
+  func funcThatThrowsBeforePromise() throws -> Promise<Void>
   func throwError(error: Error) throws -> Void
   func tryOptionalParams(num: Double, boo: Bool, str: String?) throws -> String
   func tryMiddleParam(num: Double, boo: Bool?, str: String) throws -> String
diff --git a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift
index 6155ce89c..883a3e348 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift
+++ b/packages/react-native-nitro-image/nitrogen/generated/ios/swift/HybridTestObjectSwiftKotlinSpec_cxx.swift
@@ -344,133 +344,140 @@ public class HybridTestObjectSwiftKotlinSpec_cxx {
 
   // Methods
   @inline(__always)
-  public func newTestObject() -> bridge.std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec_ {
+  public func newTestObject() -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__ {
     do {
       let __result = try self.__implementation.newTestObject()
-      return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec_ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec_ in
         let __cxxWrapped = __result.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridTestObjectSwiftKotlinSpec__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func simpleFunc() -> Void {
+  public func simpleFunc() -> bridge.Result_void_ {
     do {
       try self.__implementation.simpleFunc()
-      return 
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func addNumbers(a: Double, b: Double) -> Double {
+  public func addNumbers(a: Double, b: Double) -> bridge.Result_double_ {
     do {
       let __result = try self.__implementation.addNumbers(a: a, b: b)
-      return __result
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_double_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func addStrings(a: std.string, b: std.string) -> std.string {
+  public func addStrings(a: std.string, b: std.string) -> bridge.Result_std__string_ {
     do {
       let __result = try self.__implementation.addStrings(a: String(a), b: String(b))
-      return std.string(__result)
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__string_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func multipleArguments(num: Double, str: std.string, boo: Bool) -> Void {
+  public func multipleArguments(num: Double, str: std.string, boo: Bool) -> bridge.Result_void_ {
     do {
       try self.__implementation.multipleArguments(num: num, str: String(str), boo: boo)
-      return 
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func bounceStrings(array: bridge.std__vector_std__string_) -> bridge.std__vector_std__string_ {
+  public func bounceStrings(array: bridge.std__vector_std__string_) -> bridge.Result_std__vector_std__string__ {
     do {
       let __result = try self.__implementation.bounceStrings(array: array.map({ __item in String(__item) }))
-      return { () -> bridge.std__vector_std__string_ in
+      let __resultCpp = { () -> bridge.std__vector_std__string_ in
         var __vector = bridge.create_std__vector_std__string_(__result.count)
         for __item in __result {
           __vector.push_back(std.string(__item))
         }
         return __vector
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__vector_std__string__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_std__string__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func bounceNumbers(array: bridge.std__vector_double_) -> bridge.std__vector_double_ {
+  public func bounceNumbers(array: bridge.std__vector_double_) -> bridge.Result_std__vector_double__ {
     do {
       let __result = try self.__implementation.bounceNumbers(array: array.map({ __item in __item }))
-      return { () -> bridge.std__vector_double_ in
+      let __resultCpp = { () -> bridge.std__vector_double_ in
         var __vector = bridge.create_std__vector_double_(__result.count)
         for __item in __result {
           __vector.push_back(__item)
         }
         return __vector
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__vector_double__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_double__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func bounceStructs(array: bridge.std__vector_Person_) -> bridge.std__vector_Person_ {
+  public func bounceStructs(array: bridge.std__vector_Person_) -> bridge.Result_std__vector_Person__ {
     do {
       let __result = try self.__implementation.bounceStructs(array: array.map({ __item in __item }))
-      return { () -> bridge.std__vector_Person_ in
+      let __resultCpp = { () -> bridge.std__vector_Person_ in
         var __vector = bridge.create_std__vector_Person_(__result.count)
         for __item in __result {
           __vector.push_back(__item)
         }
         return __vector
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__vector_Person__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_Person__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func bounceEnums(array: bridge.std__vector_Powertrain_) -> bridge.std__vector_Powertrain_ {
+  public func bounceEnums(array: bridge.std__vector_Powertrain_) -> bridge.Result_std__vector_Powertrain__ {
     do {
       let __result = try self.__implementation.bounceEnums(array: array.map({ __item in __item }))
-      return { () -> bridge.std__vector_Powertrain_ in
+      let __resultCpp = { () -> bridge.std__vector_Powertrain_ in
         var __vector = bridge.create_std__vector_Powertrain_(__result.count)
         for __item in __result {
           __vector.push_back(__item)
         }
         return __vector
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__vector_Powertrain__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__vector_Powertrain__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func complexEnumCallback(array: bridge.std__vector_Powertrain_, callback: bridge.Func_void_std__vector_Powertrain_) -> Void {
+  public func complexEnumCallback(array: bridge.std__vector_Powertrain_, callback: bridge.Func_void_std__vector_Powertrain_) -> bridge.Result_void_ {
     do {
       try self.__implementation.complexEnumCallback(array: array.map({ __item in __item }), callback: { () -> (([Powertrain]) -> Void) in
         let __sharedClosure = bridge.share_Func_void_std__vector_Powertrain_(callback)
@@ -484,59 +491,80 @@ public class HybridTestObjectSwiftKotlinSpec_cxx {
         }())
         }
       }())
-      return 
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func createMap() -> margelo.nitro.TSharedMap {
+  public func createMap() -> bridge.Result_std__shared_ptr_AnyMap__ {
     do {
       let __result = try self.__implementation.createMap()
-      return __result.cppPart
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = __result.cppPart
+      return bridge.create_Result_std__shared_ptr_AnyMap__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_AnyMap__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func mapRoundtrip(map: margelo.nitro.TSharedMap) -> margelo.nitro.TSharedMap {
+  public func mapRoundtrip(map: margelo.nitro.TSharedMap) -> bridge.Result_std__shared_ptr_AnyMap__ {
     do {
       let __result = try self.__implementation.mapRoundtrip(map: AnyMapHolder(withCppPart: map))
-      return __result.cppPart
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = __result.cppPart
+      return bridge.create_Result_std__shared_ptr_AnyMap__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_AnyMap__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func funcThatThrows() -> Double {
+  public func funcThatThrows() -> bridge.Result_double_ {
     do {
       let __result = try self.__implementation.funcThatThrows()
-      return __result
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_double_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func throwError(error: std.exception_ptr) -> Void {
+  public func funcThatThrowsBeforePromise() -> bridge.Result_std__shared_ptr_Promise_void___ {
+    do {
+      let __result = try self.__implementation.funcThatThrowsBeforePromise()
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
+        let __promise = bridge.create_std__shared_ptr_Promise_void__()
+        __result
+          .then({ __result in __promise.pointee.resolve() })
+          .catch({ __error in __promise.pointee.reject(__error.toCpp()) })
+        return __promise
+      }()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
+    }
+  }
+  
+  @inline(__always)
+  public func throwError(error: std.exception_ptr) -> bridge.Result_void_ {
     do {
       try self.__implementation.throwError(error: RuntimeError.from(cppError: error))
-      return 
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func tryOptionalParams(num: Double, boo: Bool, str: bridge.std__optional_std__string_) -> std.string {
+  public func tryOptionalParams(num: Double, boo: Bool, str: bridge.std__optional_std__string_) -> bridge.Result_std__string_ {
     do {
       let __result = try self.__implementation.tryOptionalParams(num: num, boo: boo, str: { () -> String? in
         if let __unwrapped = str.value {
@@ -545,105 +573,112 @@ public class HybridTestObjectSwiftKotlinSpec_cxx {
           return nil
         }
       }())
-      return std.string(__result)
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__string_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func tryMiddleParam(num: Double, boo: bridge.std__optional_bool_, str: std.string) -> std.string {
+  public func tryMiddleParam(num: Double, boo: bridge.std__optional_bool_, str: std.string) -> bridge.Result_std__string_ {
     do {
       let __result = try self.__implementation.tryMiddleParam(num: num, boo: boo.value, str: String(str))
-      return std.string(__result)
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = std.string(__result)
+      return bridge.create_Result_std__string_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__string_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func tryOptionalEnum(value: bridge.std__optional_Powertrain_) -> bridge.std__optional_Powertrain_ {
+  public func tryOptionalEnum(value: bridge.std__optional_Powertrain_) -> bridge.Result_std__optional_Powertrain__ {
     do {
       let __result = try self.__implementation.tryOptionalEnum(value: value.value)
-      return { () -> bridge.std__optional_Powertrain_ in
+      let __resultCpp = { () -> bridge.std__optional_Powertrain_ in
         if let __unwrappedValue = __result {
           return bridge.create_std__optional_Powertrain_(__unwrappedValue)
         } else {
           return .init()
         }
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__optional_Powertrain__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_Powertrain__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func calculateFibonacciSync(value: Double) -> Int64 {
+  public func calculateFibonacciSync(value: Double) -> bridge.Result_int64_t_ {
     do {
       let __result = try self.__implementation.calculateFibonacciSync(value: value)
-      return __result
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = __result
+      return bridge.create_Result_int64_t_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_int64_t_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func calculateFibonacciAsync(value: Double) -> bridge.std__shared_ptr_Promise_int64_t__ {
+  public func calculateFibonacciAsync(value: Double) -> bridge.Result_std__shared_ptr_Promise_int64_t___ {
     do {
       let __result = try self.__implementation.calculateFibonacciAsync(value: value)
-      return { () -> bridge.std__shared_ptr_Promise_int64_t__ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_int64_t__ in
         let __promise = bridge.create_std__shared_ptr_Promise_int64_t__()
         __result
           .then({ __result in __promise.pointee.resolve(__result) })
           .catch({ __error in __promise.pointee.reject(__error.toCpp()) })
         return __promise
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_Promise_int64_t___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_int64_t___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func wait(seconds: Double) -> bridge.std__shared_ptr_Promise_void__ {
+  public func wait(seconds: Double) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
       let __result = try self.__implementation.wait(seconds: seconds)
-      return { () -> bridge.std__shared_ptr_Promise_void__ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
         let __promise = bridge.create_std__shared_ptr_Promise_void__()
         __result
           .then({ __result in __promise.pointee.resolve() })
           .catch({ __error in __promise.pointee.reject(__error.toCpp()) })
         return __promise
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func promiseThrows() -> bridge.std__shared_ptr_Promise_void__ {
+  public func promiseThrows() -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
       let __result = try self.__implementation.promiseThrows()
-      return { () -> bridge.std__shared_ptr_Promise_void__ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
         let __promise = bridge.create_std__shared_ptr_Promise_void__()
         __result
           .then({ __result in __promise.pointee.resolve() })
           .catch({ __error in __promise.pointee.reject(__error.toCpp()) })
         return __promise
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func awaitAndGetPromise(promise: bridge.std__shared_ptr_Promise_double__) -> bridge.std__shared_ptr_Promise_double__ {
+  public func awaitAndGetPromise(promise: bridge.std__shared_ptr_Promise_double__) -> bridge.Result_std__shared_ptr_Promise_double___ {
     do {
       let __result = try self.__implementation.awaitAndGetPromise(promise: { () -> Promise<Double> in
         let __promise = Promise<Double>()
@@ -701,21 +736,22 @@ public class HybridTestObjectSwiftKotlinSpec_cxx {
         promise.pointee.addOnRejectedListener(__rejecterCpp)
         return __promise
       }())
-      return { () -> bridge.std__shared_ptr_Promise_double__ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_double__ in
         let __promise = bridge.create_std__shared_ptr_Promise_double__()
         __result
           .then({ __result in __promise.pointee.resolve(__result) })
           .catch({ __error in __promise.pointee.reject(__error.toCpp()) })
         return __promise
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_Promise_double___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_double___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func awaitAndGetComplexPromise(promise: bridge.std__shared_ptr_Promise_Car__) -> bridge.std__shared_ptr_Promise_Car__ {
+  public func awaitAndGetComplexPromise(promise: bridge.std__shared_ptr_Promise_Car__) -> bridge.Result_std__shared_ptr_Promise_Car___ {
     do {
       let __result = try self.__implementation.awaitAndGetComplexPromise(promise: { () -> Promise<Car> in
         let __promise = Promise<Car>()
@@ -773,21 +809,22 @@ public class HybridTestObjectSwiftKotlinSpec_cxx {
         promise.pointee.addOnRejectedListener(__rejecterCpp)
         return __promise
       }())
-      return { () -> bridge.std__shared_ptr_Promise_Car__ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_Car__ in
         let __promise = bridge.create_std__shared_ptr_Promise_Car__()
         __result
           .then({ __result in __promise.pointee.resolve(__result) })
           .catch({ __error in __promise.pointee.reject(__error.toCpp()) })
         return __promise
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_Promise_Car___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_Car___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func awaitPromise(promise: bridge.std__shared_ptr_Promise_void__) -> bridge.std__shared_ptr_Promise_void__ {
+  public func awaitPromise(promise: bridge.std__shared_ptr_Promise_void__) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
       let __result = try self.__implementation.awaitPromise(promise: { () -> Promise<Void> in
         let __promise = Promise<Void>()
@@ -822,21 +859,22 @@ public class HybridTestObjectSwiftKotlinSpec_cxx {
         promise.pointee.addOnRejectedListener(__rejecterCpp)
         return __promise
       }())
-      return { () -> bridge.std__shared_ptr_Promise_void__ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
         let __promise = bridge.create_std__shared_ptr_Promise_void__()
         __result
           .then({ __result in __promise.pointee.resolve() })
           .catch({ __error in __promise.pointee.reject(__error.toCpp()) })
         return __promise
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func callCallback(callback: bridge.Func_void) -> Void {
+  public func callCallback(callback: bridge.Func_void) -> bridge.Result_void_ {
     do {
       try self.__implementation.callCallback(callback: { () -> (() -> Void) in
         let __sharedClosure = bridge.share_Func_void(callback)
@@ -844,15 +882,15 @@ public class HybridTestObjectSwiftKotlinSpec_cxx {
           __sharedClosure.pointee.call()
         }
       }())
-      return 
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func callAll(first: bridge.Func_void, second: bridge.Func_void, third: bridge.Func_void) -> Void {
+  public func callAll(first: bridge.Func_void, second: bridge.Func_void, third: bridge.Func_void) -> bridge.Result_void_ {
     do {
       try self.__implementation.callAll(first: { () -> (() -> Void) in
         let __sharedClosure = bridge.share_Func_void(first)
@@ -870,15 +908,15 @@ public class HybridTestObjectSwiftKotlinSpec_cxx {
           __sharedClosure.pointee.call()
         }
       }())
-      return 
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func callWithOptional(value: bridge.std__optional_double_, callback: bridge.Func_void_std__optional_double_) -> Void {
+  public func callWithOptional(value: bridge.std__optional_double_, callback: bridge.Func_void_std__optional_double_) -> bridge.Result_void_ {
     do {
       try self.__implementation.callWithOptional(value: value.value, callback: { () -> ((Double?) -> Void) in
         let __sharedClosure = bridge.share_Func_void_std__optional_double_(callback)
@@ -892,15 +930,15 @@ public class HybridTestObjectSwiftKotlinSpec_cxx {
         }())
         }
       }())
-      return 
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func getValueFromJSCallbackAndWait(getValue: bridge.Func_std__shared_ptr_Promise_double__) -> bridge.std__shared_ptr_Promise_double__ {
+  public func getValueFromJSCallbackAndWait(getValue: bridge.Func_std__shared_ptr_Promise_double__) -> bridge.Result_std__shared_ptr_Promise_double___ {
     do {
       let __result = try self.__implementation.getValueFromJSCallbackAndWait(getValue: { () -> (() -> Promise<Double>) in
         let __sharedClosure = bridge.share_Func_std__shared_ptr_Promise_double__(getValue)
@@ -964,21 +1002,22 @@ public class HybridTestObjectSwiftKotlinSpec_cxx {
           }()
         }
       }())
-      return { () -> bridge.std__shared_ptr_Promise_double__ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_double__ in
         let __promise = bridge.create_std__shared_ptr_Promise_double__()
         __result
           .then({ __result in __promise.pointee.resolve(__result) })
           .catch({ __error in __promise.pointee.reject(__error.toCpp()) })
         return __promise
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_Promise_double___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_double___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func getValueFromJsCallback(callback: bridge.Func_std__shared_ptr_Promise_std__string__, andThenCall: bridge.Func_void_std__string) -> bridge.std__shared_ptr_Promise_void__ {
+  public func getValueFromJsCallback(callback: bridge.Func_std__shared_ptr_Promise_std__string__, andThenCall: bridge.Func_void_std__string) -> bridge.Result_std__shared_ptr_Promise_void___ {
     do {
       let __result = try self.__implementation.getValueFromJsCallback(callback: { () -> (() -> Promise<String>) in
         let __sharedClosure = bridge.share_Func_std__shared_ptr_Promise_std__string__(callback)
@@ -1047,219 +1086,233 @@ public class HybridTestObjectSwiftKotlinSpec_cxx {
           __sharedClosure.pointee.call(std.string(__valueFromJs))
         }
       }())
-      return { () -> bridge.std__shared_ptr_Promise_void__ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_void__ in
         let __promise = bridge.create_std__shared_ptr_Promise_void__()
         __result
           .then({ __result in __promise.pointee.resolve() })
           .catch({ __error in __promise.pointee.reject(__error.toCpp()) })
         return __promise
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_void___(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func getCar() -> Car {
+  public func getCar() -> bridge.Result_Car_ {
     do {
       let __result = try self.__implementation.getCar()
-      return __result
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = __result
+      return bridge.create_Result_Car_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_Car_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func isCarElectric(car: Car) -> Bool {
+  public func isCarElectric(car: Car) -> bridge.Result_bool_ {
     do {
       let __result = try self.__implementation.isCarElectric(car: car)
-      return __result
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = __result
+      return bridge.create_Result_bool_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_bool_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func getDriver(car: Car) -> bridge.std__optional_Person_ {
+  public func getDriver(car: Car) -> bridge.Result_std__optional_Person__ {
     do {
       let __result = try self.__implementation.getDriver(car: car)
-      return { () -> bridge.std__optional_Person_ in
+      let __resultCpp = { () -> bridge.std__optional_Person_ in
         if let __unwrappedValue = __result {
           return bridge.create_std__optional_Person_(__unwrappedValue)
         } else {
           return .init()
         }
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__optional_Person__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__optional_Person__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func createArrayBuffer() -> ArrayBufferHolder {
+  public func createArrayBuffer() -> bridge.Result_std__shared_ptr_ArrayBuffer__ {
     do {
       let __result = try self.__implementation.createArrayBuffer()
-      return __result
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = __result.getArrayBuffer()
+      return bridge.create_Result_std__shared_ptr_ArrayBuffer__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_ArrayBuffer__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func getBufferLastItem(buffer: ArrayBufferHolder) -> Double {
+  public func getBufferLastItem(buffer: ArrayBufferHolder) -> bridge.Result_double_ {
     do {
       let __result = try self.__implementation.getBufferLastItem(buffer: buffer)
-      return __result
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      let __resultCpp = __result
+      return bridge.create_Result_double_(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_double_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func setAllValuesTo(buffer: ArrayBufferHolder, value: Double) -> Void {
+  public func setAllValuesTo(buffer: ArrayBufferHolder, value: Double) -> bridge.Result_void_ {
     do {
       try self.__implementation.setAllValuesTo(buffer: buffer, value: value)
-      return 
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_void_()
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_void_(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func createArrayBufferAsync() -> bridge.std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ {
+  public func createArrayBufferAsync() -> bridge.Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____ {
     do {
       let __result = try self.__implementation.createArrayBufferAsync()
-      return { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___ in
         let __promise = bridge.create_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer___()
         __result
           .then({ __result in __promise.pointee.resolve(__result.getArrayBuffer()) })
           .catch({ __error in __promise.pointee.reject(__error.toCpp()) })
         return __promise
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_Promise_std__shared_ptr_ArrayBuffer____(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func createChild() -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ {
+  public func createChild() -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__ {
     do {
       let __result = try self.__implementation.createChild()
-      return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in
         let __cxxWrapped = __result.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func createBase() -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ {
+  public func createBase() -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ {
     do {
       let __result = try self.__implementation.createBase()
-      return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in
         let __cxxWrapped = __result.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func createBaseActualChild() -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ {
+  public func createBaseActualChild() -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ {
     do {
       let __result = try self.__implementation.createBaseActualChild()
-      return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in
         let __cxxWrapped = __result.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func bounceChild(child: bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_) -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ {
+  public func bounceChild(child: bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__ {
     do {
       let __result = try self.__implementation.bounceChild(child: { () -> HybridChildSpec in
         let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__image__HybridChildSpec_(child)
         let __instance = HybridChildSpec_cxx.fromUnsafe(__unsafePointer)
         return __instance.getHybridChildSpec()
       }())
-      return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in
         let __cxxWrapped = __result.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func bounceBase(base: bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_) -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ {
+  public func bounceBase(base: bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ {
     do {
       let __result = try self.__implementation.bounceBase(base: { () -> HybridBaseSpec in
         let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__image__HybridBaseSpec_(base)
         let __instance = HybridBaseSpec_cxx.fromUnsafe(__unsafePointer)
         return __instance.getHybridBaseSpec()
       }())
-      return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in
         let __cxxWrapped = __result.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func bounceChildBase(child: bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_) -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ {
+  public func bounceChildBase(child: bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__ {
     do {
       let __result = try self.__implementation.bounceChildBase(child: { () -> HybridChildSpec in
         let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__image__HybridChildSpec_(child)
         let __instance = HybridChildSpec_cxx.fromUnsafe(__unsafePointer)
         return __instance.getHybridChildSpec()
       }())
-      return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_ in
         let __cxxWrapped = __result.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridBaseSpec__(__exceptionPtr)
     }
   }
   
   @inline(__always)
-  public func castBase(base: bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_) -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ {
+  public func castBase(base: bridge.std__shared_ptr_margelo__nitro__image__HybridBaseSpec_) -> bridge.Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__ {
     do {
       let __result = try self.__implementation.castBase(base: { () -> HybridBaseSpec in
         let __unsafePointer = bridge.get_std__shared_ptr_margelo__nitro__image__HybridBaseSpec_(base)
         let __instance = HybridBaseSpec_cxx.fromUnsafe(__unsafePointer)
         return __instance.getHybridBaseSpec()
       }())
-      return { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in
+      let __resultCpp = { () -> bridge.std__shared_ptr_margelo__nitro__image__HybridChildSpec_ in
         let __cxxWrapped = __result.getCxxWrapper()
         return __cxxWrapped.getCxxPart()
       }()
-    } catch {
-      let __message = "\(error.localizedDescription)"
-      fatalError("Swift errors can currently not be propagated to C++! See https://github.com/swiftlang/swift/issues/75290 (Error: \(__message))")
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(__resultCpp)
+    } catch (let __error) {
+      let __exceptionPtr = __error.toCpp()
+      return bridge.create_Result_std__shared_ptr_margelo__nitro__image__HybridChildSpec__(__exceptionPtr)
     }
   }
 }
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp
index 60484e1d3..f77453d7b 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.cpp
@@ -61,6 +61,7 @@ namespace margelo::nitro::image {
       prototype.registerHybridMethod("createMap", &HybridTestObjectCppSpec::createMap);
       prototype.registerHybridMethod("mapRoundtrip", &HybridTestObjectCppSpec::mapRoundtrip);
       prototype.registerHybridMethod("funcThatThrows", &HybridTestObjectCppSpec::funcThatThrows);
+      prototype.registerHybridMethod("funcThatThrowsBeforePromise", &HybridTestObjectCppSpec::funcThatThrowsBeforePromise);
       prototype.registerHybridMethod("throwError", &HybridTestObjectCppSpec::throwError);
       prototype.registerHybridMethod("tryOptionalParams", &HybridTestObjectCppSpec::tryOptionalParams);
       prototype.registerHybridMethod("tryMiddleParam", &HybridTestObjectCppSpec::tryMiddleParam);
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp
index 38eb41fd2..f92050e14 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectCppSpec.hpp
@@ -45,8 +45,8 @@ namespace margelo::nitro::image { class HybridBaseSpec; }
 #include "Person.hpp"
 #include <functional>
 #include <NitroModules/AnyMap.hpp>
-#include <exception>
 #include <NitroModules/Promise.hpp>
+#include <exception>
 #include <NitroModules/ArrayBuffer.hpp>
 #include "HybridChildSpec.hpp"
 #include "HybridBaseSpec.hpp"
@@ -128,6 +128,7 @@ namespace margelo::nitro::image {
       virtual std::shared_ptr<AnyMap> createMap() = 0;
       virtual std::shared_ptr<AnyMap> mapRoundtrip(const std::shared_ptr<AnyMap>& map) = 0;
       virtual double funcThatThrows() = 0;
+      virtual std::shared_ptr<Promise<void>> funcThatThrowsBeforePromise() = 0;
       virtual void throwError(const std::exception_ptr& error) = 0;
       virtual std::string tryOptionalParams(double num, bool boo, const std::optional<std::string>& str) = 0;
       virtual std::string tryMiddleParam(double num, std::optional<bool> boo, const std::string& str) = 0;
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp
index 1d351c012..0769279fb 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.cpp
@@ -52,6 +52,7 @@ namespace margelo::nitro::image {
       prototype.registerHybridMethod("createMap", &HybridTestObjectSwiftKotlinSpec::createMap);
       prototype.registerHybridMethod("mapRoundtrip", &HybridTestObjectSwiftKotlinSpec::mapRoundtrip);
       prototype.registerHybridMethod("funcThatThrows", &HybridTestObjectSwiftKotlinSpec::funcThatThrows);
+      prototype.registerHybridMethod("funcThatThrowsBeforePromise", &HybridTestObjectSwiftKotlinSpec::funcThatThrowsBeforePromise);
       prototype.registerHybridMethod("throwError", &HybridTestObjectSwiftKotlinSpec::throwError);
       prototype.registerHybridMethod("tryOptionalParams", &HybridTestObjectSwiftKotlinSpec::tryOptionalParams);
       prototype.registerHybridMethod("tryMiddleParam", &HybridTestObjectSwiftKotlinSpec::tryMiddleParam);
diff --git a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp
index fd28291cc..7c0a5e719 100644
--- a/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp
+++ b/packages/react-native-nitro-image/nitrogen/generated/shared/c++/HybridTestObjectSwiftKotlinSpec.hpp
@@ -43,8 +43,8 @@ namespace margelo::nitro::image { class HybridBaseSpec; }
 #include "Person.hpp"
 #include <functional>
 #include <NitroModules/AnyMap.hpp>
-#include <exception>
 #include <NitroModules/Promise.hpp>
+#include <exception>
 #include "Car.hpp"
 #include <NitroModules/ArrayBuffer.hpp>
 #include "HybridChildSpec.hpp"
@@ -118,6 +118,7 @@ namespace margelo::nitro::image {
       virtual std::shared_ptr<AnyMap> createMap() = 0;
       virtual std::shared_ptr<AnyMap> mapRoundtrip(const std::shared_ptr<AnyMap>& map) = 0;
       virtual double funcThatThrows() = 0;
+      virtual std::shared_ptr<Promise<void>> funcThatThrowsBeforePromise() = 0;
       virtual void throwError(const std::exception_ptr& error) = 0;
       virtual std::string tryOptionalParams(double num, bool boo, const std::optional<std::string>& str) = 0;
       virtual std::string tryMiddleParam(double num, std::optional<bool> boo, const std::string& str) = 0;
diff --git a/packages/react-native-nitro-image/src/specs/TestObject.nitro.ts b/packages/react-native-nitro-image/src/specs/TestObject.nitro.ts
index 7cfe107aa..8dc345103 100644
--- a/packages/react-native-nitro-image/src/specs/TestObject.nitro.ts
+++ b/packages/react-native-nitro-image/src/specs/TestObject.nitro.ts
@@ -74,6 +74,7 @@ interface SharedTestObjectProps {
 
   // Errors
   funcThatThrows(): number
+  funcThatThrowsBeforePromise(): Promise<void>
   throwError(error: Error): void
 
   // Optional parameters
diff --git a/packages/react-native-nitro-modules/NitroModules.podspec b/packages/react-native-nitro-modules/NitroModules.podspec
index a5cefcc70..d697b8fc3 100644
--- a/packages/react-native-nitro-modules/NitroModules.podspec
+++ b/packages/react-native-nitro-modules/NitroModules.podspec
@@ -47,6 +47,7 @@ Pod::Spec.new do |s|
     "ios/core/ArrayBufferHolder.hpp",
     "ios/core/AnyMapHolder.hpp",
     "ios/core/HybridContext.hpp",
+    "ios/utils/Result.hpp",
     "ios/utils/RuntimeError.hpp",
     "ios/utils/SwiftClosure.hpp",
   ]
diff --git a/packages/react-native-nitro-modules/ios/utils/Result.hpp b/packages/react-native-nitro-modules/ios/utils/Result.hpp
new file mode 100644
index 000000000..16b00aea7
--- /dev/null
+++ b/packages/react-native-nitro-modules/ios/utils/Result.hpp
@@ -0,0 +1,193 @@
+#pragma once
+
+#include <exception>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+namespace margelo::nitro {
+
+// TODO: Remove this whole Result wrapping system once Swift errors can be caught in C++.
+//       See https://github.com/swiftlang/swift/issues/75290
+
+/**
+ * Represents a Result from a function. It's either a value (`T`), or an error (`std::exception_ptr`).
+ */
+template <typename T>
+class Result {
+public:
+  // Constructors
+  Result(const Result& other) : _hasError(other._hasError) {
+    if (_hasError) {
+      new (&_error) std::exception_ptr(other._error);
+    } else {
+      new (&_storage) T(other.value());
+    }
+  }
+
+  Result(Result&& other) noexcept(std::is_nothrow_move_constructible<T>::value) : _hasError(other._hasError) {
+    if (_hasError) {
+      new (&_error) std::exception_ptr(std::move(other._error));
+    } else {
+      new (&_storage) T(std::move(other.value()));
+    }
+  }
+
+  ~Result() {
+    destroy();
+  }
+
+  Result& operator=(const Result& other) {
+    if (this == &other)
+      return *this;
+    destroy();
+    _hasError = other._hasError;
+    if (_hasError) {
+      new (&_error) std::exception_ptr(other._error);
+    } else {
+      new (&_storage) T(other.value());
+    }
+    return *this;
+  }
+
+  Result& operator=(Result&& other) noexcept(std::is_nothrow_move_constructible<T>::value) {
+    if (this == &other)
+      return *this;
+    destroy();
+    _hasError = other._hasError;
+    if (_hasError) {
+      new (&_error) std::exception_ptr(std::move(other._error));
+    } else {
+      new (&_storage) T(std::move(other.value()));
+    }
+    return *this;
+  }
+
+  // Static factories
+  static Result withValue(const T& value) {
+    return Result(value);
+  }
+
+  static Result withValue(T&& value) {
+    return Result(std::move(value));
+  }
+
+  static Result withError(std::exception_ptr eptr) {
+    return Result(eptr);
+  }
+
+  // Accessors
+  bool hasValue() const noexcept {
+    return !_hasError;
+  }
+
+  bool hasError() const noexcept {
+    return _hasError;
+  }
+
+  const T& value() const {
+    assert(!_hasError && "Result<T> does not hold a value!");
+    return *reinterpret_cast<const T*>(&_storage);
+  }
+
+  T& value() {
+    assert(!_hasError && "Result<T> does not hold a value!");
+    return *reinterpret_cast<T*>(&_storage);
+  }
+
+  std::exception_ptr error() const {
+    assert(_hasError && "Result<T> does not hold an error!");
+    return _error;
+  }
+
+private:
+  // Private constructors
+  explicit Result(const T& value) : _hasError(false) {
+    new (&_storage) T(value);
+  }
+
+  explicit Result(T&& value) : _hasError(false) {
+    new (&_storage) T(std::move(value));
+  }
+
+  explicit Result(std::exception_ptr eptr) : _hasError(true) {
+    new (&_error) std::exception_ptr(eptr);
+  }
+
+  void destroy() {
+    if (_hasError) {
+      reinterpret_cast<std::exception_ptr*>(&_error)->~exception_ptr();
+    } else {
+      reinterpret_cast<T*>(&_storage)->~T();
+    }
+  }
+
+private:
+  bool _hasError;
+  union {
+    typename std::aligned_storage<sizeof(T), alignof(T)>::type _storage;
+    std::exception_ptr _error;
+  };
+};
+
+// Specialization for void
+template <>
+class Result<void> {
+public:
+  // Constructors
+  Result(const Result& other) : _hasError(other._hasError), _error(other._error) {}
+
+  Result(Result&& other) noexcept : _hasError(other._hasError), _error(std::move(other._error)) {}
+
+  Result& operator=(const Result& other) {
+    if (this == &other)
+      return *this;
+    _hasError = other._hasError;
+    if (_hasError) {
+      _error = other._error;
+    }
+    return *this;
+  }
+
+  Result& operator=(Result&& other) noexcept {
+    if (this == &other)
+      return *this;
+    _hasError = other._hasError;
+    if (_hasError) {
+      _error = std::move(other._error);
+    }
+    return *this;
+  }
+
+  // Static factories
+  static Result withValue() {
+    return Result();
+  }
+
+  static Result withError(std::exception_ptr eptr) {
+    return Result(eptr);
+  }
+
+  bool hasValue() const noexcept {
+    return !_hasError;
+  }
+
+  bool hasError() const noexcept {
+    return _hasError;
+  }
+
+  std::exception_ptr error() const {
+    assert(_hasError && "Result<void> does not hold an error!");
+    return _error;
+  }
+
+private:
+  explicit Result() : _hasError(false), _error(nullptr) {}
+  explicit Result(std::exception_ptr error) : _hasError(true), _error(error) {}
+
+private:
+  bool _hasError;
+  std::exception_ptr _error;
+};
+
+} // namespace margelo::nitro