mammoth-cli 2.2.46__tar.gz → 2.2.48__tar.gz

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mammoth-cli
-Version: 2.2.46
+Version: 2.2.48
 Summary: Command-line interface for the Mammoth Analytics platform
 Project-URL: homepage, https://mammoth.io
 Project-URL: repository, https://github.com/EdgeMetric/mammothsdk
@@ -17,7 +17,7 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: <3.15,>=3.12
 Requires-Dist: jsonschema>=4.20
 Requires-Dist: keyring<26,>=25.7
-Requires-Dist: mammoth-io<0.9,>=0.8.24
+Requires-Dist: mammoth-io<0.9,>=0.8.26
 Requires-Dist: platformdirs<5,>=4.10
 Requires-Dist: pydantic<3,>=2.12.5
 Requires-Dist: pyyaml<7,>=6

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/__init__.py

@@ -6,7 +6,7 @@ not implement a second HTTP client and does not call private SDK members.
 
 from __future__ import annotations
 
-__version__ = "2.2.46"
+__version__ = "2.2.48"
 
 # The versioned machine output envelope contract.
 SCHEMA_VERSION = 1

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/app.py

@@ -46,6 +46,7 @@ from mammoth_cli.runtime import executor, validate
 from mammoth_cli.runtime.dataset_health import with_dataset_health
 from mammoth_cli.runtime.intent_only import refuse_hand_crafted_write
 from mammoth_cli.runtime.invocation import Invocation
+from mammoth_cli.runtime.locked_files import with_locked_files
 from mammoth_cli.runtime.new_data import with_new_data_path
 from mammoth_cli.runtime.state import with_state
 from mammoth_cli.runtime.strict import validate_extra_args
@@ -717,6 +718,18 @@ def _shared_option_params() -> list[inspect.Parameter]:
                 ),
             ],
         ),
+        opt(
+            "allow_empty",
+            False,
+            Annotated[
+                bool,
+                typer.Option(
+                    "--allow-empty",
+                    help="Add a keep filter that matches no row; without it the dry run fails.",
+                    rich_help_panel="Safety",
+                ),
+            ],
+        ),
         opt(
             "input_file",
             None,
@@ -869,7 +882,8 @@ def _execute(invocation: Invocation) -> None:
         if invocation.dry_run:
             return _dry_run(handler, invocation)
         data, meta = handler(invocation)
-        return with_new_data_path(with_dataset_health(_apply_verify(invocation, data))), meta
+        checked = with_locked_files(with_dataset_health(_apply_verify(invocation, data)))
+        return with_new_data_path(checked), meta
 
     executor.run(
         invocation.command_id,

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/bundled_skill/mammoth-cli/SKILL.md

@@ -49,7 +49,7 @@ MAMMOTH_OUTPUT=json MAMMOTH_NO_INPUT=1` once.
 Use the project you are given; never `project ensure`. No `doctor`, auth,
 profiles, `config set`, `upgrade`, `skill install`, env vars, local files,
 stdin, `--input FILE` or `output_path` (they fail `not_available_embedded`);
-downloads return `download_url`. On an auth error, ask the user to reload.
+downloads return `download_url`. Ask for a reload on `authentication_failed` only; on a 403 check ids and scope.
 
 ## Defaults you do not repeat
 

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/bundled_skill/mammoth-cli/references/auth.md

@@ -17,8 +17,11 @@ created without a project.
 `mammoth auth login --method oauth` signs the operator in through the browser (PKCE, loopback
 `127.0.0.1`). The CLI keeps a 1 h `mm_` token and refreshes it under a file lock. `auth status`
 reports `credential: oauth` and `expires_at`. A refresh that fails exits 4 with `login_expired`:
-tell the operator to run `mammoth auth login` again. `--no-browser` prints the URL. Browser sign-in
-is for the operator's own terminal; an agent never runs it. `auth logout` also revokes the
+tell the operator to run `mammoth auth login` again. `--no-browser` prints the URL. `--device` is the sign-in for a
+machine with no browser: it prints a short code and a URL for the operator to approve on another
+device, then polls. Browser and device sign-in are for the operator's own terminal; an agent never
+runs them. A key made with `token create` expires after 30 days: `cli_key_expired` means run
+`mammoth auth login` again. `auth logout` also revokes the
 connection on the server, and warns (still clearing local state) if it cannot.
 
 `mammoth token create NAME`, `token list`, `token revoke KEY` are aliases of `client-app create`,

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/bundled_skill/mammoth-cli/references/commands/view.md

@@ -738,7 +738,7 @@ Status on release: ran once on CLI 2.0.21 — ergonomics sweep 2026-09-19: exit
 
 Run: `mammoth view optimize`. Exact input fields: `mammoth schema get view.optimize`.
 
-Example: `mammoth view optimize 123 123`. Illustrative only: append `--yes` after observing an owned target.
+Example: `mammoth view optimize 123`. Illustrative only: append `--yes` after observing an owned target.
 
 Result: `ViewOptimizeResult`; mutation `reversible_pipeline`, confirmation `prompt_or_yes`, wait policy `start_or_wait`.
 

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/bundled_skill/mammoth-cli/references/recipes/auth-scope.md

@@ -19,5 +19,6 @@ condition, not permission to retry mutations. The credential rule lives in
 Exit 4 is auth/authorization; preserve the structured error and stop safely.
 
 In the Mammoth app none of the above applies: there is no `auth status`,
-`doctor` or profile, and the app passes the login and project. On exit 4 ask
-the user to reload the page.
+`doctor` or profile, and the app passes the login and project. On `authentication_failed` or
+`not_authenticated` ask the user to reload the page; on `authorization_required` (403)
+check the ids and scope first, since a reload does not fix them.

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/bundled_skill/mammoth-cli/references/recovery.md

@@ -7,7 +7,8 @@ these commands are not blanket permission to replay a mutation.
 
 | exit | error.code (examples) | next step |
 |---|---|---|
-| 4 | not_authenticated, authentication_failed | `mammoth auth login`; in the Mammoth app, ask the user to reload the page |
+| 4 | not_authenticated, authentication_failed | `mammoth auth login`; in the Mammoth app, ask the user to reload the page (an expired or invalid sign-in only) |
+| 4 | authorization_required (403) | check the view, dataset and project ids and the scope first; a reload does not fix a wrong id |
 | 2 | keyring_unavailable, keyring_unresponsive | operator runs `mammoth auth login --storage file` (or unlocks the OS keychain); not seen in the app |
 | 5 | resource_not_found | re-list to find the correct id |
 | 2 | project_required | `mammoth context project use ID` or `--project` (in the app: `--project` only) |
@@ -48,7 +49,7 @@ the `run_id` when you report a backend fault.
 
 Do not run the next mutation on any of these; report the state (with
 `log_ref.run_id`) and either recover per the tables above or hand off:
-- `auth status` is missing or its `endpoint` does not match the intended environment (in the app there is no `auth status` or `doctor`: an auth error means ask the user to reload the page)
+- `auth status` is missing or its `endpoint` does not match the intended environment (in the app there is no `auth status` or `doctor`: a sign-in error (`authentication_failed`, `not_authenticated`) means ask the user to reload the page; `authorization_required` means check the ids and scope)
 - `mammoth doctor` fails (CLI only)
 - a dataset is still `need_action` after the settings update
 - a read-back after a value-changing step shows a uniform column (all 0 / all one value / all null) or a changed row the condition should not have touched

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/commands/auth.py

@@ -270,13 +270,13 @@ def _verify_login(invocation: Invocation, *, base_url: str, api_token: str) -> i
     return workspace_id
 
 
-_LOGIN_METHODS = ("oauth", "token")
+_LOGIN_METHODS = ("oauth", "device", "token")
 
 
 def _choose_method(
     method: str | None, invocation: Invocation, *, server_prefix: str | None, blockers: list[str]
 ) -> str:
-    """Pick ``oauth`` or ``token``: explicit, implied by ``--input``, or asked.
+    """Pick ``oauth``, ``device`` or ``token``: explicit, implied by ``--input``, or asked.
 
     A server with no CLI OAuth client, a non-interactive run, and ``--input``
     all keep the token login that existed before browser sign-in.
@@ -289,10 +289,10 @@ def _choose_method(
                 exit_status=EXIT_USAGE,
                 hint=f"Use one of: {', '.join(_LOGIN_METHODS)}.",
             )
-        if method == "oauth" and invocation.input_file is not None:
+        if method != "token" and invocation.input_file is not None:
             raise CliError(
                 code="invalid_argument_combination",
-                message="--input is for token logins; it cannot be used with --method oauth.",
+                message=f"--input is for token logins; it cannot be used with --method {method}.",
                 exit_status=EXIT_USAGE,
             )
         return method
@@ -302,16 +302,18 @@ def _choose_method(
         return "token"
     typer.echo("How do you want to sign in?", err=True)
     typer.echo("  1) Browser (OAuth)      recommended", err=True)
+    typer.echo("  2) Device code          no browser on this machine", err=True)
     typer.echo("  3) Paste an API token   for CI and scripts", err=True)
     choice = typer.prompt("Choose", default="1", show_default=False).strip()
-    if choice not in ("1", "3"):
+    methods = {"1": "oauth", "2": "device", "3": "token"}
+    if choice not in methods:
         raise CliError(
             code="invalid_login_method",
             message=f"'{choice}' is not one of the choices.",
             exit_status=EXIT_USAGE,
-            hint="Enter 1 for the browser or 3 to paste an API token.",
+            hint="Enter 1 for the browser, 2 for a device code or 3 to paste an API token.",
         )
-    return "oauth" if choice == "1" else "token"
+    return methods[choice]
 
 
 def _iso(epoch: int) -> str:
@@ -325,16 +327,18 @@ def _run_oauth_login(
     storage: str,
     open_browser: bool,
     interactive: bool,
+    device: bool = False,
 ) -> tuple[dict[str, Any], dict[str, Any]]:
-    """Sign in through the browser and persist the refreshable session."""
+    """Sign in through the browser (or a device code) and persist the refreshable session."""
     base_url = resolve_base_url(server_prefix)
     client_id = oauth.client_id_for(server_prefix)
-    session = oauth.browser_login(
-        base_url,
-        client_id=client_id,
-        open_browser=open_browser,
-        say=lambda line: typer.echo(line, err=True),
-    )
+    say = lambda line: typer.echo(line, err=True)  # noqa: E731
+    if device:
+        session = oauth.device_login(base_url, client_id=client_id, say=say)
+    else:
+        session = oauth.browser_login(
+            base_url, client_id=client_id, open_browser=open_browser, say=say
+        )
     workspace_id = _verify_login(invocation, base_url=base_url, api_token=session.access)
 
     profile_name = invocation.profile or profiles.DEFAULT_PROFILE_NAME
@@ -378,8 +382,18 @@ def _run_login(
     storage: str,
     method: str | None = None,
     no_browser: bool = False,
+    device: bool = False,
 ) -> tuple[dict[str, Any], dict[str, Any]]:
     """Validate, connection-check, and persist one `auth login` invocation."""
+    if device:
+        if method not in (None, "device"):
+            raise CliError(
+                code="invalid_argument_combination",
+                message=f"--device cannot be used with --method {method}.",
+                exit_status=EXIT_USAGE,
+                hint="Use --device alone, or --method device.",
+            )
+        method = "device"
     if storage not in _STORAGE_MODES:
         raise CliError(
             code="invalid_storage_mode",
@@ -390,16 +404,15 @@ def _run_login(
 
     blockers = _prompt_blockers(invocation)
 
-    if (
-        _choose_method(method, invocation, server_prefix=server_prefix, blockers=blockers)
-        == "oauth"
-    ):
+    chosen = _choose_method(method, invocation, server_prefix=server_prefix, blockers=blockers)
+    if chosen in ("oauth", "device"):
         return _run_oauth_login(
             invocation,
             server_prefix=server_prefix,
             storage=storage,
             open_browser=not no_browser,
             interactive=not blockers,
+            device=chosen == "device",
         )
 
     if invocation.input_file is not None:
@@ -488,19 +501,33 @@ def auth_login(
     method: str | None = typer.Option(
         None,
         "--method",
-        help="How to sign in: a browser (oauth) or a pasted API token (token).",
-        metavar="oauth|token",
+        help=(
+            "How to sign in: a browser (oauth), a code typed on another device (device) "
+            "or a pasted API token (token)."
+        ),
+        metavar="oauth|device|token",
     ),
     no_browser: bool = typer.Option(
         False, "--no-browser", help="Print the sign-in URL instead of opening a browser."
     ),
+    device: bool = typer.Option(
+        False,
+        "--device",
+        help=(
+            "Sign in with a device code, for a machine with no browser: the CLI prints "
+            "a short code and a URL, you approve on any other device, and the CLI "
+            "polls until you do. Same as --method device."
+        ),
+    ),
 ) -> None:
     """Log in and store one profile's credentials.
 
     In a terminal, choose a browser sign-in (OAuth; the CLI keeps a token that
-    refreshes itself) or paste an API token (mm_..., from Workspace settings ->
-    API Tokens). The token names its workspace. For non-interactive use
-    (agents, CI), pass ``--input FILE`` with {"api_token": ...} instead.
+    refreshes itself), a device code (``--device``: for a machine with no
+    browser, you type a short code on any other device) or paste an API token
+    (mm_..., from Workspace settings -> API Tokens). The token names its
+    workspace. For non-interactive use (agents, CI), pass ``--input FILE`` with
+    {"api_token": ...} instead.
     Performs a lightweight connection check before saving anything; a failed
     check leaves existing profile state unchanged.
     """
@@ -531,6 +558,7 @@ def auth_login(
             storage=storage,
             method=method,
             no_browser=no_browser,
+            device=device,
         )
 
     executor.run(

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/commands/job.py

@@ -199,7 +199,9 @@ def _with_outcome(service: Any, data: dict[str, Any]) -> dict[str, Any]:
     gets its copied counts and per-view runs (no read). The job succeeded either way, so
     a view that cannot be read is an ``outcome_error``, never a failed wait.
     """
-    copied = job_outcome.copy_outcome(data.get("result"))
+    result = job_outcome.with_derived_datasets(data.get("result"))
+    data = {**data, "result": result} if result is not data.get("result") else data
+    copied = job_outcome.copy_outcome(result)
     if copied is not None and data.get("operation") == job_outcome.COPY_PROJECT_OPERATION:
         return {**data, "outcome": copied}
     target = job_outcome.view_target(data)

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/commands/project.py

@@ -36,6 +36,7 @@ from mammoth_cli.runtime.confirm import (
 )
 from mammoth_cli.runtime.invocation import Invocation
 from mammoth_cli.runtime.session import open_service, resolved_project
+from mammoth_cli.services import job_outcome
 
 HandlerResult = tuple[Any, dict[str, Any]]
 
@@ -299,7 +300,7 @@ def project_copy(invocation: Invocation) -> HandlerResult:
     _forward_optional(document, kwargs, _COPY_OPTIONAL)
     with open_service(invocation) as (service, auth):
         queued = service.call(_symbol(invocation), **kwargs)
-        data = service.wait_if_job(queued)
+        data = job_outcome.with_derived_datasets(service.wait_if_job(queued))
     return data, _meta(invocation, auth.workspace_id, source_id)
 
 

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/commands/schema.py

@@ -45,6 +45,7 @@ _PROTECTED_INPUT_PATH = "/private/path/request.json"
 # Commands whose useful example the SDK signature cannot express: a distinct
 # second id, an optional-but-central input field, or two views to compare.
 _FIXED_EXAMPLES: dict[str, tuple[tuple[str, ...], dict[str, Any]]] = {
+    "view.optimize": (("123",), {}),
     "project.check": (("123", "456"), {}),
     "view.data.profile": (("123",), {"target": "Churn"}),
     "workflow.canvas": (
@@ -500,6 +501,10 @@ _COMMAND_DISCOVERY_PURPOSES = {
         "connect our own internal custom api build a connector for an unsupported source"
     ),
     "file.set-password": "locked password protected file pdf excel unlock",
+    "file.update": (
+        "pdf extraction method choose select pending tables only all content custom "
+        "uploaded pdf file extract_pdf_tables"
+    ),
     "project.sample-flow": "sample example demo starter data dataset try start from",
     "webhook.create": (
         "webhook http endpoint api push create data pushed in sent from another system receive "

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/commands/view.py

@@ -23,6 +23,7 @@ from __future__ import annotations
 import dataclasses
 import inspect
 import shlex
+import time
 from collections.abc import Callable
 from datetime import UTC, datetime
 from decimal import Decimal, InvalidOperation
@@ -212,6 +213,48 @@ def _resolve_dataset_id(
     return dataset_id
 
 
+def _check_parent_matches(view_id: int, given: int, real: int) -> None:
+    """Refuse a DATASET_ID that is not the view's parent, before any write."""
+    if given == real:
+        return
+    raise CliError(
+        code=CODE_INVALID_ARGUMENT,
+        message=f"view {view_id} belongs to dataset {real}, not {given}",
+        exit_status=EXIT_USAGE,
+        hint=f"Run it again with dataset {real}, or leave DATASET_ID out: mammoth looks it up.",
+        details={"view_id": view_id, "given_dataset_id": given, "dataset_id": real},
+    )
+
+
+def _view_parent_dataset_id(service: Any, invocation: Invocation, view_id: int) -> int:
+    """The view's own dataset: the remembered parent, else one read of the view's row."""
+    profile_name = _profile_name(invocation)
+    workspace_id = getattr(service, "_workspace_id", None)
+    remembered = parents.lookup(profile_name, workspace_id, view_id)
+    if remembered is not None:
+        return remembered
+    dataset_id = int(service.call(_FIND_DATASET_SYMBOL, dataview_id=view_id))
+    parents.remember(profile_name, workspace_id, {view_id: dataset_id})
+    return dataset_id
+
+
+def _verified_dataset_id(
+    service: Any, invocation: Invocation, view_id: int, document: dict[str, Any]
+) -> int:
+    """The view's dataset for a write, so the caller never has to supply it.
+
+    A DATASET_ID (positional or ``dataset_id`` input field) is checked against the
+    view's real parent and refused when it differs; with none, the parent is looked up.
+    """
+    explicit = _int_positional_at(invocation, 1, "dataset id")
+    if explicit is None and document.get(_DATASET_ID_FIELD) is not None:
+        explicit = _int_field(document[_DATASET_ID_FIELD], _DATASET_ID_FIELD)
+    real = _view_parent_dataset_id(service, invocation, view_id)
+    if explicit is not None:
+        _check_parent_matches(view_id, explicit, real)
+    return real
+
+
 def _resolve_dataset_id_for_settle(
     service: Any,
     invocation: Invocation,
@@ -1029,7 +1072,7 @@ def view_optimize(invocation: Invocation) -> HandlerResult:
     kwargs: dict[str, Any] = {"dataview_id": dataview_id, "project_id": project_id}
     _forward_optional(document, kwargs, ("apply_rules",))
     with open_service(invocation) as (service, auth):
-        kwargs["dataset_id"] = _resolve_dataset_id(service, invocation, dataview_id, document)
+        kwargs["dataset_id"] = _verified_dataset_id(service, invocation, dataview_id, document)
         data = service.call(_symbol(invocation), **kwargs)
         if isinstance(data, dict) and data.get("job_id") is not None:
             settled = service.wait_if_job({"job_id": data["job_id"]})
@@ -4528,6 +4571,29 @@ def wait_for_view_row_count(
     return rows_after, pipeline_error
 
 
+#: Bounded wait for a submitted draft's data: its steps run after the submit returns.
+_REFRESH_ATTEMPTS = 40
+_REFRESH_RETRY_S = 0.5
+
+
+def wait_for_refreshed_view(
+    service: Any, dataset_id: int, view_id: int, project_id: int | None, stamp_before: Any
+) -> dict[str, Any] | None:
+    """The view's record once its ``data_updated_at`` has moved past ``stamp_before``.
+
+    ``None`` when it never did within the bound; the caller reports that as
+    unfinished, never as a row count it did not see refreshed.
+    """
+    for _ in range(_REFRESH_ATTEMPTS):
+        info = service.call(
+            _DATAVIEW_GET_SYMBOL, dataset_id=dataset_id, dataview_id=view_id, project_id=project_id
+        )
+        if isinstance(info, dict) and info.get("data_updated_at") != stamp_before:
+            return info
+        time.sleep(_REFRESH_RETRY_S)
+    return None
+
+
 def _row_count_now(service: Any, dataset_id: int, view_id: int, project_id: int | None) -> Any:
     """A view's row count, read directly with no settle wait.
 
@@ -4582,7 +4648,11 @@ def _settle_async_view_write(
         return data
     dataset_id = int(dataset_id)
     row_check: dict[str, Any] = dict(before or {"rows_before": None})
-    rows_after, pipeline_error = wait_for_view_row_count(service, dataset_id, view_id, project_id)
+    # The response names the follow-on job that runs the pipeline; read back
+    # before it ends and the view still shows the old row count (FB-05).
+    rows_after, pipeline_error = wait_for_view_row_count(
+        service, dataset_id, view_id, project_id, write_result=data
+    )
     row_check["rows_after"] = rows_after
     data = {**data, "row_check": row_check}
     if pipeline_error is not None:

{mammoth_cli-2.2.46 → mammoth_cli-2.2.48}/mammoth_cli/commands/view_ops.py

@@ -20,6 +20,7 @@ enum-typed fields are forwarded as the plain string given on ``--input``.
 from __future__ import annotations
 
 import json
+import re
 import shlex
 from collections.abc import Callable
 from datetime import UTC, datetime, timedelta
@@ -29,6 +30,7 @@ from mammoth_cli.commands.view import (
     _DATAVIEW_GET_SYMBOL,
     _FIND_DATASET_SYMBOL,
     BRIEF_VIEW_FIELDS,
+    UNFINISHED_STATE,
     _dataview_metadata,
     _require_discovery_allowed,
     apply_column_renames,
@@ -39,6 +41,7 @@ from mammoth_cli.commands.view import (
     reject_dataset_export_conflicts,
     wait_for_followon_job,
     wait_for_pipeline_to_settle,
+    wait_for_refreshed_view,
     wait_for_view_row_count,
     with_join_check,
 )
@@ -60,12 +63,13 @@ from mammoth_cli.runtime.dryrun import DryRunStop
 from mammoth_cli.runtime.invocation import Invocation
 from mammoth_cli.runtime.session import open_service, resolved_project
 from mammoth_cli.services.command_contract import bind_command_inputs
-from mammoth_cli.services.conditions import CONDITION_KWARG
+from mammoth_cli.services.conditions import CONDITION_KWARG, compile_condition
 from mammoth_cli.services.input_fields import TASK_COUNT_FIELD
 from mammoth_cli.services.sql_check import check_sql_binds
 from mammoth_cli.services.write_impact import (
     ImpactRead,
     Measure,
+    empties_view_error,
     measure_bulk_replace,
     measure_duplicates,
     measure_fill_missing,
@@ -438,6 +442,7 @@ def _flag_unsettled_pipeline(service: Any, dataset_id: int, view_id: int, data:
 
 
 CODE_PIPELINE_CHANGED = "pipeline_changed"
+_DRAFT_STATUS_SYMBOL = "mammoth.api.pipeline.PipelineAPI.get_draft_status"
 _TASK_LIST_SYMBOL = "mammoth.api.pipeline.PipelineAPI.list_tasks"
 
 
@@ -911,7 +916,62 @@ def view_draft_status(invocation: Invocation) -> HandlerResult:
 def view_draft_submit(invocation: Invocation) -> HandlerResult:
     """Submit a view's draft pipeline changes."""
     view_id = _view_id(invocation)
-    return _dispatch_view(invocation, view_id, "submit_draft")
+    project_id = invocation.project
+
+    def before(service: Any, dataset_id: int) -> dict[str, Any]:
+        return _draft_before_submit(service, dataset_id, view_id, project_id)
+
+    def after(service: Any, dataset_id: int, state: Any, data: Any) -> Any:
+        return _draft_submit_row_check(service, dataset_id, view_id, project_id, state, data)
+
+    return _dispatch_view(invocation, view_id, "submit_draft", before=before, after=after)
+
+
+def _draft_before_submit(
+    service: Any, dataset_id: int, view_id: int, project_id: int | None
+) -> dict[str, Any]:
+    """The view's row count and data timestamp, and whether its draft has changes to run."""
+    info = service.call(
+        _DATAVIEW_GET_SYMBOL, dataset_id=dataset_id, dataview_id=view_id, project_id=project_id
+    )
+    draft = service.call(_DRAFT_STATUS_SYMBOL, dataview_id=view_id)
+    return {
+        "row_count": info.get("row_count"),
+        "stamp": info.get("data_updated_at"),
+        "pending": bool(draft.get("has_pending_changes")),
+    }
+
+
+def _draft_submit_row_check(
+    service: Any,
+    dataset_id: int,
+    view_id: int,
+    project_id: int | None,
+    before: dict[str, Any],
+    data: Any,
+) -> Any:
+    """``data`` with the row count read once the submitted steps' data is in.
+
+    The submit returns with the pipeline ``idle`` while its steps still run, so a
+    count read at once is the old one (FB-22). A draft with nothing to run is
+    read at once; data that never refreshes is reported as unfinished.
+    """
+    if not isinstance(data, dict):
+        return data
+    if before["pending"]:
+        info = wait_for_refreshed_view(service, dataset_id, view_id, project_id, before["stamp"])
+    else:
+        info = service.call(
+            _DATAVIEW_GET_SYMBOL, dataset_id=dataset_id, dataview_id=view_id, project_id=project_id
+        )
+    rows_after = info.get("row_count") if info is not None else None
+    out = {**data, "row_check": {"rows_before": before["row_count"], "rows_after": rows_after}}
+    if info is None:
+        out["pipeline_error"] = {
+            "execution_state": UNFINISHED_STATE,
+            "wait_error": "the view's data was not refreshed after the submit; read it again",
+        }
+    return out
 
 
 def view_draft_discard(invocation: Invocation) -> HandlerResult:
@@ -1161,7 +1221,8 @@ def _impact_check(
 
     A count of zero is a no-op: ``--dry-run`` fails with ``no_op`` and a real run
     adds no task (``status: no_change``, like a same-type convert). Otherwise a
-    dry run reports the count as ``predicted_impact``. A count that cannot run
+    dry run reports the count as ``predicted_impact``. A keep filter no row matches
+    fails a dry run with ``empties_view`` unless ``--allow-empty`` is set. A count that cannot run
     is reported as unchecked in a dry run, never as zero, and never blocks a write.
     """
 
@@ -1187,6 +1248,8 @@ def _impact_check(
                     invocation, "predicted_impact", {"checked": False, "reason": exc.message}
                 )
             return None
+        if measured.empties_message and invocation.dry_run and not invocation.allow_empty:
+            raise empties_view_error(measured.empties_message, view_id=view_id)
         if measured.changes == 0:
             if invocation.dry_run:
                 raise no_op_error(measured.no_op_message, view_id=view_id)
@@ -1386,7 +1449,57 @@ def view_transform_math(invocation: Invocation) -> HandlerResult:
     assert document is not None
     _require_one_destination(document, invocation.command_id)
     kwargs = _bind_transform_inputs(invocation, document)
-    return _dispatch_view(invocation, view_id, "math", **kwargs)
+    blanks: dict[str, int] = {}
+
+    def count_blank_inputs(service: Any, dataset_id: int, _kwargs: dict[str, Any]) -> None:
+        blanks.update(
+            _blank_math_inputs(
+                service, dataset_id, view_id, resolved_project(invocation), document["expression"]
+            )
+        )
+
+    data, meta = _dispatch_view(invocation, view_id, "math", prepare=count_blank_inputs, **kwargs)
+    return _with_blank_input_note(data, blanks), meta
+
+
+def _blank_math_inputs(
+    service: Any, dataset_id: int, view_id: int, project_id: int | None, expression: Any
+) -> dict[str, int]:
+    """Blank cells of each column a math expression names, for the columns that have any.
+
+    Mammoth computes a blank input as 0, so ``qty * unit_price`` gives 0 for an
+    unpriced row and a later total counts it with no warning (FB-01).
+    """
+    info = service.call(
+        _DATAVIEW_GET_SYMBOL, dataset_id=dataset_id, dataview_id=view_id, project_id=project_id
+    )
+    read = ImpactRead(service, dataset_id, view_id, project_id, apply_column_renames(info))
+    text = str(expression)
+    named = [
+        name
+        for name in read.display_to_internal()
+        if re.search(rf"(?<![\w]){re.escape(name)}(?![\w])", text)
+    ]
+    try:
+        counts = {
+            name: read.count(compile_condition({"column": name, "operator": "IS_EMPTY"}))
+            for name in named
+        }
+    except CliError:
+        return {}  # A count that cannot run never blocks the write; it only drops the note.
+    return {name: count for name, count in counts.items() if count}
+
+
+def _with_blank_input_note(data: Any, blanks: dict[str, int]) -> Any:
+    """``data`` with a ``blank_inputs`` note when a math input column has blanks."""
+    if not blanks or not isinstance(data, dict):
+        return data
+    listed = ", ".join(f"{name} is blank in {count} row(s)" for name, count in blanks.items())
+    note = (
+        f"A blank input counts as 0 in this math step: {listed}, so the result there is "
+        "computed as if it were 0. Fill or filter those rows first if a blank must not count as 0."
+    )
+    return {**data, "blank_inputs": {"columns": blanks, "note": note}}
 
 
 def view_transform_pivot(invocation: Invocation) -> HandlerResult: