letify 2.5.2__tar.gz → 2.5.3__tar.gz

{letify-2.5.2 → letify-2.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 2.5.2
+Version: 2.5.3
 Summary: Declarations that become infrastructure.
 Project-URL: Homepage, https://github.com/DarkPyonix/letify
 Project-URL: Documentation, https://github.com/DarkPyonix/letify/tree/main/docs

{letify-2.5.2 → letify-2.5.3}/docs/SPEC.md

@@ -1098,6 +1098,15 @@ A detected path that exists is an input. A detected directory and a detected pat
 
 Any other path is pickled unchanged, so the body receives the local path as it was. Only `os.PathLike` objects are detected. A string that happens to name a local file is left alone, because no rule tells a path from any other string.
 
+One other path is refused rather than pickled unchanged: an `os.PathLike` naming a file or directory that exists on this machine and lies outside every allowed root. Passing it on leaves the body reading a path that is not there, which fails as `FileNotFoundError` on the runtime and names neither the cause nor the rule, and on a runtime where something does sit at that path it reads the wrong bytes instead. So the call raises `ValueError` before it is sent:
+
+```
+<path> is outside the roots letify may send data from. The project root is <root>. Add its
+directory to [tool.letify] data_roots in <root>/pyproject.toml, or move the file inside the root.
+```
+
+A path that exists here and is inside a root is data; a path that does not exist here is a runtime path and still travels unchanged, because that is how a body is told where to write.
+
 A directory is walked without following symbolic links to directories. Regular files and symbolic links to regular files are included. Entries named `.git`, `.venv` and `__pycache__` are skipped.
 
 #### Digests and the digest cache <!-- id: project-data-digests -->
@@ -1290,6 +1299,10 @@ A call that detected data prints one line on standard error:
 
 The line is printed when the call has at least one input file, after the call's outcome is known, because what was sent during the call is not known before then. Sizes are in MiB with one decimal. `<the bucket>` is named when the bytes come from the bucket. `before the call` counts the first wave of The send order and the first wave, `during it` counts what the background sender delivered while the call ran, and the rate covers both. `first access waited` is the wall clock time in which at least one reader was blocked on a blob that had not arrived, and it is `0.0` when the send order was right.
 
+`already on` counts the blobs the runtime answered `data_have` with, not what is left after subtracting what was sent. The two differ whenever a blob was neither already there nor fully sent, and subtracting reports such a blob as having been there all along, which is the opposite of what happened. A blob the background sender was still carrying when the call returned is one of those, so the line ends with `, <files> files <size> dropped when the call ended` whenever there is one, and omits that clause when there is none. A dropped blob is not a failure: the call is over and its bytes are no longer needed, which is why the sender is cancelled. It is reported because a line that accounts for every detected file except the dropped ones cannot be read.
+
+Cancelling the sender removes the partial file of a blob it was writing, in the runtime's blob cache as well as a parallel put's staged ranges. A full sized partial left behind counts against the cache budget and is never completed, because the digest it would be sealed under is only written when every range has arrived.
+
 A call with an output location that returned prints a second line after the write-back:
 
 `letify: data wrote back <files> files <size> in <seconds> s (<rate> MiB/s), <files> files <size> during the call, <files> files <size> already on the client`
@@ -1356,7 +1369,7 @@ Sizes are in MiB with one decimal and `<budget>` in GiB with one decimal.
 
 `letify cache` shows the client digest cache, every local tree letify owns with its file count and size, and each provider's runtime file blob cache. `letify cache clear <target>` (or `letify cache clean <target>`) empties what is safe to clean. Credentials and configuration are never cleaned.
 
-`letify cache` first removes every digest cache entry whose file no longer exists, then prints the digest cache's entry count and how many were removed. It measures every local directory under `~/.letify`: `cache` (including digest cache, filesystem stores, and redirected CLI homes), `tools` (installed binaries), `tmp` (temporary session files), `ssh` (multiplexing control sockets), `runtime` (local provider workspace), and `accounts` (credentials, marked non-cleanable). For each provider in the configuration whose runtime disk persists between sessions, it starts a session on the provider's first instance, asks the worker with one `data_cache` request, and prints the alias, the blob count, the total size and the budget. A provider whose runtime disk does not persist is listed with `not kept between sessions` and no session is started. `--json` prints the same records under `digests`, `local` and `providers`.
+`letify cache` first removes every digest cache entry whose file no longer exists, then prints the digest cache's entry count and how many were removed. It measures every local directory under `~/.letify`: `cache` (including digest cache, filesystem stores, and redirected CLI homes), `tools` (installed binaries), `tmp` (temporary session files), `ssh` (multiplexing control sockets), `runtime` (local provider workspace), and `accounts` (credentials, marked non-cleanable). For each provider in the configuration whose runtime disk persists between sessions and already has a session running, it asks the worker with one `data_cache` request and prints the alias, the blob count, the total size and the budget. It starts a session only where starting one bills nothing, which is a provider whose runtime is this machine: a command that shows what is there must not create what is billed, and a configuration naming several providers would bill for all of them at once to print a listing. A provider with no session running is listed with `no session running`, and a provider whose runtime disk does not persist with `not kept between sessions`. Clearing a named provider still starts a session, because there the user named the provider and asked for the work. `--json` prints the same records under `digests`, `local` and `providers`.
 
 `letify cache clear <target>` (or `letify cache clean <target>`) clears caches:
 1. When `<target>` is a provider alias, it sends `data_cache` with `clear` set to that runtime. The worker removes committed blobs whose link count is 1, and the command prints `<alias>: removed <files> files <size>`.

{letify-2.5.2 → letify-2.5.3}/letify/__init__.py

@@ -66,7 +66,7 @@ distributed: Final = Host.distributed
 # The enum class stays importable from letify.declare.instance for letify's own use.
 del Host
 
-__version__ = "2.5.2"
+__version__ = "2.5.3"
 
 
 def fetch(tensor):  # type: ignore[no-untyped-def]

{letify-2.5.2 → letify-2.5.3}/letify/cli.py

@@ -322,8 +322,41 @@ def _setup_tool(args: argparse.Namespace) -> int:
     return 0
 
 
+def _running_runtime(let: Launcher, alias: str):
+    """A session this process already holds on that provider, or None.
+
+    Spec "The cache command": the listing asks only what is already running, because a
+    session it started would bill for the listing.
+    """
+    for runtime in let.pool.live:
+        if getattr(runtime.provider, "alias", None) == alias:
+            return runtime
+    return None
+
+
+def _data_cache_reply(let: Launcher, runtime, clear: bool) -> dict:
+    """One ``data_cache`` request to a session that is already up."""
+    from .store import pathdata
+
+    provider = runtime.provider
+    root = (runtime.workspace or provider.workspace_root).rstrip("/")
+    return runtime.request(
+        {
+            "op": "data_cache",
+            "dir": f"{root}/data/blobs",
+            "budget": pathdata.budget_bytes(provider),
+            "clear": clear,
+        },
+        timeout=600,
+    )
+
+
 def _data_cache_request(let: Launcher, alias: str, clear: bool) -> dict:
-    """Ask a session on the provider's first instance about its file blob cache."""
+    """Ask a session on the provider's first instance about its file blob cache.
+
+    This starts one when none is running, so only a named provider reaches it. Spec "The
+    cache command".
+    """
     from .declare import Env
     from .store import pathdata
 
@@ -462,7 +495,16 @@ def _cache(let: Launcher, args: argparse.Namespace) -> int:
             if not provider.persistent:
                 records.append({"alias": alias, "kept": False})
                 continue
-            result = _data_cache_request(let, alias, False)
+            # Spec "The cache command": a listing bills nothing, so it starts a session
+            # only where starting one is free, and otherwise asks one that is already up.
+            if provider.kind == "local":
+                result = _data_cache_request(let, alias, False)
+            else:
+                runtime = _running_runtime(let, alias)
+                if runtime is None:
+                    records.append({"alias": alias, "kept": True, "running": False})
+                    continue
+                result = _data_cache_reply(let, runtime, False)
         except LetifyError as exc:
             records.append({"alias": alias, "unavailable": str(exc)})
             continue
@@ -470,6 +512,7 @@ def _cache(let: Launcher, args: argparse.Namespace) -> int:
             {
                 "alias": alias,
                 "kept": True,
+                "running": True,
                 "files": result["files"],
                 "bytes": result["bytes"],
                 "budget": result["budget"],
@@ -498,6 +541,8 @@ def _cache(let: Launcher, args: argparse.Namespace) -> int:
             rows.append([row["alias"], f"unavailable: {row['unavailable']}", "", ""])
         elif not row["kept"]:
             rows.append([row["alias"], "not kept between sessions", "", ""])
+        elif not row.get("running"):
+            rows.append([row["alias"], "no session running", "", ""])
         else:
             rows.append(
                 [

{letify-2.5.2 → letify-2.5.3}/letify/protocol/worker.py

@@ -855,6 +855,40 @@ def _parallel_partial(root, digest):
     return "%s%s.parallel" % (_data_file(root, digest), _DATA_PARTIAL)
 
 
+def _op_data_drop(request):
+    """Remove the partials of a blob nobody is going to finish.
+
+    Spec "Data log line": a sender cancelled when the call ended leaves a partial that no
+    later request completes, because the digest it would be sealed under is written only
+    once every piece has arrived. A single put's partial is invisible to the budget scan,
+    so without this it stays for the life of the runtime.
+    """
+    digest = request["digest"]
+    final = _data_file(request["dir"], digest)
+    open_handle = _DATA_OPEN.pop(digest, None)
+    if open_handle is not None:
+        try:
+            open_handle[0].close()
+        except OSError:
+            pass
+    removed = 0
+    directory = os.path.dirname(final)
+    name = os.path.basename(final)
+    try:
+        entries = os.listdir(directory)
+    except OSError:
+        entries = []
+    for entry in entries:
+        if entry == name or not entry.startswith(name + "."):
+            continue
+        try:
+            os.remove(os.path.join(directory, entry))
+            removed += 1
+        except OSError:
+            pass
+    return {"ok": True, "value": removed}
+
+
 def _op_data_begin(request):
     """Make the file parallel senders will fill, of the size it will end up.
 
@@ -2254,6 +2288,7 @@ _OPS = {
     "data_have": _op_data_have,
     "data_put": _op_data_put,
     "data_begin": _op_data_begin,
+    "data_drop": _op_data_drop,
     "data_put_at": _op_data_put_at,
     "data_seal": _op_data_seal,
     "data_pull": _op_data_pull,

{letify-2.5.2 → letify-2.5.3}/letify/store/pathdata.py

@@ -370,6 +370,17 @@ class Collector:
         if resolved == project or resolved in project.parents:
             return None
         if not any(_inside(resolved, root) for root in roots):
+            if info is not None:
+                # Spec "Where the bytes come from": a file that exists here and cannot be
+                # sent would travel as a path the body cannot read, which fails on the
+                # runtime naming neither the cause nor this rule, or reads the wrong bytes
+                # where something does sit at that path.
+                raise ValueError(
+                    f"{resolved} is outside the roots letify may send data from. The "
+                    f"project root is {project}. Add its directory to [tool.letify] "
+                    f"data_roots in {project}/pyproject.toml, or move the file inside "
+                    f"the root."
+                )
             return None
         index = len(self.placed)
         placed = Placed(resolved, f"{self.call_dir}/{index}/{resolved.name}", is_dir)
@@ -601,6 +612,9 @@ class Stream:
         self.runtime = runtime
         self.blobs = blobs
         self.plan = plan
+        #: Digests whose send finished. ``_sent`` holds the ones it began, so a blob the
+        #: sender was carrying when the call ended is in one and not the other.
+        self.done: set[str] = set()
         self.before_files = self.before_bytes = 0
         self.during_files = self.during_bytes = 0
         self.before_seconds = self.during_seconds = 0.0
@@ -703,6 +717,22 @@ class Stream:
         if (thread is None or not thread.is_alive()) and self._pipeline is not None:
             self._pipeline.close()
             self._pipeline = None
+        self._drop_partials()
+
+    def _drop_partials(self) -> None:
+        """Remove the partial of every blob the sender was carrying. Spec "Data log line"."""
+        for digest in self.dropped:
+            try:
+                _worker(self.runtime, {"op": "data_drop", "dir": self.blobs, "digest": digest})
+            except (RuntimeFailure, RemoteError):
+                # The runtime is going away, which removes the partial with it.
+                return
+
+    @property
+    def dropped(self) -> list[str]:
+        """Blobs that were neither already on the runtime nor fully sent."""
+        with self._lock:
+            return [digest for digest in self.plan.missing if digest not in self.done]
 
     # -- the stream ---------------------------------------------------------------
 
@@ -760,6 +790,8 @@ class Stream:
         if not uploaded:
             return
         files, total = self.plan.weight(digest)
+        with self._lock:
+            self.done.add(digest)
         if self._thread is None:
             self.before_files += files
             self.before_bytes += total
@@ -780,19 +812,31 @@ class Stream:
 
         stats = stats or {}
         plan = self.plan
-        sent_files = self.before_files + self.during_files
         sent_bytes = self.before_bytes + self.during_bytes
         seconds = self.before_seconds + self.during_seconds
         rate = sent_bytes / (1 << 20) / seconds if seconds > 0 else 0.0
-        install.log(
+        # Spec "Data log line": counted from what the runtime answered data_have with,
+        # because subtracting what was sent reports a blob that was neither as having
+        # been there all along.
+        missing_weight = [plan.weight(digest) for digest in plan.missing]
+        already_files = plan.detected_files - sum(files for files, _b in missing_weight)
+        already_bytes = plan.detected_bytes - sum(total for _f, total in missing_weight)
+        dropped_weight = [plan.weight(digest) for digest in self.dropped]
+        dropped_files = sum(files for files, _b in dropped_weight)
+        dropped_bytes = sum(total for _f, total in dropped_weight)
+        line = (
             f"data {plan.detected_files} files {_mib(plan.detected_bytes)} detected, "
-            f"{plan.detected_files - sent_files} files "
-            f"{_mib(plan.detected_bytes - sent_bytes)} already on {plan.where}, "
+            f"{already_files} files {_mib(already_bytes)} already on {plan.where}, "
             f"sent {self.before_files} files {_mib(self.before_bytes)} before the call in "
             f"{self.before_seconds:.1f} s, {self.during_files} files "
             f"{_mib(self.during_bytes)} during it in {self.during_seconds:.1f} s "
             f"({rate:.1f} MiB/s), first access waited {float(stats.get('seconds', 0.0)):.1f} s"
         )
+        if dropped_files:
+            line += (
+                f", {dropped_files} files {_mib(dropped_bytes)} dropped when the call ended"
+            )
+        install.log(line)
         if stats.get("files"):
             install.log(
                 f"data waited for {stats['files']} files {_mib(int(stats.get('bytes', 0)))} "

{letify-2.5.2 → letify-2.5.3}/letify-core/Cargo.lock

@@ -138,7 +138,7 @@ dependencies = [
 
 [[package]]
 name = "letify-agent"
-version = "2.5.2"
+version = "2.5.3"
 dependencies = [
  "letify-wire",
  "libloading",
@@ -146,7 +146,7 @@ dependencies = [
 
 [[package]]
 name = "letify-driver"
-version = "2.5.2"
+version = "2.5.3"
 dependencies = [
  "letify-wire",
 ]
@@ -164,7 +164,7 @@ dependencies = [
 
 [[package]]
 name = "letify-wire"
-version = "2.5.2"
+version = "2.5.3"
 
 [[package]]
 name = "libc"

{letify-2.5.2 → letify-2.5.3}/letify-core/Cargo.toml

@@ -8,7 +8,7 @@ resolver = "3"
 members = ["letify-wire", "letify-driver", "letify-agent", "letify-quic"]
 
 [workspace.package]
-version = "2.5.2"
+version = "2.5.3"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/DarkPyonix/letify"

{letify-2.5.2 → letify-2.5.3}/letify-ext/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "letify-status",
-  "version": "2.5.2",
+  "version": "2.5.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "letify-status",
-      "version": "2.5.2",
+      "version": "2.5.3",
       "license": "SEE LICENSE IN LICENSE",
       "devDependencies": {
         "@types/node": "^18.19.0",

{letify-2.5.2 → letify-2.5.3}/letify-ext/package.json

@@ -2,7 +2,7 @@
   "name": "letify-status",
   "displayName": "letify Status",
   "description": "letify quota and GPU activity in the status bar, read from the letify CLI.",
-  "version": "2.5.2",
+  "version": "2.5.3",
   "publisher": "darkpyonix",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

{letify-2.5.2 → letify-2.5.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "letify"
-version = "2.5.2"
+version = "2.5.3"
 description = "Declarations that become infrastructure."
 readme = "README.md"
 requires-python = ">=3.11"

{letify-2.5.2 → letify-2.5.3}/tests/test_cli.py

@@ -1606,3 +1606,61 @@ def test_stop_orphans_exits_one_when_a_delete_failed(isolated_home, capsys, monk
     )
     assert main(["stop", "--orphans", "-y"]) == 1
     assert "refused" in capsys.readouterr().out
+
+
+def test_the_cache_listing_starts_no_session(isolated_home, monkeypatch, capsys) -> None:
+    """Spec "The cache command": a command that shows what is there starts nothing.
+
+    KICT ran `letify cache` and it booted a Modal CPU session, which then failed its own
+    uv sync. A configuration naming several persistent providers would bill for all of
+    them to print a listing.
+    """
+    import letify
+    from letify.cli import main
+    from letify.runtime import pool
+
+    (isolated_home / ".letify" / "config.toml").write_text(
+        '[lab]\nkind = "shell"\naddress = "gpu.example.edu"\npersistent = true\n',
+        encoding="utf-8",
+    )
+    started: list[str] = []
+
+    real = pool.RuntimePool.acquire
+
+    def watch(self, instance, env, volumes=(), **kwargs):
+        provider = instance.provider
+        started.append(provider.alias)
+        assert provider.kind == "local", f"the listing started a billed session on {provider.alias}"
+        return real(self, instance, env, volumes, **kwargs)
+
+    monkeypatch.setattr(pool.RuntimePool, "acquire", watch)
+    assert main(["cache", "--json"]) == 0
+    assert all(alias == "local" for alias in started), started
+    out = capsys.readouterr().out
+    assert "providers" in out
+    assert letify  # the import is what makes the launcher reachable in this process
+
+
+def test_the_cache_listing_says_a_provider_has_no_session_running(
+    isolated_home, capsys
+) -> None:
+    """Spec "The cache command": a provider with no session is named, not skipped."""
+    import json
+
+    from letify.cli import main
+
+    (isolated_home / ".letify" / "config.toml").write_text(
+        '[lab]\nkind = "shell"\naddress = "gpu.example.edu"\npersistent = true\n',
+        encoding="utf-8",
+    )
+    assert main(["cache", "--json"]) == 0
+    record = json.loads(capsys.readouterr().out)
+    remote = [
+        row
+        for row in record["providers"]
+        if row.get("kept") and row["alias"] != "local"
+    ]
+    assert remote, "no billed persistent provider in the fixture, so this pins nothing"
+    for row in remote:
+        assert row.get("running") is False, row
+        assert "files" not in row, row

{letify-2.5.2 → letify-2.5.3}/tests/test_data.py

@@ -106,9 +106,12 @@ def test_a_path_that_does_not_exist_outside_the_roots_is_left_as_a_plain_path(
     assert not absent.exists()
 
 
-def test_a_path_outside_the_allowed_roots_is_left_as_a_plain_path(
-    let, cpu, project, tmp_path, capsys
-) -> None:
+def test_a_file_outside_the_allowed_roots_is_refused(let, cpu, project, tmp_path) -> None:
+    """Spec "Where the bytes come from": it used to travel as a plain path.
+
+    The body then read a path that is not on the runtime, which failed there as a
+    FileNotFoundError naming neither the cause nor the rule. KICT hit that twice.
+    """
     outside = tmp_path / "elsewhere.txt"
     outside.write_text("not project data", encoding="utf-8")
 
@@ -116,8 +119,9 @@ def test_a_path_outside_the_allowed_roots_is_left_as_a_plain_path(
     def where(path: Path) -> str:
         return str(path)
 
-    assert where(outside) == str(outside)
-    assert data_lines(capsys.readouterr().err) == []
+    with pytest.raises(ValueError) as failure:
+        where(outside)
+    assert "outside the roots letify may send data from" in str(failure.value)
 
 
 def test_a_data_root_named_in_pyproject_is_allowed(let, cpu, project, tmp_path) -> None:
@@ -780,3 +784,40 @@ def test_blobs_a_write_back_adds_keep_the_cache_within_its_budget(
     root = _blobs_root()
     assert sum(p.stat().st_size for p in root.glob("*/*")) <= 20 << 10
     assert len(evictions(capsys.readouterr().err)) == 1
+
+
+def test_a_file_outside_the_allowed_roots_is_refused_rather_than_sent_as_a_path(
+    let, cpu, project, tmp_path
+) -> None:
+    """Spec "Where the bytes come from": passing it on leaves the body reading nothing.
+
+    KICT hit this twice on Kaggle: a shard outside the project root travelled as a plain
+    path and the call died on the runtime with FileNotFoundError naming only the file.
+    """
+    outside = tmp_path / "outside" / "shard.pt"
+    outside.parent.mkdir(parents=True, exist_ok=True)
+    outside.write_bytes(b"x" * 4096)
+
+    @let.function(device=cpu, host="remote")
+    def read(path) -> int:
+        import os
+
+        return os.path.getsize(path)
+
+    with pytest.raises(ValueError) as failure:
+        read(path=outside)
+    message = str(failure.value)
+    assert str(outside) in message
+    assert "data_roots" in message
+    assert "outside the roots letify may send data from" in message
+
+
+def test_a_path_that_does_not_exist_here_still_travels_unchanged(let, cpu, project) -> None:
+    """Spec "Where the bytes come from": that is how a body is told where to write."""
+
+    @let.function(device=cpu, host="remote")
+    def name(path) -> str:
+        return str(path)
+
+    target = Path("/not/on/this/machine/out.pt")
+    assert name(path=target) == str(target)

{letify-2.5.2 → letify-2.5.3}/tests/test_data_streaming.py

@@ -1551,3 +1551,93 @@ def test_a_blob_whose_bytes_are_unchanged_survives_a_new_mtime(launcher_from, pr
     with redirect_stderr(captured):
         assert touches(target)[1] == 1 << 12
     assert "data cache dropped" not in captured.getvalue()
+
+
+def test_a_blob_the_sender_was_still_carrying_is_reported_as_dropped(
+    let, cpu, project, capsys, monkeypatch
+) -> None:
+    """Spec "Data log line": subtracting reports it as having been there all along.
+
+    KICT chased this for an afternoon on Kaggle. A 1707 MiB shard was over the first wave
+    budget, so it went to the background sender; the body only stat'ed it, which the
+    observation patch answers from the manifest without waiting; the call returned and the
+    sender was cancelled before the blob was sealed. The line then read "1707 MiB already
+    on the runtime, sent 0", which says the opposite of what happened.
+    """
+    from letify.store import pathdata
+
+    big = project / "big.bin"
+    big.write_bytes(b"z" * (3 << 20))
+
+    # The wave takes nothing, so the one blob goes to the background sender, and the
+    # sender is held until the call has returned and cancelled it.
+    monkeypatch.setattr(pathdata, "FIRST_WAVE_MIB", 0.0)
+    monkeypatch.setattr(pathdata, "FIRST_WAVE_FILES", 0)
+    holding = threading.Event()
+    real_send = pathdata.Stream._send
+
+    def slow(self, digest, meter):
+        holding.wait(timeout=10)
+        return real_send(self, digest, meter)
+
+    monkeypatch.setattr(pathdata.Stream, "_send", slow)
+
+    @let.function(device=cpu, host=letify.remote)
+    def peek(path) -> int:
+        import os
+
+        return os.path.getsize(str(path))
+
+    try:
+        peek(path=big)
+    finally:
+        holding.set()
+    lines = [
+        text
+        for text in capsys.readouterr().err.splitlines()
+        if text.startswith("letify: data ") and not text.startswith("letify: data wrote back ")
+    ]
+    assert lines
+    line = lines[0]
+    assert "0 files 0.0 MiB already on the runtime" in line, line
+    assert "dropped when the call ended" in line, line
+
+
+def test_a_cancelled_send_leaves_no_partial_in_the_blob_cache(
+    let, cpu, project, capsys, monkeypatch
+) -> None:
+    """Spec "Data log line": a full sized partial counts against the budget forever."""
+    from letify.store import pathdata
+
+    big = project / "big2.bin"
+    big.write_bytes(b"y" * (3 << 20))
+    monkeypatch.setattr(pathdata, "FIRST_WAVE_MIB", 0.0)
+    monkeypatch.setattr(pathdata, "FIRST_WAVE_FILES", 0)
+    holding = threading.Event()
+    real_send = pathdata.Stream._send
+
+    def slow(self, digest, meter):
+        holding.wait(timeout=10)
+        return real_send(self, digest, meter)
+
+    monkeypatch.setattr(pathdata.Stream, "_send", slow)
+
+    @let.function(device=cpu, host=letify.remote)
+    def peek(path) -> list[str]:
+        import os
+
+        root = os.path.join(os.path.dirname(os.path.dirname(str(path))), "..", "blobs")
+        root = os.path.normpath(root)
+        found = []
+        for directory, _dirs, names in os.walk(root):
+            found.extend(os.path.join(directory, name) for name in names)
+        return found
+
+    try:
+        peek(path=big)
+    finally:
+        holding.set()
+    time.sleep(1.0)
+    root = Path.home() / ".letify" / "runtime" / "data" / "blobs"
+    leftovers = [p for p in root.rglob("*") if p.is_file() and ".letify-" in p.name]
+    assert leftovers == [], leftovers