laya: pre-resolve native execution resources and kernel handles

.github/workflows/ci.yml

@@ -23,13 +23,13 @@ jobs:
       - name: Format
         run: cargo fmt --all --check
       - name: Clippy
-        run: cargo clippy --workspace --locked --all-targets -- -D warnings
+        run: cargo clippy --workspace --locked --all-targets --features omni-laya/serve -- -D warnings
       - name: Frontend API tests
         run: cargo test -p omni-jev --test frontend --locked
       - name: Test
-        run: cargo test --workspace --locked
+        run: cargo test --workspace --locked --features omni-laya/serve
       - name: Build
-        run: cargo build --workspace --release --locked
+        run: cargo build --workspace --release --locked --features omni-laya/serve
 
   benchmarks:
     runs-on: ubuntu-latest

CONTRIBUTING.md

@@ -76,9 +76,9 @@ The Rust checks used by [CI](.github/workflows/ci.yml) are:
 
 ```sh
 cargo fmt --all --check
-cargo clippy --workspace --locked --all-targets -- -D warnings
-cargo test --workspace --locked
-cargo build --workspace --release --locked
+cargo clippy --workspace --locked --all-targets --features omni-laya/serve -- -D warnings
+cargo test --workspace --locked --features omni-laya/serve
+cargo build --workspace --release --locked --features omni-laya/serve
 ```
 
 For an agent-assisted self-review, use the repository's
@@ -96,29 +96,6 @@ remain responsible for understanding the changes and verifying the results.
 Self-review helps maintainers focus on design and correctness; it does not
 replace maintainer review.
 
-### Large code changes
-
-PRs with **more than 3,000 changed lines of authored code** need extra contributor
-attention before requesting review. Count additions plus deletions against the
-PR's merge base in source files, tests, and build or validation scripts. Report
-this count separately from the total diff size; exclude documentation, generated
-output, lockfiles, and static fixtures from the code count, while still reviewing
-those files for relevance and correctness.
-
-- Complete a full self-review of every affected component and its integration
-  boundaries. A quick precheck alone is insufficient; keep the PR in draft until
-  the contributor self-review is complete.
-- Consider splitting independent features, refactors, and cleanup into focused
-  PRs. If the change needs to stay together, explain why in the PR description
-  and provide a component map and suggested review order.
-- Include the code-line count and a validation summary for each affected area in
-  the PR description: commands, results, and unverified behavior with reasons.
-  Cover changed interfaces between components as well as individual components.
-
-Size signals the need for closer review; it is not itself a correctness finding.
-Choose checks based on the changed behavior and risk. Crossing this threshold
-alone does not require GPU benchmarks or other expensive experiments.
-
 ## Documentation site
 
 The site at <https://thinkflowlab.github.io/system1-omni/> is built with MkDocs

src/backends/cuda/Cargo.toml

@@ -7,3 +7,10 @@ publish = false
 [dependencies]
 anyhow = "1"
 libloading = "0.8"
+
+[dev-dependencies]
+tempfile = "3"
+
+[[test]]
+name = "laya_runtime"
+path = "../../../tests/cuda/laya_runtime.rs"

src/backends/cuda/src/lib.rs

@@ -7,7 +7,7 @@ use std::{
     rc::Rc,
 };
 pub type Ptr = *mut c_void;
-type Kernel = unsafe extern "C" fn(*mut Ptr, i32, i32, i32, Ptr) -> i32;
+type Launch = unsafe extern "C" fn(*mut Ptr, i32, i32, i32, Ptr) -> i32;
 struct Context {
     lib: Library,
     stream: Ptr,
@@ -86,6 +86,15 @@ impl Cuda {
     pub fn sync(&self) -> Result<()> {
         self.ctx.sync()
     }
+    /// Resolve a kernel once while retaining the owning runtime and native code.
+    pub fn resolve(&self, name: &str) -> Result<Kernel> {
+        Ok(Kernel {
+            ctx: self.ctx.clone(),
+            launch: self
+                .ctx
+                .symbol::<Launch>(format!("laya_{name}\0").as_bytes())?,
+        })
+    }
     /// # Safety
     /// Tensor shape, dtype, layout, aliasing and allocation sizes must match the generated kernel.
     /// Buffers must belong to this context and stay alive until synchronization or graph destruction.
@@ -96,7 +105,7 @@ impl Cuda {
         );
         let k = self
             .ctx
-            .symbol::<Kernel>(format!("laya_{name}\0").as_bytes())?;
+            .symbol::<Launch>(format!("laya_{name}\0").as_bytes())?;
         self.ctx.check(unsafe {
             k(
                 args.as_ptr() as *mut Ptr,
@@ -151,7 +160,7 @@ impl Cuda {
     ) -> Result<()> {
         let k = self
             .ctx
-            .symbol::<Kernel>(format!("laya_{name}\0").as_bytes())?;
+            .symbol::<Launch>(format!("laya_{name}\0").as_bytes())?;
         self.ctx.check(unsafe {
             k(
                 args.as_ptr() as *mut Ptr,
@@ -245,3 +254,31 @@ impl Drop for Graph {
         }
     }
 }
+
+/// A resolved entry point retaining its stream and native library.
+#[derive(Clone)]
+pub struct Kernel {
+    ctx: Rc<Context>,
+    launch: Launch,
+}
+impl Kernel {
+    /// # Safety
+    /// Shapes, dtype, layout, aliasing and pointer lifetimes must match this kernel.
+    /// Every pointer belongs to this context and stays alive through synchronization
+    /// or destruction of any graph that captures the launch.
+    pub unsafe fn launch(&self, args: &[Ptr], b: usize, l: usize) -> Result<()> {
+        ensure!(
+            b > 0 && b <= 16 && l > 0 && l <= 512 && l.is_multiple_of(16),
+            "invalid CUDA shape"
+        );
+        self.ctx.check(unsafe {
+            (self.launch)(
+                args.as_ptr() as *mut Ptr,
+                b as i32,
+                l as i32,
+                (b * l) as i32,
+                self.ctx.stream,
+            )
+        })
+    }
+}

src/models/laya/README.md

@@ -37,6 +37,10 @@ and [measured scope](../../../recipe/laya/native/VALIDATION.md).
 ## CPU checks
 
 The normal workspace tests cover configuration errors, malformed tensors, inventory mismatches and conversion boundaries without downloading weights.
+Feature-enabled CI also runs [CPU host/ABI regressions](../../../tests/cuda/laya/README.md)
+for resolved-handle lifetimes, exact dispatch traces and sparse wrappers. They compile a small
+native fixture with `cc` on Linux/macOS and require no CUDA toolkit or weights;
+they do not establish GPU numerical parity.
 
 To check the complete checkpoint, use `convaiinnovations/laya` revision `55cf4c4ebb4ebe31b2550e8bdf3bd21b99753851` and a Python environment with PyTorch, safetensors and NumPy: