command now spins up the main UI plus the EM (:8701) and QLBM (:8702) workers without binding conflicts

Dockerfile

@@ -22,7 +22,7 @@ ENV DEBIAN_FRONTEND=noninteractive \
 # *** UPDATED this section to use current package names (e.g., libgl1, libegl1) ***
 #
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential cmake wget xvfb \
+  build-essential cmake wget xvfb nginx \
     libosmesa6 libosmesa6-dev \
     libgl1 libgl1-mesa-dev \
     libegl1 libegl1-mesa-dev \
@@ -47,10 +47,22 @@ RUN python3 -m pip install --upgrade pip setuptools wheel \
 # This copies app.py, delta_impulse_generator.py, etc.
 # We set the owner to our new 'user'.
 COPY --chown=user:user . .
+COPY docker/nginx.conf /etc/nginx/nginx.conf
 
 # 7. Switch to the non-root user
 USER user
 
+# Default runtime configuration for multiprocess layout
+ENV OMP_NUM_THREADS=1 \
+  APP_HOST=127.0.0.1 \
+  APP_PORT=8700 \
+  EM_APP_PORT=8701 \
+  QLBM_APP_PORT=8702 \
+  EM_HOST=127.0.0.1 \
+  QLBM_HOST=127.0.0.1 \
+  EM_IFRAME_SRC=/em/ \
+  QLBM_IFRAME_SRC=/qlbm/
+
 # 8. Expose the port the app will run on
 EXPOSE 7860
 
@@ -64,6 +76,6 @@ HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
 # b) 'exec' runs your app. Using 'exec' is important as it makes the Python
 #    process the main one, which properly handles signals (like stopping the container).
 #    '--host 0.0.0.0' is ESSENTIAL to make the server accessible from outside the container.
-CMD ["sh", "-c", "Xvfb :99 -screen 0 1024x768x24 >/dev/null 2>&1 & exec python3 app.py --server --host 0.0.0.0 --port ${PORT:-7860}"]
+CMD ["sh", "-c", "Xvfb :99 -screen 0 1024x768x24 >/dev/null 2>&1 & nginx && exec python3 app.py --server --host ${APP_HOST:-127.0.0.1} --port ${APP_PORT:-8700}"]
 
 

README.md

@@ -8,4 +8,27 @@ hf_oauth: false
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+Check out the configuration reference at <https://huggingface.co/docs/hub/spaces-config-reference>
+
+## Running locally
+
+```powershell
+python app.py
+```
+
+By default the UI listens on `http://127.0.0.1:7860`. The EM and QLBM pages start in the
+background and expose themselves on `http://127.0.0.1:8701` and `http://127.0.0.1:8702`.
+
+## Single-port / Hugging Face deployment
+
+Spaces (and other single-port hosts) now work by running everything behind an internal
+reverse proxy. Set the following environment variables (the Dockerfile already does this):
+
+| Variable | Purpose |
+| --- | --- |
+| `APP_HOST` / `APP_PORT` | Internal address that `app.py` binds to (defaults: `127.0.0.1:8700`). |
+| `EM_APP_PORT` / `QLBM_APP_PORT` | Ports for the EM and QLBM subprocesses (defaults: `8701` and `8702`). |
+| `EM_IFRAME_SRC` / `QLBM_IFRAME_SRC` | Public paths served by the proxy (e.g., `/em/` and `/qlbm/`). |
+
+The bundled `docker/nginx.conf` proxies incoming traffic on `${PORT:-7860}` to the
+individual services so the browser never tries to contact `127.0.0.1` directly.

app.py

@@ -88,8 +88,9 @@ with SinglePageLayout(server) as layout:
                 trame_html.Div(f"QLBM embed failed: {e}", style="padding:8px;color:#b00020;")
 
 if __name__ == "__main__":
-    # For Hugging Face, use the PORT env var and listen on 0.0.0.0
-    port = int(os.environ.get("PORT", 7860))
-    server.start(host="0.0.0.0", port=port, open_browser=False)
+    # Allow reverse-proxy setups to pin the internal host/port independently from the public PORT
+    port = int(os.environ.get("APP_PORT") or os.environ.get("PORT", 7860))
+    host = os.environ.get("APP_HOST", "0.0.0.0")
+    server.start(host=host, port=port, open_browser=False)
 
 

docker/nginx.conf

@@ -0,0 +1,71 @@
+user user;
+worker_processes auto;
+pid /tmp/nginx.pid;
+error_log /tmp/nginx.error.log warn;
+access_log /tmp/nginx.access.log;
+
+events {
+    worker_connections 1024;
+}
+
+http {
+    include       /etc/nginx/mime.types;
+    default_type  application/octet-stream;
+    sendfile        on;
+    keepalive_timeout  65;
+
+    map $http_upgrade $connection_upgrade {
+        default upgrade;
+        ''      close;
+    }
+
+    upstream app_root {
+        server 127.0.0.1:8700;
+    }
+
+    upstream app_em {
+        server 127.0.0.1:8701;
+    }
+
+    upstream app_qlbm {
+        server 127.0.0.1:8702;
+    }
+
+    server {
+        listen 7860;
+        server_name _;
+
+        location /em/ {
+            proxy_pass http://app_em/;
+            proxy_http_version 1.1;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection $connection_upgrade;
+        }
+
+        location /qlbm/ {
+            proxy_pass http://app_qlbm/;
+            proxy_http_version 1.1;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection $connection_upgrade;
+        }
+
+        location / {
+            proxy_pass http://app_root/;
+            proxy_http_version 1.1;
+            proxy_set_header Host $host;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+            proxy_set_header X-Forwarded-Proto $scheme;
+            proxy_set_header Upgrade $http_upgrade;
+            proxy_set_header Connection $connection_upgrade;
+        }
+    }
+}

em.ipynb

@@ -1,254 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "id": "fe68f8a9",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Available backends: [<qiskit_ionq.ionq_backend.IonQSimulatorBackend object at 0x7f91854ff520>, <qiskit_ionq.ionq_backend.IonQQPUBackend object at 0x7f91851f8d90>]\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/cudaq/.local/lib/python3.10/site-packages/qiskit_ionq/ionq_backend.py:127: IonQTranspileLevelWarning: Transpiler default optimization_level=2. IonQ (QIS) recommends 0-1 to avoid aggressive re-synthesis; use transpile(..., optimization_level=1).\n",
-      "  warn_bad_transpile_level()\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit import QuantumCircuit\n",
-    "from qiskit_ionq import IonQProvider\n",
-    "import os\n",
-    "my_api_key = os.getenv(\"IONQ_API_KEY\")\n",
-    "# # provider = IonQProvider()\n",
-    "\n",
-    "api_token = \"SgUkiDq1r2bVEadyiUfvtuxQ03Qci6UW\"\n",
-    "provider = IonQProvider(api_token)\n",
-    "\n",
-    "\n",
-    "backends = provider.backends()\n",
-    "print(\"Available backends:\", backends)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "id": "6b2b90ef",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/cudaq/.local/lib/python3.10/site-packages/qiskit_ionq/ionq_backend.py:127: IonQTranspileLevelWarning: Transpiler default optimization_level=2. IonQ (QIS) recommends 0-1 to avoid aggressive re-synthesis; use transpile(..., optimization_level=1).\n",
-      "  warn_bad_transpile_level()\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Expectation values: [1.55664062]\n"
-     ]
-    }
-   ],
-   "source": [
-    "from qiskit import QuantumCircuit\n",
-    "from qiskit_ionq import IonQProvider\n",
-    "\n",
-    "backend = provider.get_backend(\"simulator\")\n",
-    "\n",
-    "from qiskit.circuit.library import real_amplitudes\n",
-    "from qiskit.quantum_info import SparsePauliOp\n",
-    "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
-    "from qiskit_ibm_runtime import QiskitRuntimeService, EstimatorV2 as Estimator\n",
-    "from qiskit.primitives import StatevectorEstimator\n",
-    "\n",
-    "# service = QiskitRuntimeService()\n",
-    "# backend = service.least_busy(operational=True, simulator=False)\n",
-    " \n",
-    "psi = real_amplitudes(num_qubits=2, reps=2)\n",
-    "hamiltonian = SparsePauliOp.from_list([(\"II\", 1), (\"IZ\", 2), (\"XI\", 3)])\n",
-    "theta = [0, 1, 1, 2, 3, 5]\n",
-    " \n",
-    "pm = generate_preset_pass_manager(backend=backend, optimization_level=1)\n",
-    "isa_psi = pm.run(psi)\n",
-    "isa_observables = hamiltonian.apply_layout(isa_psi.layout)\n",
-    " \n",
-    "estimator = Estimator(mode=backend)\n",
-    " \n",
-    "# calculate [ <psi(theta)|hamiltonian|psi(theta)> ]\n",
-    "job = estimator.run([(isa_psi, isa_observables, [theta])])\n",
-    "pub_result = job.result()[0]\n",
-    "print(f\"Expectation values: {pub_result.data.evs}\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "id": "4147b18a",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Expectation values: [1.55555728]\n"
-     ]
-    }
-   ],
-   "source": [
-    "qiskit_estimator = StatevectorEstimator()\n",
-    "job2 = qiskit_estimator.run([(psi, hamiltonian, [theta])])\n",
-    "pub_result = job2.result()[0]\n",
-    "print(f\"Expectation values: {pub_result.data.evs}\")                             "
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "109a7251",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def run_sim_ionq(nx, na, R, initial_state, T, snapshot_dt=None, stop_check=None, progress_callback=None):\n",
-    "    \"\"\"\n",
-    "    Runs the quantum simulation for electromagnetic scattering with fixed dt=0.1.\n",
-    "    Captures frames only at user-defined snapshot times: [0, Δt, 2Δt, ..., ≤ T_eff],\n",
-    "    always including t=0 and the final solver-aligned T (T_eff = floor(T/dt)*dt).\n",
-    "\n",
-    "    Returns:\n",
-    "        frames (np.ndarray), snapshot_times (np.ndarray)\n",
-    "    \"\"\"\n",
-    "    dt = 0.1\n",
-    "    # Validate total time and compute solver-aligned end time\n",
-    "    try:\n",
-    "        T_val = float(T)\n",
-    "    except Exception:\n",
-    "        return np.array([]), np.array([])\n",
-    "    if T_val <= 0:\n",
-    "        return np.array([]), np.array([])\n",
-    "\n",
-    "    steps = int(np.floor(T_val / dt))\n",
-    "    if steps <= 0:\n",
-    "        return np.array([]), np.array([])\n",
-    "    T_eff = steps * dt\n",
-    "\n",
-    "    # Determine snapshot Δt on solver grid\n",
-    "    tol = 1e-12\n",
-    "    if snapshot_dt is None:\n",
-    "        snapshot_dt_val = dt\n",
-    "    else:\n",
-    "        try:\n",
-    "            snapshot_dt_val = float(snapshot_dt)\n",
-    "        except Exception:\n",
-    "            snapshot_dt_val = dt\n",
-    "    if snapshot_dt_val < dt - tol:\n",
-    "        snapshot_dt_val = dt\n",
-    "    k = max(1, int(round(snapshot_dt_val / dt)))\n",
-    "    snapshot_dt_eff = k * dt\n",
-    "\n",
-    "    # Build requested snapshot times on solver grid\n",
-    "    target_times = [0.0]\n",
-    "    t = 0.0\n",
-    "    while t + snapshot_dt_eff <= T_eff + tol:\n",
-    "        t = round(t + snapshot_dt_eff, 12)\n",
-    "        if t <= T_eff + tol:\n",
-    "            target_times.append(min(t, T_eff))\n",
-    "    if abs(target_times[-1] - T_eff) > tol:\n",
-    "        target_times.append(T_eff)\n",
-    "\n",
-    "    # Setup circuit\n",
-    "    nq = int(np.ceil(np.log2(nx)))\n",
-    "    dp = 2 * R * np.pi / 2 ** na\n",
-    "    p = np.arange(-R * np.pi, R * np.pi, step=dp)\n",
-    "    fp = np.exp(-np.abs(p))\n",
-    "    system, ancilla = QuantumRegister(2 * nq + 2), QuantumRegister(na)\n",
-    "    qc = QuantumCircuit(system, ancilla)\n",
-    "    qc.append(StatePreparation(initial_state), system)\n",
-    "    qc.append(StatePreparation(fp / np.linalg.norm(fp)), ancilla)\n",
-    "    expA1 = V1(nx, dt).to_gate()\n",
-    "    expA2 = V2(nx, dt)\n",
-    "\n",
-    "    frames = []\n",
-    "    \n",
-    "     # Run the circuit on IonQ's platform:\n",
-    "    job = simulator_backend.run(qc, shots=10000)\n",
-    "\n",
-    "    # Print the counts\n",
-    "    # print(job.get_counts())\n",
-    "    # # Capture initial frame at t=0\n",
-    "    # sv0 = np.real(Statevector(qc)).reshape(2 ** na, 2 ** (2 * nq + 2))\n",
-    "    # frames.append(sv0[2 ** (na - 1)])\n",
-    "    # next_idx = 1  # next target_times index to capture\n",
-    "\n",
-    "    # for i in range(steps):\n",
-    "    #     if stop_check and stop_check():\n",
-    "    #         print(f\"Simulation interrupted at step {i}/{steps}\")\n",
-    "    #         break\n",
-    "    #     # One solver step\n",
-    "    #     qc.append(QFTGate(na), ancilla)\n",
-    "    #     qc.x(ancilla[-1])\n",
-    "    #     for j in range(na - 1):\n",
-    "    #         qc.append(expA1.control().repeat(2 ** j), [ancilla[j]] + system[:])\n",
-    "    #     qc.append(expA1.inverse().control(ctrl_state=\"0\").repeat(2 ** (na - 1)), [ancilla[na - 1]] + system[:])\n",
-    "    #     qc.append(expA2, system[:])\n",
-    "    #     qc.x(ancilla[-1])\n",
-    "    #     qc.append(QFTGate(na).inverse(), ancilla)\n",
-    "\n",
-    "    #     current_time = (i + 1) * dt\n",
-    "    #     if next_idx < len(target_times) and abs(current_time - target_times[next_idx]) <= tol:\n",
-    "    #         u = np.real(Statevector(qc)).reshape(2 ** na, 2 ** (2 * nq + 2))\n",
-    "    #         frames.append(u[2 ** (na - 1)])\n",
-    "    #         next_idx += 1\n",
-    "\n",
-    "    #     if progress_callback:\n",
-    "    #         try:\n",
-    "    #             progress = ((i + 1) / steps) * 100\n",
-    "    #             progress_callback(progress)\n",
-    "    #         except Exception:\n",
-    "    #             pass\n",
-    "\n",
-    "    # if progress_callback:\n",
-    "    #     try:\n",
-    "    #         progress_callback(100.0)\n",
-    "    #     except Exception:\n",
-    "    #         pass\n",
-    "\n",
-    "    # # Ensure snapshot_times align with number of captured frames (covers early stop)\n",
-    "    # frames_arr = np.asarray(frames)\n",
-    "    # times_arr = np.asarray(target_times[: len(frames_arr)])\n",
-    "    # return frames_arr, times_arr\n",
-    "\n"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.10.12"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
-}

em_trame.py

@@ -2557,6 +2557,7 @@ def on_qpu_plot_filter_change(qpu_plot_filter, **kwargs):
 
 # --- Inline embedding support for single-script startup ---
 _em_started = False
+_em_iframe_src = os.environ.get("EM_IFRAME_SRC", "").strip()
 
 def _ensure_em_server_started():
     global _em_started
@@ -2599,11 +2600,12 @@ def build(host_server):
     _ensure_em_server_started()
     h_state, _ = host_server.state, host_server.controller
     default_port = os.environ.get("EM_APP_PORT", os.environ.get("PORT_EM", "8701"))
+    iframe_src = _em_iframe_src or f"http://localhost:{default_port}/"
     if not getattr(h_state, "em_iframe_src", None):
-        h_state.em_iframe_src = f"http://localhost:{default_port}/"
+        h_state.em_iframe_src = iframe_src
     with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
         trame_html.Iframe(
-            src=("em_iframe_src", f"http://localhost:{default_port}/"),
+            src=("em_iframe_src", iframe_src),
             style="border:0; width:100%; height: calc(100vh - 64px);",
         )
         # Optional debug note if background start has issues

pages/em_page.py

@@ -8,6 +8,7 @@ import atexit
 # Keep a single child process for the EM app
 _em_proc = None
 _EM_HOST = os.environ.get("EM_HOST", "127.0.0.1")
+_EM_IFRAME_SRC = os.environ.get("EM_IFRAME_SRC", "").strip()
 
 
 def _kill_em_process():
@@ -37,6 +38,9 @@ def _ensure_em_process_started():
     base_dir = os.path.dirname(os.path.dirname(__file__))
     em_path = os.path.join(base_dir, "em_trame.py")
     env = os.environ.copy()
+    # Prevent hosted platforms from forcing the subprocess to bind to $PORT
+    env.pop("PORT", None)
+    env.pop("HF_PORT", None)
     # Port used by iframe
     env.setdefault("EM_APP_PORT", env.get("PORT_EM", "8701"))
     env.setdefault("EM_HOST", _EM_HOST)
@@ -54,9 +58,10 @@ def build(server):
     _ensure_em_process_started()
     port = os.environ.get("EM_APP_PORT", os.environ.get("PORT_EM", "8701"))
     host = os.environ.get("EM_HOST", _EM_HOST)
+    iframe_src = _EM_IFRAME_SRC or f"http://{host}:{port}/"
     with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
         trame_html.Iframe(
-            src=("em_iframe_src", f"http://{host}:{port}/"),
+            src=("em_iframe_src", iframe_src),
             style="border:0; width:100%; height: calc(100vh - 64px);",
         )
         trame_html.Div(

pages/qlbm_page.py

@@ -13,6 +13,7 @@ from trame.widgets import html as trame_html
 
 _qlbm_proc = None
 _QLBM_HOST = os.environ.get("QLBM_HOST", "127.0.0.1")
+_QLBM_IFRAME_SRC = os.environ.get("QLBM_IFRAME_SRC", "").strip()
 
 
 def _kill_qlbm_process():
@@ -37,6 +38,8 @@ def _ensure_qlbm_process_started():
     base_dir = os.path.dirname(os.path.dirname(__file__))
     qlbm_path = os.path.join(base_dir, "qlbm.py")
     env = os.environ.copy()
+    env.pop("PORT", None)
+    env.pop("HF_PORT", None)
     env.setdefault("QLBM_APP_PORT", env.get("PORT_QLBM", "8702"))
     env.setdefault("QLBM_HOST", _QLBM_HOST)
     py = sys.executable or "python"
@@ -57,9 +60,10 @@ def build(server):  # signature matches app.py expectation
     _ensure_qlbm_process_started()
     port = os.environ.get("QLBM_APP_PORT", os.environ.get("PORT_QLBM", "8702"))
     host = os.environ.get("QLBM_HOST", _QLBM_HOST)
+    iframe_src = _QLBM_IFRAME_SRC or f"http://{host}:{port}/"
     with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
         trame_html.Iframe(
-            src=("qlbm_iframe_src", f"http://{host}:{port}/"),
+            src=("qlbm_iframe_src", iframe_src),
             style="border:0;width:100%;height:100%;min-height:0;",
         )
         trame_html.Div(

qlbm.py

@@ -613,6 +613,7 @@ ctrl.sim_plot_update = sim_fig.update
 # Embedding helper
 # --------------------------------------------------------------------------------------
 _started = False
+_iframe_src = os.environ.get("QLBM_IFRAME_SRC", "").strip()
 
 def build(host_server):
 	"""Embed this app into another Trame server via an iframe, auto-starting its own server."""
@@ -629,40 +630,11 @@ def build(host_server):
 		_started = True
 	h_state = host_server.state
 	default_port = os.environ.get("TRAME3D_PORT", "8811")
+	iframe_src = _iframe_src or f"http://localhost:{default_port}/"
 	if not getattr(h_state, "trame3d_iframe_src", None):
-		h_state.trame3d_iframe_src = f"http://localhost:{default_port}/"
+		h_state.trame3d_iframe_src = iframe_src
 	with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
-		trame_html.Iframe(src=("trame3d_iframe_src", f"http://localhost:{default_port}/"), style="border:0; width:100%; height: calc(100vh - 64px);")
-		trame_html.Div("If the 3D QLBM view is blank, wait a few seconds or verify TRAME3D_PORT.", style="color: rgba(0,0,0,.6); padding: 6px;")
-
-# Controller hooks for plot updates
-ctrl.qubit_plot_update = qubit_fig.update
-ctrl.sim_plot_update = sim_fig.update
-
-# --------------------------------------------------------------------------------------
-# Embedding helper
-# --------------------------------------------------------------------------------------
-_started = False
-
-def build(host_server):
-	"""Embed this app into another Trame server via an iframe, auto-starting its own server."""
-	global _started
-	if not _started:
-		import threading
-		def _run():
-			try:
-				port = int(os.environ.get("TRAME3D_PORT", "8811"))
-				server.start(host="0.0.0.0", port=port, open_browser=False)
-			except Exception as e:
-				print(f"trame3d server failed to start: {e}")
-		threading.Thread(target=_run, daemon=True).start()
-		_started = True
-	h_state = host_server.state
-	default_port = os.environ.get("TRAME3D_PORT", "8811")
-	if not getattr(h_state, "trame3d_iframe_src", None):
-		h_state.trame3d_iframe_src = f"http://localhost:{default_port}/"
-	with vuetify3.VContainer(fluid=True, classes="pa-0 fill-height"):
-		trame_html.Iframe(src=("trame3d_iframe_src", f"http://localhost:{default_port}/"), style="border:0; width:100%; height: calc(100vh - 64px);")
+		trame_html.Iframe(src=("trame3d_iframe_src", iframe_src), style="border:0; width:100%; height: calc(100vh - 64px);")
 		trame_html.Div("If the 3D QLBM view is blank, wait a few seconds or verify TRAME3D_PORT.", style="color: rgba(0,0,0,.6); padding: 6px;")
 
 # --- Entry point ---