wafer-core 0.1.26__py3-none-any.whl → 0.1.28__py3-none-any.whl

wafer_core/targets/spec_store.py

@@ -0,0 +1,200 @@
+"""Spec store: CRUD for TargetSpec TOML files.
+
+Specs live in ~/.wafer/specs/{name}.toml. On first access, auto-migrates
+from the old ~/.wafer/targets/ directory if specs/ doesn't exist yet.
+
+This module provides the same operations as the old targets.py but under
+the "spec" vocabulary. The CLI-layer targets.py still works and delegates
+here where needed.
+"""
+
+from __future__ import annotations
+
+import logging
+import shutil
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any
+
+import tomllib
+
+from wafer_core.utils.kernel_utils.targets.config import (
+    BaremetalTarget,
+    DigitalOceanTarget,
+    LocalTarget,
+    ModalTarget,
+    RunPodTarget,
+    TargetConfig,
+    VMTarget,
+    WorkspaceTarget,
+)
+
+logger = logging.getLogger(__name__)
+
+WAFER_DIR = Path.home() / ".wafer"
+SPECS_DIR = WAFER_DIR / "specs"
+OLD_TARGETS_DIR = WAFER_DIR / "targets"
+CONFIG_FILE = WAFER_DIR / "config.toml"
+
+
+def _ensure_specs_dir() -> None:
+    """Ensure ~/.wafer/specs/ exists, migrating from targets/ if needed."""
+    if SPECS_DIR.exists():
+        return
+
+    if OLD_TARGETS_DIR.exists() and any(OLD_TARGETS_DIR.glob("*.toml")):
+        logger.info(
+            f"Migrating {OLD_TARGETS_DIR} -> {SPECS_DIR} (target configs are now called 'specs')"
+        )
+        shutil.copytree(OLD_TARGETS_DIR, SPECS_DIR)
+        # Don't delete old dir yet — other code may still read from it.
+        # It becomes a dead symlink target once all callers migrate.
+        logger.info(
+            f"Migration complete. Old directory preserved at {OLD_TARGETS_DIR}. "
+            "You can safely delete it once 'wafer specs list' works."
+        )
+    else:
+        SPECS_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def _spec_path(name: str) -> Path:
+    return SPECS_DIR / f"{name}.toml"
+
+
+# ── Parsing ──────────────────────────────────────────────────────────────────
+
+_TYPE_MAP: dict[str, type] = {
+    "baremetal": BaremetalTarget,
+    "vm": VMTarget,
+    "modal": ModalTarget,
+    "workspace": WorkspaceTarget,
+    "runpod": RunPodTarget,
+    "digitalocean": DigitalOceanTarget,
+    "local": LocalTarget,
+}
+
+_TYPE_REVERSE: dict[type, str] = {v: k for k, v in _TYPE_MAP.items()}
+
+
+def parse_spec(data: dict[str, Any]) -> TargetConfig:
+    """Parse TOML dict into TargetSpec (TargetConfig union)."""
+    target_type = data.get("type")
+    if not target_type:
+        raise ValueError("Spec must have 'type' field")
+
+    cls = _TYPE_MAP.get(target_type)
+    if cls is None:
+        raise ValueError(
+            f"Unknown spec type: {target_type}. Must be one of: {', '.join(sorted(_TYPE_MAP))}"
+        )
+
+    fields = {k: v for k, v in data.items() if k != "type"}
+
+    # TOML parses lists; dataclasses may want tuples
+    if "pip_packages" in fields and isinstance(fields["pip_packages"], list):
+        fields["pip_packages"] = tuple(fields["pip_packages"])
+    if "gpu_ids" in fields and isinstance(fields["gpu_ids"], list):
+        fields["gpu_ids"] = tuple(fields["gpu_ids"])
+
+    return cls(**fields)
+
+
+def serialize_spec(spec: TargetConfig) -> dict[str, Any]:
+    """Serialize TargetSpec to TOML-compatible dict."""
+    data = asdict(spec)
+    data["type"] = _TYPE_REVERSE.get(type(spec), "unknown")
+
+    # Tuples -> lists for TOML
+    for key in ("pip_packages", "gpu_ids"):
+        if key in data and isinstance(data[key], tuple):
+            data[key] = list(data[key])
+
+    # Drop empty pip_packages
+    if "pip_packages" in data and not data["pip_packages"]:
+        del data["pip_packages"]
+
+    return data
+
+
+# ── CRUD ─────────────────────────────────────────────────────────────────────
+
+
+def load_spec(name: str) -> TargetConfig:
+    """Load spec by name from ~/.wafer/specs/{name}.toml.
+
+    Falls back to ~/.wafer/targets/{name}.toml for backwards compatibility.
+    """
+    _ensure_specs_dir()
+
+    path = _spec_path(name)
+    if not path.exists():
+        # Fallback to old location
+        old_path = OLD_TARGETS_DIR / f"{name}.toml"
+        if old_path.exists():
+            path = old_path
+        else:
+            raise FileNotFoundError(f"Spec not found: {name} (looked in {SPECS_DIR})")
+
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+
+    return parse_spec(data)
+
+
+def save_spec(spec: TargetConfig) -> None:
+    """Save spec to ~/.wafer/specs/{name}.toml."""
+    _ensure_specs_dir()
+
+    data = serialize_spec(spec)
+    path = _spec_path(spec.name)
+    _write_toml(path, data)
+
+
+def list_spec_names() -> list[str]:
+    """List all spec names from ~/.wafer/specs/."""
+    _ensure_specs_dir()
+    return sorted(p.stem for p in SPECS_DIR.glob("*.toml"))
+
+
+def remove_spec(name: str) -> None:
+    """Remove a spec by name."""
+    path = _spec_path(name)
+    if not path.exists():
+        raise FileNotFoundError(f"Spec not found: {name}")
+    path.unlink()
+
+
+def load_all_specs() -> list[TargetConfig]:
+    """Load all specs. Skips specs that fail to parse (logs warning)."""
+    specs = []
+    for name in list_spec_names():
+        try:
+            specs.append(load_spec(name))
+        except Exception as e:
+            logger.warning(f"Failed to load spec {name}: {e}")
+    return specs
+
+
+# ── TOML writer ──────────────────────────────────────────────────────────────
+
+
+def _write_toml(path: Path, data: dict[str, Any]) -> None:
+    """Write dict as flat TOML file."""
+    lines = []
+    for key, value in data.items():
+        if value is None:
+            continue
+        if isinstance(value, bool):
+            lines.append(f"{key} = {str(value).lower()}")
+        elif isinstance(value, int | float):
+            lines.append(f"{key} = {value}")
+        elif isinstance(value, str):
+            lines.append(f'{key} = "{value}"')
+        elif isinstance(value, list):
+            if all(isinstance(v, int) for v in value):
+                lines.append(f"{key} = {value}")
+            else:
+                formatted = ", ".join(f'"{v}"' if isinstance(v, str) else str(v) for v in value)
+                lines.append(f"{key} = [{formatted}]")
+
+    path.write_text("\n".join(lines) + "\n")

wafer_core/targets/state_cache.py

@@ -0,0 +1,150 @@
+"""Target state cache: bindings and labels for live resources.
+
+Cache file: ~/.wafer/target_state.json
+
+Bindings map resource_id -> spec_name (performance hint for reconciliation).
+Labels map resource_id -> {key: value} (probed software versions).
+
+The provider API is always the source of truth for whether a resource exists.
+This cache stores metadata that's expensive to recompute (SSH probes, name inference).
+
+Format:
+{
+    "bindings": {
+        "<resource_id>": {
+            "spec_name": "<spec_name>",
+            "provider": "<provider>",
+            "bound_at": "<ISO timestamp>"
+        }
+    },
+    "labels": {
+        "<resource_id>": {
+            "rocm_version": "7.0.2",
+            "python_version": "3.12",
+            ...
+        }
+    }
+}
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import asdict, dataclass
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+WAFER_DIR = Path.home() / ".wafer"
+STATE_FILE = WAFER_DIR / "target_state.json"
+
+
+@dataclass(frozen=True)
+class BindingEntry:
+    """A cached binding from resource_id to spec_name."""
+
+    spec_name: str
+    provider: str
+    bound_at: str  # ISO timestamp
+
+
+# ---------------------------------------------------------------------------
+# Raw file I/O
+# ---------------------------------------------------------------------------
+
+def _load_state() -> dict:
+    """Load the full state file. Returns empty dict if missing/corrupted."""
+    if not STATE_FILE.exists():
+        return {}
+
+    try:
+        return json.loads(STATE_FILE.read_text())
+    except (json.JSONDecodeError, TypeError) as e:
+        logger.warning(f"Corrupted state cache, ignoring: {e}")
+        return {}
+
+
+def _save_state(data: dict) -> None:
+    """Write the full state file."""
+    STATE_FILE.parent.mkdir(parents=True, exist_ok=True)
+    STATE_FILE.write_text(json.dumps(data, indent=2) + "\n")
+
+
+# ---------------------------------------------------------------------------
+# Bindings
+# ---------------------------------------------------------------------------
+
+def load_bindings() -> dict[str, BindingEntry]:
+    """Load binding cache from disk."""
+    data = _load_state()
+    bindings_raw = data.get("bindings", {})
+    result = {}
+    for rid, entry in bindings_raw.items():
+        try:
+            result[rid] = BindingEntry(**entry)
+        except TypeError:
+            logger.warning(f"Skipping malformed binding for {rid}")
+    return result
+
+
+def save_bindings(bindings: dict[str, BindingEntry]) -> None:
+    """Write bindings to disk (preserves labels)."""
+    data = _load_state()
+    data["bindings"] = {rid: asdict(entry) for rid, entry in bindings.items()}
+    _save_state(data)
+
+
+def add_binding(resource_id: str, entry: BindingEntry) -> None:
+    """Add a single binding to the cache."""
+    bindings = load_bindings()
+    bindings[resource_id] = entry
+    save_bindings(bindings)
+
+
+def remove_binding(resource_id: str) -> None:
+    """Remove a binding from the cache. No-op if not found."""
+    bindings = load_bindings()
+    if resource_id in bindings:
+        del bindings[resource_id]
+        save_bindings(bindings)
+
+
+def get_binding_hints() -> dict[str, str]:
+    """Get resource_id -> spec_name map for reconciliation."""
+    bindings = load_bindings()
+    return {rid: entry.spec_name for rid, entry in bindings.items()}
+
+
+# ---------------------------------------------------------------------------
+# Labels
+# ---------------------------------------------------------------------------
+
+def load_all_labels() -> dict[str, dict[str, str]]:
+    """Load all cached labels. Returns resource_id -> labels dict."""
+    data = _load_state()
+    return data.get("labels", {})
+
+
+def load_labels(resource_id: str) -> dict[str, str]:
+    """Load cached labels for a single resource. Returns empty dict if none."""
+    return load_all_labels().get(resource_id, {})
+
+
+def save_labels(resource_id: str, labels: dict[str, str]) -> None:
+    """Save labels for a resource (preserves bindings and other labels)."""
+    data = _load_state()
+    if "labels" not in data:
+        data["labels"] = {}
+    data["labels"][resource_id] = labels
+    _save_state(data)
+
+
+def remove_labels(resource_id: str) -> None:
+    """Remove cached labels for a resource. No-op if not found."""
+    data = _load_state()
+    labels = data.get("labels", {})
+    if resource_id in labels:
+        del labels[resource_id]
+        data["labels"] = labels
+        _save_state(data)

wafer_core/targets/types.py

@@ -0,0 +1,141 @@
+"""Target and TargetSpec: the two core concepts for GPU resource management.
+
+TargetSpec = provisioning blueprint (TOML config, "how to get a GPU")
+Target = live running resource (from provider API, "what's actually running")
+
+TargetSpec is the existing union of provider-specific frozen dataclasses
+(RunPodTarget, DigitalOceanTarget, BaremetalTarget, etc.), re-exported here
+under the name TargetSpec for clarity.
+
+Target is always fetched from provider APIs. The spec_name field links a
+live resource back to the spec that created it (None = orphan/unbound).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Protocol, runtime_checkable
+
+if TYPE_CHECKING:
+    pass
+
+# TargetSpec is the existing union type, re-exported under a clearer name.
+# Each variant is a frozen dataclass with provider-specific provisioning params.
+from wafer_core.utils.kernel_utils.targets.config import (  # noqa: E402
+    TargetConfig,
+)
+
+# TargetSpec = TargetConfig (same union, better name for the new API)
+TargetSpec = TargetConfig
+
+
+@dataclass(frozen=True)
+class Target:
+    """A live running GPU resource, fetched from a provider API.
+
+    This is the runtime counterpart to TargetSpec. A TargetSpec describes
+    *how* to provision a GPU; a Target describes *what's actually running*.
+
+    The provider API is the source of truth for Target state. Local caches
+    (target_state.json) are performance hints only.
+
+    Fields:
+        resource_id: Provider's unique ID (pod_id, droplet_id, or
+            "baremetal:{host}:{port}" for SSH targets with no cloud lifecycle).
+        provider: Which cloud provider owns this resource.
+        status: Current state from provider API.
+        public_ip: SSH-reachable IP address (None if not yet assigned).
+        ssh_port: SSH port (None if not yet assigned).
+        ssh_username: SSH user (typically "root" for cloud providers).
+        gpu_type: GPU model name (e.g., "MI300X", "B200").
+        name: Provider-side resource name (e.g., "wafer-runpod-mi300x-1706000000",
+            "kernelbench-pool-0"). Used for spec_name inference.
+        created_at: ISO timestamp of resource creation (None if unknown).
+        spec_name: Name of the TargetSpec that owns this resource.
+            None means unbound (orphan) — running but no spec claims it.
+        price_per_hour: Cost in $/hr (None if unknown or baremetal).
+        labels: Software metadata not available from the provider API's
+            structured fields. Examples: {"rocm_version": "7.0.2",
+            "cuda_version": "12.4", "image": "rocm/pytorch:rocm7.0.2_..."}.
+            Populated from the container image string at provision time,
+            or from SSH probe on demand. Pool queries filter on these.
+    """
+
+    resource_id: str
+    provider: str
+    status: str
+    public_ip: str | None
+    ssh_port: int | None
+    ssh_username: str
+    gpu_type: str
+    name: str | None = None
+    created_at: str | None = None
+    spec_name: str | None = None
+    price_per_hour: float | None = None
+    labels: dict[str, str] = field(default_factory=dict)
+
+    def __post_init__(self) -> None:
+        assert self.resource_id, "resource_id cannot be empty"
+        assert self.provider, "provider cannot be empty"
+        assert self.status, "status cannot be empty"
+
+
+@dataclass(frozen=True)
+class ReconcileResult:
+    """Result of comparing TargetSpecs to live Targets.
+
+    Pure data — no side effects. The caller decides what to do:
+    - Display bound/unbound/unprovisioned in CLI
+    - Terminate unbound targets
+    - Provision from unprovisioned specs
+
+    Fields:
+        bound: Specs matched to live targets (spec, target) pairs.
+        unbound: Live targets with no matching spec (orphans).
+        unprovisioned: Specs with no live target running.
+    """
+
+    bound: list[tuple[TargetSpec, Target]]
+    unbound: list[Target]
+    unprovisioned: list[TargetSpec]
+
+
+@runtime_checkable
+class TargetProvider(Protocol):
+    """Interface for querying and managing live GPU resources from a cloud provider.
+
+    Each cloud provider (RunPod, DigitalOcean, etc.) implements this protocol.
+    Methods are async because they hit external APIs.
+
+    Baremetal is a degenerate case: list_targets returns a Target built from
+    the spec's ssh_target, provision/terminate are no-ops.
+    """
+
+    async def list_targets(self) -> list[Target]:
+        """List all running resources on the provider account.
+
+        Always hits the provider API — never reads from local cache.
+        """
+        ...
+
+    async def get_target(self, resource_id: str) -> Target | None:
+        """Get a specific resource by provider ID.
+
+        Returns None if the resource doesn't exist or is terminated.
+        """
+        ...
+
+    async def provision(self, spec: TargetSpec) -> Target:
+        """Provision a new resource from a spec.
+
+        Blocks until the resource is SSH-ready.
+        Raises on failure (no silent None returns).
+        """
+        ...
+
+    async def terminate(self, resource_id: str) -> bool:
+        """Terminate a resource by provider ID.
+
+        Returns True if terminated, False if resource not found.
+        """
+        ...

wafer_core/utils/kernel_utils/targets/config.py

@@ -346,25 +346,17 @@ class RunPodTarget:
     ncu_available: bool = False
 
     def __post_init__(self) -> None:
-        """Validate configuration."""
-        from wafer_core.auth import get_api_key
+        """Validate configuration fields.
 
+        API key availability is checked at provision/query time, not here —
+        loading a spec from TOML should not require credentials.
+        """
         assert self.name, "name cannot be empty"
         assert self.ssh_key, "ssh_key cannot be empty"
         assert self.gpu_count > 0, "gpu_count must be positive"
         assert self.provision_timeout > 0, "provision_timeout must be positive"
         assert self.eval_timeout > 0, "eval_timeout must be positive"
 
-        # Check for API key (env var or ~/.wafer/auth.json)
-        api_key = get_api_key("runpod")
-        if not api_key:
-            raise ValueError(
-                "RunPod API key not found.\n"
-                "Set WAFER_RUNPOD_API_KEY environment variable, or run:\n"
-                "  wafer auth login runpod\n"
-                "Get your API key from: https://runpod.io/console/user/settings"
-            )
-
 
 @dataclass(frozen=True)
 class LocalTarget:
@@ -468,24 +460,16 @@ class DigitalOceanTarget:
     ncu_available: bool = False
 
     def __post_init__(self) -> None:
-        """Validate configuration."""
-        from wafer_core.auth import get_api_key
+        """Validate configuration fields.
 
+        API key availability is checked at provision/query time, not here —
+        loading a spec from TOML should not require credentials.
+        """
         assert self.name, "name cannot be empty"
         assert self.ssh_key, "ssh_key cannot be empty"
         assert self.provision_timeout > 0, "provision_timeout must be positive"
         assert self.eval_timeout > 0, "eval_timeout must be positive"
 
-        # Check for API key (env var or ~/.wafer/auth.json)
-        api_key = get_api_key("digitalocean")
-        if not api_key:
-            raise ValueError(
-                "DigitalOcean API key not found.\n"
-                "Set WAFER_AMD_DIGITALOCEAN_API_KEY environment variable, or run:\n"
-                "  wafer auth login digitalocean\n"
-                "Get your API key from: https://cloud.digitalocean.com/account/api/tokens"
-            )
-
 
 # Union type for target configs
 TargetConfig = (

{wafer_core-0.1.26.dist-info → wafer_core-0.1.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wafer-core
-Version: 0.1.26
+Version: 0.1.28
 Summary: Core utilities and environments for Wafer GPU kernel optimization
 Requires-Python: >=3.10
 Requires-Dist: aiohttp>=3.9.0
@@ -15,12 +15,14 @@ Requires-Dist: dash-svg>=0.0.11
 Requires-Dist: dash>=3.0.0
 Requires-Dist: dnspython>=2.8.0
 Requires-Dist: httpx>=0.25.0
+Requires-Dist: ijson>=3.2.0
 Requires-Dist: kaleido==0.2.1
 Requires-Dist: markdownify>=0.11.0
 Requires-Dist: matplotlib>=3.0.0
 Requires-Dist: modal>=0.64.0
 Requires-Dist: numpy>=1.17.5
 Requires-Dist: openai>=1.0.0
+Requires-Dist: orjson>=3.9.0
 Requires-Dist: pandas~=3.0.0
 Requires-Dist: paramiko>=3.0.0
 Requires-Dist: paramiko>=3.4.0

{wafer_core-0.1.26.dist-info → wafer_core-0.1.28.dist-info}/RECORD

@@ -318,12 +318,20 @@ wafer_core/lib/rocprofiler/systems/run/analyzer.py,sha256=Qg3M8-kCKdV82ehn6Ta20N
 wafer_core/lib/rocprofiler/systems/run/profiler.py,sha256=aiQLsDnfQHSeCM5zLnO4VlbTmREYnAtiuT50Eq6uWfg,8387
 wafer_core/lib/rocprofiler/systems/sample/__init__.py,sha256=31rNmLPQ7OVhvlOEEOwPKgk8_qrCidj6AmzDXexQJ_o,288
 wafer_core/lib/rocprofiler/systems/sample/profiler.py,sha256=CYZPTzNXd48LoCfmY6h_5RSYEdWYccuv3-t4YncHJLE,7384
-wafer_core/lib/trace_compare/__init__.py,sha256=G5vmiQnuweiF9vjK1FC4ZIy-tzuHiaLMs7QBnir8OJw,800
-wafer_core/lib/trace_compare/analyzer.py,sha256=o0SI1PsehpgxeUPQEB9708W_Q_ILiO5apgqVLe2xE8A,14541
-wafer_core/lib/trace_compare/classifier.py,sha256=sE1K007GVk_Up2g59SVUIZ7BThf0yHNjGsZ9AyM_Ah8,6028
+wafer_core/lib/trace_compare/PERFORMANCE.md,sha256=jkJh7ApZi8H7NKTcz8v0LNtwSFtIUqY88e3QbL749ww,3823
+wafer_core/lib/trace_compare/__init__.py,sha256=CyUPbPQDYhVLCFFA7S_jNSilG3OgqYjmHSKfR5X11go,1377
+wafer_core/lib/trace_compare/aligner.py,sha256=1S8Ob3RaEsIjN0HdqEx0yGsW5uf_lMrJVSH_MnZhKok,13788
+wafer_core/lib/trace_compare/analyzer.py,sha256=YkuOPA3HFX_7mNUEhE9CMOtEMGLQd12lvUkvqqeQF14,29698
+wafer_core/lib/trace_compare/api.py,sha256=JSRTcd7eZK1Z8l18TFEiA5A8ENJS1TMz7oIiw1KBbAs,8796
+wafer_core/lib/trace_compare/architecture.py,sha256=8bqlAJQeJLBHblyXvFV-w55PIKiVQDPjDQZ8Jx4tuGg,2110
+wafer_core/lib/trace_compare/classifier.py,sha256=CDGzY9TY-I5wRuEGsu4mTCdljqVTOnLWyFLyNgmkGXI,16864
 wafer_core/lib/trace_compare/formatter.py,sha256=GNrCZ45ueBN05CEXjOtTuKvTI8z-g-ZZFil-ni3sWVY,37962
-wafer_core/lib/trace_compare/fusion_analyzer.py,sha256=LwYTBjL_gHCvydfgFp-L9f_qfXq3GenJHRemygly4H8,36482
-wafer_core/lib/trace_compare/loader.py,sha256=E7-OS4uMqvJhGLyxKQNnAgK33YECrSjuCssUT_X0LQA,11728
+wafer_core/lib/trace_compare/fusion_analyzer.py,sha256=ZbFXUuPOt8ezT08WfjlDx7XaUNoUgg9hlFTJb68-eo0,17433
+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=zBHI0r7CX_wJ2mz0_-s0lm9KGSdaVaq7OKyxUL6KIlw,23997
+wafer_core/lib/trace_compare/same_kernel_analyzer.py,sha256=sp81NJGVJeYdAfRQRgMbB5HcGTOneF1Rau3rbLPfpv4,3489
+wafer_core/lib/trace_compare/warnings.py,sha256=B1HxFt-v1mDqLT2aD5bSm1Yn88bfPYnM-wui0WBF3xM,3548
 wafer_core/lib/tracelens/__init__.py,sha256=AkHdmOnKlBO4RpsAqVVGe7MOfv6E6uhEaC_iKrYeMPI,2002
 wafer_core/lib/tracelens/comparator.py,sha256=71YEPfjBi7_24u1oQuPerNtFsN0sDQ5CT_uBi0XLllw,3460
 wafer_core/lib/tracelens/finder.py,sha256=HpbN8TuRNbbBytPYOmkBkfsFVBReQqVgsvFX-mBrln4,2459
@@ -589,9 +597,19 @@ wafer_core/sessions/__init__.py,sha256=Ybps5QclZShAELoW9bva4w6OCNrcBf8vd9nGDjYfQ
 wafer_core/sessions/agent.py,sha256=4-Q-NG_xm07FFq7hB8mjxW38nt2_S0QpwCYkPOoGRxA,5946
 wafer_core/sessions/dtypes.py,sha256=K6nOjvL6sjCGY7GTtdEygf1IZY_18R9YkHGqFyMd8wY,589
 wafer_core/sessions/hooks.py,sha256=A-txm6ufnRGQCdtP3vwh7oEOdlLN9Tv0XsjORMihuAI,4295
-wafer_core/targets/__init__.py,sha256=sHndC7AAOaHXlrmDXFLB53a5Y8DBjuyqS6nwsO2nj-Y,1728
+wafer_core/targets/__init__.py,sha256=N4lTf9MjZ5dzAShObweZzyBfPMSzwjD5qBFWnM5lczM,2800
 wafer_core/targets/digitalocean.py,sha256=cvoYpYjtSyy5t2lQAPi7ERruuuibronah_ivOiduAHQ,16550
+wafer_core/targets/pool.py,sha256=TeNE9rpr67OsGtbxniYpr9Cb3wosnf_e3kTLBbwtDok,5434
+wafer_core/targets/probe.py,sha256=rzF8tiq5GxkMR3jhryTOW0GMcoHtrN67wmHlGJuBTv8,3038
+wafer_core/targets/reconcile.py,sha256=Hftd7LyqkcTOP0Qpa_cdYpxGW2I3bkSlkQrnYjU5lns,3091
 wafer_core/targets/runpod.py,sha256=LrVmNvA6qjzL5nbGSWvtw7CHrK6bDu7_o3vKIek00Tc,20286
+wafer_core/targets/spec_store.py,sha256=uNpMdo7ASeq7_RhgAqj8CFIK39rGEbaYtYtqt--FXO0,6455
+wafer_core/targets/state_cache.py,sha256=oji4APL_tjOty_u0CJzHaP59jJAIJWQTjYvD4pCdQ3g,4479
+wafer_core/targets/types.py,sha256=MQ7ECcBAwSoWsJfGxycJoLBeoTXSYtGeXEg5ZNxfs4c,5217
+wafer_core/targets/providers/__init__.py,sha256=u6OCCgyPRymrnZmIYPLF0hdkr6aTCF301K9gSgcFWvc,1355
+wafer_core/targets/providers/baremetal.py,sha256=L0KAiTkRH_fQvCbtaEa5wlJBqsvNaY56Zq6ovBhk2YY,2452
+wafer_core/targets/providers/digitalocean.py,sha256=_TnGi9Otzsn2T_vSv40T_3HFLT559WS_ljGsrWr7j0s,5281
+wafer_core/targets/providers/runpod.py,sha256=jCA7ENFRwbTKyToGa7fw2VS3coY61ggK1m0F17-rvng,7388
 wafer_core/tools/__init__.py,sha256=wBQD45GdSfkxcT6NHzIv0IMeXCc0enwwkpm3T_9j1X8,3341
 wafer_core/tools/bash_tool.py,sha256=daoKOVGSgL0x9X_3l8Apd6-wFH4VMXMGJwVemw2FIfc,16828
 wafer_core/tools/glob_tool.py,sha256=9X5PdOjQJj7kiVNqqCZC0-1LmnE6wHx3Zc9zfMjtXdc,3533
@@ -671,7 +689,7 @@ wafer_core/utils/kernel_utils/static_checker.py,sha256=XIQkzAOkGH5xtrOuZM4tNUqVJ
 wafer_core/utils/kernel_utils/task.py,sha256=XcmKxKUWh5It6nX3zGqj77tWgA32uPfQMqNOqyD5T48,2682
 wafer_core/utils/kernel_utils/utils.py,sha256=uDZoJDxh07hJeLNlPdKN2vgB15pqIr1LbXf0YIBHU4E,43056
 wafer_core/utils/kernel_utils/targets/__init__.py,sha256=4NwRLsuJ__S4xKAfda4Ag82C5MQ3Qio-4xA5S-mQGlU,2067
-wafer_core/utils/kernel_utils/targets/config.py,sha256=V587DYkisEFoWwkmLQUW6I0mXkMEwA52sM7ZINslkK8,20625
+wafer_core/utils/kernel_utils/targets/config.py,sha256=DJPPyV7yGmyvS7cavdDENC5PQsia1dQeQYlWCTE7iUo,19975
 wafer_core/utils/kernel_utils/targets/execution.py,sha256=bZuNXCo0sIdD6hFhetLPrtDC-zMSiIsAx_aml49VVL0,15033
 wafer_core/utils/kernel_utils/targets/selection.py,sha256=5I_RG_7cfhq7uaeR28meC2EeNNKssFsK-Tc3QFG6Ze0,3590
 wafer_core/utils/modal_execution/__init__.py,sha256=jkVqYOLzCT5K73N9Od0UIUsx-99A0m6bpDrxfyXxQZ8,945
@@ -679,6 +697,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.26.dist-info/METADATA,sha256=xzTIIcsmbJkA06hTdoRb4uXZj2ud1-wnV7EXdLOSOe4,1420
-wafer_core-0.1.26.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-wafer_core-0.1.26.dist-info/RECORD,,
+wafer_core-0.1.28.dist-info/METADATA,sha256=0x6opc3zOlxGhlZNJDVDY2LPnBZHYP5K4U0I6ZDl0Os,1477
+wafer_core-0.1.28.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+wafer_core-0.1.28.dist-info/RECORD,,