wafer-core 0.1.37__py3-none-any.whl → 0.1.39__py3-none-any.whl

wafer_core/tools/compile/tests/test_modal_integration.py

@@ -0,0 +1,326 @@
+"""Integration tests for Modal-based CUDA compilation.
+
+These tests require Modal to be configured with valid credentials.
+They are skipped if Modal is not available or not authenticated.
+
+Run with:
+    MODAL_TOKEN_ID=... MODAL_TOKEN_SECRET=... pytest test_modal_integration.py -v
+"""
+
+import os
+from pathlib import Path
+
+import pytest
+
+# Skip all tests if Modal credentials are not set
+pytestmark = pytest.mark.skipif(
+    not os.environ.get("MODAL_TOKEN_ID") or not os.environ.get("MODAL_TOKEN_SECRET"),
+    reason="Modal credentials not configured (set MODAL_TOKEN_ID and MODAL_TOKEN_SECRET)",
+)
+
+# Test data directory
+TEST_DATA_DIR = Path(__file__).parent / "test_data"
+
+
+# =============================================================================
+# Test CUDA Code Samples
+# =============================================================================
+
+SIMPLE_KERNEL = """\
+__global__ void test_kernel() {
+    // Empty kernel for testing
+}
+"""
+
+VECTOR_ADD_KERNEL = """\
+__global__ void vector_add(float* a, float* b, float* c, int n) {
+    int idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx < n) {
+        c[idx] = a[idx] + b[idx];
+    }
+}
+"""
+
+SHARED_MEMORY_KERNEL = """\
+#define TILE_SIZE 16
+
+__global__ void tiled_matmul(float* A, float* B, float* C, int N) {
+    __shared__ float As[TILE_SIZE][TILE_SIZE];
+    __shared__ float Bs[TILE_SIZE][TILE_SIZE];
+
+    int bx = blockIdx.x, by = blockIdx.y;
+    int tx = threadIdx.x, ty = threadIdx.y;
+
+    int row = by * TILE_SIZE + ty;
+    int col = bx * TILE_SIZE + tx;
+
+    float sum = 0.0f;
+
+    for (int t = 0; t < (N + TILE_SIZE - 1) / TILE_SIZE; t++) {
+        if (row < N && t * TILE_SIZE + tx < N)
+            As[ty][tx] = A[row * N + t * TILE_SIZE + tx];
+        else
+            As[ty][tx] = 0.0f;
+
+        if (t * TILE_SIZE + ty < N && col < N)
+            Bs[ty][tx] = B[(t * TILE_SIZE + ty) * N + col];
+        else
+            Bs[ty][tx] = 0.0f;
+
+        __syncthreads();
+
+        for (int k = 0; k < TILE_SIZE; k++) {
+            sum += As[ty][k] * Bs[k][tx];
+        }
+        __syncthreads();
+    }
+
+    if (row < N && col < N) {
+        C[row * N + col] = sum;
+    }
+}
+"""
+
+SYNTAX_ERROR_KERNEL = """\
+__global__ void broken_kernel() {
+    // Missing semicolon below
+    int x = 1
+}
+"""
+
+
+# =============================================================================
+# Tests
+# =============================================================================
+
+
+class TestModalCompileSimple:
+    """Test simple kernel compilation via Modal."""
+
+    @pytest.mark.slow
+    def test_simple_kernel_ptx(self) -> None:
+        """Test compiling a simple kernel to PTX."""
+        from wafer_core.tools.compile import (
+            CompileRequest,
+            OutputFormat,
+        )
+        from wafer_core.tools.compile.modal_compile import compile_cuda
+
+        request = CompileRequest(
+            files={"kernel.cu": SIMPLE_KERNEL},
+            arch="sm_90a",
+            output=(OutputFormat.PTX,),
+        )
+
+        # Call Modal function
+        result = compile_cuda.remote({
+            "files": request.files,
+            "arch": request.arch,
+            "flags": list(request.flags),
+            "output": [fmt.value for fmt in request.output],
+        })
+
+        assert result["success"] is True
+        assert result["ptx"] is not None
+        assert ".version" in result["ptx"]
+        assert ".target" in result["ptx"]
+        assert "test_kernel" in result["ptx"]
+
+    @pytest.mark.slow
+    def test_vector_add_kernel_sass(self) -> None:
+        """Test compiling vector_add kernel to SASS."""
+        from wafer_core.tools.compile import (
+            CompileRequest,
+            OutputFormat,
+        )
+        from wafer_core.tools.compile.modal_compile import compile_cuda
+
+        request = CompileRequest(
+            files={"kernel.cu": VECTOR_ADD_KERNEL},
+            arch="sm_90a",
+            output=(OutputFormat.SASS,),
+        )
+
+        result = compile_cuda.remote({
+            "files": request.files,
+            "arch": request.arch,
+            "flags": list(request.flags),
+            "output": [fmt.value for fmt in request.output],
+        })
+
+        assert result["success"] is True
+        assert result["sass"] is not None
+        # SASS should contain assembly instructions
+        assert "vector_add" in result["sass"]
+
+    @pytest.mark.slow
+    def test_both_ptx_and_sass(self) -> None:
+        """Test generating both PTX and SASS."""
+        from wafer_core.tools.compile import (
+            CompileRequest,
+            OutputFormat,
+        )
+        from wafer_core.tools.compile.modal_compile import compile_cuda
+
+        request = CompileRequest(
+            files={"kernel.cu": VECTOR_ADD_KERNEL},
+            arch="sm_90a",
+            output=(OutputFormat.PTX, OutputFormat.SASS),
+        )
+
+        result = compile_cuda.remote({
+            "files": request.files,
+            "arch": request.arch,
+            "flags": list(request.flags),
+            "output": [fmt.value for fmt in request.output],
+        })
+
+        assert result["success"] is True
+        assert result["ptx"] is not None
+        assert result["sass"] is not None
+
+
+class TestModalCompileMultiFile:
+    """Test multi-file compilation via Modal."""
+
+    @pytest.mark.slow
+    def test_kernel_with_header(self) -> None:
+        """Test compiling a kernel that includes a header."""
+        from wafer_core.tools.compile.modal_compile import compile_cuda
+
+        main_cu = '#include "utils.cuh"\n' + """
+__global__ void apply_square(float* data, int n) {
+    int idx = blockIdx.x * blockDim.x + threadIdx.x;
+    if (idx < n) {
+        data[idx] = square(data[idx]);
+    }
+}
+"""
+        header = """
+#pragma once
+__device__ float square(float x) {
+    return x * x;
+}
+"""
+
+        result = compile_cuda.remote({
+            "files": {
+                "main.cu": main_cu,
+                "utils.cuh": header,
+            },
+            "arch": "sm_90a",
+            "flags": [],
+            "output": ["ptx"],
+        })
+
+        assert result["success"] is True
+        assert result["ptx"] is not None
+        assert "apply_square" in result["ptx"]
+
+
+class TestModalCompileArchitectures:
+    """Test compilation for different GPU architectures."""
+
+    @pytest.mark.slow
+    @pytest.mark.parametrize("arch", ["sm_80", "sm_89", "sm_90a"])
+    def test_different_architectures(self, arch: str) -> None:
+        """Test compiling for different architectures."""
+        from wafer_core.tools.compile.modal_compile import compile_cuda
+
+        result = compile_cuda.remote({
+            "files": {"kernel.cu": SIMPLE_KERNEL},
+            "arch": arch,
+            "flags": [],
+            "output": ["ptx"],
+        })
+
+        assert result["success"] is True
+        assert result["ptx"] is not None
+        assert f".target {arch}" in result["ptx"]
+
+
+class TestModalCompileErrors:
+    """Test error handling in Modal compilation."""
+
+    @pytest.mark.slow
+    def test_syntax_error(self) -> None:
+        """Test that syntax errors are reported."""
+        from wafer_core.tools.compile.modal_compile import compile_cuda
+
+        result = compile_cuda.remote({
+            "files": {"kernel.cu": SYNTAX_ERROR_KERNEL},
+            "arch": "sm_90a",
+            "flags": [],
+            "output": ["ptx"],
+        })
+
+        assert result["success"] is False
+        assert result["stderr"] != ""
+        # Error should mention the missing semicolon or syntax error
+        assert "error" in result["stderr"].lower()
+
+    @pytest.mark.slow
+    def test_missing_include(self) -> None:
+        """Test that missing includes are reported."""
+        from wafer_core.tools.compile.modal_compile import compile_cuda
+
+        kernel = '#include "nonexistent.h"\n__global__ void test() {}'
+
+        result = compile_cuda.remote({
+            "files": {"kernel.cu": kernel},
+            "arch": "sm_90a",
+            "flags": [],
+            "output": ["ptx"],
+        })
+
+        assert result["success"] is False
+        assert "nonexistent.h" in result["stderr"] or "cannot open" in result["stderr"].lower()
+
+
+class TestModalCompileFlags:
+    """Test custom compiler flags."""
+
+    @pytest.mark.slow
+    def test_optimization_flags(self) -> None:
+        """Test compilation with optimization flags."""
+        from wafer_core.tools.compile.modal_compile import compile_cuda
+
+        result = compile_cuda.remote({
+            "files": {"kernel.cu": VECTOR_ADD_KERNEL},
+            "arch": "sm_90a",
+            "flags": ["-O3"],
+            "output": ["ptx"],
+        })
+
+        assert result["success"] is True
+        assert result["ptx"] is not None
+
+    @pytest.mark.slow
+    def test_lineinfo_flag(self) -> None:
+        """Test compilation with lineinfo flag."""
+        from wafer_core.tools.compile.modal_compile import compile_cuda
+
+        result = compile_cuda.remote({
+            "files": {"kernel.cu": VECTOR_ADD_KERNEL},
+            "arch": "sm_90a",
+            "flags": ["-lineinfo"],
+            "output": ["ptx"],
+        })
+
+        assert result["success"] is True
+        assert result["ptx"] is not None
+
+
+class TestModalHealthCheck:
+    """Test Modal health check function."""
+
+    @pytest.mark.slow
+    def test_health_check(self) -> None:
+        """Test the health check endpoint."""
+        from wafer_core.tools.compile.modal_compile import health_check
+
+        result = health_check.remote()
+
+        assert result["status"] == "ok"
+        assert result["nvcc_available"] is True
+        assert "nvcc_version" in result

wafer_core/tools/compile/types.py

@@ -0,0 +1,117 @@
+"""Types for the cloud CUDA compiler."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Literal
+
+
+class OutputFormat(str, Enum):
+    """Supported output formats."""
+
+    PTX = "ptx"
+    SASS = "sass"
+
+
+# Valid SM architectures (CUDA compute capabilities)
+VALID_ARCHITECTURES = frozenset(
+    {
+        # Ampere
+        "sm_80",
+        "sm_86",
+        "sm_87",
+        # Ada Lovelace
+        "sm_89",
+        # Hopper
+        "sm_90",
+        "sm_90a",
+        # Blackwell
+        "sm_100",
+        "sm_100a",
+        "sm_101",
+        "sm_101a",
+        "sm_120",
+        "sm_120a",
+    }
+)
+
+
+@dataclass(frozen=True)
+class CompileRequest:
+    """Request to compile CUDA code.
+
+    Attributes:
+        files: Mapping of filename to file content. At least one .cu file required.
+        arch: Target GPU architecture (e.g., "sm_90a" for Hopper).
+        flags: Additional nvcc flags (e.g., ["-O3", "--maxrregcount=64"]).
+        output: Requested output formats (ptx and/or sass).
+    """
+
+    files: dict[str, str]
+    arch: str = "sm_90a"
+    flags: tuple[str, ...] = field(default_factory=tuple)
+    output: tuple[OutputFormat, ...] = field(
+        default_factory=lambda: (OutputFormat.PTX, OutputFormat.SASS)
+    )
+
+    def __post_init__(self) -> None:
+        """Validate the request."""
+        # Validate files
+        if not self.files:
+            raise ValueError("At least one file is required")
+
+        # Check for at least one .cu file
+        cu_files = [f for f in self.files if f.endswith(".cu")]
+        if not cu_files:
+            raise ValueError("At least one .cu file is required")
+
+        # Validate architecture
+        if self.arch not in VALID_ARCHITECTURES:
+            raise ValueError(
+                f"Invalid architecture '{self.arch}'. "
+                f"Valid architectures: {sorted(VALID_ARCHITECTURES)}"
+            )
+
+        # Validate output formats
+        if not self.output:
+            raise ValueError("At least one output format is required")
+
+    @property
+    def main_cu_file(self) -> str:
+        """Get the main .cu file (first one found)."""
+        for filename in self.files:
+            if filename.endswith(".cu"):
+                return filename
+        # This should never happen due to __post_init__ validation
+        raise ValueError("No .cu file found")  # pragma: no cover
+
+
+@dataclass(frozen=True)
+class CompileResponse:
+    """Response from CUDA compilation.
+
+    Attributes:
+        success: Whether compilation succeeded.
+        ptx: Generated PTX code (if requested and successful).
+        sass: Generated SASS code (if requested and successful).
+        stderr: Compiler warnings or errors.
+        compilation_time_ms: Time taken to compile in milliseconds.
+    """
+
+    success: bool
+    ptx: str | None = None
+    sass: str | None = None
+    stderr: str = ""
+    compilation_time_ms: int = 0
+
+    @classmethod
+    def error(cls, message: str, compilation_time_ms: int = 0) -> "CompileResponse":
+        """Create an error response."""
+        return cls(
+            success=False,
+            stderr=message,
+            compilation_time_ms=compilation_time_ms,
+        )
+
+
+# Type alias for the output format literal
+OutputFormatLiteral = Literal["ptx", "sass"]

{wafer_core-0.1.37.dist-info → wafer_core-0.1.39.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-core
-Version: 0.1.37
+Version: 0.1.39
 Summary: Core utilities and environments for Wafer GPU kernel optimization
 Requires-Python: >=3.10
 Requires-Dist: aiohttp>=3.9.0

{wafer_core-0.1.37.dist-info → wafer_core-0.1.39.dist-info}/RECORD

@@ -326,7 +326,7 @@ wafer_core/lib/trace_compare/api.py,sha256=JSRTcd7eZK1Z8l18TFEiA5A8ENJS1TMz7oIiw
 wafer_core/lib/trace_compare/architecture.py,sha256=8bqlAJQeJLBHblyXvFV-w55PIKiVQDPjDQZ8Jx4tuGg,2110
 wafer_core/lib/trace_compare/classifier.py,sha256=sE1K007GVk_Up2g59SVUIZ7BThf0yHNjGsZ9AyM_Ah8,6028
 wafer_core/lib/trace_compare/formatter.py,sha256=GNrCZ45ueBN05CEXjOtTuKvTI8z-g-ZZFil-ni3sWVY,37962
-wafer_core/lib/trace_compare/fusion_analyzer.py,sha256=eJba8VdHrz3IVlo4oAhFRRQLzj3I3KS-6otrFznooXg,38459
+wafer_core/lib/trace_compare/fusion_analyzer.py,sha256=xmVEF9qeroMa-ONfpnn64_q-aLyAjZ-9EIAYdVpIHKI,38555
 wafer_core/lib/trace_compare/kernel_registry.yaml,sha256=0-knXwsF3pR1x1JdIz-aWaH-5xDgTylh53E47Kf6nHo,9808
 wafer_core/lib/trace_compare/layer_segmentation.py,sha256=kI_Y1e9nrKZfdwfcrGo4h7gpMxqXI_xkgXk46zuFen4,4642
 wafer_core/lib/trace_compare/loader.py,sha256=z3gO7CV8AxZloWUCA0aA3pwkNiEnEobdLQBAII41cGY,16129
@@ -352,8 +352,7 @@ wafer_core/rollouts/cli_agents.py,sha256=e4qqqYBzWLsbw8FsNnddGApWp_on9Cvzrfd1ami
 wafer_core/rollouts/deploy.py,sha256=3t88fM_BMyAPkxIl8pS4r5ogHJvrlqWQDuIaltDZBRc,40924
 wafer_core/rollouts/dtypes.py,sha256=oRWjpbUOTf4uyXvnO9QThcSzD1fBrDQnAfRhGbxdgrg,61916
 wafer_core/rollouts/eval_helpers.py,sha256=OE7uQZRcbqQhpFqb4zOj8zafc9Gr6xZJpSrMvxXKVUw,1699
-wafer_core/rollouts/evaluation.py,sha256=fk-pGZ5vpocVmw1iBbHtxMK0K6l8pYTLHCpDNvRY1Xo,69142
-wafer_core/rollouts/events.py,sha256=z85J8kq0LXPj5CiUk4RkiTQg--r9xiO7QeeJwkyUOto,7505
+wafer_core/rollouts/evaluation.py,sha256=CGBOsqJNyC4fsgTbdcBs8OXY3Ihk_Er-K4g76GFq9M0,67139
 wafer_core/rollouts/export.py,sha256=0CfdBB7Du4E3VekKEUcTwTEFS1bOMGZ9GbD5KU3CecQ,11583
 wafer_core/rollouts/feedback.py,sha256=mu17eQbAinXZWI3hMYLq-LyF4JAdH9SfNRWY-0S8jvQ,6769
 wafer_core/rollouts/fingerprint.py,sha256=9qL9VrKdg2lhGnSD8ycMZ214EBeH5XCDpPgFJdbwmW4,10542
@@ -363,7 +362,7 @@ wafer_core/rollouts/models.py,sha256=BrMnUpTA9_HnOghpedzdLUm9Di3FyJouzOkK4PPBg_k
 wafer_core/rollouts/paths.py,sha256=9XtrA9ylhb5LttMFe2DE7X0IHeUMjuGUerII9OscYec,3436
 wafer_core/rollouts/pipeline.py,sha256=vlJTYE3ZX2XScpF9pmtv91K8Q0g8uLmcbI5jn6b5Hzg,15319
 wafer_core/rollouts/progress.py,sha256=szA9cvWT2xUxGVhF9BaAqJMmKDqMAUlxImxcOpcnqbY,29228
-wafer_core/rollouts/progress_display.py,sha256=it-IiI37k9whAuB6T_66GYgsZyidCq5x00URiOcxe2c,15769
+wafer_core/rollouts/progress_app.py,sha256=ir3fk8OZd09Zs7e7EC2WjQs_H-6W-zCbZAjSCDIcKEo,13517
 wafer_core/rollouts/prompt.py,sha256=EDmGb0rhWwke7tokIcO8dukc3q5c8x0n5Omi5CpAQmA,11022
 wafer_core/rollouts/providers.py,sha256=dcGJh1p30hstVbCDDtJ902lyafkg81DKjcOzb0uuKS0,1400
 wafer_core/rollouts/remote.py,sha256=cAYpRCONlsTeRxzLiegAUfjZWGtqBNwZTHehMhk5ldA,8816
@@ -374,10 +373,19 @@ wafer_core/rollouts/slice.py,sha256=darOZO53BuSPfvv_KjOSzulGVSWbL4OuoE3k6xXpBFg,
 wafer_core/rollouts/store.py,sha256=UDP9idDOEVs_0Pslx0K_Y8E1i-BeoqVSaxdQiaqtz1E,18051
 wafer_core/rollouts/transform_messages.py,sha256=yldzdLgugNYb5Zxju7myFBel1tmrHXx9M399ImqPLGI,20891
 wafer_core/rollouts/upload.py,sha256=hEqZfwgb0b4GYbrwRSA3fuqF70pqo6hyaQU59j3vM7E,4890
-wafer_core/rollouts/_logging/__init__.py,sha256=rCXeAssQ3gIrduuMzvKPD-ikt6rXejVL9h5XtDRyIQg,498
+wafer_core/rollouts/_logging/__init__.py,sha256=njcyIodFQKYWS6AxXSpuSH6KBQ4hS1SH71wuvt4cApc,677
 wafer_core/rollouts/_logging/color_formatter.py,sha256=x3qRKwHsUCFkgcIl8x_Ajjw82X2EedbTe14sCxMU4Kc,2267
 wafer_core/rollouts/_logging/json_formatter.py,sha256=jJIa2IZCsu2C_Y1HXQi7hbI33x6L6shN_dqu-hmhxp4,2380
-wafer_core/rollouts/_logging/logging_config.py,sha256=FY32lGbbTv5YCCN7em6LjupsV-R_onVCPeXGaQIKMYI,7449
+wafer_core/rollouts/_logging/logging_config.py,sha256=JbHCBcKHaospwF3BlKfp1HzhZTUElhtOGghKHF21bvc,10581
+wafer_core/rollouts/_logging/sample_handler.py,sha256=XhS5bVs6VKjABP7PeAp8CuEppqXUOm5rPCi-uEbt6QU,2122
+wafer_core/rollouts/_pytui/__init__.py,sha256=Q4TwOoefOqDkudvaWJ7TQF6Ak32Nqs09h7jl8luPuo8,2368
+wafer_core/rollouts/_pytui/app.py,sha256=NGNZ97nPq8ZZitMrY2tUgSEz_K3m5FqlNQpdy3geoEk,26163
+wafer_core/rollouts/_pytui/console.py,sha256=0TBZ9MPfLls6wPQvI9KA_0k1348e0VckAvPwn2y6D9Q,10804
+wafer_core/rollouts/_pytui/renderer.py,sha256=kFJoEsURAowj8KmKujcDJF00VDwiFhW4AP0fFD7hsrA,6429
+wafer_core/rollouts/_pytui/spinner.py,sha256=ilIOIubZQz5C77m-Y6te55z8c1Kz8njy66CVsxMu9xw,2256
+wafer_core/rollouts/_pytui/terminal.py,sha256=mCSZYAAH10Dl53fuCxQ2ZegkOmL1gFI5wEkTxQyOoKI,17736
+wafer_core/rollouts/_pytui/text.py,sha256=KeGJAM6MJQQLSk9y2R-HnYgLqCcc8Qk4QfukctBuYA8,14107
+wafer_core/rollouts/_pytui/theme.py,sha256=FdYrvQz66b7uMNbB2WCp8FPUvGSJ6vUHDaYnR6SSeSY,8067
 wafer_core/rollouts/agent_presets/README.md,sha256=gGyE0P_2Cp5s5ekHVY3cYcz19g91Wb-wboFakcvBriQ,7584
 wafer_core/rollouts/agent_presets/__init__.py,sha256=BLZOzAyC-cThQQQpAROeo4eEMOlMCrVEgnKYqzSsyS4,454
 wafer_core/rollouts/agent_presets/base_preset.py,sha256=vDzDiVe_DHN2fiQrtGTW309EJgt3t1jaPAgkQCgDycw,2550
@@ -577,11 +585,11 @@ wafer_core/rollouts/training/rollout_gen/__init__.py,sha256=-jX1P4Q2HSwBZ733kA1R
 wafer_core/rollouts/training/rollout_gen/async_rollout_manager.py,sha256=I1ZlQRonw-bZzxFKz94x22lLKwKBlw5Jqos5BDEDrIU,12488
 wafer_core/rollouts/training/rollout_gen/rollout_generation.py,sha256=QlkYrvS1dKFIKseLLHC_IApy4bMJDuf5iDeM0rm9wTQ,8271
 wafer_core/rollouts/training/rollout_gen/rollout_manager.py,sha256=SUOWxPqy8KPDkmYLJ-EWSm5NzDNZASBizcQuqgCGzGM,5011
-wafer_core/rollouts/tui/DESIGN.md,sha256=lrBmulRC8dbMaoKumCV9bUqdnhUJ8RxW_OLBYP3wbCo,6481
+wafer_core/rollouts/tui/DESIGN.md,sha256=ssWAZa2CIMkEBMnpm7diSsQE7cagP_CzJQhdktQVM5Q,14273
 wafer_core/rollouts/tui/__init__.py,sha256=-lAiJnFzsq9EAmynS2o0sJ0MBCsoKO8FRJycZbnx3xo,502
 wafer_core/rollouts/tui/__main__.py,sha256=cL010zdA5VKP9eQVYZThIodr4mIbb126x4agDLBUmmk,117
 wafer_core/rollouts/tui/demo.py,sha256=3jEmdFlIRLqdDINI9gOgWUV077ZFJ2AbG1yFH0QKEbo,1851
-wafer_core/rollouts/tui/monitor.py,sha256=lPfsp9clKelSD7nB8CIVjs-7MTFvAmNS2uCzrS_DH-I,38082
+wafer_core/rollouts/tui/monitor.py,sha256=BrFgFefp8p6XleSUTjjLvg75KX9QoofjZTxwI6SqUTM,40012
 wafer_core/rollouts/tui/remote_runner.py,sha256=qdoZV-MWkja8NS3zUPdeHfxbbx4D7weLjIB3T3vvLp4,4132
 wafer_core/rollouts/tui/terminal.py,sha256=-kp4rUAqwWUJbIMJAgouMoMPHUHN1OhTRh5STW1yqMI,4856
 wafer_core/rollouts/tui/traces.py,sha256=-VE32AGY03X1tGGZNm2jFSS8oWjagshlVTv_XXgOArc,62977
@@ -636,6 +644,16 @@ wafer_core/tools/capture_tool/core.py,sha256=zQPilq5ZDJxBm0MFAzrl1-I2A2fyBGPRs8r
 wafer_core/tools/capture_tool/dtypes.py,sha256=1Vm5obOCYc-Njuwkp7uqh_W4lqtYurT3b8lLnunc2Q8,3790
 wafer_core/tools/capture_tool/executor.py,sha256=n1DVfbsP60yJAazx9C9Kwed9LB7AcKXJcoDnhno7ydU,1495
 wafer_core/tools/capture_tool/metrics.py,sha256=BFZNmdE-kh3LneYdWXTNZmlLuo-DCrP5aEBHxEQYJDU,10890
+wafer_core/tools/compile/__init__.py,sha256=8VyaMDDPxg4DcT-rwMf9lcNhAanWnmsqijUJYsuzJNg,615
+wafer_core/tools/compile/compiler.py,sha256=rGPvfqLTg-7y3hyFEihF6lxiEOfbIsRwfvOZSaVJ2_A,10192
+wafer_core/tools/compile/modal_compile.py,sha256=zYrkAtGYkDiM6tJfH_hD-mJ0LqCW5HCSsf_6fADJIbI,13310
+wafer_core/tools/compile/types.py,sha256=8Hjh6Mz2a7s2JjtKYQq-l3X41gmywnbKk3tc1wvbMLM,3277
+wafer_core/tools/compile/tests/__init__.py,sha256=gSuBMN-7VayQ9HgyNuUXRumenwk7jtq86ZxdCgFjeYE,41
+wafer_core/tools/compile/tests/test_compiler.py,sha256=kQ-YTLY8ETnS83nQ8xVSygKY532epxqRTsGx311SG7w,20795
+wafer_core/tools/compile/tests/test_modal_integration.py,sha256=EIufgxGmZedovjchOp8nDWd9fM-nVAd59GsPZddUnc4,9551
+wafer_core/tools/compile/tests/test_data/utils.cuh,sha256=nLGyklqWX2RJKNmdq6eBZX9eKo06jGk6e1q5kpNQGWY,155
+wafer_core/tools/compile/tests/test_data/vector_add.cu,sha256=ZCXfrrr0SSD_g-ekZ9fAhwIq3hlQWqLhGmiLYGgKQ1s,213
+wafer_core/tools/compile/tests/test_data/with_header.cu,sha256=MktwDpDDG4zH3HEgvwqZKn3n9cb7_v-OczXEsybORRM,215
 wafer_core/tools/dispatch_baseline/__init__.py,sha256=RgWDH5rPYGDnC_MDosVAygsBj9SYLZFJQqF7QjNYwAw,1635
 wafer_core/tools/dispatch_baseline/analyzer.py,sha256=Js2ctkd_3qTbV6u8bTUBfwrnof3X2WMD8F6K2qZQowE,5229
 wafer_core/tools/dispatch_baseline/client.py,sha256=-kzRYGEFG0QnrHtgz5WATAgk1_RzQ2RGuUt7L1A6Mww,5611
@@ -676,7 +694,6 @@ wafer_core/utils/__init__.py,sha256=oPHgkMkE7wS2lYKLlXrw4Ia5EHnpVcGHFfpWebIlVKs,
 wafer_core/utils/backend.py,sha256=zt5AX00OXSIstprvQ1_WNf_PQYphD2y53kOXWvg20RY,8986
 wafer_core/utils/code_validation.py,sha256=UqS4UVDxO-atdbn6i7JygX6IFPITvT56zZn1t-ZNuM8,4692
 wafer_core/utils/environment_serialization.py,sha256=cVDkapx0JC60CekazgirPEMAeGZhbLdX1WMIkFvId60,5047
-wafer_core/utils/event_streaming.py,sha256=Sg3-hI043Ofc2b29Z3DWrKgu4HkfJoIqhhbfGRJv70Q,2260
 wafer_core/utils/exceptions.py,sha256=Tl6Ml47Sr55DLEO_ehZc9jC5bNJRONslKCga5S2U4Rc,12164
 wafer_core/utils/execution_types.py,sha256=j2AGSoEIoY13BnGK9ggZQrM1BpVf6KjXZg2ASObhOqA,1159
 wafer_core/utils/gpu_environment_utils.py,sha256=IYIQkFv_dW9jVd1oPAA7yszXrlbApXnVLiXM_Eh89U0,9560
@@ -705,6 +722,6 @@ wafer_core/utils/modal_execution/modal_app.py,sha256=VfS2cX8gHtnlPXemmMcEwDPeQdh
 wafer_core/utils/modal_execution/modal_config.py,sha256=7cGX9TGqilQ3qxI3OFGXV5orjtyRU-PEDOJ4vP2oxno,4421
 wafer_core/utils/modal_execution/modal_execution.py,sha256=gChjnV6jqA3A7IRP3DfvV5cSfm_MN0X4f7JZufXgdZE,24594
 wafer_core/utils/modal_execution/test_modal.py,sha256=_jqou_hrLs1Daf1590Pnb0a_lXMMa2rczAPpW9HpoNQ,8153
-wafer_core-0.1.37.dist-info/METADATA,sha256=i2rz9s8beDf1a-zDbQwwugs6LTYtYQLxwt6djruJjiM,1477
-wafer_core-0.1.37.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-wafer_core-0.1.37.dist-info/RECORD,,
+wafer_core-0.1.39.dist-info/METADATA,sha256=OcMn8TZzsUvPT2JBa0xYK_sAT_og1PAZd-DpDcLG1XA,1477
+wafer_core-0.1.39.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+wafer_core-0.1.39.dist-info/RECORD,,