inline-core 1.3.0__tar.gz → 1.3.1__tar.gz

{inline_core-1.3.0 → inline_core-1.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: inline-core
-Version: 1.3.0
+Version: 1.3.1
 Summary: The generation engine behind Inline Studio.
 License-Expression: GPL-3.0-or-later
 Requires-Python: >=3.11

{inline_core-1.3.0 → inline_core-1.3.1}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 # PyPI name; the import package is `inline_core` (src/inline_core).
 name = "inline-core"
-version = "1.3.0"
+version = "1.3.1"
 description = "The generation engine behind Inline Studio."
 readme = "README.md"
 license = "GPL-3.0-or-later"

{inline_core-1.3.0 → inline_core-1.3.1}/src/inline_core/server/__main__.py

@@ -34,6 +34,7 @@ from .bootstrap import register_models
 from .frontend import resolve_frontend_root
 from .rpc import EventBroadcaster, RpcRouter
 from .run_store import SqliteRunStore
+from .version import report_versions
 
 
 def _quiet_dependency_noise() -> None:
@@ -50,6 +51,10 @@ def _quiet_dependency_noise() -> None:
 
 def main() -> None:
     _quiet_dependency_noise()  # before register_models, which is what pulls diffusers/torchao in
+    # Resolved and reported first: model registration is slow and can crash, and the two version
+    # numbers are the first thing a bug report needs.
+    frontend_root = resolve_frontend_root()
+    report_versions(frontend_root)
     policy = MemoryPolicy()
     registry = build_default_registry()
     data = data_dir()
@@ -71,7 +76,6 @@ def main() -> None:
     torch_warning = cpu_only_torch_warning() or unsupported_arch_warning()
     if torch_warning:
         print(f"WARNING: {torch_warning}")
-    frontend_root = resolve_frontend_root()
     # The Studio app-backend: Core is the sole native backend (projects, frames, moodboard, assets,
     # generation, fal, timeline). Every InlineStudioApi channel is handled here.
     store = StudioStore(

inline_core-1.3.1/src/inline_core/server/version.py

@@ -0,0 +1,205 @@
+"""What is installed and whether PyPI has newer: the engine and the UI ship separately and drift."""
+
+from __future__ import annotations
+
+import json
+import os
+import threading
+import time
+import urllib.error
+import urllib.request
+from dataclasses import dataclass
+from importlib.metadata import PackageNotFoundError, distribution, version
+from pathlib import Path
+from typing import Any, cast
+
+from ..config import data_dir
+
+CORE_PACKAGE = "inline-core"
+FRONTEND_PACKAGE = "inline-studio-frontend"
+
+#: A day: long enough that a restart loop never hammers PyPI, short enough to notice a release.
+CACHE_TTL_SECONDS = 24 * 60 * 60
+
+#: The check runs off the boot path, but a hung socket would still hold the daemon thread open.
+FETCH_TIMEOUT_SECONDS = 5
+
+
+@dataclass(frozen=True)
+class Component:
+    package: str
+    #: None when what runs is not an installed distribution - a local SPA build, or no UI at all.
+    version: str | None
+    origin: str
+
+
+def core_component() -> Component:
+    """An editable install records its version at install time, so the number can lag the source."""
+    return Component(
+        CORE_PACKAGE, _installed(CORE_PACKAGE), "editable" if _is_editable(CORE_PACKAGE) else ""
+    )
+
+
+def frontend_component(frontend_root: str | None) -> Component:
+    if frontend_root is None:
+        return Component(FRONTEND_PACKAGE, None, "not installed")
+    if _is_package_static(frontend_root):
+        return Component(FRONTEND_PACKAGE, _installed(FRONTEND_PACKAGE), "")
+    return Component(FRONTEND_PACKAGE, None, f"local build: {frontend_root}")
+
+
+def report_versions(frontend_root: str | None) -> None:
+    """Name both halves at boot, then announce an update - cached, or from a background fetch."""
+    core, frontend = core_component(), frontend_component(frontend_root)
+    print("Versions: " + ", ".join(describe(c) for c in (core, frontend)))
+    if os.environ.get("INLINE_NO_UPDATE_CHECK", "").strip().lower() in {"1", "true", "yes"}:
+        return
+    cached = _read_cache()
+    if cached is not None:
+        _announce(core, frontend, cached)
+        return
+    threading.Thread(target=_check, args=(core, frontend), daemon=True).start()
+
+
+def describe(component: Component) -> str:
+    parts = [component.package, component.version or "unknown"]
+    return " ".join(parts) + (f" ({component.origin})" if component.origin else "")
+
+
+def update_lines(component: Component, latest: str | None) -> list[str]:
+    """Empty unless this half is behind - an unreachable PyPI must never claim either answer."""
+    if component.version is None or latest is None or not is_newer(latest, component.version):
+        return []
+    launcher = ".\\webui.bat" if os.name == "nt" else "./webui.sh"
+    hint = f"{launcher} --install"
+    if component.package == CORE_PACKAGE and component.origin == "editable":
+        hint = f"git pull, then {hint}"
+    return [
+        f"UPDATE AVAILABLE: {component.package} {component.version} -> {latest}",
+        f"  Update with: {hint}  (or: pip install -U {component.package})",
+    ]
+
+
+def is_newer(candidate: str, current: str) -> bool:
+    """PEP 440 when packaging is importable; it is not a declared dependency of the engine."""
+    try:
+        from packaging.version import InvalidVersion, Version
+
+        try:
+            return Version(candidate) > Version(current)
+        except InvalidVersion:
+            pass
+    except ModuleNotFoundError:
+        pass
+    return _numeric(candidate) > _numeric(current)
+
+
+def latest_release(package: str) -> str | None:
+    url = f"https://pypi.org/pypi/{package}/json"
+    try:
+        with urllib.request.urlopen(url, timeout=FETCH_TIMEOUT_SECONDS) as response:  # noqa: S310
+            payload = _object(json.loads(response.read().decode("utf-8")))
+    except (urllib.error.URLError, OSError, ValueError):
+        return None
+    latest = _object(payload.get("info")).get("version")
+    return latest if isinstance(latest, str) else None
+
+
+def _check(core: Component, frontend: Component) -> None:
+    latest = {p: latest_release(p) for p in (CORE_PACKAGE, FRONTEND_PACKAGE)}
+    found = {p: v for p, v in latest.items() if v is not None}
+    # Only a complete answer is cached, so one unreachable fetch does not freeze a stale pair in.
+    if len(found) == len(latest):
+        _write_cache(found)
+    _announce(core, frontend, found)
+
+
+def _announce(core: Component, frontend: Component, latest: dict[str, str]) -> None:
+    lines = [
+        line
+        for component in (core, frontend)
+        for line in update_lines(component, latest.get(component.package))
+    ]
+    for line in lines:
+        print(line)
+
+
+def _object(value: object) -> dict[str, Any]:
+    """`json.loads` returns `Any`; narrowed once here so the rest of the module stays typed."""
+    return cast("dict[str, Any]", value) if isinstance(value, dict) else {}
+
+
+def _installed(package: str) -> str | None:
+    try:
+        return version(package)
+    except PackageNotFoundError:
+        return None
+
+
+def _is_editable(package: str) -> bool:
+    try:
+        raw = distribution(package).read_text("direct_url.json")
+    except (PackageNotFoundError, OSError):
+        return False
+    if not raw:
+        return False
+    try:
+        info = _object(json.loads(raw))
+    except ValueError:
+        return False
+    return bool(_object(info.get("dir_info")).get("editable"))
+
+
+def _is_package_static(frontend_root: str) -> bool:
+    """INLINE_FRONTEND_ROOT can name the package's own static dir, which is still the package."""
+    try:
+        import inline_studio_frontend  # type: ignore[import-not-found]
+    except ModuleNotFoundError:
+        return False
+    pkg_file = getattr(inline_studio_frontend, "__file__", None)
+    if not pkg_file:
+        return False
+    static = Path(pkg_file).parent / "static"
+    try:
+        return static.resolve() == Path(frontend_root).resolve()
+    except OSError:
+        return False
+
+
+def _numeric(value: str) -> tuple[int, ...]:
+    parts: list[int] = []
+    for chunk in value.split("."):
+        digits = ""
+        for character in chunk:
+            if not character.isdigit():
+                break
+            digits += character
+        if not digits:
+            break
+        parts.append(int(digits))
+    return tuple(parts)
+
+
+def _cache_path() -> Path:
+    return data_dir() / "version-check.json"
+
+
+def _read_cache() -> dict[str, str] | None:
+    """None when absent or past the TTL, so a stale file never reports an old release as newest."""
+    path = _cache_path()
+    try:
+        if time.time() - path.stat().st_mtime > CACHE_TTL_SECONDS:
+            return None
+        raw = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return {k: v for k, v in _object(raw).items() if isinstance(v, str)}
+
+
+def _write_cache(latest: dict[str, str]) -> None:
+    path = _cache_path()
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(latest), encoding="utf-8")
+    except OSError:
+        pass

{inline_core-1.3.0 → inline_core-1.3.1}/src/inline_core/studio/dataset_import.py

@@ -9,11 +9,18 @@ names it ``caption-nvila15b``.
 
 Filenames remain the fallback: ``bear.mp4`` pairs with ``bear_reference.mp4`` with no sidecar at
 all, which is what ``training/dataset.py`` already reads at train time.
+
+Nesting is read too. The Hugging Face ``videofolder`` convention puts the clips in ``train/`` beside
+a ``metadata.jsonl`` whose ``file_name`` is relative to that split, so a reader that only looked at
+the root of a pulled repo found no media at all and every path here is relative to the root instead
+of a bare name.
 """
 
 from __future__ import annotations
 
 import json
+import os
+from collections.abc import Iterator
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
@@ -38,9 +45,39 @@ class DatasetEntry:
 
 
 def read_metadata(root: Path) -> dict[str, DatasetEntry]:
-    """Every metadata row, keyed by target filename. Empty when the folder carries none."""
+    """Every metadata row, keyed by path relative to `root`. Empty when the folder carries none."""
+    entries: dict[str, DatasetEntry] = {}
+    for folder in sorted({root, *(f.parent for f in walk_files(root))}):
+        entries.update(_read_folder(root, folder))
+    return entries
+
+
+def walk_files(root: Path) -> list[Path]:
+    """Every file under `root`, sorted, skipping dot-dirs - `.cache/` mirrors the whole snapshot."""
+    return sorted(_walk(root))
+
+
+def media_files(root: Path) -> list[Path]:
+    return [p for p in walk_files(root) if p.suffix.lower() in _MEDIA_SUFFIXES]
+
+
+def _walk(root: Path) -> Iterator[Path]:
+    try:
+        entries = sorted(root.iterdir())
+    except OSError:
+        return
+    for entry in entries:
+        if entry.name.startswith("."):
+            continue
+        if entry.is_dir():
+            yield from _walk(entry)
+        elif entry.is_file():
+            yield entry
+
+
+def _read_folder(root: Path, folder: Path) -> dict[str, DatasetEntry]:
     for name in _METADATA_FILES:
-        path = root / name
+        path = folder / name
         if not path.is_file():
             continue
         try:
@@ -52,16 +89,23 @@ def read_metadata(root: Path) -> dict[str, DatasetEntry]:
             target = _first(row, _TARGET_KEYS)
             if not target:
                 continue
-            entries[Path(target).name] = DatasetEntry(
-                target=Path(target).name,
+            reference = _first(row, _REFERENCE_KEYS)
+            key = _relative(root, folder, target)
+            entries[key] = DatasetEntry(
+                target=key,
                 caption=_caption(row),
-                reference=(lambda r: Path(r).name if r else None)(_first(row, _REFERENCE_KEYS)),
+                reference=_relative(root, folder, reference) if reference else None,
             )
         if entries:
             return entries
     return {}
 
 
+def _relative(root: Path, folder: Path, value: str) -> str:
+    """A sidecar names its files relative to itself, so a split's rows key on `train/0001.mp4`."""
+    return Path(os.path.normpath(folder.relative_to(root) / value)).as_posix()
+
+
 def _rows(path: Path) -> list[dict[str, Any]]:
     text = path.read_text(encoding="utf-8").strip()
     if not text:
@@ -134,14 +178,16 @@ def inspect_repo(repo: str, token: str | None = None) -> RepoPreview:
             return RepoPreview(repo, 0, 0, 0, None, f"No dataset repo called {repo!r}.")
         return RepoPreview(repo, 0, 0, 0, None, str(exc).splitlines()[0])
 
-    names, total = [], 0
-    metadata_file = None
+    names: list[str] = []
+    total, metadata_file = 0, None
     for sibling in info.siblings or []:
-        name = Path(sibling.rfilename).name
-        if sibling.rfilename in _METADATA_FILES or name in _METADATA_FILES:
-            metadata_file = name
-        if Path(name).suffix.lower() in _MEDIA_SUFFIXES:
-            names.append(name)
+        # The repo path, not its basename: the preview counted `train/0001.mp4` while the import
+        # read only the root, so it promised 173 clips and then found none.
+        rel = Path(str(sibling.rfilename))
+        if rel.name in _METADATA_FILES:
+            metadata_file = rel.name
+        if rel.suffix.lower() in _MEDIA_SUFFIXES:
+            names.append(rel.as_posix())
             total += int(getattr(sibling, "size", 0) or 0)
 
     return _preview(repo, names, total, metadata_file)
@@ -152,15 +198,13 @@ def inspect_folder(path: str) -> RepoPreview:
     folder = Path(path).expanduser()
     if not folder.is_dir():
         return RepoPreview(path, 0, 0, 0, None, f"No folder at {path!r}.")
-    names, total = [], 0
-    metadata_file = None
-    for entry in sorted(folder.iterdir()):
-        if not entry.is_file():
-            continue
+    names: list[str] = []
+    total, metadata_file = 0, None
+    for entry in walk_files(folder):
         if entry.name in _METADATA_FILES:
             metadata_file = entry.name
         if entry.suffix.lower() in _MEDIA_SUFFIXES:
-            names.append(entry.name)
+            names.append(entry.relative_to(folder).as_posix())
             total += entry.stat().st_size
     return _preview(path, names, total, metadata_file)
 
@@ -185,7 +229,8 @@ def _looks_like_reference(name: str) -> bool:
 def _reference_name_for(name: str, present: set[str]) -> str | None:
     path = Path(name)
     for suffix in (".ref", "_reference"):
-        candidate = f"{path.stem}{suffix}{path.suffix.lower()}"
+        # with_name, so a nested pair stays in its own split rather than matching across folders.
+        candidate = path.with_name(f"{path.stem}{suffix}{path.suffix.lower()}").as_posix()
         if candidate in present:
             return candidate
     return None

{inline_core-1.3.0 → inline_core-1.3.1}/src/inline_core/studio/training.py

@@ -32,7 +32,7 @@ from ..training.dataset import (
 )
 from . import training_store as ts
 from .activity import ActivityRun
-from .dataset_import import read_metadata
+from .dataset_import import read_metadata, walk_files
 
 _CAPTION_EXT = ".txt"
 
@@ -168,38 +168,39 @@ class Training:
         if not folder.is_dir():
             raise ValueError(f"Not a folder: {path}")
         conn, project = self._conn(), self._store.folder()
-        media = [
-            p
-            for p in sorted(folder.iterdir())
-            if p.is_file() and ax.kind_for_file(str(p)) in ("image", "video")
-        ]
+        # Nested, because a pulled Hugging Face dataset keeps its clips in `train/`, not the root.
+        media = [p for p in walk_files(folder) if ax.kind_for_file(str(p)) in ("image", "video")]
         if not media:
             raise ValueError(f"No images or clips in {path}")
 
+        def relative(source: Path) -> str:
+            return source.relative_to(folder).as_posix()
+
         metadata = read_metadata(folder)
+        names = {relative(p) for p in media}
         references = {e.reference for e in metadata.values() if e.reference} | {
-            p.name for p in media if is_reference_name(p)
+            n for n in names if is_reference_name(Path(n))
         }
         imported = [(p, ax.import_file(conn, project, str(p), None)) for p in media]
-        by_name = {p.name: a["id"] for p, a in imported if a}
-        names = {p.name for p in media}
+        by_name = {relative(p): a["id"] for p, a in imported if a}
 
         staged: list[dict[str, Any]] = []
         for source, asset in imported:
-            if asset is None or source.name in references:
+            name = relative(source)
+            if asset is None or name in references:
                 continue
-            entry = metadata.get(source.name)
+            entry = metadata.get(name)
             sidecar = source.with_suffix(_CAPTION_EXT)
             caption = ""
             if sidecar.is_file():
                 caption = sidecar.read_text(encoding="utf-8").strip()
             elif entry is not None:
                 caption = entry.caption
-            reference_name = entry.reference if entry else reference_for_name(source, names)
+            reference_name = entry.reference if entry else reference_for_name(Path(name), names)
             staged.append(
                 {
                     "assetId": asset["id"],
-                    "name": source.name,
+                    "name": name,
                     "caption": caption,
                     "referenceAssetId": by_name.get(reference_name) if reference_name else None,
                 }

{inline_core-1.3.0 → inline_core-1.3.1}/src/inline_core/training/dataset.py

@@ -56,7 +56,8 @@ def reference_for_name(target: Path, names: set[str]) -> str | None:
     out. Same two spellings, matched against what is actually being imported.
     """
     for suffix in (_REFERENCE_INFIX, _REFERENCE_SUFFIX):
-        candidate = f"{target.stem}{suffix}{target.suffix.lower()}"
+        # with_name keeps a nested target in its own folder; a bare name is unchanged by it.
+        candidate = target.with_name(f"{target.stem}{suffix}{target.suffix.lower()}").as_posix()
         if candidate in names:
             return candidate
     return None

{inline_core-1.3.0 → inline_core-1.3.1}/tests/test_dataset_import.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import json
 from pathlib import Path
 
-from inline_core.studio.dataset_import import read_metadata
+from inline_core.studio.dataset_import import inspect_folder, media_files, read_metadata
 from inline_core.training.dataset import is_reference_name, reference_for_name
 
 
@@ -41,6 +41,48 @@ def test_hugging_face_metadata_jsonl_finds_a_prefixed_caption_key(tmp_path: Path
     assert entries["0001.mp4"].reference is None
 
 
+def test_a_split_subfolder_is_read_and_keyed_from_the_root(tmp_path: Path) -> None:
+    """The videofolder convention: clips in `train/`, a sidecar beside them, `file_name` relative.
+
+    Reading only the root is what made a pulled pixel-art dataset import as "No images or clips".
+    """
+    train = tmp_path / "train"
+    train.mkdir()
+    (train / "metadata.jsonl").write_text(
+        '{"file_name": "0001.mp4", "caption-nvila15b": "a pixel scene"}\n'
+    )
+    (train / "0001.mp4").write_bytes(b"clip")
+    (tmp_path / "README.md").write_text("# a dataset")
+
+    entries = read_metadata(tmp_path)
+    assert set(entries) == {"train/0001.mp4"}
+    assert entries["train/0001.mp4"].caption == "a pixel scene"
+    assert [p.name for p in media_files(tmp_path)] == ["0001.mp4"]
+    preview = inspect_folder(str(tmp_path))
+    assert (preview.items, preview.problem) == (1, None)
+
+
+def test_a_nested_pair_stays_inside_its_own_split(tmp_path: Path) -> None:
+    """Pairing is by relative path, so `train/bear.mp4` cannot claim `test/bear_reference.mp4`."""
+    for split in ("train", "test"):
+        (tmp_path / split).mkdir()
+        (tmp_path / split / "bear.mp4").write_bytes(b"clip")
+    (tmp_path / "test" / "bear_reference.mp4").write_bytes(b"clip")
+
+    preview = inspect_folder(str(tmp_path))
+    assert (preview.items, preview.pairs) == (2, 1)
+
+
+def test_the_hugging_face_download_cache_is_not_imported(tmp_path: Path) -> None:
+    """`local_dir` snapshots leave a `.cache/huggingface/` mirror beside the real files."""
+    cache = tmp_path / ".cache" / "huggingface" / "download" / "train"
+    cache.mkdir(parents=True)
+    (cache / "0001.mp4").write_bytes(b"not the real clip")
+    (tmp_path / "0001.mp4").write_bytes(b"clip")
+    assert [p.name for p in media_files(tmp_path)] == ["0001.mp4"]
+    assert media_files(tmp_path)[0].parent == tmp_path
+
+
 def test_a_malformed_sidecar_falls_back_rather_than_failing_the_import(tmp_path: Path) -> None:
     (tmp_path / "dataset.json").write_text("{not json")
     assert read_metadata(tmp_path) == {}

inline_core-1.3.1/tests/test_version_report.py

@@ -0,0 +1,79 @@
+"""The two halves ship separately, so the boot banner has to name both and notice either lagging."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from inline_core.server import version as v
+
+
+def _component(package: str, installed: str | None, origin: str = "") -> v.Component:
+    return v.Component(package, installed, origin)
+
+
+def test_a_newer_release_is_announced_with_a_command() -> None:
+    lines = v.update_lines(_component(v.FRONTEND_PACKAGE, "1.2.52"), "1.3.0")
+    assert "1.2.52 -> 1.3.0" in lines[0]
+    assert v.FRONTEND_PACKAGE in lines[1]
+
+
+def test_an_editable_checkout_is_told_to_pull_first() -> None:
+    """Its version is recorded at install time, so pip would not move it - only the source does."""
+    lines = v.update_lines(_component(v.CORE_PACKAGE, "1.2.0", "editable"), "1.3.0")
+    assert "git pull" in lines[1]
+
+
+def test_nothing_is_claimed_when_current_or_unreachable() -> None:
+    assert v.update_lines(_component(v.CORE_PACKAGE, "1.3.0"), "1.3.0") == []
+    assert v.update_lines(_component(v.CORE_PACKAGE, "1.4.0"), "1.3.0") == []
+    assert v.update_lines(_component(v.CORE_PACKAGE, "1.3.0"), None) == []
+    assert v.update_lines(_component(v.FRONTEND_PACKAGE, None, "local build: x"), "1.3.0") == []
+
+
+def test_version_compare_without_packaging(monkeypatch) -> None:
+    """`packaging` is not a declared dependency of the engine, so the fallback has to hold."""
+    import builtins
+
+    real_import = builtins.__import__
+
+    def _blocked(name, *args, **kwargs):
+        if name.startswith("packaging"):
+            raise ModuleNotFoundError(name)
+        return real_import(name, *args, **kwargs)
+
+    monkeypatch.setattr(builtins, "__import__", _blocked)
+    assert v.is_newer("1.3.0", "1.2.52")
+    assert v.is_newer("1.10.0", "1.9.0")
+    assert not v.is_newer("1.3.0", "1.3.0")
+    assert not v.is_newer("1.2.0", "1.3.0")
+
+
+def test_a_local_spa_build_reports_no_package_version(tmp_path: Path) -> None:
+    """A `--rebuild` / `--front-end-root` run serves source, which no wheel version describes."""
+    component = v.frontend_component(str(tmp_path / "dist-web"))
+    assert component.version is None
+    assert "local build" in component.origin
+    assert v.frontend_component(None).origin == "not installed"
+
+
+def test_a_stale_cache_is_ignored(monkeypatch, tmp_path: Path) -> None:
+    """Otherwise the first check's answer would be reported as the newest release forever."""
+    monkeypatch.setenv("INLINE_DATA_DIR", str(tmp_path))
+    cache = tmp_path / "version-check.json"
+    cache.write_text(json.dumps({v.CORE_PACKAGE: "1.3.0"}))
+    assert v._read_cache() == {v.CORE_PACKAGE: "1.3.0"}
+    import os
+
+    stale = cache.stat().st_mtime - v.CACHE_TTL_SECONDS - 1
+    os.utime(cache, (stale, stale))
+    assert v._read_cache() is None
+
+
+def test_the_check_is_skippable(monkeypatch, capsys) -> None:
+    monkeypatch.setenv("INLINE_NO_UPDATE_CHECK", "1")
+    monkeypatch.setattr(v, "latest_release", lambda package: "99.0.0")
+    v.report_versions(None)
+    out = capsys.readouterr().out
+    assert "Versions:" in out
+    assert "UPDATE AVAILABLE" not in out

{inline_core-1.3.0 → inline_core-1.3.1}/webui.bat

@@ -223,7 +223,14 @@ if "!TORCH_FORCE!"=="1" if defined TORCH_CHOICE (
   echo + uv pip install --python "!TARGET_PY!" --index-url !TORCH_URL! --reinstall !TORCH_PINS!
   uv pip install --python "!TARGET_PY!" --index-url !TORCH_URL! --reinstall !TORCH_PINS! || goto fail
 )
-uv pip install --python "!TARGET_PY!" inline-studio-frontend >nul 2>nul && echo Installed the prebuilt web UI (inline-studio-frontend). || echo Note: inline-studio-frontend not installed; the UI will build from source or run API-only.
+rem --upgrade, because uv leaves an already-satisfied requirement alone: without it a re-run of
+rem --install kept whatever UI was first installed while the engine moved on underneath it.
+set "FRONTEND_VERSION="
+uv pip install --python "!TARGET_PY!" --upgrade inline-studio-frontend >nul 2>nul && (
+  for /f "usebackq delims=" %%v in (`"!TARGET_PY!" -c "from importlib.metadata import version; print(version('inline-studio-frontend'))" 2^>nul`) do set "FRONTEND_VERSION=%%v"
+  if not defined FRONTEND_VERSION set "FRONTEND_VERSION=unknown"
+  echo Installed the prebuilt web UI ^(inline-studio-frontend !FRONTEND_VERSION!^).
+) || echo Note: inline-studio-frontend not installed; the UI will build from source or run API-only.
 call :write_install_record
 rem A CPU-only wheel on a GPU box is silent at runtime and ~100x slower, so say it here rather than
 rem let it through: it can still happen if PyPI ever outranks the CUDA index on version.
@@ -234,7 +241,9 @@ echo          CPU, roughly 100x slower. Re-run with an explicit index, e.g.
 echo          .\webui.bat --install --torch-index !TORCH_CHOICE! --recreate
 
 :install_done
-echo Installed extras: !EXTRAS!. Start with: .\webui.bat
+set "CORE_VERSION=unknown"
+for /f "usebackq delims=" %%v in (`"!TARGET_PY!" -c "from importlib.metadata import version; print(version('inline-core'))" 2^>nul`) do set "CORE_VERSION=%%v"
+echo Installed inline-core !CORE_VERSION! with extras: !EXTRAS!. Start with: .\webui.bat
 exit /b 0
 
 rem One query for both, keeping the highest capability. set /a not a findstr guard: `if LSS` would

{inline_core-1.3.0 → inline_core-1.3.1}/webui.sh

@@ -370,9 +370,15 @@ if [[ "$RUN_INSTALL" -eq 1 ]]; then
     uv pip install --python "$TARGET_PY" --index-url "$TORCH_URL" --reinstall "${TORCH_PINS[@]}"
   fi
   # Pull the prebuilt web UI so there's no Node build (best-effort - it may not be published yet).
-  uv pip install --python "$TARGET_PY" inline-studio-frontend >/dev/null 2>&1 \
-    && echo "Installed the prebuilt web UI (inline-studio-frontend)." \
-    || echo "Note: inline-studio-frontend not installed; the UI will build from source or run API-only."
+  # --upgrade, because uv leaves an already-satisfied requirement alone: without it a re-run of
+  # --install kept whatever UI was first installed while the engine moved on underneath it.
+  if uv pip install --python "$TARGET_PY" --upgrade inline-studio-frontend >/dev/null 2>&1; then
+    FRONTEND_VERSION="$("$TARGET_PY" -c 'from importlib.metadata import version
+print(version("inline-studio-frontend"))' 2>/dev/null || true)"
+    echo "Installed the prebuilt web UI (inline-studio-frontend ${FRONTEND_VERSION:-unknown})."
+  else
+    echo "Note: inline-studio-frontend not installed; the UI will build from source or run API-only."
+  fi
   # A CPU-only wheel on a GPU box is silent at runtime and ~100x slower, so say it here rather than
   # let the resolve fail quietly - it can still happen if PyPI outranks the CUDA index on version.
   if [[ "$TORCH_CHOICE" != "cpu" ]] && ! "$TARGET_PY" -c 'import importlib.util, sys
@@ -409,7 +415,9 @@ rec = {
 with open(os.environ["INLINE_RECORD"], "w", encoding="utf-8") as fh:
     json.dump(rec, fh, indent=2)
 ' 2>/dev/null || true
-  echo "Installed extras: $EXTRAS. Start with: ./webui.sh"
+  CORE_VERSION="$("$TARGET_PY" -c 'from importlib.metadata import version
+print(version("inline-core"))' 2>/dev/null || true)"
+  echo "Installed inline-core ${CORE_VERSION:-unknown} with extras: $EXTRAS. Start with: ./webui.sh"
   exit 0
 fi