splent-cli 1.25.1__tar.gz → 1.26.0__tar.gz

{splent_cli-1.25.1/src/splent_cli.egg-info → splent_cli-1.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.25.1
+Version: 1.26.0
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 Project-URL: Homepage, https://github.com/diverso-lab/splent_cli

{splent_cli-1.25.1 → splent_cli-1.26.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.25.1"
+version = "1.26.0"
 description = "SPLENT-CLI is a CLI to be able to work on your development more easily."
 readme = "README.md"
 requires-python = ">=3.13"

{splent_cli-1.25.1 → splent_cli-1.26.0}/src/splent_cli/commands/export/export_puml.py

@@ -788,7 +788,7 @@ def export_puml(
     product = context.require_app()
     product_dir = os.path.join(workspace, product)
 
-    # Read UVL — try SPL catalog first, fall back to legacy [tool.splent.uvl]
+    # Read UVL — the model the product's SPL pin names first, then legacy [tool.splent.uvl]
     import tomllib
 
     uvl_path = None

splent_cli-1.26.0/src/splent_cli/commands/feature/feature_discard.py

@@ -0,0 +1,105 @@
+import os
+import click
+import tomllib
+from splent_cli.services import context
+from splent_cli.utils.cache_utils import rmtree_force
+from splent_cli.utils.feature_utils import (
+    editable_feature_dir,
+    find_feature_entries,
+    get_normalize_feature_name_in_splent_format,
+    normalize_namespace,
+    parse_feature_entry,
+)
+
+
+DEFAULT_NAMESPACE = os.getenv("SPLENT_DEFAULT_NAMESPACE", "splent_io")
+
+
+def _products_declaring_editable(workspace, feature_name, ns_safe) -> list[str]:
+    """The products in the workspace that declare the feature without a version.
+
+    Those are the ones running the editable copy, and the ones that break when
+    it goes. The match ignores how the namespace is spelled.
+    """
+    used_in = []
+    for item in sorted(os.listdir(workspace)):
+        pyproject_path = os.path.join(workspace, item, "pyproject.toml")
+        if not os.path.isfile(pyproject_path):
+            continue
+        try:
+            with open(pyproject_path, "rb") as f:
+                data = tomllib.load(f)
+        except (OSError, tomllib.TOMLDecodeError):
+            continue
+        for _, entry in find_feature_entries(data, feature_name, namespace=ns_safe):
+            if parse_feature_entry(entry)[2] is None:
+                used_in.append(item)
+                break
+    return used_in
+
+
+@click.command(
+    "feature:discard",
+    short_help="Delete the editable copy of a feature from the workspace root (snapshots kept).",
+)
+@click.argument("feature_name", required=True)
+@click.option("--namespace", default=DEFAULT_NAMESPACE, help="Feature namespace.")
+@context.requires_product
+def feature_discard(feature_name, namespace):
+    """
+    Delete the editable copy of a feature, the checkout at the workspace root:
+
+      - Warns when a product in the workspace declares it without a version.
+      - Removes ONLY that checkout, never the versioned snapshots in the cache.
+    """
+
+    workspace = str(context.workspace())
+    ns_safe = normalize_namespace(namespace)
+    feature_name = get_normalize_feature_name_in_splent_format(feature_name)
+
+    # Editable copies live at the workspace root, next to splent_cli and
+    # splent_framework. This used to look under .splent_cache/features/, where
+    # they were kept before, and so never found one.
+    editable_path = editable_feature_dir(workspace, feature_name, ns_safe)
+
+    # 1) Check if editable exists
+    if editable_path is None:
+        click.echo(
+            f"ℹ️ No editable copy of {feature_name} at the workspace root. "
+            "Nothing to discard."
+        )
+        return
+
+    click.echo(f"🧩 Editable feature detected at:\n   {editable_path}")
+
+    # 2) Detect products using this editable feature
+    used_in = _products_declaring_editable(workspace, feature_name, ns_safe)
+
+    if used_in:
+        click.echo("⚠️ This editable feature is currently being used in:")
+        for product in used_in:
+            click.echo(f"   - {product}")
+
+        if not click.confirm(
+            "Do you want to continue and break these products?", default=False
+        ):
+            click.echo("🚫 Aborted. Nothing removed.")
+            raise SystemExit(1)
+
+    # 3) Delete the checkout. A copy that came out of the cache through
+    # feature:unlock may still carry read-only files, so a plain rmtree would
+    # raise PermissionError and leave a partial delete.
+    click.echo("🗑️ Removing editable feature folder...")
+    try:
+        rmtree_force(editable_path)
+    except OSError as e:
+        raise click.ClickException(
+            f"Failed to remove editable feature at {editable_path}: {e}\n"
+            "Check filesystem permissions and that no process is using the folder."
+        )
+
+    click.echo("✅ Editable feature removed.")
+    click.echo("🎯 All versioned snapshots preserved.")
+
+
+cli_command = feature_discard

{splent_cli-1.25.1 → splent_cli-1.26.0}/src/splent_cli/commands/feature/feature_pull.py

@@ -2,21 +2,11 @@ import subprocess
 import click
 from pathlib import Path
 from splent_cli.services import context
-from splent_cli.utils.feature_utils import normalize_namespace
-
-
-def _editable_features(cache_root: Path) -> list:
-    """Return list of (namespace, name, path) for all editable (non-versioned) cache entries."""
-    result = []
-    if not cache_root.exists():
-        return result
-    for ns_dir in sorted(cache_root.iterdir()):
-        if not ns_dir.is_dir():
-            continue
-        for feat_dir in sorted(ns_dir.iterdir()):
-            if feat_dir.is_dir() and "@" not in feat_dir.name:
-                result.append((ns_dir.name, feat_dir.name, feat_dir))
-    return result
+from splent_cli.utils.feature_utils import (
+    editable_feature_dirs,
+    get_normalize_feature_name_in_splent_format,
+    normalize_namespace,
+)
 
 
 def _git_pull(path: Path) -> tuple:
@@ -40,25 +30,30 @@ def _git_pull(path: Path) -> tuple:
 
 
 @click.command(
-    "feature:pull", short_help="Git pull on one or all editable features in cache."
+    "feature:pull",
+    short_help="Git pull on one or all editable features at the workspace root.",
 )
 @click.argument("feature_ref", required=False)
 @context.requires_product
 def feature_pull(feature_ref):
     """
-    Run git pull on editable (non-versioned) features in the local cache.
+    Run git pull on the editable features, the checkouts at the workspace root.
 
     \b
     With no arguments, pulls all editable features.
     With FEATURE_REF (e.g. splent_io/splent_feature_auth), pulls only that one.
     """
     workspace = context.workspace()
-    cache_root = workspace / ".splent_cache" / "features"
 
-    all_features = _editable_features(cache_root)
+    # Editable copies live at the workspace root. This used to walk
+    # .splent_cache/features/ for directories without a version, where they
+    # were kept before, and so always found nothing.
+    all_features = [
+        (ns, name, Path(path)) for ns, name, path in editable_feature_dirs(workspace)
+    ]
 
     if not all_features:
-        click.secho("ℹ️  No editable features found in cache.", fg="yellow")
+        click.secho("ℹ️  No editable features at the workspace root.", fg="yellow")
         return
 
     if feature_ref:
@@ -67,6 +62,7 @@ def feature_pull(feature_ref):
         if "/" in feature_ref:
             ns_filter, name_filter = feature_ref.split("/", 1)
             ns_filter = normalize_namespace(ns_filter)
+        name_filter = get_normalize_feature_name_in_splent_format(name_filter)
 
         targets = [
             f
@@ -75,7 +71,8 @@ def feature_pull(feature_ref):
         ]
         if not targets:
             click.secho(
-                f"⚠️  No editable cache entry found for '{feature_ref}'.", fg="yellow"
+                f"⚠️  No editable copy of '{feature_ref}' at the workspace root.",
+                fg="yellow",
             )
             return
     else:

{splent_cli-1.25.1 → splent_cli-1.26.0}/src/splent_cli/commands/feature/feature_remove.py

@@ -68,30 +68,6 @@ def feature_remove(feature_name, namespace, env_scope, force):
     product_path = os.path.join(workspace, product)
     short = feature_name.replace("splent_feature_", "")
 
-    if not force:
-        # Guard: dependency check
-        dependents = get_dependents(product_path, feature_name)
-        if dependents:
-            click.secho(
-                f"  Cannot remove '{short}': the following features depend on it:\n"
-                + "".join(f"    - {d}\n" for d in dependents)
-                + "  Remove those first, or use --force.",
-                fg="red",
-            )
-            raise SystemExit(1)
-
-        # Guard: migration state
-        key = feature_key(org_safe, feature_name)
-        state = get_feature_state(product_path, key)
-        if state == "migrated":
-            click.secho(
-                f"  {short} has migrations applied (state: {state}).\n"
-                f"  Roll them back first: splent db:rollback {feature_name} --steps 999\n"
-                f"  Or use --force.",
-                fg="red",
-            )
-            raise SystemExit(1)
-
     # ── Update pyproject.toml ─────────────────────────────────────────
     pyproject_path = os.path.join(product_path, "pyproject.toml")
     if not os.path.exists(pyproject_path):
@@ -105,6 +81,39 @@ def feature_remove(feature_name, namespace, env_scope, force):
     # normalizes the namespace spelling (splent-io == splent_io) and ignores any
     # pinned version, so every spelling of the entry is caught.
     keys = (f"features_{env_scope}",) if env_scope else FEATURE_LIST_KEYS
+    declared = find_feature_entries(data, feature_name, namespace=org_safe, keys=keys)
+
+    if not force:
+        # Guard: dependency check
+        dependents = get_dependents(product_path, feature_name)
+        if dependents:
+            click.secho(
+                f"  Cannot remove '{short}': the following features depend on it:\n"
+                + "".join(f"    - {d}\n" for d in dependents)
+                + "  Remove those first, or use --force.",
+                fg="red",
+            )
+            raise SystemExit(1)
+
+        # Guard: migration state. The manifest is keyed on the version, so
+        # the state is looked up under the key of each declaration about to
+        # go, plus the bare key, which is what a pinned feature removed by
+        # name alone used to be checked against, and never matched.
+        candidates = {feature_key(org_safe, feature_name)}
+        for _, entry in declared:
+            _, entry_name, entry_version = parse_feature_entry(entry)
+            candidates.add(feature_key(org_safe, entry_name, entry_version))
+        for key in sorted(candidates):
+            state = get_feature_state(product_path, key)
+            if state in ("migrated", "active"):
+                click.secho(
+                    f"  {short} has migrations applied (state: {state}).\n"
+                    f"  Roll them back first: splent db:rollback {feature_name} --steps 999\n"
+                    f"  Or use --force.",
+                    fg="red",
+                )
+                raise SystemExit(1)
+
     removed = drop_feature_entries(data, feature_name, namespace=org_safe, keys=keys)
     # What survives the removal, e.g. a features entry when --dev was used.
     remaining = find_feature_entries(data, feature_name, namespace=org_safe)

{splent_cli-1.25.1 → splent_cli-1.26.0}/src/splent_cli/commands/feature/feature_unlock.py

@@ -8,6 +8,7 @@ from splent_cli.utils import forge
 from splent_cli.utils.cache_utils import make_feature_writable
 from splent_cli.utils.proc import run
 from splent_cli.utils.io_utils import load_toml, atomic_write
+from splent_cli.utils.manifest import feature_key, remove_feature, set_feature_state
 
 
 # =====================================================================
@@ -307,6 +308,22 @@ def _edit_one(
         os.unlink(new)
         os.symlink(rel_target, new)
 
+    # The manifest is keyed on the version. Without this the product kept
+    # reporting the feature as pinned at a version it no longer declared,
+    # and the editable copy it now runs had no record at all.
+    product = os.path.basename(product_path)
+    remove_feature(product_path, product, feature_key(ns_fs, name, version))
+    set_feature_state(
+        product_path,
+        product,
+        feature_key(ns_fs, name),
+        "declared",
+        namespace=ns_fs,
+        name=name,
+        version=None,
+        mode="editable",
+    )
+
     # Reinstall via pip in the product's web container so the running
     # Flask process picks up the new location without a manual restart.
     _hot_reinstall(workspace, product_path, editable_path, name)

{splent_cli-1.25.1 → splent_cli-1.26.0}/src/splent_cli/commands/feature/feature_upgrade.py

@@ -3,13 +3,19 @@ import tomllib
 from pathlib import Path
 
 import click
+import tomli_w
 from packaging.version import Version, InvalidVersion
 
 from splent_cli.services import context, registry
 from splent_cli.utils.feature_utils import (
+    find_feature_entries,
     normalize_namespace,
+    prune_feature_links,
+    read_feature_list,
     read_features_from_data,
+    write_features_to_data,
 )
+from splent_cli.utils.io_utils import atomic_write, load_toml
 
 
 # ── GitHub helpers ────────────────────────────────────────────────────────────
@@ -76,22 +82,22 @@ def _read_features(pyproject_path: Path) -> list[dict]:
     return result
 
 
-def _update_pyproject(
-    pyproject_path: Path,
-    ns_github: str,
-    name: str,
-    old_ver: str | None,
-    new_ver: str,
-):
-    content = pyproject_path.read_text()
-    if old_ver:
-        content = content.replace(f"{name}@{old_ver}", f"{name}@{new_ver}")
-    else:
-        # editable entry: append version
-        content = content.replace(
-            f"{ns_github}/{name}", f"{ns_github}/{name}@{new_ver}"
-        )
-    pyproject_path.write_text(content)
+def _update_pyproject(pyproject_path: Path, ns_fs: str, name: str, new_ver: str):
+    """Move every declaration of the feature to *new_ver*, in place.
+
+    The entry is rewritten where it is declared, with the namespace spelled
+    the way it already is. This used to be a text replace that spelled the
+    namespace as the forge does (splent-io), while products spell it as the
+    package does (splent_io), so an editable entry never matched: the
+    symlink moved to the new version and the declaration stayed editable.
+    """
+    data = load_toml(pyproject_path, what="pyproject.toml")
+    for key, entry in find_feature_entries(data, name, namespace=ns_fs):
+        base = entry.partition("@")[0]
+        entries = read_feature_list(data, key)
+        entries[entries.index(entry)] = f"{base}@{new_ver}"
+        write_features_to_data(data, entries, key=key)
+    atomic_write(pyproject_path, tomli_w.dumps(data))
 
 
 # ── Cache / clone helpers ─────────────────────────────────────────────────────
@@ -118,25 +124,19 @@ def _clone_if_missing(ns_fs: str, name: str, version: str, cache_root: Path):
 
 
 def _update_symlink(
-    product_path: Path,
-    ns_fs: str,
-    name: str,
-    old_ver: str | None,
-    new_ver: str,
-    cache_root: Path,
+    product_path: Path, ns_fs: str, name: str, new_ver: str, cache_root: Path
 ):
     features_dir = product_path / "features" / ns_fs
     features_dir.mkdir(parents=True, exist_ok=True)
-    if old_ver:
-        old_link = features_dir / f"{name}@{old_ver}"
-        if old_link.is_symlink():
-            old_link.unlink()
     new_link = features_dir / f"{name}@{new_ver}"
     target = cache_root / ns_fs / f"{name}@{new_ver}"
     if new_link.is_symlink():
         new_link.unlink()
     rel_target = os.path.relpath(str(target), str(features_dir))
     new_link.symlink_to(rel_target)
+    # The link the previous declaration created, name@old for a pinned
+    # feature or plain name for an editable one, and any other leftover.
+    prune_feature_links(str(product_path), ns_fs, name, keep=new_link.name)
 
 
 # ── Command ───────────────────────────────────────────────────────────────────
@@ -244,7 +244,7 @@ def feature_upgrade(feature_ref, yes):
 
     click.echo()
     from splent_cli.utils.lifecycle import require_state
-    from splent_cli.utils.manifest import feature_key
+    from splent_cli.utils.manifest import feature_key, remove_feature, set_feature_state
 
     for u in upgrades:
         # Guard: cannot upgrade a feature with applied migrations
@@ -256,20 +256,22 @@ def feature_upgrade(feature_ref, yes):
 
         try:
             _clone_if_missing(u["ns_fs"], u["name"], u["latest"], cache_root)
-            _update_pyproject(
-                pyproject_path,
-                u["ns_github"],
-                u["name"],
-                u["version"],
-                u["latest"],
-            )
+            _update_pyproject(pyproject_path, u["ns_fs"], u["name"], u["latest"])
             _update_symlink(
-                product_path,
-                u["ns_fs"],
-                u["name"],
-                u["version"],
-                u["latest"],
-                cache_root,
+                product_path, u["ns_fs"], u["name"], u["latest"], cache_root
+            )
+            # The manifest is keyed on the version, so the old record goes
+            # and the new version starts over as declared and pinned.
+            remove_feature(str(product_path), product, key)
+            set_feature_state(
+                str(product_path),
+                product,
+                feature_key(u["ns_fs"], u["name"], u["latest"]),
+                "declared",
+                namespace=u["ns_fs"],
+                name=u["name"],
+                version=u["latest"],
+                mode="pinned",
             )
             click.secho(f"  ✔  {u['ns_fs']}/{u['name']} → {u['latest']}", fg="green")
         except Exception as e:

{splent_cli-1.25.1 → splent_cli-1.26.0}/src/splent_cli/commands/marketplace/marketplace_index.py

@@ -2,11 +2,12 @@
 marketplace:index — Build the marketplace index from the real sources.
 
 The index is a regenerable cache: every entry derives from a feature's
-[tool.splent.contract] (read at its latest released tag on GitHub, or from
-the workspace in --local mode) plus the SPL catalog. Publishing a feature
-is `splent feature:release` — the tag IS the publication; this command just
-picks it up. There is no server, no upload, and nothing to keep in sync by
-hand: when in doubt, rebuild.
+[tool.splent.contract] (read at its latest released tag on the forge, or from
+the workspace in --local mode) plus the SPL lines the marketplace publishes
+(or the models the workspace knows, in --local mode). Publishing a feature
+is `splent feature:release`, and publishing an SPL is `splent spl:publish`;
+this command just picks both up. Nothing is kept in sync by hand: when in
+doubt, rebuild.
 """
 
 import os
@@ -14,7 +15,8 @@ from pathlib import Path
 
 import click
 
-from splent_cli.services import context, marketplace, registry
+from splent_cli.services import context, marketplace, marketplace_api, registry
+from splent_cli.services.marketplace_url import InvalidRegistryURL, resolve_registry
 from splent_cli.utils.io_utils import load_toml
 
 
@@ -78,7 +80,9 @@ def marketplace_index(orgs, repos, registry_file, local, output, no_pypi):
     The index is derived from:
       - [tool.splent.contract] of each feature at its latest released tag
         (or the workspace pyprojects with --local)
-      - every SPL model the workspace knows: UVL structure and constraints
+      - every SPL line the marketplace publishes, at the DOI it publishes
+        (or every SPL model the workspace knows, with --local): UVL
+        structure and constraints
       - computed relations: used_by (reverse deps) and provides collisions
 
     \b
@@ -147,7 +151,21 @@ def marketplace_index(orgs, repos, registry_file, local, output, no_pypi):
             click.secho("  Index NOT written.", fg="red")
             raise SystemExit(1)
 
-    spls = marketplace.build_spls(workspace)
+    if local:
+        spls = marketplace.build_spls(workspace)
+        marketplace_url = None
+    else:
+        try:
+            marketplace_url = resolve_registry(None).url
+            click.echo(f"  spls     marketplace: {marketplace_url}")
+            lines = marketplace_api.MarketplaceClient(marketplace_url).list_spls()
+        except (InvalidRegistryURL, marketplace_api.MarketplaceError) as e:
+            # Same rule as the features: an index without the product lines
+            # must never overwrite a good one.
+            click.secho(f"  ❌ Could not read the SPL lines. {e}", fg="red")
+            click.secho("  Index NOT written.", fg="red")
+            raise SystemExit(1)
+        spls = marketplace.build_published_spls(workspace, lines)
 
     index = marketplace.assemble_index(
         features,
@@ -156,6 +174,7 @@ def marketplace_index(orgs, repos, registry_file, local, output, no_pypi):
             "orgs": org_list if not local else [],
             "repos": repo_list if not local else [],
             "workspace": local,
+            "marketplace": marketplace_url,
         },
     )
 

{splent_cli-1.25.1 → splent_cli-1.26.0}/src/splent_cli/commands/product/product_configure.py

@@ -887,7 +887,7 @@ def product_configure():
     Interactive SPL feature configurator.
 
     \b
-    Reads the UVL model from the SPL catalog, walks the full feature tree
+    Reads the product's SPL model (UVL), walks the full feature tree
     recursively, respects mandatory/optional/alternative/or/cardinality
     group semantics, propagates constraints (including parent-chain,
     excludes, and contrapositive), validates with Flamapy,

{splent_cli-1.25.1 → splent_cli-1.26.0}/src/splent_cli/commands/product/product_validate.py

@@ -62,20 +62,6 @@ def _infer_parents(uvl_path: str, selected: set[str]) -> set[str]:
     return extra
 
 
-def _catalog_migration_hint(workspace):
-    """Name the migration when the workspace still depends on splent_catalog.
-
-    Before the pin existed the catalog held every DOI, so an unmigrated
-    workspace cannot resolve any model and every phase that needs one fails
-    for the same single reason.
-    """
-    from splent_cli.services import spl_store
-
-    if spl_store.catalog_migration_pending(workspace):
-        return spl_store.MIGRATE_HINT
-    return None
-
-
 def _run_sat_check(workspace, app_name, data, feature_list, print_config):
     """Run UVL SAT check. Returns (ok, selected, universe, uvl_path)."""
     local_uvl = _resolve_uvl_path(workspace, app_name, data)
@@ -296,9 +282,6 @@ def product_validate(feature_list, pyproject, print_config, only):
                 "proved either way",
                 fg="red",
             )
-            hint = _catalog_migration_hint(workspace)
-            if hint:
-                click.secho(f"     {hint}", fg="yellow")
             failed = True
         elif sat_ok:
             click.secho(

{splent_cli-1.25.1 → splent_cli-1.26.0}/src/splent_cli/commands/spl/spl_create.py

@@ -40,8 +40,8 @@ def spl_create(name):
     uvl_path = spl_dir / spl_store.uvl_filename(name)
     uvl_path.write_text(f"features\n\t{name}\n", encoding="utf-8")
 
-    # Unlike the old catalog, the model itself is tracked here. Only the
-    # backups spl:add-feature leaves behind are noise.
+    # The model itself is tracked here. Only the backups spl:add-feature
+    # leaves behind are noise.
     (spl_dir / ".gitignore").write_text("*.uvl.bak\n", encoding="utf-8")
 
     click.secho(f"  SPL '{name}' created at {spl_dir}", fg="green")

{splent_cli-1.25.1 → splent_cli-1.26.0}/src/splent_cli/commands/spl/spl_info.py

@@ -78,14 +78,6 @@ def spl_info(spl_name):
         )
     else:
         click.echo(click.style("Status      : no model and no DOI", fg="red"))
-        # The DOI is very likely sitting in splent_catalog, unmigrated. Saying
-        # so here saves the reader from concluding the model is simply lost.
-        if spl_store.catalog_entry(workspace, spl_name) is not None:
-            click.secho(
-                "              splent_catalog still describes it. "
-                f"{spl_store.MIGRATE_HINT}",
-                fg="yellow",
-            )
 
     click.echo()
 

{splent_cli-1.25.1 → splent_cli-1.26.0}/src/splent_cli/commands/spl/spl_list.py

@@ -51,18 +51,5 @@ def spl_list():
             click.secho(f"  {' ' * width}  {pin.description}", dim=True)
     click.echo()
 
-    # A workspace that predates the pin has a splent_catalog holding every DOI
-    # and no product carrying one, so every row above reads "no model". Naming
-    # the fix here is the whole point: this is the command someone runs to find
-    # out what is wrong, and the hint used to live only behind a hard failure.
-    pending = spl_store.catalog_migration_pending(workspace)
-    if pending:
-        click.secho(
-            f"  {len(pending)} of these are still described only by splent_catalog.",
-            fg="yellow",
-        )
-        click.echo(f"  {spl_store.MIGRATE_HINT}")
-        click.echo()
-
 
 cli_command = spl_list

{splent_cli-1.25.1 → splent_cli-1.26.0}/src/splent_cli/commands/spl/spl_utils.py

@@ -15,9 +15,8 @@ def _resolve_spl_metadata(spl_name: str) -> dict:
     """Everything known about an SPL, in the shape metadata.toml used to have.
 
     Kept in the old shape because callers pass it straight to
-    :func:`_fetch_uvl`. The values no longer come from a catalog checkout:
-    they are merged from the product that pins the model, the working copy,
-    and the cache, in that order.
+    :func:`_fetch_uvl`. The values are merged from the product that pins the
+    model, the working copy, and the cache, in that order.
     """
     workspace = str(context.workspace())
     pin = spl_store.read_pin(workspace, spl_name)