superlocalmemory 3.4.52 → 3.4.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "superlocalmemory",
-  "version": "3.4.52",
+  "version": "3.4.54",
   "description": "Information-geometric agent memory with mathematical guarantees. 4-channel retrieval, Fisher-Rao similarity, zero-LLM mode, EU AI Act compliant. Works with Claude, Cursor, Windsurf, and 17+ AI tools.",
   "keywords": [
     "ai-memory",

package/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superlocalmemory"
-version = "3.4.52"
+version = "3.4.54"
 description = "Information-geometric agent memory with mathematical guarantees"
 readme = "README.md"
 license = {text = "AGPL-3.0-or-later"}

package/src/superlocalmemory/__init__.py

@@ -3,7 +3,7 @@
 import os
 os.environ.setdefault("KMP_DUPLICATE_LIB_OK", "TRUE")
 
-__version__ = "3.4.52"
+__version__ = "3.4.54"
 
 _REQUIRED_VERSIONS = {
     "sentence_transformers": "5.3.0",

package/src/superlocalmemory/cli/commands.py

@@ -652,30 +652,11 @@ def cmd_mode(args: Namespace) -> None:
 
     config = SLMConfig.load()
 
-    def _apply_mode_change(new_value: str) -> tuple[SLMConfig, bool]:
-        """Mutate-in-place mode switch. Returns (updated_config, llm_was_set).
-
-        Only changes ``config.mode``. If the user has no LLM provider
-        configured AND is moving to Mode B or C, populates the mode's
-        default LLM block so the daemon has something to talk to.
-        Everything else (embedding, retrieval, evolution, forgetting,
-        math, profile) is preserved byte-for-byte.
-        """
-        new_mode = Mode(new_value)
-        llm_was_set = False
-        if new_mode != Mode.A and not config.llm.provider:
-            defaults = SLMConfig.for_mode(new_mode)
-            config.llm = defaults.llm
-            llm_was_set = True
-        config.mode = new_mode
-        config.save(mode_change=True)
-        return config, llm_was_set
-
     if getattr(args, 'json', False):
         from superlocalmemory.cli.json_output import json_print
         if args.value:
             old_mode = config.mode.value.upper()
-            updated, _ = _apply_mode_change(args.value)
+            updated = SLMConfig.switch_mode(args.value)
             json_print("mode", data={
                 "previous_mode": old_mode, "current_mode": args.value.upper(),
             }, next_actions=[
@@ -690,22 +671,17 @@ def cmd_mode(args: Namespace) -> None:
         return
 
     if args.value:
-        updated, llm_was_set = _apply_mode_change(args.value)
+        updated = SLMConfig.switch_mode(args.value)
         print(f"Mode set to: {args.value.upper()}")
-
-        # v3.4.43: embedding/retrieval are now preserved, so the old
-        # "Embedding model changed. Re-indexing will run on next recall."
-        # warning no longer fires from a CLI mode switch — that was the
-        # symptom of the bug. The warning is retained ONLY as an
-        # informational note when LLM defaults were freshly populated.
-        if llm_was_set:
-            print(f"  ℹ LLM provider populated from mode defaults: "
-                  f"{updated.llm.provider}/{updated.llm.model}. "
-                  f"Run `slm provider set` to customize.")
+        print(f"  Embedding: {updated.embedding.provider}/{updated.embedding.model_name}")
+        if args.value.lower() != "a":
+            print(f"  LLM: {updated.llm.provider}/{updated.llm.model}")
+        print(f"  Reranker: ONNX cross-encoder (enabled)")
 
         # V3.3.4: Warn if Mode C lacks cloud API key
         if args.value == "c" and not updated.llm.api_key:
             print("  ⚠ Mode C requires a cloud API key. Run: slm provider set")
+        print("  ℹ Run `slm restart` to apply the new mode.")
     else:
         print(f"Current mode: {config.mode.value.upper()}")
 

package/src/superlocalmemory/core/config.py

@@ -12,9 +12,12 @@ Part of Qualixar | Author: Varun Pratap Bhardwaj
 
 from __future__ import annotations
 
+import logging
 from dataclasses import dataclass, field
 from pathlib import Path
 
+logger = logging.getLogger(__name__)
+
 from superlocalmemory.storage.models import Mode
 
 
@@ -25,6 +28,9 @@ from superlocalmemory.storage.models import Mode
 DEFAULT_BASE_DIR = Path.home() / ".superlocalmemory"
 DEFAULT_DB_NAME = "memory.db"
 DEFAULT_PROFILES_FILE = "profiles.json"
+CURRENT_MODE_FILE = "current_mode"
+# Populated lazily in _get_mode_config_path() to avoid circular imports
+_MODE_CONFIG_NAMES: dict | None = None
 
 
 # ---------------------------------------------------------------------------
@@ -950,3 +956,180 @@ class SLMConfig:
                 sheaf_contradiction_threshold=0.65,  # Higher for 3072d embeddings
             ),
         )
+
+    # ------------------------------------------------------------------
+    # 3-Mode config system (v3.4.54)
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _mode_config_path(base_dir: Path, mode: "Mode") -> Path:
+        """Return the per-mode config file path."""
+        from superlocalmemory.storage.models import Mode as _M
+        _names = {
+            _M.A: "mode_a.json",
+            _M.B: "mode_b.json",
+            _M.C: "mode_c.json",
+        }
+        return base_dir / _names.get(mode, "mode_a.json")
+
+    @staticmethod
+    def read_current_mode(base_dir: Path | None = None) -> str:
+        """Read the current mode from the ``current_mode`` file.
+
+        Returns ``\"b\"`` (the default) if the file doesn't exist.
+        """
+        _base = base_dir or DEFAULT_BASE_DIR
+        _f = _base / CURRENT_MODE_FILE
+        try:
+            return _f.read_text(encoding="utf-8").strip().lower() or "b"
+        except (OSError, FileNotFoundError):
+            return "b"
+
+    @staticmethod
+    def write_current_mode(mode: str, base_dir: Path | None = None) -> None:
+        """Write the current mode letter to ``current_mode``."""
+        _base = base_dir or DEFAULT_BASE_DIR
+        _base.mkdir(parents=True, exist_ok=True)
+        (_base / CURRENT_MODE_FILE).write_text(
+            mode.lower().strip(), encoding="utf-8",
+        )
+
+    @classmethod
+    def switch_mode(
+        cls,
+        new_mode: str,
+        base_dir: Path | None = None,
+    ) -> "SLMConfig":
+        """Switch to a different mode, preserving the old mode's config.
+
+        v3.4.54: Saves the current config as ``mode_{old}.json``, then
+        loads ``mode_{new}.json`` (or creates it from defaults if it
+        doesn't exist). Writes ``current_mode`` and persists the new
+        active config as ``config.json`` for backward compatibility
+        with tooling that reads it directly.
+
+        Returns the new active config.
+        """
+        from superlocalmemory.storage.models import Mode as _M
+        _base = base_dir or DEFAULT_BASE_DIR
+        _base.mkdir(parents=True, exist_ok=True)
+
+        old_config = cls.load(_base / "config.json")
+        old_mode = old_config.mode.value.lower()
+
+        new_mode_val = _M(new_mode.lower())
+
+        # 1. Save current config to its per-mode file (unless already
+        #    matched — prevents overwriting user customizations)
+        if old_mode != new_mode.lower():
+            old_path = cls._mode_config_path(_base, old_config.mode)
+            old_config.save(old_path)
+
+        # 2. Try to load the target mode's saved config.
+        new_path = cls._mode_config_path(_base, new_mode_val)
+        need_migration = False
+        if new_path.exists():
+            try:
+                new_config = cls.load(new_path)
+                # Ensure the loaded config actually has the right mode
+                if new_config.mode != new_mode_val:
+                    new_config = cls.for_mode(new_mode_val, base_dir=_base)
+            except Exception:
+                new_config = cls.for_mode(new_mode_val, base_dir=_base)
+        else:
+            # First time switching to this mode: try migrating from
+            # legacy config.json if it was already in this mode
+            legacy = _base / "config.json"
+            if legacy.exists():
+                try:
+                    import json
+                    _data = json.loads(legacy.read_text(encoding="utf-8"))
+                    _legacy_mode = _data.get("mode", "").lower()
+                    if _legacy_mode == new_mode.lower():
+                        # config.json IS this mode — use it directly
+                        new_config = cls.load(legacy)
+                        need_migration = True
+                    else:
+                        new_config = cls.for_mode(new_mode_val, base_dir=_base)
+                except Exception:
+                    new_config = cls.for_mode(new_mode_val, base_dir=_base)
+            else:
+                new_config = cls.for_mode(new_mode_val, base_dir=_base)
+
+        # 3. Save as active config.json (backward compat)
+        new_config.save(_base / "config.json", mode_change=True)
+
+        # 4. Write current_mode
+        cls.write_current_mode(new_mode, _base)
+
+        # 5. On first migration, also save mode_a.json and mode_c.json
+        #    so users have a complete set
+        if need_migration:
+            for _m in (_M.A, _M.B, _M.C):
+                _mp = cls._mode_config_path(_base, _m)
+                if not _mp.exists():
+                    try:
+                        _mc = cls.for_mode(_m, base_dir=_base)
+                        _mc.save(_mp)
+                    except Exception:
+                        pass
+
+        return new_config
+
+    @classmethod
+    def migrate_to_3mode(cls, base_dir: Path | None = None) -> bool:
+        """One-time migration: config.json → 3-mode system.
+
+        Called on daemon boot. Idempotent — if ``current_mode`` already
+        exists, this is a no-op. Returns True if migration was performed.
+        """
+        _base = base_dir or DEFAULT_BASE_DIR
+        _current = _base / CURRENT_MODE_FILE
+        if _current.exists():
+            return False  # already migrated
+
+        legacy = _base / "config.json"
+        if not legacy.exists():
+            # No config at all — write defaults and current_mode
+            from superlocalmemory.storage.models import Mode as _M
+            _def = cls.for_mode(_M.B, base_dir=_base)
+            _def.save(legacy)
+            cls.write_current_mode("b", _base)
+            for _m in (_M.A, _M.B, _M.C):
+                _mp = cls._mode_config_path(_base, _m)
+                if not _mp.exists():
+                    try:
+                        _mc = cls.for_mode(_m, base_dir=_base)
+                        _mc.save(_mp)
+                    except Exception:
+                        pass
+            return True
+
+        # Migrate existing config.json → mode_{current}.json
+        try:
+            config = cls.load(legacy)
+            current = config.mode.value.lower()
+            cls.write_current_mode(current, _base)
+
+            # Save current config to its mode file
+            mode_path = cls._mode_config_path(_base, config.mode)
+            config.save(mode_path)
+
+            # Generate other mode files from defaults
+            from superlocalmemory.storage.models import Mode as _M
+            for _m in (_M.A, _M.B, _M.C):
+                _mp = cls._mode_config_path(_base, _m)
+                if not _mp.exists():
+                    try:
+                        _mc = cls.for_mode(_m, base_dir=_base)
+                        _mc.save(_mp)
+                    except Exception:
+                        pass
+
+            logger.info(
+                "3-mode config system migrated: config.json → mode_%s.json. "
+                "All three mode configs generated.", current,
+            )
+            return True
+        except Exception:
+            return False

package/src/superlocalmemory/retrieval/engine.py

@@ -451,7 +451,17 @@ class RetrievalEngine:
     def _run_channels(
         self, query: str, profile_id: str, strat: QueryStrategy,
     ) -> dict[str, list[tuple[str, float]]]:
-        """Run active retrieval channels. Respects disabled_channels config for ablation."""
+        """Run active retrieval channels.
+
+        v3.4.53: channels run in PARALLEL via ThreadPoolExecutor. Industry
+        standard (EverMemOS, szl-recall, ContentPilot 2026): all channels
+        are independent after embedding; running them serially wastes time
+        equal to the sum of all channel latencies. Parallel execution brings
+        total channel time from sum(semantic+bm25+entity+temporal+hopfield+sa)
+        down to max(semantic,bm25,entity,temporal,hopfield,sa) — roughly a
+        3-5x speedup for the channel phase.
+        """
+        import concurrent.futures
         out: dict[str, list[tuple[str, float]]] = {}
         # Skip channels listed in disabled_channels (ablation support)
         # V3.4.40: union with per-recall extra_disabled set (e.g. --fast skip)
@@ -475,51 +485,55 @@ class RetrievalEngine:
             except Exception as exc:
                 logger.warning("Query embedding failed: %s", exc)
 
-        if self._semantic is not None and q_emb is not None and "semantic" not in disabled:
-            try:
-                r = self._semantic.search(q_emb, profile_id, self._config.semantic_top_k)
-                if r:
-                    out["semantic"] = r
-            except Exception as exc:
-                logger.warning("Semantic channel: %s", exc)
-
-        if self._bm25 is not None and "bm25" not in disabled:
-            try:
-                r = self._bm25.search(query, profile_id, self._config.bm25_top_k)
-                if r:
-                    out["bm25"] = r
-            except Exception as exc:
-                logger.warning("BM25 channel: %s", exc)
-
-        # V3.4.12: entity_graph is now a signal enhancer (post-RRF boost),
-        # not an independent channel. Removed from channel execution to avoid
-        # running spreading activation twice. See score_candidates() in engine.recall().
-
-        if self._temporal is not None and "temporal" not in disabled:
-            try:
-                r = self._temporal.search(query, profile_id, top_k=self._config.bm25_top_k)
-                if r:
-                    out["temporal"] = r
-            except Exception as exc:
-                logger.warning("Temporal channel: %s", exc)
+        # v3.4.53: collect channel callables and run in parallel.
+        # Each channel is a standalone search — no shared mutable state,
+        # no ordering dependencies. SQLite WAL mode permits concurrent reads.
+        futures: dict[str, concurrent.futures.Future] = {}
 
-        # Phase G: Hopfield channel (6th) — energy-based pattern completion
-        if self._hopfield is not None and q_emb is not None and "hopfield" not in disabled:
+        def _safe_channel(name: str, fn, *args):
+            """Run a single channel, returning (name, result_or_None)."""
             try:
-                r = self._hopfield.search(q_emb, profile_id, self._config.hopfield_top_k)
-                if r:
-                    out["hopfield"] = r
+                res = fn(*args)
+                return (name, res if res else None)
             except Exception as exc:
-                logger.warning("Hopfield channel: %s", exc)
+                logger.warning("%s channel: %s", name, exc)
+                return (name, None)
+
+        with concurrent.futures.ThreadPoolExecutor(max_workers=6) as executor:
+            if self._semantic is not None and q_emb is not None and "semantic" not in disabled:
+                futures["semantic"] = executor.submit(
+                    _safe_channel, "semantic",
+                    self._semantic.search, q_emb, profile_id, self._config.semantic_top_k,
+                )
+            if self._bm25 is not None and "bm25" not in disabled:
+                futures["bm25"] = executor.submit(
+                    _safe_channel, "bm25",
+                    self._bm25.search, query, profile_id, self._config.bm25_top_k,
+                )
+            if self._temporal is not None and "temporal" not in disabled:
+                futures["temporal"] = executor.submit(
+                    _safe_channel, "temporal",
+                    self._temporal.search, query, profile_id, self._config.bm25_top_k,
+                )
+            if self._hopfield is not None and q_emb is not None and "hopfield" not in disabled:
+                futures["hopfield"] = executor.submit(
+                    _safe_channel, "hopfield",
+                    self._hopfield.search, q_emb, profile_id, self._config.hopfield_top_k,
+                )
+            if self._spreading_activation is not None and q_emb is not None and "spreading_activation" not in disabled:
+                futures["spreading_activation"] = executor.submit(
+                    _safe_channel, "spreading_activation",
+                    self._spreading_activation.search, q_emb, profile_id, self._config.bm25_top_k,
+                )
 
-        # Phase 3: Spreading Activation channel (5th) — graph-based associative recall
-        if self._spreading_activation is not None and q_emb is not None and "spreading_activation" not in disabled:
-            try:
-                r = self._spreading_activation.search(q_emb, profile_id, self._config.bm25_top_k)
-                if r:
-                    out["spreading_activation"] = r
-            except Exception as exc:
-                logger.warning("Spreading activation channel: %s", exc)
+            # Collect results as channels complete
+            for name, fut in futures.items():
+                try:
+                    ch_name, result = fut.result(timeout=30)
+                    if result:
+                        out[ch_name] = result
+                except Exception as exc:
+                    logger.warning("Channel %s timed out or failed: %s", name, exc)
 
         # Apply registered post-retrieval filters (forgetting filter, etc.)
         if hasattr(self, '_registry') and self._registry._filters:

package/src/superlocalmemory/retrieval/reranker.py

@@ -56,7 +56,11 @@ _IDLE_TIMEOUT_SECONDS = 300  # V3.4.37: 5 min (was 30) — balance cold-start vs
 # V3.4.19: Bumped from 120 → 1800 in lock-step with the embedding worker.
 # Set ``SLM_RERANKER_IDLE_TIMEOUT=120`` + ``slm restart`` to revert.
 _IDLE_TIMEOUT_SECONDS = int(os.environ.get("SLM_RERANKER_IDLE_TIMEOUT", _IDLE_TIMEOUT_SECONDS))
-_SUBPROCESS_RESPONSE_TIMEOUT = 180  # V3.3.12: 180s (was 120s) for stressed system respawns
+_SUBPROCESS_RESPONSE_TIMEOUT = 15  # v3.4.52: 15s (was 180s). Long timeout blocked the
+# entire FastAPI event loop — a dead reranker subprocess held ALL
+# endpoints hostage for 3 minutes. 15s is enough for ONNX inference
+# cold start; if the worker can't respond, we fall back to fusion
+# scores without reranking.
 _WORKER_RECYCLE_AFTER = 500  # Recycle after N requests
 
 
@@ -231,16 +235,26 @@ class CrossEncoderReranker:
             logger.warning("Failed to spawn reranker worker: %s", exc)
             self._worker_proc = None
 
-    def _send_request(self, req: dict, timeout: float | None = None) -> dict | None:
+    def _send_request(self, req: dict, timeout: float | None = None,
+                      block: bool = True) -> dict | None:
         """Send JSON request to worker, get response. Thread-safe.
 
         Uses a short timeout (10s) for rerank requests since the model
         should already be loaded by the background warmup. Uses the full
         timeout only for explicit load/ping commands.
+
+        v3.4.52: when ``block=False``, uses ``try_lock`` instead of
+        ``lock.acquire()``. If another thread is already using the
+        reranker subprocess, returns ``None`` immediately (the caller
+        falls back to fusion scores without reranking). This prevents
+        concurrent recall requests from serialising on the lock.
         """
         effective_timeout = timeout or _SUBPROCESS_RESPONSE_TIMEOUT
 
-        with self._lock:
+        acquired = self._lock.acquire(blocking=block)
+        if not acquired:
+            return None  # another request is using the subprocess
+        try:
             if self._request_count >= _WORKER_RECYCLE_AFTER and self._worker_proc is not None:
                 logger.info("Recycling reranker worker after %d requests", self._request_count)
                 self._kill_worker()
@@ -253,31 +267,32 @@ class CrossEncoderReranker:
             if self._worker_proc is None:
                 return None
 
-            try:
-                msg = json.dumps(req) + "\n"
-                self._worker_proc.stdin.write(msg)
-                self._worker_proc.stdin.flush()
+            msg = json.dumps(req) + "\n"
+            self._worker_proc.stdin.write(msg)
+            self._worker_proc.stdin.flush()
 
-                resp_line = self._readline_with_timeout(
-                    self._worker_proc.stdout,
-                    effective_timeout,
-                )
-                if not resp_line:
-                    logger.warning("Reranker worker timed out after %ds", effective_timeout)
-                    self._kill_worker()
-                    self._model_loaded = False
-                    return None
-
-                resp = json.loads(resp_line)
-                self._reset_idle_timer()
-                self._request_count += 1
-                return resp
-            except (BrokenPipeError, OSError, json.JSONDecodeError) as exc:
-                logger.warning("Reranker worker communication failed: %s", exc)
+            resp_line = self._readline_with_timeout(
+                self._worker_proc.stdout,
+                effective_timeout,
+            )
+            if not resp_line:
+                logger.warning("Reranker worker timed out after %ds", effective_timeout)
                 self._kill_worker()
                 self._model_loaded = False
                 return None
 
+            resp = json.loads(resp_line)
+            self._reset_idle_timer()
+            self._request_count += 1
+            return resp
+        except (BrokenPipeError, OSError, json.JSONDecodeError) as exc:
+            logger.warning("Reranker worker communication failed: %s", exc)
+            self._kill_worker()
+            self._model_loaded = False
+            return None
+        finally:
+            self._lock.release()
+
     @staticmethod
     def _readline_with_timeout(stream: Any, timeout_seconds: float) -> str:
         """Read a line from stream with timeout. Returns '' on timeout."""
@@ -363,14 +378,16 @@ class CrossEncoderReranker:
 
         documents = [fact.content for fact, _ in candidates]
 
-        # V3.3.16: Timeout 180s — ONNX CoreML compilation can take 30-60s on
-        # first inference even after model load. The warmup_inference in the
-        # worker should prevent this, but 180s is a safety net.
+        # v3.4.53: block=False — if another recall is using the reranker
+        # subprocess, skip reranking and return fusion scores directly.
+        # This prevents concurrent recalls from serialising on the lock.
+        # 15s timeout (was 180s) — warm ONNX inference takes ~100ms; if
+        # the worker can't respond in 15s it's dead and we fall back.
         resp = self._send_request({
             "cmd": "rerank",
             "query": query,
             "documents": documents,
-        }, timeout=180.0)
+        }, timeout=15.0, block=False)
 
         if resp is None or not resp.get("ok"):
             # Fallback: return by existing score

package/src/superlocalmemory/server/unified_daemon.py

@@ -156,6 +156,13 @@ from superlocalmemory.core.recall_gate import (
 # daemon startup via engine._process_pending_memories().
 _engine = None
 
+# v3.4.53: Limit concurrent full (non-fast) recalls. Without this, N parallel
+# /recall calls spawn N × 6-channel threads → Ollama serialises, reranker
+# lock queues, and total wall time is N × single-recall-time. 3 concurrent
+# full recalls gives parallelism benefit without resource oversaturation.
+import asyncio as _asyncio
+_recall_semaphore = _asyncio.Semaphore(3)
+
 # v3.4.52: Embedding model warm state. Set to True by the async pre-warm
 # thread once Ollama has loaded the embedding model. /health reports this
 # so MCP clients can wait for warm state before issuing recall calls.
@@ -439,6 +446,9 @@ async def lifespan(application: FastAPI):
         from superlocalmemory.core.config import SLMConfig
         from superlocalmemory.core.engine import MemoryEngine
 
+        # v3.4.54: one-time migration config.json → 3-mode system
+        SLMConfig.migrate_to_3mode()
+
         config = SLMConfig.load()
         engine = MemoryEngine(config)
         engine.initialize()
@@ -1167,9 +1177,22 @@ def _register_daemon_routes(application: FastAPI) -> None:
             import time as _t
             effective_sid = f"http:{int(_t.time() * 1000)}"
         # v3.4.32: mark recall in-flight so the pending materializer pauses
+        # v3.4.52: run engine.recall() in a thread-pool executor so the
+        # FastAPI event loop stays responsive for /health, /remember, and
+        # concurrent /recall requests. Without this, a single slow full
+        # recall (reranker timeout, cold embedder) blocks ALL endpoints.
+        import asyncio
         _begin_recall()
+        # v3.4.53: Full (non-fast) recalls are gated by a semaphore to
+        # prevent resource oversaturation. Ollama serialises concurrent
+        # embedding calls and the reranker subprocess has a single lock —
+        # queuing more than ~3 concurrent full recalls just adds latency.
+        # Fast recalls (SQLite/BM25 only) skip the semaphore.
+        if not fast:
+            await _recall_semaphore.acquire()
         try:
-            response = engine.recall(
+            response = await asyncio.to_thread(
+                engine.recall,
                 search_query, limit=limit, session_id=effective_sid,
                 fast=fast,
             )
@@ -1228,6 +1251,8 @@ def _register_daemon_routes(application: FastAPI) -> None:
         except Exception as exc:
             raise HTTPException(500, detail=str(exc))
         finally:
+            if not fast:
+                _recall_semaphore.release()
             _end_recall()
 
     @application.post("/remember")

package/src/superlocalmemory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superlocalmemory
-Version: 3.4.52
+Version: 3.4.54
 Summary: Information-geometric agent memory with mathematical guarantees
 Author-email: Varun Pratap Bhardwaj <admin@superlocalmemory.com>
 License: AGPL-3.0-or-later