Light unlit scenes with daylight, colour assets from thumbnails, hint at the next tier

From the "green apple on the table" pre-push test:
- No glowing verb meant no sun and a near-black picture. Unlit scenes now
get soft seeded daylight, and the ledger asks "what light?" (default:
daylight), the same way the implied ground is surfaced. Lit scenes keep
their exact seeded configuration.
- SimReady assets rendered grey because textures are skipped. The colour now
comes from the mean of the 256 px thumbnail (backdrop left out), and the
thumbnail is a public dataset URL instead of a local Space path.
- base_color read trimesh's default dark grey (102) as a real colour, so
every uncoloured mesh rendered murky; it now falls back to light grey.
- "which <word>?" questions carry on_reject, e.g. 101 Objaverse tables
behind the one SimReady table.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

SPEC.md

@@ -52,6 +52,17 @@ comes back with a **mini HTML page** the model can read, edit and build on.
   nominal default (an `unresolved` decision the user can set).
 - Light comes from the verb, not from a special word: whatever "shone" becomes the
   light source and sits in the sky along the light direction.
+- When nothing shines, the picture still needs light: seeing needs light as sitting
+  needs a ground. The scene gets soft daylight from no object (`sun.daylight: true`,
+  seeded direction, shadows on) and `unresolved` asks "what light?" (default:
+  daylight; rephrase with "<noun> shone/glowed" to make an object the light).
+- SimReady geometry comes without textures, so the colour is the mean of the asset's
+  256 px thumbnail (backdrop and transparent pixels left out), stored as `item.color`.
+  `item.thumbnail` is a public dataset URL, so the chat can show and compare assets.
+  Uncoloured meshes render neutral light grey.
+- A "which <word>?" question carries `on_reject`: what rejecting the tier would offer
+  (e.g. `{"tier": "objaverse", "candidates": 101, "offered": 9}`), since those
+  alternatives are invisible until the tier is rejected.
 - The ground implied by "sat" (with no stated object) is a support plane created by
   the relation. It is not a typed word, so it needs no asset. To exist, a thing needs
   a reality to exist in: reading skips this, but visualising exposes it. So the

vli/assets.py

@@ -8,6 +8,7 @@ import gzip
 import json
 import os
 from functools import lru_cache
+from urllib.parse import quote
 
 import numpy as np
 import trimesh
@@ -112,8 +113,33 @@ def load_simready(cand):
     roots = sorted(glob.glob(os.path.join(folder, "simready_usd", "*.usd*")))
     if not roots:
         raise UnusableAsset("no root USD file")
-    thumbs = glob.glob(os.path.join(folder, "simready_usd", ".thumbs", "256x256", "*.usd.png"))
-    return _usd_mesh(roots[0]), {"license": lic, "metric": True, "thumbnail": thumbs[0] if thumbs else None}
+    thumbs = sorted(glob.glob(os.path.join(folder, "simready_usd", ".thumbs", "256x256", "*.usd.png")))
+    mesh, url, color = _usd_mesh(roots[0]), None, None
+    if thumbs:
+        rel = "/".join([cand["name"], "simready_usd", ".thumbs", "256x256", os.path.basename(thumbs[0])])
+        url = f"https://huggingface.co/datasets/{cand['repo']}/resolve/{cand['revision']}/{quote(rel)}"
+        color = thumbnail_color(thumbs[0])
+    if color is not None:  # geometry comes without textures; the thumbnail still knows the colour
+        mesh.visual = trimesh.visual.ColorVisuals(mesh, face_colors=np.tile(color, (len(mesh.faces), 1)))
+    return mesh, {"license": lic, "metric": True, "thumbnail": url,
+                  "color": None if color is None else "#%02x%02x%02x" % tuple(color[:3])}
+
+
+def thumbnail_color(path):
+    """Mean RGBA of the object in a thumbnail: transparent pixels, or pixels close to the
+    border colour (the backdrop), are left out. None when nothing is left."""
+    from PIL import Image
+
+    img = np.asarray(Image.open(path).convert("RGBA").resize((64, 64)), dtype=np.float64)
+    rgb, alpha = img[..., :3], img[..., 3]
+    if (alpha < 128).any():
+        mask = alpha >= 128
+    else:
+        border = np.concatenate([rgb[0], rgb[-1], rgb[:, 0], rgb[:, -1]])
+        mask = np.linalg.norm(rgb - np.median(border, axis=0), axis=-1) > 30
+    if mask.sum() < 20:
+        return None
+    return np.r_[rgb[mask].mean(axis=0), 255].astype(np.uint8)
 
 
 # ---------------- objaverse (GLB, no real-world scale) ----------------
@@ -133,7 +159,7 @@ def load_objaverse(cand):
     mesh = _flatten(trimesh.load(path, force="scene"))
     if len(mesh.faces) == 0:
         raise UnusableAsset("empty mesh")
-    return _normalize(mesh), {"license": lic, "metric": False, "thumbnail": None}
+    return _normalize(mesh), {"license": lic, "metric": False, "thumbnail": None, "color": None}
 
 
 # ---------------- construction tiers ----------------
@@ -151,7 +177,7 @@ def load_primitive(cand, word):
         mesh = trimesh.creation.box([4 * h, 0.01, 4 * h])
     else:
         mesh = trimesh.creation.box([h, h, h])
-    return _normalize(mesh), {"license": None, "metric": False, "thumbnail": None}
+    return _normalize(mesh), {"license": None, "metric": False, "thumbnail": None, "color": None}
 
 
 def load_generation(cand, word):
@@ -196,7 +222,8 @@ def settle(item):
                 raise UnusableAsset(f"no usable {dec['tier']} asset for '{item['word']}' ({e})")
             dec["chosen"] = dec["alternatives"].pop(0)
     item["license"] = info["license"]
-    item["thumbnail"] = info["thumbnail"]
+    item["thumbnail"] = info["thumbnail"]  # a public URL, so the chat can show and compare it
+    item["color"] = info["color"]
     height = item["height_m"]
     native = float(mesh.extents[1]) or 1.0
     if height["source"] == "user":

vli/grammar.py

@@ -95,6 +95,9 @@ def classify(word):
 
 # ---------------- ledger ----------------
 
+POOL = 9  # candidates taken from a tier: the chosen one plus alternatives
+
+
 def primitive_candidate(shape="box"):
     return {"source": "primitive", "shape": shape}
 
@@ -108,7 +111,7 @@ def _object_decision(word, shape=None):
     for tier in ASSET_TIERS:
         cands = found.get(tier, [])
         if cands:
-            return {"tier": tier, "chosen": cands[0], "alternatives": cands[1:9],
+            return {"tier": tier, "chosen": cands[0], "alternatives": cands[1:POOL],
                     "rejected_tiers": [], "skipped": []}
     raise ValueError(f"'{word}' has no asset")
 
@@ -122,7 +125,7 @@ def next_tier(decision, word):
             cands = found.get(tier, [])
             if not cands:
                 continue
-            return {"tier": tier, "chosen": cands[0], "alternatives": cands[1:9]}
+            return {"tier": tier, "chosen": cands[0], "alternatives": cands[1:POOL]}
         if tier == "primitive":
             return {"tier": tier, "chosen": primitive_candidate(), "alternatives": []}
         raise ValueError(f"'{word}' has no tier left after {decision['tier']}: generation is not "
@@ -225,6 +228,11 @@ def build_ledger(sentence, primitives=None):
     for q in unresolved:
         if q["about"] is None:
             q["question"] = "determiner without a noun"
+    if not any(i.get("emits_light") for i in items):
+        # Seeing needs light, as sitting needs a ground: unstated, so surfaced like the ground.
+        unresolved.append({"id": "q_light", "token": None, "about": "light", "question": "what light?",
+                           "default_chosen": "daylight", "implied": True,
+                           "alternatives": ["rephrase: '<noun> shone' or '<noun> glowed'"]})
     return {"version": 1, "sentence": sentence, "primitives": primitives,
             "tokens": tokens, "items": items, "unresolved": unresolved}
 

vli/pipeline.py

@@ -8,7 +8,8 @@ import os
 import tempfile
 
 from . import assets, html, scene
-from .grammar import build_ledger, candidate_label, next_tier, parse_primitives, primitive_candidate
+from .grammar import POOL, build_ledger, candidate_label, next_tier, parse_primitives, primitive_candidate
+from .lexicon import ASSET_TIERS, LEXICON
 
 
 def _workdir():
@@ -21,6 +22,20 @@ def _option_label(cand):
     return f"{label} [{cand['uid'][:6]}]" if cand.get("uid") else label
 
 
+def _on_reject(item):
+    """What rejecting this item's tier would offer: alternatives in the next asset tier
+    are invisible in the question until then."""
+    dec = item["decision"]
+    if dec["tier"] not in ASSET_TIERS:
+        return None
+    found = LEXICON.lookup(item["word"])
+    for tier in ASSET_TIERS[ASSET_TIERS.index(dec["tier"]) + 1:]:
+        n = len(found.get(tier, []))
+        if n:
+            return {"tier": tier, "candidates": n, "offered": min(n, POOL)}
+    return {"tier": "primitive"}
+
+
 def settle_all(ledger):
     """Load every object's mesh; unusable candidates are skipped and recorded."""
     meshes = {}
@@ -34,6 +49,7 @@ def settle_all(ledger):
         if about and about["kind"] == "object":
             q["default_chosen"] = _option_label(about["decision"]["chosen"])
             q["alternatives"] = [_option_label(c) for c in about["decision"]["alternatives"]]
+            q["on_reject"] = _on_reject(about)
     return meshes
 
 

vli/scene.py

@@ -45,11 +45,13 @@ def configure(ledger, meshes, seed=0):
     for p in place.values():
         p["position"][0] -= x / 2
 
-    sun = None
     if lights:
         sun = {"id": lights[0]["id"], "elevation_deg": float(rng.uniform(25, 65)),
                "azimuth_deg": float(rng.uniform(-150, 150)),
                "shadows": any(r["relation"] == "lights" for r in relations)}
+    else:  # nothing shines: soft daylight from no object (the ledger asks "what light?")
+        sun = {"id": None, "elevation_deg": float(rng.uniform(35, 60)),
+               "azimuth_deg": float(rng.uniform(-150, 150)), "shadows": True, "daylight": True}
 
     def height(oid):
         return float(meshes[oid].extents[1])
@@ -88,7 +90,7 @@ def configure(ledger, meshes, seed=0):
             elif rel == "faces":
                 place[a]["yaw_deg"] = math.degrees(math.atan2(pb[0] - pa[0], pb[2] - pa[2]))
 
-    if sun:  # whatever shone sits in the sky along the light direction
+    if lights:  # whatever shone sits in the sky along the light direction
         reach = max([abs(c) + _half_width(meshes[o]) for o, p in place.items()
                      for c in (p["position"][0], p["position"][2])] + [0.3])
         for it in lights:

vli/simplify.py

@@ -12,7 +12,8 @@ FACE_LEVELS = [20000, 5000, 1000, 250, 60]
 def base_color(mesh):
     """Mean RGBA of a mesh's colours, or neutral grey."""
     vis = getattr(mesh, "visual", None)
-    if isinstance(vis, trimesh.visual.ColorVisuals):
+    # an uncoloured mesh still reports trimesh's default dark grey, so ask whether colours are defined
+    if isinstance(vis, trimesh.visual.ColorVisuals) and vis.defined:
         try:
             cols = vis.vertex_colors if vis.kind == "vertex" else vis.face_colors
             if cols is not None and len(cols):