feat: flag mixed glTF/FBX axis RNA in the import/export harness

export_scene.gltf does not take axis_forward/axis_up; export_scene.fbx does not take export_yup.
The check is per-call so a file that correctly uses both exporters still passes.

Signed-off-by: TMHSDigital <154358121+TMHSDigital@users.noreply.github.com>
Co-authored-by: Cursor <cursoragent@cursor.com>

Author: TMHSDigital

rules/use-correct-axis-rna-per-exporter.mdc

@@ -0,0 +1,83 @@
+---
+description: Flag export_scene.gltf calls that pass FBX axis_forward or axis_up, and export_scene.fbx calls that pass glTF export_yup. The two exporters do not share axis RNA.
+alwaysApply: true
+globs:
+  - "**/*.py"
+standards-version: 1.10.0
+---
+
+# Use correct axis RNA per exporter
+
+`bpy.ops.export_scene.gltf` exposes axis as `export_yup` (bool).
+`bpy.ops.export_scene.fbx` exposes `axis_forward` and `axis_up` (axis
+enums) plus `global_scale`. Mixing them is the usual engine-preset bug:
+the glTF call raises or ignores FBX names, and the FBX call never sees
+`export_yup`.
+
+Verified: https://docs.blender.org/api/current/bpy.ops.export_scene.html#bpy.ops.export_scene.gltf
+and https://docs.blender.org/api/current/bpy.ops.export_scene.html#bpy.ops.export_scene.fbx
+
+## What this rule flags
+
+A `bpy.ops.export_scene.gltf(...)` call whose arguments include
+`axis_forward` or `axis_up`. A `bpy.ops.export_scene.fbx(...)` call whose
+arguments include `export_yup`. Whole-file scans are not enough: a file
+that correctly calls both exporters (Unreal glTF plus Unreal FBX) must
+still pass.
+
+```python
+# WRONG: FBX axis names on the glTF operator
+bpy.ops.export_scene.gltf(
+    filepath=path,
+    use_selection=True,
+    axis_forward="-Z",
+    axis_up="Y",
+)
+```
+
+```python
+# WRONG: glTF Y-up flag on the FBX operator
+bpy.ops.export_scene.fbx(
+    filepath=path,
+    use_selection=True,
+    export_yup=True,
+)
+```
+
+## The required pattern
+
+```python
+# glTF: Unity Y-up
+bpy.ops.export_scene.gltf(
+    filepath=path,
+    use_selection=True,
+    export_yup=True,
+    export_apply=True,
+)
+
+# FBX: Unreal centimeters
+bpy.ops.export_scene.fbx(
+    filepath=path,
+    use_selection=True,
+    axis_forward="-Z",
+    axis_up="Y",
+    global_scale=100.0,
+    use_mesh_modifiers=True,
+)
+```
+
+## Why it matters
+
+Unity vs Godot vs Unreal is not one export with different comments. glTF
+Y-up bakes `(x, y, z) -> (x, z, -y)` into POSITION. Z-up glTF writes the
+Blender coords. FBX uses a different axis pair and can scale to
+centimeters without mutating the mesh. Getting the RNA names wrong ships
+the default axis and looks like "the engine importer is broken".
+
+## Related
+
+- Skill `engine-export-presets`
+- Example `export-preset-axis`
+- Example `gltf-export-roundtrip`
+- Snippet `export_preset_unity.py`
+- Snippet `export_preset_unreal.py`

tests/check_import_export_rules.py

@@ -1,5 +1,5 @@
-"""Static checks for validate-imported-mesh-scale and
-no-unapplied-modifiers-on-export.
+"""Static checks for validate-imported-mesh-scale,
+no-unapplied-modifiers-on-export, and use-correct-axis-rna-per-exporter.
 
 Scans snippets/ and templates/**/*.py. examples/ is excluded because several
 examples are intentional pathology witnesses (unapplied-scale-gltf).
@@ -14,6 +14,7 @@
 REQUIRED_RULES = (
     "rules/validate-imported-mesh-scale.mdc",
     "rules/no-unapplied-modifiers-on-export.mdc",
+    "rules/use-correct-axis-rna-per-exporter.mdc",
 )
 
 IMPORT_RE = re.compile(r"bpy\.ops\.import_scene\.(gltf|fbx)\s*\(")
@@ -27,6 +28,11 @@
 )
 MODIFIER_NEW_RE = re.compile(r"modifiers\.new")
 MODIFIER_APPLY_RE = re.compile(r"modifier_apply")
+GLTF_CALL_RE = re.compile(r"bpy\.ops\.export_scene\.gltf\s*\(")
+FBX_CALL_RE = re.compile(r"bpy\.ops\.export_scene\.fbx\s*\(")
+AXIS_FORWARD_RE = re.compile(r"\baxis_forward\b")
+AXIS_UP_RE = re.compile(r"\baxis_up\b")
+EXPORT_YUP_RE = re.compile(r"\bexport_yup\b")
 
 
 def scan_paths(extra):
@@ -40,6 +46,31 @@ def scan_paths(extra):
     return paths
 
 
+def _call_bodies(text, opener_re):
+    """Extract argument text of each matching call, paren-matched.
+
+    Whole-file scans false-positive a file that correctly calls both
+    exporters (Unreal glTF plus Unreal FBX). Per-call bodies keep those
+    legal.
+    """
+    bodies = []
+    for match in opener_re.finditer(text):
+        i = match.end()
+        depth = 1
+        start = i
+        while i < len(text) and depth:
+            char = text[i]
+            if char == "(":
+                depth += 1
+            elif char == ")":
+                depth -= 1
+            i += 1
+        if depth != 0:
+            continue
+        bodies.append(text[start : i - 1])
+    return bodies
+
+
 def check_text(rel, text):
     errors = []
     if IMPORT_RE.search(text) and MESH_WORK_RE.search(text):
@@ -55,6 +86,18 @@ def check_text(rel, text):
                 f"{rel}: export with modifiers.new but no export_apply=True, "
                 "evaluation_mode, or modifier_apply"
             )
+    for body in _call_bodies(text, GLTF_CALL_RE):
+        if AXIS_FORWARD_RE.search(body) or AXIS_UP_RE.search(body):
+            errors.append(
+                f"{rel}: export_scene.gltf call passes axis_forward or "
+                "axis_up (FBX RNA; glTF uses export_yup)"
+            )
+    for body in _call_bodies(text, FBX_CALL_RE):
+        if EXPORT_YUP_RE.search(body):
+            errors.append(
+                f"{rel}: export_scene.fbx call passes export_yup "
+                "(glTF RNA; FBX uses axis_forward / axis_up)"
+            )
     return errors