This still leaves even lower-level code not returning propert failure
results, but one step at a time.

@@ -493,3 +533,3 @@
           for (n = 1, fp = value_cache; n < range && fp; n++, fp++) {
             blender::animrig::insert_vert_fcurve(
-                fcu, {fp->frame, fp->val}, settings, eInsertKeyFlags(1));
+                fcu, {fp->frame, fp->val}, settings, INSERTKEY_NOFLAGS);

@@ -1071,2 +1072,4 @@
     rna_tag_animation_update(bmain, id);
 
+    bool replace;
+    const int index = BKE_fcurve_bezt_binarysearch_index(fcu->bezt, frame, fcu->totvert, &replace);

@@ -443,1 +444,4 @@
+  SingleKeyingResult result_loc_a = key_strip.keyframe_insert(
+      binding, "location", 0, {1.0f, 47.0f}, INSERTKEY_NOFLAGS, settings);
+  ASSERT_EQ(SingleKeyingResult::SUCCESS, result_loc_a)
       << "Expect all the necessary data structures to be created on insertion of a key";

@@ -291,1 +340,3 @@
-    return -1;
+    /* TODO: we need more info from `insert_bezt_fcurve()` called above to
+     * return a more specific failure. */
+    return SingleKeyingResult::GENERIC_FAILURE;

@@ -1060,2 +1169,3 @@
 
-  AnimData *adt = BKE_animdata_from_id(id);
+  if (USER_EXPERIMENTAL_TEST(&U, use_animation_baklava) && (adt->animation || !adt->action)) {
+    /* TODO: Don't hardcode key settings. */

@@ -43,6 +43,11 @@ static eInsertKeyFlags get_autokey_flags(Scene *scene)
     flag |= INSERTKEY_NEEDED;
   }
 
+  /* Only insert available. */

@@ -72,0 +87,4 @@
+
+/**
+ * Return whether a new fcurve can be created according to the given keyframing
+ * flags.

@@ -646,3 +646,3 @@
   BLI_assert(StringRef(this->name).size() >= name_length_min);
 
-  /* Avoid accessing an uninitialized part of the string accidentally. */
+  /* Avoid accessing an uninitialised part of the string accidentally. */

@@ -878,3 +872,1 @@
-                 array_index,
-                 binding.name);
-    return nullptr;
+  /* Get the fcurve, or if one doesn't exist and the keying flags allow then

@@ -454,1 +455,3 @@
-      << "Expect same (binding/rna path/array index) tuple to return the same FCurve.";
+  SingleKeyingResult result_loc_b = key_strip.keyframe_insert(
+      binding, "location", 0, {5.0f, 47.1f}, INSERTKEY_NOFLAGS, settings);
+  ASSERT_EQ(SingleKeyingResult::SUCCESS, result_loc_b);

@@ -455,0 +457,4 @@
+  ASSERT_EQ(SingleKeyingResult::SUCCESS, result_loc_b);
+  ASSERT_EQ(1, channels->fcurves().size()) << "Expect insertion with the same (binding/rna "
+                                              "path/array index) tuple to go into the same FCurve";
+  ASSERT_EQ(2, channels->fcurves()[0]->totvert)

@@ -455,0 +458,4 @@
+  ASSERT_EQ(1, channels->fcurves().size()) << "Expect insertion with the same (binding/rna "
+                                              "path/array index) tuple to go into the same FCurve";
+  ASSERT_EQ(2, channels->fcurves()[0]->totvert)
+      << "Expect insertion with the same (binding/rna "

@@ -77,0 +86,4 @@
+     * this?  If it's never supposed to happen, an assert would be better.  If
+     * it *is* supposed to happen, then printf doesn't seem like the right way
+     * to report it, if it should be reported at all. */
+    printf("ERROR: Couldn't add AnimData (ID = %s)\n", (id) ? (id->name) : "<None>");

@@ -278,1 +290,4 @@
+ */
+static bool new_key_needed(FCurve *fcu, const float frame, const float value)
 {
+  if (fcu == nullptr) {

@@ -92,6 +97,17 @@ void CombinedKeyingResult::generate_reports(ReportList *reports)
   }
 
   Vector<std::string> errors;
+  if (this->get_count(SingleKeyingResult::UNKNOWN_FAILURE) > 0) {

@@ -1045,0 +1071,4 @@
+                                           const eInsertKeyFlags insert_key_flags,
+                                           const KeyframeSettings &key_settings)
+{
+  if (layer.strips().size() == 0) {

@@ -1045,0 +1094,4 @@
+  ID *id = rna_pointer->owner_id;
+  CombinedKeyingResult combined_result;
+
+  Binding *binding = anim.binding_for_id(*id);

@@ -1045,0 +1100,4 @@
+    const bool success = anim.assign_id(binding, *id);
+    if (!success) {
+      /* TODO: count the rna paths properly (e.g. accounting for multi-element properties). */
+      combined_result.add(SingleKeyingResult::NO_VALID_BINDING, rna_paths.size());

@@ -1045,0 +1107,4 @@
+
+  Layer *layer;
+  if (anim.layers().size() == 0) {
+    layer = &anim.layer_add("Layer 0");

@@ -1045,0 +1113,4 @@
+    layer = anim.layer(0);
+  }
+
+  if (layer == nullptr) {

@@ -1045,0 +1120,4 @@
+  }
+
+  for (const std::string &rna_path : rna_paths) {
+    const bool visual_keyframing = insert_key_flags & INSERTKEY_MATRIX;

@@ -1045,0 +1126,4 @@
+    const bool path_resolved = RNA_path_resolve_property(
+        rna_pointer, rna_path.c_str(), &ptr, &prop);
+    if (!path_resolved) {
+      combined_result.add(SingleKeyingResult::CANNOT_RESOLVE_PATH);

@@ -1045,0 +1129,4 @@
+      combined_result.add(SingleKeyingResult::CANNOT_RESOLVE_PATH);
+      continue;
+    }
+    const std::optional<std::string> rna_path_id_to_prop = RNA_path_from_ID_to_property(&ptr,

@@ -1045,0 +1131,4 @@
+    }
+    const std::optional<std::string> rna_path_id_to_prop = RNA_path_from_ID_to_property(&ptr,
+                                                                                        prop);
+    Vector<float> rna_values = get_keyframe_values(&ptr, prop, visual_keyframing);

@@ -1045,0 +1138,4 @@
+      key_data.array_index = property_index;
+      key_data.position = {scene_frame, rna_values[property_index]};
+      const SingleKeyingResult result = insert_key_layer(
+          *layer, *binding, rna_path_id_to_prop.value(), key_data, insert_key_flags, key_settings);

@@ -289,3 +262,1 @@
-        }
-      }
-    }
+  /* Optimization: if there's no animation at all and "Only Insert Available" is