urun-cli 0.6.2__tar.gz → 0.7.0__tar.gz

{urun_cli-0.6.2 → urun_cli-0.7.0}/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.6.3
+
+- Bump the vendored `urun-openai` binary pin to `@urun-sh/openai@0.5.0` — the
+  **`omp` agent launcher** (`urun compat omp -p "..."`, the direct
+  extension lane: no proxy subprocess, omp loads `@urun-sh/openai/pi-extension`
+  via its own `-e` mechanism and selects the app with `--model urun/<slug>`)
+  ships through the installed CLI's vendored bundle. Pin + integrity advanced
+  in the same commit (supply-chain contract, see `scripts/openai_proxy.pin`).
+
 # Changelog
 
 ## 0.5.4

{urun_cli-0.6.2 → urun_cli-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: urun-cli
-Version: 0.6.2
+Version: 0.7.0
 Summary: End-user CLI for deploying apps to urun
 Project-URL: Homepage, https://urun.sh
 Project-URL: Repository, https://github.com/urun-sh/urun-cli
@@ -18,11 +18,14 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Build Tools
 Requires-Python: >=3.11
+Provides-Extra: rust
+Requires-Dist: tree-sitter-rust==0.24.0; extra == 'rust'
+Requires-Dist: tree-sitter==0.25.2; extra == 'rust'
 Description-Content-Type: text/markdown
 
 # urun CLI
 
-Deploy Python apps to urun from your terminal.
+Deploy Python and Rust (native SDK) apps to urun from your terminal.
 
 [![PyPI](https://img.shields.io/pypi/v/urun-cli.svg)](https://pypi.org/project/urun-cli/)
 [![Python](https://img.shields.io/pypi/pyversions/urun-cli.svg)](https://pypi.org/project/urun-cli/)
@@ -35,6 +38,15 @@ uv tool install urun-cli
 pip install urun-cli
 ```
 
+For Rust (native SDK) deploys, install with the `[rust]` extra — see
+[Deploy a Rust app (native SDK)](#deploy-a-rust-app-native-sdk):
+
+```bash
+uv tool install "urun-cli[rust]"
+# or
+pip install "urun-cli[rust]"
+```
+
 The package installs the `urun` command:
 
 ```bash
@@ -154,6 +166,100 @@ Override the examples checkout with `--examples-root` or `URUN_EXAMPLES_ROOT`;
 override the session API with `--session-url` or `URUN_SESSION_BASE_URL`; pin
 the function with `--function` and the environment with `--environment`.
 
+## Deploy a Rust app (native SDK)
+
+Rust apps use the native SDK crate `urun` and are declared by an inline module
+owning `#[urun::app(name = "...")]` with nested `#[urun::function]` handlers.
+
+The executable calls `urun::main!(app)` from `fn main()`. Each handler crosses
+the `ctx.self_test(...)` barrier before accessing session state. The runnable
+`native-echo` example below includes the complete lifecycle.
+
+Install the CLI with the Rust parser extra (a plain install stays
+dependency-free; the extra pulls the pinned `tree-sitter`/`tree-sitter-rust`
+wheels used for static declaration extraction — no Rust toolchain needed):
+
+```bash
+uv tool install "urun-cli[rust]"
+# or
+pip install "urun-cli[rust]"
+```
+
+Deploy by pointing at the project's `Cargo.toml` (a `src/main.rs` or the
+project directory also work):
+
+```bash
+urun deploy path/to/project/Cargo.toml
+```
+
+- **Vendor the SDK in-root.** The `urun` SDK crate is not published to
+  crates.io and the build environment has no private git credentials, so the
+  crate must ship inside your deploy root: reference it by a relative path
+  dependency (`urun = { path = "vendor/urun" }`) or as a member of the Cargo
+  workspace rooted there. Credential-free registry/git dependencies are fine.
+- **`Cargo.lock` is mandatory.** The builder builds with `--locked`; a missing
+  lock file fails the deploy.
+- The bundle is the full in-root Cargo workspace / path-dependency / resource
+  closure, minus `target/`, `.git`, and `.cargo/credentials{,.toml}`.
+
+A runnable starting point is the SDK checkout's `examples/native-echo` app,
+which vendors the SDK via a path dependency and deploys as-is:
+
+```bash
+git clone git@github.com:urun-sh/urun-rs.git
+urun deploy urun-rs/examples/native-echo
+```
+
+## Deploy a mixed Python + Rust app
+
+ONE app can hold functions implemented in BOTH languages: one identity, one
+release, the full function set replaced atomically on every deploy. Declare
+the sources explicitly in the project's `pyproject.toml` — nothing is scanned
+or inferred, so vendored SDK examples are never pulled into your app:
+
+```toml
+# pyproject.toml
+[tool.urun]
+entrypoints = ["app.py", "native/src/main.rs"]
+```
+
+Python functions register on one `App("mixed-app")`. Rust functions use
+`#[urun::function(...)]` inside `#[urun::app(name = "mixed-app")]`.
+The builder assembles both into one function registry: the language belongs
+to the function, not to a separate app. See the runnable
+[`examples/mixed-app`](https://github.com/urun-sh/urun-rs/tree/main/examples/mixed-app)
+for complete Python and Rust implementations, including self-tests and calls
+in both directions.
+
+Deploy the whole app with any of these — each resolves the ENTIRE declared
+app, so one component invocation never accidentally retires its sibling
+functions:
+
+```bash
+urun deploy .                # the config directory
+urun deploy pyproject.toml   # the declaration itself
+urun deploy app.py           # a declared component
+urun deploy native/src/main.rs
+```
+
+- **One identity across all sources.** Python helpers may import the same
+  `App` object; Rust declarations use the same app-name literal. A different
+  App object, mismatched name, or duplicate function name is a hard error.
+- **Declared paths stay in the config directory** (root-relative, no `..`
+  escapes, every declared file present). The bundle root may widen through
+  ordinary Cargo workspace resolution — e.g. a crate that is a member of a
+  wider workspace ships that whole workspace closure — and every entrypoint
+  and `manifest_path` rebases onto it.
+- **Python dependencies stay Python.** The manifest's `deps` block is
+  resolved from the Python source exactly like a pure Python deploy
+  (`Dependencies(python=...)`, `requirements.txt`, `python_version`); the
+  Rust sources' `apt`/`build_deps` function options fold into the same lists.
+- **Resources ride with their code** in both halves: the Python import/data
+  closure plus each Rust crate's full workspace/path closure and every
+  referenced `Cargo.lock`.
+
+A runnable starting point is the SDK checkout's `examples/mixed-app` app.
+
 ## Serve a model from the catalog
 
 `urun serve` deploys a model straight from the urun model catalog — no app code
@@ -449,6 +555,8 @@ would fire kubectl at a cluster you are not looking at.
 | Entrypoint | Included source |
 | --- | --- |
 | `urun deploy app.py` | `app.py` and local Python files it imports |
+| `urun deploy Cargo.toml` | The in-root Cargo workspace / path-dependency closure (see [Deploy a Rust app (native SDK)](#deploy-a-rust-app-native-sdk)). |
+| `urun deploy .` / `pyproject.toml` | The whole explicitly-declared `[tool.urun]` app — Python + Rust sources, both closures (see [Deploy a mixed Python + Rust app](#deploy-a-mixed-python--rust-app)). A declared component (`app.py`, `native/src/main.rs`) resolves the same entire app. |
 
 Dependencies are declared in your urun app code. Project-level files such as
 `pyproject.toml` and `requirements.txt` are not uploaded as dependency

{urun_cli-0.6.2 → urun_cli-0.7.0}/README.md

@@ -1,6 +1,6 @@
 # urun CLI
 
-Deploy Python apps to urun from your terminal.
+Deploy Python and Rust (native SDK) apps to urun from your terminal.
 
 [![PyPI](https://img.shields.io/pypi/v/urun-cli.svg)](https://pypi.org/project/urun-cli/)
 [![Python](https://img.shields.io/pypi/pyversions/urun-cli.svg)](https://pypi.org/project/urun-cli/)
@@ -13,6 +13,15 @@ uv tool install urun-cli
 pip install urun-cli
 ```
 
+For Rust (native SDK) deploys, install with the `[rust]` extra — see
+[Deploy a Rust app (native SDK)](#deploy-a-rust-app-native-sdk):
+
+```bash
+uv tool install "urun-cli[rust]"
+# or
+pip install "urun-cli[rust]"
+```
+
 The package installs the `urun` command:
 
 ```bash
@@ -132,6 +141,100 @@ Override the examples checkout with `--examples-root` or `URUN_EXAMPLES_ROOT`;
 override the session API with `--session-url` or `URUN_SESSION_BASE_URL`; pin
 the function with `--function` and the environment with `--environment`.
 
+## Deploy a Rust app (native SDK)
+
+Rust apps use the native SDK crate `urun` and are declared by an inline module
+owning `#[urun::app(name = "...")]` with nested `#[urun::function]` handlers.
+
+The executable calls `urun::main!(app)` from `fn main()`. Each handler crosses
+the `ctx.self_test(...)` barrier before accessing session state. The runnable
+`native-echo` example below includes the complete lifecycle.
+
+Install the CLI with the Rust parser extra (a plain install stays
+dependency-free; the extra pulls the pinned `tree-sitter`/`tree-sitter-rust`
+wheels used for static declaration extraction — no Rust toolchain needed):
+
+```bash
+uv tool install "urun-cli[rust]"
+# or
+pip install "urun-cli[rust]"
+```
+
+Deploy by pointing at the project's `Cargo.toml` (a `src/main.rs` or the
+project directory also work):
+
+```bash
+urun deploy path/to/project/Cargo.toml
+```
+
+- **Vendor the SDK in-root.** The `urun` SDK crate is not published to
+  crates.io and the build environment has no private git credentials, so the
+  crate must ship inside your deploy root: reference it by a relative path
+  dependency (`urun = { path = "vendor/urun" }`) or as a member of the Cargo
+  workspace rooted there. Credential-free registry/git dependencies are fine.
+- **`Cargo.lock` is mandatory.** The builder builds with `--locked`; a missing
+  lock file fails the deploy.
+- The bundle is the full in-root Cargo workspace / path-dependency / resource
+  closure, minus `target/`, `.git`, and `.cargo/credentials{,.toml}`.
+
+A runnable starting point is the SDK checkout's `examples/native-echo` app,
+which vendors the SDK via a path dependency and deploys as-is:
+
+```bash
+git clone git@github.com:urun-sh/urun-rs.git
+urun deploy urun-rs/examples/native-echo
+```
+
+## Deploy a mixed Python + Rust app
+
+ONE app can hold functions implemented in BOTH languages: one identity, one
+release, the full function set replaced atomically on every deploy. Declare
+the sources explicitly in the project's `pyproject.toml` — nothing is scanned
+or inferred, so vendored SDK examples are never pulled into your app:
+
+```toml
+# pyproject.toml
+[tool.urun]
+entrypoints = ["app.py", "native/src/main.rs"]
+```
+
+Python functions register on one `App("mixed-app")`. Rust functions use
+`#[urun::function(...)]` inside `#[urun::app(name = "mixed-app")]`.
+The builder assembles both into one function registry: the language belongs
+to the function, not to a separate app. See the runnable
+[`examples/mixed-app`](https://github.com/urun-sh/urun-rs/tree/main/examples/mixed-app)
+for complete Python and Rust implementations, including self-tests and calls
+in both directions.
+
+Deploy the whole app with any of these — each resolves the ENTIRE declared
+app, so one component invocation never accidentally retires its sibling
+functions:
+
+```bash
+urun deploy .                # the config directory
+urun deploy pyproject.toml   # the declaration itself
+urun deploy app.py           # a declared component
+urun deploy native/src/main.rs
+```
+
+- **One identity across all sources.** Python helpers may import the same
+  `App` object; Rust declarations use the same app-name literal. A different
+  App object, mismatched name, or duplicate function name is a hard error.
+- **Declared paths stay in the config directory** (root-relative, no `..`
+  escapes, every declared file present). The bundle root may widen through
+  ordinary Cargo workspace resolution — e.g. a crate that is a member of a
+  wider workspace ships that whole workspace closure — and every entrypoint
+  and `manifest_path` rebases onto it.
+- **Python dependencies stay Python.** The manifest's `deps` block is
+  resolved from the Python source exactly like a pure Python deploy
+  (`Dependencies(python=...)`, `requirements.txt`, `python_version`); the
+  Rust sources' `apt`/`build_deps` function options fold into the same lists.
+- **Resources ride with their code** in both halves: the Python import/data
+  closure plus each Rust crate's full workspace/path closure and every
+  referenced `Cargo.lock`.
+
+A runnable starting point is the SDK checkout's `examples/mixed-app` app.
+
 ## Serve a model from the catalog
 
 `urun serve` deploys a model straight from the urun model catalog — no app code
@@ -427,6 +530,8 @@ would fire kubectl at a cluster you are not looking at.
 | Entrypoint | Included source |
 | --- | --- |
 | `urun deploy app.py` | `app.py` and local Python files it imports |
+| `urun deploy Cargo.toml` | The in-root Cargo workspace / path-dependency closure (see [Deploy a Rust app (native SDK)](#deploy-a-rust-app-native-sdk)). |
+| `urun deploy .` / `pyproject.toml` | The whole explicitly-declared `[tool.urun]` app — Python + Rust sources, both closures (see [Deploy a mixed Python + Rust app](#deploy-a-mixed-python--rust-app)). A declared component (`app.py`, `native/src/main.rs`) resolves the same entire app. |
 
 Dependencies are declared in your urun app code. Project-level files such as
 `pyproject.toml` and `requirements.txt` are not uploaded as dependency

{urun_cli-0.6.2 → urun_cli-0.7.0}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "urun-cli"
-# Cut the paused-function recovery fixes merged after v0.6.0.
+# Cut the native Rust SDK deploy path (feature minor on 0.6.x).
 #
 # WHY THIS IS EDITED BY HAND. [tool.semantic_release] below is fully
 # configured -- conventional commit parser, version_toml pointing here, tag
@@ -19,8 +19,8 @@ name = "urun-cli"
 # READS this value and skips publishing when the matching tag already exists,
 # so every merge remains on the already-published version until this value is
 # advanced. Wiring semantic-release into CI remains separate work; this patch
-# bump is the minimal release unblock for the three post-v0.6.0 fixes.
-version = "0.6.2"
+# bump is the minimal release unblock (post-v0.6.3 fixes + the Rust feature minor).
+version = "0.7.0"
 description = "End-user CLI for deploying apps to urun"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -49,6 +49,16 @@ Issues = "https://github.com/urun-sh/urun-cli/issues"
 urun = "urun.cli:main"
 urun-cli = "urun.cli:main"
 
+[project.optional-dependencies]
+# Rust app discovery (urun/rust.py) parses with the pinned native
+# tree-sitter wheels; lazy-imported only for Rust deploys, so the ordinary
+# wheel stays dependency-free. Pin advance = contract native_crate_baselines
+# (tree-sitter 0.25.2 / tree-sitter-rust 0.24.0).
+rust = [
+  "tree-sitter==0.25.2",
+  "tree-sitter-rust==0.24.0",
+]
+
 [dependency-groups]
 dev = [
   # The build backend, present in the dev env so tests can import hatch_build.py

{urun_cli-0.6.2 → urun_cli-0.7.0}/src/urun/catalog.py

@@ -104,6 +104,7 @@ ENGINE_DEPS: dict[str, list[str]] = {
     "echo-speak": [],
     "echo-video": [],
     "echo-video-diffusion": [],
+    "echo-t2av": [],
     "vllm": [
         "vllm==0.24.0",
         "arctic-inference==0.1.1",
@@ -386,6 +387,65 @@ ENGINE_DEPS: dict[str, list[str]] = {
         "huggingface_hub[hf_transfer]>=0.30.0,<1.0.0",
         "sentencepiece",
     ],
+    "t2av": [
+        "remote_pdb>=1.4",
+        "scipy>=1.14.1",
+        "six>=1.16.0",
+        "h5py>=3.12.1",
+        "requests>=2.32.2",
+        "numpy>=1.26,<2",
+        "transformers>=5.0.0",
+        "tokenizers>=0.20.1,<0.23",
+        "sentencepiece>=0.2.0",
+        "timm>=1.0.11",
+        "peft>=0.15.0",
+        "diffusers>=0.38.0",
+        "torch==2.12.0",
+        "torchvision",
+        "torchaudio",
+        "accelerate==1.0.1",
+        "opencv-python>=4.10,<5",
+        "pillow>=10.3.0",
+        "imageio>=2.36.0",
+        "imageio-ffmpeg>=0.5.1",
+        "einops",
+        "loguru",
+        "tqdm",
+        "PyYAML>=6.0.1",
+        "protobuf>=5.28.3",
+        "aiohttp",
+        "huggingface_hub",
+        "cloudpickle",
+        "omegaconf",
+        "gpustat",
+        "ninja",
+        "fastvideo-kernel==0.3.2; sys_platform == 'linux'",
+    ],
+    "ltx-realtime": [
+        "torch~=2.7",
+        "torchaudio",
+        "einops",
+        "numpy",
+        "av",
+        "transformers>=5.8.0,<5.15",
+        "safetensors",
+        "accelerate",
+        "scipy>=1.14",
+        "tqdm",
+        "pillow>=10.0.0",
+        "openimageio",
+        "cloudpickle>=3.1",
+        "huggingface_hub[hf_transfer]>=0.30.0,<1.0.0",
+        "sentencepiece",
+        "nvidia-cuda-nvcc==13.0.88",
+        "nvidia-cuda-crt==13.0.88",
+        "nvidia-cuda-cccl==13.0.85",
+        "nvidia-nvvm==13.0.88",
+        "nvidia-cuda-runtime==13.0.96",
+        "ninja",
+        "pip",
+        "nvidia-cutlass-dsl>=4.6.0.dev0,<5",
+    ],
     "media-transform": [
         "torch==2.6.0",
         "transformers==4.51.3",

{urun_cli-0.6.2 → urun_cli-0.7.0}/src/urun/cli.py

@@ -50,10 +50,15 @@ from .config import (
     secret_consent_scope,
 )
 from .deps import (
+    collect_python_sources_metadata,
     confirm_local_env_capture,
     extract_app_credentials_env,
     extract_app_gpu_type,
     extract_app_python_deps,
+    fold_rust_options,
+    mixed_gpu_type,
+    native_gpu_type,
+    native_runtime_credentials,
     resolve_declared_credentials,
     resolve_deps,
     running_in_ci,
@@ -360,7 +365,7 @@ def build_parser() -> argparse.ArgumentParser:
     )
     add_login_args(login_parser)
 
-    deploy = sub.add_parser("deploy", help="Deploy a Python app to urun")
+    deploy = sub.add_parser("deploy", help="Deploy a Python or Rust (native SDK) app to urun")
     add_deploy_args(deploy)
 
     env_parser = sub.add_parser(
@@ -444,11 +449,13 @@ def build_parser() -> argparse.ArgumentParser:
         "dev",
         help="Watch a local app and hot-reload it on every save, or --attach to a deployed one",
         description=(
-            "Deploy a Python app, then watch its directory and continuously "
-            "redeploy on every save. Code-only edits take the control plane's "
-            "hot-reload fast lane (the running pod adopts the new code in place, "
-            "no dependency reinstall or image rebuild), so iteration is fast. "
-            "Changing declared dependencies, adding/removing files, or moving the "
+            "Deploy a Python or Rust (native SDK) app, then watch its directory "
+            "and continuously redeploy on every save. Code-only Python edits "
+            "take the control plane's hot-reload fast lane (the running pod "
+            "adopts the new code in place, no dependency reinstall or image "
+            "rebuild), so iteration is fast; native Rust source changes always "
+            "rebuild through Cargo — they are never hot-patched. Changing "
+            "declared dependencies, adding/removing files, or moving the "
             "entrypoint falls back to a full rebuild (and the CLI says so). "
             "Dev deploys are ephemeral: while `urun dev` runs the app keeps one "
             "replica warm with capacity capped at 1 (your app's own warm= / "
@@ -467,10 +474,11 @@ def build_parser() -> argparse.ArgumentParser:
 
     run = sub.add_parser(
         "run",
-        help="Run a Python app on urun",
+        help="Run a Python or Rust (native SDK) app on urun",
         description=(
-            "Run a Python app on urun. In this release, run uses the deploy pipeline "
-            "while the full deploy/run/monitor workflow is still being built."
+            "Run a Python or Rust (native SDK) app on urun. In this release, run "
+            "uses the deploy pipeline while the full deploy/run/monitor workflow "
+            "is still being built."
         ),
     )
     add_deploy_args(run)
@@ -1728,7 +1736,14 @@ def make_retry_logger(verbose: bool) -> RetryReporter:
 
 
 def add_deploy_args(parser: argparse.ArgumentParser) -> None:
-    parser.add_argument("entrypoint", nargs="?", help="Python app file, e.g. app.py")
+    parser.add_argument(
+        "entrypoint",
+        nargs="?",
+        help=(
+            "App entrypoint: a Python file (app.py), or a Rust project's "
+            "Cargo.toml / src/main.rs for a native SDK deploy"
+        ),
+    )
     parser.add_argument("--name", help="App name (defaults from entrypoint file)")
     parser.add_argument(
         "--environment",
@@ -2122,13 +2137,47 @@ def deploy_once(args: argparse.Namespace) -> DeployOutcome:
     layout = discover_deploy_layout(args.entrypoint, invocation_root)
     entrypoint, files = layout.entrypoint, layout.files
     entrypoint_path = layout.entrypoint_path
-    # Fail LOUD before registering anything: an import that would silently not
-    # ship (or not import at runtime) is a deploy-time error, never a pod
-    # crashloop (the dreamx 2026-06-26 silent-drop hop).
-    assert_collected_imports_resolve(
-        layout, declared_deps=extract_app_python_deps(entrypoint_path).get("python", [])
-    )
-    deps, deps_blob, python_version = resolve_deps(layout.root, entrypoint_path)
+    runtime = layout.runtime
+    if runtime is None:
+        # Python deploy (unchanged behavior). Fail LOUD before registering
+        # anything: an import that would silently not ship (or not import at
+        # runtime) is a deploy-time error, never a pod crashloop (the dreamx
+        # 2026-06-26 silent-drop hop).
+        assert_collected_imports_resolve(
+            layout, declared_deps=extract_app_python_deps(entrypoint_path).get("python", [])
+        )
+        deps, deps_blob, python_version = resolve_deps(layout.root, entrypoint_path)
+    elif runtime.get("kind") == "mixed":
+        # MIXED deploy: ONE app (Python + Rust sources), ONE release. EVERY
+        # declared Python source's import closure is first-class metadata:
+        # credentials, deps and GPU declarations are extracted across the
+        # WHOLE union (deduped by file identity), imports are verified against
+        # the collected closure, deps resolve through the normal Python path
+        # (app/requirements kinds; NEVER the Rust-only supervisor spec) with
+        # per-function declarations preserved for the builder, and the Rust
+        # sources' apt/build_deps options fold into the SAME deps block.
+        # Discovery already rejected identity mismatches and statically-visible
+        # duplicate function names.
+        python_entrypoint_path = layout.python_entrypoint_path
+        # Computed ONCE here and reused by the credentials and GPU-class
+        # blocks below — never re-parsed per metadata consumer.
+        mixed_metadata = collect_python_sources_metadata(layout.collected)
+        assert_collected_imports_resolve(
+            layout._replace(entrypoint_path=python_entrypoint_path),
+            declared_deps=mixed_metadata["python_deps"],
+        )
+        deps, deps_blob, python_version = resolve_deps(
+            layout.root, python_entrypoint_path, python_sources=list(layout.collected)
+        )
+        deps = fold_rust_options(deps, runtime)
+    else:
+        # Native Rust deploy: there is no Python entrypoint to parse, so the
+        # Python import/deps AST scans are skipped entirely. resolve_deps
+        # consumes the discovery-produced runtime object directly — the Rust
+        # source is never reparsed here.
+        deps, deps_blob, python_version = resolve_deps(
+            layout.root, entrypoint_path, runtime=runtime
+        )
 
     # PER-DEPLOY torch backend. `resolve_deps` already threads the app-declared
     # ``Dependencies(torch_backend=...)`` into ``deps`` for a plain `urun deploy`.
@@ -2137,7 +2186,7 @@ def deploy_once(args: argparse.Namespace) -> DeployOutcome:
     # build's app-deps install (urun-python deps_install) installs the engine's
     # pinned torch from the GPU-correct CUDA index.
     torch_backend = getattr(args, "torch_backend", None)
-    if torch_backend:
+    if torch_backend and (runtime is None or runtime.get("kind") == "mixed"):
         deps = {**deps, "torch_backend": torch_backend}
 
     # Derive the fallback name from the entrypoint's boundary-relative path —
@@ -2145,22 +2194,45 @@ def deploy_once(args: argparse.Namespace) -> DeployOutcome:
     # app used to derive "app" from inside backend/ and "backend" from the
     # repo root).
     entrypoint_rel = entrypoint_path.relative_to(layout.boundary).as_posix()
-    # The app's OWN declared App("...") name is the SINGLE source of truth
-    # (OWNER ruling: one identity per app, no divergence). --name stays for
-    # compat, but when the entrypoint declares a static App("<literal>") name a
-    # divergent --name is a HARD ERROR — that mismatch is exactly how one app
+    # The app's OWN declared identity is the SINGLE source of truth (OWNER
+    # ruling: one identity per app, no divergence). Python reads a static
+    # App("<literal>") name; a native deploy reads the #[urun::app(name =
+    # "...")] literal carried on the layout. A divergent --name is a HARD
+    # ERROR either way — that mismatch is exactly how one app
     # (App("magic-mirror")) got deployed under a second control-plane identity
     # (--name magic-mirror-sana) and forked into a duplicate row.
-    declared = declared_app_name(entrypoint_path)
+    declared = declared_app_name(entrypoint_path) if runtime is None else layout.app_name
     if args.name is not None and declared is not None and args.name != declared:
+        if runtime is None:
+            declared_how = 'App("...")'
+        elif runtime.get("kind") == "mixed":
+            declared_how = (
+                'the mixed app\'s declared identity (App("...") / #[urun::app(name = "...")])'
+            )
+        else:
+            declared_how = '#[urun::app(name = "...")]'
         raise UrunError(
             f"--name {args.name!r} disagrees with the app's own declared identity "
-            f'App("{declared}") in {entrypoint_rel}. The App("...") name is the '
-            "single source of truth for an app's identity; drop --name (it is "
-            f'inferred from App("...")) or make it match. To rename the app, '
-            f'change the App(...) literal to "{args.name}".'
+            f'{declared_how} "{declared}" in {entrypoint_rel}. The declared name is '
+            "the single source of truth for an app's identity; drop --name (it is "
+            "inferred from the declaration) or make it match. To rename the app, "
+            f'change the declared name to "{args.name}".'
         )
-    app_name = args.name or derive_app_name(entrypoint_rel, entrypoint_path)
+    if runtime is None:
+        app_name = args.name or derive_app_name(entrypoint_rel, entrypoint_path)
+    elif declared is None:
+        # Fail-closed, and unreachable through real discovery (urun.rust
+        # refuses any Rust app whose #[urun::app] lacks `name = "<literal>"`),
+        # so --name can never substitute for a missing declared identity —
+        # a --name-only identity is exactly the duplicate-app fork the
+        # declared-identity ruling exists to prevent. No fallback is invented.
+        raise UrunError(
+            f'native app {entrypoint_rel} carries no declared #[urun::app(name = "...")] '
+            "identity. The declared name is the single source of truth for a "
+            "native deploy — declare it in the source; --name cannot substitute."
+        )
+    else:
+        app_name = args.name or declared
 
     # Segregated dev identity (OWNER ruling 2026-07-18): a dev deploy and a
     # standard deploy of the same app share a release but NOT the app
@@ -2204,7 +2276,30 @@ def deploy_once(args: argparse.Namespace) -> DeployOutcome:
     # AT PRIMITIVE USE — surfaced through the boot self-test's ``MissingCredentialError``
     # (rendered by :func:`print_build_failure`), not by a blanket declaration check.
     # Secret values are never printed.
-    required_env, optional_env = extract_app_credentials_env(entrypoint_path)
+    if runtime is None:
+        required_env, optional_env = extract_app_credentials_env(entrypoint_path)
+    elif runtime.get("kind") == "mixed":
+        # Mixed runtime: EVERY declared Python source's closure contributes
+        # its Credentials declarations (deduped by file identity); the Rust
+        # sources' declared function-credential NAMES union in on top.
+        # Everything rides the same org-store resolution + local-env capture
+        # consent as the pure Python extraction.
+        rust_required, rust_optional = native_runtime_credentials(runtime)
+        required_env = mixed_metadata["required_env"] + [
+            n for n in rust_required if n not in mixed_metadata["required_env"]
+        ]
+        # REQUIRED wins over OPTIONAL: a name any Python source or Rust
+        # function REQUIRES never also rides the optional lane — the optional
+        # consent path (a declined name just deploys without it) must never
+        # weaken a required secret into a skippable one.
+        optional_env = [n for n in mixed_metadata["optional_env"] if n not in required_env] + [
+            n for n in rust_optional if n not in required_env
+        ]
+    else:
+        # Native runtime: credentials come from the declared function options
+        # (env-var NAMES only) and ride the exact same org-store resolution +
+        # local-env capture consent as the Python extraction.
+        required_env, optional_env = native_runtime_credentials(runtime)
     creds_to_push: dict[str, str] = {}
     creds_from_store: list[str] = []
     declared_credential_names: list[str] = []
@@ -2234,6 +2329,11 @@ def deploy_once(args: argparse.Namespace) -> DeployOutcome:
         "client_version": f"urun-cli/{__version__}",
         "environment": environment,
     }
+    if runtime is not None:
+        # runtime IS content identity (contract): emitted VERBATIM from
+        # discovery and folded into the canonical manifest hash — never
+        # stripped. Python manifests carry no runtime key at all.
+        manifest["runtime"] = runtime
     # DEPLOY-DECLARED GPU CLASS (content-bearing — the class IS content: it
     # decides the venv's torch backend). The builder's only other source of the
     # class is importing the app, which legitimately fails pre-deps-install
@@ -2242,7 +2342,14 @@ def deploy_once(args: argparse.Namespace) -> DeployOutcome:
     # an sm_120 (rtx6000) release (prod-use2 2026-07-17 rolling-sink poison).
     # Stamped only when statically certain (see extract_app_gpu_type); absent =>
     # byte-identical manifest and legacy builder behavior.
-    gpu_type = extract_app_gpu_type(entrypoint_path)
+    if runtime is None:
+        gpu_type = extract_app_gpu_type(entrypoint_path)
+    elif runtime.get("kind") == "mixed":
+        # EVERY declared Python source's closure contributes its GPU class
+        # (order-free conflict check against the Rust classes downstream).
+        gpu_type = mixed_gpu_type(mixed_metadata["gpu_classes"], runtime)
+    else:
+        gpu_type = native_gpu_type(runtime)
     if gpu_type:
         manifest["gpu_type"] = gpu_type
     # Declare the credential env-var NAMES (never values) on the manifest so the