plexora 0.0.9__tar.gz → 0.0.10__tar.gz

{plexora-0.0.9/plexora.egg-info → plexora-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexora
-Version: 0.0.9
+Version: 0.0.10
 Summary: OpenSeadragon-based cellular image viewing and analysis tool.
 License-Expression: LicenseRef-Plexora-Academic-1.0
 Requires-Python: <3.14,>=3.12

{plexora-0.0.9 → plexora-0.0.10}/plexora/client/src/js/main.js

@@ -60,10 +60,9 @@ async function init(config) {
     // to "everything is on this server" without a single probe, and the rewrite
     // below is exactly what it has always been. For a project reading from a
     // data node it decides, once per tab, whether this browser can reach that
-    // node directly -- see services/resourceRouting.js.
-    const routing = await PlexoraRouting.load(datasource);
-    const imageRoute = PlexoraRouting.tileSource(routing, "image");
-    const segRoute = PlexoraRouting.tileSource(routing, "segmentation");
+    // node directly -- see services/resourceRouting.js. `let`, because a
+    // reconnect mid-session replaces it -- see repairRouting below.
+    let routing = await PlexoraRouting.load(datasource);
 
     // A layer that could not be loaded at all is already absent from `config`
     // by this point, so nothing below would ever mention it. Not awaited: the
@@ -74,21 +73,49 @@ async function init(config) {
     }
 
     if (Array.isArray(config.imageData)) {
-        config.imageData.forEach(function (channel, index) {
+        config.imageData.forEach(function (channel) {
             if (channel.src && channel.src.startsWith("/")) {
                 channel.src = plexoraUrl(channel.src);
             }
+            // The address THIS server serves the layer at, kept apart from the
+            // routed rewrite below so routing can be applied again later. A
+            // reconnect changes a node's port and token, and re-deriving the
+            // direct address from the previous direct address would strand the
+            // one case that has to work: a route that has fallen back to the
+            // proxy and later becomes direct again.
+            channel.origSrc = channel.src;
+        });
+        applyRouting(routing);
+    }
+
+    /**
+     * Point every layer's tile address at what `routing` says, from scratch.
+     *
+     * Idempotent over `origSrc`, so it can run again when the answer changes
+     * -- at boot, and on every repair after a node reconnects or goes away.
+     */
+    function applyRouting(resolved) {
+        const imageRoute = PlexoraRouting.tileSource(resolved, "image");
+        const segRoute = PlexoraRouting.tileSource(resolved, "segmentation");
+        (config.imageData || []).forEach(function (channel, index) {
+            if (!channel.origSrc) return;
             // imageData[0] is the label layer when, and only when, the project
             // has a mask -- the same rule ViewerManager.raiseLabelLayer applies
             // and for the same reason, so the two cannot disagree about which
             // entry is which.
             const isLabel = index === 0 && Boolean(config.segmentation);
             const route = isLabel ? segRoute : imageRoute;
-            if (!route) return;
+            if (!route) {
+                // This server's own address: the proxy path, which is also the
+                // only path for a local layer.
+                channel.src = channel.origSrc;
+                channel.srcQuery = "";
+                return;
+            }
             // An image names which channel in the path; a mask has one plane
             // and names nothing. The key is the last segment of the address
-            // this entry already had, whichever server it pointed at.
-            const key = channel.src.replace(/\/+$/, "").split("/").pop();
+            // this server would serve the entry at.
+            const key = channel.origSrc.replace(/\/+$/, "").split("/").pop();
             channel.src = route.appendKey ? route.base + key + "/" : route.base;
             // Carried apart from `src` rather than appended to it, because
             // `channel_add` reads the key back out of `src` by position and a
@@ -163,6 +190,112 @@ async function init(config) {
     __plexora.dataset = PlexoraDataset.build(config, imageChannels, dd);
     channelList.init(dd);
 
+    /**
+     * Rebuild every tiled image off the addresses `config` now holds.
+     *
+     * The same remove-and-re-add the HD toggle uses, and for the same reason
+     * (see ViewerManager.setHdMode): invalidating tiles in place leaves stale
+     * canvases on screen. `currentChannels` still holds each layer's OLD url,
+     * which is exactly what channel_remove matches world items against -- so
+     * the order is fixed: applyRouting first, this second.
+     */
+    function rebuildTileLayers() {
+        const world = seaDragonViewer.viewer && seaDragonViewer.viewer.world;
+        if (!world) return;
+        Object.keys(channelList.currentChannels).map(Number).forEach((srcIdx) => {
+            viewerManager.channel_remove(srcIdx);
+            viewerManager.channel_add(srcIdx);
+        });
+        if (config.segmentation) {
+            for (let i = world.getItemCount() - 1; i >= 0; i -= 1) {
+                const item = world.getItemAt(i);
+                if (item && item.source && item.source.tileFormat === 32) {
+                    world.removeItem(item);
+                }
+            }
+            // Both guards exist to make lazy loading happen once; this is the
+            // one caller that means "again" -- the same resets
+            // adoptSegmentation makes when a mask arrives mid-session.
+            // `noLabel` is set by the error callback when the label layer
+            // failed to load, which during an outage it did.
+            seaDragonViewer.noLabel = false;
+            viewerManager.labelLayerRequested = false;
+            viewerManager.load_label_image();
+        }
+    }
+
+    /**
+     * Say again what is missing, now that the answer may have changed.
+     *
+     * One banner at a time: whatever strip is up is about the addresses that
+     * were just replaced, and report() draws a fresh one when there is still
+     * something to say (and clears its own per-tab memories when there is not).
+     */
+    function rereportResources(resolved) {
+        if (!window.PlexoraResourceStatus) return;
+        document.querySelectorAll(".resource-status-banner")
+            .forEach((strip) => strip.remove());
+        PlexoraResourceStatus.report(datasource, resolved);
+    }
+
+    //: The in-flight repair, shared: a burst of failing tiles and a reconnect
+    //: event landing together is one re-resolution, not several racing ones.
+    let repairing = null;
+
+    /**
+     * Re-resolve where tiles come from, and take the answer on in place.
+     *
+     * What a reconnect used to require a page reload for: the node comes back
+     * on a new port with a new token, the server's own providers re-resolve on
+     * their next call (nodes.address_generation), and this is the browser-side
+     * counterpart -- without it every direct tile URL on the page kept the
+     * dead address, which made each reconnect look like it had done nothing.
+     */
+    function repairRouting() {
+        if (!window.PlexoraRouting) return Promise.resolve(null);
+        if (repairing) return repairing;
+        repairing = (async () => {
+            const before = JSON.stringify(routing && routing.routes || {});
+            const fresh = await PlexoraRouting.refresh(datasource);
+            routing = fresh;
+            rereportResources(fresh);
+            if (JSON.stringify(fresh.routes || {}) === before) return null;
+            applyRouting(fresh);
+            rebuildTileLayers();
+            return fresh;
+        })().finally(() => { repairing = null; });
+        return repairing;
+    }
+    __plexora.repairRouting = repairRouting;
+
+    // A data node connecting or going away is the moment tile addresses can
+    // change. remoteState announces the transition (it is already watching
+    // whenever one can happen in this tab); repairing on it is what lets a
+    // reconnect heal an open viewer instead of needing a reload nobody was
+    // told about.
+    window.addEventListener("plexora:remote-nodes-changed", () => {
+        repairRouting();
+    });
+
+    //: How often failing tiles may trigger a repair attempt. A dead node fails
+    //: tiles for as long as it is dead; asking the server once per window is
+    //: what keeps that from becoming a poll.
+    const TILE_FAILURE_REPAIR_MS = 30000;
+    let lastTileRepair = 0;
+    // A burst of failing tiles is how a moved or dead node actually presents
+    // mid-session -- nothing else on the page is watching when no dialog is
+    // open. Repairing answers both cases: an address that changed is taken on
+    // in place, and a node that is gone from the map gets the resource-status
+    // report (the modal with the Connect button) instead of silent timeouts.
+    if (seaDragonViewer.viewer && seaDragonViewer.viewer.addHandler) {
+        seaDragonViewer.viewer.addHandler("tile-load-failed", () => {
+            const now = Date.now();
+            if (now - lastTileRepair < TILE_FAILURE_REPAIR_MS) return;
+            lastTileRepair = now;
+            repairRouting();
+        });
+    }
+
     /**
      * Re-fetch what the server says this project's numbers are.
      *

{plexora-0.0.9 → plexora-0.0.10}/plexora/client/src/js/services/remoteGlobe.js

@@ -85,7 +85,7 @@ window.PlexoraRemoteGlobe = (function () {
      * Collapsing them loses the case that matters -- a session that still
      * reads connected against a node that has stopped answering.
      */
-    function healthOf(entry, health) {
+    function healthOf(entry, health, stale) {
         //: The probe first, and the session only as a fallback. A data node
         //: outlives the process that started it, so after a restart there is
         //: no session and the registry still holds the node -- asking the
@@ -101,6 +101,18 @@ window.PlexoraRemoteGlobe = (function () {
                      cls: "is-checking", ms: null, detail: "" };
         }
         if (probe.state === "healthy") {
+            //: The BROWSER's own version of the server's "stale" below, and it
+            //: outlasts it: the server's held address heals itself on its next
+            //: proxied call, while the page's direct tile URLs stay wherever
+            //: the tiles on screen were fetched from. Checked here, on top of
+            //: a healthy probe, because both claims are true at once -- the
+            //: machine IS well, and this page is not reading from it.
+            if (stale && stale[nodeNameOf(entry)]) {
+                return { word: "Reconnected", glyph: "arrows-rotate",
+                         cls: "is-degraded", ms: null,
+                         detail: "That machine is answering at a new address; "
+                                 + "this page is being repointed at it now." };
+            }
             return { word: "Healthy", glyph: "circle-check", cls: "is-healthy",
                      ms: probe.ms, detail: "" };
         }
@@ -120,6 +132,33 @@ window.PlexoraRemoteGlobe = (function () {
         };
     }
 
+    /**
+     * Which nodes the open page is still addressing at a retired location.
+     *
+     * Compares what this page's tiles were actually built from
+     * (`PlexoraRouting.held`) with what `/resource_routing` answers NOW. Only
+     * a direct route can be stale in the browser -- a proxied layer goes
+     * through this server, whose providers re-resolve on their own -- and a
+     * node that has left the map entirely is not stale, it is gone, which the
+     * probe already says in its own words. Empty on every page that never
+     * resolved routing, which is every page but the viewer.
+     */
+    function staleNodes(datasource, candidates) {
+        const held = window.PlexoraRouting && PlexoraRouting.held
+            ? PlexoraRouting.held(datasource) : null;
+        const routes = (held && held.routes) || {};
+        const stale = {};
+        Object.keys(routes).forEach((kind) => {
+            const mine = routes[kind];
+            const now = candidates[kind];
+            if (!mine || mine.mode !== "direct" || !now) return;
+            if (mine.base !== now.tile_base || mine.query !== now.query) {
+                stale[mine.node] = true;
+            }
+        });
+        return stale;
+    }
+
     //: The one mount there will ever be. This icon lives in the NAVBAR, which
     //: the router does not swap -- only the page below it is replaced -- so
     //: `PlexoraPage.register` runs again on every internal navigation against
@@ -158,6 +197,10 @@ window.PlexoraRemoteGlobe = (function () {
         //: and a different one from "we have not asked".
         let imageNode = null;
         let routingRead = false;
+        //: Node names whose registry address no longer matches what this
+        //: page's tiles were built from -- see staleNodes. Computed with the
+        //: routing read, drawn over a healthy probe as "Reconnected".
+        let pageStale = {};
         //: What `/remote_health` last said, by profile name, and which set of
         //: connected machines that answer was about -- so becoming connected
         //: while the panel is open re-asks, and a poll that changed nothing
@@ -234,6 +277,7 @@ window.PlexoraRemoteGlobe = (function () {
 
             imageNode = null;
             routingRead = false;
+            pageStale = {};
             health = {};
             healthFor = null;
             readRouting();
@@ -295,6 +339,18 @@ window.PlexoraRemoteGlobe = (function () {
                     const routes = (payload && payload.routes) || {};
                     imageNode = (routes.image && routes.image.node) || null;
                     routingRead = true;
+                    pageStale = staleNodes(datasource, routes);
+                    if (Object.keys(pageStale).length) {
+                        // Saying so is this panel's job; fixing it is the
+                        // viewer's. The same event a watched reconnect fires,
+                        // so there is one repair path -- this is the backstop
+                        // for a reconnect made from another tab, which no poll
+                        // in this one was awake to see.
+                        window.dispatchEvent(new CustomEvent(
+                            "plexora:remote-nodes-changed",
+                            { detail: { changed: Object.keys(pageStale).map(
+                                (node) => ({ name: null, node: node, up: true })) } }));
+                    }
                     if (panel) draw(Remotes().snapshot());
                 })
                 .catch(() => {});
@@ -430,7 +486,7 @@ window.PlexoraRemoteGlobe = (function () {
             item.append(top);
 
             const bottom = el("div", "remote-conn-bottom");
-            const state = healthOf(entry, health);
+            const state = healthOf(entry, health, pageStale);
             const well = el("span", "remote-conn-health " + state.cls);
             well.append(icon(state.glyph));
             well.append(el("span", null, state.word));

{plexora-0.0.9 → plexora-0.0.10}/plexora/client/src/js/services/remoteState.js

@@ -299,7 +299,52 @@ window.PlexoraRemotes = (function () {
         timer = window.setTimeout(() => { refresh(); }, POLL_MS);
     }
 
+    /**
+     * Which profiles' data nodes changed condition between two snapshots.
+     *
+     * The one thing a snapshot difference can say that no subscriber can:
+     * a node session coming up or going away changes which ADDRESS the open
+     * project's tiles should be fetched from, and the page holding those tile
+     * URLs (main.js) is not a subscriber -- it resolved routing once at boot.
+     * The event is what lets it repair itself instead of failing against a
+     * port that has gone until somebody thinks to reload.
+     *
+     * Only real transitions: a profile present in both snapshots whose node
+     * half changed being-up, map name, or registry name. The first snapshot
+     * has nothing to differ from, and a failed poll republishes the same
+     * entries object, so neither fires anything.
+     */
+    function nodeChanges(previous, next) {
+        if (!previous.loaded || !next.loaded) return [];
+        if (previous.entries === next.entries) return [];
+        const before = new Map();
+        (previous.entries || []).forEach((entry) => {
+            before.set(entry.name, entry.node);
+        });
+        const changed = [];
+        (next.entries || []).forEach((entry) => {
+            const was = before.get(entry.name);
+            if (!was) return;
+            const wasUp = was.state === "connected" || Boolean(was.node);
+            const isUp = entry.node.state === "connected"
+                || Boolean(entry.node.node);
+            if (wasUp !== isUp
+                    || (was.node || null) !== (entry.node.node || null)
+                    || (was.registered || null)
+                        !== (entry.node.registered || null)) {
+                changed.push({
+                    name: entry.name,
+                    node: entry.node.node || entry.node.registered
+                        || was.node || was.registered || null,
+                    up: isUp,
+                });
+            }
+        });
+        return changed;
+    }
+
     function publish(next) {
+        const changed = nodeChanges(current, next);
         current = next;
         subscribers.forEach((sub) => {
             try {
@@ -311,6 +356,10 @@ window.PlexoraRemotes = (function () {
                 if (window.console) console.error("remote state subscriber", e);
             }
         });
+        if (changed.length) {
+            window.dispatchEvent(new CustomEvent("plexora:remote-nodes-changed",
+                                                 { detail: { changed } }));
+        }
     }
 
     /**

{plexora-0.0.9 → plexora-0.0.10}/plexora/client/src/js/services/resourceRouting.js

@@ -48,6 +48,14 @@ window.PlexoraRouting = (function () {
     //: wait on the same probe rather than starting their own.
     const pending = new Map();
 
+    //: datasource -> the last fully-resolved table this page handed out: what
+    //: the page is ACTUALLY using, kept for anything that compares it against
+    //: the registry's current answer (the globe's stale check). Overwritten
+    //: when a re-resolution lands, never cleared by `forget` -- while a fresh
+    //: probe is in flight the old table is still the truthful account of what
+    //: the tiles on screen were built from.
+    const settled = new Map();
+
     //: The answer for a project with nothing on a node. Frozen and shared:
     //: every lookup against it returns "local", which is what every call site
     //: already assumed.
@@ -119,7 +127,11 @@ window.PlexoraRouting = (function () {
                               + "?datasource=" + encodeURIComponent(datasource))
             .then((response) => (response.ok ? response.json() : { routes: {} }))
             .then((body) => decide(datasource, body.routes || {}))
-            .catch(() => NOTHING_REMOTE);
+            .catch(() => NOTHING_REMOTE)
+            .then((resolved) => {
+                settled.set(datasource, resolved);
+                return resolved;
+            });
 
         pending.set(datasource, promise);
         return promise;
@@ -142,8 +154,14 @@ window.PlexoraRouting = (function () {
         });
 
         const asked = Array.from(byNode.entries()).map(([node, route]) => {
-            if (Object.prototype.hasOwnProperty.call(known, node)) {
-                verdicts[node] = known[node];
+            // Only a remembered YES is reused. A remembered "unreachable" was
+            // true of a moment -- a node mid-restart, a tunnel not yet up --
+            // and reusing it pinned the whole tab to the proxy hop for as long
+            // as it stayed open, silently, after the node came back. Probing
+            // again costs this one load at most PROBE_TIMEOUT_MS; being wrong
+            // the other way cost every tile an extra hop for the afternoon.
+            if (known[node] === true) {
+                verdicts[node] = true;
                 return Promise.resolve();
             }
             return probe(route).then((reachable) => { verdicts[node] = reachable; });
@@ -202,5 +220,30 @@ window.PlexoraRouting = (function () {
         pending.delete(datasource);
     }
 
-    return { load, tileSource, unreachable, forget, PROBE_TIMEOUT_MS };
+    /**
+     * The routing table this page is currently using, or null.
+     *
+     * Synchronous and never resolving anything: it answers "what were the
+     * tiles on screen built from", which is a fact about the past. The globe
+     * compares it against `/resource_routing`'s current answer to tell whether
+     * the open project is still addressed to where a node was before it was
+     * reconnected.
+     */
+    function held(datasource) {
+        return settled.get(datasource) || null;
+    }
+
+    /**
+     * Ask again from scratch: drop the memoised table AND the remembered
+     * verdicts, then resolve anew. What a reconnect calls -- the node came
+     * back on a new port with a new token, so both halves of what this tab
+     * remembers are about an address that has gone.
+     */
+    function refresh(datasource) {
+        forget(datasource);
+        return load(datasource);
+    }
+
+    return { load, tileSource, unreachable, forget, held, refresh,
+             PROBE_TIMEOUT_MS };
 })();

{plexora-0.0.9 → plexora-0.0.10}/plexora/client/templates/base.html

@@ -34,7 +34,7 @@
          awaits it before it builds a single tile source, and every page that
          can open a viewer loads it. Costs one request that answers "{}" for a
          project with nothing on a node. -->
-    <script src="{{ data.base_url }}/client/src/js/services/resourceRouting.js?v=20260826_direct_routing" type="text/javascript"></script>
+    <script src="{{ data.base_url }}/client/src/js/services/resourceRouting.js?v=20260830_reconnect_repair" type="text/javascript"></script>
     <!-- Why a layer is missing, when one is. Asks /resource_status once per
          project load and says nothing at all for a project with everything on
          this machine, which is every ordinary one. -->
@@ -87,7 +87,7 @@
        the one poll that four surfaces used to run three of. It costs nothing
        on a page that never subscribes -- there is no timer until somebody
        does. #}
-    <script src="{{ data.base_url }}/client/src/js/services/remoteState.js?v=20260830_install_plexora" defer></script>
+    <script src="{{ data.base_url }}/client/src/js/services/remoteState.js?v=20260830_reconnect_repair" defer></script>
     {# The connection log, shared by the modal and the Settings page's cards.
        Before both of them: they call into it as they build. #}
     <script src="{{ data.base_url }}/client/src/js/services/logTerminal.js?v=20260829_terminal" defer></script>
@@ -97,7 +97,7 @@
        it after pageBoot.js below (a normal script beats every deferred one),
        so PlexoraPage.register exists by the time this file's last line runs.
        It needs popoverPortal.js, loaded above with the other widgets. #}
-    <script src="{{ data.base_url }}/client/src/js/services/remoteGlobe.js?v=20260830_node_reconnect" defer></script>
+    <script src="{{ data.base_url }}/client/src/js/services/remoteGlobe.js?v=20260830_reconnect_repair" defer></script>
     {# Says so before a scheduled job ends, from whichever page the user is on.
        After connectionModal.js, which its one button opens; passive, so it
        costs nothing while a connection sits settled. #}

{plexora-0.0.9 → plexora-0.0.10}/plexora/client/templates/index.html

@@ -244,7 +244,7 @@
    by the time the user clicks the sidebar's upload icon, so deferred is ample.
    #}
 <script src="{{ data.base_url }}/client/src/js/views/channelNamesUpload.js?v=20260829_channel_names_switch" defer></script>
-<script src="{{ data.base_url }}/client/src/js/main.js?v=20260826_direct_routing" defer></script>
+<script src="{{ data.base_url }}/client/src/js/main.js?v=20260830_reconnect_repair" defer></script>
 {% else %}
 <div id="quick_view_landing" class="quick-view-landing">
     <div class="quick-view-card">

{plexora-0.0.9 → plexora-0.0.10}/plexora/server/models/remote_sessions.py

@@ -222,15 +222,17 @@ class RemoteSession:
 
     def __init__(self, remote, *, askpass_url=None, auth_token=None,
                  timeout=None, kind=KIND_VIEWER, allow_origin=None,
-                 register=None):
+                 register=None, unregister=None):
         self.remote = remote
         self.name = remote.name
         self.kind = kind
-        #: Node sessions only: the origin the browser will use, and the
-        #: callable that records the node once it answers. Both are supplied by
-        #: the route, which is the only place that knows either.
+        #: Node sessions only: the origin the browser will use, the callable
+        #: that records the node once it answers, and the one that takes it
+        #: back off the map when this session ends on its own. All supplied by
+        #: the route, which is the only place that knows any of them.
         self._allow_origin = allow_origin
         self._register = register
+        self._unregister = unregister
         self.state = STATE_CONNECTING
         #: What establishment last said it was doing, kept separately because a
         #: prompt covers it over for as long as the question is on screen and
@@ -501,7 +503,12 @@ class RemoteSession:
             self.session.establish()
         except BaseException as exc:  # noqa: BLE001 - reported, never raised
             self._fail(exc)
-            self._cleanup_helper()
+            # Not only the helper: establishment spawns real ssh processes
+            # before it can fail -- under srun, a job holding an allocation and
+            # a tunnel beside it -- and a failed connection's children serve
+            # nobody. Left running, they held the Slurm job (and its walltime
+            # bill) until the app exited.
+            self._tidy_after_end()
             return
 
         with self._lock:
@@ -528,6 +535,47 @@ class RemoteSession:
         with self._lock:
             if self.state not in (STATE_FAILED,):
                 self.state = STATE_EXITED
+            stopping = self._stopping
+        # `wait()` returning without stop() having been called means the
+        # connection died on its own -- a walltime, a dropped network, a crash
+        # on the far side -- and nothing else is going to run the teardown.
+        # When stop() IS what unblocked the wait, the teardown has already run
+        # (and for a disconnect, the route forgets the node itself).
+        if not stopping:
+            self._tidy_after_end()
+
+    def _tidy_after_end(self):
+        """Teardown for a session nothing will press Disconnect on.
+
+        Three things only stop() used to do, each of which a session that
+        failed or exited on its own left behind:
+
+        - The sibling watchers. Under srun the tunnel is a second ssh: the job
+          leg exiting (which is what ends `wait()`) does not end it, and on a
+          cluster that does not adopt compute-side ssh into the job it kept a
+          local port listening and forwarding into refused connections.
+        - The askpass helper's temp directory.
+        - The node entry this session registered. The node ran inside the job
+          that just ended, so the address on the map is dead -- and while the
+          entry stood, `/resource_routing` kept offering it to browsers and
+          `/resource_status` reported a project reading from it as fine. Only
+          an entry THIS session put there (`session.registered`), through the
+          route-supplied callable that re-checks `managed_by` -- an entry a
+          terminal's own `plexora connect` owns is not this session's to take
+          down.
+        """
+        try:
+            if self.session is not None:
+                self.session.stop()
+        except Exception:
+            pass
+        self._cleanup_helper()
+        if (self.kind == KIND_NODE and self._unregister is not None
+                and getattr(self.session, "registered", None) is not None):
+            try:
+                self._unregister(self.node_name)
+            except Exception:
+                pass
 
     def _fail(self, exc):
         with self._lock:
@@ -804,7 +852,7 @@ def find_by_nonce(nonce):
 
 
 def start(remote, *, askpass_url=None, auth_token=None, timeout=None,
-          kind=KIND_VIEWER, allow_origin=None, register=None):
+          kind=KIND_VIEWER, allow_origin=None, register=None, unregister=None):
     """Begin connecting to `remote`, or say why not."""
     key = _key(kind, remote.name)
     with _REGISTRY_LOCK:
@@ -822,8 +870,18 @@ def start(remote, *, askpass_url=None, auth_token=None, timeout=None,
         session = RemoteSession(remote, askpass_url=askpass_url,
                                 auth_token=auth_token, timeout=timeout,
                                 kind=kind, allow_origin=allow_origin,
-                                register=register)
+                                register=register, unregister=unregister)
         _SESSIONS[key] = session
+    if existing is not None:
+        # Outside the lock -- stopping waits on processes. A failed or exited
+        # session's stop() is usually a no-op by now (its own teardown ran),
+        # but replacing the record without it leaked its watcher entries into
+        # connect._ACTIVE for the life of the app, and any child process that
+        # happened to survive its session with them.
+        try:
+            existing.stop()
+        except Exception:
+            pass
     return session.start()
 
 

{plexora-0.0.9 → plexora-0.0.10}/plexora/server/routes/settings_routes.py

@@ -789,7 +789,12 @@ def settings_remotes_connect(name):
     if kind == remote_sessions.KIND_NODE:
         # Read here, in the request, because both are facts about the browser
         # that made it -- and the thread that uses them has no request to ask.
-        extra = {"allow_origin": _browser_origin(), "register": _record_node}
+        # `unregister` is the other half of `register`: when the session ends
+        # on its own -- a walltime, a dropped network -- the node it put on
+        # the map is dead, and the session's own teardown is the only thing
+        # left that knows to take it off.
+        extra = {"allow_origin": _browser_origin(), "register": _record_node,
+                 "unregister": _forget_node_entry}
     try:
         session = remote_sessions.start(
             remote,
@@ -837,12 +842,28 @@ def _forget_node(name):
     an address they can fix, and is none of this route's business.
     """
     try:
-        from plexora import nodes as node_api
-        from plexora.server.models import nodes as node_registry
         from plexora.server.models import remotes as remote_store
 
         remote = remote_store.find(name)
         node_name = (remote.node_name or name) if remote is not None else name
+        _forget_node_entry(node_name)
+    except Exception:
+        pass
+
+
+def _forget_node_entry(node_name):
+    """Drop one registry entry, if a saved connection is what wrote it.
+
+    The half of `_forget_node` that acts on a NODE name rather than a profile
+    name. Shared with the session's own teardown (`remote_sessions.start`'s
+    `unregister`), which already knows the node's name and has no request to
+    resolve a profile from. Never fatal, and guarded by the same `managed_by`
+    proof: an entry somebody registered by hand is theirs.
+    """
+    try:
+        from plexora import nodes as node_api
+        from plexora.server.models import nodes as node_registry
+
         entry = node_registry.load_all().get(node_name)
         if entry is not None and entry.managed_by == f"connect:{node_name}":
             node_api.forget_node(node_name)

{plexora-0.0.9 → plexora-0.0.10/plexora.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: plexora
-Version: 0.0.9
+Version: 0.0.10
 Summary: OpenSeadragon-based cellular image viewing and analysis tool.
 License-Expression: LicenseRef-Plexora-Academic-1.0
 Requires-Python: <3.14,>=3.12

{plexora-0.0.9 → plexora-0.0.10}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "plexora"
-version = "0.0.9"
+version = "0.0.10"
 description = "OpenSeadragon-based cellular image viewing and analysis tool."
 readme = "README.md"
 requires-python = ">=3.12,<3.14"