Treat the asset export as a build

First, build a mental model

Blender to browser resembles source code to application: author, prepare, export, validate, load and inspect. The exported asset must preserve the intended scale, orientation, origin, material roles, animation and performance budget. Each stage can introduce a defect that the previous stage could not reveal.

1. Agree on units, up direction, forward direction and origin before exporting. A door needs a useful hinge origin; a vehicle needs a deliberate movement reference. Apply transforms only when appropriate for the asset and animation workflow, rather than blindly applying them to every rig.
2. Topology describes how vertices, edges and faces connect. Silhouette, deformation and shading determine useful detail. UV layout and material assignments define texture interpretation. Exporters often triangulate or split vertices at attribute boundaries, so authoring vertex counts need not equal runtime counts.
3. A game material must fit the target format and renderer. Complex Blender node graphs may need conversion or baking. Inspect supported glTF material features and exported maps; the browser does not execute an arbitrary Blender shader graph.
4. Armatures and animation add a contract for rest pose, skin weights, clip names and supported channels. Validate representative motion after export. An unrigged prop pipeline can be simpler than an animated-character pipeline; document which one a script supports.
5. Blender Python can select objects, validate inputs, generate assets and invoke export. Operator options vary with the installed build and addons. Inspect the installed operator's RNA properties and record the tool version, rather than assuming a tutorial's flags always apply.

# Outline for a saved Blender file containing selected, unrigged mesh props.
# Run inside Blender's Python environment after reviewing the export destination.
from pathlib import Path
import bpy

if not bpy.data.filepath:
    raise RuntimeError("Save the authoring file before using a relative export path")
selected = list(bpy.context.selected_objects)
if not selected or any(obj.type != "MESH" for obj in selected):
    raise ValueError("This prop pipeline accepts only selected mesh objects")
for obj in selected:
    if any(modifier.type == "ARMATURE" for modifier in obj.modifiers):
        raise ValueError("Skinned meshes need the character pipeline")
    if obj.parent and obj.parent.type == "ARMATURE":
        raise ValueError("Armature-parented objects need the character pipeline")
    if obj.animation_data:
        raise ValueError("Animated objects need additional clip validation")
    if any(abs(value - 1.0) > 1e-6 for value in obj.scale):
        raise ValueError("Review and normalize prop scale before export")
    if not obj.data.uv_layers:
        raise ValueError("This textured-prop contract requires UVs")
properties = set(bpy.ops.export_scene.gltf.get_rna_type().properties.keys())
required = {"filepath", "export_format", "use_selection"}
if not required.issubset(properties):
    raise RuntimeError("Inspect the installed exporter before choosing its options")
destination = Path(bpy.path.abspath("//exports/demo-prop.glb"))
destination.parent.mkdir(parents=True, exist_ok=True)
result = bpy.ops.export_scene.gltf(
    filepath=str(destination), export_format="GLB", use_selection=True
)
if "FINISHED" not in result or not destination.is_file():
    raise RuntimeError("Export did not produce the expected artifact")
# Next: independently validate and load the artifact; existence is not correctness.

1. Input contract

   This outline deliberately accepts selected unrigged mesh props from a saved file, with unit scale and UVs. It does not claim to handle every character rig or material graph.

2. Export boundary

   The script checks that expected operator properties exist before invoking them. A successful operator result and file existence establish artifact creation, not visual or runtime quality.

3. Independent check

   A fresh import or target loader checks bounds, materials, clips and dependencies. A representative browser scene then checks appearance, interaction and budgets.