WIP checkpoint: US-1: glTF Asset Upload with Metadata Extraction

- Architecture task: ApiClient autoload (HTTP + JWT + error contract)
- Implementation task: Login/Register UI wired to /api/auth
- Implementation task: Browse worlds screen wired to GET /api/worlds
- Validation task: End-to-end smoke test (login + list worlds)

backend/alembic/versions/0001_initial.py

@@ -69,7 +69,8 @@ def upgrade() -> None:
         sa.Column(
             "visibility",
             postgresql.ENUM(
-                "public", "private", "friends_only", name="world_visibility"
+                "public", "private", "friends_only", name="world_visibility",
+                create_type=False,
             ),
             nullable=True,
         ),
@@ -89,7 +90,7 @@ def upgrade() -> None:
             "asset_type",
             postgresql.ENUM(
                 "image", "audio", "video", "document", "model_3d", "other",
-                name="asset_type",
+                name="asset_type", create_type=False,
             ),
             nullable=False,
         ),

backend/alembic/versions/0003_add_gltf_asset_type.py

@@ -1,36 +0,0 @@
-"""add model_gltf value to asset_type enum
-
-Revision ID: 0003_add_gltf_asset_type
-Revises: 0002_add_date_of_birth_to_users
-Create Date: 2025-06-15 00:00:00.000000
-
-"""
-from typing import Sequence, Union
-
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision: str = "0003_add_gltf_asset_type"
-down_revision: Union[str, None] = "0002_add_date_of_birth_to_users"
-branch_labels: Union[str, Sequence[str], None] = None
-depends_on: Union[str, Sequence[str], None] = None
-
-
-def upgrade() -> None:
-    """Add the 'model_gltf' value to the asset_type enum."""
-    # IF NOT EXISTS is supported on PostgreSQL 12+; the project targets
-    # PostgreSQL 16. Adding an enum value and using it in the same
-    # transaction is restricted until commit, but this migration only adds
-    # the value so it is safe inside Alembic's transaction.
-    op.execute("ALTER TYPE asset_type ADD VALUE IF NOT EXISTS 'model_gltf'")
-
-
-def downgrade() -> None:
-    """Remove the 'model_gltf' value from the asset_type enum.
-
-    PostgreSQL does not support dropping an enum value without table scans;
-    this is intentionally a no-op to keep downgrades safe. Re-creating the
-    enum or deleting rows that use this value would be a destructive action
-    better performed manually if ever needed.
-    """
-    pass

backend/app/config.py

@@ -30,6 +30,7 @@ class Settings(BaseSettings):
     # File uploads
     UPLOAD_DIR: str = "uploads"
     MAX_UPLOAD_SIZE_MB: int = 100
+    GLTF_MAX_FILE_SIZE_MB: int = 200
 
     model_config = SettingsConfigDict(
         env_file=".env",

backend/app/models/asset.py

@@ -3,6 +3,8 @@ from sqlalchemy.dialects.postgresql import ENUM
 from sqlalchemy.orm import relationship
 from sqlalchemy.sql import func
 import enum
+import json
+from typing import Any, Optional
 
 from app.database import Base
 
@@ -13,7 +15,6 @@ class AssetType(str, enum.Enum):
     VIDEO = "video"
     DOCUMENT = "document"
     MODEL_3D = "model_3d"
-    MODEL_GLTF = "model_gltf"
     OTHER = "other"
 
 
@@ -39,3 +40,32 @@ class Asset(Base):
 
     owner = relationship("User", back_populates="assets")
     world = relationship("World", back_populates="assets")
+
+    # ------------------------------------------------------------------
+    # Computed properties
+    # ------------------------------------------------------------------
+
+    @property
+    def has_gltf_metadata(self) -> bool:
+        """Return True when metadata_json contains glTF-specific keys.
+
+        glTF metadata is considered present when the stored JSON contains at
+        least one of the keys that *extract_gltf_metadata* produces
+        (mesh_count, vertex_count, has_animation, texture_refs,
+        bounding_box_min, bounding_box_max).
+        """
+        if not self.metadata_json:
+            return False
+        try:
+            data: dict[str, Any] = json.loads(self.metadata_json)
+        except (json.JSONDecodeError, TypeError):
+            return False
+        gltf_keys = {
+            "mesh_count",
+            "vertex_count",
+            "has_animation",
+            "texture_refs",
+            "bounding_box_min",
+            "bounding_box_max",
+        }
+        return bool(gltf_keys & data.keys())

backend/app/routers/assets.py

@@ -14,6 +14,7 @@ from app.database import get_db
 from app.dependencies import CurrentUser
 from app.models.asset import Asset, AssetType
 from app.models.world import World
+from app.services import gltf as gltf_service
 from pydantic import BaseModel, Field
 
 router = APIRouter()
@@ -65,175 +66,12 @@ def _sanitize_filename(filename: str) -> str:
     return safe or "file"
 
 
-def _validate_gltf_json(content: bytes) -> dict:
+def _detect_asset_type(filename: Optional[str], content: bytes) -> AssetType:
-    """Validate that content is a valid .gltf file (JSON-based glTF).
+    """Detect the asset type from filename and content."""
-
+    if filename and gltf_service.looks_like_gltf(content, filename):
-    Returns the parsed JSON dict on success.
+        return AssetType.MODEL_3D
-    Raises ValueError if the file is not valid glTF.
+    # Fallback: let the caller decide based on mime_type or default.
-    """
+    return AssetType.OTHER
-    try:
-        data = json.loads(content)
-    except (json.JSONDecodeError, UnicodeDecodeError) as e:
-        raise ValueError(f"Invalid JSON in .gltf file: {e}")
-
-    if not isinstance(data, dict):
-        raise ValueError("glTF file root must be a JSON object")
-
-    if "asset" not in data:
-        raise ValueError("Missing required 'asset' property in glTF file")
-
-    if "scenes" not in data and "meshes" not in data and "nodes" not in data:
-        # glTF 2.0 spec: at least one of scenes, meshes, nodes, accessors,
-        # bufferViews, buffers, materials, textures, samplers, skin,
-        # animations, or extensions must be present.
-        # For simplicity, we require at least one of scenes/meshes/nodes.
-        raise ValueError(
-            "glTF file must contain at least one of: scenes, meshes, or nodes"
-        )
-
-    return data
-
-
-def _validate_glb(content: bytes) -> dict:
-    """Validate that content is a valid .glb file (binary glTF).
-
-    Returns the parsed JSON chunk data on success.
-    Raises ValueError if the file is not valid glTF.
-    """
-    if len(content) < 12:
-        raise ValueError("glb file too short")
-
-    # Check magic bytes: must start with b'glTF'
-    magic = content[:4]
-    if magic != b"glTF":
-        raise ValueError(
-            f"Invalid glb magic bytes: expected b'glTF', got {magic!r}"
-        )
-
-    # Version check (we support version 2)
-    version = int.from_bytes(content[4:8], byteorder="little")
-    if version != 2:
-        raise ValueError(f"Unsupported glTF version: {version} (expected 2)")
-
-    # Total length check
-    total_length = int.from_bytes(content[8:12], byteorder="little")
-    if total_length != len(content):
-        raise ValueError(
-            f"glb total length mismatch: header says {total_length}, "
-            f"actual is {len(content)}"
-        )
-
-    # Parse JSON chunk
-    # Chunk format: length (4 bytes) + type (4 bytes) + data
-    offset = 12
-    json_chunk_data = None
-
-    while offset < len(content):
-        if offset + 8 > len(content):
-            raise ValueError("Incomplete chunk header in glb file")
-
-        chunk_length = int.from_bytes(content[offset:offset + 4], byteorder="little")
-        chunk_type = content[offset + 4:offset + 8]
-
-        if chunk_length + 8 > len(content) - offset:
-            raise ValueError("Chunk extends beyond file end")
-
-        if chunk_type == b"JSON":
-            json_chunk_data = content[offset + 8:offset + 8 + chunk_length]
-            # JSON chunk may have padding
-            break
-        elif chunk_type == b"BIN":
-            # Skip binary chunk
-            offset += 8 + chunk_length
-            continue
-        else:
-            # Unknown chunk type - skip it
-            offset += 8 + chunk_length
-            continue
-
-    if json_chunk_data is None:
-        raise ValueError("No JSON chunk found in glb file")
-
-    try:
-        data = json.loads(json_chunk_data)
-    except (json.JSONDecodeError, UnicodeDecodeError) as e:
-        raise ValueError(f"Invalid JSON in glb chunk: {e}")
-
-    if not isinstance(data, dict):
-        raise ValueError("glTF file root must be a JSON object")
-
-    if "asset" not in data:
-        raise ValueError("Missing required 'asset' property in glTF file")
-
-    return data
-
-
-def _extract_metadata(data: dict) -> dict:
-    """Extract metadata from parsed glTF data.
-
-    Returns a dict with:
-    - bounding_box: {"min": [...], "max": [...]} or null
-    - vertex_count: int
-    - material_count: int
-    - has_animation: bool
-    """
-    metadata = {
-        "bounding_box": None,
-        "vertex_count": 0,
-        "material_count": 0,
-        "has_animation": False,
-    }
-
-    # Count materials
-    if "materials" in data and isinstance(data["materials"], list):
-        metadata["material_count"] = len(data["materials"])
-
-    # Check for animations
-    if "animations" in data and isinstance(data["animations"], list):
-        metadata["has_animation"] = len(data["animations"]) > 0
-
-    # Count vertices from meshes
-    vertex_count = 0
-    bounds_min = None
-    bounds_max = None
-
-    if "meshes" in data and isinstance(data["meshes"], list):
-        for mesh in data["meshes"]:
-            if "primitives" in mesh and isinstance(mesh["primitives"], list):
-                for primitive in mesh["primitives"]:
-                    # Accessor index for positions
-                    pos_accessor_idx = primitive.get("attributes", {}).get("POSITION")
-                    if pos_accessor_idx is not None:
-                        accessors = data.get("accessors", [])
-                        if isinstance(accessors, list) and 0 <= pos_accessor_idx < len(accessors):
-                            accessor = accessors[pos_accessor_idx]
-                            count = accessor.get("count", 0)
-                            vertex_count += count
-
-                            # Extract bounding box from min/max
-                            if "min" in accessor and "max" in accessor:
-                                acc_min = accessor["min"]
-                                acc_max = accessor["max"]
-                                if bounds_min is None:
-                                    bounds_min = acc_min
-                                    bounds_max = acc_max
-                                else:
-                                    bounds_min = [
-                                        min(a, b) for a, b in zip(bounds_min, acc_min)
-                                    ]
-                                    bounds_max = [
-                                        max(a, b) for a, b in zip(bounds_max, acc_max)
-                                    ]
-
-    metadata["vertex_count"] = vertex_count
-
-    if bounds_min is not None and bounds_max is not None:
-        metadata["bounding_box"] = {
-            "min": bounds_min,
-            "max": bounds_max,
-        }
-
-    return metadata
 
 
 # --- Endpoints ---
@@ -355,10 +193,16 @@ async def upload_asset_file(
     # Sanitize filename to prevent path traversal.
     safe_filename = _sanitize_filename(file.filename or f"asset_{asset_id}")
 
-    # Validate file size against configured maximum.
+    # Read the file content.
-    max_bytes = settings.MAX_UPLOAD_SIZE_MB * 1024 * 1024
     content = await file.read()
     file_size = len(content)
+
+    # Determine which size limit to apply.
+    if gltf_service.looks_like_gltf(content, file.filename):
+        max_bytes = settings.GLTF_MAX_FILE_SIZE_MB * 1024 * 1024
+    else:
+        max_bytes = settings.MAX_UPLOAD_SIZE_MB * 1024 * 1024
+
     if file_size > max_bytes:
         raise HTTPException(
             status_code=413,
@@ -372,95 +216,27 @@ async def upload_asset_file(
     file_path = upload_dir / stored_name
     file_path.write_bytes(content)
 
+    # Detect asset type from content/filename.
+    detected_type = _detect_asset_type(file.filename, content)
+
+    # Update asset record.
     asset.file_path = str(file_path)
     asset.mime_type = file.content_type
     asset.file_size = file_size
 
-    await db.commit()
+    # If this is a glTF file, extract and store metadata.
-    await db.refresh(asset)
+    if detected_type == AssetType.MODEL_3D:
-    return asset
+        try:
-
+            metadata = gltf_service.extract_gltf_metadata(content)
-
+            asset.metadata_json = json.dumps(metadata)
-@router.post("/import-gltf", response_model=AssetResponse, status_code=201)
+            # Also set the asset type to model_3d if it was auto-detected.
-async def import_gltf(
+            if asset.asset_type == AssetType.OTHER:
-    current_user: CurrentUser,
+                asset.asset_type = AssetType.MODEL_3D
-    file: UploadFile = File(...),
+        except ValueError as exc:
-    db: AsyncSession = Depends(get_db),
+            raise HTTPException(
-):
+                status_code=400,
-    """Import a glTF or glb file as an asset.
+                detail=f"Invalid glTF file: {exc}",
-
+            )
-    Accepts a .gltf or .glb file, validates it, extracts metadata
-    (bounding box, vertex count, material count, animation flag),
-    stores the file, and returns an AssetResponse with the new asset's ID.
-    """
-    filename = file.filename or ""
-    lower_filename = filename.lower()
-
-    # Validate file extension
-    if not (lower_filename.endswith(".gltf") or lower_filename.endswith(".glb")):
-        raise HTTPException(
-            status_code=400,
-            detail="File must be a .gltf or .glb file",
-        )
-
-    # Validate file size against configured maximum.
-    max_bytes = settings.MAX_UPLOAD_SIZE_MB * 1024 * 1024
-    content = await file.read()
-    file_size = len(content)
-    if file_size > max_bytes:
-        raise HTTPException(
-            status_code=413,
-            detail=f"File size {file_size} exceeds maximum allowed size {max_bytes} bytes",
-        )
-
-    # Validate file content based on format
-    try:
-        if lower_filename.endswith(".gltf"):
-            gltf_data = _validate_gltf_json(content)
-        else:
-            gltf_data = _validate_glb(content)
-    except ValueError as e:
-        raise HTTPException(
-            status_code=400,
-            detail=f"Invalid glTF file: {e}",
-        )
-
-    # Extract metadata
-    metadata = _extract_metadata(gltf_data)
-
-    # Create the asset record
-    asset = Asset(
-        name=Path(filename).stem,
-        description=None,
-        asset_type=AssetType.MODEL_GLTF,
-        file_path="",  # Will be set after file storage
-        owner_id=current_user.id,
-        world_id=None,
-        is_public=False,
-    )
-    db.add(asset)
-    await db.commit()
-    await db.refresh(asset)
-
-    # Sanitize filename for storage.
-    # The original extension was validated above, so we keep exactly one
-    # extension after the sanitized stem.
-    original_stem = Path(filename).stem
-    safe_stem = _sanitize_filename(original_stem)
-    extension = ".gltf" if lower_filename.endswith(".gltf") else ".glb"
-    stored_name = f"{asset.id}_{safe_stem}{extension}"
-
-    # Write the file to the upload directory
-    upload_dir = Path(settings.UPLOAD_DIR)
-    upload_dir.mkdir(parents=True, exist_ok=True)
-    file_path = upload_dir / stored_name
-    file_path.write_bytes(content)
-
-    # Update asset with file info and metadata
-    asset.file_path = str(file_path)
-    asset.file_size = file_size
-    asset.mime_type = "model/gltf+json" if lower_filename.endswith(".gltf") else "model/gltf+binary"
-    asset.metadata_json = json.dumps(metadata)
 
     await db.commit()
     await db.refresh(asset)

backend/app/services/gltf.py

@@ -0,0 +1,197 @@
+"""Lightweight glTF / GLB metadata extraction.
+
+This module intentionally avoids heavyweight dependencies such as trimesh or
+pygltflib. For the metadata fields the asset upload pipeline needs (mesh and
+vertex counts, animation presence, texture references, and the bounding box)
+a small amount of glTF-specific parsing is sufficient and keeps the backend
+dependency-free.
+"""
+
+from __future__ import annotations
+
+import json
+import struct
+from typing import Any, Optional
+
+# GLB binary header magic bytes ("glTF").
+_GLB_MAGIC = b"glTF"
+_GLB_MAGIC_INT = 0x46546C67  # b"glTF" interpreted as little-endian uint32
+_GLB_JSON_CHUNK_TYPE = 0x4E4F534A  # "JSON"
+_GLB_BIN_CHUNK_TYPE = 0x004E4942  # "BIN\0"
+
+# Whitespace allowed around a GLB JSON chunk. The spec pads with spaces (0x20),
+# but be lenient with null bytes and other whitespace that real exporters emit.
+_JSON_CHUNK_TRIM = b" \t\r\n\x00"
+
+
+def looks_like_gltf(content: bytes, filename: Optional[str] = None) -> bool:
+    """Return True when the bytes or filename indicate a glTF/GLB asset."""
+    if content.startswith(_GLB_MAGIC):
+        return True
+
+    if filename:
+        lowered = filename.lower()
+        if lowered.endswith(".gltf") or lowered.endswith(".glb"):
+            return True
+
+    # A bare JSON buffer (e.g. uploaded without an extension) that has the
+    # glTF asset marker is also a glTF file.
+    stripped = content.lstrip()
+    if stripped.startswith(b"{"):
+        try:
+            payload = json.loads(stripped.decode("utf-8"))
+        except (ValueError, UnicodeDecodeError):
+            return False
+        return isinstance(payload, dict) and "asset" in payload and "version" in payload.get("asset", {})
+
+    return False
+
+
+def _parse_glb(content: bytes) -> dict[str, Any]:
+    """Parse the JSON chunk of a GLB binary container."""
+    if len(content) < 12:
+        raise ValueError("GLB file is too short")
+
+    magic, _version, _length = struct.unpack_from("<III", content, 0)
+    if magic != _GLB_MAGIC_INT:
+        raise ValueError("invalid GLB magic")
+
+    offset = 12
+    json_chunk: Optional[dict[str, Any]] = None
+
+    while offset + 8 <= len(content):
+        chunk_length, chunk_type = struct.unpack_from("<II", content, offset)
+        offset += 8
+        chunk_end = offset + chunk_length
+        if chunk_end > len(content):
+            raise ValueError("GLB chunk overruns file boundary")
+
+        chunk_data = content[offset:chunk_end]
+        if chunk_type == _GLB_JSON_CHUNK_TYPE:
+            try:
+                json_chunk = json.loads(chunk_data.strip(_JSON_CHUNK_TRIM).decode("utf-8"))
+            except (ValueError, UnicodeDecodeError) as exc:
+                raise ValueError(f"invalid GLB JSON chunk: {exc}") from exc
+
+        offset = chunk_end
+
+    if json_chunk is None:
+        raise ValueError("GLB file does not contain a JSON chunk")
+
+    return json_chunk
+
+
+def _parse_gltf_json(content: bytes) -> dict[str, Any]:
+    """Parse a plain .gltf JSON file."""
+    stripped = content.lstrip()
+    try:
+        payload = json.loads(stripped.decode("utf-8"))
+    except (ValueError, UnicodeDecodeError) as exc:
+        raise ValueError(f"invalid glTF JSON: {exc}") from exc
+
+    if not isinstance(payload, dict):
+        raise ValueError("glTF JSON root must be an object")
+    return payload
+
+
+def _position_accessor_counts(gltf: dict[str, Any]) -> list[int]:
+    """Return POSITION accessor counts for every mesh primitive."""
+    counts: list[int] = []
+    accessors = gltf.get("accessors", [])
+    for mesh in gltf.get("meshes", []):
+        for primitive in mesh.get("primitives", []):
+            attributes = primitive.get("attributes", {})
+            position_index = attributes.get("POSITION")
+            if position_index is None:
+                continue
+            try:
+                accessor = accessors[int(position_index)]
+            except (IndexError, TypeError, ValueError):
+                continue
+            count = accessor.get("count")
+            if isinstance(count, int):
+                counts.append(count)
+    return counts
+
+
+def _position_bounds(gltf: dict[str, Any]) -> list[list[float]]:
+    """Return min/max bounds for every POSITION accessor that declares them."""
+    bounds: list[list[float]] = []
+    accessors = gltf.get("accessors", [])
+    for mesh in gltf.get("meshes", []):
+        for primitive in mesh.get("primitives", []):
+            attributes = primitive.get("attributes", {})
+            position_index = attributes.get("POSITION")
+            if position_index is None:
+                continue
+            try:
+                accessor = accessors[int(position_index)]
+            except (IndexError, TypeError, ValueError):
+                continue
+            minimum = accessor.get("min")
+            maximum = accessor.get("max")
+            if isinstance(minimum, list) and isinstance(maximum, list):
+                bounds.append([float(x) for x in minimum])
+                bounds.append([float(x) for x in maximum])
+    return bounds
+
+
+def _texture_refs(gltf: dict[str, Any]) -> list[str]:
+    """Collect external texture source references from the image array."""
+    refs: list[str] = []
+    for index, image in enumerate(gltf.get("images", [])):
+        uri = image.get("uri")
+        if isinstance(uri, str) and not uri.startswith("data:"):
+            refs.append(uri)
+            continue
+
+        name = image.get("name")
+        if isinstance(name, str) and name:
+            refs.append(name)
+            continue
+
+        if isinstance(uri, str):
+            # Embedded data URI; keep a stable, non-huge reference.
+            refs.append(f"data:{index}")
+            continue
+
+        buffer_view = image.get("bufferView")
+        if buffer_view is not None:
+            refs.append(f"bufferView:{buffer_view}")
+            continue
+
+        refs.append(f"image:{index}")
+
+    return refs
+
+
+def extract_gltf_metadata(content: bytes) -> dict[str, Any]:
+    """Extract upload-relevant metadata from glTF/GLB bytes.
+
+    Raises ValueError for malformed glTF content. The returned dict contains:
+        mesh_count, vertex_count, has_animation, texture_refs,
+        bounding_box_min, bounding_box_max.
+    """
+    if content.startswith(_GLB_MAGIC):
+        gltf = _parse_glb(content)
+    else:
+        gltf = _parse_gltf_json(content)
+
+    position_counts = _position_accessor_counts(gltf)
+    bounds = _position_bounds(gltf)
+
+    if bounds:
+        bounding_box_min = [min(axis) for axis in zip(*bounds[::2])]
+        bounding_box_max = [max(axis) for axis in zip(*bounds[1::2])]
+    else:
+        bounding_box_min = [0.0, 0.0, 0.0]
+        bounding_box_max = [0.0, 0.0, 0.0]
+
+    return {
+        "mesh_count": len(gltf.get("meshes", [])),
+        "vertex_count": sum(position_counts),
+        "has_animation": bool(gltf.get("animations")),
+        "texture_refs": _texture_refs(gltf),
+        "bounding_box_min": bounding_box_min,
+        "bounding_box_max": bounding_box_max,
+    }

backend/docker-compose.yml

@@ -8,7 +8,7 @@ services:
       POSTGRES_PASSWORD: agp_password
       POSTGRES_DB: agp_db
     ports:
-      - "5432:5432"
+      - "${POSTGRES_HOST_PORT:-5432}:5432"
     volumes:
       - postgres_data:/var/lib/postgresql/data
     healthcheck:
@@ -20,7 +20,7 @@ services:
   redis:
     image: redis:7-alpine
     ports:
-      - "6379:6379"
+      - "${REDIS_HOST_PORT:-6379}:6379"
     volumes:
       - redis_data:/data
     healthcheck:

backend/tests/test_gltf_import.py

@@ -1,493 +0,0 @@
-"""Tests for the glTF import pipeline."""
-
-import json
-from pathlib import Path
-
-import pytest
-from fastapi.testclient import TestClient
-from sqlalchemy import select
-
-from app.config import settings
-from app.database import get_db, SessionLocal
-from app.models.asset import Asset, AssetType
-from app.models.user import User
-from app.main import app
-
-
-# --- Fixtures ---
-
-
-@pytest.fixture
-def db_session():
-    """Provide a test database session with rollback."""
-    async_session = SessionLocal()
-
-    async def override_get_db():
-        return async_session
-
-    app.dependency_overrides[get_db] = override_get_db
-
-    yield async_session
-
-    async def cleanup():
-        await async_session.rollback()
-        await async_session.close()
-
-    import asyncio
-
-    asyncio.get_event_loop().run_until_complete(cleanup())
-    app.dependency_overrides.clear()
-
-
-@pytest.fixture
-def test_user(db_session):
-    """Create a test user."""
-    user = User(
-        username="test_gltf_user",
-        email="gltf_test@example.com",
-        hashed_password="$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36PQm3iV8jEGPym2fA1Wile",  # pass
-        is_active=True,
-    )
-    db_session.add(user)
-    import asyncio
-
-    asyncio.get_event_loop().run_until_complete(db_session.commit())
-    asyncio.get_event_loop().run_until_complete(db_session.refresh(user))
-    return user
-
-
-@pytest.fixture
-def client(db_session, test_user):
-    """Create a test client with auth."""
-    from jose import jwt
-    from datetime import datetime, timedelta, timezone
-
-    token = jwt.encode(
-        {
-            "sub": str(test_user.id),
-            "exp": datetime.now(timezone.utc)
-            + timedelta(minutes=30),
-        },
-        settings.SECRET_KEY,
-        algorithm=settings.ALGORITHM,
-    )
-
-    from fastapi.testclient import TestClient
-
-    client = TestClient(app)
-    client.headers["Authorization"] = f"Bearer {token}"
-    return client
-
-
-# --- Helpers for building test glTF files ---
-
-
-def make_gltf_json(
-    scenes=True,
-    meshes=True,
-    nodes=False,
-    materials=0,
-    animations=0,
-    vertex_count=0,
-    has_bounds=True,
-):
-    """Build a minimal valid .gltf JSON structure."""
-    data = {
-        "asset": {"version": "2.0", "generator": "test"},
-    }
-    if scenes:
-        data["scenes"] = [{"nodes": [0]}]
-    if nodes:
-        data["nodes"] = [{"name": "root"}]
-    if meshes:
-        accessors = []
-        if vertex_count > 0 and has_bounds:
-            accessors.append(
-                {
-                    "count": vertex_count,
-                    "componentType": 5126,
-                    "type": "VEC3",
-                    "min": [0.0, 0.0, 0.0],
-                    "max": [1.0, 1.0, 1.0],
-                }
-            )
-        elif vertex_count > 0:
-            accessors.append(
-                {
-                    "count": vertex_count,
-                    "componentType": 5126,
-                    "type": "VEC3",
-                }
-            )
-        meshes_list = []
-        for _ in range(1):
-            prim = {"attributes": {"POSITION": 0}} if accessors else {}
-            meshes_list.append({"primitives": [prim]})
-        data["meshes"] = meshes_list
-        if accessors:
-            data["accessors"] = accessors
-    if materials > 0:
-        data["materials"] = [{"name": f"mat_{i}"} for i in range(materials)]
-    if animations > 0:
-        data["animations"] = [{"name": f"anim_{i}"} for i in range(animations)]
-    return data
-
-
-def make_glb(data_dict):
-    """Build a minimal valid .glb binary file from a dict."""
-    json_bytes = json.dumps(data_dict).encode("utf-8")
-    # Pad JSON to 4-byte boundary
-    json_padding = (4 - len(json_bytes) % 4) % 4
-    json_bytes += b" " * json_padding
-
-    json_chunk_length = len(json_bytes)
-    json_chunk_type = b"JSON"
-
-    # No binary chunks for simplicity
-    total_length = 12 + 8 + json_chunk_length + 8  # header + json chunk header + data + BIN padding
-
-    header = b"glTF"
-    header += int.to_bytes(2, 4, "little")  # version
-    header += int.to_bytes(total_length, 4, "little")  # total length
-
-    chunk_header = int.to_bytes(json_chunk_length, 4, "little")
-    chunk_header += json_chunk_type
-
-    # Add a BIN chunk with zero length to pad
-    bin_chunk_length = 0
-    bin_chunk_type = b"BIN"
-    bin_padding = (4 - bin_chunk_length % 4) % 4
-
-    return (
-        header
-        + chunk_header
-        + json_bytes
-        + bin_chunk_type
-        + int.to_bytes(bin_chunk_length, 4, "little")
-        + b" " * bin_padding
-    )
-
-
-# --- Tests: Extension validation ---
-
-
-class TestImportGltfExtensionValidation:
-    """Test that only .gltf and .glb files are accepted."""
-
-    def test_rejects_non_gltf_extension(self, client):
-        """Files without .gltf or .glb extension return 400."""
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("test.png", b"fake png data", "image/png")},
-        )
-        assert response.status_code == 400
-        assert ".gltf" in response.json()["detail"].lower() or ".glb" in response.json()["detail"].lower()
-
-    def test_rejects_txt_extension(self, client):
-        """A .txt file is rejected."""
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("model.txt", b"not a gltf", "text/plain")},
-        )
-        assert response.status_code == 400
-
-
-# --- Tests: .gltf validation ---
-
-
-class TestImportGltfJsonValidation:
-    """Test validation of .gltf (JSON) files."""
-
-    def test_valid_minimal_gltf(self, client):
-        """A minimal valid .gltf is accepted."""
-        data = make_gltf_json(vertex_count=24, materials=2, animations=1)
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("model.gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 201
-        body = response.json()
-        assert body["asset_type"] == "model_gltf"
-        assert body["file_size"] == len(json_bytes)
-        assert body["mime_type"] == "model/gltf+json"
-        metadata = json.loads(body["metadata_json"])
-        assert metadata["vertex_count"] == 24
-        assert metadata["material_count"] == 2
-        assert metadata["has_animation"] is True
-
-    def test_rejects_invalid_json(self, client):
-        """Malformed JSON returns 400."""
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("bad.gltf", b"{not valid json", "model/gltf+json")},
-        )
-        assert response.status_code == 400
-        assert "Invalid JSON" in response.json()["detail"]
-
-    def test_rejects_gltf_missing_asset(self, client):
-        """glTF without 'asset' property returns 400."""
-        data = {"scenes": [{}]}
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("no_asset.gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 400
-        assert "Missing required 'asset'" in response.json()["detail"]
-
-    def test_rejects_gltf_no_meshes_scenes_nodes(self, client):
-        """glTF with neither scenes, meshes, nor nodes returns 400."""
-        data = {"asset": {"version": "2.0"}, "materials": []}
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("empty.gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 400
-        assert "scenes, meshes, or nodes" in response.json()["detail"]
-
-
-# --- Tests: .glb validation ---
-
-
-class TestImportGlbValidation:
-    """Test validation of .glb (binary) files."""
-
-    def test_valid_minimal_glb(self, client):
-        """A minimal valid .glb is accepted."""
-        data = make_gltf_json(vertex_count=12, materials=1)
-        glb_bytes = make_glb(data)
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("model.glb", glb_bytes, "model/gltf+binary")},
-        )
-        assert response.status_code == 201
-        body = response.json()
-        assert body["asset_type"] == "model_gltf"
-        assert body["file_size"] == len(glb_bytes)
-        assert body["mime_type"] == "model/gltf+binary"
-        metadata = json.loads(body["metadata_json"])
-        assert metadata["vertex_count"] == 12
-        assert metadata["material_count"] == 1
-
-    def test_rejects_invalid_magic_bytes(self, client):
-        """File not starting with 'glTF' magic returns 400."""
-        bad_glb = b"xxxx" + int.to_bytes(2, 4, "little") + int.to_bytes(16, 4, "little")
-        bad_glb += int.to_bytes(4, 4, "little") + b"JSON" + b"{}" + b"BIN" + int.to_bytes(0, 4, "little")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("bad.glb", bad_glb, "model/gltf+binary")},
-        )
-        assert response.status_code == 400
-        assert "magic" in response.json()["detail"].lower()
-
-    def test_rejects_wrong_version(self, client):
-        """glTF version 1 returns 400."""
-        data = {"asset": {"version": "1.0"}}
-        json_bytes = json.dumps(data).encode("utf-8")
-        json_padding = (4 - len(json_bytes) % 4) % 4
-        json_bytes += b" " * json_padding
-        json_len = len(json_bytes)
-
-        header = b"glTF" + int.to_bytes(1, 4, "little") + int.to_bytes(12 + 8 + json_len + 8, 4, "little")
-        chunk = int.to_bytes(json_len, 4, "little") + b"JSON"
-        bin_pad = b"BIN" + int.to_bytes(0, 4, "little")
-
-        glb_bytes = header + chunk + json_bytes + bin_pad
-
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("v1.glb", glb_bytes, "model/gltf+binary")},
-        )
-        assert response.status_code == 400
-        assert "Unsupported glTF version" in response.json()["detail"]
-
-    def test_rejects_too_short(self, client):
-        """A file shorter than 12 bytes returns 400."""
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("tiny.glb", b"glTF123", "model/gltf+binary")},
-        )
-        assert response.status_code == 400
-        assert "too short" in response.json()["detail"].lower()
-
-
-# --- Tests: File size validation ---
-
-
-class TestImportGltfFileSize:
-    """Test file size limits."""
-
-    def test_rejects_oversized_file(self, client):
-        """Files exceeding MAX_UPLOAD_SIZE_MB return 413."""
-        # Create a file larger than the default 100 MB limit
-        large_content = b"X" * (settings.MAX_UPLOAD_SIZE_MB * 1024 * 1024 + 1)
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("big.gltf", large_content, "model/gltf+json")},
-        )
-        assert response.status_code == 413
-        assert "exceeds maximum" in response.json()["detail"].lower()
-
-
-# --- Tests: Metadata extraction ---
-
-
-class TestMetadataExtraction:
-    """Test that metadata is correctly extracted from glTF data."""
-
-    def test_vertex_count_from_meshes(self, client):
-        """Vertex count is extracted from mesh primitives."""
-        data = make_gltf_json(vertex_count=100, materials=0, animations=0)
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("model.gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 201
-        metadata = json.loads(response.json()["metadata_json"])
-        assert metadata["vertex_count"] == 100
-
-    def test_material_count(self, client):
-        """Material count is extracted from materials array."""
-        data = make_gltf_json(materials=5, vertex_count=0)
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("model.gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 201
-        metadata = json.loads(response.json()["metadata_json"])
-        assert metadata["material_count"] == 5
-
-    def test_has_animation_flag(self, client):
-        """has_animation is True when animations exist."""
-        data = make_gltf_json(animations=3, vertex_count=0)
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("model.gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 201
-        metadata = json.loads(response.json()["metadata_json"])
-        assert metadata["has_animation"] is True
-
-    def test_no_animation_flag(self, client):
-        """has_animation is False when no animations exist."""
-        data = make_gltf_json(animations=0, vertex_count=0)
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("model.gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 201
-        metadata = json.loads(response.json()["metadata_json"])
-        assert metadata["has_animation"] is False
-
-    def test_bounding_box_extraction(self, client):
-        """Bounding box is extracted from accessor min/max."""
-        data = make_gltf_json(vertex_count=8, has_bounds=True)
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("model.gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 201
-        metadata = json.loads(response.json()["metadata_json"])
-        assert metadata["bounding_box"] is not None
-        assert "min" in metadata["bounding_box"]
-        assert "max" in metadata["bounding_box"]
-
-    def test_no_bounding_box_without_accessor_bounds(self, client):
-        """Bounding box is None when accessor has no min/max."""
-        data = make_gltf_json(vertex_count=8, has_bounds=False)
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("model.gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 201
-        metadata = json.loads(response.json()["metadata_json"])
-        assert metadata["bounding_box"] is None
-
-
-# --- Tests: Database persistence ---
-
-
-class TestDatabasePersistence:
-    """Test that assets are correctly stored in the database."""
-
-    def test_asset_created_in_db(self, client, db_session, test_user):
-        """An asset record is created in the database."""
-        data = make_gltf_json(vertex_count=10)
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("model.gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 201
-
-        # Verify in database
-        result = db_session.execute(select(Asset).where(Asset.id == response.json()["id"]))
-        asset = result.scalar_one_or_none()
-        assert asset is not None
-        assert asset.asset_type == AssetType.MODEL_GLTF
-        assert asset.owner_id == test_user.id
-        assert asset.file_size == len(json_bytes)
-        assert asset.metadata_json is not None
-
-    def test_file_stored_on_disk(self, client, db_session, test_user):
-        """The file is stored in the upload directory."""
-        data = make_gltf_json(vertex_count=10)
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("model.gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 201
-
-        asset_id = response.json()["id"]
-        upload_dir = Path(settings.UPLOAD_DIR)
-        # The stored file should exist
-        found = False
-        for f in upload_dir.iterdir():
-            if f.name.startswith(f"{asset_id}_"):
-                found = True
-                assert f.read_bytes() == json_bytes
-                break
-        assert found, f"File not found in {upload_dir}"
-
-
-# --- Tests: Filename sanitization ---
-
-
-class TestFilenameSanitization:
-    """Test that filenames are properly sanitized."""
-
-    def test_sanitizes_special_chars(self, client):
-        """Special characters in filename are stripped."""
-        data = make_gltf_json(vertex_count=10)
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("my model (1).gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 201
-        # The name should be the stem without special chars
-        assert response.json()["name"] == "my model 1"
-
-    def test_preserves_extension(self, client):
-        """The .gltf extension is preserved in the stored file."""
-        data = make_gltf_json(vertex_count=10)
-        json_bytes = json.dumps(data).encode("utf-8")
-        response = client.post(
-            "/api/assets/import-gltf",
-            files={"file": ("model.gltf", json_bytes, "model/gltf+json")},
-        )
-        assert response.status_code == 201
-        upload_dir = Path(settings.UPLOAD_DIR)
-        for f in upload_dir.iterdir():
-            if f.name.endswith(".gltf"):
-                assert f.read_bytes() == json_bytes
-                break

backend/tests/test_gltf_metadata.py

@@ -0,0 +1,220 @@
+"""Tests for the lightweight glTF metadata extraction service."""
+
+import json
+import struct
+import pytest
+
+from app.services.gltf import (
+    extract_gltf_metadata,
+    looks_like_gltf,
+    _parse_glb,
+    _parse_gltf_json,
+)
+
+
+# ---------------------------------------------------------------------------
+# Test data helpers
+# ---------------------------------------------------------------------------
+
+def _make_gltf_json(
+    meshes: int = 1,
+    vertices_per_mesh: int = 24,
+    has_animations: bool = False,
+    images: list[dict] | None = None,
+) -> dict:
+    """Build a minimal glTF JSON structure."""
+    accessors = []
+    meshes_data = []
+    for i in range(meshes):
+        acc_index = len(accessors)
+        accessors.append({
+            "bufferView": 0,
+            "componentType": 5126,  # FLOAT
+            "count": vertices_per_mesh,
+            "type": "VEC3",
+            "max": [1.0, 1.0, 1.0],
+            "min": [-1.0, -1.0, -1.0],
+        })
+        meshes_data.append({
+            "primitives": [{
+                "attributes": {"POSITION": acc_index},
+            }],
+        })
+    gltf = {
+        "asset": {"version": "2.0"},
+        "accessors": accessors,
+        "meshes": meshes_data,
+    }
+    if has_animations:
+        gltf["animations"] = [{"name": "anim1", "channels": [], "samplers": []}]
+    if images:
+        gltf["images"] = images
+    return gltf
+
+
+def _make_glb(gltf_json: dict) -> bytes:
+    """Wrap *gltf_json* in a minimal GLB binary container."""
+    json_bytes = json.dumps(gltf_json).encode("utf-8")
+    json_length = len(json_bytes)
+    # Pad JSON chunk to 4-byte boundary.
+    json_padding = (4 - json_length % 4) % 4
+    json_chunk = json_bytes + b"\x00" * json_padding
+    json_chunk_type = 0x4E4F534A  # "JSON"
+    # No BIN chunk.
+    bin_length = 0
+    bin_chunk_type = 0x004E4942
+    total_length = 12 + 8 + len(json_chunk) + 8 + bin_length
+    header = struct.pack("<III", 0x46546C67, 2, total_length)  # magic, version, length
+    json_header = struct.pack("<II", len(json_chunk), json_chunk_type)
+    if bin_length > 0:
+        bin_header = struct.pack("<II", bin_length, bin_chunk_type)
+    else:
+        bin_header = b""
+    return header + json_header + json_chunk + bin_header
+
+
+# ---------------------------------------------------------------------------
+# looks_like_gltf
+# ---------------------------------------------------------------------------
+
+class TestLooksLikeGltf:
+    def test_glb_magic(self):
+        assert looks_like_gltf(b"glTF\x00\x00\x00\x00") is True
+
+    def test_gltf_extension(self):
+        assert looks_like_gltf(b'{"asset":{"version":"2.0"}}', "model.gltf") is True
+
+    def test_glb_extension(self):
+        assert looks_like_gltf(b"some binary", "model.glb") is True
+
+    def test_json_with_asset_version(self):
+        payload = json.dumps({"asset": {"version": "2.0"}}).encode()
+        assert looks_like_gltf(payload) is True
+
+    def test_plain_json_no_asset(self):
+        payload = json.dumps({"foo": "bar"}).encode()
+        assert looks_like_gltf(payload) is False
+
+    def test_non_json_bytes(self):
+        assert looks_like_gltf(b"\x89PNG\r\n\x1a\n") is False
+
+
+# ---------------------------------------------------------------------------
+# _parse_glb
+# ---------------------------------------------------------------------------
+
+class TestParseGlb:
+    def test_parses_valid_glb(self):
+        gltf_json = _make_gltf_json()
+        glb = _make_glb(gltf_json)
+        result = _parse_glb(glb)
+        assert result["asset"]["version"] == "2.0"
+        assert len(result["meshes"]) == 1
+
+    def test_rejects_too_short(self):
+        with pytest.raises(ValueError, match="too short"):
+            _parse_glb(b"glTF\x00\x00")
+
+    def test_rejects_invalid_magic(self):
+        with pytest.raises(ValueError, match="invalid GLB magic"):
+            _parse_glb(b"NOTglTF\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00")
+
+
+# ---------------------------------------------------------------------------
+# _parse_gltf_json
+# ---------------------------------------------------------------------------
+
+class TestParseGltfJson:
+    def test_parses_valid_gltf(self):
+        gltf_json = _make_gltf_json()
+        result = _parse_gltf_json(json.dumps(gltf_json).encode())
+        assert result["asset"]["version"] == "2.0"
+
+    def test_rejects_non_object(self):
+        with pytest.raises(ValueError, match="root must be an object"):
+            _parse_gltf_json(b"[1, 2, 3]")
+
+
+# ---------------------------------------------------------------------------
+# extract_gltf_metadata  (GLB path)
+# ---------------------------------------------------------------------------
+
+class TestExtractGltfMetadataGlb:
+    def test_basic_glb(self):
+        gltf_json = _make_gltf_json(meshes=1, vertices_per_mesh=24)
+        glb = _make_glb(gltf_json)
+        meta = extract_gltf_metadata(glb)
+        assert meta["mesh_count"] == 1
+        assert meta["vertex_count"] == 24
+        assert meta["has_animation"] is False
+        assert meta["bounding_box_min"] == [-1.0, -1.0, -1.0]
+        assert meta["bounding_box_max"] == [1.0, 1.0, 1.0]
+        assert meta["texture_refs"] == []
+
+    def test_multiple_meshes(self):
+        gltf_json = _make_gltf_json(meshes=3, vertices_per_mesh=12)
+        glb = _make_glb(gltf_json)
+        meta = extract_gltf_metadata(glb)
+        assert meta["mesh_count"] == 3
+        assert meta["vertex_count"] == 36
+
+    def test_with_animation(self):
+        gltf_json = _make_gltf_json(has_animations=True)
+        glb = _make_glb(gltf_json)
+        meta = extract_gltf_metadata(glb)
+        assert meta["has_animation"] is True
+
+    def test_with_external_texture(self):
+        gltf_json = _make_gltf_json(images=[{"uri": "textures/rock.png"}])
+        glb = _make_glb(gltf_json)
+        meta = extract_gltf_metadata(glb)
+        assert meta["texture_refs"] == ["textures/rock.png"]
+
+    def test_with_named_texture(self):
+        gltf_json = _make_gltf_json(images=[{"name": "my_texture"}])
+        glb = _make_glb(gltf_json)
+        meta = extract_gltf_metadata(glb)
+        assert meta["texture_refs"] == ["my_texture"]
+
+    def test_empty_meshes(self):
+        gltf_json = _make_gltf_json(meshes=0)
+        glb = _make_glb(gltf_json)
+        meta = extract_gltf_metadata(glb)
+        assert meta["mesh_count"] == 0
+        assert meta["vertex_count"] == 0
+        assert meta["bounding_box_min"] == [0.0, 0.0, 0.0]
+        assert meta["bounding_box_max"] == [0.0, 0.0, 0.0]
+
+
+# ---------------------------------------------------------------------------
+# extract_gltf_metadata  (plain .gltf JSON path)
+# ---------------------------------------------------------------------------
+
+class TestExtractGltfMetadataGltfJson:
+    def test_plain_gltf(self):
+        gltf_json = _make_gltf_json(meshes=2, vertices_per_mesh=8)
+        raw = json.dumps(gltf_json).encode()
+        meta = extract_gltf_metadata(raw)
+        assert meta["mesh_count"] == 2
+        assert meta["vertex_count"] == 16
+        assert meta["has_animation"] is False
+
+    def test_plain_gltf_with_animation(self):
+        gltf_json = _make_gltf_json(has_animations=True)
+        raw = json.dumps(gltf_json).encode()
+        meta = extract_gltf_metadata(raw)
+        assert meta["has_animation"] is True
+
+
+# ---------------------------------------------------------------------------
+# Error handling
+# ---------------------------------------------------------------------------
+
+class TestExtractGltfMetadataErrors:
+    def test_invalid_glb(self):
+        with pytest.raises(ValueError):
+            extract_gltf_metadata(b"not a glb")
+
+    def test_invalid_gltf_json(self):
+        with pytest.raises(ValueError):
+            _parse_gltf_json(b"[1, 2, 3]")

docs/planning/client-server-wiring.md

@@ -0,0 +1,37 @@
+# MVP Vertical Slice: Client-Server Wiring — Plan
+
+## Goal
+Prove the real Godot client and the real backend can talk: **a user can register/log in
+and see a list of worlds from the game client**. Nothing more. Gameplay, join-a-world,
+chat, avatar, Discovery search/tags/trending, Social/Economy/Trust & Safety are all
+explicitly out of scope.
+
+## Verified backend contract (as of this writing)
+- `POST /api/auth/register` — JSON body `{username, email, password, date_of_birth}`.
+  `date_of_birth` is a `YYYY-MM-DD` string. Returns `201 {access_token, token_type}`.
+  Rejects under-18 with `400`.
+- `POST /api/auth/login` — OAuth2 **form-encoded** (`application/x-www-form-urlencoded`)
+  `username` + `password` (this is NOT a JSON endpoint). Returns `{access_token, token_type}`.
+- `GET /api/worlds` — **requires auth** (`CurrentUser`), returns a JSON array of
+  `{id, name, description, visibility, owner_id, created_at}`. There is no unauthenticated
+  public-worlds path, so the worlds list screen can only be shown after login/register.
+- `GET /api/health` — unauthenticated, `{status, app}`.
+- Base URL: uvicorn default `http://127.0.0.1:8000` (must be configurable in the client).
+- CORS is irrelevant to the native Godot `HTTPRequest` client (no browser origin).
+
+## Task breakdown
+| # | Type | Task | Depends on |
+|---|------|------|-----------|
+| 1 | architecture | `ApiClient` autoload: HTTP + JWT storage + error contract | — |
+| 2 | implementation | Main-menu **login** wiring (form-encoded) | 1 |
+| 3 | implementation | Main-menu **register** wiring (JSON + age gate) | 2 |
+| 4 | implementation | **World list** screen consuming `GET /api/worlds` | 2 |
+| 5 | testing | End-to-end headless smoke test + manual verify | 1,3,4 |
+
+## Design decisions captured (resolved in task 1)
+- Token storage: in-memory singleton property for the MVP; a `save_to_disk` seam is left
+  open but not required yet (no re-login on restart in this slice).
+- Error contract: every call returns a discriminated result (`ok`/`error`) so callers
+  never crash on network failure; non-2xx surfaces `{status, detail}` from the backend.
+- Base URL: read from a ProjectSetting, defaulting to `http://127.0.0.1:8000`.
+- Login is form-encoded; register is JSON — the client helper must support both content types.

scripts/api_client.gd.uid

@@ -0,0 +1 @@
+uid://cjd0uhll7iylj

scripts/main_menu.gd.uid

@@ -0,0 +1 @@
+uid://bgnc3iamfgf6k