splent-cli 1.42.0__tar.gz → 1.44.0__tar.gz

{splent_cli-1.42.0/src/splent_cli.egg-info → splent_cli-1.44.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: splent_cli
-Version: 1.42.0
+Version: 1.44.0
 Summary: SPLENT-CLI is a CLI to be able to work on your development more easily.
 Author-email: DiversoLab <diversolab@us.es>
 License-Expression: LGPL-3.0-or-later

{splent_cli-1.42.0 → splent_cli-1.44.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "splent_cli"
-version = "1.42.0"
+version = "1.44.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.42.0 → splent_cli-1.44.0}/src/splent_cli/cli.py

@@ -5,10 +5,13 @@ import os
 import click
 from dotenv import load_dotenv
 
+from splent_cli.services import context
 from splent_cli.utils.command_loader import load_commands
 
 # From here on os.environ holds the workspace .env as well. What the shell
 # itself exported is splent_cli.SHELL_ENV, taken before this line ran.
+# Nothing exported is replaced, so a SPLENT_APP given to one command beats
+# the selection in the file (context.active_app has the whole rule).
 load_dotenv()
 
 
@@ -122,7 +125,7 @@ class SPLENTCLI(click.Group):
                 app = get_app()
                 with app.app_context():
                     self._own_cmds_cache = own_commands.collect(
-                        os.getenv("SPLENT_APP"), set(self.commands)
+                        context.active_app(), set(self.commands)
                     )
         except Exception as e:
             if debug:
@@ -170,7 +173,7 @@ class SPLENTCLI(click.Group):
         """
         from splent_cli.services import web_container
 
-        product = os.getenv("SPLENT_APP")
+        product = context.active_app()
         if not product or web_container.is_product_container():
             return
         if not web_container.running(web_container.name(product)):
@@ -196,6 +199,12 @@ class SPLENTCLI(click.Group):
             from splent_cli.utils.dynamic_imports import get_app
             from splent_cli.utils.db_utils import check_db_connection
 
+            # For another product than the selection the CLI's container stays
+            # on the selection's network (compose.attach_self_to_network), so
+            # what reaches this product's services runs where they are.
+            if context.is_override():
+                self._delegate_to_the_product(ctx)
+
             try:
                 app = get_app()
             except Exception as exc:
@@ -205,7 +214,7 @@ class SPLENTCLI(click.Group):
                 # Only then: where the app builds here, the command runs here
                 # with the tools the CLI image has (ruff formats migrations).
                 self._delegate_to_the_product(ctx)
-                product = os.getenv("SPLENT_APP", "The product")
+                product = context.active_app() or "The product"
                 raise click.ClickException(
                     f"{product}'s features need {missing}, which the product's "
                     "image installs and the CLI's does not.\n"

{splent_cli-1.42.0 → splent_cli-1.44.0}/src/splent_cli/commands/check/check_env.py

@@ -8,6 +8,7 @@ import sys
 import click
 import importlib.metadata
 
+from splent_cli.services import context
 from splent_cli.services.release_gate import pypi_credentials
 from splent_cli.utils import forge
 
@@ -61,7 +62,7 @@ def check_env():
         _warn(".env file not found in workspace")
 
     # SPLENT_APP
-    app = os.getenv("SPLENT_APP")
+    app = context.active_app(workspace)
     if app:
         app_path = os.path.join(workspace, app)
         if os.path.isdir(app_path):

{splent_cli-1.42.0 → splent_cli-1.44.0}/src/splent_cli/commands/clear/clear_uploads.py

@@ -99,7 +99,7 @@ def resolve_uploads_dir(app=None) -> str:
     product or its package, anything holding one of them, or a directory with
     code at its top.
     """
-    product = os.getenv("SPLENT_APP", "")
+    product = context.active_app() or ""
     if not product or product in (".", "..") or os.sep in product or "/" in product:
         raise UploadsDirError(f"'{product}' is not a valid product name.")
 
@@ -279,7 +279,7 @@ def clear_uploads(env_dev, env_prod, yes):
         click.echo(click.style("Cannot specify both --dev and --prod.", fg="red"))
         raise SystemExit(1)
     env = context.resolve_env(env_dev, env_prod)
-    _run_where_the_uploads_are(os.getenv("SPLENT_APP", ""), env, yes)
+    _run_where_the_uploads_are(context.active_app() or "", env, yes)
 
     try:
         uploads_dir = resolve_uploads_dir()

{splent_cli-1.42.0 → splent_cli-1.44.0}/src/splent_cli/commands/database/db_reset.py

@@ -199,7 +199,7 @@ def db_reset(feature_name, yes):
     """
     app = current_app
     product_path = PathUtils.get_app_base_dir()
-    product_name = os.getenv("SPLENT_APP", "")
+    product_name = context.active_app() or ""
 
     if feature_name:
         _reset_one_feature(app, feature_name, yes, product_path, product_name)

{splent_cli-1.42.0 → splent_cli-1.44.0}/src/splent_cli/commands/database/db_rollback.py

@@ -140,7 +140,7 @@ def _downgrade(directory: str, revision: str) -> None:
 def db_rollback(feature, steps, to_base, cascade):
     app = current_app
     product_path = PathUtils.get_app_base_dir()
-    product_name = os.getenv("SPLENT_APP", "")
+    product_name = context.active_app() or ""
 
     if to_base:
         source = click.get_current_context().get_parameter_source("steps")

{splent_cli-1.42.0 → splent_cli-1.44.0}/src/splent_cli/commands/database/db_seed.py

@@ -23,7 +23,7 @@ def _resolve_feature_order(features_raw: list[str]) -> list[str]:
     feature it refines (the refinement metadata the boot reads), with or
     without a UVL. Features with neither keep their declared order.
     """
-    splent_app = os.getenv("SPLENT_APP", "")
+    splent_app = context.active_app() or ""
     working_dir = os.getenv("WORKING_DIR", "/workspace")
     product_dir = os.path.join(working_dir, splent_app) if splent_app else ""
 
@@ -112,7 +112,7 @@ def _product_seeders(errors):
     They are always loaded, also when a single module is seeded, because
     their ``replaces`` decide which feature seeders may run at all.
     """
-    product = os.getenv("SPLENT_APP", "")
+    product = context.active_app()
     if not product:
         return []
     return _load_seeders(f"{product}.seeders", errors, label="product seeders")
@@ -154,7 +154,7 @@ def get_installed_seeders(specific_module=None):
     )
 
     targets = _module_names(specific_module) if specific_module else None
-    if targets and os.getenv("SPLENT_APP", "") in targets:
+    if targets and context.active_app() in targets:
         return product_seeders, errors
 
     seeders = []

{splent_cli-1.42.0 → splent_cli-1.44.0}/src/splent_cli/commands/database/db_upgrade.py

@@ -79,7 +79,7 @@ def _mark_without_migrations(
 
 def _resolve_product():
     """Return (product_path, product_name) from env."""
-    product = os.getenv("SPLENT_APP", "")
+    product = context.active_app() or ""
     product_path = PathUtils.get_app_base_dir()
     return product_path, product
 

{splent_cli-1.42.0 → splent_cli-1.44.0}/src/splent_cli/commands/doctor.py

@@ -19,6 +19,7 @@ from splent_cli.commands.check.check_product import check_product
 from splent_cli.commands.feature.feature_status import feature_status
 from splent_cli.commands.database.db_status import db_status
 from splent_cli.commands.product.product_containers import product_docker
+from splent_cli.services import context
 
 
 SECTIONS = [
@@ -74,7 +75,7 @@ def _check_workspace_precondition():
     elif not os.path.isdir(wd):
         problems.append(f"WORKING_DIR points to a missing directory: {wd}")
 
-    app = os.getenv("SPLENT_APP")
+    app = context.active_app(workspace)
     if not app:
         problems.append("SPLENT_APP is not set")
     elif not os.path.isdir(os.path.join(workspace, app)):

{splent_cli-1.42.0 → splent_cli-1.44.0}/src/splent_cli/commands/feature/feature_compile.py

@@ -123,6 +123,63 @@ def _container_workspace(container_id: str, workspace: str) -> tuple[str | None,
     return None, mounted
 
 
+def webpack_container(product: str, env: str, workspace: str) -> tuple[str | None, str]:
+    """Where webpack runs for *product*: ``(container id, its workspace path)``.
+
+    The container is None inside the product's web container, where webpack
+    is at hand. Elsewhere (the CLI container, the host) it is the product's
+    running web container of *env*, and the path is where that container
+    sees *workspace*. Raises ClickException when there is none to run in.
+    feature:release --dry-run asks it too, to say whether the bundle can be
+    built.
+    """
+    if _is_product_container():
+        return None, workspace
+
+    product_path = os.path.join(workspace, product)
+    docker_dir = os.path.join(product_path, "docker")
+    compose_file = compose.resolve_file(product_path, env)
+
+    if not compose_file:
+        raise click.ClickException(
+            f"No docker-compose file found for {product} ({env})"
+        )
+
+    project_name = compose.project_name(product, env)
+    container_id = compose.find_main_container(project_name, compose_file, docker_dir)
+    host = _on_host()
+    if not container_id and host:
+        container_id = _web_container_by_label(product, env)
+
+    if not container_id:
+        raise click.ClickException(
+            f"No running container found for {product} ({env}). "
+            f"Start it with splent product:up --{env}"
+        )
+
+    if not host:
+        return container_id, workspace
+
+    # webpack runs in the container, so it needs the container's paths, and
+    # only a container that mounts this workspace has the sources being
+    # compiled.
+    container_workspace, mounted = _container_workspace(container_id, workspace)
+    if container_workspace is None and mounted:
+        raise click.ClickException(
+            f"The {product} web container runs the workspace at "
+            f"{mounted}, not this one ({workspace}). Start this "
+            "workspace's product, or compile from the workspace that "
+            "runs it."
+        )
+    if container_workspace is None:
+        raise click.ClickException(
+            f"The {product} web container does not mount this "
+            f"workspace ({workspace}), so webpack cannot reach the "
+            "sources there."
+        )
+    return container_id, container_workspace
+
+
 @click.command(
     "feature:compile",
     short_help="Compile frontend assets (webpack) for one or all features.",
@@ -131,66 +188,32 @@ def _container_workspace(container_id: str, workspace: str) -> tuple[str | None,
 @click.option("--watch", is_flag=True, help="Enable watch mode for development.")
 @click.option("--dev", "env_dev", is_flag=True, help="Use development environment.")
 @click.option("--prod", "env_prod", is_flag=True, help="Use production environment.")
-def feature_compile(feature_name, watch, env_dev, env_prod):
-    production = os.getenv("FLASK_ENV", "develop") == "production" or env_prod
+@click.option(
+    "--release",
+    "release_build",
+    is_flag=True,
+    help="Build the bundle a release ships: production mode, into an emptied "
+    "assets/dist, and fail when the feature has nothing to build. "
+    "feature:release runs it.",
+)
+def feature_compile(feature_name, watch, env_dev, env_prod, release_build):
+    if release_build and watch:
+        raise click.UsageError("--release builds the bundle once; drop --watch.")
+    production = (
+        os.getenv("FLASK_ENV", "develop") == "production" or env_prod or release_build
+    )
 
     features = (
-        [get_normalize_feature_name_in_splent_format(feature_name)]
-        if feature_name
-        else get_features_from_pyproject()
+        [_feature_ref(feature_name)] if feature_name else get_features_from_pyproject()
     )
 
     env = context.resolve_env(env_dev, env_prod)
     product = context.require_app()
     workspace = str(context.workspace())
-    product_path = os.path.join(workspace, product)
 
     # If running inside the product's web container, webpack is available locally.
     # Otherwise (CLI container or host), delegate to the product container via docker exec.
-    container_workspace = workspace
-    if _is_product_container():
-        container_id = None
-    else:
-        docker_dir = os.path.join(product_path, "docker")
-        compose_file = compose.resolve_file(product_path, env)
-
-        if not compose_file:
-            raise click.ClickException(
-                f"No docker-compose file found for {product} ({env})"
-            )
-
-        project_name = compose.project_name(product, env)
-        container_id = compose.find_main_container(
-            project_name, compose_file, docker_dir
-        )
-        host = _on_host()
-        if not container_id and host:
-            container_id = _web_container_by_label(product, env)
-
-        if not container_id:
-            raise click.ClickException(
-                f"No running container found for {product} ({env}). "
-                f"Start it with splent product:up --{env}"
-            )
-
-        if host:
-            # webpack runs in the container, so it needs the container's
-            # paths, and only a container that mounts this workspace has the
-            # sources being compiled.
-            container_workspace, mounted = _container_workspace(container_id, workspace)
-            if container_workspace is None and mounted:
-                raise click.ClickException(
-                    f"The {product} web container runs the workspace at "
-                    f"{mounted}, not this one ({workspace}). Start this "
-                    "workspace's product, or compile from the workspace that "
-                    "runs it."
-                )
-            if container_workspace is None:
-                raise click.ClickException(
-                    f"The {product} web container does not mount this "
-                    f"workspace ({workspace}), so webpack cannot reach the "
-                    "sources there."
-                )
+    container_id, container_workspace = webpack_container(product, env, workspace)
 
     # Every feature is attempted, so one run reports every broken bundle, and
     # the exit code then says whether any failed: the production Dockerfile
@@ -206,6 +229,7 @@ def feature_compile(feature_name, watch, env_dev, env_prod):
             workspace,
             product,
             container_workspace=container_workspace,
+            release_build=release_build,
         )
     ]
     if failed and not watch:
@@ -217,6 +241,16 @@ def feature_compile(feature_name, watch, env_dev, env_prod):
         raise SystemExit(1)
 
 
+def _feature_ref(name: str) -> str:
+    """*name* as typed, with the ``splent_feature_`` prefix on the feature's
+    own name: ``auth`` and ``splent_io/auth`` are ``splent_feature_auth``
+    and ``splent_io/splent_feature_auth``. feature:release passes the
+    namespaced ref, and prefixing the whole of it looked for
+    ``splent_feature_splent_io/...`` and found no webpack config."""
+    namespace, sep, base = name.rpartition("/")
+    return f"{namespace}{sep}{get_normalize_feature_name_in_splent_format(base)}"
+
+
 def _find_webpack(workspace, product, org_safe, base_name, version):
     """Locate webpack.config.js for an editable feature.
 
@@ -242,6 +276,7 @@ def _compile_in_container(
     workspace,
     product,
     container_workspace=None,
+    release_build=False,
 ):
     """Compile one feature's assets. False only when webpack itself failed;
     a skipped feature (pinned, or without webpack.config.js) is not a failure.
@@ -249,6 +284,12 @@ def _compile_in_container(
     *container_workspace* is where the container that runs webpack sees the
     workspace. It differs from *workspace* only when the command runs on the
     host and delegates to the product's container.
+
+    *release_build* is feature:release's build (``--release``): webpack
+    empties assets/dist before it writes the bundle, so nothing a former
+    build left there ships with it, and a feature that would be skipped is a
+    failure, because the release would otherwise go on with whatever bundle
+    was there.
     """
     parts = feature.split("/")
     if len(parts) == 2:
@@ -263,6 +304,13 @@ def _compile_in_container(
     # Pinned features are immutable — never compile them.
     # Assets must be included at release time via feature:release.
     if version:
+        if release_build:
+            click.secho(
+                f"❌ {feature} is pinned ({version}): a release builds the "
+                "bundle of the working copy at the workspace root.",
+                fg="red",
+            )
+            return False
         click.echo(
             click.style(
                 f"    {feature} is pinned ({version}), skipping.",
@@ -274,6 +322,13 @@ def _compile_in_container(
     webpack_file = _find_webpack(workspace, product, org_safe, base_name, version)
 
     if not webpack_file:
+        if release_build:
+            click.secho(
+                f"❌ No webpack.config.js found in {feature} at the workspace "
+                "root, so there is no bundle to build.",
+                fg="red",
+            )
+            return False
         click.echo(
             click.style(
                 f"⚠ No webpack.config.js found in {feature}, skipping...", fg="yellow"
@@ -300,6 +355,8 @@ def _compile_in_container(
         cmd_parts.append("--watch")
     if not production:
         cmd_parts.extend(["--devtool=source-map", "--no-cache"])
+    if release_build:
+        cmd_parts.append("--output-clean")
 
     shell_cmd = " ".join(shlex.quote(p) for p in cmd_parts)
     cd_cmd = f"cd {shlex.quote(product_root)} && {shell_cmd}"
@@ -308,7 +365,20 @@ def _compile_in_container(
     # From the host: run via `docker exec` so webpack uses the container's
     # node_modules.
     if container_id:
-        run_cmd = ["docker", "exec", container_id, "bash", "-c", cd_cmd]
+        # As the workspace's owner, as feature:test runs there: an exec runs
+        # as root in a development image, and a file webpack creates in
+        # assets/dist (a release's <bundle>.LICENSE.txt) stayed root's.
+        from splent_cli.commands.feature.feature_test import workspace_user
+
+        run_cmd = [
+            "docker",
+            "exec",
+            *workspace_user(container_id),
+            container_id,
+            "bash",
+            "-c",
+            cd_cmd,
+        ]
         tool_hint = (
             "Install Docker Desktop or Docker Engine: "
             "https://docs.docker.com/get-docker/"

{splent_cli-1.42.0 → splent_cli-1.44.0}/src/splent_cli/commands/feature/feature_release.py

@@ -1845,38 +1845,164 @@ def _commands_help_block(commands_help: dict) -> str:
     return "".join(lines)
 
 
-# ── Compile assets ────────────────────────────────────────────────────
+# ── Frontend bundle ───────────────────────────────────────────────────
 
 
-def _compile_before_release(feature_name: str):
-    """Build the feature's frontend bundles, which the package ships.
+# How long the production build of one feature may take. A build cut short
+# stops the release, so the bound is generous: TinyMCE's takes seconds.
+_BUNDLE_TIMEOUT = 600
 
-    MANIFEST.in puts assets/dist in the wheel, so this runs before the build.
-    It runs this same CLI (``sys.executable -m splent_cli``), not whatever
-    ``splent`` is first on PATH, and webpack runs in the product's web
-    container, found from the host too. A failure never stops the release:
-    the package then ships the bundle the working tree already had.
+
+def _assets_dir(feature_path: str, namespace: str, feature_name: str) -> Path:
+    """``src/<org>/<feature>/assets``: the webpack config is in js/, and
+    webpack writes the bundle to dist/."""
+    return (
+        Path(feature_path)
+        / "src"
+        / normalize_namespace(namespace)
+        / feature_name
+        / "assets"
+    )
+
+
+def _bundle_files(feature_path: str, dist: Path) -> dict[str, str]:
+    """The sha256 of every file under *dist*, by path relative to the feature."""
+    import hashlib
+
+    if not dist.is_dir():
+        return {}
+    return {
+        path.relative_to(feature_path).as_posix(): hashlib.sha256(
+            path.read_bytes()
+        ).hexdigest()
+        for path in sorted(dist.rglob("*"))
+        if path.is_file()
+    }
+
+
+def _refuse_bundle(feature_ref: str, reason: str, output: str = "") -> None:
+    click.secho(
+        f"  error: the frontend bundle of {feature_ref} was not built: {reason}.",
+        fg="red",
+    )
+    lines = [line for line in output.splitlines() if line.strip()][-8:]
+    for line in lines:
+        click.secho(f"     {line}", fg="bright_black")
+    click.echo(
+        "  The release tags the bundle with the code, so it does not go on "
+        "without one.\n"
+        "  webpack runs in the product's web container (splent product:up "
+        "--dev starts it).\n"
+        f"  Try the build on its own with: splent feature:compile {feature_ref} "
+        "--release\n"
+        "  No version bump, no commit, no tag, no release."
+    )
+    raise SystemExit(1)
+
+
+def _build_bundle(feature_path: str, namespace: str, feature_name: str):
+    """Build the frontend bundle the release ships, or stop the release.
+
+    None for a feature without ``assets/js/webpack.config.js``, which has no
+    bundle. Otherwise the sha256 of every file the build left in
+    ``assets/dist``, by path relative to the feature, for
+    :func:`_stage_bundle`.
+
+    Every channel installs what the tag holds: the snapshot in .splent_cache
+    is a clone of it, pip builds a git+ install from it, and the wheel is
+    built from the same tree. assets/dist is gitignored, so the tags of 13
+    of uvlhub's 14 webpack features carried no bundle. Development served it
+    from the working copy at the workspace root, and the forge CI and an
+    image that installed from a tag answered 404. The release builds the
+    bundle in production mode, into an emptied assets/dist, before the
+    tests, and its commit carries it, so the tag, the wheel and the sdist
+    hold the same bytes (SD-01: what is verified is what is deployed).
+
+    A build that cannot run, fails, or writes no bundle stops the release
+    before anything versioned changes. It used to go on, and the package
+    then shipped whatever bundle the working tree had, stale or none.
     """
-    click.echo("  compile  building frontend assets...")
+    assets = _assets_dir(feature_path, namespace, feature_name)
+    if not (assets / "js" / "webpack.config.js").is_file():
+        return None
+    feature_ref = f"{namespace}/{feature_name}"
+    click.echo("  bundle   building assets/dist in production mode...")
+    # This same CLI (sys.executable -m splent_cli), not whatever splent is
+    # first on PATH, and webpack runs in the product's web container, found
+    # from the host too.
     try:
         result = subprocess.run(
-            [sys.executable, "-m", "splent_cli", "feature:compile", feature_name],
+            [
+                sys.executable,
+                "-m",
+                "splent_cli",
+                "feature:compile",
+                feature_ref,
+                "--release",
+            ],
             capture_output=True,
             text=True,
-            timeout=120,
+            timeout=_BUNDLE_TIMEOUT,
         )
     except subprocess.TimeoutExpired:
-        click.secho("  compile  timed out (120s)", fg="yellow")
-        return
+        _refuse_bundle(
+            feature_ref, f"webpack did not finish within {_BUNDLE_TIMEOUT} seconds"
+        )
     except OSError as e:
-        click.secho(f"  compile  skipped, the CLI could not run ({e})", fg="yellow")
-        return
-    if result.returncode == 0:
-        click.echo("  compile  done")
-        return
-    output = (result.stderr or result.stdout or "").strip()
-    detail = output.removeprefix("Error: ").strip()[:200] or "feature:compile failed"
-    click.secho(f"  compile  skipped, {detail}", fg="yellow")
+        _refuse_bundle(feature_ref, f"the CLI could not run ({e})")
+    if result.returncode != 0:
+        output = "\n".join(part for part in (result.stdout, result.stderr) if part)
+        _refuse_bundle(feature_ref, "feature:compile --release failed", output)
+
+    built = _bundle_files(feature_path, assets / "dist")
+    if not any(path.endswith(".js") for path in built):
+        _refuse_bundle(feature_ref, "webpack wrote no bundle to assets/dist")
+    click.echo(f"  bundle   built, {len(built)} file(s) in assets/dist")
+    return built
+
+
+def _stage_bundle(feature_path: str, namespace: str, feature_name: str, built) -> None:
+    """Put the bundle :func:`_build_bundle` built into the release commit.
+
+    assets/dist is gitignored, and the release commit stages what git tracks
+    and the new files it does not ignore, so the bundle is added here by
+    name (``git add -f``). A file the build no longer writes, a bundle
+    renamed or a source map dropped, is a tracked file gone, which the
+    commit stages as a deletion.
+
+    The commit has to carry the bundle the build wrote. Anything that
+    rewrote assets/dist since (a watch build of the same working copy)
+    would tag another one, and that stops the release here.
+    """
+    dist = _assets_dir(feature_path, namespace, feature_name) / "dist"
+    if _bundle_files(feature_path, dist) != built:
+        click.secho(
+            "  error: assets/dist changed after the release built it, so the "
+            "release commit would carry another bundle.",
+            fg="red",
+        )
+        click.echo(
+            "  Stop whatever rebuilds it (feature:compile --watch) and release "
+            "again.\n"
+            "  The version was bumped but not committed."
+        )
+        raise SystemExit(1)
+    try:
+        subprocess.run(
+            ["git", "add", "-f", "--", *built],
+            cwd=feature_path,
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+    except subprocess.CalledProcessError as e:
+        click.secho(
+            f"  error: git could not stage the bundle: {(e.stderr or '').strip() or e}",
+            fg="red",
+        )
+        click.echo("  The version was bumped but not committed.")
+        raise SystemExit(1)
+    click.echo("  bundle   assets/dist goes into the release commit")
 
 
 # ── Versioned snapshot ────────────────────────────────────────────────
@@ -2183,17 +2309,22 @@ def feature_release(
         else "this package does not publish to the forge"
     )
 
+    # The bundle the release ships, by path: built before the tests, so they
+    # run against it, and staged into the release commit, so the tag, the
+    # wheel and the sdist all carry it.
+    bundle: dict = {}
+
+    def _build(path, ver):
+        bundle["files"] = _build_bundle(path, namespace, feature_name)
+
     def _pre_commit(path, ver):
         click.echo("  contract updating from source code...")
         from splent_cli.commands.feature.feature_contract import update_contract
 
         update_contract(path, namespace, feature_name)
         click.echo("  contract written to pyproject.toml")
-        # Before the package is built, because the wheel ships assets/dist.
-        # Before the local release commit too, which stages everything, so a
-        # feature that tracks its bundles in git (auth does) commits the
-        # bundle just built, the same one the wheel ships.
-        _compile_before_release(feature_name)
+        if bundle.get("files") is not None:
+            _stage_bundle(path, namespace, feature_name, bundle["files"])
 
     def _post_pypi(path, ver):
         if release_gate.FORGE in channels:
@@ -2221,6 +2352,7 @@ def feature_release(
         channels=channels,
         resume_target=feature_name,
         allow_unfinished=allow_unfinished,
+        build_hook=_build,
         pre_commit_hook=_pre_commit,
         post_pypi_hook=_post_pypi,
         wait=wait,
@@ -2440,7 +2572,7 @@ def _dry_run(
 
     tag = f"v{version.lstrip('v')}"
     git_state = release_dry_run.read_git_state(feature_path, tag)
-    product = os.getenv("SPLENT_APP") or None
+    product = context.active_app()
 
     rehearsal = release_dry_run.rehearse_feature_release(
         feature_path=feature_path,