arrayview 0.41.1__tar.gz → 0.42.1__tar.gz

{arrayview-0.41.1 → arrayview-0.42.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: arrayview
-Version: 0.41.1
+Version: 0.42.1
 Summary: Fast multi-dimensional array viewer
 Project-URL: Home, https://github.com/oscarvanderheide/arrayview
 Project-URL: Source, https://github.com/oscarvanderheide/arrayview

{arrayview-0.41.1 → arrayview-0.42.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "arrayview"
-version = "0.41.1"
+version = "0.42.1"
 description = "Fast multi-dimensional array viewer"
 readme = { file = "README.md", content-type = "text/markdown" }
 requires-python = ">=3.12"

{arrayview-0.41.1 → arrayview-0.42.1}/src/arrayview/_diagnostics.py

@@ -76,7 +76,11 @@ _DIAGNOSES: list[tuple[str, str, str, str]] = [
      _RETRY),
 
     # ── Timing — slow, not broken ─────────────────────────────────────────
-    (r"did not render a frame|did not become ready|did not start the viewer",
+    (r"did not start the viewer script", ACTION,
+     "VS Code opened an integrated-browser tab, but the tab did not navigate "
+     "to the ArrayView page.",
+     _RETRY + "  If it repeats, reload the VS Code window."),
+    (r"did not render a frame|did not become ready",
      ACTION,
      "The viewer opened but showed no frame before the deadline — usually a "
      "slow first load.",

{arrayview-0.41.1 → arrayview-0.42.1}/src/arrayview/_launch_trace.py

@@ -1,8 +1,10 @@
 """Best-effort, opt-in launch event tracing.
 
 The trace is deliberately dependency-free and inert unless
-``ARRAYVIEW_LAUNCH_TRACE`` names an absolute JSONL file.  Launch behavior must
-never depend on a trace write succeeding.
+``ARRAYVIEW_LAUNCH_TRACE`` names an absolute JSONL file.  Integrated-browser
+route tracing can also be enabled explicitly with
+``~/.arrayview/enable-launch-trace``.  Launch behavior must never depend on a
+trace write succeeding.
 """
 
 from __future__ import annotations
@@ -20,6 +22,8 @@ TRACE_PATH_ENV = "ARRAYVIEW_LAUNCH_TRACE"
 TRACE_ID_ENV = "ARRAYVIEW_LAUNCH_ID"
 TRACE_ROLE_ENV = "ARRAYVIEW_LAUNCH_ROLE"
 TRACE_SCHEMA = 1
+TRACE_MARKER_NAME = "enable-launch-trace"
+TRACE_DEFAULT_NAME = "launch-trace.jsonl"
 _MAX_EVENT_BYTES = 4096
 
 _lock = threading.Lock()
@@ -70,6 +74,56 @@ def trace_tag(value: object) -> str:
     return hashlib.sha256(str(value).encode("utf-8", "replace")).hexdigest()[:12]
 
 
+def configure_route_launch_trace() -> bool:
+    """Enable route tracing from an explicit environment or marker opt-in.
+
+    Route handlers call this directly so an already-running server can notice
+    the marker even when its process environment never contained the trace
+    variable.  An explicit environment value always wins, including an invalid
+    relative value, which keeps the normal trace contract unambiguous.
+    """
+    try:
+        explicit = os.environ.get(TRACE_PATH_ENV)
+        if explicit is not None:
+            if not explicit or not Path(explicit).is_absolute():
+                return False
+            if _path != explicit:
+                configure_launch_trace()
+            return _path == explicit
+
+        trace_dir = Path.home() / ".arrayview"
+        if not (trace_dir / TRACE_MARKER_NAME).is_file():
+            return False
+        candidate = str(trace_dir / TRACE_DEFAULT_NAME)
+        if _path != candidate:
+            configure_launch_trace(path=candidate, role="server")
+        return _path == candidate
+    except Exception:
+        return False
+
+
+def emit_route_launch_event(
+    event: str,
+    *,
+    navigation_key: str,
+    tab_key: str | None = None,
+    **attrs: object,
+) -> None:
+    """Emit a route event without exposing private route credentials."""
+    try:
+        if not configure_route_launch_trace():
+            return
+        safe_attrs = {
+            "navigation_key_tag": trace_tag(navigation_key),
+            **attrs,
+        }
+        if tab_key is not None:
+            safe_attrs["tab_key_tag"] = trace_tag(tab_key)
+        emit_launch_event(event, **safe_attrs)
+    except Exception:
+        return
+
+
 def emit_launch_event(event: str, **attrs: object) -> None:
     """Append one compact event, swallowing every tracing-related failure."""
     try:
@@ -113,10 +167,13 @@ def _ensure_environment_configuration() -> None:
 
 __all__ = [
     "TRACE_ID_ENV",
+    "TRACE_MARKER_NAME",
     "TRACE_PATH_ENV",
     "TRACE_ROLE_ENV",
     "configure_launch_trace",
+    "configure_route_launch_trace",
     "emit_launch_event",
+    "emit_route_launch_event",
     "trace_child_environment",
     "trace_tag",
 ]

{arrayview-0.41.1 → arrayview-0.42.1}/src/arrayview/_launcher.py

@@ -5266,15 +5266,56 @@ def _handle_management_command(argv: list[str]) -> bool:
                 ),
             }
         )
+    from arrayview._platform import _in_vscode_terminal  # noqa: PLC0415
+    from arrayview._vscode_extension import (  # noqa: PLC0415
+        _describe_window,
+        _opener_version_report,
+    )
+
+    versions = _opener_version_report()
+    if versions["state"] in {"window_older", "window_unversioned"}:
+        remediation.append(
+            {
+                "code": "opener_version_skew",
+                "message": (
+                    "Reload this VS Code window to run opener "
+                    f"v{versions['bundled_opener']}."
+                ),
+            }
+        )
     report = {
         "snapshot": snapshot_dict,
         "plan": plan.to_dict(),
         "instances": rows,
         "remediation": remediation,
+        "versions": versions,
     }
     if args.json:
         print(json.dumps(report, indent=2, sort_keys=True))
     else:
+        print(
+            f"arrayview {versions['package_version']} "
+            f"({versions['package_path']})"
+        )
+        print(f"Opener bundled here: v{versions['bundled_opener']}")
+        if versions["this_window"] is not None:
+            suffix = {
+                "window_older": "  ← older than this arrayview; reload this window",
+                "window_newer": "  ← newer than this arrayview; kept and used",
+                "window_unversioned": "  ← pre-0.15 build; reload this window",
+            }.get(versions["state"], "")
+            print(
+                "Opener live in this window: "
+                f"{_describe_window(versions['this_window'])}{suffix}"
+            )
+        elif _in_vscode_terminal():
+            print(
+                "Opener live in this window: none — no live VS Code window "
+                "claims this terminal"
+            )
+        for index, other in enumerate(versions["other_windows"]):
+            label = "Opener live in other windows:" if index == 0 else " " * 29
+            print(f"{label} {_describe_window(other)}")
         print(f"Environment: {plan.environment.value}")
         print(
             f"Server: {plan.server_owner.value} on port {plan.effective_port} "

{arrayview-0.41.1 → arrayview-0.42.1}/src/arrayview/_routes_query.py

@@ -60,12 +60,11 @@ def register_query_routes(app, *, get_session_or_404, pil_image, pil_imageops) -
             raise HTTPException(status_code=400, detail="Invalid viewer phase")
         if phase != "launch-prepared" and not viewer_instance_id:
             raise HTTPException(status_code=400, detail="Incomplete viewer phase identity")
-        # `launch-prepared` is control-plane bookkeeping. The viewer is meant
-        # to open while a large array is still loading, so waiting for the data
-        # Session here deadlocks that design against the opener's short journal
-        # timeout. Pending registration is sufficient; later viewer phases
-        # still wait for the real Session.
-        if phase == "launch-prepared":
+        # Preparation and script startup are control-plane events. The viewer
+        # is meant to open while a large array is still loading, so hiding
+        # either event behind Session readiness creates a false pre-script
+        # timeout. Data-dependent phases still wait for the real Session.
+        if phase in {"launch-prepared", "script-loaded"}:
             if sid not in SESSIONS and sid not in _session_mod.PENDING_SESSIONS:
                 raise HTTPException(status_code=404, detail="Session not found")
         else:
@@ -141,6 +140,20 @@ def register_query_routes(app, *, get_session_or_404, pil_image, pil_imageops) -
                     previous_navigation_key,
                     None,
                 )
+                try:
+                    from arrayview._launch_trace import emit_route_launch_event
+
+                    emit_route_launch_event(
+                        "page.route_retired",
+                        navigation_key=previous_navigation_key,
+                        tab_key=previous_journal.get("tab_key"),
+                        request_id=request_id,
+                        navigation_attempt=previous_journal.get(
+                            "navigation_attempt"
+                        ),
+                    )
+                except Exception:
+                    pass
             journal = journals[request_id] = {
                 "token": token,
                 "window_id": window_id,
@@ -160,6 +173,18 @@ def register_query_routes(app, *, get_session_or_404, pil_image, pil_imageops) -
                     sid,
                     request_id,
                 )
+                try:
+                    from arrayview._launch_trace import emit_route_launch_event
+
+                    emit_route_launch_event(
+                        "page.route_prepared",
+                        navigation_key=navigation_key,
+                        tab_key=tab_key,
+                        request_id=request_id,
+                        navigation_attempt=navigation_attempt,
+                    )
+                except Exception:
+                    pass
             return {
                 "sid": sid,
                 "request_id": request_id,
@@ -208,8 +233,7 @@ def register_query_routes(app, *, get_session_or_404, pil_image, pil_imageops) -
     @app.get("/viewer-phase/{sid}/{request_id}")
     async def get_viewer_phases(sid: str, request_id: str, token: str):
         """Return phases correlated to one browser launch transaction."""
-        session = SESSIONS.get(sid)
-        if session is None:
+        if sid not in SESSIONS and sid not in _session_mod.PENDING_SESSIONS:
             raise HTTPException(status_code=404, detail="Session not found")
         journals = _session_mod.VIEWER_PHASE_JOURNALS.get(sid, {})
         journal = journals.get(request_id, {})

{arrayview-0.41.1 → arrayview-0.42.1}/src/arrayview/_server.py

@@ -422,6 +422,16 @@ def get_short_viewer_ui(
     navigation_key: str,
 ):
     """Resolve a private integrated-browser launch without exposing its query."""
+    try:
+        from arrayview._launch_trace import emit_route_launch_event
+
+        emit_route_launch_event(
+            "page.route_entered",
+            navigation_key=navigation_key,
+            tab_key=tab_key,
+        )
+    except Exception:
+        pass
     owner = _session_mod.VIEWER_LAUNCH_ROUTES.get(navigation_key)
     if owner is None:
         raise HTTPException(status_code=404, detail="Viewer launch route expired")
@@ -437,6 +447,18 @@ def get_short_viewer_ui(
         or journal.get("navigation_key") != navigation_key
     ):
         raise HTTPException(status_code=409, detail="Viewer launch route changed")
+    try:
+        from arrayview._launch_trace import emit_route_launch_event
+
+        emit_route_launch_event(
+            "page.route_resolved",
+            navigation_key=navigation_key,
+            tab_key=tab_key,
+            request_id=request_id,
+            navigation_attempt=journal["navigation_attempt"],
+        )
+    except Exception:
+        pass
     bootstrap_query = journal["viewer_query"] + "&" + urlencode(
         {
             "_av_integrated_browser": "1",