@@ -73,13 +73,17 @@ similar operators act on `selected_editable_objects`, so
 
 ## When you also need a window override
 
-Headless scripts often need `window`, `area`, `region`, or `screen`
-overrides because no UI exists by default. Pass them all to
-`temp_override`:
+Editor operators (`view3d.*`, `screen.*`) poll on an area and region,
+which a script's context does not provide. Object operators do not need
+this. Under `--background` the loaded file still has its window and screen,
+so borrow the 3D viewport from it, and guard the lookup: a file whose
+layout has no 3D viewport has nothing to borrow.
 
 ```python
 window = bpy.context.window_manager.windows[0]
-area = next(a for a in window.screen.areas if a.type == 'VIEW_3D')
+area = next((a for a in window.screen.areas if a.type == 'VIEW_3D'), None)
+if area is None:
+    raise RuntimeError("loaded file has no 3D viewport to override")
 region = next(r for r in area.regions if r.type == 'WINDOW')
 
 with bpy.context.temp_override(window=window, area=area, region=region):
 
@@ -43,24 +43,26 @@ The Blender API is the same in headless mode but several context-dependent behav
 | --- | --- |
 | `bpy.context.window`, `bpy.context.area`, `bpy.context.region` | Often `None` |
 | `bpy.context.active_object` | `None` if no scene is loaded or no active object set |
-| `bpy.context.selected_objects` | Empty by default |
-| Most `bpy.ops.<editor>.*` operators | Fail with "context is incorrect" because they expect an editor that does not exist |
+| `bpy.context.selected_objects` | Whatever the loaded file saved (the factory startup selects its cube); never assume it |
+| Editor operators (`view3d.*`, `screen.*`) | Fail with "context is incorrect": the script's context has no area/region. Override one from the loaded file's screen (below) |
 | Modal operators | Cannot be used; no event loop |
 | Drag and drop, file dialogs, keymaps | All gone |
 | Scene rendering (`bpy.ops.render.render`) | Works fine, this is the standard headless render path |
 
-The headless API surface is essentially "everything that operates on `bpy.data` directly" plus a small whitelist of operators that do not depend on UI state (most `render.*`, most `wm.*` save/load, scene-level edits).
+The headless API surface is "everything that operates on `bpy.data` directly" plus every operator that polls on objects or data rather than on an editor (`object.*`, import/export, `render.*`, `wm.*` save/load). Editor operators need the override described below.
 
 ## Rule of thumb: `bpy.data` is your friend
 
 The single most important pattern: **prefer `bpy.data.*` over `bpy.ops.*`** in batch scripts.
 
 ```python
-# WRONG: requires a 3D viewport context to even poll.
+# FRAGILE: object operators do run under --background, but they act on
+# whatever the selection happens to be, and each call is a full operator
+# round-trip (slow in a loop).
 bpy.ops.object.select_all(action='DESELECT')
 bpy.ops.object.delete()
 
-# RIGHT: works headless.
+# RIGHT: explicit, selection-independent, fast.
 for obj in list(bpy.data.objects):
     bpy.data.objects.remove(obj, do_unlink=True)
 ```
@@ -75,15 +77,28 @@ bpy.ops.wm.obj_export(filepath="/tmp/out.obj", export_selected_objects=False)
 
 The `mesh-editing-and-bmesh` skill covers the rest of the `bpy.data` and `bmesh` patterns. This skill is about **when** the headless context forces you toward those patterns.
 
-## When you must use a `bpy.ops` that wants UI: `temp_override`
+## Which operators run headless
+
+Two kinds of operator behave differently under `--background`:
+
+- **Object and data operators** (`object.*`, `mesh.*` outside edit-mode UI, `export_scene.*`, `wm.*_export`, `render.render`): they poll on `context.object` / selection, not on an editor, so they run headless. `bpy.ops.object.select_all(action='DESELECT')` and `bpy.ops.object.transform_apply(...)` both return `{'FINISHED'}` under `--background` on 4.5 LTS and 5.2 LTS. Narrow them with an object/selection override, no window needed:
+
+  ```python
+  with bpy.context.temp_override(object=obj, active_object=obj, selected_editable_objects=[obj]):
+      bpy.ops.object.transform_apply(location=False, rotation=True, scale=True)
+  ```
+
+- **Editor operators** (`view3d.*`, `screen.*`, `uv.*` that read the editor): they poll on an area/region and fail with `poll() failed, context is incorrect` unless you override one. A file loaded under `--background` still has its window and screen, so you can borrow the 3D viewport area from it.
+
+## When you must use an editor operator: `temp_override` with window/area/region
 
 A few `bpy.ops` calls have no `bpy.data` equivalent and genuinely need an editor context. For these, use `bpy.context.temp_override`:
 
 ```python
 import bpy
 
 def find_window_and_area():
-    for window in bpy.data.window_managers[0].windows:
+    for window in bpy.context.window_manager.windows:
         for area in window.screen.areas:
             if area.type == 'VIEW_3D':
                 return window, area
@@ -100,12 +115,10 @@ def run_in_view3d_context(callable_, *args, **kwargs):
         return callable_(*args, **kwargs)
 
 
-run_in_view3d_context(bpy.ops.object.transform_apply, location=True, rotation=True, scale=True)
+run_in_view3d_context(bpy.ops.view3d.snap_cursor_to_selected)
 ```
 
-In **pure** headless mode (`--background`), there are no windows at all, so this pattern only works if you have a "GUI but headless" setup (e.g. `blender --python` without `--background`, running on a virtual framebuffer).
-
-For true headless, your only option is to find a `bpy.data` equivalent or pre-bake the operation into the .blend file.
+This works under `--background` too: the window and screen come from the loaded file (the factory startup has one window whose screen includes a `VIEW_3D` area), so `bpy.ops.view3d.snap_cursor_to_selected()` returns `{'FINISHED'}` with the override and fails its poll without it. It fails only when the loaded file's screen has no 3D viewport, which is why the helper raises instead of assuming one. Prefer a `bpy.data` equivalent whenever one exists; it does not depend on what the file's UI layout happened to be.
 
 ## Argument parsing after `--`
 
@@ -222,12 +235,14 @@ except Exception as e:
 
 ## Common AI mistakes
 
-1. **Calling UI-dependent `bpy.ops` in headless** without a `temp_override`:
+1. **Calling an editor operator in headless** without a window/area/region `temp_override`:
 
    ```python
-   bpy.ops.object.select_all(action='DESELECT')  # fails: no view3d
+   bpy.ops.view3d.snap_cursor_to_selected()  # poll() failed, context is incorrect
    ```
 
+   Object operators such as `object.select_all` and `object.transform_apply` do not need this; they run under `--background` as-is.
+
 2. **Using `bpy.context.scene` before a scene is loaded**. After Blender starts, the default startup file is loaded, so `context.scene` works. But if you've called `bpy.ops.wm.read_factory_settings(use_empty=True)`, dereferencing `context.scene.collection` may surprise you.
 
 3. **Forgetting the `--` argv split**. Without it, `argparse` sees Blender's own flags and rejects them.