MetaList 0.6.3__tar.gz → 0.7.1__tar.gz

{metalist-0.6.3 → metalist-0.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metalist
-Version: 0.6.3
+Version: 0.7.1
 Summary: A minimalist single-user note-taking app with SSR, fast in-memory tree operations, and efficient sync.
 Project-URL: Homepage, https://github.com/evolvingstuff/metalist
 Project-URL: Repository, https://github.com/evolvingstuff/metalist
@@ -213,6 +213,18 @@ METALIST_HOST=192.168.1.20 metalist
 ```
 On a fresh machine, that first launch also creates the default TLS cert pair automatically. Then open either `http://192.168.1.20:8000` or `https://192.168.1.20:8443` from the other machine.
 
+Starting with 0.7.1, an explicit `METALIST_HOST` or `METALIST_ALLOWED_HOSTS`
+configuration is saved in `~/MetaList/network-settings.json` (under
+`METALIST_DATA_DIRECTORY` when overridden). Subsequent source launches, plain
+`metalist` launches, and updates reuse it. Environment values override and update
+the corresponding saved settings. This file stores only the bind address and
+allowed hosts; namespace ports remain in their launch profiles, and shell access
+still requires `--enable-shell` on each launch. Invalid settings stop startup
+with an error. Fresh installations continue to bind to localhost by default.
+To switch back to local-only access, run `METALIST_HOST=127.0.0.1 metalist` once.
+Older installed versions do not read this file; keep supplying their LAN settings
+until upgrading to 0.7.1 or later.
+
 To keep `@shell` available on the host laptop while allowing another laptop to
 use normal MetaList features, bind both interfaces and explicitly allow the LAN
 address:

{metalist-0.6.3 → metalist-0.7.1}/README.md

@@ -177,6 +177,18 @@ METALIST_HOST=192.168.1.20 metalist
 ```
 On a fresh machine, that first launch also creates the default TLS cert pair automatically. Then open either `http://192.168.1.20:8000` or `https://192.168.1.20:8443` from the other machine.
 
+Starting with 0.7.1, an explicit `METALIST_HOST` or `METALIST_ALLOWED_HOSTS`
+configuration is saved in `~/MetaList/network-settings.json` (under
+`METALIST_DATA_DIRECTORY` when overridden). Subsequent source launches, plain
+`metalist` launches, and updates reuse it. Environment values override and update
+the corresponding saved settings. This file stores only the bind address and
+allowed hosts; namespace ports remain in their launch profiles, and shell access
+still requires `--enable-shell` on each launch. Invalid settings stop startup
+with an error. Fresh installations continue to bind to localhost by default.
+To switch back to local-only access, run `METALIST_HOST=127.0.0.1 metalist` once.
+Older installed versions do not read this file; keep supplying their LAN settings
+until upgrading to 0.7.1 or later.
+
 To keep `@shell` available on the host laptop while allowing another laptop to
 use normal MetaList features, bind both interfaces and explicitly allow the LAN
 address:

{metalist-0.6.3 → metalist-0.7.1}/app/exception_boundaries.py

@@ -78,9 +78,9 @@ CAPTURE_BOUNDARIES = {
     # Translate explicitly validated domain input/resource rejection.
     'app/main.py:namespace_renamed_page:job_record_capture': ('NamespaceInputRejected', 'FileNotFoundError'),
     # Parse external host, URL, IP or date input at the named boundary.
-    'app/security/request_boundary.py:_normalize_configured_hostname:normalize_capture': ('ValueError',),
+    'app/security/request_hosts.py:_normalize_configured_hostname:normalize_capture': ('ValueError',),
     # Parse external host, URL, IP or date input at the named boundary.
-    'app/security/request_boundary.py:_normalize_hostname:ip_capture': ('ValueError',),
+    'app/security/request_hosts.py:_normalize_hostname:ip_capture': ('ValueError',),
     # Parse external host, URL, IP or date input at the named boundary.
     'app/security/request_boundary.py:_parse_host_header:parse_capture': ('ValueError',),
     # Parse external host, URL, IP or date input at the named boundary.

metalist-0.7.1/app/network_settings.py

@@ -0,0 +1,61 @@
+"""Machine network preferences shared by source and installed entrypoints.
+
+Only an explicit bind address/allowed-host configuration opts into persistence.
+Namespace ports, shell capability, credentials, and backups are not stored here.
+"""
+from __future__ import annotations
+
+from collections.abc import MutableMapping
+import json
+import os
+from pathlib import Path
+from uuid import uuid4
+
+from app.data_directory import resolve_data_directory
+from app.security.request_hosts import resolve_allowed_request_hosts
+
+
+_NETWORK_ENVIRONMENT_KEYS = frozenset({'METALIST_HOST', 'METALIST_ALLOWED_HOSTS'})
+
+
+def _validate_network_environment(environment: object) -> dict[str, str]:
+    if not isinstance(environment, dict) or not environment.keys() <= _NETWORK_ENVIRONMENT_KEYS:
+        raise RuntimeError('Network settings must contain only bind-address and allowed-host preferences')
+    if any(not isinstance(value, str) for value in environment.values()):
+        raise RuntimeError('Network settings values must be strings')
+    resolve_allowed_request_hosts(environ=environment)
+    return dict(environment)
+
+
+def _read_network_settings(path: Path) -> dict[str, str]:
+    if not path.exists():
+        return {}
+    payload = json.loads(path.read_text(encoding='utf-8'))
+    if (not isinstance(payload, dict) or set(payload) != {'version', 'environment'}
+            or type(payload['version']) is not int or payload['version'] != 1):
+        raise RuntimeError(f'Invalid network settings file: {path}')
+    return _validate_network_environment(payload['environment'])
+
+
+def _write_network_settings(path: Path, environment: dict[str, str]) -> None:
+    assert path.name == 'network-settings.json'
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f'.network-settings-{uuid4().hex}.tmp')
+    try:
+        with temporary.open('x', encoding='utf-8') as stream:
+            json.dump({'version': 1, 'environment': environment}, stream, indent=2)
+            stream.write('\n')
+        os.replace(temporary, path)
+    finally:
+        temporary.unlink(missing_ok=True)
+
+
+def apply_network_settings(*, environ: MutableMapping[str, str], persist: bool) -> None:
+    path = resolve_data_directory(environ=environ) / 'network-settings.json'
+    saved = _read_network_settings(path)
+    configured = {key: environ[key] for key in _NETWORK_ENVIRONMENT_KEYS if key in environ}
+    effective = _validate_network_environment(saved | configured)
+    if persist and effective != saved:
+        _write_network_settings(path, effective)
+        print(f'[startup] Saved network settings: {path}', flush=True)
+    environ.update(effective)

{metalist-0.6.3 → metalist-0.7.1}/app/security/request_boundary.py

@@ -1,9 +1,6 @@
 from __future__ import annotations
 
-from collections.abc import Mapping
 from dataclasses import dataclass
-import ipaddress
-import re
 from urllib.parse import urlsplit
 
 from fastapi import Request
@@ -12,14 +9,10 @@ from starlette.middleware.base import BaseHTTPMiddleware
 
 from app.api.request_auth import AUTH_COOKIE_NAME
 from app.services.exception_capture import CapturedExceptionContext
+from app.security.request_hosts import _normalize_hostname, resolve_allowed_request_hosts
 
 
-_LOOPBACK_REQUEST_HOSTS = frozenset({"127.0.0.1", "::1", "localhost"})
-_WILDCARD_BIND_HOSTS = frozenset({"0.0.0.0", "::"})
 _SAFE_METHODS = frozenset({"GET", "HEAD", "OPTIONS"})
-_DNS_HOSTNAME_PATTERN = re.compile(
-    r"^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$"
-)
 
 
 @dataclass(frozen=True)
@@ -28,72 +21,6 @@ class RequestBoundaryRejection:
     detail: str
 
 
-def _normalize_hostname(*, hostname: str, context: str) -> str:
-    normalized = hostname.strip().casefold().rstrip(".")
-    if normalized == "":
-        raise ValueError(f"{context} hostname must not be empty")
-
-    ip_capture = CapturedExceptionContext(ValueError, boundary='app/security/request_boundary.py:_normalize_hostname:ip_capture')
-    parsed_ip: ipaddress._BaseAddress | None = None
-    with ip_capture:
-        parsed_ip = ipaddress.ip_address(normalized)
-    if ip_capture.captured_exception is None:
-        if parsed_ip is None:
-            raise RuntimeError("IP parser returned no address")
-        return parsed_ip.compressed.casefold()
-
-    if _DNS_HOSTNAME_PATTERN.fullmatch(normalized) is None:
-        raise ValueError(f"{context} contains an invalid hostname: {hostname!r}")
-    return normalized
-
-
-def _normalize_configured_hostname(*, raw_value: str) -> str:
-    value = raw_value.strip()
-    if value == "":
-        raise RuntimeError("METALIST_ALLOWED_HOSTS contains an empty entry")
-    if value == "*":
-        raise RuntimeError("METALIST_ALLOWED_HOSTS must not contain '*'")
-    if "://" in value or "/" in value or "@" in value:
-        raise RuntimeError(
-            "METALIST_ALLOWED_HOSTS entries must be hostnames without schemes, ports, or paths"
-        )
-
-    unbracketed_value = value
-    if value.startswith("[") and value.endswith("]"):
-        unbracketed_value = value[1:-1]
-    normalize_capture = CapturedExceptionContext(ValueError, boundary='app/security/request_boundary.py:_normalize_configured_hostname:normalize_capture')
-    normalized_hostname: str | None = None
-    with normalize_capture:
-        normalized_hostname = _normalize_hostname(
-            hostname=unbracketed_value,
-            context="METALIST_ALLOWED_HOSTS",
-        )
-    if normalize_capture.captured_exception is not None:
-        exc = normalize_capture.captured_exception
-        raise RuntimeError(str(exc)) from exc
-    if normalized_hostname is None:
-        raise RuntimeError("METALIST_ALLOWED_HOSTS parser returned no hostname")
-    return normalized_hostname
-
-
-def resolve_allowed_request_hosts(*, environ: Mapping[str, str]) -> frozenset[str]:
-    allowed_hosts = set(_LOOPBACK_REQUEST_HOSTS)
-    bind_host = environ.get("METALIST_HOST", "127.0.0.1").strip()
-    if bind_host == "":
-        raise RuntimeError("METALIST_HOST must not be empty")
-    normalized_bind_host = _normalize_configured_hostname(raw_value=bind_host)
-    if normalized_bind_host not in _WILDCARD_BIND_HOSTS:
-        allowed_hosts.add(normalized_bind_host)
-
-    configured_hosts = environ.get("METALIST_ALLOWED_HOSTS")
-    if configured_hosts is not None:
-        if configured_hosts.strip() == "":
-            raise RuntimeError("METALIST_ALLOWED_HOSTS must not be empty when set")
-        for raw_host in configured_hosts.split(","):
-            allowed_hosts.add(_normalize_configured_hostname(raw_value=raw_host))
-    return frozenset(allowed_hosts)
-
-
 def _parse_host_header(host_header: str) -> tuple[str, int | None] | None:
     raw_host = host_header.strip()
     if raw_host == "":

metalist-0.7.1/app/security/request_hosts.py

@@ -0,0 +1,83 @@
+"""Host validation shared by early launch settings and HTTP request checks."""
+from __future__ import annotations
+
+from collections.abc import Mapping
+import ipaddress
+import re
+
+from app.services.exception_capture import CapturedExceptionContext
+
+
+_LOOPBACK_REQUEST_HOSTS = frozenset({"127.0.0.1", "::1", "localhost"})
+_WILDCARD_BIND_HOSTS = frozenset({"0.0.0.0", "::"})
+_DNS_HOSTNAME_PATTERN = re.compile(
+    r"^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?)*$"
+)
+
+
+def _normalize_hostname(*, hostname: str, context: str) -> str:
+    normalized = hostname.strip().casefold().rstrip(".")
+    if normalized == "":
+        raise ValueError(f"{context} hostname must not be empty")
+
+    ip_capture = CapturedExceptionContext(ValueError, boundary='app/security/request_hosts.py:_normalize_hostname:ip_capture')
+    parsed_ip: ipaddress._BaseAddress | None = None
+    with ip_capture:
+        parsed_ip = ipaddress.ip_address(normalized)
+    if ip_capture.captured_exception is None:
+        if parsed_ip is None:
+            raise RuntimeError("IP parser returned no address")
+        return parsed_ip.compressed.casefold()
+
+    if _DNS_HOSTNAME_PATTERN.fullmatch(normalized) is None:
+        raise ValueError(f"{context} contains an invalid hostname: {hostname!r}")
+    return normalized
+
+
+def _normalize_configured_hostname(*, raw_value: str) -> str:
+    value = raw_value.strip()
+    if value == "":
+        raise RuntimeError("METALIST_ALLOWED_HOSTS contains an empty entry")
+    if value == "*":
+        raise RuntimeError("METALIST_ALLOWED_HOSTS must not contain '*'")
+    if "://" in value or "/" in value or "@" in value:
+        raise RuntimeError(
+            "METALIST_ALLOWED_HOSTS entries must be hostnames without schemes, ports, or paths"
+        )
+
+    unbracketed_value = value
+    if value.startswith("[") and value.endswith("]"):
+        unbracketed_value = value[1:-1]
+    normalize_capture = CapturedExceptionContext(ValueError, boundary='app/security/request_hosts.py:_normalize_configured_hostname:normalize_capture')
+    normalized_hostname: str | None = None
+    with normalize_capture:
+        normalized_hostname = _normalize_hostname(
+            hostname=unbracketed_value,
+            context="METALIST_ALLOWED_HOSTS",
+        )
+    if normalize_capture.captured_exception is not None:
+        exc = normalize_capture.captured_exception
+        raise RuntimeError(str(exc)) from exc
+    if normalized_hostname is None:
+        raise RuntimeError("METALIST_ALLOWED_HOSTS parser returned no hostname")
+    return normalized_hostname
+
+
+def resolve_allowed_request_hosts(*, environ: Mapping[str, str]) -> frozenset[str]:
+    allowed_hosts = set(_LOOPBACK_REQUEST_HOSTS)
+    bind_host = environ.get("METALIST_HOST", "127.0.0.1").strip()
+    if bind_host == "":
+        raise RuntimeError("METALIST_HOST must not be empty")
+    normalized_bind_host = _normalize_configured_hostname(raw_value=bind_host)
+    if normalized_bind_host not in _WILDCARD_BIND_HOSTS:
+        allowed_hosts.add(normalized_bind_host)
+
+    configured_hosts = environ.get("METALIST_ALLOWED_HOSTS")
+    if configured_hosts is not None:
+        if configured_hosts.strip() == "":
+            raise RuntimeError("METALIST_ALLOWED_HOSTS must not be empty when set")
+        for raw_host in configured_hosts.split(","):
+            allowed_hosts.add(_normalize_configured_hostname(raw_value=raw_host))
+    return frozenset(allowed_hosts)
+
+

{metalist-0.6.3 → metalist-0.7.1}/app/services/note_store.py

@@ -113,6 +113,8 @@ class NoteStore:
         self._ordering = NoteOrdering()
         self._effective_non_meta_tag_terms: Dict[str, FrozenSet[str]] = {}
         self._effective_proposed_non_meta_tag_terms: Dict[str, FrozenSet[str]] = {}
+        self._subtree_non_meta_tag_terms: Dict[str, FrozenSet[str]] = {}
+        self._subtree_proposed_non_meta_tag_terms: Dict[str, FrozenSet[str]] = {}
         self._loaded = False
         self._revision = 0
         self._timing_enabled = True
@@ -120,17 +122,20 @@ class NoteStore:
     def _get_children_locked(self, parent_id: Optional[str]) -> List[str]:
         return self._ordering.children(self._note_map, parent_id)
 
-    def _tag_dependencies_locked(self, note_id: str) -> set[str]:
-        record = self._note_map[note_id]
-        dependencies = set(self._backlink_index.get_target_ids(note_id)) & self._note_map.keys()
-        if record.parent_id is not None:
-            assert record.parent_id in self._note_map
-            dependencies.add(record.parent_id)
-        return dependencies
+    def _reference_targets_locked(self, note_id: str) -> set[str]:
+        return set(self._backlink_index.get_target_ids(note_id)) & self._note_map.keys()
+
+    def _referrers_locked(self, note_id: str) -> set[str]:
+        return self._backlink_index.get_counts(note_id).keys() & self._note_map.keys()
 
-    def _tag_dependents_locked(self, note_id: str) -> set[str]:
-        return (set(self._get_children_locked(note_id))
-                | (self._backlink_index.get_counts(note_id).keys() & self._note_map.keys()))
+    def _inherited_tag_terms_locked(
+        self, note_id: str, effective: Dict[str, FrozenSet[str]], subtree: Dict[str, FrozenSet[str]],
+    ) -> FrozenSet[str]:
+        terms = frozenset().union(*(subtree[target] for target in self._reference_targets_locked(note_id)))
+        parent_id = self._note_map[note_id].parent_id
+        if parent_id is not None:
+            terms |= effective[parent_id]
+        return terms
 
     def _raw_tag_terms_locked(self, note_id: str) -> FrozenSet[str]:
         record = self._note_map[note_id]
@@ -153,20 +158,46 @@ class NoteStore:
             raise RuntimeError("Integrity failure: unreachable notes during tag inheritance")
         self._effective_non_meta_tag_terms.clear()
         self._effective_proposed_non_meta_tag_terms.clear()
+        self._subtree_non_meta_tag_terms.clear()
+        self._subtree_proposed_non_meta_tag_terms.clear()
+        self._propagate_subtree_tag_terms_locked(visited)
         return self._propagate_inherited_tag_terms_locked(visited)
 
-    def _recompute_effective_tag_terms_locked(self, root_ids: Iterable[str]) -> Dict[str, FrozenSet[str]]:
-        # Include both hierarchy descendants and referrers, transitively. Rebuilding
-        # this closure from direct tags also removes stale tags from reference cycles.
+    def _recompute_effective_tag_terms_locked(
+        self, root_ids: Iterable[str], *, subtree_root_ids: Iterable[str],
+    ) -> Dict[str, FrozenSet[str]]:
+        roots = set(root_ids)
+        # Subtree contributions flow upward and across references, never through
+        # inherited parent tags. Include former parents after moves/deletions.
+        subtree_affected: set[str] = set()
+        pending = list(roots | set(subtree_root_ids))
+        effective_roots = set(roots)
+        while pending:
+            note_id = pending.pop()
+            assert note_id in self._note_map
+            if note_id in subtree_affected:
+                continue
+            subtree_affected.add(note_id)
+            referrers = self._referrers_locked(note_id)
+            effective_roots.update(referrers)
+            pending.extend(referrers - subtree_affected)
+            parent_id = self._note_map[note_id].parent_id
+            if parent_id is not None:
+                pending.append(parent_id)
+        self._assert_acyclic_parent_paths_locked(subtree_affected)
+        self._propagate_subtree_tag_terms_locked(subtree_affected)
+
+        # Ordinary inheritance flows down from changed notes and referrers only;
+        # siblings of an edited source descendant need no search-index update.
         affected: set[str] = set()
-        pending = list(root_ids)
+        pending = list(effective_roots)
         while pending:
             note_id = pending.pop()
             assert note_id in self._note_map
             if note_id in affected:
                 continue
             affected.add(note_id)
-            pending.extend(self._tag_dependents_locked(note_id) - affected)
+            pending.extend(set(self._get_children_locked(note_id)) - affected)
         self._assert_acyclic_parent_paths_locked(affected)
         return self._propagate_inherited_tag_terms_locked(affected)
 
@@ -183,39 +214,64 @@ class NoteStore:
             visited.update(path)
 
     def _propagate_inherited_tag_terms_locked(self, affected: set[str]) -> Dict[str, FrozenSet[str]]:
-        dependents = {note_id: set() for note_id in affected}
+        dependencies = {}
         for note_id in affected:
             record = self._note_map[note_id]
-            accepted = record.non_meta_tag_terms
-            proposed = record.proposed_non_meta_tag_terms
-            for source_id in self._tag_dependencies_locked(note_id):
-                if source_id in affected:
+            targets = self._reference_targets_locked(note_id)
+            self._effective_non_meta_tag_terms[note_id] = record.non_meta_tag_terms | frozenset().union(
+                *(self._subtree_non_meta_tag_terms[target] for target in targets))
+            self._effective_proposed_non_meta_tag_terms[note_id] = (
+                record.proposed_non_meta_tag_terms | frozenset().union(
+                    *(self._subtree_proposed_non_meta_tag_terms[target] for target in targets)))
+            dependencies[note_id] = set()
+            if record.parent_id is not None:
+                dependencies[note_id].add(record.parent_id)
+        self._propagate_tag_dependencies_locked(
+            dependencies, self._effective_non_meta_tag_terms, self._effective_proposed_non_meta_tag_terms)
+        return {note_id: self._raw_tag_terms_locked(note_id) for note_id in affected}
+
+    def _propagate_subtree_tag_terms_locked(self, affected: set[str]) -> None:
+        dependencies = {}
+        for note_id in affected:
+            record = self._note_map[note_id]
+            self._subtree_non_meta_tag_terms[note_id] = record.non_meta_tag_terms
+            self._subtree_proposed_non_meta_tag_terms[note_id] = record.proposed_non_meta_tag_terms
+            dependencies[note_id] = (set(self._get_children_locked(note_id))
+                                     | self._reference_targets_locked(note_id))
+        self._propagate_tag_dependencies_locked(
+            dependencies, self._subtree_non_meta_tag_terms, self._subtree_proposed_non_meta_tag_terms)
+
+    @staticmethod
+    def _propagate_tag_dependencies_locked(
+        dependencies: Dict[str, set[str]],
+        accepted_terms: Dict[str, FrozenSet[str]], proposed_terms: Dict[str, FrozenSet[str]],
+    ) -> None:
+        # Callers reset the affected closure to direct contributions first, so
+        # cycles converge to the least fixed point even when tags are removed.
+        dependents: Dict[str, set[str]] = {note_id: set() for note_id in dependencies}
+        for note_id, sources in dependencies.items():
+            assert note_id in accepted_terms and note_id in proposed_terms
+            for source_id in sources:
+                if source_id in dependencies:
                     dependents[source_id].add(note_id)
                 else:
-                    accepted |= self._effective_non_meta_tag_terms[source_id]
-                    proposed |= self._effective_proposed_non_meta_tag_terms[source_id]
-            self._effective_non_meta_tag_terms[note_id] = accepted
-            self._effective_proposed_non_meta_tag_terms[note_id] = proposed
-
-        pending = deque(affected)
-        queued = set(affected)
+                    accepted_terms[note_id] |= accepted_terms[source_id]
+                    proposed_terms[note_id] |= proposed_terms[source_id]
+        pending = deque(dependencies)
+        queued = set(dependencies)
         while pending:
             source_id = pending.popleft()
             queued.remove(source_id)
             for note_id in dependents[source_id]:
-                accepted = (self._effective_non_meta_tag_terms[note_id]
-                            | self._effective_non_meta_tag_terms[source_id])
-                proposed = (self._effective_proposed_non_meta_tag_terms[note_id]
-                            | self._effective_proposed_non_meta_tag_terms[source_id])
-                if (accepted == self._effective_non_meta_tag_terms[note_id]
-                        and proposed == self._effective_proposed_non_meta_tag_terms[note_id]):
+                accepted = accepted_terms[note_id] | accepted_terms[source_id]
+                proposed = proposed_terms[note_id] | proposed_terms[source_id]
+                if accepted == accepted_terms[note_id] and proposed == proposed_terms[note_id]:
                     continue
-                self._effective_non_meta_tag_terms[note_id] = accepted
-                self._effective_proposed_non_meta_tag_terms[note_id] = proposed
+                accepted_terms[note_id] = accepted
+                proposed_terms[note_id] = proposed
                 if note_id not in queued:
                     pending.append(note_id)
                     queued.add(note_id)
-        return {note_id: self._raw_tag_terms_locked(note_id) for note_id in affected}
 
     def _publish_tag_updates(self, raw_terms_by_id: Dict[str, FrozenSet[str]]) -> None:
         if not raw_terms_by_id:
@@ -242,6 +298,8 @@ class NoteStore:
             self._ordering = NoteOrdering()
             self._effective_non_meta_tag_terms.clear()
             self._effective_proposed_non_meta_tag_terms.clear()
+            self._subtree_non_meta_tag_terms.clear()
+            self._subtree_proposed_non_meta_tag_terms.clear()
             self._loaded = False
             search_index.rebuild(
                 [],
@@ -625,7 +683,7 @@ class NoteStore:
             self._backlink_index.upsert(record.id, record.content, record.tags)
             self._insert_link(record.parent_id, record.id, record.prev_id, record.next_id)
 
-            tag_updates = self._recompute_effective_tag_terms_locked({record.id})
+            tag_updates = self._recompute_effective_tag_terms_locked({record.id}, subtree_root_ids=())
             effective_tag_terms = tag_updates.pop(record.id)
 
         ontology = get_ontology()
@@ -699,7 +757,8 @@ class NoteStore:
                     tag_sources_changed = True
 
             if tag_sources_changed:
-                effective_tag_terms_by_id = self._recompute_effective_tag_terms_locked({note.id})
+                effective_tag_terms_by_id = self._recompute_effective_tag_terms_locked(
+                    {note.id}, subtree_root_ids=())
             else:
                 effective_tag_terms = self._raw_tag_terms_locked(updated.id)
 
@@ -751,7 +810,11 @@ class NoteStore:
             self._insert_link(note.parent_id, note.id, note.prev_id, next_id)
             tag_updates = {}
             if record.parent_id != note.parent_id:
-                tag_updates = self._recompute_effective_tag_terms_locked({note.id})
+                former_parents = set()
+                if record.parent_id is not None:
+                    former_parents.add(record.parent_id)
+                tag_updates = self._recompute_effective_tag_terms_locked(
+                    {note.id}, subtree_root_ids=former_parents)
         self._publish_tag_updates(tag_updates)
 
     def bulk_update_metadata(self, notes: Iterable[SimpleNamespace], *, rebuild: bool) -> None:
@@ -768,6 +831,7 @@ class NoteStore:
             self._revision += 1
             replacements = {}
             moved_ids: Set[str] = set()
+            former_parents: Set[str] = set()
 
             for note in payload:
                 record = self._note_map[note.id]
@@ -792,6 +856,8 @@ class NoteStore:
                 replacements[note.id] = updated
                 if record.parent_id != updated.parent_id:
                     moved_ids.add(note.id)
+                    if record.parent_id is not None:
+                        former_parents.add(record.parent_id)
             next_records = dict(self._note_map)
             next_records.update(replacements)
             if moved_ids:
@@ -801,7 +867,8 @@ class NoteStore:
             self._ordering = next_ordering
 
             if moved_ids:
-                tag_updates = self._recompute_effective_tag_terms_locked(moved_ids)
+                tag_updates = self._recompute_effective_tag_terms_locked(
+                    moved_ids, subtree_root_ids=former_parents)
 
         self._publish_tag_updates(tag_updates)
 
@@ -833,9 +900,14 @@ class NoteStore:
                 self._backlink_index.remove(removed_id)
                 self._effective_non_meta_tag_terms.pop(removed_id, None)
                 self._effective_proposed_non_meta_tag_terms.pop(removed_id, None)
+                self._subtree_non_meta_tag_terms.pop(removed_id, None)
+                self._subtree_proposed_non_meta_tag_terms.pop(removed_id, None)
 
+            former_parents = set()
+            if root.parent_id is not None:
+                former_parents.add(root.parent_id)
             tag_updates = self._recompute_effective_tag_terms_locked(
-                referrer_ids & self._note_map.keys())
+                referrer_ids & self._note_map.keys(), subtree_root_ids=former_parents)
 
         if removed_ids:
             search_index.remove_many(removed_ids)
@@ -939,8 +1011,8 @@ class NoteStore:
             if record is None:
                 raise KeyError(f"Note {note_id} not present in NoteStore")
 
-            return frozenset().union(*(self._effective_non_meta_tag_terms[source_id]
-                                       for source_id in self._tag_dependencies_locked(note_id)))
+            return self._inherited_tag_terms_locked(
+                note_id, self._effective_non_meta_tag_terms, self._subtree_non_meta_tag_terms)
 
     def get_inherited_proposed_non_meta_tag_terms(self, note_id: str) -> FrozenSet[str]:
         if not isinstance(note_id, str) or not note_id:
@@ -950,8 +1022,8 @@ class NoteStore:
                 raise RuntimeError("NoteStore is not loaded")
             if note_id not in self._note_map:
                 raise KeyError(f"Note {note_id} not present in NoteStore")
-            return frozenset().union(*(self._effective_proposed_non_meta_tag_terms[source_id]
-                                       for source_id in self._tag_dependencies_locked(note_id)))
+            return self._inherited_tag_terms_locked(
+                note_id, self._effective_proposed_non_meta_tag_terms, self._subtree_proposed_non_meta_tag_terms)
 
     def apply_bulk_tag_sources(self, changes: Mapping[str, tuple[str, str]]) -> None:
         """Publish sources together and rebuild inheritance once for the whole pass."""

{metalist-0.6.3 → metalist-0.7.1}/app/static/css/main.css

@@ -5565,6 +5565,11 @@ body.pref-show-ai-chat .chat-toggle-button {
 }
 
 /* Loading state styling */
+#version-info-modal:has([data-update-pending="true"]),
+#version-info-modal:has([data-update-pending="true"]) * {
+    cursor: wait !important;
+}
+
 body.loading {
     cursor: wait !important;
 }

{metalist-0.6.3 → metalist-0.7.1}/app/static/js/modules/modals/version-info-modal.js

@@ -124,6 +124,10 @@ export class VersionInfoModal extends BaseModal {
         const loading = state.loading === true;
         const error = typeof state.error === 'string' ? state.error : '';
         const info = state.info;
+        let isUpdating = state.updatePending;
+        if (state.updateJob !== null && !['complete', 'failed'].includes(state.updateJob.status)) {
+            isUpdating = true;
+        }
 
         let bodyHtml = '<p class="version-info-status">Loading version info...</p>';
         if (!loading && info !== null) {
@@ -137,7 +141,7 @@ export class VersionInfoModal extends BaseModal {
             <div class="modal-content version-info-modal-content">
                 <h3>Version Info</h3>
                 ${bodyHtml}
-                <section class="version-update-section" aria-live="polite">
+                <section class="version-update-section" aria-live="polite" data-update-pending="${isUpdating}">
                     <p>${escapeHtml(state.updateMessage)}</p>
                     ${this.buildUpdateControls(state)}
                 </section>