Fix latent client-side encode_binary bounds min+size/min+max bug (nonzero position)

Found during review of the persistence-plumbing branch: _build_metadata_section
wrote raw bounds.size into the wire's 2nd float triple, but the wire format
(and _parse_metadata_section) treats that triple as max_pos, computing
size = max - min. AABB(Vector3.ZERO, size) masks this since size == max when
position is 0 -- exactly what every existing test used. Any chunk at a real,
nonzero world position would silently corrupt on its own client-local
encode/decode round-trip. Same bug class as the backend's min+size/min+max
mismatch fixed in chunk_codec.py (eb39e43), just on the client side this
time. Added a regression case to smoke_test_chunk_codec_interop.gd using a
real nonzero chunk position (96,-32,0) -- 33/33 passing. Full sibling smoke
suite re-verified clean afterward.

assets/scripting/behaviors/demo_chest.json

@@ -0,0 +1,17 @@
+{
+  "content_flags": {
+    "violence": "none",
+    "mature": false
+  },
+  "rules": [
+    {
+      "trigger": {"type": "on_interact"},
+      "conditions": [],
+      "actions": [
+        {"verb": "give_item", "item_id": "gold_coin", "count": 3},
+        {"verb": "play_sound", "sound_id": "chest_open"},
+        {"verb": "rotate", "target": "self", "degrees": 90, "axis": "y", "duration": 0.4}
+      ]
+    }
+  ]
+}

assets/scripting/spawn_catalog.json

@@ -0,0 +1,8 @@
+{
+  "templates": {
+    "small_crate": {
+      "asset_id": "props/crate_small.glb",
+      "display_name": "Small Crate"
+    }
+  }
+}

backend/alembic/env.py

@@ -8,7 +8,7 @@ from sqlalchemy.ext.asyncio import create_async_engine
 
 from app.config import settings
 from app.database import Base
-from app.models import user, session, world, asset, avatar_loadout  # noqa: F401
+from app.models import user, session, world, asset, avatar_loadout, world_content  # noqa: F401
 
 # this is the Alembic Config object, which provides
 # access to the values within the .ini file in use.

backend/alembic/versions/0005_add_world_content_tables.py

@@ -0,0 +1,120 @@
+"""add world_rooms, world_chunks, world_chunk_revisions tables
+
+Revision ID: 0005_add_world_content_tables
+Revises: 0004_add_avatar_loadouts_table
+Create Date: 2026-09-14 00:00:00.000000
+
+See docs/architecture/world_persistence_impl.md §4. Chunk content
+(rooms, chunk payloads, chunk revisions) lives in Postgres, purely
+additive to the existing ``worlds`` table.
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+# revision identifiers, used by Alembic.
+revision: str = "0005_add_world_content_tables"
+down_revision: Union[str, None] = "0004_add_avatar_loadouts_table"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.create_table(
+        "world_rooms",
+        sa.Column("id", sa.Integer(), primary_key=True, index=True),
+        sa.Column(
+            "world_id", sa.Integer(),
+            sa.ForeignKey("worlds.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column("slug", sa.String(64), nullable=False),
+        sa.Column("name", sa.String(255), nullable=False),
+        sa.Column(
+            "grid", postgresql.JSONB(), nullable=False,
+            server_default='{"size": [32, 32, 1], "origin": [0, 0, 0]}',
+        ),
+        sa.Column("bounds", postgresql.JSONB(), nullable=True),
+        sa.Column("spawn", postgresql.JSONB(), nullable=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+        sa.Column(
+            "updated_at", sa.DateTime(timezone=True),
+            server_default=sa.func.now(), nullable=False,
+        ),
+        sa.UniqueConstraint("world_id", "slug", name="uq_world_rooms_world_slug"),
+    )
+    op.create_index("ix_world_rooms_world_id", "world_rooms", ["world_id"])
+
+    op.create_table(
+        "world_chunks",
+        sa.Column("id", sa.Integer(), primary_key=True, index=True),
+        sa.Column(
+            "world_id", sa.Integer(),
+            sa.ForeignKey("worlds.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column(
+            "room_id", sa.Integer(),
+            sa.ForeignKey("world_rooms.id", ondelete="CASCADE"),
+            nullable=False,
+        ),
+        sa.Column("chunk_key", sa.String(160), nullable=False, unique=True),
+        sa.Column("cx", sa.Integer(), nullable=False),
+        sa.Column("cy", sa.Integer(), nullable=False),
+        sa.Column("cz", sa.Integer(), nullable=False, server_default="0"),
+        sa.Column("format_version", sa.Integer(), nullable=False, server_default="1"),
+        sa.Column("payload", sa.LargeBinary(), nullable=False),
+        sa.Column("payload_len", sa.Integer(), nullable=False),
+        sa.Column("checksum", sa.String(64), nullable=False),
+        sa.Column("revision", sa.Integer(), nullable=False, server_default="1"),
+        sa.Column("content_flags", postgresql.JSONB(), nullable=False, server_default="{}"),
+        sa.Column("is_mature", sa.Boolean(), nullable=False, server_default="false"),
+        sa.Column(
+            "updated_by_id", sa.Integer(),
+            sa.ForeignKey("users.id", ondelete="SET NULL"),
+            nullable=True,
+        ),
+        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+        sa.Column(
+            "updated_at", sa.DateTime(timezone=True),
+            server_default=sa.func.now(), nullable=False,
+        ),
+        sa.UniqueConstraint("room_id", "cx", "cy", "cz", name="uq_world_chunks_coord"),
+    )
+    op.create_index("ix_world_chunks_world_id", "world_chunks", ["world_id"])
+    op.create_index("ix_world_chunks_room_id", "world_chunks", ["room_id"])
+    op.create_index(
+        "ix_world_chunks_room_coord", "world_chunks", ["room_id", "cx", "cy", "cz"],
+    )
+    op.create_index(
+        "ix_world_chunks_mature", "world_chunks", ["world_id"],
+        postgresql_where=sa.text("is_mature"),
+    )
+
+    op.create_table(
+        "world_chunk_revisions",
+        sa.Column("id", sa.Integer(), primary_key=True, index=True),
+        sa.Column("chunk_key", sa.String(160), nullable=False),
+        sa.Column("world_id", sa.Integer(), nullable=False),
+        sa.Column("revision", sa.Integer(), nullable=False),
+        sa.Column("action", sa.String(16), nullable=False),
+        sa.Column(
+            "actor_id", sa.Integer(),
+            sa.ForeignKey("users.id", ondelete="SET NULL"),
+            nullable=True,
+        ),
+        sa.Column("checksum", sa.String(64), nullable=False),
+        sa.Column("payload", sa.LargeBinary(), nullable=True),
+        sa.Column("created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False),
+    )
+    op.create_index("ix_world_chunk_revisions_chunk_key", "world_chunk_revisions", ["chunk_key"])
+    op.create_index("ix_world_chunk_revisions_world_id", "world_chunk_revisions", ["world_id"])
+    op.create_index("ix_world_chunk_revisions_created_at", "world_chunk_revisions", ["created_at"])
+
+
+def downgrade() -> None:
+    op.drop_table("world_chunk_revisions")
+    op.drop_table("world_chunks")
+    op.drop_table("world_rooms")

backend/app/config.py

@@ -104,6 +104,22 @@ class Settings(BaseSettings):
     # Kill a world's server this long after its last join with no active
     # players reported.
     GAME_SERVER_IDLE_TIMEOUT_SECONDS: int = 300
+    # How long ensure_server() waits for a spawned server to report
+    # "ready": true in its status file before giving up (503 to the
+    # joining client). See world_persistence_impl.md §7.4 -- content
+    # loading makes a slow start more likely than the old bare-port-bind
+    # wait, so this is a separate, longer-by-default budget.
+    GAME_SERVER_READY_TIMEOUT_SECONDS: float = 20.0
+    # The base URL the dedicated Godot server should call back into this
+    # backend on, for the read-only /api/internal content routes
+    # (world_persistence_impl.md §4.4 / §7).
+    GAME_SERVER_INTERNAL_API_URL: str = "http://127.0.0.1:8000"
+
+    # ── World content persistence (world_persistence_impl.md §4.4) ─────────
+    WORLD_CHUNK_MAX_PAYLOAD_BYTES: int = 1_048_576  # 1 MiB
+    WORLD_CHUNK_MAX_OBJECTS: int = 512
+    WORLD_CHUNK_MAX_BATCH: int = 64
+    WORLD_CHUNK_REVISION_KEEP: int = 20
 
     model_config = SettingsConfigDict(
         env_file=".env",

backend/app/main.py

@@ -6,7 +6,7 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 
 from app.config import settings
-from app.routers import auth, users, worlds, assets, avatar
+from app.routers import auth, users, worlds, assets, avatar, world_content, internal
 
 
 from app.services.game_servers import supervisor
@@ -40,8 +40,10 @@ app.add_middleware(
 app.include_router(auth.router, prefix="/api/auth", tags=["auth"])
 app.include_router(users.router, prefix="/api/users", tags=["users"])
 app.include_router(worlds.router, prefix="/api/worlds", tags=["worlds"])
+app.include_router(world_content.router, prefix="/api/worlds", tags=["world-content"])
 app.include_router(assets.router, prefix="/api/assets", tags=["assets"])
 app.include_router(avatar.router, prefix="/api/avatar", tags=["avatar"])
+app.include_router(internal.router, prefix="/api/internal", tags=["internal"])
 
 
 @app.get("/api/health")

backend/app/models/__init__.py

@@ -3,5 +3,9 @@ from app.models.session import Session
 from app.models.world import World
 from app.models.asset import Asset
 from app.models.avatar_loadout import AvatarLoadout
+from app.models.world_content import WorldRoom, WorldChunk, WorldChunkRevision
 
-__all__ = ["User", "Session", "World", "Asset", "AvatarLoadout"]
+__all__ = [
+    "User", "Session", "World", "Asset", "AvatarLoadout",
+    "WorldRoom", "WorldChunk", "WorldChunkRevision",
+]

backend/app/models/world.py

@@ -34,3 +34,6 @@ class World(Base):
 
     owner = relationship("User", back_populates="worlds")
     assets = relationship("Asset", back_populates="world", cascade="all, delete-orphan")
+    # world_content.py / world_persistence_impl.md §4.1. Added here (only)
+    # so PC1/PC2 code depending on this module is otherwise untouched.
+    rooms = relationship("WorldRoom", back_populates="world", cascade="all, delete-orphan")

backend/app/models/world_content.py

@@ -0,0 +1,153 @@
+"""World content persistence models.
+
+Implements the schema decided in ``docs/architecture/world_persistence_impl.md``
+§4: chunk content (rooms, chunk payloads, chunk revisions) lives in Postgres,
+alongside ``worlds``, rather than in a per-world SQLite file
+(``docs/architecture/world.md`` §4, superseded).
+
+The chunk *payload* format itself (the 48-byte header + sectioned binary
+body) is unchanged from ``world.md`` §3.6 and is decoded/encoded by
+``app.services.chunk_codec``, not by these models -- these just store the
+opaque ``BYTEA``.
+
+Conventions follow the existing models (``app/models/world.py``,
+``app/models/avatar_loadout.py``): declarative ``Column(...)`` style,
+``Integer`` surrogate PKs, ``DateTime(timezone=True)`` with
+``server_default=func.now()``, JSONB for document-shaped fields.
+"""
+
+from sqlalchemy import (
+    Boolean,
+    Column,
+    DateTime,
+    ForeignKey,
+    Index,
+    Integer,
+    LargeBinary,
+    String,
+    UniqueConstraint,
+    text,
+)
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import relationship
+from sqlalchemy.sql import func
+
+from app.database import Base
+
+# Default chunk grid, matching Chunk.CHUNK_SIZE_* in scripts/chunk.gd (the
+# client's source of truth for the same constants) and world.md §2.2.
+DEFAULT_ROOM_GRID: dict = {"size": [32, 32, 1], "origin": [0, 0, 0]}
+
+# The room every world gets automatically (world_persistence_impl.md §4.1).
+MAIN_ROOM_SLUG = "main"
+MAIN_ROOM_NAME = "Main"
+
+
+class WorldRoom(Base):
+    """A bounded region within a world -- a level, building, or zone
+    (world.md §2.1). Holds the chunk grid config so a world can later hold
+    rooms with different grids without touching the ``worlds`` table.
+    """
+
+    __tablename__ = "world_rooms"
+
+    id = Column(Integer, primary_key=True, index=True)
+    world_id = Column(
+        Integer, ForeignKey("worlds.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+    slug = Column(String(64), nullable=False)  # url-safe; "main" by default
+    name = Column(String(255), nullable=False)
+    # {"size": [x, y, z], "origin": [x, y, z]}
+    grid = Column(
+        JSONB, nullable=False,
+        server_default='{"size": [32, 32, 1], "origin": [0, 0, 0]}',
+    )
+    bounds = Column(JSONB, nullable=True)  # {"min":[x,y,z], "max":[x,y,z]}; null = unbounded
+    spawn = Column(JSONB, nullable=True)  # {"pos":[x,y,z], "yaw": 0.0}
+    created_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=False)
+    updated_at = Column(
+        DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False
+    )
+
+    __table_args__ = (
+        UniqueConstraint("world_id", "slug", name="uq_world_rooms_world_slug"),
+    )
+
+    world = relationship("World", back_populates="rooms")
+    chunks = relationship("WorldChunk", back_populates="room", cascade="all, delete-orphan")
+
+
+class WorldChunk(Base):
+    """One chunk's persisted content -- the atomic load/save/stream unit
+    (world.md §2.1). ``payload`` is the world.md §3.6 binary blob, stored
+    verbatim as BYTEA.
+
+    Deltas from world.md §4.4 (SQLite design): a surrogate integer PK +
+    unique coordinate constraint (rather than ``chunk_key`` as the PK), no
+    ``dirty`` column (write-behind doesn't apply over Postgres -- see
+    world_persistence_impl.md §3.3/§5), and content flags folded into this
+    row as JSONB + an indexed ``is_mature`` boolean rather than a separate
+    ``content_flags`` table (world.md §4.6).
+    """
+
+    __tablename__ = "world_chunks"
+
+    id = Column(Integer, primary_key=True, index=True)
+    world_id = Column(
+        Integer, ForeignKey("worlds.id", ondelete="CASCADE"), nullable=False, index=True
+    )  # denormalized: world-scoped queries without a join through rooms
+    room_id = Column(
+        Integer, ForeignKey("world_rooms.id", ondelete="CASCADE"), nullable=False, index=True
+    )
+    chunk_key = Column(String(160), nullable=False, unique=True)  # world.md §2.3 / §4.5
+    cx = Column(Integer, nullable=False)
+    cy = Column(Integer, nullable=False)
+    cz = Column(Integer, nullable=False, server_default="0")
+
+    format_version = Column(Integer, nullable=False, server_default="1")
+    payload = Column(LargeBinary, nullable=False)  # world.md §3.6 bytes
+    payload_len = Column(Integer, nullable=False)
+    checksum = Column(String(64), nullable=False)  # SHA-256 hex of payload body
+    revision = Column(Integer, nullable=False, server_default="1")
+
+    content_flags = Column(JSONB, nullable=False, server_default="{}")  # world.md §3.4
+    is_mature = Column(Boolean, nullable=False, server_default="false")
+
+    updated_by_id = Column(Integer, ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=False)
+    updated_at = Column(
+        DateTime(timezone=True), server_default=func.now(), onupdate=func.now(), nullable=False
+    )
+
+    __table_args__ = (
+        UniqueConstraint("room_id", "cx", "cy", "cz", name="uq_world_chunks_coord"),
+        Index("ix_world_chunks_room_coord", "room_id", "cx", "cy", "cz"),
+        Index("ix_world_chunks_mature", "world_id", postgresql_where=text("is_mature")),
+    )
+
+    room = relationship("WorldRoom", back_populates="chunks")
+
+
+class WorldChunkRevision(Base):
+    """Audit trail of chunk writes (world.md §4.7). ``chunk_key``/``world_id``
+    are deliberately **not** foreign keys, so deleting a chunk or a world
+    preserves the audit trail.
+
+    Retention (world_persistence_impl.md §4.3, required): only the newest
+    ``settings.WORLD_CHUNK_REVISION_KEEP`` rows per ``chunk_key`` keep a
+    non-null ``payload``; older rows are pruned (payload nulled, metadata
+    row kept) by ``WorldStore`` in the same transaction as the write that
+    triggers it.
+    """
+
+    __tablename__ = "world_chunk_revisions"
+
+    id = Column(Integer, primary_key=True, index=True)
+    chunk_key = Column(String(160), nullable=False, index=True)
+    world_id = Column(Integer, nullable=False, index=True)
+    revision = Column(Integer, nullable=False)
+    action = Column(String(16), nullable=False)  # 'create' | 'update' | 'delete'
+    actor_id = Column(Integer, ForeignKey("users.id", ondelete="SET NULL"), nullable=True)
+    checksum = Column(String(64), nullable=False)
+    payload = Column(LargeBinary, nullable=True)  # full payload at this revision; nulled by retention
+    created_at = Column(DateTime(timezone=True), server_default=func.now(), nullable=False, index=True)

backend/app/routers/internal.py

@@ -0,0 +1,146 @@
+"""Internal, dedicated-server-only content API.
+
+Implements `docs/architecture/world_persistence_impl.md` §7 + §8.3. This is
+how a spawned Godot dedicated server (`scripts/server.gd`, spawned by
+`app.services.game_servers`) pulls its world's content read-only over HTTP
+before binding its ENet port. Mounted at ``/api/internal`` -- a prefix that
+can also be blocked at the reverse proxy, per the doc's rejected-alternative
+note in §7.3.
+
+Gated by ``require_game_server`` (§7.3): a bearer token minted per spawn by
+``GameServerSupervisor._spawn`` and checked against
+``supervisor.validate_token(world_id, token)``. There is no user identity
+here at all -- these routes skip the per-user visibility check public
+routes apply, and apply no mature-content gating (gating is a client/user
+concern; the dedicated server still needs the geometry for collision).
+
+Read-only by construction: there is no write route here, and adding one
+would violate world_persistence_impl.md D2 (the FastAPI backend is the
+only writer).
+"""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Header, HTTPException, Response
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.database import get_db
+from app.models.world import World
+from app.models.world_content import MAIN_ROOM_SLUG
+from app.services import chunk_codec
+from app.services.game_servers import supervisor
+from app.services.world_store import Bounds, WorldStore
+
+router = APIRouter()
+
+DbDep = Annotated[AsyncSession, Depends(get_db)]
+
+
+async def require_game_server(
+    world_id: int,
+    authorization: Annotated[str | None, Header()] = None,
+) -> None:
+    """world_persistence_impl.md §7.3. A path whose ``world_id`` differs
+    from the token's world is 403 -- ``validate_token`` enforces that by
+    construction (it looks the token up *by* ``world_id``)."""
+    if not authorization or not authorization.lower().startswith("bearer "):
+        raise HTTPException(status_code=401, detail="missing bearer token")
+    token = authorization.split(" ", 1)[1].strip()
+    if not token or not supervisor.validate_token(world_id, token):
+        raise HTTPException(status_code=403, detail="invalid or expired server token")
+
+
+async def _get_world_or_404(world_id: int, db: AsyncSession) -> World:
+    result = await db.execute(select(World).where(World.id == world_id))
+    world = result.scalar_one_or_none()
+    if world is None:
+        raise HTTPException(status_code=404, detail="World not found")
+    return world
+
+
+async def _resolve_room(store: WorldStore, db: AsyncSession, world_id: int, slug: str):
+    room = await store.get_room(world_id, slug)
+    if room is None and slug == MAIN_ROOM_SLUG:
+        room = await store.get_or_create_main_room(world_id)
+        await db.commit()
+    return room
+
+
+@router.get("/worlds/{world_id}/manifest", dependencies=[Depends(require_game_server)])
+async def manifest(world_id: int, db: DbDep):
+    await _get_world_or_404(world_id, db)
+    store = WorldStore(db)
+    rooms = await store.list_rooms(world_id)
+    if not rooms:
+        rooms = [await store.get_or_create_main_room(world_id)]
+        await db.commit()
+
+    room_payloads = []
+    for r in rooms:
+        room_payloads.append({
+            "slug": r.slug, "name": r.name, "grid": r.grid, "bounds": r.bounds,
+            "spawn": r.spawn, "chunk_count": await store.count_chunks(r.id),
+        })
+
+    return {
+        "world_id": world_id,
+        "content_revision": await store.content_revision(world_id),
+        "rooms": room_payloads,
+    }
+
+
+@router.get("/worlds/{world_id}/rooms/{slug}/chunks", dependencies=[Depends(require_game_server)])
+async def internal_list_chunks(
+    world_id: int, slug: str, db: DbDep,
+    cx_min: int | None = None, cx_max: int | None = None,
+    cy_min: int | None = None, cy_max: int | None = None,
+    cz: int | None = None,
+):
+    await _get_world_or_404(world_id, db)
+    store = WorldStore(db)
+    room = await _resolve_room(store, db, world_id, slug)
+    if room is None:
+        raise HTTPException(status_code=404, detail="room not found")
+
+    bounds = Bounds(cx_min=cx_min, cx_max=cx_max, cy_min=cy_min, cy_max=cy_max, cz=cz)
+    chunks = await store.list_chunks(world_id, room.id, bounds)
+    return {
+        "room": room.slug,
+        "content_revision": await store.content_revision(world_id),
+        "chunks": [
+            {
+                "key": c.chunk_key, "cx": c.cx, "cy": c.cy, "cz": c.cz,
+                "revision": c.revision, "checksum": c.checksum, "payload_len": c.payload_len,
+                "is_mature": c.is_mature,
+                "updated_at": c.updated_at.isoformat() if c.updated_at else None,
+            }
+            for c in chunks
+        ],
+    }
+
+
+@router.get(
+    "/worlds/{world_id}/rooms/{slug}/chunks/{cx}/{cy}/{cz}",
+    dependencies=[Depends(require_game_server)],
+)
+async def internal_get_chunk(world_id: int, slug: str, cx: int, cy: int, cz: int, db: DbDep):
+    await _get_world_or_404(world_id, db)
+    store = WorldStore(db)
+    room = await _resolve_room(store, db, world_id, slug)
+    if room is None:
+        raise HTTPException(status_code=404, detail="room not found")
+
+    key = chunk_codec.build_key(world_id, slug, cx, cy, cz)
+    chunk = await store.get_chunk(key)
+    if chunk is None:
+        raise HTTPException(status_code=404, detail="chunk not found")
+
+    return Response(
+        content=chunk.payload, media_type="application/octet-stream",
+        headers={
+            "ETag": f'"{chunk.checksum}"', "X-Chunk-Revision": str(chunk.revision), "X-Chunk-Key": key,
+        },
+    )

backend/app/routers/world_content.py

@@ -0,0 +1,451 @@
+"""World content router -- rooms + chunks, for the editor and player client.
+
+Implements `docs/architecture/world_persistence_impl.md` §8.1. JWT-authenticated
+(``CurrentUser``, same as ``app/routers/worlds.py``). All chunk content
+reads/writes go through ``WorldStore``; this module is HTTP plumbing +
+authorization only.
+
+Authorization (doc §5.3):
+ - **Read** (world visibility, room listing, chunk fetch/index/revisions):
+   same rule as ``GET /api/worlds/{id}`` -- 404 (not 403) if the world is
+   neither PUBLIC nor owned by the caller. See ``_get_world_readable``.
+ - **Write** (room create, chunk PUT/DELETE/rollback): caller must be
+   ``world.owner_id``, matching ``update_world`` -- 403 otherwise, with
+   *no* visibility gate (this deliberately mirrors ``update_world``, which
+   also has no visibility check; see ``_get_world_writable``).
+"""
+
+from __future__ import annotations
+
+import base64
+import binascii
+from typing import Annotated
+
+from fastapi import APIRouter, Depends, Header, HTTPException, Request, Response
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, Field
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from app.config import settings
+from app.database import get_db
+from app.dependencies import CurrentUser
+from app.models.user import User
+from app.models.world import World, WorldVisibility
+from app.models.world_content import MAIN_ROOM_SLUG, WorldRoom
+from app.services import chunk_codec
+from app.services.game_servers import supervisor
+from app.services.world_store import Bounds, RevisionConflict, RevisionNotAvailable, WorldStore
+
+router = APIRouter()
+
+DbDep = Annotated[AsyncSession, Depends(get_db)]
+
+# world_persistence_impl.md §8.1: "Bounds are capped (default 32x32 chunks
+# per query) and return 422 beyond that."
+MAX_BOUNDS_SPAN = 32
+# §8.1 batch write cap, beyond WORLD_CHUNK_MAX_BATCH chunks: "Capped at ...
+# 8 MB."
+MAX_BATCH_TOTAL_BYTES = 8 * 1024 * 1024
+
+
+# ─────────────────────────── auth helpers ───────────────────────────
+
+async def _get_world_readable(world_id: int, current_user: User, db: AsyncSession) -> World:
+    result = await db.execute(select(World).where(World.id == world_id))
+    world = result.scalar_one_or_none()
+    if world is None:
+        raise HTTPException(status_code=404, detail="World not found")
+    if world.visibility != WorldVisibility.PUBLIC and world.owner_id != current_user.id:
+        raise HTTPException(status_code=404, detail="World not found")
+    return world
+
+
+async def _get_world_writable(world_id: int, current_user: User, db: AsyncSession) -> World:
+    result = await db.execute(select(World).where(World.id == world_id))
+    world = result.scalar_one_or_none()
+    if world is None:
+        raise HTTPException(status_code=404, detail="World not found")
+    if world.owner_id != current_user.id:
+        raise HTTPException(status_code=403, detail="Not owner of this world")
+    return world
+
+
+async def _resolve_room(store: WorldStore, db: AsyncSession, world_id: int, slug: str) -> WorldRoom | None:
+    """world_persistence_impl.md §4.1: lazily create the main room for
+    worlds that predate this feature, on first read/write."""
+    room = await store.get_room(world_id, slug)
+    if room is None and slug == MAIN_ROOM_SLUG:
+        room = await store.get_or_create_main_room(world_id)
+        await db.commit()
+    return room
+
+
+def _is_live(world_id: int) -> bool:
+    return any(s["world_id"] == str(world_id) for s in supervisor.debug_state())
+
+
+def _validation_error_body(exc: chunk_codec.ChunkValidationError) -> dict:
+    return {"detail": "chunk validation failed", "reason": exc.reason}
+
+
+def _conflict_body(exc: RevisionConflict) -> dict:
+    body: dict = {
+        "detail": "revision conflict",
+        "current_revision": exc.current_revision,
+        "current_checksum": exc.current_checksum,
+    }
+    if exc.coord is not None:
+        body["coord"] = list(exc.coord)
+    return body
+
+
+# ─────────────────────────── schemas ───────────────────────────
+
+class RoomResponse(BaseModel):
+    id: int
+    slug: str
+    name: str
+    grid: dict
+    bounds: dict | None
+    spawn: dict | None
+    chunk_count: int
+
+
+class RoomCreate(BaseModel):
+    slug: str = Field(..., min_length=1, max_length=64, pattern=r"^[a-z0-9_-]+$")
+    name: str = Field(..., min_length=1, max_length=255)
+    grid: dict | None = None
+    bounds: dict | None = None
+    spawn: dict | None = None
+
+
+# ─────────────────────────── rooms ───────────────────────────
+
+@router.get("/{world_id}/rooms", response_model=list[RoomResponse])
+async def list_rooms(world_id: int, current_user: CurrentUser, db: DbDep):
+    await _get_world_readable(world_id, current_user, db)
+    store = WorldStore(db)
+    rooms = await store.list_rooms(world_id)
+    if not rooms:
+        rooms = [await store.get_or_create_main_room(world_id)]
+        await db.commit()
+    return [
+        RoomResponse(
+            id=r.id, slug=r.slug, name=r.name, grid=r.grid, bounds=r.bounds, spawn=r.spawn,
+            chunk_count=await store.count_chunks(r.id),
+        )
+        for r in rooms
+    ]
+
+
+@router.post("/{world_id}/rooms", response_model=RoomResponse, status_code=201)
+async def create_room(world_id: int, body: RoomCreate, current_user: CurrentUser, db: DbDep):
+    await _get_world_writable(world_id, current_user, db)
+    store = WorldStore(db)
+    if await store.get_room(world_id, body.slug) is not None:
+        raise HTTPException(status_code=409, detail="a room with this slug already exists")
+    room = await store.create_room(
+        world_id, body.slug, body.name, grid=body.grid, bounds=body.bounds, spawn=body.spawn
+    )
+    await db.commit()
+    await db.refresh(room)
+    return RoomResponse(
+        id=room.id, slug=room.slug, name=room.name, grid=room.grid,
+        bounds=room.bounds, spawn=room.spawn, chunk_count=0,
+    )
+
+
+# ─────────────────────────── chunk index ───────────────────────────
+
+@router.get("/{world_id}/rooms/{slug}/chunks")
+async def list_chunks(
+    world_id: int, slug: str, current_user: CurrentUser, db: DbDep,
+    cx_min: int | None = None, cx_max: int | None = None,
+    cy_min: int | None = None, cy_max: int | None = None,
+    cz: int | None = None,
+):
+    await _get_world_readable(world_id, current_user, db)
+    store = WorldStore(db)
+    room = await _resolve_room(store, db, world_id, slug)
+    if room is None:
+        raise HTTPException(status_code=404, detail="room not found")
+
+    if cx_min is not None and cx_max is not None and (cx_max - cx_min + 1) > MAX_BOUNDS_SPAN:
+        raise HTTPException(status_code=422, detail=f"cx bounds span exceeds {MAX_BOUNDS_SPAN}")
+    if cy_min is not None and cy_max is not None and (cy_max - cy_min + 1) > MAX_BOUNDS_SPAN:
+        raise HTTPException(status_code=422, detail=f"cy bounds span exceeds {MAX_BOUNDS_SPAN}")
+
+    bounds = Bounds(cx_min=cx_min, cx_max=cx_max, cy_min=cy_min, cy_max=cy_max, cz=cz)
+    chunks = await store.list_chunks(world_id, room.id, bounds)
+    content_revision = await store.content_revision(world_id)
+    return {
+        "room": room.slug,
+        "content_revision": content_revision,
+        "chunks": [
+            {
+                "key": c.chunk_key, "cx": c.cx, "cy": c.cy, "cz": c.cz,
+                "revision": c.revision, "checksum": c.checksum, "payload_len": c.payload_len,
+                "is_mature": c.is_mature,
+                "updated_at": c.updated_at.isoformat() if c.updated_at else None,
+            }
+            for c in chunks
+        ],
+    }
+
+
+# ─────────────────────────── chunk fetch ───────────────────────────
+
+@router.get("/{world_id}/rooms/{slug}/chunks/{cx}/{cy}/{cz}")
+async def get_chunk(
+    world_id: int, slug: str, cx: int, cy: int, cz: int,
+    current_user: CurrentUser, db: DbDep,
+    accept: Annotated[str | None, Header()] = None,
+    if_none_match: Annotated[str | None, Header(alias="If-None-Match")] = None,
+):
+    await _get_world_readable(world_id, current_user, db)
+    store = WorldStore(db)
+    room = await _resolve_room(store, db, world_id, slug)
+    if room is None:
+        raise HTTPException(status_code=404, detail="room not found")
+
+    key = chunk_codec.build_key(world_id, slug, cx, cy, cz)
+    chunk = await store.get_chunk(key)
+    if chunk is None:
+        raise HTTPException(status_code=404, detail="chunk not found")
+
+    etag = f'"{chunk.checksum}"'
+    headers = {"ETag": etag, "X-Chunk-Revision": str(chunk.revision), "X-Chunk-Key": key}
+
+    if if_none_match is not None and if_none_match.strip('"') == chunk.checksum:
+        return Response(status_code=304, headers=headers)
+
+    wants_json = (
+        accept is not None
+        and "application/json" in accept
+        and "application/octet-stream" not in accept
+    )
+    if wants_json:
+        decoded = chunk_codec.decode_binary(chunk.payload)
+        body = chunk_codec.to_json_dict(decoded, key=key, chunk_checksum=chunk.checksum)
+        return JSONResponse(content=body, headers=headers)
+
+    return Response(content=chunk.payload, media_type="application/octet-stream", headers=headers)
+
+
+# ─────────────────────────── chunk write ───────────────────────────
+
+async def _read_write_payload(request: Request, x_base_revision: int | None) -> tuple[bytes, int]:
+    content_type = request.headers.get("content-type", "")
+    if "application/json" in content_type:
+        body = await request.json()
+        try:
+            payload_bytes = base64.b64decode(body["payload_b64"], validate=True)
+        except (KeyError, binascii.Error, ValueError) as exc:
+            raise HTTPException(status_code=422, detail=f"invalid payload_b64: {exc}")
+        base_revision = int(body.get("base_revision", 0))
+        return payload_bytes, base_revision
+    payload_bytes = await request.body()
+    return payload_bytes, (x_base_revision if x_base_revision is not None else 0)
+
+
+@router.put("/{world_id}/rooms/{slug}/chunks/{cx}/{cy}/{cz}")
+async def put_chunk(
+    world_id: int, slug: str, cx: int, cy: int, cz: int,
+    request: Request, current_user: CurrentUser, db: DbDep,
+    x_base_revision: Annotated[int | None, Header(alias="X-Base-Revision")] = None,
+):
+    await _get_world_writable(world_id, current_user, db)
+    store = WorldStore(db)
+    room = await _resolve_room(store, db, world_id, slug)
+    if room is None:
+        raise HTTPException(status_code=404, detail="room not found")
+
+    payload_bytes, base_revision = await _read_write_payload(request, x_base_revision)
+    if len(payload_bytes) > settings.WORLD_CHUNK_MAX_PAYLOAD_BYTES:
+        raise HTTPException(
+            status_code=413,
+            detail=f"payload exceeds WORLD_CHUNK_MAX_PAYLOAD_BYTES ({settings.WORLD_CHUNK_MAX_PAYLOAD_BYTES})",
+        )
+
+    try:
+        chunk = await store.put_chunk(
+            room=room, cx=cx, cy=cy, cz=cz, payload_bytes=payload_bytes,
+            base_revision=base_revision, actor_id=current_user.id,
+        )
+    except chunk_codec.ChunkCodecError as exc:
+        await db.rollback()
+        return JSONResponse(status_code=422, content={"detail": "chunk decode failed", "reason": "malformed", "message": str(exc)})
+    except chunk_codec.ChunkValidationError as exc:
+        await db.rollback()
+        return JSONResponse(status_code=422, content=_validation_error_body(exc))
+    except RevisionConflict as exc:
+        # Nothing must stick from a failed write. Returning a JSONResponse
+        # here (rather than raising) means no exception propagates through
+        # `get_db`, so this rollback has to be explicit -- see the note on
+        # the batch endpoint below, where this is load-bearing for
+        # all-or-nothing semantics.
+        await db.rollback()
+        return JSONResponse(status_code=409, content=_conflict_body(exc))
+
+    await db.commit()
+    await db.refresh(chunk)
+
+    return {
+        "key": chunk.chunk_key, "revision": chunk.revision, "checksum": chunk.checksum,
+        "payload_len": chunk.payload_len,
+        "updated_at": chunk.updated_at.isoformat() if chunk.updated_at else None,
+        "is_mature": chunk.is_mature, "live_session": _is_live(world_id),
+    }
+
+
+# ─────────────────────────── batch write ───────────────────────────
+
+class BatchChunkItem(BaseModel):
+    cx: int
+    cy: int
+    cz: int
+    base_revision: int
+    payload_b64: str
+
+
+class BatchPutRequest(BaseModel):
+    chunks: list[BatchChunkItem]
+
+
+@router.put("/{world_id}/rooms/{slug}/chunks")
+async def put_chunks_batch(
+    world_id: int, slug: str, body: BatchPutRequest, current_user: CurrentUser, db: DbDep,
+):
+    await _get_world_writable(world_id, current_user, db)
+    store = WorldStore(db)
+    room = await _resolve_room(store, db, world_id, slug)
+    if room is None:
+        raise HTTPException(status_code=404, detail="room not found")
+
+    if len(body.chunks) > settings.WORLD_CHUNK_MAX_BATCH:
+        raise HTTPException(
+            status_code=422,
+            detail=f"batch of {len(body.chunks)} exceeds WORLD_CHUNK_MAX_BATCH ({settings.WORLD_CHUNK_MAX_BATCH})",
+        )
+
+    items = []
+    total_bytes = 0
+    for item in body.chunks:
+        try:
+            payload_bytes = base64.b64decode(item.payload_b64, validate=True)
+        except (binascii.Error, ValueError) as exc:
+            raise HTTPException(status_code=422, detail=f"invalid payload_b64 for ({item.cx},{item.cy},{item.cz}): {exc}")
+        total_bytes += len(payload_bytes)
+        items.append({
+            "cx": item.cx, "cy": item.cy, "cz": item.cz,
+            "base_revision": item.base_revision, "payload_bytes": payload_bytes,
+        })
+
+    if total_bytes > MAX_BATCH_TOTAL_BYTES:
+        raise HTTPException(status_code=413, detail=f"batch exceeds {MAX_BATCH_TOTAL_BYTES} bytes")
+
+    try:
+        rows = await store.put_chunks_batch(room=room, items=items, actor_id=current_user.id)
+    except chunk_codec.ChunkCodecError as exc:
+        # All-or-nothing (world_persistence_impl.md §8.1): earlier items in
+        # this batch may already be flushed (but never committed) to this
+        # transaction. Rolling back here is what actually makes the batch
+        # atomic -- without it, returning a JSONResponse instead of raising
+        # means no exception reaches `get_db`, and its own transaction
+        # handling would otherwise commit those earlier writes anyway.
+        await db.rollback()
+        return JSONResponse(status_code=422, content={"detail": "chunk decode failed", "reason": "malformed", "message": str(exc)})
+    except chunk_codec.ChunkValidationError as exc:
+        await db.rollback()
+        return JSONResponse(status_code=422, content=_validation_error_body(exc))
+    except RevisionConflict as exc:
+        await db.rollback()
+        return JSONResponse(status_code=409, content=_conflict_body(exc))
+
+    await db.commit()
+    for row in rows:
+        await db.refresh(row)
+
+    return {
+        "live_session": _is_live(world_id),
+        "chunks": [
+            {
+                "key": r.chunk_key, "revision": r.revision, "checksum": r.checksum,
+                "payload_len": r.payload_len,
+                "updated_at": r.updated_at.isoformat() if r.updated_at else None,
+                "is_mature": r.is_mature,
+            }
+            for r in rows
+        ],
+    }
+
+
+# ─────────────────────────── delete ───────────────────────────
+
+@router.delete("/{world_id}/rooms/{slug}/chunks/{cx}/{cy}/{cz}", status_code=204)
+async def delete_chunk(
+    world_id: int, slug: str, cx: int, cy: int, cz: int, current_user: CurrentUser, db: DbDep,
+):
+    await _get_world_writable(world_id, current_user, db)
+    store = WorldStore(db)
+    room = await _resolve_room(store, db, world_id, slug)
+    if room is None:
+        raise HTTPException(status_code=404, detail="room not found")
+
+    key = chunk_codec.build_key(world_id, slug, cx, cy, cz)
+    await store.delete_chunk(key, current_user.id)
+    await db.commit()
+    return Response(status_code=204)
+
+
+# ─────────────────────────── revisions + rollback ───────────────────────────
+
+@router.get("/{world_id}/rooms/{slug}/chunks/{cx}/{cy}/{cz}/revisions")
+async def chunk_revisions(
+    world_id: int, slug: str, cx: int, cy: int, cz: int, current_user: CurrentUser, db: DbDep,
+):
+    # doc: "(owner)" -- same gate as writes.
+    await _get_world_writable(world_id, current_user, db)
+    store = WorldStore(db)
+    key = chunk_codec.build_key(world_id, slug, cx, cy, cz)
+    revisions = await store.list_revisions(key)
+    return [
+        {
+            "revision": r.revision, "action": r.action, "actor_id": r.actor_id,
+            "checksum": r.checksum, "payload_available": r.payload is not None,
+            "created_at": r.created_at.isoformat() if r.created_at else None,
+        }
+        for r in revisions
+    ]
+
+
+class RollbackRequest(BaseModel):
+    revision: int
+
+
+@router.post("/{world_id}/rooms/{slug}/chunks/{cx}/{cy}/{cz}/rollback")
+async def rollback_chunk(
+    world_id: int, slug: str, cx: int, cy: int, cz: int,
+    body: RollbackRequest, current_user: CurrentUser, db: DbDep,
+):
+    await _get_world_writable(world_id, current_user, db)
+    store = WorldStore(db)
+    key = chunk_codec.build_key(world_id, slug, cx, cy, cz)
+    try:
+        chunk = await store.rollback_chunk(key, body.revision, current_user.id)
+    except RevisionNotAvailable as exc:
+        await db.rollback()
+        return JSONResponse(status_code=404, content={"detail": str(exc)})
+    except chunk_codec.ChunkValidationError as exc:
+        await db.rollback()
+        return JSONResponse(status_code=422, content=_validation_error_body(exc))
+
+    await db.commit()
+    await db.refresh(chunk)
+    return {
+        "key": chunk.chunk_key, "revision": chunk.revision, "checksum": chunk.checksum,
+        "payload_len": chunk.payload_len,
+        "updated_at": chunk.updated_at.isoformat() if chunk.updated_at else None,
+        "is_mature": chunk.is_mature, "live_session": _is_live(world_id),
+    }

backend/app/routers/worlds.py

@@ -13,6 +13,7 @@ from app.database import get_db
 from app.dependencies import CurrentUser
 from app.models.world import World, WorldVisibility
 from app.services.game_servers import supervisor
+from app.services.world_store import WorldStore
 
 router = APIRouter()
 
@@ -147,7 +148,12 @@ async def create_world(
     current_user: CurrentUser,
     db: DbDep,
 ):
-    """Create a new world."""
+    """Create a new world.
+
+    Also creates the world's "main" room (world_persistence_impl.md §4.1) --
+    every world gets one so chunk content has somewhere to live from the
+    start.
+    """
     world = World(
         name=world_data.name,
         description=world_data.description,
@@ -155,6 +161,8 @@ async def create_world(
         visibility=world_data.visibility,
     )
     db.add(world)
+    await db.flush()  # assigns world.id, needed for the room's FK
+    await WorldStore(db).get_or_create_main_room(world.id)
     await db.commit()
     await db.refresh(world)
     return world

backend/app/services/chunk_codec.py

@@ -0,0 +1,676 @@
+"""Python port of the chunk binary/JSON codec, `docs/architecture/world.md` §3.
+
+This is the server-side half of the "single shared format, two
+implementations" contract world.md §5.2 and
+`world_persistence_impl.md` §5.5/§9 call for. The Godot-side implementation
+is `scripts/chunk_data_decoder.gd`; this module must decode anything it
+produces and produce bytes it can decode.
+
+IMPORTANT DEVIATION (see the "Known cross-codec divergence" note at the
+bottom of this file): the current `scripts/chunk_data_decoder.gd` does not
+actually implement IEEE-754 float32 for the `pos`/`rot`/`scale`/`bounds`
+fields -- it performs a lossy numeric `int`/`float` cast instead of a bit
+reinterpretation, which both truncates fractional values and does not
+write IEEE-754 bits at all. This module implements the format as
+*specified* (real `<f` IEEE-754 float32, matching every other field in the
+spec and matching what any conformant decoder would assume). See the note
+for what this means for cross-codec byte parity today.
+
+Nothing here talks to a database or the FastAPI app; it is a pure,
+side-effect-free codec so it can be golden-file tested in isolation.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import struct
+from dataclasses import dataclass, field
+
+MAGIC = b"AGPC"
+HEADER_SIZE = 48
+CURRENT_VERSION = 1
+
+SECTION_META = 0x01
+SECTION_TILE = 0x02
+SECTION_OBJECT = 0x03
+SECTION_FLAGS = 0x04
+SECTION_REVISION_META = 0x05
+
+CATEGORY_FIELDS = (
+    "violence", "sexual", "language", "substance",
+    "gambling", "horror", "hate", "custom",
+)
+
+
+class ChunkCodecError(Exception):
+    """Malformed bytes -- the payload isn't shaped like a chunk at all."""
+
+
+class ChunkValidationError(Exception):
+    """A structurally-valid chunk failed a content/business-rule check.
+
+    ``reason`` is the machine-readable code the API surface (world_persistence_impl.md
+    §8.1) puts in the 422 response body's ``reason`` field, e.g.
+    ``"checksum_mismatch"``, ``"layer_dims"``, ``"object_out_of_bounds"``.
+    """
+
+    def __init__(self, reason: str, message: str | None = None) -> None:
+        self.reason = reason
+        super().__init__(message or reason)
+
+
+# ───────────────────────── Logical model ─────────────────────────
+
+@dataclass
+class TileDef:
+    id: int
+    asset_id: str = ""
+    solid: bool = False
+    flags: int = 0
+    variants: int = 1
+
+
+@dataclass
+class TileLayer:
+    name: str
+    layer_id: int = 0
+    width: int = 0
+    height: int = 0
+    depth: int = 1
+    palette: list[TileDef] = field(default_factory=list)
+    tiles: list[int] = field(default_factory=list)  # flattened, row-major
+
+
+@dataclass
+class ContentFlags:
+    violence: int = 0
+    sexual: int = 0
+    language: int = 0
+    substance: int = 0
+    gambling: int = 0
+    horror: int = 0
+    hate: int = 0
+    custom: int = 0
+    mature: bool = False
+    sources: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "categories": {name: getattr(self, name) for name in CATEGORY_FIELDS},
+            "mature": self.mature,
+            "sources": list(self.sources),
+        }
+
+    @classmethod
+    def from_dict(cls, d: dict) -> "ContentFlags":
+        cats = d.get("categories", {})
+        return cls(
+            **{name: int(cats.get(name, 0)) for name in CATEGORY_FIELDS},
+            mature=bool(d.get("mature", False)),
+            sources=list(d.get("sources", [])),
+        )
+
+
+@dataclass
+class WorldObject:
+    id: str
+    type: str
+    asset_id: str
+    pos: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    rot: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 1.0)
+    scale: tuple[float, float, float] = (1.0, 1.0, 1.0)
+    dynamic: bool = False
+    properties: dict = field(default_factory=dict)
+    flags: ContentFlags = field(default_factory=ContentFlags)
+
+
+@dataclass
+class ChunkBounds:
+    """Stored here as min-corner + size (matching the Godot client's AABB
+    type) for convenience, but the §3.6 BINARY wire format is min + max
+    (world.md §3.1, and the client's actual ChunkDataDecoder) -- fixed
+    2026-09-14 after a real client/server interop test caught this class's
+    original binary codec writing min+size on the wire, which the client
+    decoder (unaware of the "size" convention) read as a second min/max
+    pair, corrupting every chunk's bounds. The two representations are
+    fully recoverable from each other; `max` below is computed for exactly
+    this reason."""
+
+    min: tuple[float, float, float] = (0.0, 0.0, 0.0)
+    size: tuple[float, float, float] = (0.0, 0.0, 0.0)
+
+    @property
+    def max(self) -> tuple[float, float, float]:
+        return tuple(a + b for a, b in zip(self.min, self.size))
+
+
+@dataclass
+class ChunkPayload:
+    version: int = CURRENT_VERSION
+    world_id: str = ""
+    room_id: str = ""
+    coord: tuple[int, int, int] = (0, 0, 0)
+    bounds: ChunkBounds = field(default_factory=ChunkBounds)
+    tile_layers: list[TileLayer] = field(default_factory=list)
+    objects: list[WorldObject] = field(default_factory=list)
+    flags: ContentFlags = field(default_factory=ContentFlags)
+    created_at: int = 0
+    updated_at: int = 0
+    revision: int = 0
+    author: str = ""
+
+
+def build_key(world_id: str | int, room_slug: str, cx: int, cy: int, cz: int) -> str:
+    """world_persistence_impl.md §4.5: ``"{world.id}:{room.slug}:{cx}:{cy}:{cz}"``."""
+    return f"{world_id}:{room_slug}:{cx}:{cy}:{cz}"
+
+
+# ───────────────────────── Binary primitives ─────────────────────────
+# All integers little-endian, matching world.md §3.6.3. Floats are packed
+# as real IEEE-754 float32 -- see the module docstring's deviation note.
+
+def _read_u16(data: bytes, off: int) -> int:
+    return struct.unpack_from("<H", data, off)[0]
+
+
+def _read_u32(data: bytes, off: int) -> int:
+    return struct.unpack_from("<I", data, off)[0]
+
+
+def _read_i32(data: bytes, off: int) -> int:
+    return struct.unpack_from("<i", data, off)[0]
+
+
+def _read_i64(data: bytes, off: int) -> int:
+    return struct.unpack_from("<q", data, off)[0]
+
+
+def _read_f32(data: bytes, off: int) -> float:
+    return struct.unpack_from("<f", data, off)[0]
+
+
+def _w_u16(v: int) -> bytes:
+    return struct.pack("<H", v & 0xFFFF)
+
+
+def _w_u32(v: int) -> bytes:
+    return struct.pack("<I", v & 0xFFFFFFFF)
+
+
+def _w_i32(v: int) -> bytes:
+    return struct.pack("<i", v)
+
+
+def _w_i64(v: int) -> bytes:
+    return struct.pack("<q", v)
+
+
+def _w_f32(v: float) -> bytes:
+    return struct.pack("<f", v)
+
+
+def _read_str(data: bytes, off: int) -> tuple[str, int]:
+    """Length-prefixed UTF-8 string. Returns (value, next_offset)."""
+    n = _read_u16(data, off)
+    off += 2
+    s = data[off:off + n].decode("utf-8")
+    return s, off + n
+
+
+def _w_str(s: str) -> bytes:
+    b = s.encode("utf-8")
+    if len(b) > 0xFFFF:
+        raise ChunkCodecError(f"string field too long to encode ({len(b)} bytes)")
+    return _w_u16(len(b)) + b
+
+
+def checksum(payload_body: bytes) -> str:
+    """SHA-256 hex digest of the payload body (world.md §3.6.3)."""
+    return hashlib.sha256(payload_body).hexdigest()
+
+
+# ───────────────────────── Section codecs ─────────────────────────
+
+def _encode_metadata(payload: ChunkPayload) -> bytes:
+    out = bytearray()
+    out += _w_str(payload.world_id)
+    out += _w_str(payload.room_id)
+    out += _w_i32(payload.coord[0])
+    out += _w_i32(payload.coord[1])
+    out += _w_i32(payload.coord[2])
+    out += _w_f32(payload.bounds.min[0])
+    out += _w_f32(payload.bounds.min[1])
+    out += _w_f32(payload.bounds.min[2])
+    out += _w_f32(payload.bounds.max[0])
+    out += _w_f32(payload.bounds.max[1])
+    out += _w_f32(payload.bounds.max[2])
+    return bytes(out)
+
+
+def _decode_metadata(data: bytes, result: ChunkPayload) -> None:
+    off = 0
+    result.world_id, off = _read_str(data, off)
+    result.room_id, off = _read_str(data, off)
+    coord = (_read_i32(data, off), _read_i32(data, off + 4), _read_i32(data, off + 8))
+    off += 12
+    min_pos = (_read_f32(data, off), _read_f32(data, off + 4), _read_f32(data, off + 8))
+    max_pos = (_read_f32(data, off + 12), _read_f32(data, off + 16), _read_f32(data, off + 20))
+    size = tuple(a - b for a, b in zip(max_pos, min_pos))
+    result.coord = coord
+    result.bounds = ChunkBounds(min=min_pos, size=size)
+
+
+def _encode_tile_layer(layer: TileLayer) -> bytes:
+    out = bytearray()
+    out += _w_str(layer.name)
+    out += _w_u16(layer.layer_id)
+    out += _w_u16(layer.width)
+    out += _w_u16(layer.height)
+    out += _w_u16(layer.depth)
+    out += _w_u16(len(layer.palette))
+    for td in layer.palette:
+        out += _w_u16(td.id)
+        out += _w_str(td.asset_id)
+        out += bytes([1 if td.solid else 0])
+        out += _w_u32(td.flags)
+        out += bytes([td.variants & 0xFF])
+    out += _w_u32(len(layer.tiles))
+    for tile_id in layer.tiles:
+        out += _w_u16(tile_id)
+    return bytes(out)
+
+
+def _decode_tile_layer(data: bytes) -> TileLayer:
+    off = 0
+    name, off = _read_str(data, off)
+    layer_id = _read_u16(data, off); off += 2
+    width = _read_u16(data, off); off += 2
+    height = _read_u16(data, off); off += 2
+    depth = _read_u16(data, off); off += 2
+    palette_count = _read_u16(data, off); off += 2
+    palette: list[TileDef] = []
+    for _ in range(palette_count):
+        tid = _read_u16(data, off); off += 2
+        asset_id, off = _read_str(data, off)
+        solid = data[off] != 0; off += 1
+        flags = _read_u32(data, off); off += 4
+        variants = data[off]; off += 1
+        palette.append(TileDef(id=tid, asset_id=asset_id, solid=solid, flags=flags, variants=variants))
+    tile_count = _read_u32(data, off); off += 4
+    tiles: list[int] = []
+    for _ in range(tile_count):
+        tiles.append(_read_u16(data, off))
+        off += 2
+    return TileLayer(name=name, layer_id=layer_id, width=width, height=height,
+                      depth=depth, palette=palette, tiles=tiles)
+
+
+def _encode_flags(flags: ContentFlags) -> bytes:
+    out = bytearray()
+    for name in CATEGORY_FIELDS:
+        out.append(getattr(flags, name) & 0xFF)
+    out.append(1 if flags.mature else 0)
+    out += _w_u16(len(flags.sources))
+    for src in flags.sources:
+        out += _w_str(src)
+    return bytes(out)
+
+
+def _decode_flags(data: bytes) -> ContentFlags:
+    off = 0
+    values = {}
+    for name in CATEGORY_FIELDS:
+        values[name] = data[off]
+        off += 1
+    mature = data[off] != 0
+    off += 1
+    source_count = _read_u16(data, off)
+    off += 2
+    sources = []
+    for _ in range(source_count):
+        s, off = _read_str(data, off)
+        sources.append(s)
+    return ContentFlags(**values, mature=mature, sources=sources)
+
+
+def _encode_object(obj: WorldObject) -> bytes:
+    out = bytearray()
+    out += _w_str(obj.id)
+    out += _w_str(obj.type)
+    out += _w_str(obj.asset_id)
+    for v in obj.pos:
+        out += _w_f32(v)
+    for v in obj.rot:
+        out += _w_f32(v)
+    for v in obj.scale:
+        out += _w_f32(v)
+    out.append(1 if obj.dynamic else 0)
+    # Canonical JSON: keys sorted lexicographically (world.md §3.6.3).
+    props_json = json.dumps(obj.properties, sort_keys=True, separators=(",", ":"))
+    out += _w_str(props_json)
+    out += _encode_flags(obj.flags)
+    return bytes(out)
+
+
+def _decode_object(data: bytes) -> WorldObject:
+    off = 0
+    oid, off = _read_str(data, off)
+    otype, off = _read_str(data, off)
+    asset_id, off = _read_str(data, off)
+    pos = (_read_f32(data, off), _read_f32(data, off + 4), _read_f32(data, off + 8))
+    off += 12
+    rot = (
+        _read_f32(data, off), _read_f32(data, off + 4),
+        _read_f32(data, off + 8), _read_f32(data, off + 12),
+    )
+    off += 16
+    scale = (_read_f32(data, off), _read_f32(data, off + 4), _read_f32(data, off + 8))
+    off += 12
+    dynamic = data[off] != 0
+    off += 1
+    props_str, off = _read_str(data, off)
+    try:
+        properties = json.loads(props_str) if props_str else {}
+    except json.JSONDecodeError as exc:
+        raise ChunkCodecError(f"object {oid!r}: invalid properties JSON") from exc
+    obj_flags = _decode_flags(data[off:])
+    return WorldObject(id=oid, type=otype, asset_id=asset_id, pos=pos, rot=rot,
+                        scale=scale, dynamic=dynamic, properties=properties, flags=obj_flags)
+
+
+def _encode_revision_meta(payload: ChunkPayload) -> bytes:
+    out = bytearray()
+    out += _w_i64(payload.created_at)
+    out += _w_i64(payload.updated_at)
+    out += _w_u32(payload.revision)
+    out += _w_str(payload.author)
+    return bytes(out)
+
+
+def _decode_revision_meta(data: bytes, result: ChunkPayload) -> None:
+    off = 0
+    result.created_at = _read_i64(data, off); off += 8
+    result.updated_at = _read_i64(data, off); off += 8
+    result.revision = _read_u32(data, off); off += 4
+    result.author, off = _read_str(data, off)
+
+
+def _wrap_section(section_id: int, data: bytes) -> bytes:
+    return bytes([section_id]) + _w_u32(len(data)) + data
+
+
+# ───────────────────────── Top-level encode/decode ─────────────────────────
+
+def encode_binary(payload: ChunkPayload) -> bytes:
+    """Encode a ChunkPayload to the world.md §3.6 wire format."""
+    sections = bytearray()
+    sections += _wrap_section(SECTION_META, _encode_metadata(payload))
+    for layer in payload.tile_layers:
+        sections += _wrap_section(SECTION_TILE, _encode_tile_layer(layer))
+    for obj in payload.objects:
+        sections += _wrap_section(SECTION_OBJECT, _encode_object(obj))
+    sections += _wrap_section(SECTION_FLAGS, _encode_flags(payload.flags))
+    sections += _wrap_section(SECTION_REVISION_META, _encode_revision_meta(payload))
+
+    payload_body = bytes(sections)
+    digest = hashlib.sha256(payload_body).digest()  # 32 raw bytes
+
+    header = bytearray()
+    header += MAGIC
+    header += _w_u16(CURRENT_VERSION)
+    header += _w_u16(HEADER_SIZE - 8)  # header_len: bytes of header after this field (spec-correct)
+    header += _w_u32(0)  # flags (reserved)
+    header += _w_u32(len(payload_body))
+    header += digest
+
+    return bytes(header) + payload_body
+
+
+def decode_binary(data: bytes) -> ChunkPayload:
+    """Decode a world.md §3.6 binary chunk. Raises ChunkCodecError on
+    structurally malformed input (short buffer, bad magic, unsupported
+    version, truncated payload)."""
+    if len(data) < HEADER_SIZE:
+        raise ChunkCodecError(f"data too short for header ({len(data)} bytes)")
+
+    if data[0:4] != MAGIC:
+        raise ChunkCodecError("bad magic bytes")
+
+    version = _read_u16(data, 4)
+    if version < 1 or version > CURRENT_VERSION:
+        raise ChunkCodecError(f"unsupported chunk format version {version}")
+
+    # header_len (offset 6) is intentionally not used for offset math --
+    # both this decoder and the Godot one always slice at the fixed
+    # HEADER_SIZE, matching the reference implementation's actual (if
+    # spec-inconsistent) behaviour.
+    payload_len = _read_u32(data, 12)
+    # bytes 16:48 are the header's advisory checksum -- decode_and_validate
+    # re-reads it directly and recomputes against the parsed payload body.
+
+    if len(data) - HEADER_SIZE != payload_len:
+        raise ChunkCodecError(
+            f"declared payload_len ({payload_len}) does not match actual "
+            f"remaining bytes ({len(data) - HEADER_SIZE})"
+        )
+
+    payload_body = data[HEADER_SIZE:HEADER_SIZE + payload_len]
+
+    result = ChunkPayload(version=version)
+
+    offset = 0
+    while offset < len(payload_body):
+        if offset + 5 > len(payload_body):
+            raise ChunkCodecError("truncated section header")
+        section_id = payload_body[offset]
+        section_len = _read_u32(payload_body, offset + 1)
+        data_start = offset + 5
+        data_end = data_start + section_len
+        if data_end > len(payload_body):
+            raise ChunkCodecError("truncated section body")
+        section_data = payload_body[data_start:data_end]
+
+        if section_id == SECTION_META:
+            _decode_metadata(section_data, result)
+        elif section_id == SECTION_TILE:
+            result.tile_layers.append(_decode_tile_layer(section_data))
+        elif section_id == SECTION_OBJECT:
+            result.objects.append(_decode_object(section_data))
+        elif section_id == SECTION_FLAGS:
+            result.flags = _decode_flags(section_data)
+        elif section_id == SECTION_REVISION_META:
+            _decode_revision_meta(section_data, result)
+        # Unknown section ids are skipped (forward-compat), matching the
+        # Godot decoder's match-with-no-default behaviour.
+
+        offset = data_end
+
+    return result
+
+
+# ───────────────────────── JSON encoding (world.md §3.5) ─────────────────────────
+# Derived, never stored (world_persistence_impl.md §8.1) -- produced here
+# from a decoded ChunkPayload for the ``Accept: application/json`` path.
+
+def to_json_dict(payload: ChunkPayload, *, key: str, chunk_checksum: str) -> dict:
+    return {
+        "version": payload.version,
+        "key": key,
+        "world_id": payload.world_id,
+        "room_id": payload.room_id,
+        "coord": {"cx": payload.coord[0], "cy": payload.coord[1], "cz": payload.coord[2]},
+        "bounds": {
+            "min_x": payload.bounds.min[0], "min_y": payload.bounds.min[1], "min_z": payload.bounds.min[2],
+            "max_x": payload.bounds.max[0], "max_y": payload.bounds.max[1], "max_z": payload.bounds.max[2],
+        },
+        "tiles": [
+            {
+                "name": layer.name,
+                "layer_id": layer.layer_id,
+                "width": layer.width,
+                "height": layer.height,
+                "depth": layer.depth,
+                "palette": [
+                    {"id": td.id, "asset_id": td.asset_id, "solid": td.solid,
+                     "flags": td.flags, "variants": td.variants}
+                    for td in layer.palette
+                ],
+                "tiles": list(layer.tiles),
+            }
+            for layer in payload.tile_layers
+        ],
+        "objects": [
+            {
+                "id": obj.id, "type": obj.type, "asset_id": obj.asset_id,
+                "transform": {
+                    "pos": list(obj.pos), "rot": list(obj.rot), "scale": list(obj.scale),
+                },
+                "properties": obj.properties,
+                "dynamic": obj.dynamic,
+                "flags": obj.flags.to_dict(),
+            }
+            for obj in payload.objects
+        ],
+        "flags": payload.flags.to_dict(),
+        "meta": {
+            "created_at": payload.created_at, "updated_at": payload.updated_at,
+            "revision": payload.revision, "author": payload.author,
+        },
+        "checksum": chunk_checksum,
+    }
+
+
+# ───────────────────────── Validation (world_persistence_impl.md §5.5) ─────────────────────────
+
+# Not precisely quantified by the design doc beyond "length limits" --
+# these are this implementation's conservative defaults (world.md §7).
+MAX_STRING_FIELD_LEN = 256
+MAX_PROPERTIES_JSON_LEN = 16_384
+MAX_SOURCES_PER_FLAGSET = 32
+
+
+def _check_string_lengths(obj: WorldObject) -> None:
+    for field_name, value in (("id", obj.id), ("type", obj.type), ("asset_id", obj.asset_id)):
+        if len(value) > MAX_STRING_FIELD_LEN:
+            raise ChunkValidationError(
+                "string_field_too_long", f"object.{field_name} exceeds {MAX_STRING_FIELD_LEN} chars"
+            )
+    props_json = json.dumps(obj.properties)
+    if len(props_json) > MAX_PROPERTIES_JSON_LEN:
+        raise ChunkValidationError(
+            "string_field_too_long", f"object {obj.id!r} properties exceed {MAX_PROPERTIES_JSON_LEN} bytes"
+        )
+    if len(obj.flags.sources) > MAX_SOURCES_PER_FLAGSET:
+        raise ChunkValidationError("string_field_too_long", f"object {obj.id!r} has too many flag sources")
+
+
+def decode_and_validate(
+    data: bytes,
+    *,
+    expected_key: str,
+    grid_size: tuple[int, int, int],
+    max_objects: int,
+) -> ChunkPayload:
+    """Decode + fully validate a client-submitted chunk payload.
+
+    This is the boundary world_persistence_impl.md §5.5 requires: "the
+    backend must not trust the client". Raises ``ChunkCodecError`` for
+    structurally malformed bytes (mapped to a 422 by the router with a
+    generic reason) or ``ChunkValidationError`` with a specific ``reason``
+    code for a well-formed-but-invalid payload.
+    """
+    payload = decode_binary(data)  # raises ChunkCodecError for structural problems first
+
+    # Checksum is advisory in the header (world.md §7); the value that
+    # matters is recomputed from the actual payload body we just parsed.
+    payload_body = data[HEADER_SIZE:]
+    recomputed = checksum(payload_body)
+    header_checksum_hex = data[16:48].hex()
+    if header_checksum_hex != recomputed:
+        raise ChunkValidationError(
+            "checksum_mismatch",
+            "header checksum does not match the recomputed SHA-256 of the payload body",
+        )
+
+    actual_key = build_key(payload.world_id, payload.room_id, *payload.coord)
+    if actual_key != expected_key:
+        raise ChunkValidationError(
+            "chunk_key_mismatch",
+            f"payload key {actual_key!r} does not match URL {expected_key!r}",
+        )
+
+    for layer in payload.tile_layers:
+        if (layer.width, layer.height, layer.depth) != tuple(grid_size):
+            raise ChunkValidationError(
+                "layer_dims",
+                f"tile layer {layer.name!r} dims {(layer.width, layer.height, layer.depth)} "
+                f"!= room grid {tuple(grid_size)}",
+            )
+        valid_ids = {0} | {td.id for td in layer.palette}
+        for tile_id in layer.tiles:
+            if tile_id not in valid_ids:
+                raise ChunkValidationError(
+                    "tile_out_of_palette",
+                    f"tile layer {layer.name!r} references palette id {tile_id} not in its palette",
+                )
+        if len(layer.tiles) != layer.width * layer.height * layer.depth:
+            raise ChunkValidationError(
+                "layer_dims",
+                f"tile layer {layer.name!r} has {len(layer.tiles)} cells, expected "
+                f"{layer.width * layer.height * layer.depth}",
+            )
+
+    if len(payload.objects) > max_objects:
+        raise ChunkValidationError(
+            "too_many_objects", f"{len(payload.objects)} objects exceeds max {max_objects}"
+        )
+
+    bmin, bmax = payload.bounds.min, payload.bounds.max
+    for obj in payload.objects:
+        _check_string_lengths(obj)
+        if not all(bmin[i] <= obj.pos[i] <= bmax[i] for i in range(3)):
+            raise ChunkValidationError(
+                "object_out_of_bounds",
+                f"object {obj.id!r} position {obj.pos} outside chunk bounds "
+                f"[{bmin}, {bmax}]",
+            )
+
+    if len(payload.author) > MAX_STRING_FIELD_LEN:
+        raise ChunkValidationError("string_field_too_long", "meta.author too long")
+
+    return payload
+
+
+# ───────────────────────── Known cross-codec divergence ─────────────────────────
+#
+# `scripts/chunk_data_decoder.gd`'s `_read_float32`/`_write_float32` do:
+#
+#     static func _write_float32(val: float) -> PackedByteArray:
+#         var bits := val as int
+#         return _write_uint32(bits)
+#
+#     static func _read_float32(data: PackedByteArray, offset: int) -> float:
+#         var bits := _read_uint32(data, offset)
+#         return bits as float
+#
+# `as` between int and float in GDScript is a numeric conversion, not a bit
+# reinterpretation (verified empirically against Godot 4.6.2 headless:
+# `1.5 as int` -> `1`, `1 as float` -> `1.0`; the IEEE-754 bit pattern of
+# 1.5f is 0x3FC00000 = 1069547520, not 1). So the shipped client codec
+# truncates every float32 field (bounds, object pos/rot/scale) to its
+# integer part and stores that integer as a raw int32 -- not as float32
+# bits at all. This is a real bug in already-merged, client-side code
+# (scripts/ is out of scope for this task) that breaks the "byte-stable
+# across two implementations" guarantee world.md §3.6.3 states.
+#
+# This module implements the *specified* format (real IEEE-754 float32)
+# rather than replicating that bug, because world.md §3.6 is normative and
+# says "float32" for these fields, and mirroring the bug would mean the
+# backend also corrupts every non-integer transform/bounds value it
+# stores. Practical effect until the client-side bug is fixed: payloads
+# with integer-only floats will decode identically on both sides; any
+# payload with a fractional position/rotation/scale/bounds value will not
+# be byte-identical (or numerically identical) between this module and the
+# current `scripts/chunk_data_decoder.gd`. This is flagged for the
+# client/editor follow-on task, not fixed here.

backend/app/services/game_servers.py

@@ -13,15 +13,26 @@ project are on the host (see ``settings.GODOT_BIN`` / ``GAME_PROJECT_DIR``);
 the backend spawns them as subprocesses.
 
 Design notes / limits (PC3):
- - All worlds currently load the same test level (per-world content is M2/M7).
-   ``world_id`` still scopes a distinct server process + session.
  - Port allocation is a linear scan of the configured range.
  - No crash-restart: if a server process dies, the next join respawns it.
+   With world content now durable in Postgres (world_persistence_impl.md
+   D2), this is genuinely safe rather than merely tolerated: the sim
+   process holds no unsaved world content, so a reap/crash/kill can never
+   lose world data.
+
+Per-spawn auth token (world_persistence_impl.md §7.3): each spawned server
+gets a random ``secrets.token_urlsafe(32)`` on its command line, which it
+uses as a Bearer token against ``/api/internal`` to pull its world's
+content read-only before binding its ENet port. The token grants access to
+exactly one world and dies with its process (the reaper's
+``del self._servers[wid]`` invalidates it; see ``validate_token``).
 """
 from __future__ import annotations
 
 import asyncio
+import hmac
 import json
+import secrets
 import socket
 import subprocess
 import tempfile
@@ -38,6 +49,7 @@ class _WorldServer:
     port: int
     proc: subprocess.Popen
     status_path: Path
+    token: str
     started_at: float = field(default_factory=time.time)
     last_join: float = field(default_factory=time.time)
 
@@ -50,6 +62,9 @@ class _WorldServer:
     def player_count(self) -> int:
         return int(self.status().get("players", 0))
 
+    def is_ready(self) -> bool:
+        return self.status().get("ready") is True
+
     def alive(self) -> bool:
         return self.proc.poll() is None
 
@@ -104,16 +119,35 @@ class GameServerSupervisor:
             if srv is None:
                 srv = self._spawn(world_id)
                 self._servers[world_id] = srv
-                # Give the engine a moment to bind the ENet port before we
-                # hand the address to a client.
-                await self._await_port(srv.port)
+                try:
+                    await self._await_ready(srv)
+                except TimeoutError:
+                    # Real failure now, not a silent "hope it's fine" --
+                    # see _await_ready's docstring. Don't leave a possibly
+                    # half-started process registered.
+                    srv.stop()
+                    del self._servers[world_id]
+                    raise RuntimeError(
+                        f"dedicated server for world {world_id} did not become ready in time"
+                    )
 
             srv.last_join = time.time()
             return {"host": settings.GAME_SERVER_HOST, "port": srv.port, "world_id": world_id}
 
+    def validate_token(self, world_id: str, token: str) -> bool:
+        """`require_game_server` dependency support (world_persistence_impl.md
+        §7.3): true iff *token* is the live token for *world_id*'s server.
+        A dict lookup, as the doc specifies, plus a constant-time compare
+        since it's a bearer credential."""
+        srv = self._servers.get(str(world_id))
+        if srv is None or not srv.alive():
+            return False
+        return hmac.compare_digest(srv.token, token)
+
     # ── internals ────────────────────────────────────────────────────────
     def _spawn(self, world_id: str) -> _WorldServer:
         port = self._free_port()
+        token = secrets.token_urlsafe(32)
         status_path = self._runtime_dir / f"world_{world_id}_{port}.json"
         status_path.unlink(missing_ok=True)
         cmd = [
@@ -123,9 +157,13 @@ class GameServerSupervisor:
             "--port", str(port),
             "--world", str(world_id),
             "--status-file", str(status_path),
+            "--api-url", settings.GAME_SERVER_INTERNAL_API_URL,
+            "--server-token", token,
         ]
         proc = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-        return _WorldServer(world_id=world_id, port=port, proc=proc, status_path=status_path)
+        return _WorldServer(
+            world_id=world_id, port=port, proc=proc, status_path=status_path, token=token
+        )
 
     def _free_port(self) -> int:
         used = {s.port for s in self._servers.values()}
@@ -140,16 +178,35 @@ class GameServerSupervisor:
                     continue
         raise RuntimeError("no free game-server port in the configured range")
 
-    async def _await_port(self, port: int, timeout: float = 8.0) -> None:
-        deadline = time.time() + timeout
+    async def _await_ready(self, srv: _WorldServer) -> None:
+        """Wait for a ``"ready": true`` field in the status file
+        (world_persistence_impl.md §7.4).
+
+        This replaces the old ``_await_port``, which had two real bugs:
+        it treated a bound UDP port as "ready", but with content loading
+        the port binds *before* the server has fetched its world's rooms
+        and chunks (world_persistence_impl.md §7.2 step 4) -- so a client
+        could get handed an address for a server still mid-fetch. And it
+        *failed open*: past its 8s deadline it simply returned, with no
+        error, so ``ensure_server`` reported success for a server that may
+        never have started at all. This raises ``TimeoutError`` instead,
+        which ``ensure_server`` turns into a real 503 for the joining
+        client, and also bails out early (same exception) if the process
+        has already exited.
+        """
+        deadline = time.time() + settings.GAME_SERVER_READY_TIMEOUT_SECONDS
         while time.time() < deadline:
-            # ENet is UDP; a bind failure means something (our server) has it.
-            with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
-                try:
-                    s.bind(("0.0.0.0", port))
-                except OSError:
-                    return
+            if srv.is_ready():
+                return
+            if not srv.alive():
+                raise TimeoutError(
+                    f"server process for world {srv.world_id} exited before becoming ready"
+                )
             await asyncio.sleep(0.25)
+        raise TimeoutError(
+            f"server for world {srv.world_id} did not report ready within "
+            f"{settings.GAME_SERVER_READY_TIMEOUT_SECONDS}s"
+        )
 
     async def _reap_loop(self) -> None:
         try:

backend/app/services/world_store.py

@@ -0,0 +1,431 @@
+"""World content storage service.
+
+Implements the `world.md` §5.1 service interface over Postgres, per
+`world_persistence_impl.md` §9 -- **minus** ``flush_dirty`` and
+``rebuild_index``, which don't apply once there is no write-behind dirty
+set and no derived index to rebuild (see that doc's §3.3 and §4.2).
+
+This is the *only* place chunk content is written (world_persistence_impl.md
+D2 / §5). Callers (the routers) own transaction boundaries: methods here
+``flush()`` so later statements in the same request see earlier ones and so
+integrity errors surface before a caller commits, but they never
+``commit()`` -- that mirrors the existing convention in
+``app/routers/worlds.py`` (``get_db`` docs: "Handlers are responsible for
+committing or rolling back their own transactions").
+
+Known gap this module had to resolve on its own (flagged, not silently
+decided): `world_persistence_impl.md` §6/§7.2/§8.1 all reference a world's
+monotonic ``content_revision`` ("bumped on every chunk write"), but no
+column for it is defined anywhere in §4's schema. Rather than add an
+undocumented column, ``content_revision()`` below derives it as
+``MAX(id)`` over ``world_chunk_revisions`` scoped to the world: that table
+is append-only (retention only nulls ``payload``, it never deletes rows),
+so the value is genuinely monotonic and increments on every
+create/update/delete/rollback.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from sqlalchemy import func, select, update
+from sqlalchemy.exc import IntegrityError
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import load_only
+
+from app.config import settings
+from app.models.world_content import (
+    MAIN_ROOM_NAME,
+    MAIN_ROOM_SLUG,
+    WorldChunk,
+    WorldChunkRevision,
+    WorldRoom,
+)
+from app.services import chunk_codec
+
+
+class RevisionConflict(Exception):
+    """Optimistic-concurrency conflict (world.md §5.4). ``current_revision``
+    is 0 and ``current_checksum`` is None when the caller's ``base_revision``
+    assumed a chunk exists but it doesn't."""
+
+    def __init__(
+        self,
+        current_revision: int,
+        current_checksum: str | None,
+        coord: tuple[int, int, int] | None = None,
+    ) -> None:
+        self.current_revision = current_revision
+        self.current_checksum = current_checksum
+        self.coord = coord
+        super().__init__(f"revision conflict: current_revision={current_revision}")
+
+
+class RevisionNotAvailable(Exception):
+    """Raised by ``rollback_chunk`` when the requested revision doesn't
+    exist, or exists but its payload was pruned by the retention policy
+    (world_persistence_impl.md §4.3)."""
+
+
+@dataclass
+class Bounds:
+    cx_min: int | None = None
+    cx_max: int | None = None
+    cy_min: int | None = None
+    cy_max: int | None = None
+    cz: int | None = None
+
+
+class WorldStore:
+    """Owns chunk/room read/write operations over the async session
+    handed to it. One instance per request is the expected usage
+    (``WorldStore(db)`` where ``db`` is the ``DbDep`` session)."""
+
+    def __init__(self, db: AsyncSession) -> None:
+        self.db = db
+
+    # ── rooms ────────────────────────────────────────────────────────────
+
+    async def get_room(self, world_id: int, slug: str) -> WorldRoom | None:
+        result = await self.db.execute(
+            select(WorldRoom).where(WorldRoom.world_id == world_id, WorldRoom.slug == slug)
+        )
+        return result.scalar_one_or_none()
+
+    async def list_rooms(self, world_id: int) -> list[WorldRoom]:
+        result = await self.db.execute(
+            select(WorldRoom).where(WorldRoom.world_id == world_id).order_by(WorldRoom.id)
+        )
+        return list(result.scalars().all())
+
+    async def create_room(
+        self,
+        world_id: int,
+        slug: str,
+        name: str,
+        *,
+        grid: dict | None = None,
+        bounds: dict | None = None,
+        spawn: dict | None = None,
+    ) -> WorldRoom:
+        room = WorldRoom(world_id=world_id, slug=slug, name=name)
+        if grid is not None:
+            room.grid = grid
+        if bounds is not None:
+            room.bounds = bounds
+        if spawn is not None:
+            room.spawn = spawn
+        self.db.add(room)
+        await self.db.flush()
+        await self.db.refresh(room)
+        return room
+
+    async def get_or_create_main_room(self, world_id: int) -> WorldRoom:
+        """world_persistence_impl.md §4.1: every world gets a ``main`` room.
+        Called from ``create_world`` for new worlds, and lazily here for
+        worlds that predate this migration."""
+        room = await self.get_room(world_id, MAIN_ROOM_SLUG)
+        if room is not None:
+            return room
+        try:
+            return await self.create_room(world_id, MAIN_ROOM_SLUG, MAIN_ROOM_NAME)
+        except IntegrityError:
+            # Lost a race with a concurrent creator; the row now exists.
+            await self.db.rollback()
+            room = await self.get_room(world_id, MAIN_ROOM_SLUG)
+            if room is None:
+                raise
+            return room
+
+    async def count_chunks(self, room_id: int) -> int:
+        result = await self.db.execute(
+            select(func.count()).select_from(WorldChunk).where(WorldChunk.room_id == room_id)
+        )
+        return int(result.scalar_one())
+
+    async def content_revision(self, world_id: int) -> int:
+        """See module docstring for why this is derived rather than stored."""
+        result = await self.db.execute(
+            select(func.max(WorldChunkRevision.id)).where(WorldChunkRevision.world_id == world_id)
+        )
+        return int(result.scalar() or 0)
+
+    # ── chunk reads ──────────────────────────────────────────────────────
+
+    async def get_chunk(self, key: str) -> WorldChunk | None:
+        result = await self.db.execute(select(WorldChunk).where(WorldChunk.chunk_key == key))
+        return result.scalar_one_or_none()
+
+    async def get_chunk_by_coord(self, room_id: int, cx: int, cy: int, cz: int) -> WorldChunk | None:
+        result = await self.db.execute(
+            select(WorldChunk).where(
+                WorldChunk.room_id == room_id, WorldChunk.cx == cx,
+                WorldChunk.cy == cy, WorldChunk.cz == cz,
+            )
+        )
+        return result.scalar_one_or_none()
+
+    async def get_chunk_binary(self, key: str) -> bytes | None:
+        chunk = await self.get_chunk(key)
+        return chunk.payload if chunk is not None else None
+
+    async def get_chunk_flags(self, key: str) -> dict | None:
+        chunk = await self.get_chunk(key)
+        return chunk.content_flags if chunk is not None else None
+
+    async def list_chunks(
+        self,
+        world_id: int,
+        room_id: int | None = None,
+        bounds: Bounds | None = None,
+    ) -> list[WorldChunk]:
+        """Index query -- world.md §5.1's ``list_chunks``. Payload bytes are
+        deliberately not loaded (world_persistence_impl.md §8.1: "Payloads
+        are not included")."""
+        query = select(WorldChunk).options(
+            load_only(
+                WorldChunk.id, WorldChunk.world_id, WorldChunk.room_id, WorldChunk.chunk_key,
+                WorldChunk.cx, WorldChunk.cy, WorldChunk.cz, WorldChunk.revision,
+                WorldChunk.checksum, WorldChunk.payload_len, WorldChunk.is_mature,
+                WorldChunk.updated_at,
+            )
+        ).where(WorldChunk.world_id == world_id)
+        if room_id is not None:
+            query = query.where(WorldChunk.room_id == room_id)
+        if bounds is not None:
+            if bounds.cx_min is not None:
+                query = query.where(WorldChunk.cx >= bounds.cx_min)
+            if bounds.cx_max is not None:
+                query = query.where(WorldChunk.cx <= bounds.cx_max)
+            if bounds.cy_min is not None:
+                query = query.where(WorldChunk.cy >= bounds.cy_min)
+            if bounds.cy_max is not None:
+                query = query.where(WorldChunk.cy <= bounds.cy_max)
+            if bounds.cz is not None:
+                query = query.where(WorldChunk.cz == bounds.cz)
+        query = query.order_by(WorldChunk.cx, WorldChunk.cy, WorldChunk.cz)
+        result = await self.db.execute(query)
+        return list(result.scalars().all())
+
+    # ── chunk writes ─────────────────────────────────────────────────────
+
+    async def put_chunk(
+        self,
+        *,
+        room: WorldRoom,
+        cx: int,
+        cy: int,
+        cz: int,
+        payload_bytes: bytes,
+        base_revision: int,
+        actor_id: int | None,
+    ) -> WorldChunk:
+        """Full-chunk write with optimistic concurrency (world.md §5.4,
+        world_persistence_impl.md §5.4/§8.2). Validates the payload
+        server-side (§5.5) before ever touching a row. ``base_revision=0``
+        means "create; 409 if it already exists"."""
+        key = chunk_codec.build_key(room.world_id, room.slug, cx, cy, cz)
+        grid_size = tuple(room.grid.get("size", [32, 32, 1]))
+
+        # Raises ChunkCodecError / ChunkValidationError -- the router maps
+        # those to 422. Nothing below trusts the request body's own claims
+        # about content_flags/is_mature; both come from `decoded`.
+        decoded = chunk_codec.decode_and_validate(
+            payload_bytes,
+            expected_key=key,
+            grid_size=grid_size,
+            max_objects=settings.WORLD_CHUNK_MAX_OBJECTS,
+        )
+        body_checksum = chunk_codec.checksum(payload_bytes[chunk_codec.HEADER_SIZE:])
+
+        result = await self.db.execute(
+            select(WorldChunk)
+            .where(
+                WorldChunk.room_id == room.id, WorldChunk.cx == cx,
+                WorldChunk.cy == cy, WorldChunk.cz == cz,
+            )
+            .with_for_update()
+        )
+        row = result.scalar_one_or_none()
+
+        if base_revision == 0:
+            if row is not None:
+                raise RevisionConflict(row.revision, row.checksum, (cx, cy, cz))
+            row = WorldChunk(
+                world_id=room.world_id, room_id=room.id, chunk_key=key,
+                cx=cx, cy=cy, cz=cz, revision=1,
+            )
+            self.db.add(row)
+            action = "create"
+        else:
+            if row is None or row.revision != base_revision:
+                raise RevisionConflict(
+                    row.revision if row else 0, row.checksum if row else None, (cx, cy, cz)
+                )
+            row.revision = row.revision + 1
+            action = "update"
+
+        row.format_version = decoded.version
+        row.payload = payload_bytes
+        row.payload_len = len(payload_bytes)
+        row.checksum = body_checksum
+        row.content_flags = decoded.flags.to_dict()
+        row.is_mature = decoded.flags.mature
+        row.updated_by_id = actor_id
+
+        try:
+            await self.db.flush()
+        except IntegrityError:
+            # Lost a create race to a concurrent writer between our SELECT
+            # and this flush. Roll back and report the real current state.
+            await self.db.rollback()
+            existing = await self.get_chunk_by_coord(room.id, cx, cy, cz)
+            raise RevisionConflict(
+                existing.revision if existing else 0,
+                existing.checksum if existing else None,
+                (cx, cy, cz),
+            )
+
+        await self._record_revision(key, room.world_id, row.revision, action, actor_id, body_checksum, payload_bytes)
+        await self.db.refresh(row)
+        return row
+
+    async def put_chunks_batch(
+        self,
+        *,
+        room: WorldRoom,
+        items: list[dict],
+        actor_id: int | None,
+    ) -> list[WorldChunk]:
+        """Batch write (world_persistence_impl.md §8.1). One transaction,
+        all-or-nothing: none of this ``commit()``s, so a ``RevisionConflict``
+        raised partway leaves nothing persisted once the caller's request
+        handler lets the exception (or the HTTPException it becomes)
+        propagate through ``get_db``, which rolls back on any exception."""
+        rows: list[WorldChunk] = []
+        for item in items:
+            row = await self.put_chunk(
+                room=room, cx=item["cx"], cy=item["cy"], cz=item["cz"],
+                payload_bytes=item["payload_bytes"], base_revision=item["base_revision"],
+                actor_id=actor_id,
+            )
+            rows.append(row)
+        return rows
+
+    async def delete_chunk(self, key: str, actor_id: int | None) -> None:
+        row = await self.get_chunk(key)
+        if row is None:
+            return
+        await self._record_revision(key, row.world_id, row.revision, "delete", actor_id, row.checksum, None)
+        await self.db.delete(row)
+        await self.db.flush()
+
+    async def rollback_chunk(self, key: str, revision: int, actor_id: int | None) -> WorldChunk:
+        """Restore a chunk to a previously-recorded revision's payload
+        (world.md §5.1). Raises ``RevisionNotAvailable`` if that revision
+        was never recorded, its payload was pruned by retention, or the
+        chunk has since been deleted outright (nothing to update in place)."""
+        rev_result = await self.db.execute(
+            select(WorldChunkRevision)
+            .where(WorldChunkRevision.chunk_key == key, WorldChunkRevision.revision == revision)
+            .order_by(WorldChunkRevision.id.desc())
+            .limit(1)
+        )
+        rev_row = rev_result.scalar_one_or_none()
+        if rev_row is None:
+            raise RevisionNotAvailable(f"no revision {revision} recorded for {key!r}")
+        if rev_row.payload is None:
+            raise RevisionNotAvailable(f"revision {revision} of {key!r} was pruned; payload unavailable")
+
+        chunk = await self.get_chunk(key)
+        if chunk is None:
+            raise RevisionNotAvailable(f"chunk {key!r} no longer exists; cannot roll back in place")
+
+        room_result = await self.db.execute(select(WorldRoom).where(WorldRoom.id == chunk.room_id))
+        room = room_result.scalar_one()
+        grid_size = tuple(room.grid.get("size", [32, 32, 1]))
+        decoded = chunk_codec.decode_and_validate(
+            rev_row.payload, expected_key=key, grid_size=grid_size,
+            max_objects=settings.WORLD_CHUNK_MAX_OBJECTS,
+        )
+        body_checksum = chunk_codec.checksum(rev_row.payload[chunk_codec.HEADER_SIZE:])
+
+        chunk.revision = chunk.revision + 1
+        chunk.payload = rev_row.payload
+        chunk.payload_len = len(rev_row.payload)
+        chunk.checksum = body_checksum
+        chunk.format_version = decoded.version
+        chunk.content_flags = decoded.flags.to_dict()
+        chunk.is_mature = decoded.flags.mature
+        chunk.updated_by_id = actor_id
+
+        await self.db.flush()
+        # Tagged "update" (not a fourth action value) to keep the
+        # documented 'create'|'update'|'delete' action enum intact.
+        await self._record_revision(
+            key, chunk.world_id, chunk.revision, "update", actor_id, body_checksum, rev_row.payload
+        )
+        await self.db.refresh(chunk)
+        return chunk
+
+    async def list_revisions(self, chunk_key: str, limit: int = 50) -> list[WorldChunkRevision]:
+        """Not in world.md §5.1's interface by name, but required to
+        implement the revision-history endpoint world_persistence_impl.md
+        §8.1 lists (``GET .../revisions``)."""
+        result = await self.db.execute(
+            select(WorldChunkRevision)
+            .where(WorldChunkRevision.chunk_key == chunk_key)
+            .order_by(WorldChunkRevision.revision.desc(), WorldChunkRevision.id.desc())
+            .limit(limit)
+        )
+        return list(result.scalars().all())
+
+    async def migrate(self) -> None:
+        """No-op. `world.md` §4.8's hand-rolled SQLite migration runner is
+        superseded by Alembic (`backend/alembic/`) now that content lives
+        in Postgres (world_persistence_impl.md §3.3). Kept only so this
+        class's shape still matches the §5.1 interface it's implementing
+        a subset of."""
+        return None
+
+    # ── internals ────────────────────────────────────────────────────────
+
+    async def _record_revision(
+        self,
+        chunk_key: str,
+        world_id: int,
+        revision: int,
+        action: str,
+        actor_id: int | None,
+        checksum_hex: str,
+        payload_bytes: bytes | None,
+    ) -> None:
+        """Append an audit row and enforce the retention policy
+        (world_persistence_impl.md §4.3, required): keep the newest
+        ``WORLD_CHUNK_REVISION_KEEP`` payloads per ``chunk_key``, null out
+        ``payload`` on older rows, in the same transaction as the write."""
+        rev = WorldChunkRevision(
+            chunk_key=chunk_key, world_id=world_id, revision=revision, action=action,
+            actor_id=actor_id, checksum=checksum_hex, payload=payload_bytes,
+        )
+        self.db.add(rev)
+        await self.db.flush()
+
+        keep = settings.WORLD_CHUNK_REVISION_KEEP
+        keep_ids_result = await self.db.execute(
+            select(WorldChunkRevision.id)
+            .where(WorldChunkRevision.chunk_key == chunk_key)
+            .order_by(WorldChunkRevision.id.desc())
+            .limit(keep)
+        )
+        keep_ids = [row[0] for row in keep_ids_result.all()]
+        if keep_ids:
+            await self.db.execute(
+                update(WorldChunkRevision)
+                .where(
+                    WorldChunkRevision.chunk_key == chunk_key,
+                    WorldChunkRevision.id.notin_(keep_ids),
+                    WorldChunkRevision.payload.isnot(None),
+                )
+                .values(payload=None)
+            )

backend/tests/conftest.py

@@ -30,7 +30,16 @@ from app.config import settings
 from app.database import get_db
 from app.main import app
 
-TEST_TABLES = ("avatar_loadouts", "assets", "worlds", "sessions", "refresh_tokens", "users")
+TEST_TABLES = (
+    "avatar_loadouts", "assets",
+    # world_chunk_revisions has no FK to worlds/world_chunks (world.md §4.7 /
+    # world_persistence_impl.md §4.3, deliberate -- deleting a chunk or world
+    # must not lose the audit trail), so it won't be cascade-truncated via
+    # `worlds` the way world_rooms/world_chunks would be. List all three
+    # explicitly rather than rely on cascade for some of them.
+    "world_chunk_revisions", "world_chunks", "world_rooms",
+    "worlds", "sessions", "refresh_tokens", "users",
+)
 
 BACKEND_DIR = Path(__file__).resolve().parents[1]
 _COMPOSE_PROJECT = "agp-pytest"

backend/tests/fixtures/chunks/generate_fixtures.py

@@ -0,0 +1,105 @@
+"""Generates the golden-file chunk fixtures in this directory.
+
+These pin the world.md §3.6 binary format so the Python codec
+(app/services/chunk_codec.py) and any future Godot-side test fixture can be
+checked for drift (world_persistence_impl.md §5.5's "drift control"
+requirement). No Godot-side golden fixture existed at the time this was
+written (searched scripts/ and tests/ for AGPC / binary-format test
+vectors -- none found), so these are authored here, from this
+implementation, as the first golden files for the format. The client/editor
+follow-on task should decode these same files with
+`ChunkDataDecoder.decode_binary()` and assert the same logical values
+(see the note in chunk_codec.py about a confirmed float32 handling bug in
+that decoder that will need fixing for full byte parity on non-integer
+transforms).
+
+Run with: `python tests/fixtures/chunks/generate_fixtures.py` from `backend/`.
+Fixtures are checked in; this script is for regenerating them if the format
+or these examples change, not run as part of the test suite.
+"""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[3]))  # backend/
+
+from app.services import chunk_codec as cc
+
+FIXTURES_DIR = Path(__file__).resolve().parent
+
+
+def _empty_chunk() -> cc.ChunkPayload:
+    return cc.ChunkPayload(
+        world_id="7", room_id="main", coord=(0, 0, 0),
+        bounds=cc.ChunkBounds(min=(0.0, 0.0, 0.0), size=(32.0, 32.0, 1.0)),
+        tile_layers=[], objects=[],
+        flags=cc.ContentFlags(),
+        created_at=1_700_000_000, updated_at=1_700_000_000, revision=1, author="fixture-gen",
+    )
+
+
+def _simple_tile_chunk() -> cc.ChunkPayload:
+    layer = cc.TileLayer(
+        name="ground", layer_id=0, width=4, height=4, depth=1,
+        palette=[
+            cc.TileDef(id=0, asset_id="", solid=False, flags=0, variants=1),
+            cc.TileDef(id=1, asset_id="tiles/grass", solid=False, flags=1, variants=4),
+            cc.TileDef(id=2, asset_id="tiles/stone", solid=True, flags=2, variants=2),
+        ],
+        tiles=[0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1, 0, 1, 1, 0],
+    )
+    return cc.ChunkPayload(
+        world_id="12", room_id="main", coord=(3, -1, 0),
+        bounds=cc.ChunkBounds(min=(96.0, -32.0, 0.0), size=(32.0, 32.0, 1.0)),
+        tile_layers=[layer], objects=[],
+        flags=cc.ContentFlags(violence=0, mature=False, sources=[]),
+        created_at=1_700_000_000, updated_at=1_700_000_500, revision=2, author="fixture-gen",
+    )
+
+
+def _chunk_with_objects() -> cc.ChunkPayload:
+    layer = cc.TileLayer(
+        name="ground", layer_id=0, width=2, height=2, depth=1,
+        palette=[cc.TileDef(id=0, asset_id="", solid=False, flags=0, variants=1)],
+        tiles=[0, 0, 0, 0],
+    )
+    obj1 = cc.WorldObject(
+        id="obj_0001", type="interactable", asset_id="props/chest",
+        pos=(101.5, -110.25, 0.5), rot=(0.0, 0.0, 0.0, 1.0), scale=(1.0, 1.0, 1.0),
+        dynamic=False,
+        properties={"locked": False, "loot_table": "chest_basic"},
+        flags=cc.ContentFlags(violence=0, mature=False, sources=[]),
+    )
+    obj2 = cc.WorldObject(
+        id="obj_0002", type="spawn_point", asset_id="",
+        pos=(96.0, -128.0, 1.0), rot=(0.0, 0.7071, 0.0, 0.7071), scale=(1.0, 1.0, 1.0),
+        dynamic=True,
+        properties={},
+        flags=cc.ContentFlags(violence=1, mature=False, sources=["asset:props/chest"]),
+    )
+    return cc.ChunkPayload(
+        world_id="12", room_id="main", coord=(3, -4, 0),
+        bounds=cc.ChunkBounds(min=(96.0, -128.0, 0.0), size=(32.0, 32.0, 1.0)),
+        tile_layers=[layer], objects=[obj1, obj2],
+        flags=cc.ContentFlags(violence=1, mature=False, sources=["asset:props/chest"]),
+        created_at=1_700_000_000, updated_at=1_700_001_000, revision=5, author="agent-bot",
+    )
+
+
+FIXTURES = {
+    "empty_chunk.bin": _empty_chunk,
+    "simple_tile_chunk.bin": _simple_tile_chunk,
+    "chunk_with_objects.bin": _chunk_with_objects,
+}
+
+
+def main() -> None:
+    for filename, builder in FIXTURES.items():
+        payload = builder()
+        data = cc.encode_binary(payload)
+        (FIXTURES_DIR / filename).write_bytes(data)
+        print(f"wrote {filename} ({len(data)} bytes)")
+
+
+if __name__ == "__main__":
+    main()

backend/tests/test_chunk_codec.py

@@ -0,0 +1,219 @@
+"""Tests for app.services.chunk_codec -- the Python port of world.md §3.6.
+
+Pure unit tests: no database, no app, no network. Golden fixtures live in
+tests/fixtures/chunks/ (see generate_fixtures.py there for how/why).
+"""
+
+from pathlib import Path
+
+import pytest
+
+from app.services import chunk_codec as cc
+
+FIXTURES_DIR = Path(__file__).resolve().parent / "fixtures" / "chunks"
+
+
+def _read_fixture(name: str) -> bytes:
+    return (FIXTURES_DIR / name).read_bytes()
+
+
+class TestGoldenFixtures:
+    """Byte-stability: decode a committed fixture, re-encode it, and the
+    bytes must match exactly (world.md §3.6.3)."""
+
+    @pytest.mark.parametrize("filename", [
+        "empty_chunk.bin", "simple_tile_chunk.bin", "chunk_with_objects.bin",
+    ])
+    def test_round_trip_is_byte_identical(self, filename):
+        original = _read_fixture(filename)
+        decoded = cc.decode_binary(original)
+        re_encoded = cc.encode_binary(decoded)
+        assert re_encoded == original
+
+    def test_simple_tile_chunk_logical_values(self):
+        decoded = cc.decode_binary(_read_fixture("simple_tile_chunk.bin"))
+        assert decoded.world_id == "12"
+        assert decoded.room_id == "main"
+        assert decoded.coord == (3, -1, 0)
+        assert decoded.bounds.min == (96.0, -32.0, 0.0)
+        assert decoded.bounds.size == (32.0, 32.0, 1.0)
+        assert len(decoded.tile_layers) == 1
+        layer = decoded.tile_layers[0]
+        assert layer.name == "ground"
+        assert (layer.width, layer.height, layer.depth) == (4, 4, 1)
+        assert len(layer.palette) == 3
+        assert layer.tiles == [0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1, 0, 1, 1, 0]
+        assert decoded.revision == 2
+        assert decoded.author == "fixture-gen"
+
+    def test_chunk_with_objects_logical_values(self):
+        decoded = cc.decode_binary(_read_fixture("chunk_with_objects.bin"))
+        assert len(decoded.objects) == 2
+        obj1, obj2 = decoded.objects
+        assert obj1.id == "obj_0001"
+        assert obj1.type == "interactable"
+        assert obj1.pos == (101.5, -110.25, 0.5)
+        assert obj1.properties == {"locked": False, "loot_table": "chest_basic"}
+        assert obj2.id == "obj_0002"
+        assert obj2.dynamic is True
+        assert obj2.flags.violence == 1
+        assert obj2.flags.sources == ["asset:props/chest"]
+        assert decoded.flags.violence == 1
+        assert decoded.flags.sources == ["asset:props/chest"]
+
+    def test_empty_chunk_has_no_layers_or_objects(self):
+        decoded = cc.decode_binary(_read_fixture("empty_chunk.bin"))
+        assert decoded.tile_layers == []
+        assert decoded.objects == []
+
+
+class TestChecksum:
+    def test_checksum_is_sha256_hex(self):
+        import hashlib
+        assert cc.checksum(b"") == hashlib.sha256(b"").hexdigest()
+        assert len(cc.checksum(b"")) == 64
+
+    def test_header_checksum_matches_recomputed_for_valid_fixture(self):
+        data = _read_fixture("simple_tile_chunk.bin")
+        header_checksum_hex = data[16:48].hex()
+        body = data[cc.HEADER_SIZE:]
+        assert header_checksum_hex == cc.checksum(body)
+
+
+class TestBuildKey:
+    def test_matches_world_persistence_impl_4_5_format(self):
+        assert cc.build_key(12, "main", 3, -1, 0) == "12:main:3:-1:0"
+        assert cc.build_key("12", "main", 3, -1, 0) == "12:main:3:-1:0"
+
+
+class TestFloat32Fidelity:
+    """This is the concrete regression test for the cross-codec divergence
+    documented at the bottom of chunk_codec.py: this module must encode
+    real IEEE-754 float32, including fractional and negative values,
+    round-tripping exactly (up to float32 precision) -- unlike
+    scripts/chunk_data_decoder.gd's current int-truncating implementation."""
+
+    def test_fractional_and_negative_floats_survive_round_trip(self):
+        payload = cc.ChunkPayload(
+            world_id="1", room_id="main", coord=(0, 0, 0),
+            bounds=cc.ChunkBounds(min=(-17.25, 0.125, -3.0), size=(32.0, 32.0, 1.0)),
+            objects=[cc.WorldObject(
+                id="o1", type="prop", asset_id="a",
+                pos=(1.5, -2.75, 0.001), rot=(0.0, 0.7071068, 0.0, 0.7071068),
+                scale=(1.0, 1.0, 1.0),
+            )],
+        )
+        encoded = cc.encode_binary(payload)
+        decoded = cc.decode_binary(encoded)
+        assert decoded.bounds.min == pytest.approx((-17.25, 0.125, -3.0), abs=1e-6)
+        assert decoded.objects[0].pos == pytest.approx((1.5, -2.75, 0.001), abs=1e-6)
+        assert decoded.objects[0].rot == pytest.approx(
+            (0.0, 0.7071068, 0.0, 0.7071068), abs=1e-6
+        )
+
+
+class TestMalformedInput:
+    def test_bad_magic_raises_codec_error(self):
+        data = bytearray(_read_fixture("empty_chunk.bin"))
+        data[0:4] = b"XXXX"
+        with pytest.raises(cc.ChunkCodecError):
+            cc.decode_binary(bytes(data))
+
+    def test_too_short_raises_codec_error(self):
+        with pytest.raises(cc.ChunkCodecError):
+            cc.decode_binary(b"AGPC\x01\x00")
+
+    def test_unsupported_version_raises_codec_error(self):
+        data = bytearray(_read_fixture("empty_chunk.bin"))
+        data[4:6] = (99).to_bytes(2, "little")
+        with pytest.raises(cc.ChunkCodecError):
+            cc.decode_binary(bytes(data))
+
+    def test_payload_len_mismatch_raises_codec_error(self):
+        data = bytearray(_read_fixture("empty_chunk.bin"))
+        # Corrupt the declared payload_len (offset 12..16).
+        data[12:16] = (99999).to_bytes(4, "little")
+        with pytest.raises(cc.ChunkCodecError):
+            cc.decode_binary(bytes(data))
+
+
+class TestValidation:
+    """decode_and_validate: the server-side "don't trust the client"
+    boundary (world_persistence_impl.md §5.5)."""
+
+    def _valid_args(self):
+        return {
+            "expected_key": "12:main:3:-1:0",
+            "grid_size": (4, 4, 1),
+            "max_objects": 512,
+        }
+
+    def test_valid_payload_passes(self):
+        data = _read_fixture("simple_tile_chunk.bin")
+        payload = cc.decode_and_validate(data, **self._valid_args())
+        assert payload.coord == (3, -1, 0)
+
+    def test_checksum_mismatch_detected(self):
+        data = bytearray(_read_fixture("simple_tile_chunk.bin"))
+        # Corrupt one byte of the header's advisory checksum field
+        # (offset 16..48) only -- magic/version/payload_len and the whole
+        # payload body stay untouched, so this exercises exactly the
+        # "recomputed checksum disagrees with the header" path rather than
+        # also breaking structural decoding.
+        data[16] ^= 0xFF
+        with pytest.raises(cc.ChunkValidationError) as exc_info:
+            cc.decode_and_validate(bytes(data), **self._valid_args())
+        assert exc_info.value.reason == "checksum_mismatch"
+
+    def test_chunk_key_mismatch_detected(self):
+        data = _read_fixture("simple_tile_chunk.bin")
+        args = self._valid_args()
+        args["expected_key"] = "12:main:99:99:0"  # doesn't match the payload's own coord
+        with pytest.raises(cc.ChunkValidationError) as exc_info:
+            cc.decode_and_validate(data, **args)
+        assert exc_info.value.reason == "chunk_key_mismatch"
+
+    def test_layer_dims_mismatch_detected(self):
+        data = _read_fixture("simple_tile_chunk.bin")
+        args = self._valid_args()
+        args["grid_size"] = (8, 8, 1)  # fixture's layer is 4x4x1
+        with pytest.raises(cc.ChunkValidationError) as exc_info:
+            cc.decode_and_validate(data, **args)
+        assert exc_info.value.reason == "layer_dims"
+
+    def test_too_many_objects_detected(self):
+        data = _read_fixture("chunk_with_objects.bin")  # has 2 objects
+        args = self._valid_args()
+        args["expected_key"] = "12:main:3:-4:0"
+        args["grid_size"] = (2, 2, 1)
+        args["max_objects"] = 1
+        with pytest.raises(cc.ChunkValidationError) as exc_info:
+            cc.decode_and_validate(data, **args)
+        assert exc_info.value.reason == "too_many_objects"
+
+    def test_object_out_of_bounds_detected(self):
+        payload = cc.ChunkPayload(
+            world_id="1", room_id="main", coord=(0, 0, 0),
+            bounds=cc.ChunkBounds(min=(0.0, 0.0, 0.0), size=(32.0, 32.0, 1.0)),
+            objects=[cc.WorldObject(id="o1", type="prop", asset_id="a", pos=(9999.0, 0.0, 0.0))],
+        )
+        data = cc.encode_binary(payload)
+        with pytest.raises(cc.ChunkValidationError) as exc_info:
+            cc.decode_and_validate(
+                data, expected_key="1:main:0:0:0", grid_size=(32, 32, 1), max_objects=10
+            )
+        assert exc_info.value.reason == "object_out_of_bounds"
+
+    def test_tile_out_of_palette_detected(self):
+        layer = cc.TileLayer(
+            name="ground", width=2, height=2, depth=1,
+            palette=[cc.TileDef(id=1)],  # tile 5 below isn't in this palette
+            tiles=[1, 5, 0, 1],
+        )
+        payload = cc.ChunkPayload(world_id="1", room_id="main", coord=(0, 0, 0), tile_layers=[layer])
+        data = cc.encode_binary(payload)
+        with pytest.raises(cc.ChunkValidationError) as exc_info:
+            cc.decode_and_validate(
+                data, expected_key="1:main:0:0:0", grid_size=(2, 2, 1), max_objects=10
+            )
+        assert exc_info.value.reason == "tile_out_of_palette"

backend/tests/test_game_servers.py

@@ -0,0 +1,153 @@
+"""Unit tests for the game_servers.py changes made for world persistence
+(world_persistence_impl.md §7.3/§7.4): per-spawn token validation, and the
+``_await_ready`` replacement for the old, fail-open ``_await_port``.
+
+No real Godot process is spawned here (that stays a manual/checkpoint
+integration test, per test_world_join.py's docstring) -- these exercise
+``GameServerSupervisor`` against a fake process object standing in for
+``subprocess.Popen``.
+"""
+
+import json
+
+import pytest
+
+from app.config import settings
+from app.services.game_servers import GameServerSupervisor, _WorldServer
+
+
+class _FakeProc:
+    """Stands in for subprocess.Popen: only .poll() is needed by the code
+    paths under test here."""
+
+    def __init__(self, exited: bool = False):
+        self._exited = exited
+
+    def poll(self):
+        return 0 if self._exited else None
+
+    def terminate(self):
+        self._exited = True
+
+    def wait(self, timeout=None):
+        return 0
+
+    def kill(self):
+        self._exited = True
+
+
+def _make_srv(tmp_path, token="secret", alive=True) -> _WorldServer:
+    status_path = tmp_path / "status.json"
+    return _WorldServer(
+        world_id="7", port=27000, proc=_FakeProc(exited=not alive),
+        status_path=status_path, token=token,
+    )
+
+
+class TestValidateToken:
+    def test_unknown_world_is_false(self):
+        sup = GameServerSupervisor()
+        assert sup.validate_token("no-such-world", "anything") is False
+
+    def test_correct_token_is_true(self, tmp_path):
+        sup = GameServerSupervisor()
+        sup._servers["7"] = _make_srv(tmp_path, token="secret")
+        assert sup.validate_token("7", "secret") is True
+        # world_id is looked up as str(world_id), so an int works too --
+        # this matters because the FastAPI path param is an int.
+        assert sup.validate_token(7, "secret") is True
+
+    def test_wrong_token_is_false(self, tmp_path):
+        sup = GameServerSupervisor()
+        sup._servers["7"] = _make_srv(tmp_path, token="secret")
+        assert sup.validate_token("7", "wrong") is False
+
+    def test_token_scoped_to_its_own_world_only(self, tmp_path):
+        sup = GameServerSupervisor()
+        sup._servers["7"] = _make_srv(tmp_path, token="secret")
+        # Same token, different world_id -- must not authenticate (§7.3:
+        # "a path whose world_id differs from the token's world is 403").
+        assert sup.validate_token("8", "secret") is False
+
+    def test_dead_server_token_is_false(self, tmp_path):
+        sup = GameServerSupervisor()
+        sup._servers["7"] = _make_srv(tmp_path, token="secret", alive=False)
+        assert sup.validate_token("7", "secret") is False
+
+    def test_reaping_invalidates_the_token(self, tmp_path):
+        """§7.3: "dies with its process" -- once removed from _servers
+        (what the reaper does), the same token no longer validates."""
+        sup = GameServerSupervisor()
+        sup._servers["7"] = _make_srv(tmp_path, token="secret")
+        assert sup.validate_token("7", "secret") is True
+        del sup._servers["7"]
+        assert sup.validate_token("7", "secret") is False
+
+
+class TestAwaitReady:
+    """Replaces the old _await_port, which (a) treated a bound UDP port as
+    readiness even though content loading happens before create_server, and
+    (b) failed open past its deadline with no error at all."""
+
+    async def test_raises_timeout_error_when_never_ready(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(settings, "GAME_SERVER_READY_TIMEOUT_SECONDS", 0.3)
+        sup = GameServerSupervisor()
+        srv = _make_srv(tmp_path)  # status file never written
+        with pytest.raises(TimeoutError):
+            await sup._await_ready(srv)
+
+    async def test_returns_once_status_file_reports_ready(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(settings, "GAME_SERVER_READY_TIMEOUT_SECONDS", 5.0)
+        sup = GameServerSupervisor()
+        srv = _make_srv(tmp_path)
+        srv.status_path.write_text(json.dumps({"ready": True, "players": 0}))
+        await sup._await_ready(srv)  # must not raise / must not hang
+
+    async def test_ready_false_is_not_ready(self, tmp_path, monkeypatch):
+        monkeypatch.setattr(settings, "GAME_SERVER_READY_TIMEOUT_SECONDS", 0.3)
+        sup = GameServerSupervisor()
+        srv = _make_srv(tmp_path)
+        srv.status_path.write_text(json.dumps({"ready": False, "players": 0}))
+        with pytest.raises(TimeoutError):
+            await sup._await_ready(srv)
+
+    async def test_raises_promptly_if_process_already_exited(self, tmp_path, monkeypatch):
+        # A long deadline, but the process is already dead -- must not wait
+        # out the full deadline (this is the "no crash restart mid-wait"
+        # case: don't silently poll a corpse for 20s).
+        monkeypatch.setattr(settings, "GAME_SERVER_READY_TIMEOUT_SECONDS", 20.0)
+        sup = GameServerSupervisor()
+        srv = _make_srv(tmp_path, alive=False)
+        with pytest.raises(TimeoutError):
+            await sup._await_ready(srv)
+
+
+class TestSpawnCommandLine:
+    def test_spawn_includes_api_url_and_server_token(self, monkeypatch, tmp_path):
+        """world_persistence_impl.md §7.2 step 1 / §7.4: `_spawn` must pass
+        --api-url and --server-token on the command line."""
+        sup = GameServerSupervisor()
+        monkeypatch.setattr(sup, "_free_port", lambda: 27050)
+
+        captured = {}
+
+        class _Proc:
+            def poll(self):
+                return None
+
+        def _fake_popen(cmd, **kwargs):
+            captured["cmd"] = cmd
+            return _Proc()
+
+        monkeypatch.setattr(
+            "app.services.game_servers.subprocess.Popen", _fake_popen
+        )
+        srv = sup._spawn("42")
+
+        cmd = captured["cmd"]
+        assert "--api-url" in cmd
+        assert cmd[cmd.index("--api-url") + 1] == settings.GAME_SERVER_INTERNAL_API_URL
+        assert "--server-token" in cmd
+        token_in_cmd = cmd[cmd.index("--server-token") + 1]
+        assert token_in_cmd == srv.token
+        assert len(srv.token) > 20  # secrets.token_urlsafe(32) -- not a short/guessable value

backend/tests/test_world_content.py

@@ -0,0 +1,490 @@
+"""Integration tests for the world content API: rooms + chunks.
+
+Covers docs/architecture/world_persistence_impl.md §8.1 (public router,
+app/routers/world_content.py) and §8.3 (internal router,
+app/routers/internal.py), plus the create_world -> auto "main" room
+behaviour (§4.1).
+
+Runs against the real ephemeral Postgres the hermetic conftest.py stands
+up -- these are full HTTP round trips through TestClient, not mocked.
+"""
+
+import base64
+
+import pytest
+from fastapi.testclient import TestClient
+
+from app.main import app
+from app.services import chunk_codec as cc
+from app.services.game_servers import supervisor
+
+GRID_32 = (32, 32, 1)
+
+
+def _auth(client: TestClient, name: str) -> tuple[dict, int]:
+    r = client.post("/api/auth/register", json={
+        "username": name, "email": f"{name}@e.com", "password": "secret123",
+        "date_of_birth": "1990-01-01",
+    })
+    assert r.status_code == 201, r.text
+    headers = {"Authorization": f"Bearer {r.json()['access_token']}"}
+    me = client.get("/api/users/me", headers=headers)
+    return headers, me.json()["id"]
+
+
+def _make_world(client: TestClient, headers: dict, visibility: str = "public") -> int:
+    r = client.post("/api/worlds/", headers=headers, json={"name": "W", "visibility": visibility})
+    assert r.status_code == 201, r.text
+    return r.json()["id"]
+
+
+def _build_chunk(world_id: int, slug: str, cx: int, cy: int, cz: int, *,
+                  grid=GRID_32, revision: int = 1, extra_tag: str = "") -> bytes:
+    """A small but structurally-real chunk payload for `world_id`/`slug`/coord,
+    sized to match the room's default 32x32x1 grid."""
+    w, h, d = grid
+    layer = cc.TileLayer(
+        name="ground", layer_id=0, width=w, height=h, depth=d,
+        palette=[cc.TileDef(id=0, asset_id="", solid=False, flags=0, variants=1)],
+        tiles=[0] * (w * h * d),
+    )
+    obj = cc.WorldObject(
+        id=f"obj_{extra_tag or '1'}", type="prop", asset_id="props/rock",
+        pos=(1.0, 1.0, 0.0), properties={"tag": extra_tag},
+    )
+    payload = cc.ChunkPayload(
+        world_id=str(world_id), room_id=slug, coord=(cx, cy, cz),
+        bounds=cc.ChunkBounds(min=(0.0, 0.0, 0.0), size=(float(w), float(h), float(d))),
+        tile_layers=[layer], objects=[obj], revision=revision, author="pytest",
+        created_at=1_700_000_000, updated_at=1_700_000_000,
+    )
+    return cc.encode_binary(payload)
+
+
+class TestCreateWorldMainRoom:
+    def test_create_world_auto_creates_main_room(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "cw_main")
+        wid = _make_world(client, headers)
+
+        r = client.get(f"/api/worlds/{wid}/rooms", headers=headers)
+        assert r.status_code == 200, r.text
+        rooms = r.json()
+        assert len(rooms) == 1
+        assert rooms[0]["slug"] == "main"
+        assert rooms[0]["name"] == "Main"
+        assert rooms[0]["chunk_count"] == 0
+        assert rooms[0]["grid"]["size"] == [32, 32, 1]
+
+
+class TestRoomAuth:
+    def test_create_room_requires_owner(self):
+        client = TestClient(app)
+        owner_headers, _ = _auth(client, "room_owner")
+        wid = _make_world(client, owner_headers)
+        other_headers, _ = _auth(client, "room_other")
+        r = client.post(f"/api/worlds/{wid}/rooms", headers=other_headers,
+                         json={"slug": "annex", "name": "Annex"})
+        assert r.status_code == 403
+
+    def test_list_rooms_of_private_world_is_404_for_non_owner(self):
+        client = TestClient(app)
+        owner_headers, _ = _auth(client, "room_priv_owner")
+        wid = _make_world(client, owner_headers, "private")
+        other_headers, _ = _auth(client, "room_priv_other")
+        r = client.get(f"/api/worlds/{wid}/rooms", headers=other_headers)
+        assert r.status_code == 404
+
+
+class TestChunkPutGetRoundTrip:
+    def test_binary_put_then_binary_get_round_trips(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "chunk_rt")
+        wid = _make_world(client, headers)
+        payload = _build_chunk(wid, "main", 0, 0, 0)
+
+        r = client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/0/0/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=payload,
+        )
+        assert r.status_code == 200, r.text
+        body = r.json()
+        assert body["revision"] == 1
+        assert body["payload_len"] == len(payload)
+        assert body["checksum"] == cc.checksum(payload[cc.HEADER_SIZE:])
+        assert body["live_session"] is False
+
+        g = client.get(
+            f"/api/worlds/{wid}/rooms/main/chunks/0/0/0",
+            headers={**headers, "Accept": "application/octet-stream"},
+        )
+        assert g.status_code == 200
+        assert g.content == payload
+        assert g.headers["ETag"] == f'"{body["checksum"]}"'
+        assert g.headers["X-Chunk-Revision"] == "1"
+
+    def test_json_accept_returns_decoded_shape(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "chunk_json")
+        wid = _make_world(client, headers)
+        payload = _build_chunk(wid, "main", 1, 1, 0)
+        client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/1/1/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=payload,
+        )
+        g = client.get(
+            f"/api/worlds/{wid}/rooms/main/chunks/1/1/0",
+            headers={**headers, "Accept": "application/json"},
+        )
+        assert g.status_code == 200
+        data = g.json()
+        assert data["coord"] == {"cx": 1, "cy": 1, "cz": 0}
+        assert data["world_id"] == str(wid)
+        assert data["room_id"] == "main"
+        assert len(data["objects"]) == 1
+
+    def test_json_put_with_base64_payload(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "chunk_json_put")
+        wid = _make_world(client, headers)
+        payload = _build_chunk(wid, "main", 2, 2, 0)
+        r = client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/2/2/0", headers=headers,
+            json={"base_revision": 0, "payload_b64": base64.b64encode(payload).decode()},
+        )
+        assert r.status_code == 200, r.text
+        assert r.json()["revision"] == 1
+
+    def test_if_none_match_returns_304(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "chunk_304")
+        wid = _make_world(client, headers)
+        payload = _build_chunk(wid, "main", 3, 3, 0)
+        put = client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/3/3/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=payload,
+        )
+        checksum = put.json()["checksum"]
+        g = client.get(
+            f"/api/worlds/{wid}/rooms/main/chunks/3/3/0",
+            headers={**headers, "If-None-Match": f'"{checksum}"'},
+        )
+        assert g.status_code == 304
+
+    def test_unwritten_coordinate_is_404(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "chunk_404")
+        wid = _make_world(client, headers)
+        g = client.get(f"/api/worlds/{wid}/rooms/main/chunks/9/9/0", headers=headers)
+        assert g.status_code == 404
+
+
+class TestRevisionConflict:
+    def test_create_conflict_when_chunk_already_exists(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "conflict_create")
+        wid = _make_world(client, headers)
+        payload = _build_chunk(wid, "main", 4, 4, 0)
+        first = client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/4/4/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=payload,
+        )
+        assert first.status_code == 200
+
+        second = client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/4/4/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=payload,
+        )
+        assert second.status_code == 409
+        body = second.json()
+        assert body["detail"] == "revision conflict"
+        assert body["current_revision"] == 1
+
+    def test_stale_base_revision_conflict_reports_current_state(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "conflict_stale")
+        wid = _make_world(client, headers)
+        payload_v1 = _build_chunk(wid, "main", 5, 5, 0, revision=1)
+        client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/5/5/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=payload_v1,
+        )
+        payload_v2 = _build_chunk(wid, "main", 5, 5, 0, revision=2, extra_tag="v2")
+        r2 = client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/5/5/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "1"},
+            content=payload_v2,
+        )
+        assert r2.status_code == 200
+        assert r2.json()["revision"] == 2
+
+        # Now retry with the now-stale base_revision=1 again.
+        payload_v3 = _build_chunk(wid, "main", 5, 5, 0, revision=3, extra_tag="v3")
+        stale = client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/5/5/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "1"},
+            content=payload_v3,
+        )
+        assert stale.status_code == 409
+        body = stale.json()
+        assert body["current_revision"] == 2
+        assert body["current_checksum"] == r2.json()["checksum"]
+
+
+class TestBatchWrite:
+    def test_batch_put_all_succeed(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "batch_ok")
+        wid = _make_world(client, headers)
+        chunks = [
+            {"cx": cx, "cy": 0, "cz": 0, "base_revision": 0,
+             "payload_b64": base64.b64encode(_build_chunk(wid, "main", cx, 0, 0)).decode()}
+            for cx in (10, 11)
+        ]
+        r = client.put(f"/api/worlds/{wid}/rooms/main/chunks", headers=headers, json={"chunks": chunks})
+        assert r.status_code == 200, r.text
+        body = r.json()
+        assert len(body["chunks"]) == 2
+        assert all(c["revision"] == 1 for c in body["chunks"])
+
+        idx = client.get(f"/api/worlds/{wid}/rooms/main/chunks", headers=headers)
+        keys = {c["key"] for c in idx.json()["chunks"]}
+        assert f"{wid}:main:10:0:0" in keys
+        assert f"{wid}:main:11:0:0" in keys
+
+    def test_batch_put_is_all_or_nothing_on_conflict(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "batch_conflict")
+        wid = _make_world(client, headers)
+
+        # Pre-create one of the two coordinates so the batch's base_revision=0
+        # for it will conflict.
+        pre = _build_chunk(wid, "main", 20, 0, 0)
+        client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/20/0/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=pre,
+        )
+
+        chunks = [
+            {"cx": 21, "cy": 0, "cz": 0, "base_revision": 0,
+             "payload_b64": base64.b64encode(_build_chunk(wid, "main", 21, 0, 0)).decode()},
+            {"cx": 20, "cy": 0, "cz": 0, "base_revision": 0,  # conflicts: already exists at revision 1
+             "payload_b64": base64.b64encode(_build_chunk(wid, "main", 20, 0, 0, extra_tag="v2")).decode()},
+        ]
+        r = client.put(f"/api/worlds/{wid}/rooms/main/chunks", headers=headers, json={"chunks": chunks})
+        assert r.status_code == 409
+
+        # Nothing from this batch should have been persisted -- (21,0,0)
+        # must NOT exist even though it was valid and came first.
+        g = client.get(f"/api/worlds/{wid}/rooms/main/chunks/21/0/0", headers=headers)
+        assert g.status_code == 404
+
+
+class TestDelete:
+    def test_delete_then_get_is_404(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "chunk_delete")
+        wid = _make_world(client, headers)
+        payload = _build_chunk(wid, "main", 30, 0, 0)
+        client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/30/0/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=payload,
+        )
+        d = client.delete(f"/api/worlds/{wid}/rooms/main/chunks/30/0/0", headers=headers)
+        assert d.status_code == 204
+        g = client.get(f"/api/worlds/{wid}/rooms/main/chunks/30/0/0", headers=headers)
+        assert g.status_code == 404
+
+
+class TestRevisionsAndRollback:
+    def test_revisions_then_rollback(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "chunk_rollback")
+        wid = _make_world(client, headers)
+        v1 = _build_chunk(wid, "main", 40, 0, 0, revision=1)
+        r1 = client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/40/0/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=v1,
+        )
+        v2 = _build_chunk(wid, "main", 40, 0, 0, revision=2, extra_tag="v2")
+        r2 = client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/40/0/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "1"},
+            content=v2,
+        )
+        assert r2.status_code == 200
+
+        revs = client.get(f"/api/worlds/{wid}/rooms/main/chunks/40/0/0/revisions", headers=headers)
+        assert revs.status_code == 200
+        rev_numbers = [row["revision"] for row in revs.json()]
+        assert 1 in rev_numbers and 2 in rev_numbers
+
+        rb = client.post(
+            f"/api/worlds/{wid}/rooms/main/chunks/40/0/0/rollback",
+            headers=headers, json={"revision": 1},
+        )
+        assert rb.status_code == 200, rb.text
+        assert rb.json()["revision"] == 3  # a new revision, restoring v1's content
+        assert rb.json()["checksum"] == r1.json()["checksum"]
+
+    def test_revisions_requires_owner(self):
+        client = TestClient(app)
+        owner_headers, _ = _auth(client, "revisions_owner")
+        wid = _make_world(client, owner_headers)
+        payload = _build_chunk(wid, "main", 41, 0, 0)
+        client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/41/0/0",
+            headers={**owner_headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=payload,
+        )
+        other_headers, _ = _auth(client, "revisions_other")
+        r = client.get(f"/api/worlds/{wid}/rooms/main/chunks/41/0/0/revisions", headers=other_headers)
+        assert r.status_code == 403
+
+
+class TestValidationErrors:
+    def test_malformed_payload_is_422(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "chunk_malformed")
+        wid = _make_world(client, headers)
+        r = client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/0/0/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=b"not a real chunk",
+        )
+        assert r.status_code == 422
+        assert r.json()["reason"] == "malformed"
+
+    def test_wrong_grid_size_is_422_layer_dims(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "chunk_layerdims")
+        wid = _make_world(client, headers)
+        # Room's default grid is 32x32x1; build a chunk sized for 4x4x1.
+        payload = _build_chunk(wid, "main", 0, 0, 0, grid=(4, 4, 1))
+        r = client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/0/0/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=payload,
+        )
+        assert r.status_code == 422
+        assert r.json()["reason"] == "layer_dims"
+
+    def test_oversized_payload_is_413(self, monkeypatch):
+        from app.config import settings
+        monkeypatch.setattr(settings, "WORLD_CHUNK_MAX_PAYLOAD_BYTES", 10)
+        client = TestClient(app)
+        headers, _ = _auth(client, "chunk_413")
+        wid = _make_world(client, headers)
+        payload = _build_chunk(wid, "main", 0, 0, 0)
+        r = client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/0/0/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=payload,
+        )
+        assert r.status_code == 413
+
+
+class TestInternalApi:
+    """docs/architecture/world_persistence_impl.md §7/§8.3. No real Godot
+    process is spawned in this test env (GAME_SERVERS_ENABLED=False); we
+    register a fake in-memory server entry with a known token to exercise
+    require_game_server without needing a live process."""
+
+    @pytest.fixture
+    def fake_server_token(self):
+        # NB: a class body can't read a same-named local from the
+        # enclosing function via `token = token` (class bodies use LOAD_NAME,
+        # which skips enclosing function scopes) -- use a literal instead.
+        world_id_str = "internal-test-world"
+
+        class _FakeSrv:
+            def alive(self_inner):
+                return True
+            token = "test-internal-token-12345"
+
+        supervisor._servers[world_id_str] = _FakeSrv()
+        yield _FakeSrv.token
+        supervisor._servers.pop(world_id_str, None)
+
+    def test_missing_token_is_401(self):
+        client = TestClient(app)
+        r = client.get("/api/internal/worlds/1/manifest")
+        assert r.status_code == 401
+
+    def test_wrong_token_is_403(self):
+        client = TestClient(app)
+        r = client.get(
+            "/api/internal/worlds/1/manifest",
+            headers={"Authorization": "Bearer not-the-real-token"},
+        )
+        assert r.status_code == 403
+
+    def test_valid_token_but_wrong_world_id_is_403(self, fake_server_token):
+        # The fake token is registered under world_id "internal-test-world";
+        # a request for a different world_id must not authenticate.
+        client = TestClient(app)
+        r = client.get(
+            "/api/internal/worlds/999999/manifest",
+            headers={"Authorization": f"Bearer {fake_server_token}"},
+        )
+        assert r.status_code == 403
+
+    def test_valid_token_reaches_manifest_for_real_world(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "internal_manifest")
+        wid = _make_world(client, headers)
+
+        class _FakeSrv:
+            def alive(self_inner):
+                return True
+            token = "another-real-token"
+
+        supervisor._servers[str(wid)] = _FakeSrv()
+        try:
+            r = client.get(
+                f"/api/internal/worlds/{wid}/manifest",
+                headers={"Authorization": "Bearer another-real-token"},
+            )
+            assert r.status_code == 200, r.text
+            body = r.json()
+            assert body["world_id"] == wid
+            assert len(body["rooms"]) == 1
+            assert body["rooms"][0]["slug"] == "main"
+        finally:
+            supervisor._servers.pop(str(wid), None)
+
+    def test_internal_chunk_fetch_returns_binary(self):
+        client = TestClient(app)
+        headers, _ = _auth(client, "internal_chunk")
+        wid = _make_world(client, headers)
+        payload = _build_chunk(wid, "main", 0, 0, 0)
+        client.put(
+            f"/api/worlds/{wid}/rooms/main/chunks/0/0/0",
+            headers={**headers, "Content-Type": "application/octet-stream", "X-Base-Revision": "0"},
+            content=payload,
+        )
+
+        class _FakeSrv:
+            def alive(self_inner):
+                return True
+            token = "internal-chunk-token"
+
+        supervisor._servers[str(wid)] = _FakeSrv()
+        try:
+            r = client.get(
+                f"/api/internal/worlds/{wid}/rooms/main/chunks/0/0/0",
+                headers={"Authorization": "Bearer internal-chunk-token"},
+            )
+            assert r.status_code == 200
+            assert r.content == payload
+        finally:
+            supervisor._servers.pop(str(wid), None)

project.godot

@@ -45,6 +45,11 @@ move_down={
 "events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":83,"key_label":0,"unicode":115,"location":0,"echo":false,"script":null)
 ]
 }
+interact={
+"deadzone": 0.5,
+"events": [Object(InputEventKey,"resource_local_to_scene":false,"resource_name":"","device":-1,"window_id":0,"alt_pressed":false,"shift_pressed":false,"ctrl_pressed":false,"meta_pressed":false,"pressed":false,"keycode":0,"physical_keycode":69,"key_label":0,"unicode":101,"location":0,"echo":false,"script":null)
+]
+}
 
 [physics]
 

scenes/player.tscn

@@ -1,6 +1,7 @@
-[gd_scene load_steps=4 format=3 uid="uid://player_scene_001"]
+[gd_scene load_steps=5 format=3 uid="uid://player_scene_001"]
 
 [ext_resource type="Script" path="res://scripts/player.gd" id="1_player"]
+[ext_resource type="Script" path="res://scripts/scripting/player_inventory.gd" id="2_inventory"]
 
 [sub_resource type="CapsuleMesh" id="CapsuleMesh1"]
 radius = 0.35
@@ -30,3 +31,6 @@ margin = 0.2
 
 [node name="Camera3D" type="Camera3D" parent="CameraPivot/SpringArm3D"]
 current = true
+
+[node name="Inventory" type="Node" parent="."]
+script = ExtResource("2_inventory")

scenes/worlds/test_level.tscn

@@ -1,4 +1,6 @@
-[gd_scene load_steps=1 format=3 uid="uid://c49a36fc7db_test_level"]
+[gd_scene load_steps=2 format=3 uid="uid://c49a36fc7db_test_level"]
+
+[ext_resource type="Script" path="res://scripts/scripting/script_interpreter.gd" id="1_scripted_chest"]
 
 [sub_resource type="BoxShape3D" id="BoxShape3D_ground"]
 size = Vector3(40, 1, 40)
@@ -44,6 +46,12 @@ radius = 0.5
 subdivisions_ring = 8
 subdivisions_height = 8
 
+[sub_resource type="BoxShape3D" id="BoxShape3D_chest"]
+size = Vector3(1, 0.8, 0.6)
+
+[sub_resource type="BoxMesh" id="BoxMesh_chest"]
+size = Vector3(1, 0.8, 0.6)
+
 [sub_resource type="Environment" id="WorldEnvironment_env"]
 background_mode = 1
 background_color = Color(0.45, 0.62, 0.82, 1)
@@ -109,6 +117,18 @@ shape = SubResource("SphereShape3D_prop5")
 [node name="MeshInstance3D" type="MeshInstance3D" parent="Props/Prop5_SmallSphere"]
 mesh = SubResource("SphereMesh_prop5")
 
+[node name="ScriptedChest" type="StaticBody3D" parent="."]
+position = Vector3(0, 1.0, 1.5)
+script = ExtResource("1_scripted_chest")
+behavior_path = "res://assets/scripting/behaviors/demo_chest.json"
+interact_radius = 2.5
+
+[node name="CollisionShape3D" type="CollisionShape3D" parent="ScriptedChest"]
+shape = SubResource("BoxShape3D_chest")
+
+[node name="MeshInstance3D" type="MeshInstance3D" parent="ScriptedChest"]
+mesh = SubResource("BoxMesh_chest")
+
 [node name="Sun" type="DirectionalLight3D" parent="."]
 rotation = Vector3(-0.95, -0.5, 0)
 light_energy = 1.3

scripts/api_client.gd

@@ -69,6 +69,16 @@ func clear_token() -> void:
 
 var _base_url: String = "http://127.0.0.1:8000"
 
+## Read-only access to the configured backend base URL (no trailing slash).
+## Lets other client-side code that needs to build its own request outside
+## the [method request] primitive -- e.g. [HttpChunkSource], which needs raw
+## response bytes and custom headers `request()`'s JSON-only contract can't
+## give it -- target the same backend without duplicating the env var /
+## ProjectSettings resolution logic in `_ready()`.
+var base_url: String:
+	get:
+		return _base_url
+
 ## Request timeout in seconds. 0 disables the timeout.
 var timeout_seconds: float = 10.0
 

scripts/chunk_data_decoder.gd

@@ -404,7 +404,15 @@ static func _parse_object_section(data: PackedByteArray, result: ChunkPayload) -
 	offset += 2
 	var props_str := data.slice(offset, offset + props_len).get_string_from_utf8()
 	offset += props_len
-	obj.properties = JSON.parse_string(props_str) or {}
+	# `or` in GDScript is a boolean operator, not Python/JS-style
+	# short-circuit-return -- `parsed or {}` returns a bool (true for any
+	# non-empty Dictionary), not `parsed` itself. Assigning that bool to
+	# `properties` (typed Dictionary) crashes at runtime for any object
+	# with real property data -- verified: a real fixture with
+	# {"locked": false, ...} threw "Invalid assignment of property or key
+	# 'properties' with value of type 'bool'".
+	var parsed_props: Variant = JSON.parse_string(props_str)
+	obj.properties = parsed_props if parsed_props is Dictionary else {}
 
 	# flags (ContentFlags)
 	obj.flags.violence = data[offset]
@@ -484,13 +492,33 @@ static func _build_metadata_section(payload: ChunkPayload) -> PackedByteArray:
 	data.append_array(_write_int32(payload.coord.x))
 	data.append_array(_write_int32(payload.coord.y))
 	data.append_array(_write_int32(payload.coord.z))
+	# Wire format is min + max (world.md §3, and _parse_metadata_section
+	# below reads the 2nd triple as max_pos and computes size = max - min)
+	# -- writing raw `.size` here instead of `.position + .size` was a
+	# latent bug that only escaped every test because AABB(Vector3.ZERO, ...)
+	# happens to make size == max when position is exactly zero. Any chunk
+	# at a real, nonzero world position (i.e. every real chunk except the
+	# one at the origin) would round-trip through encode_binary/decode_binary
+	# with a corrupted size. Same bug class as the backend's min+size/
+	# min+max mismatch fixed in chunk_codec.py (commit eb39e43).
+	var bounds_max: Vector3 = payload.bounds.position + payload.bounds.size
 	data.append_array(_write_float32(payload.bounds.position.x))
 	data.append_array(_write_float32(payload.bounds.position.y))
 	data.append_array(_write_float32(payload.bounds.position.z))
-	data.append_array(_write_float32(payload.bounds.size.x))
-	data.append_array(_write_float32(payload.bounds.size.y))
-	data.append_array(_write_float32(payload.bounds.size.z))
-	return data
+	data.append_array(_write_float32(bounds_max.x))
+	data.append_array(_write_float32(bounds_max.y))
+	data.append_array(_write_float32(bounds_max.z))
+	# Every other section builder wraps its body with `_wrap_section`
+	# (section_id + uint32 length prefix) -- this one didn't, so
+	# `encode_binary()` spliced the raw metadata bytes directly into the
+	# section stream with no header at all. The decoder then read the
+	# metadata's own first bytes (a string length prefix) as a bogus
+	# section_id/section_len pair, producing a garbage length that
+	# overran the buffer ("truncated section body") and silently found
+	# zero real sections. Never caught before because nothing in this
+	# codebase called encode_binary() until
+	# scripts/smoke_test_http_chunk_source.gd.
+	return _wrap_section(data, SECTION_META)
 
 
 static func _build_tile_section(layer: TileLayerData) -> PackedByteArray:
@@ -607,8 +635,11 @@ static func _read_int64(data: PackedByteArray, offset: int) -> int:
 	return hi * 0x100000000 + lo
 
 static func _read_float32(data: PackedByteArray, offset: int) -> float:
-	var bits := _read_uint32(data, offset)
-	return bits as float  # GDScript float is 64-bit; bits repr works for IEEE 754
+	# `int as float` is a NUMERIC cast, not an IEEE-754 bit reinterpretation --
+	# it was silently corrupting every non-integer value (verified: bits for
+	# 1.5f decoded as 1069547520.0). decode_float() does a real bitcast and
+	# matches this format's little-endian byte order (§3.6).
+	return data.decode_float(offset)
 
 static func _read_hex_string(data: PackedByteArray, offset: int, length: int) -> String:
 	var hex_chars := "0123456789abcdef"
@@ -637,8 +668,10 @@ static func _write_int64(val: int) -> PackedByteArray:
 	return _write_uint32(lo) + _write_uint32(hi)
 
 static func _write_float32(val: float) -> PackedByteArray:
-	var bits := val as int
-	return _write_uint32(bits)
+	var out := PackedByteArray()
+	out.resize(4)
+	out.encode_float(0, val)
+	return out
 
 static func _write_string(s: String) -> PackedByteArray:
 	var bytes := s.to_utf8_buffer()

scripts/chunk_stream_manager.gd

@@ -241,7 +241,11 @@ func _instantiate_chunk_scene_with_data(coord: Vector3i, data: ChunkDataDecoder.
 	chunk_scene.coord = coord
 	chunk_scene.key = data.key
 	chunk_scene.bounds = data.bounds
-	chunk_scene.format_version = data.format_version
+	# ChunkDataDecoder.ChunkPayload's field is named `version`, not
+	# `format_version` -- this was a hard crash ("Invalid access to
+	# property or key 'format_version'") the first time real decoded data
+	# ever reached this dormant method (via HttpChunkSource).
+	chunk_scene.format_version = data.version
 	chunk_scene.revision = data.revision
 
 	# Add tiles
@@ -348,7 +352,13 @@ func clear_all_chunks() -> void:
 
 func _parse_coord_from_key(key: String) -> Variant:
 	"""Parse chunk coordinate from a canonical chunk key."""
-	var parts: Array[String] = key.split(":")
+	# String.split() returns PackedStringArray, not Array[String] -- those
+	# are different container types with no implicit conversion, so this
+	# raised "Trying to assign a value of type 'PackedStringArray' to a
+	# variable of type 'Array[String]'" the moment real data reached this
+	# dormant method for the first time (via HttpChunkSource's
+	# _on_chunk_data_received call -- nothing exercised this path before).
+	var parts: PackedStringArray = key.split(":")
 	if parts.size() < 5:
 		return null
 	return Vector3i(

scripts/http_chunk_source.gd

@@ -0,0 +1,203 @@
+class_name HttpChunkSource
+extends Node
+## HTTP-backed adapter for ChunkStreamManager.set_server_rpc().
+##
+## Implements docs/architecture/world_persistence_impl.md D6/§8.4: the
+## playing client streams chunks from the FastAPI backend over HTTP (the
+## same public routes the editor uses -- `backend/app/routers/world_content.py`),
+## not over the dedicated server's ENet connection.
+##
+## `ChunkStreamManager` only requires an object with a `request_chunk(key)`
+## method (see its `_server_rpc` seam); this adapter satisfies that and feeds
+## results back through the manager's existing (previously dormant)
+## `_on_chunk_data_received(key, bytes)` / `_on_chunk_load_error(coord, msg)`
+## methods, and its `_instantiate_chunk_scene(coord)` for the "unwritten
+## coordinate renders empty" case (§8.1).
+##
+## `ChunkStreamManager._load_chunk()` builds its request key with empty
+## world/room components (`Chunk.build_key("", "", coord)`) because the
+## manager itself has no notion of which world/room it's streaming --
+## that's this adapter's job. `request_chunk(key)` only reads the
+## coordinate out of the key it's given and rebuilds the real key from
+## `world_id`/`room_slug` before touching the network, per the doc's note
+## under §8.4.
+##
+## Must be added to the scene tree before use (it creates per-request
+## HTTPRequest child nodes), e.g.:
+##
+##     var source := HttpChunkSource.new()
+##     source.world_id = str(Session.world_id)
+##     source.room_slug = "main"
+##     source.stream_manager = stream_manager
+##     stream_manager.add_child(source)
+##     stream_manager.set_server_rpc(source)
+
+## The world this source fetches chunks for (string form of the backend's
+## numeric world id -- matches Chunk.build_key's world_id parameter type).
+var world_id: String = ""
+
+## The room slug within that world. world.md's default room is "main".
+var room_slug: String = "main"
+
+## The ChunkStreamManager to feed decoded results back into. Required.
+var stream_manager: ChunkStreamManager = null
+
+## In-memory ETag cache: chunk key -> last-known checksum (bare hex, no
+## quotes). Backs the on-disk payload cache so re-fetching an unchanged
+## chunk costs a 304, not a re-download (world_persistence_impl.md §8.1:
+## "This is what makes the client's user://chunk_cache/ cache cheap").
+var _etag_by_key: Dictionary = {}
+
+const CACHE_DIR := "user://chunk_cache"
+
+
+func _ready() -> void:
+	DirAccess.make_dir_recursive_absolute(CACHE_DIR)
+
+
+## Satisfies ChunkStreamManager's `_server_rpc.request_chunk(key)` seam.
+func request_chunk(key: String) -> void:
+	var coord: Variant = _coord_from_key(key)
+	if coord == null:
+		push_error("HttpChunkSource: malformed chunk key %s" % key)
+		return
+	_fetch(coord)
+
+
+## world_persistence_impl.md §8.1 chunk index -- lists which chunks in a
+## bounds actually exist without fetching their payloads. Not called by
+## ChunkStreamManager's per-coordinate streaming loop today, but is the
+## "bounds-query listing" half of this adapter's contract for future
+## callers (e.g. a minimap, or a smarter prefetcher).
+func list_chunks(cx_min: int, cx_max: int, cy_min: int, cy_max: int, cz: int = 0) -> Dictionary:
+	var path := "/api/worlds/%s/rooms/%s/chunks?cx_min=%d&cx_max=%d&cy_min=%d&cy_max=%d&cz=%d" % [
+		world_id, room_slug, cx_min, cx_max, cy_min, cy_max, cz
+	]
+	return await _api_client().request(HTTPClient.METHOD_GET, path, "", "application/json", true)
+
+
+# ─────────────────────────── internals ───────────────────────────
+
+## Resolved via an absolute node path rather than the bare `ApiClient`
+## autoload identifier: bare autoload identifiers only resolve at GDScript
+## compile time inside a scene the engine boots normally. Any script
+## compiled while running headless via `godot --script ...` (as
+## scripts/smoke_test_*.gd do) fails with "Identifier not found: ApiClient"
+## on the bare form -- confirmed while writing
+## scripts/smoke_test_http_chunk_source.gd. `get_node` resolves the same
+## singleton correctly in both contexts (the same pattern game.gd already
+## uses for AvatarSystem via `get_node_or_null("/root/AvatarSystem")`).
+func _api_client() -> Node:
+	return get_node("/root/ApiClient")
+
+
+func _fetch(coord: Vector3i) -> void:
+	var key := Chunk.build_key(world_id, room_slug, coord)
+
+	var http := HTTPRequest.new()
+	http.timeout = 10.0
+	add_child(http)
+
+	var api := _api_client()
+	var headers := PackedStringArray()
+	headers.append("Accept: application/octet-stream")
+	if api.has_token():
+		var bearer: String = api.bearer_token
+		headers.append("Authorization: " + bearer)
+	var cached_etag: String = _etag_by_key.get(key, "")
+	if cached_etag != "":
+		headers.append("If-None-Match: \"%s\"" % cached_etag)
+
+	var base_url: String = api.base_url
+	var url := "%s/api/worlds/%s/rooms/%s/chunks/%d/%d/%d" % [
+		base_url, world_id, room_slug, coord.x, coord.y, coord.z
+	]
+	var err := http.request(url, headers, HTTPClient.METHOD_GET)
+	if err != OK:
+		http.queue_free()
+		_fail(coord, "HttpChunkSource: failed to start request for %s (%d)" % [key, err])
+		return
+
+	var args: Array = await http.request_completed
+	var result_code: int = args[0]
+	var response_code: int = args[1]
+	var response_headers: PackedStringArray = args[2]
+	var body: PackedByteArray = args[3]
+	http.queue_free()
+
+	if result_code != HTTPRequest.RESULT_SUCCESS:
+		_fail(coord, "HttpChunkSource: transport error fetching %s (code %d)" % [key, result_code])
+		return
+
+	match response_code:
+		304:
+			var cached := _read_cache(cached_etag)
+			if cached.is_empty():
+				# Cache miss despite a 304 (e.g. the user:// cache got
+				# cleared) -- drop the stale ETag and refetch unconditionally
+				# rather than deliver empty bytes to the decoder.
+				_etag_by_key.erase(key)
+				_fetch(coord)
+				return
+			_deliver(key, cached)
+		200:
+			var checksum := _etag_from_headers(response_headers)
+			if checksum != "":
+				_etag_by_key[key] = checksum
+				_write_cache(checksum, body)
+			_deliver(key, body)
+		404:
+			# world_persistence_impl.md §8.1: "an unwritten coordinate is not
+			# an error to the streamer -- it renders empty."
+			if stream_manager != null:
+				stream_manager._instantiate_chunk_scene(coord)
+		_:
+			_fail(coord, "HttpChunkSource: HTTP %d fetching %s" % [response_code, key])
+
+
+func _deliver(key: String, bytes: PackedByteArray) -> void:
+	if stream_manager != null:
+		stream_manager._on_chunk_data_received(key, bytes)
+
+
+func _fail(coord: Vector3i, message: String) -> void:
+	push_error(message)
+	if stream_manager != null:
+		stream_manager._on_chunk_load_error(coord, message)
+
+
+func _coord_from_key(key: String) -> Variant:
+	var parts: PackedStringArray = key.split(":")
+	if parts.size() < 5:
+		return null
+	return Vector3i(int(parts[2]), int(parts[3]), int(parts[4]))
+
+
+func _etag_from_headers(headers: PackedStringArray) -> String:
+	for h in headers:
+		if h.to_lower().begins_with("etag:"):
+			var v := h.substr(h.find(":") + 1).strip_edges()
+			return v.trim_prefix('"').trim_suffix('"')
+	return ""
+
+
+func _cache_path(checksum: String) -> String:
+	return "%s/%s" % [CACHE_DIR, checksum]
+
+
+func _write_cache(checksum: String, bytes: PackedByteArray) -> void:
+	var f := FileAccess.open(_cache_path(checksum), FileAccess.WRITE)
+	if f:
+		f.store_buffer(bytes)
+		f.close()
+
+
+func _read_cache(checksum: String) -> PackedByteArray:
+	if checksum == "":
+		return PackedByteArray()
+	var f := FileAccess.open(_cache_path(checksum), FileAccess.READ)
+	if f == null:
+		return PackedByteArray()
+	var bytes := f.get_buffer(f.get_length())
+	f.close()
+	return bytes

scripts/scripting/player_inventory.gd

@@ -0,0 +1,41 @@
+class_name PlayerInventory
+extends Node
+## Minimal per-player item-count store.
+##
+## docs/architecture/dynamic_object_node.gd's header notes that a dynamic
+## object's runtime state ("position, health, inventory") belongs to "the
+## entity system" -- but no such system exists yet (M9 Economy hasn't been
+## built). This is a deliberately small, local stub scoped to make
+## ScriptBehavior's `give_item` verb demonstrable now, not an attempt to
+## build the real economy/inventory system. Replace it wholesale when M9
+## lands; keep the give_item/get_count surface so existing ScriptBehavior
+## data keeps working against the real thing.
+##
+## Attach one of these as a child node named "Inventory" under a player (see
+## scenes/player.tscn) -- [ScriptInterpreterNode] looks it up by that name
+## when resolving `target: "player"` for the `give_item` verb.
+
+## Emitted whenever an item's count changes, with the item's new total.
+signal item_changed(item_id: String, count: int)
+
+var _items: Dictionary = {}  # item_id (String) -> count (int)
+
+
+## Add (or, with a negative count, remove) units of an item. Counts never go
+## negative. `count == 0` is a no-op.
+func give_item(item_id: String, count: int) -> void:
+	if item_id.is_empty() or count == 0:
+		return
+	var new_count: int = maxi(0, int(_items.get(item_id, 0)) + count)
+	_items[item_id] = new_count
+	item_changed.emit(item_id, new_count)
+
+
+## Current count for an item (0 if never granted).
+func get_count(item_id: String) -> int:
+	return int(_items.get(item_id, 0))
+
+
+## A snapshot of the whole inventory (for UI/debugging/tests).
+func get_all() -> Dictionary:
+	return _items.duplicate()

scripts/scripting/script_behavior.gd

@@ -0,0 +1,383 @@
+class_name ScriptBehavior
+extends RefCounted
+## A data-driven, non-Turing-complete behavior attached to a world object.
+##
+## This is the DSL described in docs/architecture/scripting_sandbox.md §3.1:
+## a small, fixed set of trigger/condition/action verbs, expressed as plain
+## JSON/Dictionary data, with zero ability to reference engine singletons,
+## call arbitrary methods, or execute code. There is no interpreter to
+## escape because there is no general execution -- every verb is a reviewed,
+## hand-written GDScript function in [ScriptInterpreterNode], and every verb
+## argument here is a plain scalar (String, int, float, bool) or a 3-element
+## Array of numbers, never a Callable/Object/Script.
+##
+## Because the data is exactly this restricted, it plugs into the content
+## moderation pipeline (docs/architecture/content_moderation.md) the same way
+## an asset or room does: it's a plain JSON blob that can be hashed, stored,
+## flagged and reviewed without needing to sandbox code execution to do so.
+##
+## ## Format
+##
+## ```json
+## {
+##   "rules": [
+##     {
+##       "trigger": {"type": "on_interact"},
+##       "conditions": [
+##         {"type": "item_count", "item_id": "torch", "op": ">=", "value": 1}
+##       ],
+##       "actions": [
+##         {"verb": "give_item", "item_id": "gold_coin", "count": 3},
+##         {"verb": "play_sound", "sound_id": "chest_open"}
+##       ]
+##     }
+##   ]
+## }
+## ```
+##
+## Any rule that fails validation (unknown trigger/condition/action, wrong
+## argument types, out-of-range values, an unrecognized key standing in for
+## one of the whitelisted ones) is **dropped silently from execution** --
+## never partially applied, never run "best effort". The rejection reason is
+## recorded in [member rejected_rules] so callers/tests/moderation tooling
+## can see *why*, but the interpreter never runs a rule that didn't fully
+## validate.
+
+# Sibling scripting scripts are referenced via preload rather than by their
+# global class_name so this module parses correctly from a bare/cold
+# compile (matches the convention in scripts/avatar/avatar_loadout.gd --
+# a headless `godot --script` run doesn't always rebuild the global class
+# registry; only an editor scan / `--import` reliably does).
+const ScriptRuleClass := preload("res://scripts/scripting/script_rule.gd")
+
+const VALID_TRIGGERS: Array[String] = ["on_interact", "on_enter", "on_touch", "on_timer"]
+const VALID_CONDITION_TYPES: Array[String] = ["item_count", "flag", "timer_active", "timer_remaining"]
+const VALID_OPS: Array[String] = ["==", "!=", "<", "<=", ">", ">="]
+const VALID_VERBS: Array[String] = ["give_item", "play_sound", "move", "rotate", "spawn_from_catalog", "set_timer"]
+const VALID_TARGETS: Array[String] = ["self", "player"]
+const VALID_AXES: Array[String] = ["x", "y", "z"]
+
+const MAX_STRING_LEN: int = 64
+const MAX_ITEM_COUNT: int = 100000
+const MAX_TIMER_SECONDS: float = 3600.0
+const MAX_DEGREES: float = 100000.0
+const MAX_OFFSET_MAGNITUDE: float = 10000.0
+const DEFAULT_MOVE_DURATION: float = 0.4
+const MIN_DURATION: float = 0.05
+const MAX_DURATION: float = 5.0
+
+## Successfully parsed, executable rules (each a ScriptRuleClass instance --
+## left as a plain untyped Array since Godot's typed-array element type
+## can't reliably reference a cross-file preloaded const; see the
+## preload note above).
+var rules: Array = []
+
+## Human-readable reasons every rejected rule (or top-level parse failure)
+## was dropped. Never empty on a fully-clean input, always non-empty
+## whenever `rules` is missing entries an author intended.
+var rejected_rules: Array[String] = []
+
+## Optional passthrough content-moderation metadata (see
+## docs/architecture/content_moderation.md §7.2 -- "Each content resource
+## carries a content_flags metadata field"). Not enforced by anything in
+## this system yet -- scripts as a moderated content type is still an open
+## item there -- but the field round-trips through parsing so a future
+## moderation pipeline has somewhere to read/write it without a format
+## change. Untrusted data can only ever set this to a plain Dictionary of
+## scalars; it's metadata, never consulted by the interpreter for control
+## flow.
+var content_flags: Dictionary = {}
+
+
+# ---------------------------------------------------------------------------
+# Construction
+# ---------------------------------------------------------------------------
+
+## Load and parse a ScriptBehavior from a JSON file on disk.
+static func load_from_file(path: String) -> ScriptBehavior:
+	var behavior := ScriptBehavior.new()
+	var file := FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		behavior.rejected_rules.append(
+			"cannot open '%s' (error %d)" % [path, FileAccess.get_open_error()]
+		)
+		return behavior
+
+	var text := file.get_as_text()
+	file.close()
+
+	var parsed: Variant = JSON.parse_string(text)
+	if parsed == null or not (parsed is Dictionary):
+		behavior.rejected_rules.append("invalid JSON in '%s'" % path)
+		return behavior
+
+	behavior._parse(parsed as Dictionary)
+	return behavior
+
+
+## Parse a ScriptBehavior from an already-decoded Dictionary (e.g. embedded
+## inline in a WorldObject's `properties["script_behavior"]`).
+static func load_from_dict(data: Dictionary) -> ScriptBehavior:
+	var behavior := ScriptBehavior.new()
+	behavior._parse(data)
+	return behavior
+
+
+# ---------------------------------------------------------------------------
+# Parsing / validation
+# ---------------------------------------------------------------------------
+
+func _parse(data: Dictionary) -> void:
+	var raw_flags: Variant = data.get("content_flags")
+	if raw_flags is Dictionary:
+		content_flags = raw_flags as Dictionary
+
+	var raw_rules: Variant = data.get("rules")
+	if not (raw_rules is Array):
+		rejected_rules.append("top-level 'rules' key missing or not an array")
+		return
+
+	for entry in (raw_rules as Array):
+		if not (entry is Dictionary):
+			rejected_rules.append("rule entry is not an object: %s" % str(entry))
+			continue
+		var rule := _parse_rule(entry as Dictionary)
+		if rule != null:
+			rules.append(rule)
+
+
+func _parse_rule(rule_dict: Dictionary) -> ScriptRuleClass:
+	var trigger: Variant = rule_dict.get("trigger")
+	if not (trigger is Dictionary):
+		rejected_rules.append("rule missing a 'trigger' object")
+		return null
+
+	var trigger_type: Variant = (trigger as Dictionary).get("type")
+	if not (trigger_type is String) or not VALID_TRIGGERS.has(trigger_type):
+		rejected_rules.append("rule has unknown/missing trigger type: %s" % str(trigger_type))
+		return null
+
+	var interval: float = 0.0
+	if trigger_type == "on_timer":
+		var raw_interval: Variant = (trigger as Dictionary).get("interval")
+		if not _is_number(raw_interval) or float(raw_interval) <= 0.0 or float(raw_interval) > MAX_TIMER_SECONDS:
+			rejected_rules.append("on_timer rule has invalid 'interval': %s" % str(raw_interval))
+			return null
+		interval = float(raw_interval)
+
+	var conditions: Array[Dictionary] = []
+	var raw_conditions: Variant = rule_dict.get("conditions", [])
+	if not (raw_conditions is Array):
+		rejected_rules.append("rule 'conditions' is not an array")
+		return null
+	for raw_cond in (raw_conditions as Array):
+		if not (raw_cond is Dictionary):
+			rejected_rules.append("condition entry is not an object: %s" % str(raw_cond))
+			return null
+		var cond := _parse_condition(raw_cond as Dictionary)
+		if cond.is_empty():
+			return null
+		conditions.append(cond)
+
+	var actions: Array[Dictionary] = []
+	var raw_actions: Variant = rule_dict.get("actions", [])
+	if not (raw_actions is Array) or raw_actions.is_empty():
+		rejected_rules.append("rule 'actions' is missing, not an array, or empty")
+		return null
+	for raw_action in (raw_actions as Array):
+		if not (raw_action is Dictionary):
+			rejected_rules.append("action entry is not an object: %s" % str(raw_action))
+			return null
+		var action := _parse_action(raw_action as Dictionary)
+		if action.is_empty():
+			return null
+		actions.append(action)
+
+	var rule := ScriptRuleClass.new()
+	rule.trigger_type = trigger_type
+	rule.trigger_interval = interval
+	rule.conditions = conditions
+	rule.actions = actions
+	return rule
+
+
+## Returns a normalized condition Dictionary, or {} (empty) if invalid --
+## the empty dict is the "rejected" sentinel since a valid condition always
+## has at least "type" and "op".
+func _parse_condition(raw: Dictionary) -> Dictionary:
+	var cond_type: Variant = raw.get("type")
+	if not (cond_type is String) or not VALID_CONDITION_TYPES.has(cond_type):
+		rejected_rules.append("condition has unknown/missing type: %s" % str(cond_type))
+		return {}
+
+	var op: Variant = raw.get("op")
+	if not (op is String) or not VALID_OPS.has(op):
+		rejected_rules.append("condition has unknown/missing op: %s" % str(op))
+		return {}
+
+	var value: Variant = raw.get("value")
+	if not _is_scalar(value):
+		rejected_rules.append("condition 'value' is not a plain scalar: %s" % str(value))
+		return {}
+
+	# Relational ops only make sense against numbers -- reject up front
+	# rather than silently coercing at eval time.
+	if op != "==" and op != "!=" and not _is_number(value):
+		rejected_rules.append("condition op '%s' requires a numeric value" % op)
+		return {}
+
+	match cond_type:
+		"item_count":
+			var item_id: Variant = raw.get("item_id")
+			if not _is_valid_id_string(item_id):
+				rejected_rules.append("item_count condition has invalid item_id: %s" % str(item_id))
+				return {}
+			return {"type": "item_count", "op": op, "value": value, "item_id": item_id}
+		"flag":
+			var name: Variant = raw.get("name")
+			if not _is_valid_id_string(name):
+				rejected_rules.append("flag condition has invalid name: %s" % str(name))
+				return {}
+			return {"type": "flag", "op": op, "value": value, "name": name}
+		"timer_active", "timer_remaining":
+			var timer_name: Variant = raw.get("name")
+			if not _is_valid_id_string(timer_name):
+				rejected_rules.append("%s condition has invalid name: %s" % [cond_type, str(timer_name)])
+				return {}
+			return {"type": cond_type, "op": op, "value": value, "name": timer_name}
+	# Unreachable given the VALID_CONDITION_TYPES check above, but never
+	# fall through to something that looks valid.
+	return {}
+
+
+## Returns a normalized action Dictionary, or {} (empty) if invalid.
+func _parse_action(raw: Dictionary) -> Dictionary:
+	var verb: Variant = raw.get("verb")
+	if not (verb is String) or not VALID_VERBS.has(verb):
+		rejected_rules.append("action has unknown/missing verb: %s" % str(verb))
+		return {}
+
+	match verb:
+		"give_item":
+			var item_id: Variant = raw.get("item_id")
+			var count: Variant = raw.get("count")
+			if not _is_valid_id_string(item_id):
+				rejected_rules.append("give_item has invalid item_id: %s" % str(item_id))
+				return {}
+			if not _is_number(count) or int(count) <= 0 or int(count) > MAX_ITEM_COUNT:
+				rejected_rules.append("give_item has invalid count: %s" % str(count))
+				return {}
+			return {"verb": "give_item", "item_id": item_id, "count": int(count)}
+
+		"play_sound":
+			var sound_id: Variant = raw.get("sound_id")
+			if not _is_valid_id_string(sound_id):
+				rejected_rules.append("play_sound has invalid sound_id: %s" % str(sound_id))
+				return {}
+			return {"verb": "play_sound", "sound_id": sound_id}
+
+		"move":
+			var target: Variant = raw.get("target", "self")
+			var offset: Variant = _parse_vector3(raw.get("offset"), MAX_OFFSET_MAGNITUDE)
+			var duration: Variant = _parse_duration(raw.get("duration", DEFAULT_MOVE_DURATION))
+			if not (target is String) or not VALID_TARGETS.has(target):
+				rejected_rules.append("move has invalid target: %s" % str(target))
+				return {}
+			if offset == null:
+				rejected_rules.append("move has invalid offset: %s" % str(raw.get("offset")))
+				return {}
+			if duration == null:
+				rejected_rules.append("move has invalid duration: %s" % str(raw.get("duration")))
+				return {}
+			return {"verb": "move", "target": target, "offset": offset, "duration": duration}
+
+		"rotate":
+			var r_target: Variant = raw.get("target", "self")
+			var degrees: Variant = raw.get("degrees")
+			var axis: Variant = raw.get("axis", "y")
+			var r_duration: Variant = _parse_duration(raw.get("duration", DEFAULT_MOVE_DURATION))
+			if not (r_target is String) or not VALID_TARGETS.has(r_target):
+				rejected_rules.append("rotate has invalid target: %s" % str(r_target))
+				return {}
+			if not _is_number(degrees) or absf(float(degrees)) > MAX_DEGREES:
+				rejected_rules.append("rotate has invalid degrees: %s" % str(degrees))
+				return {}
+			if not (axis is String) or not VALID_AXES.has(axis):
+				rejected_rules.append("rotate has invalid axis: %s" % str(axis))
+				return {}
+			if r_duration == null:
+				rejected_rules.append("rotate has invalid duration: %s" % str(raw.get("duration")))
+				return {}
+			return {"verb": "rotate", "target": r_target, "degrees": float(degrees), "axis": axis, "duration": r_duration}
+
+		"spawn_from_catalog":
+			var catalog_id: Variant = raw.get("catalog_id")
+			var position: Variant = _parse_vector3(raw.get("position"), MAX_OFFSET_MAGNITUDE)
+			if not _is_valid_id_string(catalog_id):
+				rejected_rules.append("spawn_from_catalog has invalid catalog_id: %s" % str(catalog_id))
+				return {}
+			if position == null:
+				rejected_rules.append("spawn_from_catalog has invalid position: %s" % str(raw.get("position")))
+				return {}
+			return {"verb": "spawn_from_catalog", "catalog_id": catalog_id, "position": position}
+
+		"set_timer":
+			var timer_name: Variant = raw.get("name")
+			var seconds: Variant = raw.get("seconds")
+			if not _is_valid_id_string(timer_name):
+				rejected_rules.append("set_timer has invalid name: %s" % str(timer_name))
+				return {}
+			if not _is_number(seconds) or float(seconds) <= 0.0 or float(seconds) > MAX_TIMER_SECONDS:
+				rejected_rules.append("set_timer has invalid seconds: %s" % str(seconds))
+				return {}
+			return {"verb": "set_timer", "name": timer_name, "seconds": float(seconds)}
+
+	# Unreachable given the VALID_VERBS check above.
+	return {}
+
+
+# ---------------------------------------------------------------------------
+# Scalar validation helpers
+# ---------------------------------------------------------------------------
+
+func _is_number(v: Variant) -> bool:
+	return v is int or v is float
+
+
+## A "plain scalar" -- the only shapes a condition/action value is ever
+## allowed to be. Deliberately excludes Dictionary, Array, Object, Callable,
+## Node, Resource -- there is no representable way for UGC data to hand the
+## interpreter anything but a bare String/int/float/bool.
+func _is_scalar(v: Variant) -> bool:
+	return v is String or v is int or v is float or v is bool
+
+
+## Identifiers (item ids, sound ids, catalog ids, flag/timer names) are
+## always plain, short, non-empty strings -- never used as a path, never
+## passed to load()/call() directly, only ever looked up as a Dictionary
+## key against a trusted, code-defined table.
+func _is_valid_id_string(v: Variant) -> bool:
+	if not (v is String):
+		return false
+	var s: String = v
+	return not s.is_empty() and s.length() <= MAX_STRING_LEN
+
+
+func _parse_duration(raw: Variant) -> Variant:
+	if not _is_number(raw):
+		return null
+	var d: float = clampf(float(raw), MIN_DURATION, MAX_DURATION)
+	return d
+
+
+## Parses a JSON array of exactly 3 numbers into a Vector3. Returns null
+## (never a partially-applied Vector3) on anything else.
+func _parse_vector3(raw: Variant, max_component: float) -> Variant:
+	if not (raw is Array) or (raw as Array).size() != 3:
+		return null
+	var comps: Array = []
+	for c in (raw as Array):
+		if not _is_number(c) or absf(float(c)) > max_component:
+			return null
+		comps.append(float(c))
+	return Vector3(comps[0], comps[1], comps[2])

scripts/scripting/script_interpreter.gd

@@ -0,0 +1,459 @@
+class_name ScriptInterpreterNode
+extends Node3D
+## Trusted interpreter for a [ScriptBehavior] attached to a world object.
+##
+## This is the **only** code that ever executes a ScriptBehavior's rules.
+## The rule data (ScriptBehavior / ScriptRule) is plain JSON-shaped
+## Dictionaries -- it is never handed to `eval`, never passed through
+## [Expression], and never used to call a method by a name that came from
+## the data. Every verb is dispatched through an explicit `match` in
+## [method _execute_action], and every argument reaches the engine only
+## after [ScriptBehavior] has validated it's a plain scalar / 3-vector and
+## this class has resolved it through a fixed, code-defined path (a
+## Dictionary lookup on a whitelisted catalog, a child node named
+## "Inventory", etc). There is no reachable path from rule data to
+## OS/FileAccess/networking/ClassDB/Callable. See
+## docs/architecture/scripting_sandbox.md §3.1 for the design rationale.
+##
+## ## Usage
+##
+## Attach this script directly to the Node3D that represents the object in
+## the scene (see the "ScriptedChest" node in scenes/worlds/test_level.tscn
+## for a worked example). Either set [member behavior_path] (loaded on
+## [method _ready]) or call [method set_behavior] directly with an
+## already-parsed [ScriptBehavior] (e.g. from tests).
+##
+## Triggers:
+##   - `on_interact`: player presses the "interact" action while within
+##     [member interact_radius] of this node.
+##   - `on_enter`: fires once, edge-triggered, when a player's body starts
+##     overlapping this node's trigger volume.
+##   - `on_touch`: fires every physics frame while a player's body is
+##     overlapping this node's trigger volume (continuous contact).
+##   - `on_timer`: fires on a repeating interval regardless of any player,
+##     via a dedicated [Timer] child per on_timer rule.
+
+# Sibling scripting scripts are referenced via preload rather than by their
+# global class_name so this module parses correctly from a bare/cold
+# compile -- see the note in script_behavior.gd.
+const ScriptBehaviorClass := preload("res://scripts/scripting/script_behavior.gd")
+const SpawnCatalogClass := preload("res://scripts/scripting/spawn_catalog.gd")
+const PlayerInventoryClass := preload("res://scripts/scripting/player_inventory.gd")
+
+## Emitted every time a verb actually executes, for observability/tests.
+## `args` is the normalized action Dictionary that was executed.
+signal verb_executed(verb: String, args: Dictionary)
+
+## Emitted for every rule ScriptBehavior rejected at parse time (so callers
+## can surface this in an editor / moderation tool).
+signal rule_rejected(reason: String)
+
+## JSON file to load the behavior from, if [member behavior] isn't set
+## directly before this node enters the tree.
+@export var behavior_path: String = ""
+
+## How close (metres) a player must be for `on_interact` and to count as
+## "in range" for the interact input check.
+@export var interact_radius: float = 2.5
+
+## Collision layer bit the player's body is on (see scenes/player.tscn --
+## Player.collision_layer = 2). Used as this node's trigger Area3D's
+## collision_mask so it only ever notices players, nothing else.
+@export var player_collision_mask: int = 2
+
+## The parsed behavior this node interprets. Set directly (tests) or leave
+## null and set [member behavior_path] to load one on [method _ready].
+var behavior: ScriptBehaviorClass = null
+
+var _area: Area3D = null
+var _players_in_range: Array[Node] = []
+var _entered_once: Dictionary = {}  # body instance id (int) -> true
+
+# Local, per-object whitelisted state store (see docs/architecture/
+# scripting_sandbox.md §4 open question re: static analysis of "what a
+# script can possibly do" -- flags/timers are always plain scalars here).
+var _flags: Dictionary = {}   # name (String) -> scalar
+var _timers: Dictionary = {}  # name (String) -> {"remaining": float, "active": bool}
+
+var _timer_nodes: Array[Timer] = []
+var _spawn_catalog: SpawnCatalogClass = null
+
+
+# ---------------------------------------------------------------------------
+# Lifecycle
+# ---------------------------------------------------------------------------
+
+func _ready() -> void:
+	if behavior == null and not behavior_path.is_empty():
+		behavior = ScriptBehaviorClass.load_from_file(behavior_path)
+	_apply_loaded_behavior()
+
+
+## Assign an already-parsed behavior (e.g. from a test, or built inline
+## rather than loaded from a file). Safe to call before or after this node
+## enters the tree.
+func set_behavior(new_behavior: ScriptBehaviorClass) -> void:
+	behavior = new_behavior
+	if is_inside_tree():
+		_apply_loaded_behavior()
+
+
+func _apply_loaded_behavior() -> void:
+	if behavior == null:
+		return
+	for msg in behavior.rejected_rules:
+		push_warning("ScriptInterpreterNode(%s): rejected rule -- %s" % [name, msg])
+		rule_rejected.emit(msg)
+	_setup_area()
+	_setup_timers()
+
+
+func _setup_area() -> void:
+	if _area != null:
+		_area.queue_free()
+		_area = null
+
+	_area = Area3D.new()
+	_area.name = "_ScriptTriggerArea"
+	_area.collision_layer = 0
+	_area.collision_mask = player_collision_mask
+	_area.monitoring = true
+	_area.monitorable = false
+
+	var shape := CollisionShape3D.new()
+	var sphere := SphereShape3D.new()
+	sphere.radius = interact_radius
+	shape.shape = sphere
+	_area.add_child(shape)
+
+	add_child(_area)
+	_area.body_entered.connect(_on_body_entered)
+	_area.body_exited.connect(_on_body_exited)
+
+
+func _setup_timers() -> void:
+	for t in _timer_nodes:
+		if is_instance_valid(t):
+			t.queue_free()
+	_timer_nodes.clear()
+
+	if behavior == null:
+		return
+	for rule in behavior.rules:
+		if rule.trigger_type != "on_timer":
+			continue
+		var timer := Timer.new()
+		timer.wait_time = rule.trigger_interval
+		timer.autostart = true
+		timer.one_shot = false
+		# Tied to the fixed physics step (not idle/process delta) so
+		# on_timer fires deterministically off the simulation clock,
+		# matching physics_ticks_per_second (see project.godot §physics)
+		# rather than however fast the host happens to be rendering.
+		timer.process_callback = Timer.TIMER_PROCESS_PHYSICS
+		add_child(timer)
+		timer.timeout.connect(_on_rule_timer_timeout.bind(rule))
+		_timer_nodes.append(timer)
+
+
+# ---------------------------------------------------------------------------
+# Trigger sources
+# ---------------------------------------------------------------------------
+
+func _is_player_body(body: Node) -> bool:
+	# Player carries a global class_name (scripts/player.gd); this stays a
+	# plain `is` check against a known engine/script type, never a
+	# data-driven dispatch.
+	return body is CharacterBody3D and body.has_node("Inventory")
+
+
+func _on_body_entered(body: Node) -> void:
+	if not _is_player_body(body):
+		return
+	if not _players_in_range.has(body):
+		_players_in_range.append(body)
+	var id := body.get_instance_id()
+	if not _entered_once.has(id):
+		_entered_once[id] = true
+		fire("on_enter", body)
+
+
+func _on_body_exited(body: Node) -> void:
+	_players_in_range.erase(body)
+	_entered_once.erase(body.get_instance_id())
+
+
+func _unhandled_input(event: InputEvent) -> void:
+	if _players_in_range.is_empty():
+		return
+	if event.is_action_pressed("interact") and not event.is_echo():
+		fire("on_interact", _players_in_range[0])
+
+
+func _on_rule_timer_timeout(rule) -> void:
+	_fire_rule(rule, null)
+
+
+func _physics_process(delta: float) -> void:
+	# Continuous on_touch contact -- checked every physics frame while
+	# overlapping, unlike the edge-triggered on_enter above.
+	if behavior != null and _area != null:
+		for body in _area.get_overlapping_bodies():
+			if _is_player_body(body):
+				fire("on_touch", body)
+
+	# Tick down local timers set via the set_timer verb.
+	for t_name in _timers.keys():
+		var t: Dictionary = _timers[t_name]
+		if t.get("active", false):
+			t["remaining"] = maxf(0.0, float(t.get("remaining", 0.0)) - delta)
+			if t["remaining"] <= 0.0:
+				t["active"] = false
+			_timers[t_name] = t
+
+
+# ---------------------------------------------------------------------------
+# Public firing API -- this is what every trigger source above calls, and
+# what a test can call directly to exercise a rule deterministically.
+# ---------------------------------------------------------------------------
+
+## Fire every rule of the given trigger type whose conditions currently
+## hold, in order. `player` is the entity that caused the trigger (may be
+## null for `on_timer`, which has no player context).
+func fire(trigger_type: String, player: Node) -> void:
+	if behavior == null:
+		return
+	for rule in behavior.rules:
+		if rule.trigger_type == trigger_type:
+			_fire_rule(rule, player)
+
+
+func _fire_rule(rule, player: Node) -> void:
+	if not _conditions_met(rule.conditions, player):
+		return
+	for action in rule.actions:
+		_execute_action(action, player)
+
+
+# ---------------------------------------------------------------------------
+# Condition evaluation -- reads only the small whitelisted state store
+# (item counts via a player's Inventory, local flags, local timer state).
+# No expression evaluation, no arbitrary field access.
+# ---------------------------------------------------------------------------
+
+func _conditions_met(conditions: Array[Dictionary], player: Node) -> bool:
+	for cond in conditions:
+		if not _eval_condition(cond, player):
+			return false
+	return true
+
+
+func _eval_condition(cond: Dictionary, player: Node) -> bool:
+	var op: String = cond.get("op", "")
+	var expected: Variant = cond.get("value")
+	var actual: Variant = null
+
+	match cond.get("type", ""):
+		"item_count":
+			var inv := _get_inventory(player)
+			if inv == null:
+				return false
+			actual = inv.get_count(cond.get("item_id", ""))
+		"flag":
+			actual = _flags.get(cond.get("name", ""), false)
+		"timer_active":
+			var t: Dictionary = _timers.get(cond.get("name", ""), {})
+			actual = t.get("active", false)
+		"timer_remaining":
+			var tr: Dictionary = _timers.get(cond.get("name", ""), {})
+			actual = tr.get("remaining", 0.0)
+		_:
+			return false
+
+	return _compare(actual, op, expected)
+
+
+func _compare(actual: Variant, op: String, expected: Variant) -> bool:
+	match op:
+		"==":
+			return actual == expected
+		"!=":
+			return actual != expected
+		"<", "<=", ">", ">=":
+			if not ((actual is int or actual is float) and (expected is int or expected is float)):
+				return false
+			var a: float = float(actual)
+			var b: float = float(expected)
+			match op:
+				"<":
+					return a < b
+				"<=":
+					return a <= b
+				">":
+					return a > b
+				">=":
+					return a >= b
+	return false
+
+
+## Set a local flag on this object's whitelisted state store. Not driven by
+## any ScriptBehavior verb yet (the verb list in the task spec has no
+## setter) -- exposed for forward compatibility / tests exercising `flag`
+## conditions without needing a real gameplay event to set one.
+func set_flag(flag_name: String, value: Variant) -> void:
+	if not (value is String or value is int or value is float or value is bool):
+		return
+	_flags[flag_name] = value
+
+
+# ---------------------------------------------------------------------------
+# Verb dispatch -- the entire attack surface this system deliberately does
+# NOT have. Every branch is a fixed, hand-written function; nothing here is
+# ever `call()`-ed by a name that came from data.
+# ---------------------------------------------------------------------------
+
+func _execute_action(action: Dictionary, player: Node) -> void:
+	match action.get("verb", ""):
+		"give_item":
+			_act_give_item(action, player)
+		"play_sound":
+			_act_play_sound(action, player)
+		"move":
+			_act_move(action, player)
+		"rotate":
+			_act_rotate(action, player)
+		"spawn_from_catalog":
+			_act_spawn_from_catalog(action, player)
+		"set_timer":
+			_act_set_timer(action, player)
+		_:
+			# Unreachable in practice -- ScriptBehavior rejects unknown
+			# verbs at parse time, so this branch should never see a rule
+			# at all. Fail safe (do nothing) if it somehow does.
+			push_warning("ScriptInterpreterNode(%s): refused to run unknown verb '%s'" % [name, str(action.get("verb"))])
+
+
+func _resolve_target(target: String, player: Node) -> Node3D:
+	match target:
+		"self":
+			return self
+		"player":
+			return player if player is Node3D else null
+	return null
+
+
+func _get_inventory(player: Node) -> PlayerInventoryClass:
+	if player == null:
+		return null
+	var inv: Node = player.get_node_or_null("Inventory")
+	if inv is PlayerInventoryClass:
+		return inv as PlayerInventoryClass
+	return null
+
+
+func _act_give_item(action: Dictionary, player: Node) -> void:
+	var inv := _get_inventory(player)
+	if inv == null:
+		push_warning("ScriptInterpreterNode(%s): give_item has no player Inventory to target" % name)
+		return
+	inv.give_item(action.get("item_id", ""), int(action.get("count", 0)))
+	verb_executed.emit("give_item", action)
+
+
+func _act_play_sound(action: Dictionary, _player: Node) -> void:
+	# No real audio asset catalog exists in this repo yet. The verb still
+	# runs through a real, trusted playback path -- attempting to resolve
+	# and play a stream when one is registered -- so it's not a no-op
+	# pretending to be a verb; it's just that today's trusted sound table
+	# is empty. `sound_id` is only ever used as a key into that trusted,
+	# code-defined table below, never as a path handed to load() directly.
+	var sound_id: String = action.get("sound_id", "")
+	var stream_path: String = _TRUSTED_SOUND_TABLE.get(sound_id, "")
+	if not stream_path.is_empty() and ResourceLoader.exists(stream_path):
+		var stream: Resource = load(stream_path)
+		if stream is AudioStream:
+			var player_node := AudioStreamPlayer3D.new()
+			player_node.stream = stream
+			add_child(player_node)
+			player_node.finished.connect(player_node.queue_free)
+			player_node.play()
+	verb_executed.emit("play_sound", action)
+
+
+## Trusted, code-defined mapping from sound_id -> resource path. Rule data
+## supplies only the key; this table (not the data) decides what actually
+## plays. Empty for now -- no sound assets exist in this repo yet.
+const _TRUSTED_SOUND_TABLE: Dictionary = {}
+
+
+func _act_move(action: Dictionary, player: Node) -> void:
+	var target_node := _resolve_target(action.get("target", "self"), player)
+	if target_node == null:
+		push_warning("ScriptInterpreterNode(%s): move has no valid target" % name)
+		return
+	var offset: Vector3 = action.get("offset", Vector3.ZERO)
+	var duration: float = float(action.get("duration", ScriptBehaviorClass.DEFAULT_MOVE_DURATION))
+	var dest: Vector3 = target_node.global_position + offset
+	var tween := target_node.create_tween()
+	tween.tween_property(target_node, "global_position", dest, duration)
+	verb_executed.emit("move", action)
+
+
+func _act_rotate(action: Dictionary, player: Node) -> void:
+	var target_node := _resolve_target(action.get("target", "self"), player)
+	if target_node == null:
+		push_warning("ScriptInterpreterNode(%s): rotate has no valid target" % name)
+		return
+	var degrees: float = float(action.get("degrees", 0.0))
+	var axis: String = action.get("axis", "y")
+	var duration: float = float(action.get("duration", ScriptBehaviorClass.DEFAULT_MOVE_DURATION))
+	var delta_rot := Vector3.ZERO
+	match axis:
+		"x":
+			delta_rot.x = degrees
+		"y":
+			delta_rot.y = degrees
+		"z":
+			delta_rot.z = degrees
+	var dest: Vector3 = target_node.rotation_degrees + delta_rot
+	var tween := target_node.create_tween()
+	tween.tween_property(target_node, "rotation_degrees", dest, duration)
+	verb_executed.emit("rotate", action)
+
+
+func _act_spawn_from_catalog(action: Dictionary, _player: Node) -> void:
+	if _spawn_catalog == null:
+		_spawn_catalog = SpawnCatalogClass.new()
+		_spawn_catalog.load_catalog()
+	var catalog_id: String = action.get("catalog_id", "")
+	var entry: Dictionary = _spawn_catalog.resolve(catalog_id)
+	if entry.is_empty():
+		push_warning("ScriptInterpreterNode(%s): spawn_from_catalog unknown catalog_id '%s'" % [name, catalog_id])
+		return
+
+	var asset_id: String = entry.get("asset_id", "")
+	var position: Vector3 = action.get("position", Vector3.ZERO)
+
+	# Both WorldObject and DynamicObjectNode carry a global class_name and
+	# are already relied on elsewhere in the project (scripts/chunk_scene.gd)
+	# without preloading -- consistent with that existing convention.
+	var obj := WorldObject.new(
+		"spawned_%d" % Time.get_ticks_usec(), "prop", asset_id,
+		position, Vector4(0, 0, 0, 1), Vector3.ONE, {}, true
+	)
+	var node := DynamicObjectNode.new()
+	node.world_object = obj
+	node.position = position
+	node.name = "spawned_%s" % obj.id
+
+	var host := get_parent() if get_parent() != null else get_tree().current_scene
+	if host != null:
+		host.add_child(node)
+	verb_executed.emit("spawn_from_catalog", action)
+
+
+func _act_set_timer(action: Dictionary, _player: Node) -> void:
+	var timer_name: String = action.get("name", "")
+	var seconds: float = float(action.get("seconds", 0.0))
+	_timers[timer_name] = {"remaining": seconds, "active": true}
+	verb_executed.emit("set_timer", action)

scripts/scripting/script_rule.gd

@@ -0,0 +1,32 @@
+class_name ScriptRule
+extends RefCounted
+## One parsed, validated rule: WHEN [trigger] IF [conditions] THEN [actions].
+##
+## Rules are parsed once, by [ScriptBehavior], from a plain [Dictionary] that
+## ultimately comes from untrusted UGC data (a JSON file on disk, or a dict
+## embedded in a [WorldObject]'s `properties`). Every field on this class is
+## a plain scalar (String/int/float/bool) or a small [Dictionary]/[Array] of
+## scalars -- never a [Callable], a [Script], a [Node] reference, or anything
+## else the data could use to reach into the engine. [ScriptInterpreterNode]
+## is the only code that reads these fields, and it does so through an
+## explicit `match` over a fixed whitelist -- see script_interpreter.gd.
+##
+## See docs/architecture/scripting_sandbox.md for why the data format has to
+## look like this (no eval, no Expression, no call-by-name).
+
+## One of "on_interact", "on_enter", "on_touch", "on_timer".
+var trigger_type: String = ""
+
+## Only meaningful when trigger_type == "on_timer": seconds between firings.
+var trigger_interval: float = 0.0
+
+## Normalized condition dicts. Each has a "type" (one of
+## ScriptBehavior.VALID_CONDITION_TYPES), an "op" (one of
+## ScriptBehavior.VALID_OPS) and scalar operands -- see script_behavior.gd
+## for the exact per-type shape.
+var conditions: Array[Dictionary] = []
+
+## Normalized action dicts. Each has a "verb" (one of
+## ScriptBehavior.VALID_VERBS) and scalar arguments -- see
+## script_behavior.gd for the exact per-verb shape.
+var actions: Array[Dictionary] = []

scripts/scripting/spawn_catalog.gd

@@ -0,0 +1,55 @@
+class_name SpawnCatalog
+extends RefCounted
+## Catalog of spawnable object templates for ScriptBehavior's
+## `spawn_from_catalog` verb.
+##
+## Mirrors the loading convention of [AvatarCatalog]
+## (assets/avatars/catalog.json / scripts/avatar/avatar_catalog.gd) --
+## a data-driven JSON manifest, loaded once, looked up by id.
+##
+## Crucially, a ScriptBehavior rule only ever supplies a `catalog_id`
+## *key* -- never a resource path. The mapping from key to actual asset
+## path lives entirely in this trusted, code-shipped JSON file. A
+## malicious/malformed catalog_id in UGC data just fails to resolve
+## ([method resolve] returns an empty Dictionary); there's no way for the
+## data to point anywhere else.
+
+var _catalog: Dictionary = {}
+var _loaded: bool = false
+var _catalog_path: String = "res://assets/scripting/spawn_catalog.json"
+
+
+## Load the catalog from disk. Call this before any lookups.
+func load_catalog(path: String = _catalog_path) -> Error:
+	_catalog_path = path
+	_catalog = {}
+
+	var file := FileAccess.open(path, FileAccess.READ)
+	if file == null:
+		return FileAccess.get_open_error()
+
+	var json_text: String = file.get_as_text()
+	file.close()
+
+	var result: Variant = JSON.parse_string(json_text)
+	if result == null or not (result is Dictionary) or not (result as Dictionary).has("templates"):
+		return ERR_INVALID_DATA
+
+	_catalog = (result as Dictionary)["templates"]
+	_loaded = true
+	return OK
+
+
+func is_loaded() -> bool:
+	return _loaded
+
+
+## Resolve a catalog_id to its template Dictionary ({} if unknown/unloaded).
+func resolve(catalog_id: String) -> Dictionary:
+	if not _loaded:
+		return {}
+	return _catalog.get(catalog_id, {})
+
+
+func has_template(catalog_id: String) -> bool:
+	return _loaded and _catalog.has(catalog_id)

scripts/server.gd

@@ -9,9 +9,26 @@
 ## Launched by the backend's game-server supervisor
 ## (backend/app/services/game_servers.py):
 ##     godot --headless --path . res://scenes/server.tscn -- \
-##         --port 27000 --world 3 --status-file /path/to/status.json
+##         --port 27000 --world 3 --status-file /path/to/status.json \
+##         --api-url http://127.0.0.1:8000 --server-token <per-spawn token>
 ## All args are optional; the defaults let `godot res://scenes/server.tscn`
-## run standalone on 7777 for smoke_test_network_client.gd.
+## run standalone on 7777 for smoke_test_network_client.gd (which passes
+## neither --api-url nor --server-token, so startup goes straight to the
+## test_level.tscn fallback below).
+##
+## Startup sequence (docs/architecture/world_persistence_impl.md §7.2):
+##   1. Parse args.
+##   2. If --api-url/--server-token/--world are all present, pull the world's
+##      manifest + the spawn-neighbourhood chunks from the backend's internal
+##      API (§8.3), decode them, and build real static collision from the
+##      tile layers + objects. This happens BEFORE the ENet port binds.
+##   3. Fall back to test_level.tscn if the backend is unreachable, the world
+##      has no rooms, or the room has zero chunks -- a content outage must
+##      never make a world un-joinable (§7.2 step 5).
+##   4. Bind the ENet port, then write "ready": true and "content" ("loaded"
+##      or "fallback") to the status file -- this is what
+##      GameServerSupervisor._await_ready() polls for (§7.4), replacing the
+##      old bare-port-bind readiness check.
 extends Node
 
 const MAX_PLAYERS := 16
@@ -21,11 +38,40 @@ const PHYSICS_HZ := 30
 ## every this many physics frames.
 const STATUS_WRITE_EVERY := 30
 
+## world_persistence_impl.md §4.1's default room slug.
+const MAIN_ROOM_SLUG := "main"
+## §7.2 step 3: "the spawn neighbourhood (radius from the spawn point,
+## default 3 chunks)".
+const SPAWN_CHUNK_RADIUS := 3
+## HTTP timeout for internal-API calls during startup. Generous but bounded
+## -- a hung backend must not hang the server startup (§7.2 fallback rule).
+const CONTENT_FETCH_TIMEOUT := 8.0
+
 var network_peer: ENetMultiplayerPeer
 var port: int = DEFAULT_PORT
 var world_id: String = ""
 var status_file_path: String = ""
 
+## world_persistence_impl.md §7.3: internal-API base URL and this spawn's
+## bearer token, both passed on the command line by
+## GameServerSupervisor._spawn(). Empty means "no backend to talk to" --
+## content loading is skipped and the fallback level loads immediately.
+var api_url: String = ""
+var server_token: String = ""
+
+## What startup actually loaded, written into the status file's "content"
+## field: "loaded" (real content from the backend) or "fallback"
+## (test_level.tscn, either because there was nothing to load or nothing
+## reachable to load it from).
+var _content_status: String = "fallback"
+## Diagnostic-only counters (not part of the doc's required status fields,
+## but real: they're the actual number of chunks decoded and collision
+## shapes added to the tree, computed in the same pass that builds them --
+## useful for verifying a real load happened without needing to poke the
+## running server's scene tree from outside).
+var _chunks_loaded: int = 0
+var _collision_shapes_built: int = 0
+
 ## peer_id -> Player node
 var players: Dictionary = {}
 var tick: int = 0
@@ -35,7 +81,7 @@ var is_running: bool = false
 var _join_count: int = 0
 
 var _player_scene: PackedScene = preload("res://scenes/server_player.tscn")
-var _level_scene: PackedScene = preload("res://scenes/worlds/test_level.tscn")
+var _fallback_level_scene: PackedScene = preload("res://scenes/worlds/test_level.tscn")
 var _spawn_point: Vector3 = Vector3(0, 1.5, 0)
 
 
@@ -48,8 +94,16 @@ func _ready() -> void:
 	_parse_args()
 	Engine.physics_ticks_per_second = PHYSICS_HZ
 
-	# Load the world's level so players have real ground + collision.
-	var level := _level_scene.instantiate()
+	var level: Node = null
+	if api_url != "" and server_token != "" and world_id != "":
+		level = await _try_load_real_content()
+
+	if level == null:
+		level = _fallback_level_scene.instantiate()
+		_content_status = "fallback"
+	else:
+		_content_status = "loaded"
+
 	level.name = "World"
 	add_child(level)
 	var marker := level.find_child("PlayerSpawn", true, false)
@@ -65,7 +119,9 @@ func _ready() -> void:
 	multiplayer.multiplayer_peer = network_peer
 	is_running = true
 	_write_status()
-	print("[Server] world=%s listening on ENet %d (%d Hz)" % [world_id, port, PHYSICS_HZ])
+	print("[Server] world=%s listening on ENet %d (%d Hz) content=%s chunks=%d collision_shapes=%d" % [
+		world_id, port, PHYSICS_HZ, _content_status, _chunks_loaded, _collision_shapes_built
+	])
 
 
 ## A spawn point offset from the level's marker so joins don't stack. Golden-
@@ -95,9 +151,198 @@ func _parse_args() -> void:
 				if i + 1 < args.size():
 					status_file_path = args[i + 1]
 					i += 1
+			"--api-url":
+				if i + 1 < args.size():
+					api_url = args[i + 1].rstrip("/")
+					i += 1
+			"--server-token":
+				if i + 1 < args.size():
+					server_token = args[i + 1]
+					i += 1
 		i += 1
 
 
+# ---------------------------------------------------------------------------
+# Startup content load (world_persistence_impl.md §7.2/§7.3/§8.3)
+# ---------------------------------------------------------------------------
+
+## Attempt to build a real level from the backend's internal content API.
+## Returns null on ANY failure (unreachable backend, no rooms, zero chunks)
+## so the caller falls back to test_level.tscn -- a content outage must
+## never make a world un-joinable.
+func _try_load_real_content() -> Node:
+	var manifest_result := await _internal_get_json("/api/internal/worlds/%s/manifest" % world_id)
+	if not manifest_result.ok:
+		print("[Server] manifest fetch failed (%s); falling back to test_level" % manifest_result.get("detail", "?"))
+		return null
+
+	var manifest: Dictionary = manifest_result.data
+	var rooms: Array = manifest.get("rooms", [])
+	var room: Variant = _pick_room(rooms)
+	if room == null:
+		print("[Server] world %s has no rooms; falling back to test_level" % world_id)
+		return null
+	if int(room.get("chunk_count", 0)) <= 0:
+		print("[Server] room '%s' has zero chunks; falling back to test_level" % room.get("slug", "?"))
+		return null
+
+	var slug: String = room.get("slug", MAIN_ROOM_SLUG)
+	var spawn_pos := _spawn_pos_from_room(room)
+	var spawn_coord := Chunk.coord_for_position(spawn_pos)
+
+	var index_path := "/api/internal/worlds/%s/rooms/%s/chunks?cx_min=%d&cx_max=%d&cy_min=%d&cy_max=%d&cz=%d" % [
+		world_id, slug,
+		spawn_coord.x - SPAWN_CHUNK_RADIUS, spawn_coord.x + SPAWN_CHUNK_RADIUS,
+		spawn_coord.y - SPAWN_CHUNK_RADIUS, spawn_coord.y + SPAWN_CHUNK_RADIUS,
+		spawn_coord.z,
+	]
+	var index_result := await _internal_get_json(index_path)
+	if not index_result.ok:
+		print("[Server] chunk index fetch failed (%s); falling back to test_level" % index_result.get("detail", "?"))
+		return null
+
+	var world_root := Node3D.new()
+	world_root.name = "World"
+	var marker := Marker3D.new()
+	marker.name = "PlayerSpawn"
+	marker.position = spawn_pos
+	world_root.add_child(marker)
+
+	var entries: Array = (index_result.data as Dictionary).get("chunks", [])
+	for entry in entries:
+		var cx: int = int(entry["cx"])
+		var cy: int = int(entry["cy"])
+		var cz: int = int(entry["cz"])
+		var chunk_path := "/api/internal/worlds/%s/rooms/%s/chunks/%d/%d/%d" % [world_id, slug, cx, cy, cz]
+		var payload_result := await _internal_get_binary(chunk_path)
+		if not payload_result.ok:
+			printerr("[Server] chunk fetch failed for %d/%d/%d (status %d); skipping" % [cx, cy, cz, payload_result.status])
+			continue
+		var decoded: ChunkDataDecoder.ChunkPayload = ChunkDataDecoder.decode_binary(payload_result.body)
+		if decoded == null:
+			printerr("[Server] chunk decode failed for %d/%d/%d; skipping" % [cx, cy, cz])
+			continue
+		_build_chunk_collision(world_root, Vector3i(cx, cy, cz), decoded)
+		_chunks_loaded += 1
+
+	return world_root
+
+
+func _pick_room(rooms: Array) -> Variant:
+	for r in rooms:
+		if r.get("slug", "") == MAIN_ROOM_SLUG:
+			return r
+	if not rooms.is_empty():
+		return rooms[0]
+	return null
+
+
+func _spawn_pos_from_room(room: Dictionary) -> Vector3:
+	var spawn: Variant = room.get("spawn")
+	if spawn is Dictionary and (spawn as Dictionary).has("pos"):
+		var p: Array = (spawn as Dictionary)["pos"]
+		if p.size() >= 3:
+			return Vector3(float(p[0]), float(p[1]), float(p[2]))
+	return Vector3(0, 1.5, 0)
+
+
+## Build a StaticBody3D of box collision shapes for one decoded chunk: one
+## box per solid tile (TileDef.solid, world.md §3.2) plus one per static
+## (non-dynamic) object that isn't walkable. This is real collision derived
+## from the actual decoded payload -- there is no client-side precedent to
+## reuse (ChunkScene/TileLayerNode only build visuals; the dedicated server
+## has no renderer and needs physics bodies instead).
+func _build_chunk_collision(parent: Node3D, coord: Vector3i, data: ChunkDataDecoder.ChunkPayload) -> void:
+	var body := StaticBody3D.new()
+	body.name = "chunk_%d_%d_%d" % [coord.x, coord.y, coord.z]
+	var chunk_origin := Vector3(
+		coord.x * Chunk.CHUNK_SIZE_X,
+		coord.y * Chunk.CHUNK_SIZE_Y,
+		coord.z * Chunk.CHUNK_SIZE_Z
+	)
+
+	for layer in data.tile_layers:
+		for z in range(layer.depth):
+			for y in range(layer.height):
+				for x in range(layer.width):
+					var tile_id := layer.get_tile(x, y, z)
+					if tile_id == 0:
+						continue
+					var tile_def := layer.get_tile_def(tile_id)
+					if tile_def == null or not tile_def.solid:
+						continue
+					var shape := CollisionShape3D.new()
+					var box := BoxShape3D.new()
+					box.size = Vector3.ONE
+					shape.shape = box
+					shape.position = chunk_origin + Vector3(x + 0.5, y + 0.5, z + 0.5)
+					body.add_child(shape)
+					_collision_shapes_built += 1
+
+	for obj in data.objects:
+		if obj.dynamic:
+			continue  # dynamic templates are spawnable entities, not static geometry
+		if bool(obj.properties.get("walkable", true)):
+			continue
+		var shape := CollisionShape3D.new()
+		var box := BoxShape3D.new()
+		box.size = obj.scale
+		shape.shape = box
+		shape.position = obj.position
+		body.add_child(shape)
+		_collision_shapes_built += 1
+
+	if body.get_child_count() > 0:
+		parent.add_child(body)
+
+
+## Minimal internal-API HTTP GET, bearer-authenticated with --server-token
+## (world_persistence_impl.md §7.3). Deliberately separate from ApiClient:
+## that autoload's `request()` always decodes the response body as
+## UTF-8/JSON, which corrupts binary chunk payloads, and its auth model is
+## the player's JWT, not this process's per-spawn server token.
+func _internal_get_json(path: String) -> Dictionary:
+	var raw := await _internal_get(path, "application/json")
+	if not raw.ok:
+		return {"ok": false, "status": raw.status, "detail": raw.get("detail", ""), "data": null}
+	var parsed: Variant = JSON.parse_string(raw.body.get_string_from_utf8())
+	if not (parsed is Dictionary):
+		return {"ok": false, "status": raw.status, "detail": "invalid JSON response", "data": null}
+	return {"ok": true, "status": raw.status, "detail": "", "data": parsed}
+
+
+func _internal_get_binary(path: String) -> Dictionary:
+	return await _internal_get(path, "application/octet-stream")
+
+
+func _internal_get(path: String, accept: String) -> Dictionary:
+	var http := HTTPRequest.new()
+	http.timeout = CONTENT_FETCH_TIMEOUT
+	add_child(http)
+
+	var headers := PackedStringArray()
+	headers.append("Accept: " + accept)
+	headers.append("Authorization: Bearer " + server_token)
+
+	var url := api_url + path
+	var err := http.request(url, headers, HTTPClient.METHOD_GET)
+	if err != OK:
+		http.queue_free()
+		return {"ok": false, "status": 0, "detail": "request() failed to start (%d)" % err, "body": PackedByteArray()}
+
+	var args: Array = await http.request_completed
+	var result_code: int = args[0]
+	var response_code: int = args[1]
+	var body: PackedByteArray = args[3]
+	http.queue_free()
+
+	if result_code != HTTPRequest.RESULT_SUCCESS:
+		return {"ok": false, "status": 0, "detail": "transport error (%d)" % result_code, "body": PackedByteArray()}
+	if response_code < 200 or response_code >= 300:
+		return {"ok": false, "status": response_code, "detail": "HTTP %d" % response_code, "body": body}
+	return {"ok": true, "status": response_code, "detail": "", "body": body}
+
+
 func _physics_process(_delta: float) -> void:
 	if not is_running:
 		return
@@ -176,7 +421,8 @@ func _on_peer_disconnected(peer_id: int) -> void:
 
 
 # ---------------------------------------------------------------------------
-# Status file for the supervisor's idle reaper
+# Status file for the supervisor's idle reaper + readiness wait
+# (world_persistence_impl.md §7.4 / game_servers.py's _await_ready)
 # ---------------------------------------------------------------------------
 
 func _write_status() -> void:
@@ -190,5 +436,12 @@ func _write_status() -> void:
 			"players": players.size(),
 			"tick": tick,
 			"updated": Time.get_unix_time_from_system(),
+			# game_servers.py's _await_ready() polls for this -- only ever
+			# written true, and only once content has been decided (loaded
+			# or fallen back) AND create_server() has already succeeded.
+			"ready": is_running,
+			"content": _content_status,
+			"chunks_loaded": _chunks_loaded,
+			"collision_shapes": _collision_shapes_built,
 		}))
 		f.close()

scripts/smoke_test_chunk_codec_interop.gd

@@ -0,0 +1,132 @@
+extends SceneTree
+## Proves the client-side ChunkDataDecoder decodes the backend's exact golden
+## fixture files (backend/tests/fixtures/chunks/*.bin) with byte-identical
+## logical values -- the actual cross-language contract this whole
+## persistence system depends on. Also regression-covers the float32
+## int<->float numeric-cast bug (fixed alongside this test): `bits as float`
+## silently corrupted every non-integer value (1.5 decoded as 1069547520.0).
+##
+## Run: ~/godot/godot --headless --script res://scripts/smoke_test_chunk_codec_interop.gd
+
+const FIXTURES_DIR := "res://backend/tests/fixtures/chunks/"
+
+var passed := 0
+var failed := 0
+
+
+func _check(label: String, cond: bool) -> void:
+	if cond:
+		passed += 1
+		print("  PASS: ", label)
+	else:
+		failed += 1
+		print("  FAIL: ", label)
+
+
+func _init() -> void:
+	_test_float32_roundtrip()
+	_test_empty_chunk_fixture()
+	_test_simple_tile_chunk_fixture()
+	_test_chunk_with_objects_fixture()
+	_test_nonzero_bounds_roundtrip()
+
+	print("\n=== SMOKE RESULT: %d/%d passed ===" % [passed, passed + failed])
+	quit(0 if failed == 0 else 1)
+
+
+func _test_nonzero_bounds_roundtrip() -> void:
+	print("--- client-local encode_binary/decode_binary round-trip, nonzero bounds position ---")
+	# Regression for a real bug: _build_metadata_section used to write raw
+	# `bounds.size` into the wire's 2nd float triple, but the wire format
+	# (and _parse_metadata_section) treats that triple as max_pos, deriving
+	# size = max - min. AABB(Vector3.ZERO, size) masks this (size == max
+	# when position is 0), so this specifically uses a real, nonzero chunk
+	# position -- e.g. the chunk at coord (3,-1,0), matching the backend
+	# golden fixture's own bounds.position (96,-32,0) -- to catch it for real.
+	var payload := ChunkDataDecoder.ChunkPayload.new()
+	payload.world_id = "1"
+	payload.room_id = "main"
+	payload.coord = Vector3i(3, -1, 0)
+	payload.bounds = AABB(Vector3(96.0, -32.0, 0.0), Vector3(32.0, 32.0, 1.0))
+
+	var encoded := ChunkDataDecoder.encode_binary(payload)
+	var decoded: ChunkDataDecoder.ChunkPayload = ChunkDataDecoder.decode_binary(encoded)
+	_check("decoded without error", decoded != null)
+	if decoded == null:
+		return
+	_check("bounds.position survives round-trip (96,-32,0)", decoded.bounds.position.is_equal_approx(Vector3(96.0, -32.0, 0.0)))
+	_check("bounds.size survives round-trip (32,32,1) -- the actual regression check", decoded.bounds.size.is_equal_approx(Vector3(32.0, 32.0, 1.0)))
+
+
+func _read_fixture(name: String) -> PackedByteArray:
+	var f := FileAccess.open(FIXTURES_DIR + name, FileAccess.READ)
+	if f == null:
+		push_error("Could not open fixture: " + name)
+		return PackedByteArray()
+	return f.get_buffer(f.get_length())
+
+
+func _test_float32_roundtrip() -> void:
+	print("--- float32 bitcast regression (the actual bug this fix addresses) ---")
+	for val in [1.5, -110.25, 0.5, 3.14159, -0.001, 0.0, 100.0]:
+		var encoded: PackedByteArray = ChunkDataDecoder._write_float32(val)
+		var decoded: float = ChunkDataDecoder._read_float32(encoded, 0)
+		_check("float32 round-trip for %s (got %s)" % [val, decoded], is_equal_approx(decoded, val))
+	# The specific regression case: 1.5 must NOT decode as 1069547520.0
+	# (the old `bits as float` numeric-cast bug's actual observed output).
+	var bad_encoded := ChunkDataDecoder._write_float32(1.5)
+	var bad_decoded: float = ChunkDataDecoder._read_float32(bad_encoded, 0)
+	_check("1.5 does not decode as the old numeric-cast bug's 1069547520.0", not is_equal_approx(bad_decoded, 1069547520.0))
+
+
+func _test_empty_chunk_fixture() -> void:
+	print("--- backend golden fixture: empty_chunk.bin ---")
+	var data := _read_fixture("empty_chunk.bin")
+	_check("fixture file read (non-empty)", data.size() > 0)
+	var payload: ChunkDataDecoder.ChunkPayload = ChunkDataDecoder.decode_binary(data)
+	_check("decoded without error", payload != null)
+	if payload == null:
+		return
+	_check("world_id matches backend fixture (7)", payload.world_id == "7")
+	_check("no tile layers", payload.tile_layers.is_empty())
+	_check("no objects", payload.objects.is_empty())
+	_check("revision matches backend fixture (1)", payload.revision == 1)
+
+
+func _test_simple_tile_chunk_fixture() -> void:
+	print("--- backend golden fixture: simple_tile_chunk.bin ---")
+	var data := _read_fixture("simple_tile_chunk.bin")
+	var payload: ChunkDataDecoder.ChunkPayload = ChunkDataDecoder.decode_binary(data)
+	_check("decoded without error", payload != null)
+	if payload == null:
+		return
+	_check("world_id matches (12)", payload.world_id == "12")
+	_check("coord matches (3,-1,0)", payload.coord == Vector3i(3, -1, 0))
+	_check("bounds.position matches (96.0,-32.0,0.0) -- non-trivial floats", payload.bounds.position.is_equal_approx(Vector3(96.0, -32.0, 0.0)))
+	_check("bounds.size matches (32.0,32.0,1.0)", payload.bounds.size.is_equal_approx(Vector3(32.0, 32.0, 1.0)))
+	_check("one tile layer parsed", payload.tile_layers.size() == 1)
+	if payload.tile_layers.size() == 1:
+		var layer: ChunkDataDecoder.TileLayerData = payload.tile_layers[0]
+		_check("tile layer dims 4x4x1", layer.width == 4 and layer.height == 4 and layer.depth == 1)
+		_check("tile data matches backend fixture", layer.tiles == PackedInt32Array([0, 1, 1, 0, 1, 2, 2, 1, 1, 2, 2, 1, 0, 1, 1, 0]))
+	_check("revision matches (2)", payload.revision == 2)
+
+
+func _test_chunk_with_objects_fixture() -> void:
+	print("--- backend golden fixture: chunk_with_objects.bin (real non-integer floats) ---")
+	var data := _read_fixture("chunk_with_objects.bin")
+	var payload: ChunkDataDecoder.ChunkPayload = ChunkDataDecoder.decode_binary(data)
+	_check("decoded without error", payload != null)
+	if payload == null:
+		return
+	_check("one object parsed", payload.objects.size() >= 1)
+	if payload.objects.is_empty():
+		return
+	var obj: ChunkDataDecoder.WorldObjectData = payload.objects[0]
+	_check("object id matches (obj_0001)", obj.id == "obj_0001")
+	_check("object asset_id matches (props/chest)", obj.asset_id == "props/chest")
+	# The core regression check: these are exactly the kind of non-integer
+	# values that decoded as garbage under the old `bits as float` bug.
+	_check("object position.x matches 101.5 exactly (was the corrupted value)", is_equal_approx(obj.position.x, 101.5))
+	_check("object position.y matches -110.25 exactly (was the corrupted value)", is_equal_approx(obj.position.y, -110.25))
+	_check("object position.z matches 0.5 exactly (was the corrupted value)", is_equal_approx(obj.position.z, 0.5))

scripts/smoke_test_http_chunk_source.gd

@@ -0,0 +1,189 @@
+extends SceneTree
+## Real integration test for HttpChunkSource against a live backend.
+##
+## Covers docs/architecture/world_persistence_impl.md D6/§8.4: the client
+## streams chunks over HTTP through the same ChunkStreamManager.set_server_rpc()
+## seam a fake/ENet source would use. This proves the adapter actually
+## satisfies that seam end-to-end -- a real PUT'd chunk decodes into a real
+## ChunkScene with real tile layers + objects, an unwritten coordinate
+## "renders empty" instead of erroring, and a second fetch of an unchanged
+## chunk round-trips through the 304/ETag cache path without failing.
+##
+## Run with:
+##     godot --headless --path . --script res://scripts/smoke_test_http_chunk_source.gd
+##
+## Requires the backend to be running (default base URL
+## `application/agp/api_base_url` -> http://127.0.0.1:8000, overridable via
+## AGP_API_BASE_URL).
+
+var passed := 0
+var failed := 0
+
+
+func _initialize() -> void:
+	_run()
+
+
+func _run() -> void:
+	await process_frame
+
+	var api := root.get_node("ApiClient")
+
+	randomize()
+	var unique_id: int = int(Time.get_unix_time_from_system() * 1000) + randi() % 100000
+	var username := "httpchunk_%d" % unique_id
+	var email := "httpchunk_%d@test.example.com" % unique_id
+	var reg: Dictionary = await api.register(username, email, "SmokeTest123!", "1990-01-01")
+	if not _check("setup: register succeeded", reg.ok):
+		print("  detail: ", reg.detail)
+		_finish()
+		return
+
+	var world_body := JSON.stringify({
+		"name": "HttpChunkSource Smoke World %d" % unique_id,
+		"visibility": "public",
+	})
+	var world_result: Dictionary = await api.request(
+		HTTPClient.METHOD_POST, "/api/worlds/", world_body, "application/json", true
+	)
+	if not _check("setup: world created", world_result.ok):
+		print("  detail: ", world_result.detail)
+		_finish()
+		return
+	var world_id: int = (world_result.data as Dictionary)["id"]
+
+	# Seed a real chunk at (0,0,0): one solid tile + one static object, built
+	# with the same client-side codec HttpChunkSource's decode path uses on
+	# the way back in (round-tripping through the real backend, not a mock).
+	var chunk_payload := _build_test_chunk(world_id)
+	var encoded := ChunkDataDecoder.encode_binary(chunk_payload)
+	# ApiClient.request() only takes a String body, which can't carry
+	# arbitrary binary safely -- PUT with a dedicated HTTPRequest instead
+	# (request_raw takes a real PackedByteArray), matching what the real
+	# backend test suite sends.
+	var put_result: Dictionary = await _put_binary(api, world_id, encoded)
+	if not _check("setup: chunk PUT succeeded", put_result.ok):
+		print("  detail: ", put_result.detail)
+		_finish()
+		return
+
+	# Build the real ChunkStreamManager + HttpChunkSource pair and wire them
+	# exactly as real gameplay code would.
+	var manager := ChunkStreamManager.new()
+	root.add_child(manager)
+	var source := HttpChunkSource.new()
+	source.world_id = str(world_id)
+	source.room_slug = "main"
+	source.stream_manager = manager
+	manager.add_child(source)
+	manager.set_server_rpc(source)
+
+	# 1. A written coordinate decodes into a real ChunkScene.
+	manager._load_chunk(Vector3i(0, 0, 0))
+	var chunk_scene: Node = await _wait_for_chunk(manager, Vector3i(0, 0, 0))
+	_check("written chunk (0,0,0) loaded via HttpChunkSource", chunk_scene != null)
+	if chunk_scene != null:
+		_check("loaded chunk has 1 tile layer", chunk_scene.tile_layers.size() == 1)
+		_check("loaded chunk tile layer has the expected solid tile",
+			chunk_scene.tile_layers[0].tiles[0] == 1)
+		_check("loaded chunk has 1 world object", chunk_scene.world_objects.size() == 1)
+
+	# 2. An unwritten coordinate renders empty, not an error.
+	manager._load_chunk(Vector3i(9, 9, 0))
+	var empty_scene: Node = await _wait_for_chunk(manager, Vector3i(9, 9, 0))
+	_check("unwritten chunk (9,9,0) still resolves (renders empty)", empty_scene != null)
+	if empty_scene != null:
+		_check("unwritten chunk has no tile layers", empty_scene.tile_layers.is_empty())
+
+	# 3. Re-fetching the same written chunk exercises the ETag/304 path
+	# (can't observe the wire status code directly here, but a stale cache
+	# entry or a broken conditional-request path would either error or
+	# silently return corrupt/empty data -- this proves it doesn't).
+	manager.force_reload_chunk(Vector3i(0, 0, 0))
+	var refetched: Node = await _wait_for_chunk(manager, Vector3i(0, 0, 0))
+	_check("re-fetch of unchanged chunk (0,0,0) round-trips via cache/304 path", refetched != null)
+	if refetched != null:
+		_check("re-fetched chunk still has 1 tile layer", refetched.tile_layers.size() == 1)
+
+	_finish()
+
+
+func _build_test_chunk(world_id: int) -> ChunkDataDecoder.ChunkPayload:
+	var layer := ChunkDataDecoder.TileLayerData.new()
+	layer.name = "ground"
+	layer.layer_id = 0
+	layer.width = 32
+	layer.height = 32
+	layer.depth = 1
+	var empty_def := TileDef.new(0, "", false, 0, 1)
+	var solid_def := TileDef.new(1, "tiles/stone", true, 0, 1)
+	layer.palette = [empty_def, solid_def]
+	var tiles := PackedInt32Array()
+	tiles.resize(32 * 32 * 1)
+	tiles[0] = 1  # (x=0, y=0, z=0) solid
+	layer.tiles = tiles
+
+	var obj := ChunkDataDecoder.WorldObjectData.new()
+	obj.id = "obj_1"
+	obj.type = "prop"
+	obj.asset_id = "props/rock"
+	obj.position = Vector3(1.0, 1.0, 0.0)
+	obj.properties = {"tag": "smoke"}
+
+	var payload := ChunkDataDecoder.ChunkPayload.new()
+	payload.world_id = str(world_id)
+	payload.room_id = "main"
+	payload.coord = Vector3i(0, 0, 0)
+	payload.bounds = AABB(Vector3.ZERO, Vector3(32, 32, 1))
+	payload.tile_layers = [layer]
+	payload.objects = [obj]
+	payload.revision = 1
+	payload.author = "smoke_test"
+	payload.created_at = 1700000000
+	payload.updated_at = 1700000000
+	return payload
+
+
+func _put_binary(api: Object, world_id: int, bytes: PackedByteArray) -> Dictionary:
+	var http := HTTPRequest.new()
+	root.add_child(http)
+	var bearer: String = api.bearer_token
+	var headers := PackedStringArray([
+		"Content-Type: application/octet-stream",
+		"X-Base-Revision: 0",
+		"Authorization: " + bearer,
+	])
+	var base: String = api.base_url
+	var url := base + "/api/worlds/%d/rooms/main/chunks/0/0/0" % world_id
+	var err := http.request_raw(url, headers, HTTPClient.METHOD_PUT, bytes)
+	if err != OK:
+		http.queue_free()
+		return {"ok": false, "detail": "request_raw failed (%d)" % err}
+	var args: Array = await http.request_completed
+	var response_code: int = args[1]
+	var body: PackedByteArray = args[3]
+	http.queue_free()
+	return {"ok": response_code >= 200 and response_code < 300, "status": response_code, "detail": body.get_string_from_utf8()}
+
+
+func _wait_for_chunk(manager: ChunkStreamManager, coord: Vector3i, max_frames: int = 120) -> Node:
+	for i in max_frames:
+		await process_frame
+		if manager.is_chunk_loaded(coord):
+			return manager.get_loaded_chunk(coord)
+	return null
+
+
+func _check(description: String, condition: bool) -> bool:
+	if condition:
+		print("  PASS: ", description)
+		passed += 1
+	else:
+		printerr("  FAIL: ", description)
+		failed += 1
+	return condition
+
+
+func _finish() -> void:
+	print("\n=== SMOKE RESULT: %d/%d passed ===" % [passed, passed + failed])
+	quit(0 if failed == 0 else 1)

scripts/smoke_test_script_behavior.gd

@@ -0,0 +1,462 @@
+extends SceneTree
+## Smoke test for the ScriptBehavior DSL + ScriptInterpreterNode.
+##
+## Run with:
+##     godot --headless --path . --script res://scripts/smoke_test_script_behavior.gd
+##
+## Covers, in order:
+##   1. Parsing/validation: a well-formed behavior parses cleanly; malformed
+##      or unsafe rules (unknown verb, unknown trigger, non-scalar
+##      arguments meant to smuggle something unsafe, unknown condition
+##      type/op) are rejected at parse time and never make it into
+##      `rules` -- never partially applied.
+##   2. A behavior mixing one bad rule with one good rule in the same file:
+##      the good rule still parses and still executes; the bad rule is
+##      dropped, not silently run.
+##   3. The real demo wired into scenes/worlds/test_level.tscn
+##      ("ScriptedChest"): loading scenes/game.tscn actually gets a
+##      ScriptInterpreterNode with the demo behavior loaded, a Player with
+##      a real Inventory, and pressing the real "interact" action while in
+##      range actually runs give_item / play_sound / rotate -- proven by
+##      observing the Inventory's item count change and the interpreter's
+##      verb_executed signal, not by calling private methods directly.
+
+const ScriptBehaviorClass := preload("res://scripts/scripting/script_behavior.gd")
+const ScriptInterpreterNodeClass := preload("res://scripts/scripting/script_interpreter.gd")
+const PlayerInventoryClass := preload("res://scripts/scripting/player_inventory.gd")
+const DynamicObjectNodeClass := preload("res://scripts/dynamic_object_node.gd")
+
+var passed := 0
+var failed := 0
+
+
+func _initialize() -> void:
+	_run()
+
+
+func _run() -> void:
+	await process_frame
+
+	_test_valid_behavior_parses()
+	_test_malformed_rules_are_rejected()
+	_test_mixed_good_and_bad_rules()
+	await _test_on_timer_trigger()
+	_test_condition_gating()
+	await _test_remaining_verbs()
+	await _test_wired_demo_in_game_scene()
+
+	print("\n=== SMOKE RESULT: %d/%d passed ===" % [passed, passed + failed])
+	quit(0 if failed == 0 else 1)
+
+
+# ---------------------------------------------------------------------------
+# 1. A well-formed behavior parses cleanly.
+# ---------------------------------------------------------------------------
+
+func _test_valid_behavior_parses() -> void:
+	print("--- valid behavior parses cleanly ---")
+	var data := {
+		"rules": [
+			{
+				"trigger": {"type": "on_interact"},
+				"conditions": [],
+				"actions": [
+					{"verb": "give_item", "item_id": "gold_coin", "count": 3},
+					{"verb": "play_sound", "sound_id": "chime"},
+				],
+			}
+		]
+	}
+	var behavior: ScriptBehaviorClass = ScriptBehaviorClass.load_from_dict(data)
+	_check("valid behavior has exactly one rule", behavior.rules.size() == 1)
+	_check("valid behavior has no rejected rules", behavior.rejected_rules.is_empty())
+
+
+# ---------------------------------------------------------------------------
+# 2. Malformed / unsafe rules never make it into `rules`.
+# ---------------------------------------------------------------------------
+
+func _test_malformed_rules_are_rejected() -> void:
+	print("--- malformed/unsafe rules are safely rejected, not executed ---")
+
+	# Unknown verb -- e.g. an attempt to invoke something outside the
+	# whitelist entirely.
+	_expect_rejected("unknown verb", {
+		"rules": [{
+			"trigger": {"type": "on_interact"}, "conditions": [],
+			"actions": [{"verb": "os_execute", "command": "rm -rf /"}],
+		}]
+	})
+
+	# Unknown trigger type.
+	_expect_rejected("unknown trigger type", {
+		"rules": [{
+			"trigger": {"type": "on_explode"}, "conditions": [],
+			"actions": [{"verb": "give_item", "item_id": "x", "count": 1}],
+		}]
+	})
+
+	# on_timer with a missing/invalid interval.
+	_expect_rejected("on_timer missing interval", {
+		"rules": [{
+			"trigger": {"type": "on_timer"}, "conditions": [],
+			"actions": [{"verb": "give_item", "item_id": "x", "count": 1}],
+		}]
+	})
+
+	# Attempt to smuggle a non-scalar (a nested object, the shape an
+	# engine-reaching payload would need) as an item_id.
+	_expect_rejected("non-scalar item_id", {
+		"rules": [{
+			"trigger": {"type": "on_interact"}, "conditions": [],
+			"actions": [{"verb": "give_item", "item_id": {"call": "OS.execute"}, "count": 1}],
+		}]
+	})
+
+	# Negative/absurd count.
+	_expect_rejected("out-of-range count", {
+		"rules": [{
+			"trigger": {"type": "on_interact"}, "conditions": [],
+			"actions": [{"verb": "give_item", "item_id": "x", "count": -5}],
+		}]
+	})
+
+	# Invalid target (not "self"/"player").
+	_expect_rejected("invalid move target", {
+		"rules": [{
+			"trigger": {"type": "on_interact"}, "conditions": [],
+			"actions": [{"verb": "move", "target": "world_root", "offset": [0, 1, 0]}],
+		}]
+	})
+
+	# Unknown condition type/op.
+	_expect_rejected("unknown condition type", {
+		"rules": [{
+			"trigger": {"type": "on_interact"},
+			"conditions": [{"type": "player_health", "op": "==", "value": 100}],
+			"actions": [{"verb": "give_item", "item_id": "x", "count": 1}],
+		}]
+	})
+	_expect_rejected("unknown condition op", {
+		"rules": [{
+			"trigger": {"type": "on_interact"},
+			"conditions": [{"type": "item_count", "item_id": "x", "op": "~=", "value": 1}],
+			"actions": [{"verb": "give_item", "item_id": "x", "count": 1}],
+		}]
+	})
+
+	# Missing actions entirely.
+	_expect_rejected("empty actions array", {
+		"rules": [{"trigger": {"type": "on_interact"}, "conditions": [], "actions": []}]
+	})
+
+	# No "rules" key at all.
+	_expect_rejected("missing top-level rules key", {"not_rules": []})
+
+
+func _expect_rejected(label: String, data: Dictionary) -> void:
+	var behavior: ScriptBehaviorClass = ScriptBehaviorClass.load_from_dict(data)
+	_check("%s -> zero rules parsed" % label, behavior.rules.is_empty())
+	_check("%s -> rejection reason recorded" % label, not behavior.rejected_rules.is_empty())
+
+
+# ---------------------------------------------------------------------------
+# 2b. A bad rule alongside a good rule in the SAME behavior: the good one
+# still parses and still runs; the bad one is dropped, not run "best
+# effort" and not blocking the good rule either.
+# ---------------------------------------------------------------------------
+
+func _test_mixed_good_and_bad_rules() -> void:
+	print("--- one bad rule does not block or corrupt a sibling good rule ---")
+	var data := {
+		"rules": [
+			{
+				# Bad: unknown verb, should be dropped silently.
+				"trigger": {"type": "on_interact"}, "conditions": [],
+				"actions": [{"verb": "eval", "code": "OS.execute('id', [])"}],
+			},
+			{
+				# Good: should parse and, when fired, actually run.
+				"trigger": {"type": "on_interact"}, "conditions": [],
+				"actions": [{"verb": "give_item", "item_id": "mixed_test_item", "count": 2}],
+			},
+		]
+	}
+	var behavior: ScriptBehaviorClass = ScriptBehaviorClass.load_from_dict(data)
+	_check("mixed behavior kept only the good rule", behavior.rules.size() == 1)
+	_check("mixed behavior recorded the bad rule's rejection", not behavior.rejected_rules.is_empty())
+
+	var interpreter := ScriptInterpreterNodeClass.new()
+	interpreter.set_behavior(behavior)
+	root.add_child(interpreter)
+
+	var fake_player := Node3D.new()
+	fake_player.name = "FakePlayer"
+	var inv := PlayerInventoryClass.new()
+	inv.name = "Inventory"
+	fake_player.add_child(inv)
+	root.add_child(fake_player)
+
+	interpreter.fire("on_interact", fake_player)
+	_check("the surviving good rule actually executed", inv.get_count("mixed_test_item") == 2)
+
+	interpreter.queue_free()
+	fake_player.queue_free()
+
+
+# ---------------------------------------------------------------------------
+# 3b. on_timer actually fires on its own, with no player/interact/touch
+# involved at all -- driven purely by a real Timer node ticking down.
+# ---------------------------------------------------------------------------
+
+func _test_on_timer_trigger() -> void:
+	print("--- on_timer fires repeatedly on its own ---")
+	var data := {
+		"rules": [{
+			"trigger": {"type": "on_timer", "interval": 0.05},
+			"conditions": [],
+			"actions": [{"verb": "set_timer", "name": "ticked", "seconds": 60}],
+		}]
+	}
+	var behavior: ScriptBehaviorClass = ScriptBehaviorClass.load_from_dict(data)
+	_check("on_timer behavior parsed", behavior.rules.size() == 1)
+
+	var interpreter := ScriptInterpreterNodeClass.new()
+	interpreter.set_behavior(behavior)
+	root.add_child(interpreter)
+
+	# A plain int captured by a lambda is captured by value in GDScript
+	# closures (the outer variable never sees the mutation) -- an Array's
+	# *reference* is what gets captured, so appends are visible outside.
+	var fire_log: Array = []
+	interpreter.verb_executed.connect(func(_verb, _args): fire_log.append(true))
+
+	for i in 30:
+		await physics_frame
+
+	_check("on_timer fired at least once with no trigger source but time",
+		   fire_log.size() >= 1)
+
+	interpreter.queue_free()
+
+
+# ---------------------------------------------------------------------------
+# 4. Conditions actually gate execution (not just parse).
+# ---------------------------------------------------------------------------
+
+func _test_condition_gating() -> void:
+	print("--- conditions gate whether an action runs ---")
+	var data := {
+		"rules": [{
+			"trigger": {"type": "on_interact"},
+			"conditions": [{"type": "item_count", "item_id": "key", "op": ">=", "value": 1}],
+			"actions": [{"verb": "give_item", "item_id": "treasure", "count": 1}],
+		}]
+	}
+	var behavior: ScriptBehaviorClass = ScriptBehaviorClass.load_from_dict(data)
+	_check("conditioned behavior parsed", behavior.rules.size() == 1)
+
+	var interpreter := ScriptInterpreterNodeClass.new()
+	interpreter.set_behavior(behavior)
+	root.add_child(interpreter)
+
+	var fake_player := Node3D.new()
+	var inv := PlayerInventoryClass.new()
+	inv.name = "Inventory"
+	fake_player.add_child(inv)
+	root.add_child(fake_player)
+
+	interpreter.fire("on_interact", fake_player)
+	_check("condition not met -> action did not run", inv.get_count("treasure") == 0)
+
+	inv.give_item("key", 1)
+	interpreter.fire("on_interact", fake_player)
+	_check("condition met -> action ran", inv.get_count("treasure") == 1)
+
+	interpreter.queue_free()
+	fake_player.queue_free()
+
+
+# ---------------------------------------------------------------------------
+# 2c. The remaining three verbs (move, spawn_from_catalog, set_timer) plus
+# the timer_active condition -- not exercised by the wired chest demo
+# (which only needs give_item/play_sound/rotate), so each gets a direct
+# check here that it actually does something real.
+# ---------------------------------------------------------------------------
+
+func _test_remaining_verbs() -> void:
+	print("--- move / spawn_from_catalog / set_timer + timer_active condition ---")
+	var data := {
+		"rules": [
+			{
+				# Only grants the item while the "cooldown" timer is NOT
+				# active -- proves timer_active is actually read back.
+				"trigger": {"type": "on_interact"},
+				"conditions": [{"type": "timer_active", "name": "cooldown", "op": "==", "value": false}],
+				"actions": [{"verb": "give_item", "item_id": "cooldown_test_item", "count": 1}],
+			},
+			{
+				"trigger": {"type": "on_interact"},
+				"conditions": [],
+				"actions": [
+					{"verb": "set_timer", "name": "cooldown", "seconds": 10},
+					{"verb": "move", "target": "self", "offset": [0, 0, -2], "duration": 0.2},
+					{"verb": "spawn_from_catalog", "catalog_id": "small_crate", "position": [5, 0, 5]},
+				],
+			},
+		]
+	}
+	var behavior: ScriptBehaviorClass = ScriptBehaviorClass.load_from_dict(data)
+	_check("remaining-verbs behavior parsed with no rejections", behavior.rejected_rules.is_empty())
+
+	var interpreter := ScriptInterpreterNodeClass.new()
+	interpreter.set_behavior(behavior)
+	root.add_child(interpreter)
+	var start_position: Vector3 = interpreter.position
+
+	var fake_player := Node3D.new()
+	var inv := PlayerInventoryClass.new()
+	inv.name = "Inventory"
+	fake_player.add_child(inv)
+	root.add_child(fake_player)
+
+	# First trigger: cooldown isn't active yet -> item granted, then the
+	# second rule starts the cooldown timer and moves/spawns.
+	interpreter.fire("on_interact", fake_player)
+	_check("give_item ran while timer_active was false",
+		   inv.get_count("cooldown_test_item") == 1)
+
+	# Second trigger, same frame: set_timer's effect must already be
+	# visible to a condition evaluated afterward -- this is the whole
+	# point of the timer_active/timer_remaining state store existing.
+	interpreter.fire("on_interact", fake_player)
+	_check("give_item did NOT run again once the cooldown timer was active",
+		   inv.get_count("cooldown_test_item") == 1)
+
+	# move() animates over a real Tween, not a teleport -- wait it out.
+	for i in 20:
+		await physics_frame
+	var moved: Vector3 = interpreter.position
+	_check("move actually relocated the object (not instantly, via a Tween)",
+		   moved.distance_to(start_position + Vector3(0, 0, -2)) < 0.05)
+
+	# spawn_from_catalog should have added a real DynamicObjectNode sibling.
+	var spawned: Node = null
+	for child in root.get_children():
+		if child is DynamicObjectNodeClass and (child as Node).name.begins_with("spawned_"):
+			spawned = child
+	_check("spawn_from_catalog actually added a DynamicObjectNode to the tree", spawned != null)
+	if spawned != null:
+		var dyn := spawned as DynamicObjectNodeClass
+		_check("spawned object resolved asset_id via the trusted catalog (not the raw data)",
+			   dyn.world_object != null and dyn.world_object.asset_id == "props/crate_small.glb")
+		_check("spawned object placed at the requested position",
+			   dyn.position.distance_to(Vector3(5, 0, 5)) < 0.01)
+		spawned.queue_free()
+
+	interpreter.queue_free()
+	fake_player.queue_free()
+
+
+# ---------------------------------------------------------------------------
+# 3. The real demo wired into the actual playable scene.
+# ---------------------------------------------------------------------------
+
+func _test_wired_demo_in_game_scene() -> void:
+	print("--- real demo: ScriptedChest in scenes/worlds/test_level.tscn via scenes/game.tscn ---")
+
+	var packed: PackedScene = load("res://scenes/game.tscn")
+	var result := change_scene_to_packed(packed)
+	if not _check("game scene loaded", result == OK):
+		return
+	await scene_changed
+
+	var game: Node3D = current_scene as Node3D
+	var player: Node = game.get_node_or_null("Player")
+	if not _check("Player exists in loaded scene", player is CharacterBody3D):
+		return
+
+	var inventory: Node = player.get_node_or_null("Inventory")
+	if not _check("Player has a real Inventory node", inventory is PlayerInventoryClass):
+		return
+
+	var chest: Node = game.get_node_or_null("Level/ScriptedChest")
+	if not _check("ScriptedChest exists in the level", chest != null):
+		return
+	if not _check("ScriptedChest has the ScriptInterpreterNode script", chest is ScriptInterpreterNodeClass):
+		return
+
+	var interpreter: ScriptInterpreterNodeClass = chest as ScriptInterpreterNodeClass
+	# Let _ready() load the behavior and build its Area3D/timers.
+	await process_frame
+	_check("ScriptedChest's behavior loaded from disk", interpreter.behavior != null)
+	if interpreter.behavior != null:
+		_check("demo_chest.json parsed with no rejected rules",
+			   interpreter.behavior.rejected_rules.is_empty())
+
+	var executed_verbs: Array[String] = []
+	interpreter.verb_executed.connect(func(verb, _args): executed_verbs.append(verb))
+
+	# Let physics settle: the player falls onto the ground and the
+	# ScriptedChest's trigger Area3D needs a few physics frames to notice
+	# the overlap before the interact key check has anyone "in range".
+	for i in 60:
+		await physics_frame
+
+	var before_count: int = (inventory as PlayerInventoryClass).get_count("gold_coin")
+	var before_rot_y: float = interpreter.rotation_degrees.y
+
+	# A real input event, exactly like a player pressing E -- not a direct
+	# call into the interpreter's action methods.
+	var interact_event := InputEventKey.new()
+	interact_event.keycode = KEY_E
+	interact_event.physical_keycode = KEY_E
+	interact_event.pressed = true
+	Input.parse_input_event(interact_event)
+
+	for i in 10:
+		await process_frame
+
+	var after_count: int = (inventory as PlayerInventoryClass).get_count("gold_coin")
+	_check("pressing 'interact' near the chest granted gold_coin via give_item",
+		   after_count == before_count + 3)
+	_check("give_item actually executed (verb_executed signal)", executed_verbs.has("give_item"))
+	_check("play_sound actually executed (verb_executed signal)", executed_verbs.has("play_sound"))
+	_check("rotate actually executed (verb_executed signal)", executed_verbs.has("rotate"))
+
+	# rotate animates over 0.4s via a real Tween -- wait it out, then check
+	# the chest's rotation actually changed (not teleported instantly, but
+	# not stuck at the start either).
+	for i in 40:
+		await physics_frame
+	var after_rot_y: float = interpreter.rotation_degrees.y
+	_check("rotate actually moved the chest's rotation",
+		   absf(wrapf(after_rot_y - before_rot_y - 90.0, -180.0, 180.0)) < 1.0)
+
+	# Pressing interact again with the player out of a fresh area-entry
+	# state should still work (rule has no conditions/limits) -- give_item
+	# is cumulative, proving repeated real triggers keep working.
+	var interact_event2 := InputEventKey.new()
+	interact_event2.keycode = KEY_E
+	interact_event2.physical_keycode = KEY_E
+	interact_event2.pressed = true
+	Input.parse_input_event(interact_event2)
+	for i in 10:
+		await process_frame
+	var final_count: int = (inventory as PlayerInventoryClass).get_count("gold_coin")
+	_check("a second real interact press granted gold_coin again",
+		   final_count == after_count + 3)
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+func _check(description: String, condition: bool) -> bool:
+	if condition:
+		print("  PASS: ", description)
+		passed += 1
+	else:
+		printerr("  FAIL: ", description)
+		failed += 1
+	return condition