@@ -187,9 +187,9 @@ && hasLookaheadInAlternation(ast)) {
     // Generator now caps the initial groupEnd to info.groupMaxCount when the group has a bounded
     // quantifier, so this fallback condition is no longer needed.
 
-    // B12 [PARTIALLY-FIXED]: emitPrefixMatch handles Literal, CharClass, Anchor, and non-capturing
-    // GroupNode (via isPrefixNodeHandleable recursion). Prefix patterns whose top-level node is a
-    // QuantifierNode or another unsupported type still fall back.
+    // B12 [PARTIALLY-FIXED]: emitPrefixMatch handles Literal, CharClass, Anchor, non-capturing
+    // GroupNode (via isPrefixNodeHandleable recursion), and unbounded/exact QuantifierNodes (e.g.
+    // a*, a+, [0-9]*, x{3}). Bounded-range quantifiers {n,m} still fall back.
     if (strategy == PatternAnalyzer.MatchingStrategy.VARIABLE_CAPTURE_BACKREF
         && hasNonAnchorPrefixBeforeBackrefGroup(ast)) {
       return "variable-capture backref with unsupported prefix node type: "
@@ -1002,6 +1002,14 @@ private static boolean isPrefixNodeHandleable(RegexNode node) {
       }
       return true;
     }
+    if (node instanceof QuantifierNode q) {
+      // Handle unbounded (max == -1: *, +, {n,}) and exact ({n}) quantifiers.
+      // Bounded ranges {n,m} with m > n are not yet implemented in emitPrefixNode.
+      if (q.max == -1 || q.min == q.max) {
+        return isPrefixNodeHandleable(q.child);
+      }
+      return false;
+    }
     return false;
   }
 
@@ -1033,7 +1041,8 @@ private static boolean hasNonAnchorPrefixBeforeBackrefGroup(RegexNode ast) {
           GroupNode g = (GroupNode) q.child;
           if (g.capturing && backrefNums.contains(g.groupNumber)) return false;
         }
-        return true; // quantified node in prefix: not handled
+        if (isPrefixNodeHandleable(child)) continue; // handled by emitPrefixNode
+        return true; // bounded-range quantified prefix: not handled
       }
       if (child instanceof LiteralNode || child instanceof CharClassNode) {
         continue; // handled by emitPrefixMatch
 
@@ -24,6 +24,7 @@
 import com.datadoghq.reggie.codegen.ast.ConcatNode;
 import com.datadoghq.reggie.codegen.ast.GroupNode;
 import com.datadoghq.reggie.codegen.ast.LiteralNode;
+import com.datadoghq.reggie.codegen.ast.QuantifierNode;
 import com.datadoghq.reggie.codegen.ast.RegexNode;
 import com.datadoghq.reggie.codegen.automaton.CharSet;
 import org.objectweb.asm.ClassWriter;
@@ -712,11 +713,33 @@ private void generateFindMatchFromMethod(ClassWriter cw) {
   private int getPrefixLength() {
     int n = 0;
     for (RegexNode node : info.prefix) {
-      if (!(node instanceof AnchorNode)) n++;
+      n += prefixNodeMinLength(node);
     }
     return n;
   }
 
+  /** Returns the minimum number of characters consumed by a single prefix node. */
+  private static int prefixNodeMinLength(RegexNode node) {
+    if (node instanceof AnchorNode) return 0;
+    if (node instanceof LiteralNode || node instanceof CharClassNode) return 1;
+    if (node instanceof QuantifierNode) {
+      QuantifierNode q = (QuantifierNode) node;
+      return q.min * prefixNodeMinLength(q.child);
+    }
+    if (node instanceof GroupNode) {
+      GroupNode g = (GroupNode) node;
+      return g.capturing ? 0 : prefixNodeMinLength(g.child);
+    }
+    if (node instanceof ConcatNode) {
+      int total = 0;
+      for (RegexNode child : ((ConcatNode) node).children) {
+        total += prefixNodeMinLength(child);
+      }
+      return total;
+    }
+    return 0;
+  }
+
   private void emitCharSetCheck(
       MethodVisitor mv, int charVar, CharSet cs, boolean negated, Label failLabel) {
     if (!negated) {
@@ -801,6 +824,23 @@ private void emitPrefixNode(
       for (RegexNode child : ((ConcatNode) node).children) {
         emitPrefixNode(mv, child, groupStartVar, lenVar, failLabel, alloc);
       }
+    } else if (node instanceof QuantifierNode) {
+      QuantifierNode q = (QuantifierNode) node;
+      // Emit min mandatory repetitions — if too few chars, jump to failLabel (match fails).
+      for (int i = 0; i < q.min; i++) {
+        emitPrefixNode(mv, q.child, groupStartVar, lenVar, failLabel, alloc);
+      }
+      // For unbounded quantifiers (max == -1): greedy loop for optional repetitions.
+      // Use loopEnd as the child's failLabel so the loop exits without failing the match.
+      if (q.max == -1) {
+        Label loopStart = new Label();
+        Label loopEnd = new Label();
+        mv.visitLabel(loopStart);
+        emitPrefixNode(mv, q.child, groupStartVar, lenVar, loopEnd, alloc);
+        mv.visitJumpInsn(GOTO, loopStart);
+        mv.visitLabel(loopEnd);
+      }
+      // For exact quantifiers (q.min == q.max): mandatory repetitions already emitted above.
     }
   }
 
 
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2026-Present Datadog, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.datadoghq.reggie.runtime;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+import com.datadoghq.reggie.Reggie;
+import com.datadoghq.reggie.ReggieOptions;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Regression coverage for B12: quantifier nodes in the prefix before a capturing backref group.
+ * After the fix these patterns route natively via VARIABLE_CAPTURE_BACKREF.
+ *
+ * <p>Patterns require variable-length group content (e.g. {@code (b+)}, {@code ([0-9]+)}) so they
+ * are detected as VARIABLE_CAPTURE_BACKREF; the prefix quantifier (e.g. {@code a*}, {@code x{3}})
+ * is what previously caused the fallback.
+ */
+class B12QuantifierPrefixTest {
+
+  private static final ReggieOptions WITH_FALLBACK =
+      ReggieOptions.builder().allowJdkFallback().build();
+
+  static Stream<Arguments> quantifierPrefixPatterns() {
+    return Stream.of(
+        Arguments.of("a*(b+)\\1", "bb"),
+        Arguments.of("a*(b+)\\1", "abb"),
+        Arguments.of("a*(b+)\\1", "aabb"),
+        Arguments.of("a*(b+)\\1", "aac"),
+        Arguments.of("a+(b+)\\1", "abb"),
+        Arguments.of("a+(b+)\\1", "aabb"),
+        Arguments.of("a+(b+)\\1", "bb"),
+        Arguments.of("[0-9]*([a-z]+)\\1", "aa"),
+        Arguments.of("[0-9]*([a-z]+)\\1", "1aa"),
+        Arguments.of("[0-9]*([a-z]+)\\1", "123aa"),
+        Arguments.of("[0-9]*([a-z]+)\\1", "ab"),
+        Arguments.of("x{3}(a+)\\1", "xxxaa"),
+        Arguments.of("x{3}(a+)\\1", "xxaa"),
+        Arguments.of("x{3}(a+)\\1", "xxxxaa"));
+  }
+
+  @ParameterizedTest(name = "[{index}] pat={0} in={1}")
+  @MethodSource("quantifierPrefixPatterns")
+  void agreesWithJdk(String pat, String in) {
+    ReggieMatcher reggie = Reggie.compile(pat, WITH_FALLBACK);
+    Pattern jdk = Pattern.compile(pat);
+    String ctx = "pat=" + pat + " in=" + repr(in);
+    assertEquals(jdk.matcher(in).matches(), reggie.matches(in), "matches() " + ctx);
+    assertEquals(jdk.matcher(in).find(), reggie.find(in), "find() " + ctx);
+    Matcher jm = jdk.matcher(in);
+    boolean jFound = jm.find();
+    MatchResult rf = reggie.findMatch(in);
+    assertEquals(jFound, rf != null, "findMatch() null " + ctx);
+    if (jFound && rf != null) {
+      assertEquals(jm.start(), rf.start(), "findMatch() start " + ctx);
+      assertEquals(jm.end(), rf.end(), "findMatch() end " + ctx);
+      if (jm.groupCount() >= 1 && jm.start(1) != -1 && rf.start(1) != -1) {
+        assertEquals(jm.start(1), rf.start(1), "g1 start " + ctx);
+        assertEquals(jm.end(1), rf.end(1), "g1 end " + ctx);
+      }
+    }
+  }
+
+  @ParameterizedTest(name = "[{index}] pat={0} in={1}")
+  @MethodSource("quantifierPrefixPatterns")
+  void routesToNative(String pat, String in) {
+    assertFalse(
+        Reggie.compile(pat) instanceof JavaRegexFallbackMatcher,
+        "expected native matcher for: " + pat);
+  }
+
+  private static String repr(String s) {
+    return s.isEmpty() ? "(empty)" : "\"" + s.replace("\n", "\\n") + "\"";
+  }
+}