@@ -13,19 +13,31 @@ live in the depsgraph. An export that does not ask for evaluated geometry
 writes the cage: the LOD modifier is dropped, the engine gets the dense
 mesh, and the script still exits 0.
 
-glTF: `export_apply=True` applies modifiers excluding armatures.
-USD: `evaluation_mode='RENDER'` or `'VIEWPORT'`.
-FBX: `use_mesh_modifiers=True`.
+Each exporter has its own switch (defaults measured on 4.5 LTS and 5.2 LTS):
+
+- glTF: `export_apply` defaults to `False`. Pass `export_apply=True`
+  (applies modifiers excluding armatures).
+- FBX: `use_mesh_modifiers` defaults to `True`. Only an explicit `False`
+  drops them.
+- USD: modifiers are evaluated by default (`evaluation_mode` defaults to
+  `'RENDER'`), so DECIMATE ships with no extra argument. **Subdivision is the
+  exception:** under the default `export_subdivision='BEST_MATCH'` a SUBSURF
+  modifier is written as the cage plus a `subdivisionScheme`, whatever
+  `evaluation_mode` says. Pass `export_subdivision='TESSELLATE'` to ship the
+  subdivided mesh.
 
 `export_apply` is not "apply object transforms". Apply object scale first.
 See rule `validate-imported-mesh-scale`.
 
 ## What this rule flags
 
-A `bpy.ops.export_scene.gltf`, `bpy.ops.export_scene.fbx`, or
-`bpy.ops.wm.usd_export` call in a file that adds modifiers (`modifiers.new`)
-and never requests evaluated geometry (`export_apply=True` or
-`evaluation_mode=`), and never applies those modifiers before export.
+In a file that adds modifiers (`modifiers.new`) and never applies them
+(`modifier_apply`):
+
+- a `bpy.ops.export_scene.gltf` call without `export_apply=True`;
+- a `bpy.ops.export_scene.fbx` call with `use_mesh_modifiers=False`;
+- a `bpy.ops.wm.usd_export` call without `export_subdivision='TESSELLATE'`
+  when one of the modifiers is SUBSURF.
 
 ```python
 # WRONG: DECIMATE on the object, glTF without export_apply
@@ -36,9 +48,10 @@ bpy.ops.export_scene.gltf(filepath=path, use_selection=True)
 ```
 
 ```python
-# WRONG: USD viewport/render mode omitted; default BEST_MATCH writes the cage
+# WRONG: evaluation_mode does not help here; default BEST_MATCH writes the
+# 8-point cube cage plus subdivisionScheme, not the subdivided mesh
 obj.modifiers.new("ss", "SUBSURF").levels = 2
-bpy.ops.wm.usd_export(filepath=path)
+bpy.ops.wm.usd_export(filepath=path, evaluation_mode="RENDER")
 ```
 
 ## The required pattern
@@ -58,7 +71,9 @@ bpy.ops.export_scene.gltf(
 )
 ```
 
-USD:
+USD with subdivision (`evaluation_mode` picks render vs viewport levels:
+a cube at levels 1 / render_levels 2 ships 26 points with `'VIEWPORT'`, 98
+with the default `'RENDER'`):
 
 ```python
 bpy.ops.wm.usd_export(
 
@@ -146,12 +146,20 @@ Read raw `obj.data` directly when:
 
 For most read paths, prefer the depsgraph route. The cost is one indirection; the safety is enormous.
 
-## `evaluation_mode` for exporters
+## Evaluation mode for exporters
 
-The USD, Alembic, and OBJ exporters accept an `evaluation_mode` parameter that controls how Blender evaluates the scene before exporting:
+The USD and Alembic exporters take `evaluation_mode`; the OBJ exporter's equivalent is `export_eval_mode` with different values. Passing `evaluation_mode=` to `wm.obj_export` raises `TypeError`.
 
-- `'RENDER'`: include render-only modifiers (subsurf at render levels, etc.). Use for final exports.
-- `'VIEWPORT'`: use viewport modifier levels. Use for fast preview exports.
+| Exporter | Parameter | Values | Default |
+| --- | --- | --- | --- |
+| `wm.usd_export` | `evaluation_mode` | `'RENDER'`, `'VIEWPORT'` | `'RENDER'` |
+| `wm.alembic_export` | `evaluation_mode` | `'RENDER'`, `'VIEWPORT'` | `'RENDER'` |
+| `wm.obj_export` | `export_eval_mode` | `'DAG_EVAL_RENDER'`, `'DAG_EVAL_VIEWPORT'` | `'DAG_EVAL_VIEWPORT'` |
+
+- Render: modifiers at render levels (subsurf `render_levels`, render-only modifiers). Use for final exports.
+- Viewport: modifiers at viewport levels. Use for fast preview exports.
+
+Note the OBJ default is the opposite of USD's.
 
 Default `export_subdivision='BEST_MATCH'` writes the **cage** plus
 `subdivisionScheme = catmullClark`. VIEWPORT and RENDER files are then
 
@@ -18,14 +18,20 @@
 )
 
 IMPORT_RE = re.compile(r"bpy\.ops\.import_scene\.(gltf|fbx)\s*\(")
-EXPORT_RE = re.compile(
-    r"bpy\.ops\.(export_scene\.gltf|export_scene\.fbx|wm\.usd_export)\s*\("
-)
 MESH_WORK_RE = re.compile(r"bmesh\.|modifiers\.new|from_pydata|foreach_set")
 UNIT_SCALE_RE = re.compile(r"unit_settings|scale_length|global_scale")
-EXPORT_EVAL_RE = re.compile(
-    r"export_apply\s*=\s*True|evaluation_mode\s*=|use_mesh_modifiers\s*=\s*True"
-)
+# Per-exporter "ships the modifier result" test, applied to each call's own
+# arguments (measured on 4.5.11 and 5.2.1):
+#   glTF  export_apply defaults to False -> must pass export_apply=True
+#   FBX   use_mesh_modifiers defaults to True -> only an explicit False drops them
+#   USD   modifiers are evaluated by default (evaluation_mode defaults to
+#         RENDER), but SUBSURF ships as the cage under the default
+#         export_subdivision='BEST_MATCH' -> needs export_subdivision='TESSELLATE'
+GLTF_APPLY_RE = re.compile(r"export_apply\s*=\s*True")
+FBX_NO_MODS_RE = re.compile(r"use_mesh_modifiers\s*=\s*False")
+USD_TESSELLATE_RE = re.compile(r"export_subdivision\s*=\s*[\"']TESSELLATE[\"']")
+SUBSURF_NEW_RE = re.compile(r"modifiers\.new\([^)]*[\"']SUBSURF[\"']")
+USD_CALL_RE = re.compile(r"bpy\.ops\.wm\.usd_export\s*\(")
 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*\(")
@@ -80,12 +86,27 @@ def check_text(rel, text):
                 "transform_apply and a unit-scale check "
                 "(unit_settings, scale_length, or global_scale)"
             )
-    if EXPORT_RE.search(text) and MODIFIER_NEW_RE.search(text):
-        if not EXPORT_EVAL_RE.search(text) and not MODIFIER_APPLY_RE.search(text):
-            errors.append(
-                f"{rel}: export with modifiers.new but no export_apply=True, "
-                "evaluation_mode, or modifier_apply"
-            )
+    if MODIFIER_NEW_RE.search(text) and not MODIFIER_APPLY_RE.search(text):
+        for body in _call_bodies(text, GLTF_CALL_RE):
+            if not GLTF_APPLY_RE.search(body):
+                errors.append(
+                    f"{rel}: export_scene.gltf after modifiers.new without "
+                    "export_apply=True (or modifier_apply) ships the cage"
+                )
+        for body in _call_bodies(text, FBX_CALL_RE):
+            if FBX_NO_MODS_RE.search(body):
+                errors.append(
+                    f"{rel}: export_scene.fbx with use_mesh_modifiers=False "
+                    "after modifiers.new ships the cage"
+                )
+        if SUBSURF_NEW_RE.search(text):
+            for body in _call_bodies(text, USD_CALL_RE):
+                if not USD_TESSELLATE_RE.search(body):
+                    errors.append(
+                        f"{rel}: wm.usd_export after a SUBSURF modifier without "
+                        "export_subdivision='TESSELLATE' writes the cage "
+                        "(default BEST_MATCH; evaluation_mode does not change it)"
+                    )
     for body in _call_bodies(text, GLTF_CALL_RE):
         if AXIS_FORWARD_RE.search(body) or AXIS_UP_RE.search(body):
             errors.append(