letify 1.2.1__tar.gz → 1.2.2__tar.gz

{letify-1.2.1 → letify-1.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 1.2.1
+Version: 1.2.2
 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-1.2.1 → letify-1.2.2}/docs/guide/04-environments-and-data.md

@@ -43,7 +43,7 @@ Packages named in the lock file are installed in the runtime and referenced by n
 letify infers this from the lock file. Override the inference only when you need to:
 
 ```python
-env = env.ship("mypkg")     # send this module by value
+env = env.ship("mypkg")     # ship this module to the runtime
 ```
 
 This is why editing code and rerunning is cheap. Code is a few hundred kilobytes; the environment and the data are the expensive parts, and they are cached.

{letify-1.2.1 → letify-1.2.2}/docs/guide/ko/04-/355/231/230/352/262/275/352/263/274-/353/215/260/354/235/264/355/204/260.md

@@ -43,7 +43,7 @@ lock 파일에 있는 패키지는 런타임에 설치되고 이름으로 참조
 letify가 lock 파일을 보고 판단합니다. 필요할 때만 덮어쓰세요.
 
 ```python
-env = env.ship("mypkg")     # 이 모듈을 내용으로 보냅니다
+env = env.ship("mypkg")     # 이 모듈을 런타임으로 전송합니다
 ```
 
 그래서 코드를 고치고 다시 돌리는 것이 쌉니다. 코드는 수백 KB이고, 비싼 것은 환경과 데이터이며 그건 캐시됩니다.

{letify-1.2.1 → letify-1.2.2}/letify/__init__.py

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

{letify-1.2.1 → letify-1.2.2}/letify/config/login.py

@@ -756,12 +756,25 @@ def colab_account(answers: Answers) -> dict[str, Any]:
 KAGGLE_COOKIE = "cookie"
 KAGGLE_COOKIE_PROMPT = "Kaggle cookie (from a logged-in kaggle.com tab): "
 
+#: What each credential prompt adds on a renewal, where a blank answer keeps the stored
+#: one. Spec "Kaggle account".
+KAGGLE_KEEP_SUFFIX = "[blank keeps the stored one] "
 
-def read_kaggle_cookie(answers: Answers, given: str | None) -> str:
-    """Return the cookie string, from the value given, a file it names, or a prompt."""
+
+def read_kaggle_cookie(answers: Answers, given: str | None, stored: str | None = None) -> str:
+    """Return the cookie string, from the value given, a file it names, or a prompt.
+
+    On a renewal the prompt says a blank answer keeps ``stored``, so the cookie, which is a
+    thirty day session, can be replaced without repasting the token. Spec "Kaggle account".
+    """
     text = (given or "").strip()
     if not text and answers.interactive:
-        text = read_password(KAGGLE_COOKIE_PROMPT).strip()
+        prompt = KAGGLE_COOKIE_PROMPT
+        if stored:
+            prompt = f"{KAGGLE_COOKIE_PROMPT}{KAGGLE_KEEP_SUFFIX}"
+        text = read_password(prompt).strip()
+    if not text and stored:
+        return stored
     if not text:
         raise LoginError(
             f"{answers.alias} needs the Kaggle cookie of a logged-in kaggle.com tab. "
@@ -794,9 +807,15 @@ def read_kaggle_token(
         username = read_line(KAGGLE_OWNER_PROMPT).strip()
     from ..providers.kaggle import read_api_token
 
-    key = given_key if given_key is not None else (read_api_token(answers.alias) or "")
-    if not key and answers.interactive:
-        key = read_password(KAGGLE_TOKEN_PROMPT)
+    stored = read_api_token(answers.alias)
+    key = given_key or ""
+    if not key.strip() and answers.interactive:
+        prompt = KAGGLE_TOKEN_PROMPT
+        if stored:
+            prompt = f"{KAGGLE_TOKEN_PROMPT}{KAGGLE_KEEP_SUFFIX}"
+        key = read_password(prompt)
+    if not key.strip() and stored:
+        key = stored
     if not username or not key:
         raise LoginError(
             f"{answers.alias} needs the Kaggle API token and notebook owner: pass "
@@ -827,7 +846,11 @@ def kaggle_account(answers: Answers) -> dict[str, Any]:
 
     username, key = read_kaggle_token(answers, answers.get("username"), answers.get("key"))
     given = answers.get(KAGGLE_COOKIE) or answers.token
-    cookie = read_kaggle_cookie(answers, given if isinstance(given, str) else None)
+    cookie = read_kaggle_cookie(
+        answers,
+        given if isinstance(given, str) else None,
+        stored=stored_secret(answers.alias, KAGGLE_COOKIE),
+    )
     try:
         kg.require_cookie_shape(cookie)
         expiry = kg.cookie_expiry(cookie)
@@ -954,6 +977,15 @@ def store_secret(alias: str, name: str, secret: str) -> None:
     secrets.write_secret(alias, name, secret)
 
 
+def stored_secret(alias: str, name: str) -> str | None:
+    """The credential already in the account directory, or None when there is none to keep."""
+    try:
+        value = (secrets.account_directory(alias) / name).read_text(encoding="utf-8").strip()
+    except (OSError, UnicodeError):
+        return None
+    return value or None
+
+
 def forget_secret(alias: str) -> bool:
     """Delete everything this machine holds for an account. Returns whether anything was there."""
     return secrets.forget_account(alias)

{letify-1.2.1 → letify-1.2.2}/letify/paths.py

@@ -37,7 +37,7 @@ ALLOWED_ACCOUNT_CREDENTIAL_FILES = frozenset(
         "eci.yaml",
         "cookie",
         "access_token",
-        "kaggle.json",
+        "username",
         "notebook_id",
         "known_hosts",
         "link.json",

{letify-1.2.1 → letify-1.2.2}/letify/protocol/driver.py

@@ -13,12 +13,14 @@ is no blob table, so every large argument travels again on every call.
 from __future__ import annotations
 
 import base64
+from collections.abc import Sequence
+from pathlib import Path
 from typing import Any
 
 from .codec import BEGIN, END, PROTOCOL_VERSION, dumps_call
 
 _TEMPLATE = """
-import base64, pickle, sys, traceback
+import base64, os, pickle, sys, traceback
 _PAYLOAD = "{payload}"
 _BEGIN, _END = "{begin}", "{end}"
 _VERSION = {version}
@@ -27,15 +29,22 @@ _NO_LETIFY = (
     "to letify (for example through letify.session_cache), cannot be loaded. Add it to "
     "the project with 'uv add letify' so uv.lock carries it into the runtime."
 )
-_SHIP_IS_NOT_INSTALL = (
-    "{{name!r}} is not importable in this runtime while the call's body was running. "
-    "Env.ship() sends a module by value: an object from it that the function captures "
-    "as a global is carried inside the call's payload, but the module itself is never "
-    "installed in the runtime, so 'import {{name}}' inside the function body has nothing "
-    "to find. Reference the name as a global the function closes over instead of "
-    "importing it inside the body, or install the package in the runtime's environment "
-    "(name it in uv.lock) so it can be imported there by reference."
-)
+_MODULES = {modules_code}
+_WORKSPACE = {workspace_root!r}
+if _MODULES:
+    _modules_dir = os.path.join(os.path.expanduser(_WORKSPACE), "modules")
+    os.makedirs(_modules_dir, exist_ok=True)
+    for _rel, _b64 in _MODULES.items():
+        _target = os.path.join(_modules_dir, _rel)
+        os.makedirs(os.path.dirname(_target), exist_ok=True)
+        with open(_target, "wb") as _f:
+            _f.write(base64.b64decode(_b64))
+    if _modules_dir not in sys.path:
+        sys.path.insert(0, _modules_dir)
+    _existing = os.environ.get("PYTHONPATH", "")
+    _parts = [p for p in _existing.split(os.pathsep) if p]
+    if _modules_dir not in _parts:
+        os.environ["PYTHONPATH"] = os.pathsep.join([_modules_dir, *_parts])
 
 def _emit(obj):
     try:
@@ -84,8 +93,6 @@ else:
     except BaseException as exc:
         if isinstance(exc, ModuleNotFoundError) and (exc.name or "").split(".")[0] == "letify":
             _error = _NO_LETIFY
-        elif isinstance(exc, ModuleNotFoundError):
-            _error = _SHIP_IS_NOT_INSTALL.format(name=exc.name)
         else:
             _error = "{{}}: {{}}".format(type(exc).__name__, exc)
         _emit({{
@@ -98,14 +105,36 @@ else:
 """
 
 
-def build(fn: Any, args: tuple, kwargs: dict) -> str:
+def build(
+    fn: Any,
+    args: tuple,
+    kwargs: dict,
+    *,
+    modules: Sequence[str] = (),
+    workspace_root: str = "~/.letify-runtime",
+) -> str:
     """Return the script that runs one call and prints its outcome."""
     payload = base64.b64encode(dumps_call(fn, args, kwargs)).decode()
+    modules_dict: dict[str, str] = {}
+    if modules:
+        from ..store.pathdata import collect_module
+
+        modules_root = f"{workspace_root.rstrip('/')}/modules"
+        for mod_name in modules:
+            placed = collect_module(mod_name, modules_root)
+            prefix = mod_name.replace(".", "/")
+            for rel, _digest, _size, local in placed.entries:
+                content = Path(local).read_bytes()
+                target_rel = f"{prefix}/{rel}" if placed.directory else prefix + Path(local).suffix
+                modules_dict[target_rel] = base64.b64encode(content).decode("ascii")
+
     return _TEMPLATE.format(
         payload=payload,
         begin=BEGIN,
         end=END,
         version=PROTOCOL_VERSION,
+        modules_code=repr(modules_dict),
+        workspace_root=workspace_root,
     )
 
 

{letify-1.2.1 → letify-1.2.2}/letify/protocol/worker.py

@@ -195,16 +195,6 @@ _NO_LETIFY = (
     "the project with 'uv add letify' so uv.lock carries it into the runtime."
 )
 
-_SHIP_IS_NOT_INSTALL = (
-    "{name!r} is not importable in this runtime while the call's body was running. "
-    "Env.ship() sends a module by value: an object from it that the function captures "
-    "as a global is carried inside the call's payload, but the module itself is never "
-    "installed in the runtime, so 'import {name}' inside the function body has nothing "
-    "to find. Reference the name as a global the function closes over instead of "
-    "importing it inside the body, or install the package in the runtime's environment "
-    "(name it in uv.lock) so it can be imported there by reference."
-)
-
 
 def _ship_main_to_children(cloudpickle):
     """Let a child process the body spawns rebuild what the caller's __main__ defined.
@@ -266,6 +256,15 @@ def _reply(stream, outcome):
 
 def _op_call(request):
     data = request.pop("data", None)
+    modules_dir = request.pop("modules_dir", None)
+    if modules_dir:
+        modules_dir = os.path.expanduser(modules_dir)
+        if modules_dir not in sys.path:
+            sys.path.insert(0, modules_dir)
+        existing = os.environ.get("PYTHONPATH", "")
+        parts = [p for p in existing.split(os.pathsep) if p]
+        if modules_dir not in parts:
+            os.environ["PYTHONPATH"] = os.pathsep.join([modules_dir, *parts])
     if data is None:
         return _call(request)
     state = _data_register(data)
@@ -872,10 +871,18 @@ def _data_place_now(state, path, entry):
     # turns it into a private copy. Spec "Materializing and the rewritten path".
     linked = False
     try:
-        os.link(source, path)
-        linked = True
+        if os.path.exists(path) and os.stat(path).st_ino == os.stat(source).st_ino:
+            linked = True
     except OSError:
         pass
+    if not linked:
+        try:
+            if os.path.exists(path):
+                os.remove(path)
+            os.link(source, path)
+            linked = True
+        except OSError:
+            pass
     if not linked:
         # Copied to a name of its own and renamed into place, so a reader never stats a
         # file that is half written. Spec "What the body sees before a file arrives".
@@ -1533,15 +1540,7 @@ def _call(request):
         # refers to it when loaded, so the same explanation applies.
         if (exc.name or "").split(".")[0] == "letify":
             raise ModuleNotFoundError(_NO_LETIFY, name=exc.name) from exc
-        # A package Env.ship() sends by value never lands on this runtime's
-        # sys.path: cloudpickle only puts a captured global in the payload, it
-        # does not install anything. An import statement inside the body still
-        # runs against this interpreter's own path and fails here, even though
-        # the same name reached the call fine as a global. Say so, because the
-        # bare ModuleNotFoundError reads as a missing dependency rather than as
-        # this shape of call.
-        explained = _SHIP_IS_NOT_INSTALL.format(name=exc.name)
-        raise ModuleNotFoundError(explained, name=exc.name) from exc
+        raise
     return {"ok": True, "value": value}
 
 

{letify-1.2.1 → letify-1.2.2}/letify/providers/base.py

@@ -99,8 +99,8 @@ class Provider(abc.ABC):
         """What this account has, read from the entry's device table.
 
         This is the only thing that bounds how much runs at once. An entry that declares
-        nothing falls back to whatever the provider discovers, one of each, because a
-        provider that can be asked should not have to be told.
+        nothing falls back to the device counts of the shapes the provider discovers,
+        because a provider that can be asked should not have to be told.
         """
         if self._inventory is None:
             declared = read_table(self.config.options)
@@ -108,7 +108,7 @@ class Provider(abc.ABC):
                 # Keyed by what an instance calls itself, so a discovered shape and its
                 # inventory entry are the same name. A CPU shape reports "cpu".
                 declared = {
-                    instance.accelerator: Devices(instance.accelerator)
+                    instance.accelerator: Devices(instance.accelerator, count=instance.devices)
                     for instance in self.discover().values()
                 }
             self._inventory = declared

{letify-1.2.1 → letify-1.2.2}/letify/providers/colab.py

@@ -278,30 +278,27 @@ class Colab(Shell):
         return env
 
     def _exec(self, session: str, source: str, timeout: float | None) -> str:
-        from .colab_keepalive import account_lock
-
-        with account_lock(account_directory(self.alias) / ".config" / "colab-cli"):
-            try:
-                return self._cli("exec", "-s", session, stdin=source, timeout=timeout)
-            except subprocess.TimeoutExpired as exc:
-                stderr = exc.stderr or ""
-                if isinstance(stderr, bytes):
-                    stderr = stderr.decode(errors="replace")
-                raise RuntimeFailure(
-                    f"{session}: colab exec timed out after {timeout} s; "
-                    "the notebook kernel may be busy or not answering",
-                    command=" ".join([*self._colab(), "exec", "-s", session]),
-                    stderr=stderr,
-                ) from exc
-            except RuntimeFailure as exc:
-                if "Timeout waiting for reply" not in exc.stderr:
-                    raise
-                raise RuntimeFailure(
-                    f"{session}: colab exec did not receive a reply; "
-                    "the notebook kernel may be busy or not answering",
-                    command=exc.command,
-                    stderr=exc.stderr,
-                ) from exc
+        try:
+            return self._cli("exec", "-s", session, stdin=source, timeout=timeout)
+        except subprocess.TimeoutExpired as exc:
+            stderr = exc.stderr or ""
+            if isinstance(stderr, bytes):
+                stderr = stderr.decode(errors="replace")
+            raise RuntimeFailure(
+                f"{session}: colab exec timed out after {timeout} s; "
+                "the notebook kernel may be busy or not answering",
+                command=" ".join([*self._colab(), "exec", "-s", session]),
+                stderr=stderr,
+            ) from exc
+        except RuntimeFailure as exc:
+            if "Timeout waiting for reply" not in exc.stderr:
+                raise
+            raise RuntimeFailure(
+                f"{session}: colab exec did not receive a reply; "
+                "the notebook kernel may be busy or not answering",
+                command=exc.command,
+                stderr=exc.stderr,
+            ) from exc
 
     def sessions(self) -> list[str]:
         """Names of the sessions this account currently holds."""
@@ -329,8 +326,27 @@ class Colab(Shell):
         from ..transport.rendezvous import ColabRendezvous
 
         name = runtime.name
+
+        def prepare_tailcat() -> str | None:
+            from .. import install
+
+            if not (
+                install.find("tailcat", link_cache=False) or self.config.option("tailcat_binary")
+            ):
+                return None
+            output = self._exec(name, install.remote_tailcat_source(), 180)
+            for line in output.splitlines():
+                if line.startswith("LETIFY-TAILCAT "):
+                    return json.loads(line[len("LETIFY-TAILCAT ") :])
+            raise RuntimeFailure(
+                "tailcat installation gave no verified binary path",
+                stderr=output.strip(),
+            )
+
         return ColabRendezvous(
-            lambda source, timeout: self._exec(name, source, timeout), self._public_key()
+            lambda source, timeout: self._exec(name, source, timeout),
+            self._public_key(),
+            prepare_tailcat=prepare_tailcat,
         )
 
     def fallback(self, runtime: Runtime | None = None) -> Callable[[], Link] | None:
@@ -350,20 +366,6 @@ class Colab(Shell):
     def target(self, runtime: Runtime | None = None) -> Target:
         target = super().target(runtime)
         target.user = self.user or "root"
-        if runtime is not None and target.rendezvous.unavailable() is None:
-            from .. import install
-
-            if install.find("tailcat", link_cache=False) or self.config.option("tailcat_binary"):
-                output = self._exec(runtime.name, install.remote_tailcat_source(), 180)
-                for line in output.splitlines():
-                    if line.startswith("LETIFY-TAILCAT "):
-                        target.rendezvous.binary = json.loads(line[len("LETIFY-TAILCAT ") :])
-                        break
-                else:
-                    raise RuntimeFailure(
-                        "tailcat installation gave no verified binary path",
-                        stderr=output.strip(),
-                    )
         if runtime is not None:
             # Each runtime is a new VM with a new host key.
             target.host_key_alias = f"letify-{self.alias}-{runtime.name}"

{letify-1.2.1 → letify-1.2.2}/letify/providers/colab_keepalive.py

@@ -28,8 +28,8 @@ READY = "LETIFY-KEEP-ALIVE ready"
 
 
 @contextlib.contextmanager
-def account_lock(directory: Path) -> Iterator[None]:
-    """Serialize full kernel commands sharing one account's CLI state."""
+def account_lock(directory: Path, *, blocking: bool = True) -> Iterator[bool]:
+    """Serialize wakes sharing account CLI state, optionally without waiting."""
     directory.mkdir(parents=True, exist_ok=True)
     with (directory / "letify-wake.lock").open("a+b") as handle:
         if os.name == "nt":  # pragma: no cover - Windows file locking
@@ -38,13 +38,23 @@ def account_lock(directory: Path) -> Iterator[None]:
             handle.write(b"\0")
             handle.flush()
             handle.seek(0)
-            msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK, 1)
+            try:
+                msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK if blocking else msvcrt.LK_NBLCK, 1)
+            except OSError:
+                if blocking:
+                    raise
+                yield False
+                return
         else:
             import fcntl
 
-            fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+            try:
+                fcntl.flock(handle.fileno(), fcntl.LOCK_EX | (0 if blocking else fcntl.LOCK_NB))
+            except BlockingIOError:
+                yield False
+                return
         try:
-            yield
+            yield True
         finally:
             if os.name == "nt":  # pragma: no cover - Windows file locking
                 handle.seek(0)
@@ -60,7 +70,15 @@ def wake(config: dict[str, Any]) -> float:
     result = None
     exc = None
     try:
-        with account_lock(Path(config["directory"])):
+        with account_lock(Path(config["directory"]), blocking=False) as acquired:
+            if not acquired:
+                entry = record(config, "wake_skipped", reason="account_busy")
+                print(
+                    f"{entry['timestamp']} letify: wake {config['session']} skipped: account busy",
+                    file=sys.stderr,
+                    flush=True,
+                )
+                return SUCCESS_INTERVAL
             result = subprocess.run(
                 command, input="pass\n", capture_output=True, text=True, timeout=WAKE_TIMEOUT
             )

{letify-1.2.1 → letify-1.2.2}/letify/providers/kaggle.py

@@ -65,12 +65,12 @@ if TYPE_CHECKING:
     from ..runtime.channel import Channel
     from ..runtime.session import Runtime
 
-#: Accelerators a Kaggle session can be started with, the memory of one card, and the name
-#: the internal API knows the card by. Both are ones the web app offers, so a session can be
-#: started on either. CPU is the empty compute, so it carries no accelerator name.
+#: GPU session shapes, with memory per card, device count and the internal API name.
+#: P100 remains available through the API although the web UI no longer lists it.
+#: CPU is the empty compute, so it carries no accelerator name.
 GPUS = {
-    "P100": {"vram_gb": 16, "accelerator": "NVIDIA_TESLA_P100"},
-    "T4": {"vram_gb": 16, "accelerator": "NVIDIA_TESLA_T4"},
+    "P100": {"vram_gb": 16, "devices": 1, "accelerator": "NVIDIA_TESLA_P100"},
+    "T4": {"vram_gb": 16, "devices": 2, "accelerator": "NVIDIA_TESLA_T4"},
 }
 TPUS = ("TPU_V3_8",)
 
@@ -974,7 +974,10 @@ class Kaggle(Provider):
         """The fixed list of accelerators a Kaggle session offers. No call is made."""
         table: dict[str, Instance] = {"CPU": Instance(self, gpu=None)}
         table.update(
-            {name: Instance(self, gpu=name, vram_gb=spec["vram_gb"]) for name, spec in GPUS.items()}
+            {
+                name: Instance(self, gpu=name, vram_gb=spec["vram_gb"], devices=spec["devices"])
+                for name, spec in GPUS.items()
+            }
         )
         table.update({name: Instance(self, tpu=name) for name in TPUS})
         return table
@@ -1050,7 +1053,7 @@ class Kaggle(Provider):
         cookie = self._require_live_cookie()
         instance = getattr(runtime, "instance", None)
         gpu = getattr(instance, "gpu", None)
-        accelerator = GPUS[gpu]["accelerator"] if gpu in GPUS else None
+        accelerator = GPUS[gpu]["accelerator"] if gpu in GPUS else getattr(instance, "tpu", None)
         run, url, notebook, slug = live_session_url(self.alias, cookie, accelerator)
         session = Session(self.alias, url)
         session.wait_alive()

{letify-1.2.1 → letify-1.2.2}/letify/runtime/channel.py

@@ -29,7 +29,7 @@ import subprocess
 import sys
 import threading
 import time
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Iterator, Sequence
 from typing import IO, Any
 
 from .. import protocol
@@ -112,6 +112,7 @@ class Channel(abc.ABC):
         kwargs: dict,
         *,
         timeout: float | None = None,
+        modules: Sequence[str] = (),
     ) -> tuple[Any, str]:
         """Run one function call inside the runtime."""
         head, buffers = protocol.dumps_call_parts(fn, args, kwargs)
@@ -908,10 +909,11 @@ class OneShotChannel(Channel):
         kwargs: dict,
         *,
         timeout: float | None = None,
+        modules: Sequence[str] = (),
     ) -> tuple[Any, str]:
         from ..protocol import driver
 
-        source = driver.build(fn, args, kwargs)
+        source = driver.build(fn, args, kwargs, modules=modules)
         stdout = self._run(source, timeout)
         logs, value = protocol.parse(stdout, runtime_key=self.name)
         return value, logs

{letify-1.2.1 → letify-1.2.2}/letify/runtime/session.py

@@ -276,13 +276,11 @@ class Runtime:
         """
         if self.channel is None:
             raise RuntimeFailure(f"{self.name}: the channel is not open")
-        # Done here rather than at declaration time, because the registration lives in
-        # cloudpickle and a process can hold declarations with different environments.
-        if self.env.ship_modules:
-            protocol.codec.ship_by_value(self.env.ship_modules)
         if not self.persistent_channel:
             self.last_used = time.monotonic()
-            return self.channel.call(fn, args, kwargs, timeout=timeout)
+            return self.channel.call(
+                fn, args, kwargs, timeout=timeout, modules=self.env.ship_modules
+            )
         args, kwargs = self._externalize(args, kwargs)
         return self._call_with_data(fn, args, kwargs, timeout, data_order, data_first_wave)
 
@@ -308,17 +306,27 @@ class Runtime:
         assert self.channel is not None
         root = (self.workspace or self.provider.workspace_root).rstrip("/")
         call_dir = f"{root}/data/calls/{secrets.token_hex(8)}"
+        modules_root = f"{root}/modules"
         collector = pathdata.Collector(call_dir)
+        ship_digests: set[str] = set()
+        if self.env.ship_modules:
+            for name in self.env.ship_modules:
+                placed = collector.collect_module(name, modules_root)
+                for _rel, digest, _size, _loc in placed.entries:
+                    ship_digests.add(digest)
         head, buffers = protocol.dumps_call_parts(fn, args, kwargs, data=collector)
         request: dict[str, Any] = {"op": "call", "payload": head, "buffers": buffers}
         blobs = f"{root}/data/blobs"
         stream: pathdata.Stream | None = None
+        if self.env.ship_modules:
+            request["modules_dir"] = modules_root
         if collector.placed:
-            request["data"] = collector.request(blobs)
+            extra_dirs = [modules_root] if self.env.ship_modules else ()
+            request["data"] = collector.request(blobs, extra_dirs=extra_dirs)
             if collector.inputs:
                 stream = self._stream_data(
                     collector, request["data"], blobs, fn, args, kwargs,
-                    data_order, data_first_wave,
+                    data_order, data_first_wave, ship_digests=ship_digests,
                 )
         self.last_used = time.monotonic()
         outcome = None
@@ -351,6 +359,7 @@ class Runtime:
         kwargs: dict,
         data_order: Any,
         data_first_wave: int | None,
+        ship_digests: set[str] | None = None,
     ) -> Any:
         """Derive the send order, place the first wave, and start the background sender."""
         from ..store import pathdata, sendorder
@@ -367,6 +376,10 @@ class Runtime:
             files=int(option("data_first_wave_files", pathdata.FIRST_WAVE_FILES)),
             count=data_first_wave,
         )
+        if ship_digests:
+            needed = [d for d in plan.missing if d in ship_digests and d not in wave]
+            if needed:
+                wave = needed + wave
         stream = pathdata.Stream(self, blobs, plan)
         if not plan.missing:
             # Nothing to stream: the runtime holds every file, so the call places them all