simview 6.3.0__tar.gz → 6.3.1__tar.gz

{simview-6.3.0/simview.egg-info → simview-6.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simview
-Version: 6.3.0
+Version: 6.3.1
 Summary: THREE.js-based simulation visualization tool
 Author-email: Jan Vlk <vlkjan6@fel.cvut.cz>, Ales Kucera <kuceral4@fel.cvut.cz>, David Korcak <david.korcak@gmail.com>
 License-Expression: BSD-3-Clause

{simview-6.3.0 → simview-6.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "simview"
-version = "6.3.0"
+version = "6.3.1"
 readme = "README.md"
 requires-python = ">=3.12"
 license = "BSD-3-Clause"

{simview-6.3.0 → simview-6.3.1}/simview/__main__.py

@@ -82,8 +82,14 @@ def export_static_viewer(directory: Path) -> None:
 
     package = files("simview")
     directory.mkdir(parents=True, exist_ok=True)
-    shutil.copy(str(package / "templates" / "index.html"), directory / "index.html")
-    shutil.copytree(str(package / "static"), directory / "static", dirs_exist_ok=True)
+    from simview.preload import render_index
+
+    index = package / "templates" / "index.html"
+    static = package / "static"
+    (directory / "index.html").write_text(
+        render_index(str(index), str(package)), encoding="utf-8"
+    )
+    shutil.copytree(str(static), directory / "static", dirs_exist_ok=True)
     logger.info("Static viewer written to %s", directory)
 
 

simview-6.3.1/simview/preload.py

@@ -0,0 +1,69 @@
+"""`<link rel="modulepreload">` tags for the viewer page.
+
+The browser only discovers an ES module's imports after it has fetched and
+parsed the importer, so the ~50-file module graph downloads one dependency
+level at a time. Listing every module in the page head lets them all start at
+once (a ~50 ms round trip each otherwise adds up level by level).
+"""
+
+import json
+import re
+from functools import cache
+from pathlib import Path
+
+# `import ... from "x"`, `export ... from "x"` and side-effect `import "x"`.
+# Dynamic import() is skipped: those modules are lazy on purpose.
+_STATIC_IMPORT = re.compile(
+    r"""(?:^|[;\n])\s*(?:import|export)\b[^;'"]*?(?:\bfrom\s*)?["']([^"']+)["']\s*;?""",
+)
+_IMPORTMAP = re.compile(r'<script type="importmap">(.*?)</script>', re.S)
+PLACEHOLDER = "<!-- @modulepreload -->"
+
+
+def _resolve(
+    spec: str, importer: Path, root: Path, imports: dict[str, str]
+) -> Path | None:
+    """Filesystem path `spec` points at, or None for anything outside `root`."""
+    if spec.startswith("."):
+        target = importer.parent / spec
+    else:
+        # Bare specifier -> import map; "prefix/" entries map whole directories.
+        for key, value in imports.items():
+            if spec == key or (key.endswith("/") and spec.startswith(key)):
+                target = root / (value + spec[len(key) :])
+                break
+        else:
+            return None
+    target = target.resolve()
+    return target if target.is_file() and root in target.parents else None
+
+
+def module_graph(html: str, root: Path, entry: str = "static/js/main.js") -> list[str]:
+    """Page-relative URLs (`./static/...`) of every module reachable from `entry`."""
+    match = _IMPORTMAP.search(html)
+    imports = json.loads(match.group(1))["imports"] if match else {}
+    imports = {k: v.removeprefix("./") for k, v in imports.items()}
+    root = root.resolve()
+    seen: dict[Path, None] = {}
+    todo = [(root / entry).resolve()]
+    while todo:
+        path = todo.pop()
+        if path in seen:
+            continue
+        seen[path] = None
+        for spec in _STATIC_IMPORT.findall(path.read_text(encoding="utf-8")):
+            dep = _resolve(spec, path, root, imports)
+            if dep is not None:
+                todo.append(dep)
+    return ["./" + p.relative_to(root).as_posix() for p in seen]
+
+
+@cache
+def render_index(index_path: str, root: str) -> str:
+    """index.html with its modulepreload placeholder filled in."""
+    html = Path(index_path).read_text(encoding="utf-8")
+    links = "\n    ".join(
+        f'<link rel="modulepreload" href="{url}" />'
+        for url in module_graph(html, Path(root))
+    )
+    return html.replace(PLACEHOLDER, links)

{simview-6.3.0 → simview-6.3.1}/simview/server.py

@@ -21,13 +21,15 @@ import orjson
 import uvicorn
 from fastapi import FastAPI, Request, Response, WebSocket, WebSocketDisconnect
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import FileResponse, JSONResponse
+from fastapi.responses import HTMLResponse, JSONResponse
 from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 from starlette.datastructures import Headers
+from starlette.middleware.gzip import GZipMiddleware
 from starlette.types import Scope
 
 from simview.columnar import columnarize_states, is_columnar, rewrite_blobs
+from simview.preload import render_index
 from simview.utils import dialable_host, find_free_port, read_maybe_gzipped_bytes
 
 logger = logging.getLogger("simview.server")
@@ -348,8 +350,17 @@ class SimViewServer:
         # libs as immutable and everything else short-lived (max-age=60), so
         # index.html's fixed ./static/... paths never need a cache-busting
         # query param.
+        # Gzipped on the fly (three.js alone is ~1.1 MB raw, ~230 KB gzipped);
+        # applied to /static only -- /blob is float data that barely
+        # compresses and is served with Range support.
         self.app.mount(
-            "/static", CacheControlStaticFiles(directory=STATIC), name="static"
+            "/static",
+            GZipMiddleware(
+                CacheControlStaticFiles(directory=STATIC),
+                minimum_size=1024,
+                compresslevel=6,
+            ),
+            name="static",
         )
 
         # Pre-serialized, gzipped payloads for HTTP serving. The parsed dicts are
@@ -521,7 +532,7 @@ class SimViewServer:
     def setup_routes(self):
         @self.app.get("/")
         async def index():
-            return FileResponse(INDEX_HTML, media_type="text/html")
+            return HTMLResponse(render_index(INDEX_HTML, str(Path(STATIC).parent)))
 
         _gzip_headers = {"Content-Encoding": "gzip"}
 

{simview-6.3.0 → simview-6.3.1}/simview/static/js/SimView.js

@@ -6,7 +6,7 @@ import { AnimationController } from "./components/AnimationController.js";
 import { UI_DEFAULT_CONFIG } from "./config.js";
 import { Body } from "./objects/Body.js";
 import { Terrain } from "./objects/Terrain.js";
-import { BatchManager } from "./components/BatchManager.js";
+import { BatchManager, batchCountOf } from "./components/BatchManager.js";
 import { ScalarPlotter } from "./ui/ScalarPlotter.js";
 import { StaticObject } from "./objects/StaticObject.js";
 import { Polyline } from "./objects/Polyline.js";
@@ -109,10 +109,18 @@ export class SimView {
     async loadData() {
         const splash = document.getElementById("loading-splash");
         const base = this.staticBase;
+        // Requests the page started before the modules loaded (see
+        // templates/index.html), each usable once. /states doesn't depend on
+        // the model, so it's requested alongside it instead of after
+        // initFromModel.
+        const prefetched = base ? null : window.__simviewPrefetch;
+        window.__simviewPrefetch = null;
+        const statesFetch = prefetched?.states ?? fetch(base ? `${base}/states.json` : "/states");
+        statesFetch.catch(() => {}); // surfaced where it's awaited below
         try {
             if (splash) splash.innerHTML = "<h1>Fetching model…</h1>";
             console.time("fetch_model");
-            const modelResponse = await fetch(base ? `${base}/model.json` : "/model");
+            const modelResponse = await (prefetched?.model ?? fetch(base ? `${base}/model.json` : "/model"));
             console.timeEnd("fetch_model");
             if (!modelResponse.ok)
                 throw new Error(`Failed to fetch model: ${modelResponse.status} ${modelResponse.statusText}`);
@@ -122,6 +130,13 @@ export class SimView {
             const model = await modelResponse.json();
             console.timeEnd("parse_model");
 
+            // The states side needs only the batch count (not the built
+            // scene), so its parse + blob downloads overlap the model's blobs
+            // and initFromModel instead of queueing behind them.
+            const batchCount = batchCountOf(model);
+            const statesReady = this.fetchStatesPayload(statesFetch, batchCount);
+            statesReady.catch(() => {}); // surfaced where it's awaited below
+
             console.time("fetch_blobs");
             await this.fetchBlobs(model);
             console.timeEnd("fetch_blobs");
@@ -130,15 +145,7 @@ export class SimView {
             this.initFromModel(model);
 
             if (splash) splash.innerHTML = "<h1>Fetching states…</h1>";
-            console.time("fetch_states");
-            const statesResponse = await fetch(base ? `${base}/states.json` : "/states");
-            console.timeEnd("fetch_states");
-            if (!statesResponse.ok)
-                throw new Error(`Failed to fetch states: ${statesResponse.status} ${statesResponse.statusText}`);
-
-            console.time("parse_states");
-            const statesPayload = await statesResponse.json();
-            console.timeEnd("parse_states");
+            const statesPayload = await statesReady;
 
             if (Array.isArray(statesPayload)) {
                 // Legacy wire shape: a plain per-frame array, possibly with
@@ -154,15 +161,9 @@ export class SimView {
             } else if (statesPayload && statesPayload.version === 4) {
                 // Columnar wire shape (see columnar.py::columnarize_states):
                 // a lightweight index plus /blob/... URLs for the actual
-                // whole-trajectory float32 data, fetched in parallel below.
+                // whole-trajectory float32 data, already fetched by
+                // fetchStatesPayload.
                 console.debug(`Received ${statesPayload.times.length} states (columnar)`);
-                // Long trajectories: swap the biggest current-frame-only
-                // fields for windowed readers before the bulk fetch, so they
-                // are never materialized in full (see utils/blobWindow.js).
-                this.windowLargeStateFields(statesPayload);
-                console.time("fetch_state_blobs");
-                await this.fetchBlobs(statesPayload);
-                console.timeEnd("fetch_state_blobs");
                 this.store = new ColumnarStateStore(statesPayload, this.batchManager.simBatches);
                 this.onStoreReady();
             } else {
@@ -182,6 +183,30 @@ export class SimView {
         }
     }
 
+    // Fetches and parses /states and, for the columnar shape, downloads its
+    // blobs (long trajectories' biggest current-frame-only fields are swapped
+    // for windowed readers first, so they are never materialized in full --
+    // see utils/blobWindow.js). Resolves to the payload.
+    async fetchStatesPayload(statesFetch, batchCount) {
+        console.time("fetch_states");
+        const statesResponse = await statesFetch;
+        console.timeEnd("fetch_states");
+        if (!statesResponse.ok)
+            throw new Error(`Failed to fetch states: ${statesResponse.status} ${statesResponse.statusText}`);
+
+        console.time("parse_states");
+        const payload = await statesResponse.json();
+        console.timeEnd("parse_states");
+
+        if (payload && !Array.isArray(payload) && payload.version === 4) {
+            this.windowLargeStateFields(payload, batchCount);
+            console.time("fetch_state_blobs");
+            await this.fetchBlobs(payload);
+            console.timeEnd("fetch_state_blobs");
+        }
+        return payload;
+    }
+
     // Replaces the blob URL of every large, current-frame-only per-body field
     // with a WindowedField, so fetchBlobs skips it and it's read in windows
     // around the playhead instead. Static demo mode is excluded: it serves
@@ -190,10 +215,9 @@ export class SimView {
     // bodyTransform, contacts and the scalars are deliberately untouched --
     // trails, error metrics, the terrain profile and the scalar plots all walk
     // the whole trajectory, so windowing those would just move the cost.
-    windowLargeStateFields(statesPayload) {
+    windowLargeStateFields(statesPayload, batchCount) {
         if (this.staticBase) return;
         const totalFrames = statesPayload.times.length;
-        const batchCount = this.batchManager.simBatches;
         // Overridable so tests can exercise windowing without a fixture big
         // enough to cross the real threshold (same spirit as
         // window.__debugSimView); undefined in normal use.
@@ -435,12 +459,12 @@ export class SimView {
     // Resolves and records position/orientation (and contacts, vectors, ...)
     // history for every frame from `startIndex` to the end of the store, for
     // trails and the error metrics panel. Each frame is materialized
-    // transiently via store.getFrame(i) (not retained) so this works
+    // transiently via store.getTransformFrame(i) (not retained) so this works
     // identically whether the store is legacy or columnar.
     appendBodyHistories(startIndex) {
         if (!this.bodies || this.bodies.size === 0) return;
         for (let s = startIndex; s < this.store.length; s++) {
-            const bodyStates = this.store.getFrame(s).bodies;
+            const bodyStates = this.store.getTransformFrame(s).bodies;
             if (!bodyStates) continue;
             // Resolve off this historical state's own data (not any Body's
             // current/live pose, which reflects whatever frame is currently

{simview-6.3.0 → simview-6.3.1}/simview/static/js/components/BatchManager.js

@@ -8,6 +8,14 @@ import {
     visibleBatchSet,
 } from "../utils/batchVisibility.js";
 
+// The batch count a model declares (1 when absent); also what loadData needs
+// before any BatchManager exists.
+export function batchCountOf(modelData) {
+    return modelData?.simBatches !== undefined
+        ? Math.max(1, parseInt(modelData.simBatches))
+        : 1;
+}
+
 export class BatchManager {
     constructor(app, modelData) {
         this.app = app;
@@ -34,7 +42,7 @@ export class BatchManager {
 
         // Set batch count from model data
         if (modelData.simBatches !== undefined) {
-            this.simBatches = Math.max(1, parseInt(modelData.simBatches));
+            this.simBatches = batchCountOf(modelData);
             console.log(
                 `Initializing with ${this.simBatches} simulation batches`
             );

{simview-6.3.0 → simview-6.3.1}/simview/static/js/components/Scene.js

@@ -16,6 +16,51 @@ export class Scene {
         this.initScene();
         this.minRenderDelay = 1000 / FREQ_CONFIG.scene;
         this.lastRenderTime = Number.NEGATIVE_INFINITY;
+        this.setupInvalidation();
+    }
+
+    // The canvas only needs redrawing when something may have changed.
+    // Mutations are scattered (GUI toggles, panels, data landing), so rather
+    // than hooking each one, any user input or camera move marks the scene
+    // dirty, playback/recording/new frames always render, and an idle
+    // heartbeat repaints anything else (e.g. a Range window landing while
+    // paused) within IDLE_RENDER_MS.
+    static IDLE_RENDER_MS = 250;
+    invalidate() {
+        this.needsRender = true;
+    }
+
+    setupInvalidation() {
+        this.needsRender = true;
+        this._lastFrameIndex = null;
+        const mark = () => this.invalidate();
+        // pointermove only while a button is held: drags orbit/pan the camera.
+        this._onInput = (e) => {
+            if (e.type !== "pointermove" || e.buttons) this.invalidate();
+        };
+        this._inputEvents = [
+            "pointerdown", "pointermove", "pointerup", "wheel",
+            "keydown", "keyup", "input", "change", "click",
+        ];
+        this._inputEvents.forEach((t) =>
+            window.addEventListener(t, this._onInput, { capture: true, passive: true })
+        );
+        this.controls.addEventListener("change", mark);
+    }
+
+    #shouldRender(now) {
+        const ac = this.app.animationController;
+        if (
+            this.needsRender ||
+            ac?.isPlaying ||
+            ac?.isRecording ||
+            ac?.currentStateIndex !== this._lastFrameIndex ||
+            now - this.lastRenderTime >= Scene.IDLE_RENDER_MS
+        ) {
+            this._lastFrameIndex = ac?.currentStateIndex;
+            return true;
+        }
+        return false;
     }
 
     initScene() {
@@ -67,12 +112,17 @@ export class Scene {
             window.removeEventListener("resize", this._onResize);
             this._onResize = null;
         }
+        this._inputEvents?.forEach((t) =>
+            window.removeEventListener(t, this._onInput, { capture: true })
+        );
+        this._inputEvents = null;
         this.controls?.dispose();
         this.renderer?.dispose();
         this.renderer?.domElement?.remove();
     }
 
     #handleWindowResize() {
+        this.invalidate(); // resizing clears the canvas
         this.camera.aspect = window.innerWidth / window.innerHeight;
         this.camera.updateProjectionMatrix();
         this.renderer.setPixelRatio(window.devicePixelRatio);
@@ -139,7 +189,11 @@ export class Scene {
     // and B side by side, shifting the camera by each batch's offset from the
     // active one for its half of the viewport.
     animate(now) {
-        if (now - this.lastRenderTime < this.minRenderDelay) return;
+        // The -1 absorbs rAF timestamp jitter: at 60 Hz the deltas hover
+        // around 16.67 ms and would otherwise drop every other frame.
+        if (now - this.lastRenderTime < this.minRenderDelay - 1) return;
+        if (!this.#shouldRender(now)) return;
+        this.needsRender = false;
 
         if (this.app.uiState && this.app.uiState.splitScreen && this.app.batchManager && this.app.batchManager.simBatches >= 2) {
             const batchA = this.app.uiState.splitBatchA !== undefined ? this.app.uiState.splitBatchA : 0;

{simview-6.3.0 → simview-6.3.1}/simview/static/js/components/StateStore.js

@@ -167,6 +167,25 @@ export class ColumnarStateStore {
         return state;
     }
 
+    // Frame `i` carrying only each body's bodyTransform. For whole-run walks
+    // (trail/error-metric histories) that never read the windowed fields:
+    // getFrame() would start a Range fetch for every window of every one.
+    getTransformFrame(i) {
+        const bodies = [];
+        for (const body of this._bodies) {
+            const value = body.fields.bodyTransform;
+            const entry = { name: body.name };
+            if (value && typeof value.rowsAt === "function") {
+                const rows = value.rowsAt(i);
+                if (rows) entry.bodyTransform = rows;
+            } else if (value) {
+                entry.bodyTransform = this._sliceField(value, COLUMNAR_FIELD_WIDTHS.bodyTransform, i);
+            }
+            bodies.push(entry);
+        }
+        return { time: this.times[i], bodies };
+    }
+
     // Per-batch series for the scalar plotter: one per-frame value array per
     // batch, indexed like `times`.
     // `simBatches` is accepted (and ignored) for API parity with
@@ -217,6 +236,10 @@ export class LegacyStateStore {
         return this._states[i];
     }
 
+    getTransformFrame(i) {
+        return this._states[i];
+    }
+
     // `simBatches` is passed explicitly: the legacy shape records no batch
     // count of its own (callers use app.batchManager.simBatches).
     getScalarSeries(name, simBatches) {

{simview-6.3.0 → simview-6.3.1}/simview/static/js/objects/Terrain.js

@@ -4,6 +4,12 @@ import { colormapLUT, getCallableFromColorMapName } from "./colormap.js";
 import { toFlatFloat32Array } from "./utils.js";
 
 export class Terrain {
+    // Per-batch normals field and the built-once arrow template of a
+    // singleton terrain; the arrows themselves are built lazily, see
+    // #ensureNormals.
+    #normals = null;
+    #singletonNormals = null;
+
     constructor(terrainData, app) {
         this.app = app; // Store reference to app for accessing batch manager
         this.bounds = terrainData.bounds;
@@ -18,6 +24,7 @@ export class Terrain {
         this.#initEmbeddingData(terrainData.embeddingData);
 
         const normals = this.#normalizeVectorField(terrainData.normals, 3);
+        this.#normals = normals;
 
         this.#createVisualRepresentations(this.heightData, normals);
     }
@@ -197,7 +204,6 @@ export class Terrain {
 
         let singletonSurfaceGeometry = null;
         let singletonWireframeGeometry = null;
-        let singletonNormals = null;
 
         if (this.isSingleton) {
             singletonSurfaceGeometry = this.#createSurfaceGeometryFromHeightData(
@@ -206,10 +212,6 @@ export class Terrain {
                 normals?.[0]
             );
             singletonWireframeGeometry = this.#createWireframeGeometry(singletonSurfaceGeometry);
-            singletonNormals = this.#createNormalVectors(
-                heightData[0],
-                normals?.[0]
-            );
         }
 
         // Create geometry for each batch
@@ -240,11 +242,12 @@ export class Terrain {
             wireframeMesh.raycast = () => {};
             batchGroup.add(wireframeMesh);
 
-            const surfaceNormals = this.isSingleton
-                ? singletonNormals.clone()
-                : this.#createNormalVectors(heightData[i], normals?.[i]);
-
+            // Filled on first use: 121 ArrowHelpers (3 objects each) per
+            // batch made up ~99% of a 512-env scene while hidden.
+            const surfaceNormals = new THREE.Group();
             surfaceNormals.name = "normals";
+            surfaceNormals.visible =
+                this.app.uiState.terrainVisualizationModes.normals || false;
             batchGroup.add(surfaceNormals);
 
             for (const [key, value] of Object.entries(
@@ -270,12 +273,35 @@ export class Terrain {
     refreshBatchVisibility() {
         const batchManager = this.app.batchManager;
         if (!batchManager?.isBatchVisible || !this.group) return;
+        const showNormals = this.app.uiState.terrainVisualizationModes?.normals;
         for (let i = 0; i < batchManager.simBatches; i++) {
-            const batchGroup = this.group.getObjectByName(`batch${i}`);
-            if (batchGroup) batchGroup.visible = batchManager.isBatchVisible(i);
+            // group.children[i] is batch i (built in order); getObjectByName
+            // searched every earlier batch's whole subtree, O(n^2) overall.
+            const batchGroup = this.group.children[i];
+            if (!batchGroup) continue;
+            batchGroup.visible = batchManager.isBatchVisible(i);
+            if (showNormals && batchGroup.visible) this.#ensureNormals(i);
         }
     }
 
+    // Builds batch i's normal arrows the first time they're wanted.
+    #ensureNormals(i) {
+        const target = this.group.children[i]?.getObjectByName("normals");
+        if (!target || target.userData.built || !this.#normals) return;
+        target.userData.built = true;
+        let source;
+        if (this.isSingleton) {
+            this.#singletonNormals ??= this.#createNormalVectors(
+                this.heightData[0],
+                this.#normals[0]
+            );
+            source = this.#singletonNormals.clone();
+        } else {
+            source = this.#createNormalVectors(this.heightData[i], this.#normals[i]);
+        }
+        target.add(...source.children);
+    }
+
     // Normalize a value into [0, 1] against an explicit [min, max] range.
     // Falls back to [0, 1] clamping when the range is missing or degenerate.
     #normalizeToRange(value, min, max) {
@@ -489,12 +515,15 @@ export class Terrain {
 
     // Shows/hides a named sub-object (surface/wireframe/normals) in every batch group.
     toggleVisualization(type, visible) {
-        for (const batchGroup of this.group.children) {
+        const batchManager = this.app.batchManager;
+        this.group.children.forEach((batchGroup, i) => {
             const object = batchGroup.getObjectByName(type);
-            if (object) {
-                object.visible = visible;
+            if (!object) return;
+            object.visible = visible;
+            if (type === "normals" && visible && (batchManager?.isBatchVisible?.(i) ?? true)) {
+                this.#ensureNormals(i);
             }
-        }
+        });
     }
 
     // Returns the per-batch data array for a diff layer name ("height", or
@@ -671,7 +700,7 @@ export class Terrain {
         const batchesToUpdate = this.isSingleton ? 1 : this.app.batchManager.simBatches;
 
         for (let i = 0; i < batchesToUpdate; i++) {
-            const batchGroup = this.group.getObjectByName(`batch${i}`);
+            const batchGroup = this.group.children[i];
             const surfaceMesh = batchGroup.getObjectByName("surface");
             const geometry = surfaceMesh.geometry;
             this.#updateSurfaceColor(i, geometry, callableColormap);
@@ -684,7 +713,7 @@ export class Terrain {
         const batchesToUpdate = this.isSingleton ? 1 : this.app.batchManager.simBatches;
 
         for (let i = 0; i < batchesToUpdate; i++) {
-            const batchGroup = this.group.getObjectByName(`batch${i}`);
+            const batchGroup = this.group.children[i];
             const surfaceMesh = batchGroup.getObjectByName("surface");
             const geometry = surfaceMesh.geometry;
             this.#updateSurfaceColor(i, geometry, callableColormap);

{simview-6.3.0 → simview-6.3.1}/simview/templates/index.html

@@ -41,6 +41,17 @@
       }
     </script>
 
+    <!-- Start the model and states requests now rather than once the ES-module
+         graph has loaded, so they overlap it (SimView.loadData consumes
+         these). Skipped for the serverless viewer (#data=...), which has no
+         /model to ask. -->
+    <script>
+      if (/^https?:/.test(location.protocol) && !/[#&]data=/.test(location.hash) && !window.__simviewStaticBase) {
+        const quiet = (p) => (p.catch(() => {}), p);
+        window.__simviewPrefetch = { model: quiet(fetch("/model")), states: quiet(fetch("/states")) };
+      }
+    </script>
+    <!-- @modulepreload -->
     <script type="module" src="./static/js/main.js"></script>
     <script>
       window.onerror = function(msg, url, line, col, error) {

{simview-6.3.0 → simview-6.3.1/simview.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: simview
-Version: 6.3.0
+Version: 6.3.1
 Summary: THREE.js-based simulation visualization tool
 Author-email: Jan Vlk <vlkjan6@fel.cvut.cz>, Ales Kucera <kuceral4@fel.cvut.cz>, David Korcak <david.korcak@gmail.com>
 License-Expression: BSD-3-Clause

{simview-6.3.0 → simview-6.3.1}/simview.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ simview/launcher.py
 simview/live.py
 simview/merge.py
 simview/model.py
+simview/preload.py
 simview/py.typed
 simview/remote.py
 simview/render.py
@@ -95,6 +96,7 @@ tests/test_launcher.py
 tests/test_live.py
 tests/test_merge.py
 tests/test_pointcloud_features.py
+tests/test_preload.py
 tests/test_remote.py
 tests/test_roundtrip.py
 tests/test_scene.py

simview-6.3.1/tests/test_preload.py

@@ -0,0 +1,25 @@
+from pathlib import Path
+
+from simview.preload import PLACEHOLDER, module_graph, render_index
+from simview.server import INDEX_HTML, STATIC
+
+ROOT = Path(STATIC).parent
+
+
+def test_module_graph_reaches_every_viewer_module():
+    graph = set(module_graph(Path(INDEX_HTML).read_text(encoding="utf-8"), ROOT))
+    assert "./static/js/main.js" in graph
+    assert "./static/lib/three-0.174.0/three.core.js" in graph  # via the import map
+    on_disk = {
+        "./" + p.relative_to(ROOT).as_posix()
+        for p in (ROOT / "static" / "js").rglob("*.js")
+    }
+    # A module the preload walk misses just loads late, but one that's on disk
+    # and unreachable is probably an import form the walk can't read.
+    assert on_disk <= graph
+
+
+def test_render_index_fills_the_placeholder():
+    html = render_index(INDEX_HTML, str(ROOT))
+    assert PLACEHOLDER not in html
+    assert '<link rel="modulepreload" href="./static/js/SimView.js" />' in html