Deploy indexing main 3afdae5 (run 20261020-a3cb7f2 kept)

check-image cache (#125), nginx upstream zone (#126), UI slim-ui-f57ff00c (curated titles, GB300 click-to-load). RESTORE_RUN_ID unchanged.

Dockerfile

@@ -183,6 +183,16 @@ RUN python3.12 -m venv /app/.venv \
     && rm -rf /tmp/usdsearch-wheels \
     && chown -R 1000:1000 /app/.venv
 
+# The vision checks' prepared asset views on disk (docker/hf-space/check_image_cache.py), on while the
+# CHECK_IMAGE_CACHE_DIR Space Variable is set (pipeline/config.py). The .pth loads it in every venv python. The
+# build fails unless it wraps the vendored llm_client and cached views come back byte-identical (--self-test).
+COPY docker/hf-space/check_image_cache.py docker/hf-space/check_image_cache.pth /tmp/check-image-hook/
+RUN SP=$(env -u PYTHONPATH /app/.venv/bin/python -c 'import sysconfig; print(sysconfig.get_path("purelib"))') \
+    && install -m 644 /tmp/check-image-hook/check_image_cache.py /tmp/check-image-hook/check_image_cache.pth "$SP/" \
+    && rm -rf /tmp/check-image-hook \
+    && env -u PYTHONPATH CHECK_IMAGE_CACHE_DIR=/tmp/check-image-selftest /app/.venv/bin/python -m check_image_cache --self-test \
+    && rm -rf /tmp/check-image-selftest
+
 # hf-storage-api — see docker/Dockerfile.hf-space's own copy of this block
 # for the full explanation (identical here; this variant serves the same
 # corpus/storage backend, just with a different SigLIP2 backend).

docker/hf-space/check_image_cache.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:edc0d12a880df88947ee550690e3733aa0478b2e161ee4a566c6e62e78680051
+size 99

docker/hf-space/check_image_cache.py

@@ -0,0 +1,487 @@
+"""The vision checks' prepared asset views, kept on disk for every deepsearch-api process of the Space.
+
+Before each check, usdsearch's llm_client prepares the asset's stored view: it decodes the stored thumbnail, fits it
+to USDSEARCH_VISION_VALIDATION_IMAGE_MAX_PX and re-encodes it as base64 PNG (``Validation._encode_reference_images``
+-> ``_encode_image``). That is most of a check's API CPU, and a stored view never changes. With
+``CHECK_IMAGE_CACHE_DIR`` set (a Space Variable, pipeline/config.py), each view ``_encode_reference_images`` prepares
+is kept in ``<dir>/<settings>/<sha256 of the stored base64>.b64``: a hit reads the file; a miss prepares the view as
+before and writes it (a temp file, then ``os.replace``), so the API processes share one copy. ``<settings>`` is a
+digest of everything else that can shape a view: the validation config, llm_client's validation module, Pillow and
+its codecs. Query images are never cached. Each file carries its length and CRC-32. Any error (unreadable,
+unwritable, full disk, a damaged file) falls back to preparing the view, so a check never fails here, and a damaged
+file is written again. The views stay under MAX_BYTES and never leave less than MIN_FREE on the disk, which the
+Space's index, media and caches share: past either, new views are prepared per check, as without the cache.
+
+Unset or empty, nothing is imported or installed and checks run exactly as usdsearch's own code.
+check_image_cache.pth, in the venv's site-packages, imports this module in every /app/.venv python (PYTHONPATH is
+unset for them) while the variable is set. The import only arms a hook that wraps llm_client's Validation when, and
+if, the process imports it. A Validation without the wrapped methods (a future wheel) logs one warning and runs
+unchanged.
+
+``python -m check_image_cache`` fills the cache once the index is in (supervisord-gpu.conf's
+[program:check-image-cache]): every image of the image cache index, loaded as a check loads it and prepared through
+the same wrapped path, so its files are the ones a check would write. It first removes what an earlier start left
+(other settings' directories, stale temp files). ``--self-test`` is the image build's check (Dockerfile.hf-space-gpu).
+"""
+
+import functools
+import hashlib
+import json
+import logging
+import os
+import re
+import shutil
+import sys
+import threading
+import time
+import weakref
+import zlib
+
+ENV = "CHECK_IMAGE_CACHE_DIR"
+TARGET = "llm_client.validation.validation"
+MAX_BYTES = 2_000_000_000  # ~15k views at ~130 KB (448-px PNG); the Space's ~2,600 stored images take ~340 MB
+MIN_FREE = 12_000_000_000  # above the 8 GB the media loader keeps free
+RECHECK_BYTES, RECHECK_S = 64_000_000, 60  # each process re-reads the size and the free space this often
+_DIGEST = re.compile(r"^[0-9a-f]{24}$")
+_TMP = re.compile(r"^[0-9a-f]{64}\.b64\.\d+\.\d+\.tmp$")
+_MARK = "__check_image_cache__"
+logger = logging.getLogger("check_image_cache")
+_warned = set()
+
+
+def _warn_once(kind, message, *args):
+    if kind not in _warned:
+        _warned.add(kind)
+        logger.warning(message, *args)
+
+
+def settings_digest(validation, module_file):
+    """What, besides the stored image, shapes a prepared view: one directory per combination."""
+    try:
+        from PIL import __version__ as pillow, features
+    except ImportError:  # no Pillow, no views to prepare (the tests' stand-in Validation)
+        pillow = features = None
+    config = validation._config
+    dump = config.model_dump() if hasattr(config, "model_dump") else dict(vars(config))
+    codecs = {}
+    for name in ("jpg", "zlib", "webp"):
+        try:
+            codecs[name] = features.version(name)
+        except Exception:
+            codecs[name] = None
+    with open(module_file, "rb") as fh:
+        module = hashlib.sha256(fh.read()).hexdigest()
+    identity = {
+        "config": dump,  # all of it: a setting llm_client reads later can never share a stale directory
+        "class": f"{type(validation).__module__}.{type(validation).__qualname__}",
+        "module": module,
+        "pillow": pillow,
+        "codecs": codecs,
+        "python": "%d.%d" % sys.version_info[:2],
+    }
+    return hashlib.sha256(json.dumps(identity, sort_keys=True, default=str).encode()).hexdigest()[:24]
+
+
+class Cache:
+    """One Validation's files, ``<root>/<settings digest>/<key>.b64``. Never raises: a failure is a miss."""
+
+    def __init__(self, directory):
+        self.directory = directory
+        self._lock = threading.Lock()
+        self.counts = {"hit": 0, "written": 0, "not_kept": 0, "bypass": 0}
+        self._used = self._free = None  # bytes of views and free on the disk, as last read plus this process's writes
+        self._since, self._read_at = 0, 0.0
+
+    def _count(self, outcome):
+        with self._lock:
+            self.counts[outcome] += 1
+
+    def _room(self, size):
+        """True while the views stay under MAX_BYTES and the disk keeps MIN_FREE: both re-read from the disk every
+        RECHECK_BYTES this process writes or RECHECK_S, so all processes together overshoot by little."""
+        with self._lock:
+            now = time.monotonic()
+            if self._used is None or self._since >= RECHECK_BYTES or now - self._read_at >= RECHECK_S:
+                self._used, self._free = files(self.directory)[1], _free(self.directory)
+                self._since, self._read_at = 0, now
+            if self._used + size > MAX_BYTES or self._free - size < MIN_FREE:
+                return False
+            self._used += size
+            self._free -= size
+            self._since += size
+            return True
+
+    def view(self, validation, image):
+        """``validation._encode_image(image)``, read from its file when there is one."""
+        path = self._path(validation, image)
+        if path is None:
+            self._count("bypass")
+            return validation._encode_image(image)
+        value = self._read(path)
+        if value is not None:
+            self._count("hit")
+            return value
+        value = validation._encode_image(image)  # its errors are the check's, as without the cache
+        self._count("written" if self._write(path, value) else "not_kept")
+        return value
+
+    def _path(self, validation, image):
+        # Only stored base64 images: a str that is not one is a file path, whose content can change under its name.
+        try:
+            if isinstance(image, str) and validation._is_base64(image):
+                return os.path.join(self.directory, hashlib.sha256(image.encode()).hexdigest() + ".b64")
+        except Exception as e:
+            _warn_once("key", "check image cache: no key for an image (%s); preparing it per check", e)
+        return None
+
+    def _read(self, path):
+        try:
+            with open(path, "rb") as fh:
+                data = fh.read()
+        except FileNotFoundError:
+            return None
+        except Exception as e:
+            _warn_once("read", "check image cache: cannot read %s (%s); preparing views per check", path, e)
+            return None
+        head, _, body = data.partition(b"\n")
+        try:
+            size, crc = head.split(b" ")
+            if int(size) == len(body) and int(crc, 16) == zlib.crc32(body):
+                return body.decode("ascii")
+        except (ValueError, UnicodeDecodeError):
+            pass
+        _warn_once("damaged", "check image cache: %s is damaged; preparing the view again", path)
+        return None
+
+    def _write(self, path, value):
+        tmp = f"{path}.{os.getpid()}.{threading.get_ident()}.tmp"
+        try:
+            body = value.encode("ascii")
+            if not self._room(len(body) + 32):
+                _warn_once("full", "check image cache: full (%d MB of views, or under %d GB free on the disk); "
+                           "new views are prepared per check", MAX_BYTES // 1_000_000, MIN_FREE // 1_000_000_000)
+                return False
+            try:
+                fh = open(tmp, "wb")
+            except FileNotFoundError:
+                os.makedirs(self.directory, exist_ok=True)
+                fh = open(tmp, "wb")
+            with fh:
+                fh.write(b"%d %08x\n" % (len(body), zlib.crc32(body)))
+                fh.write(body)
+            os.replace(tmp, path)
+            return True
+        except Exception as e:
+            _warn_once("write", "check image cache: cannot write in %s (%s); views are prepared per check",
+                        self.directory, e)
+            try:
+                os.unlink(tmp)
+            except OSError:
+                pass
+            return False
+
+
+_caches = weakref.WeakKeyDictionary()
+_caches_lock = threading.Lock()
+
+
+def is_wrapped(cls):
+    return getattr(getattr(cls, "_encode_reference_images", None), _MARK, None) is not None
+
+
+def cache_of(validation):
+    """The Cache of a Validation whose class is wrapped, else None (also when its settings can't be read)."""
+    mark = getattr(getattr(type(validation), "_encode_reference_images", None), _MARK, None)
+    if mark is None:
+        return None
+    try:
+        return _caches[validation]
+    except KeyError:
+        pass
+    except TypeError:  # not weak-referenceable: no cache
+        return None
+    root, module_file = mark
+    try:
+        cache = Cache(os.path.join(root, settings_digest(validation, module_file)))
+    except Exception as e:
+        _warn_once("settings", "check image cache off: cannot read the view settings (%s)", e)
+        cache = None
+    with _caches_lock:
+        return _caches.setdefault(validation, cache)
+
+
+def patch(module, root):
+    """Wrap ``module.Validation._encode_reference_images`` (llm_client's validation module); True when wrapped."""
+    cls = getattr(module, "Validation", None)
+    original = getattr(cls, "_encode_reference_images", None)
+    if original is None or not all(callable(getattr(cls, n, None)) for n in ("_encode_image", "_is_base64")):
+        _warn_once("missing", "check image cache off: %s.Validation has no _encode_reference_images, "
+                   "_encode_image or _is_base64", getattr(module, "__name__", module))
+        return False
+    if getattr(original, _MARK, None) is not None:
+        return True
+
+    @functools.wraps(original)
+    def _encode_reference_images(self, reference_images):
+        cache = cache_of(self) if reference_images else None
+        if cache is None:
+            return original(self, reference_images)
+        return [cache.view(self, image) for image in reference_images]
+
+    setattr(_encode_reference_images, _MARK, (root, getattr(module, "__file__", None)))
+    cls._encode_reference_images = _encode_reference_images
+    return True
+
+
+class _PatchOnImport:
+    """A sys.meta_path finder: wraps llm_client's Validation right after its module has run, in the process that
+    imports it. Every other import passes through untouched."""
+
+    def __init__(self, root):
+        self.root = root
+
+    def find_spec(self, name, path, target=None):
+        if name != TARGET:
+            return None
+        try:
+            from importlib.machinery import PathFinder, SourceFileLoader, SourcelessFileLoader
+
+            spec = PathFinder.find_spec(name, path)
+            if spec is None:
+                return None
+            # A file loader serves this one module, so its exec_module can be wrapped in place.
+            if type(spec.loader) not in (SourceFileLoader, SourcelessFileLoader):
+                _warn_once("hook", "check image cache off: %s is not loaded from a file", name)
+                return None
+            exec_module = spec.loader.exec_module
+            root = self.root
+
+            def exec_and_patch(module):
+                exec_module(module)
+                try:
+                    patch(module, root)
+                except Exception as e:
+                    _warn_once("patch", "check image cache off: %s", e)
+
+            spec.loader.exec_module = exec_and_patch
+            return spec
+        except Exception as e:
+            _warn_once("hook", "check image cache off: %s", e)
+            return None
+
+
+def install(environ=os.environ):
+    """Arm the hook when CHECK_IMAGE_CACHE_DIR is set; with it unset or empty, nothing changes."""
+    root = (environ.get(ENV) or "").strip()
+    if not root:
+        return False
+    module = sys.modules.get(TARGET)
+    if module is not None:
+        return patch(module, root)
+    if not any(isinstance(f, _PatchOnImport) for f in sys.meta_path):
+        sys.meta_path.insert(0, _PatchOnImport(root))
+    return True
+
+
+async def fill(validation, loader, threads=4, page=500, batch=25):
+    """Prepare every image of the loader's index through ``validation._encode_reference_images``.
+
+    The ids come from a scroll of the index, the images from ``loader.load_images`` (what a check loads), and up to
+    ``threads`` views are prepared at once in threads. Returns {"images", "empty", "failed"}.
+    """
+    import asyncio
+    from concurrent.futures import ThreadPoolExecutor
+
+    counts = {"images": 0, "empty": 0, "failed": 0}
+    loop = asyncio.get_running_loop()
+    slots = asyncio.Semaphore(threads * 2)
+    pending = set()
+
+    def done(task):  # on the loop's thread
+        slots.release()
+        pending.discard(task)
+        if task.cancelled() or task.exception() is not None:
+            counts["failed"] += 1
+
+    with ThreadPoolExecutor(threads, thread_name_prefix="check-image-cache") as pool:
+        client, index = loader.client, loader.image_cache_index
+        resp = await client.search(index=index, body={"query": {"match_all": {}}, "_source": False, "sort": ["_doc"]},
+                                   size=page, scroll="5m")
+        try:
+            while resp["hits"]["hits"]:
+                ids = [hit["_id"] for hit in resp["hits"]["hits"]]
+                for i in range(0, len(ids), batch):
+                    images = await loader.load_images(ids[i:i + batch])
+                    for image_id in ids[i:i + batch]:
+                        image = images.get(image_id)
+                        if not isinstance(image, str) or not image:
+                            counts["empty"] += 1
+                            continue
+                        counts["images"] += 1
+                        await slots.acquire()
+                        task = loop.run_in_executor(pool, validation._encode_reference_images, [image])
+                        pending.add(task)
+                        task.add_done_callback(done)
+                resp = await client.scroll(scroll_id=resp["_scroll_id"], scroll="5m")
+        finally:
+            if pending:
+                await asyncio.gather(*pending, return_exceptions=True)
+            try:
+                await client.clear_scroll(scroll_id=resp["_scroll_id"])
+            except Exception:
+                pass
+    return counts
+
+
+def files(directory):
+    """(count, bytes) of the views in a settings directory."""
+    n = size = 0
+    try:
+        with os.scandir(directory) as it:
+            for entry in it:
+                if entry.name.endswith(".b64"):
+                    try:
+                        size += entry.stat().st_size
+                        n += 1
+                    except OSError:  # replaced or removed meanwhile
+                        pass
+    except OSError:
+        pass
+    return n, size
+
+
+def _free(path):
+    """Free bytes on the disk that holds ``path`` (its nearest existing parent); 0 when unreadable: no writes."""
+    try:
+        while not os.path.exists(path) and os.path.dirname(path) != path:
+            path = os.path.dirname(path)
+        return shutil.disk_usage(path).free
+    except OSError:
+        return 0
+
+
+def sweep(directory, older_than=600):
+    """What an earlier start left in the cache's root: other settings' directories, and temp files of writers that
+    died (older than ``older_than`` s). Only names this module makes are touched. Returns the number removed."""
+    root, removed = os.path.dirname(directory), 0
+    try:
+        with os.scandir(root) as it:
+            for entry in it:
+                if _DIGEST.match(entry.name) and entry.path != directory and entry.is_dir(follow_symlinks=False):
+                    shutil.rmtree(entry.path, ignore_errors=True)
+                    removed += 1
+        with os.scandir(directory) as it:
+            for entry in it:
+                if _TMP.match(entry.name) and time.time() - entry.stat().st_mtime > older_than:
+                    os.unlink(entry.path)
+                    removed += 1
+    except OSError:
+        pass
+    return removed
+
+
+def self_test():
+    """The image build's check (Dockerfile.hf-space-gpu): the .pth loaded this module and it wrapped the vendored
+    llm_client, views read back from the cache are byte-identical to llm_client's own, and the warm-up's imports
+    exist. Raises on any difference. Writes only in CHECK_IMAGE_CACHE_DIR, which the build then removes."""
+    import base64
+    import io
+
+    from PIL import Image
+    from deepsearch_api.routers_v2.dependencies import build_image_loader  # noqa: F401 (the warm-up's imports)
+    from deepsearch_api.search_backend.main import SearchSettings  # noqa: F401
+    from deepsearch_api.validation.config import ValidationSettings
+    from llm_client.validation.validation import Validation
+
+    assert "check_image_cache" in sys.modules and is_wrapped(Validation), "the hook did not wrap llm_client"
+    global MIN_FREE
+    MIN_FREE = 0  # the image builder's disk is not the Space's
+
+    def b64(image, fmt, **kw):
+        buf = io.BytesIO()
+        image.save(buf, fmt, **kw)
+        return base64.b64encode(buf.getvalue()).decode()
+
+    noise = Image.effect_noise((1024, 1024), 40)
+    rgb = Image.merge("RGB", (noise, Image.linear_gradient("L").resize((1024, 1024)), noise.rotate(90)))
+    rgba = rgb.resize((900, 600))
+    rgba.putalpha(Image.linear_gradient("L").resize((900, 600)))
+    images = [b64(rgb, "JPEG", quality=90), b64(rgba, "PNG"), b64(rgb.resize((300, 200)), "JPEG", quality=90)]
+    config = ValidationSettings(image_max_px=448).to_validation_config()
+    plain = [Validation(config=config)._encode_image(image) for image in images]
+    miss = Validation(config=config)._encode_reference_images(images)
+    reader = Validation(config=config)
+    hit = reader._encode_reference_images(images)
+    assert miss == plain and hit == plain, "a cached view differs from llm_client's own"
+    assert cache_of(reader).counts["hit"] == len(images), "the views were not read back from the cache"
+    return len(images)
+
+
+def main(argv=None):
+    """``python -m check_image_cache [--threads N]``: fill the cache from the image cache index. Always exits 0
+    (``--self-test`` exits 1 when the check fails)."""
+    import argparse
+    import asyncio
+    import resource
+
+    parser = argparse.ArgumentParser(prog="check_image_cache")
+    parser.add_argument("--threads", type=int, default=4)
+    parser.add_argument("--self-test", action="store_true")
+    args = parser.parse_args(argv)
+    say = functools.partial(print, "check-image-cache:", flush=True)
+    if not (os.environ.get(ENV) or "").strip():
+        say(f"{ENV} is not set: nothing to do")
+        return 1 if args.self_test else 0
+    if args.self_test:
+        say(f"self-test passed: {self_test()} views read back byte-identical")
+        return 0
+    started, cpu = time.monotonic(), time.process_time()
+    try:
+        from deepsearch_api.validation.config import ValidationSettings
+
+        settings = ValidationSettings()
+        if not settings.enabled:
+            say("vision validation is off: nothing to do")
+            return 0
+        from llm_client.validation.validation import Validation
+
+        validation = Validation(config=settings.to_validation_config())
+        cache = cache_of(validation)
+        if cache is None:
+            say("llm_client's Validation is not wrapped (see the warning above): nothing to do")
+            return 0
+        swept = sweep(cache.directory)
+        from deepsearch_api.routers_v2.dependencies import build_image_loader
+        from deepsearch_api.search_backend.main import SearchSettings
+
+        loader = build_image_loader(SearchSettings())
+
+        async def run():
+            try:
+                return await fill(validation, loader, threads=max(1, args.threads))
+            finally:
+                await loader.client.close()
+
+        counts = asyncio.run(run())
+    except Exception as e:
+        say(f"stopped ({type(e).__name__}: {e}); checks prepare the rest as they go")
+        return 0
+    n, size = files(cache.directory)
+    c = cache.counts
+    say(f"{counts['images']} images in {time.monotonic() - started:.1f} s, {time.process_time() - cpu:.1f} CPU-s: "
+        f"{c['written']} written, {c['hit']} already there, {c['not_kept']} not kept, {c['bypass']} not cacheable, "
+        f"{counts['failed']} failed, {counts['empty']} missing or not loaded; {n} files, {size / 1e6:.0f} MB in "
+        f"{cache.directory} ({swept} old entries removed); "
+        f"peak RSS {resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024:.0f} MB")
+    return 0
+
+
+if __name__ == "__main__":
+    import check_image_cache  # the instance the .pth imported: its hook wrapped Validation
+
+    sys.exit(check_image_cache.main())
+else:
+    try:
+        install()
+    except Exception as e:  # never break a python start
+        _warn_once("install", "check image cache off: %s", e)

docker/hf-space/nginx.conf.template

@@ -107,9 +107,13 @@ map $http_accept_encoding $slim_accepts_br {
 # deepsearch-api's processes, one uvicorn worker each. least_conn, not `uvicorn --workers N`: with N workers on one
 # socket the kernel hands nearly every connection to 2-3 of them, and the rest of the CPU sits idle (lab load test
 # 2026-10-15, docs/search-performance.md). __DEEPSEARCH_API_SERVERS__ is rendered at container start from
-# DEEPSEARCH_API_PROCESSES (the nginx program in supervisord*.conf).
+# DEEPSEARCH_API_PROCESSES (the nginx program in supervisord*.conf). The zone shares least_conn's counts between
+# nginx's workers: without it each worker balances only its own connections, so two searches' 50-check batches
+# often land on one process and split its 16 check slots while others idle (lab 2026-10-20: p95 of all badges
+# 4.0 -> 3.2 s at 20 users, 6.5 -> 5.4 s at 44).
 upstream deepsearch {
     least_conn;
+    zone deepsearch 64k;
     __DEEPSEARCH_API_SERVERS__
 }
 server {

docker/hf-space/supervisord-gpu.conf

@@ -182,6 +182,24 @@ stdout_logfile_maxbytes=0
 stderr_logfile=/dev/stderr
 stderr_logfile_maxbytes=0
 
+[program:check-image-cache]
+; Fills CHECK_IMAGE_CACHE_DIR (a Space Variable) with every stored image's prepared check view:
+; docker/hf-space/check_image_cache.py. Starts once the Space serves (nginx's /health): started with the API
+; processes, it held their start back by ~5 s in the lab. They read and fill the same files on their own, so
+; nothing waits on this program. Niced, 4 threads; it always exits 0 and is never restarted. Without the
+; variable it does nothing.
+command=/usr/bin/env -u PYTHONPATH /bin/sh -c "until curl -sf http://localhost:%(ENV_PORT)s/health >/dev/null 2>&1; do sleep 5; done; cd /app && exec nice -n 10 /app/.venv/bin/python -m check_image_cache --threads 4"
+directory=/app
+user=1000
+autorestart=false
+startsecs=0
+startretries=0
+exitcodes=0
+stdout_logfile=/dev/stdout
+stdout_logfile_maxbytes=0
+stderr_logfile=/dev/stderr
+stderr_logfile_maxbytes=0
+
 [program:deepsearch-api]
 ; 6 processes with ONE uvicorn worker each, on 127.0.0.1:8101-8106, behind
 ; nginx's least_conn upstream (nginx.conf.template). Not `uvicorn --workers 6`:

pipeline/config.py

@@ -127,6 +127,9 @@ class Config:
         ]:
             if os.environ.get(key):
                 values[key] = os.environ[key]
+        # the vision-views stage is run one-off from the shell (VISION_VIEWS=all VISION_VIEWS_APPLY=... python -m
+        # pipeline.run_pipeline vision-views): its settings win even when the env file does not name them
+        values.update({k: v for k, v in os.environ.items() if k.startswith("VISION_VIEWS") and v})
         return cls(values=values, env_file=path)
 
     # ── typed accessors ───────────────────────────────────────────────────
@@ -416,6 +419,11 @@ class Config:
             # a text query's judge reads each hit's path (below its dataset or Isaac content root) and vision
             # caption, and an image + words query asks whether the candidate matches both (usdsearch !279).
             "USDSEARCH_VISION_VALIDATION_IMAGE_MAX_PX": "448",
+            # Each stored view is fitted and encoded for its check once per container, not once per check (most
+            # of a check's API CPU): docker/hf-space/check_image_cache.py, GPU image only (the CPU image has no
+            # hook: the variable does nothing there). Off: delete the Space Variable and restart; a deploy sets it
+            # again while this line is here (deploys never delete variables).
+            "CHECK_IMAGE_CACHE_DIR": "/tmp/check-image-cache",
             "USDSEARCH_VISION_VALIDATION_LOGPROB_ASSET_FACTS": json.dumps(["path", "vlm_metadata_caption"]),
             "USDSEARCH_VISION_VALIDATION_LOGPROB_ASSET_PATH_ROOTS": json.dumps(VALIDATION_ASSET_PATH_ROOTS),
             "USDSEARCH_VISION_VALIDATION_LOGPROB_IMAGE_TEXT_QUERY": "true",

pipeline/run_pipeline.py

@@ -7,7 +7,8 @@ Stages run in order and each is independently re-runnable:
     enumerate  corpus.json -> exact asset list (N) + manifest
     index      bring the stack up, restore the baseline, clear, submit the
                delta, wait, then the image-overrides, categories and
-               profiles steps (and vision-views when VISION_VIEWS is on)
+               profiles steps and, last, vision-views when VISION_VIEWS is on
+               (HF prod: the committed captions, VISION_VIEWS_APPLY)
     export     elasticdump the indexes; neo4j-admin dump the graph
     upload     publish the artifact set to S3
     bake       build images with the data pre-loaded
@@ -55,7 +56,7 @@ import os
 import subprocess
 import sys
 from pathlib import Path
-from typing import List
+from typing import List, Optional
 
 from .config import BUILD_DIR, Config
 
@@ -155,15 +156,25 @@ def _mark_done(step: str, args) -> None:
         (STAGE_MARKERS / f"{step}.done").touch()
 
 
-def enrichment_missing() -> List[str]:
-    """The ENRICHMENT_STEPS that haven't succeeded since the latest `wait` (its .build/index-report.json)."""
+def _done_at(step: str) -> Optional[float]:
+    marker = STAGE_MARKERS / f"{step}.done"
+    return marker.stat().st_mtime if marker.exists() else None
+
+
+def enrichment_missing(cfg: Optional[Config] = None) -> List[str]:
+    """The ENRICHMENT_STEPS that haven't succeeded since the latest `wait` (its .build/index-report.json), plus
+    `vision-views` when the config turns it on and it hasn't succeeded since the last of them: the captions go in
+    last (2026-10-20: a run shipped thumbnail captions when the manual captions step did not take effect)."""
     report = BUILD_DIR / "index-report.json"
     waited = report.stat().st_mtime if report.exists() else 0.0
-    return [
-        step for step in ENRICHMENT_STEPS
-        if not (STAGE_MARKERS / f"{step}.done").exists()
-        or (STAGE_MARKERS / f"{step}.done").stat().st_mtime < waited
-    ]
+    done = {step: _done_at(step) for step in (*ENRICHMENT_STEPS, "vision-views")}
+    missing = [step for step in ENRICHMENT_STEPS if done[step] is None or done[step] < waited]
+    from .vision_views import is_on
+    if is_on(cfg):
+        last = max([waited] + [done[step] for step in ENRICHMENT_STEPS if done[step] is not None])
+        if done["vision-views"] is None or done["vision-views"] < last:
+            missing.append("vision-views")
+    return missing
 
 
 def stage_image_overrides(cfg: Config, args) -> int:
@@ -191,13 +202,18 @@ def stage_profiles(cfg: Config, args) -> int:
 
 
 def stage_vision_views(cfg: Config, args) -> int:
-    from .vision_views import run
-    return run(cfg, dry_run=args.dry_run)
+    from .vision_views import is_on, run
+    code = run(cfg, dry_run=args.dry_run)
+    # Only a run that applied or generated captions counts: an off run (VISION_VIEWS=off for one command) must not
+    # let export ship the index without them.
+    if code == 0 and is_on(cfg):
+        _mark_done("vision-views", args)
+    return code
 
 
 def stage_index(cfg: Config, args) -> int:
-    """Bring the stack up, restore the baseline, clear, submit the delta, wait, write central:category and the
-    validation profiles the packages' sidecars name."""
+    """Bring the stack up, restore the baseline, clear, submit the delta, wait, write the image overrides,
+    central:category and the validation profiles the packages' sidecars name, then the captions."""
     steps = (
         ("up", stage_up),
         ("restore", stage_restore),
@@ -207,7 +223,9 @@ def stage_index(cfg: Config, args) -> int:
         ("image-overrides", stage_image_overrides),
         ("categories", stage_categories),
         ("profiles", stage_profiles),
-        ("vision-views", stage_vision_views),  # off unless VISION_VIEWS=new|all
+        # last step that writes the index, right before `export`: image-overrides re-captions its assets, so the
+        # captions go after it (HF prod: VISION_VIEWS_APPLY, the committed captions). Off unless VISION_VIEWS=new|all
+        ("vision-views", stage_vision_views),
     )
     for step, fn in steps:
         print(f"\n{'=' * 70}\n== index: {step}\n{'=' * 70}")
@@ -219,11 +237,12 @@ def stage_index(cfg: Config, args) -> int:
 
 
 def stage_export(cfg: Config, args) -> int:
-    missing = enrichment_missing()
+    missing = enrichment_missing(cfg)
     if missing:
         print(
             f"refusing to export: {', '.join(missing)} not run since the last `wait`. They write into the index "
-            f"(image overrides, central:category, partner profiles). Run them in order, then export:\n"
+            f"(image overrides, central:category, partner profiles, captions; captions last). Run them in order, "
+            f"then export:\n"
             + "".join(f"    python -m pipeline.run_pipeline {step} --env-file ...\n" for step in missing)
         )
         return 1

pipeline/vision_views.py

@@ -10,8 +10,9 @@ that plugin, inside the usdsearch image, with labelled views from the library me
     a dedicated all-open still);
   * no media at all — the shipped thumbnail, as before;
 
-plus a name hint (file name and two folders), which the prompt allows only to choose between readings the views
-already allow. Needs usdsearch with labelled views (the plugin's `view_labels` / `asset_hint`).
+plus a name hint (file name and two folders; none when the file name is only an id or a hash), which the prompt
+allows only to choose between readings the views already allow. This stage sends only that hint: the container's own
+VLM_ASSET_HINT is forced off. Needs usdsearch with labelled views (the plugin's `view_labels` / `asset_hint`).
 
 Then a mismatch report: each asset's new `object_type` against its file-name words and its Q-code's Wikidata label,
 `.build/vision-views-mismatch.{json,csv}`. Flagged assets are listed for review; nothing is relabelled.
@@ -25,16 +26,23 @@ VISION_VIEWS_MEDIA_DIR names a library media tree (manifest.json + <id>/<file>);
 fetched like the Space does (pipeline/library_media.py). VISION_VIEWS_HINT=off drops the hint; VISION_VIEWS_MAX caps
 the number of assets (a trial); VISION_VIEWS_CONCURRENCY (4), VISION_VIEWS_TIMEOUT_S (300), VISION_VIEWS_TRIES (3).
 
-VISION_VIEWS_CHECK_MODEL (+ VISION_VIEWS_CHECK_REASONING_EFFORT) has a second model caption the same inputs; on a
-disagreement VISION_VIEWS_ON_DISAGREE writes: flag (default: the primary's; never the other model's) | reference
-(the name matching the file-name or Q-code words when exactly one does, else the primary's) | hold (neither).
-Disagreements are flagged.
+VISION_VIEWS_APPLY=<captions.jsonl[.gz]> writes captions made ahead of the run instead (no model call, any usdsearch
+image): gzip read by suffix, checked against its `<name>.jsonl.sha256` sibling when there is one. HF prod's env file
+names the committed file (config/vision_captions/), so every run applies it as the last step of `index`, before
+export. Assets the file does not cover keep their caption and are listed in .build/vision-views-apply.json.
+
+VISION_VIEWS_CHECK_MODEL (+ VISION_VIEWS_CHECK_REASONING_EFFORT) has a second model caption the same inputs; off,
+none, false or 0 turns it off (the shell can override the env file's). On a disagreement VISION_VIEWS_ON_DISAGREE
+writes: flag (default: the primary's; never the other model's) | reference (the name matching the file-name or Q-code
+words when exactly one does, else the primary's) | hold (neither). Disagreements are flagged.
 """
 
 from __future__ import annotations
 
 import argparse
 import csv
+import gzip
+import hashlib
 import json
 import os
 import re
@@ -42,7 +50,7 @@ import subprocess
 import sys
 from collections import Counter
 from pathlib import Path
-from typing import Dict, Iterable, List, Optional
+from typing import Dict, Iterable, List, Optional, Tuple
 
 from . import hf_addressing
 from .vision_views_rules import agrees, compatible, path_words, words  # noqa: F401 (words: the tests)
@@ -52,6 +60,7 @@ SPEC = BUILD_DIR / "vision-views-spec.json"
 REPORT = BUILD_DIR / "vision-views.json"
 MISMATCH_JSON = BUILD_DIR / "vision-views-mismatch.json"
 MISMATCH_CSV = BUILD_DIR / "vision-views-mismatch.csv"
+APPLY_LISTING = "vision-views-apply.json"  # under BUILD_DIR: what an apply wrote and what it left as it was
 WORKER = Path(__file__).with_name("vision_views_worker.py")
 HELPERS = Path(__file__).with_name("image_overrides_worker.py")
 RULES = Path(__file__).with_name("vision_views_rules.py")
@@ -59,6 +68,7 @@ ON_DISAGREE = ("flag", "reference", "hold")
 COMPOSE_PROJECT = "simready-indexing"
 SERVICE = "omni-writer"
 MODES = ("off", "new", "all")
+OFF = ("off", "none", "false", "0", "no")
 SIDES = ("right", "back", "left")
 QCODE_PROPERTY = "simready_metadata_qcode"
 
@@ -123,9 +133,29 @@ def view_plan(entry: Optional[Dict]) -> List[Dict]:
     return views
 
 
+# Name parts that say nothing about the object: Isaac's static-mesh prefix, Vertiv's root layer, the packaging.
+PACKAGING = {"sm", "main", "simready", "usd"}
+UUID = re.compile(r"[0-9a-f]{8}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{4}-?[0-9a-f]{12}", re.I)
+
+
+def is_code(token: str, first: bool = False) -> bool:
+    """An id, not a word: anything with a digit (D00272, f01, a3f9c2e1b7), one Latin letter, two Latin letters
+    unless they lead the name (tv_stand keeps tv; crx10ia_lp's lp is a suffix), or 8+ hex letters."""
+    return (any(c.isdigit() for c in token) or re.fullmatch(r"[A-Za-z]", token) is not None
+            or (not first and re.fullmatch(r"[A-Za-z]{2}", token) is not None)
+            or re.fullmatch(r"[0-9a-fA-F]{8,}", token) is not None)
+
+
 def asset_hint(address: str) -> str:
-    """The file name and its two nearest folders — never the host, owner or revision."""
-    return "/".join(hf_addressing.parse(address).path.split("/")[-3:])
+    """The file name and its two nearest folders — never the host, owner or revision; "" when the file name is only
+    an id or a hash (Palatial's D00272.usd, a UUID), with no word for the model to read. No dictionary: a word in any
+    language or script counts."""
+    path = hf_addressing.parse(address).path
+    stem = UUID.sub(" ", path.rsplit("/", 1)[-1].rsplit(".", 1)[0])
+    tokens = [t for t in re.split(r"[\W_]+", stem) if t and t.lower() not in PACKAGING]
+    if all(is_code(t, first=i == 0) for i, t in enumerate(tokens)):
+        return ""
+    return "/".join(path.split("/")[-3:])
 
 
 def media_tree(cfg: Config) -> Optional[Path]:
@@ -181,38 +211,79 @@ def override_image_matches(rec: Dict, entry: Dict) -> bool:
     return not sha or (path.is_file() and hashlib.sha256(path.read_bytes()).hexdigest() == sha)
 
 
+def mode_of(cfg: Config) -> str:
+    return cfg.get("VISION_VIEWS", "off").strip().lower() or "off"
+
+
+def is_on(cfg: Optional[Config]) -> bool:
+    """Whether `index` runs this stage (VISION_VIEWS new or all): `export` then waits for it."""
+    return cfg is not None and mode_of(cfg) in ("new", "all")
+
+
+class CaptionsFileError(ValueError):
+    """VISION_VIEWS_APPLY's file does not match its .sha256 sibling."""
+
+
+def captions_file(value: str) -> Path:
+    """VISION_VIEWS_APPLY's path: as given, else from the repo root (the env file names it from there)."""
+    path = Path(value)
+    return REPO_ROOT / path if not path.is_absolute() and not path.exists() else path
+
+
+def sha256_sibling(path: Path) -> Path:
+    """captions.jsonl.gz and captions.jsonl both name captions.jsonl.sha256 (`sha256sum` of the uncompressed file)."""
+    name = path.name[:-3] if path.name.endswith(".gz") else path.name
+    return path.with_name(name + ".sha256")
+
+
+def read_captions(path: Path) -> Tuple[str, str]:
+    """(text, sha256) of a captions file: gzip by suffix, checked against its .sha256 sibling when there is one."""
+    data = path.read_bytes()
+    if path.name.endswith(".gz"):
+        data = gzip.decompress(data)
+    got = hashlib.sha256(data).hexdigest()
+    sibling = sha256_sibling(path)
+    if sibling.is_file():
+        want = (sibling.read_text().split() or [""])[0].lower()
+        if got != want:
+            raise CaptionsFileError(f"{path.name}: sha256 {got} does not match {sibling.name} ({want or 'empty'})")
+    return data.decode("utf-8"), got
+
+
 def apply_plan(cfg: Config, mode: str, path: Path) -> Dict:
     """Precomputed metadata to write as it is (no model call): {address: the writer's plugin fields}, for each
     selected asset the file has at the SAME pinned address (same bytes) with a writer record. Others keep what the
     thumbnail plugin wrote. An image-override asset is written only from a record made from its override picture;
-    else it keeps the image-overrides stage's caption."""
+    else it keeps the image-overrides stage's caption. Raises CaptionsFileError when the file fails its sha256."""
     from .image_overrides import load_spec
+    text, sha = read_captions(path)
     records = {}
-    for line in path.read_text().splitlines():
+    for line in text.splitlines():
         if line.strip():
             rec = json.loads(line)
             if (rec.get("writer") or {}).get("plugin_fields"):
                 records[rec["address"]] = rec
     overrides = load_spec()
-    assets, missing, wrong_image = {}, 0, 0
+    assets, missing, wrong_image = {}, [], []
     for address in select_addresses(cfg, mode, keep_curated=True):
         rec = records.get(address)
         if rec is None:
-            missing += 1
+            missing.append(address)
             continue
         if address in overrides and not override_image_matches(rec, overrides[address]):
-            wrong_image += 1
+            wrong_image.append(address)
             continue
         assets[address] = {"apply": rec["writer"]["plugin_fields"], "writer_model": rec["writer"].get("model"),
                            "check_object_type": ((rec.get("check") or {}).get("meta") or {}).get("object_type"),
                            "models_agree": rec.get("agree")}
-    return {"index": cfg.main_index, "mode": "apply", "source": str(path), "media": None, "assets": assets,
-            "not_precomputed": missing, "override_image_mismatch": wrong_image}
+    return {"index": cfg.main_index, "mode": "apply", "source": str(path), "sha256": sha, "media": None,
+            "assets": assets, "not_precomputed": len(missing), "override_image_mismatch": len(wrong_image),
+            "not_precomputed_assets": missing, "override_image_mismatch_assets": wrong_image}
 
 
 def plan(cfg: Config, mode: str) -> Dict:
     addresses = select_addresses(cfg, mode)
-    hint_on = cfg.get("VISION_VIEWS_HINT", "on").strip().lower() not in ("off", "false", "0", "no")
+    hint_on = cfg.get("VISION_VIEWS_HINT", "on").strip().lower() not in OFF
     # thumbnail: every asset from its shipped thumbnail + the hint (measured as good as the views on object_type,
     # at a quarter of the image tokens); views: the RTX views where the asset has them
     views_on = cfg.get("VISION_VIEWS_IMAGES", "views").strip().lower() != "thumbnail"
@@ -309,32 +380,52 @@ def qcode_labels(qcodes: Iterable[str]) -> Dict[str, Dict]:
 
 
 def run(cfg: Config, dry_run: bool = False) -> int:
-    mode = cfg.get("VISION_VIEWS", "off").strip().lower() or "off"
+    mode = mode_of(cfg)
     if mode not in MODES:
         print(f"VISION_VIEWS={mode!r}: expected one of {', '.join(MODES)}")
         return 1
     if mode == "off":
         print("vision views: off (VISION_VIEWS) — captions stay as the thumbnail plugin wrote them")
         return 0
-    apply_path = cfg.get("VISION_VIEWS_APPLY").strip()
-    if apply_path:
-        # write precomputed metadata (the lab's captions.jsonl): no model call, no API key, any usdsearch image
-        if not Path(apply_path).is_file():
-            print(f"VISION_VIEWS_APPLY={apply_path!r}: no such file")
+    apply_value = cfg.get("VISION_VIEWS_APPLY").strip()
+    if apply_value:
+        # write precomputed metadata (config/vision_captions/*.jsonl.gz): no model call, no API key, any usdsearch
+        # image (the worker's "usdsearch image too old" check guards generating captions only)
+        path = captions_file(apply_value)
+        if not path.is_file():
+            print(f"VISION_VIEWS_APPLY={apply_value!r}: no such file")
             return 1
-        spec = apply_plan(cfg, mode, Path(apply_path))
-        print(f"vision views ({mode}, apply {apply_path}): {len(spec['assets'])} asset(s) get precomputed metadata; "
-              f"{spec['not_precomputed']} not in the file keep the thumbnail plugin's; "
-              f"{spec['override_image_mismatch']} image-override asset(s) whose record is not from their override "
-              f"image keep the image-overrides stage's; no VLM call")
+        try:
+            spec = apply_plan(cfg, mode, path)
+        except CaptionsFileError as exc:
+            print(f"VISION_VIEWS_APPLY: {exc}; nothing written")
+            return 1
+        missing, wrong = spec.pop("not_precomputed_assets"), spec.pop("override_image_mismatch_assets")
+        listing = BUILD_DIR / APPLY_LISTING
+        shown = listing.relative_to(REPO_ROOT) if listing.is_relative_to(REPO_ROOT) else listing
+        if not dry_run:
+            record = {"source": apply_value, "sha256": spec["sha256"], "applied": len(spec["assets"]),
+                      "not_in_file": missing, "override_image_mismatch": wrong}
+            listing.write_text(json.dumps(record, indent=1) + "\n")
+        print(f"vision views ({mode}, apply {apply_value}, sha256 {spec['sha256'][:12]}): {len(spec['assets'])} "
+              f"asset(s) get precomputed metadata; {len(missing)} not in the file keep their caption; {len(wrong)} "
+              f"image-override asset(s) whose record is not from their override image keep the image-overrides "
+              f"stage's; no VLM call; listed in {shown}")
+        for address in missing[:5]:
+            print(f"  not in the file: {address}")
+        if len(missing) > 5:
+            print(f"  ... and {len(missing) - 5} more")
         if dry_run:
             print("dry run: nothing written")
             return 0
+        if not spec["assets"]:
+            return 0
         return run_worker(cfg, spec)
     if not dry_run and not os.environ.get("USDSEARCH_LLM_API_KEY", "").strip():
         print("VISION_VIEWS is on but USDSEARCH_LLM_API_KEY is not set in the environment")
         return 1
     check_model = cfg.get("VISION_VIEWS_CHECK_MODEL").strip()
+    check_model = "" if check_model.lower() in OFF else check_model
     on_disagree = cfg.get("VISION_VIEWS_ON_DISAGREE", "flag").strip().lower() or "flag"
     if on_disagree not in ON_DISAGREE:
         print(f"VISION_VIEWS_ON_DISAGREE={on_disagree!r}: expected one of {', '.join(ON_DISAGREE)}")
@@ -343,10 +434,12 @@ def run(cfg: Config, dry_run: bool = False) -> int:
     kinds = Counter(len(a["views"]) for a in spec["assets"].values())
     opens = sum(1 for a in spec["assets"].values() if any(v["label"] == "open" for v in a["views"]))
     images = sum(max(1, len(a["views"])) for a in spec["assets"].values())
+    hints = sum(1 for a in spec["assets"].values() if a["hint"])
     calls = len(spec["assets"]) * (2 if check_model else 1)
     print(f"vision views ({mode}): {len(spec['assets'])} asset(s), media {spec['media']}; views per asset "
-          f"{dict(sorted(kinds.items()))} (0 = thumbnail); {opens} with an open view; {images} image(s); {calls} VLM "
-          f"call(s)" + (f" (check model {check_model}, on disagreement: {on_disagree})" if check_model else ""))
+          f"{dict(sorted(kinds.items()))} (0 = thumbnail); {opens} with an open view; {images} image(s); {hints} with "
+          f"a name hint; {calls} VLM call(s)"
+          + (f" (check model {check_model}, on disagreement: {on_disagree})" if check_model else ""))
     if dry_run:
         print("dry run: nothing written")
         return 0
@@ -376,7 +469,9 @@ def run_worker(cfg: Config, spec: Dict) -> int:
            "-e", "USDSEARCH_VISION_METADATA_YAML_FILEPATH=/app/vlm_metadata_fields.yaml",
            "-v", f"{REPO_ROOT / 'config' / 'vlm_metadata_prompt.txt'}:/app/vlm_metadata_prompt.txt:ro",
            "-e", "USDSEARCH_VISION_METADATA_PROMPT_FILEPATH=/app/vlm_metadata_prompt.txt",
-           "-e", "OPENSEARCH_URL_INTERNAL=http://opensearch:9200"]
+           "-e", "OPENSEARCH_URL_INTERNAL=http://opensearch:9200",
+           # only the spec's hint (none for an id or a hash): never the plugin's own from omni_path
+           "-e", "VLM_ASSET_HINT=false"]
     if spec["media"]:
         cmd += ["-v", f"{spec['media']}:/media:ro"]
     for var in passthrough:

pipeline/vision_views_worker.py

@@ -18,6 +18,7 @@ from image_overrides_worker import fetch_thumbnail, os_doc, result_content  # no
 from vision_views_rules import agrees, compatible  # noqa: E402
 
 CHECK_MODEL = (os.environ.get("VISION_VIEWS_CHECK_MODEL") or "").strip()
+CHECK_MODEL = "" if CHECK_MODEL.lower() in ("off", "none", "false", "0", "no") else CHECK_MODEL
 CHECK_EFFORT = (os.environ.get("VISION_VIEWS_CHECK_REASONING_EFFORT") or "").strip()
 ON_DISAGREE = (os.environ.get("VISION_VIEWS_ON_DISAGREE") or "flag").strip().lower()
 CONCURRENCY = int(os.environ.get("VISION_VIEWS_CONCURRENCY") or 4)

services/explorer/dist/build-info.json

@@ -1,7 +1,7 @@
 {
   "product": "simready-central-slim-explorer",
-  "version": "slim-ui-749ce4a4-hfstatus",
-  "bundle_id": "main.2f1a816a.js",
-  "built_at": "2026-10-20T06:07:33Z",
-  "flags": {"public_mode": true, "email_auth": false, "create_ui": false, "hierarchy_editor": false, "create_search": false, "auth_ui": false, "credentials_ui": false, "index_management": false, "inference_backend": "hub", "vlm_asset_refs": false, "validation_image_max_px": 448, "validation_max_retries": 0, "validation_max_concurrent": 32, "validation_tail_concurrent": 8, "validation_eager_count": 50, "validation_batch_stream": true, "library_idle_prefetch": false, "validation_score_scale": "percent", "parse_gate_fields": true, "parse_fast_path": true, "featured_landing": true, "hf_download_commands": true, "capacity_level_url": "https://huggingface.co/datasets/nvidia/simready-central-status/resolve/main/status.json", "dependency_views": true, "model_viewer": false, "library_viewer": true, "library_media": "runtime", "spell_correction": true, "downloads": "runtime", "submit_content": "runtime", "third_party_notices": "runtime"}
+  "version": "slim-ui-f57ff00c",
+  "bundle_id": "main.e1d091ef.js",
+  "built_at": "2026-10-20T14:33:18Z",
+  "flags": {"public_mode": true, "email_auth": false, "create_ui": false, "hierarchy_editor": false, "create_search": false, "auth_ui": false, "credentials_ui": false, "index_management": false, "inference_backend": "hub", "vlm_asset_refs": false, "validation_image_max_px": 448, "validation_max_retries": 0, "validation_max_concurrent": 32, "validation_tail_concurrent": 8, "validation_eager_count": 50, "validation_batch_stream": true, "library_idle_prefetch": false, "validation_score_scale": "percent", "parse_gate_fields": true, "parse_fast_path": true, "featured_landing": true, "hf_download_commands": true, "capacity_level_url": "https://huggingface.co/datasets/nvidia/simready-central-status/resolve/main/status.json", "max_usd_mb": "", "notice_usd_mb": "50", "dependency_views": true, "model_viewer": false, "library_viewer": true, "library_media": "runtime", "spell_correction": true, "downloads": "runtime", "submit_content": "runtime", "third_party_notices": "runtime"}
 }

services/explorer/dist/index.html

@@ -1 +1 @@
-<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="/ds.png"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="SimReady Central — SimReady asset search"/><meta name="ui-version" content="slim-ui-749ce4a4-hfstatus"><script src="/config.js"></script><title>SimReady Central</title><script defer="defer" src="/static/js/main.2f1a816a.js"></script><link href="/static/css/main.c80b163d.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>
+<!doctype html><html lang="en"><head><meta charset="utf-8"/><link rel="icon" href="/ds.png"/><meta name="viewport" content="width=device-width,initial-scale=1"/><meta name="theme-color" content="#000000"/><meta name="description" content="SimReady Central — SimReady asset search"/><meta name="ui-version" content="slim-ui-f57ff00c"><script src="/config.js"></script><title>SimReady Central</title><script defer="defer" src="/static/js/main.e1d091ef.js"></script><link href="/static/css/main.ed151f6a.css" rel="stylesheet"></head><body><noscript>You need to enable JavaScript to run this app.</noscript><div id="root"></div></body></html>

services/explorer/dist/third-party-notices.txt

@@ -1,4 +1,4 @@
-Third-party notices — SimReady Central Explorer slim-ui-749ce4a4-hfstatus
+Third-party notices — SimReady Central Explorer slim-ui-f57ff00c
 
 The software in this web application's browser bundle includes the packages below, each under its own
 license. Each entry gives the package, its version, its license and the license / notice text it ships.