netpulse-discovery 0.1.0__tar.gz

netpulse_discovery-0.1.0/.gitignore

@@ -0,0 +1,29 @@
+# Virtual Environments
+.venv/
+venv/
+ENV/
+
+# Python Caches & Bytecode
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Rust / Maturin Build Artifacts
+rust/target/
+*.so
+*.dylib
+*.dll
+*.pyd
+
+# Local Configuration / Environment
+.env
+.env*.local
+
+# Scratch / Temporary Files
+scratch/
+netpulse.db
+.netpulse-ipam.db

netpulse_discovery-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: netpulse-discovery
+Version: 0.1.0
+Summary: High-speed network discovery and drift analysis engine
+Requires-Python: >=3.10
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: netpulse-rust
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Requires-Dist: uvicorn>=0.22.0
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="docs/assets/logo.png" alt="NetPulse Discovery Logo" width="300"/>
+</p>
+
+# NetPulse Discovery
+
+[![Python](https://img.shields.io/badge/Python-3.10%2B-blue?logo=python&logoColor=white)](https://python.org)
+[![Rust](https://img.shields.io/badge/Powered%20by-Rust-orange?logo=rust&logoColor=white)](https://rust-lang.org)
+[![Build Status](https://img.shields.io/badge/Build-Passing-brightgreen?logo=github)](https://github.com/bonheur/netpulse)
+
+**NetPulse Discovery** is a high-performance, asynchronous network mapping and drift-analysis engine. By offloading packet-level networking to a compiled Rust core, it achieves near wire-speed execution while maintaining a flexible, developer-friendly Python API.
+
+## 🚀 Key Features
+
+- **Blazing Fast Scans:** Leverages `libpcap` and raw sockets in Rust to execute ARP and ICMP sweeps orders of magnitude faster than standard Python libraries.
+- **Asynchronous Port Scanning:** Native `asyncio` TCP connect scanner that can check hundreds of ports across multiple devices concurrently.
+- **Drift Detection:** Built-in intelligence to compare historical scans and calculate exact topological drift (e.g., "Host 192.168.1.5 went offline").
+- **MAC Vendor Resolution:** Automatically translates hardware MAC addresses into human-readable manufacturer names.
+- **Standalone API & CLI:** Usable as a Python library, a Typer-powered CLI, or a FastAPI REST microservice.
+
+## 📦 Installation
+
+Since NetPulse Discovery is part of the NetPulse workspace, it relies on `uv` for dependency management and workspace resolution.
+
+```bash
+uv sync
+```
+
+## ⚡ Quickstart
+
+### As a CLI Tool
+
+The standalone CLI returns structured JSON output perfect for piping into `jq` or other tools.
+
+```bash
+# Note: Raw sockets require elevated privileges
+sudo uv run netpulse-discovery scan 192.168.1.0/24 --timeout 500
+```
+
+### As a Python Library
+
+Embed the high-performance engine directly into your own applications:
+
+```python
+import asyncio
+from netpulse.discovery.services.discovery import DiscoveryService
+from netpulse.discovery.models.discovery import DiscoveryMethod
+
+async def main():
+    service = DiscoveryService()
+    # Scans the network using ARP resolution
+    result = await service.discover_network(
+        "10.0.0.0/24", 
+        methods=[DiscoveryMethod.ARP]
+    )
+    
+    for device in result.devices:
+        print(f"[{device.ip}] {device.mac} - {device.vendor}")
+
+asyncio.run(main())
+```
+
+## 📚 Documentation
+
+For more detailed guides, check out the `docs/` folder:
+- [Usage Guide](docs/usage.md)
+- [Architecture Overview](docs/architecture.md)
+- [Contributing Guidelines](docs/contributing.md)

netpulse_discovery-0.1.0/README.md

@@ -0,0 +1,68 @@
+<p align="center">
+  <img src="docs/assets/logo.png" alt="NetPulse Discovery Logo" width="300"/>
+</p>
+
+# NetPulse Discovery
+
+[![Python](https://img.shields.io/badge/Python-3.10%2B-blue?logo=python&logoColor=white)](https://python.org)
+[![Rust](https://img.shields.io/badge/Powered%20by-Rust-orange?logo=rust&logoColor=white)](https://rust-lang.org)
+[![Build Status](https://img.shields.io/badge/Build-Passing-brightgreen?logo=github)](https://github.com/bonheur/netpulse)
+
+**NetPulse Discovery** is a high-performance, asynchronous network mapping and drift-analysis engine. By offloading packet-level networking to a compiled Rust core, it achieves near wire-speed execution while maintaining a flexible, developer-friendly Python API.
+
+## 🚀 Key Features
+
+- **Blazing Fast Scans:** Leverages `libpcap` and raw sockets in Rust to execute ARP and ICMP sweeps orders of magnitude faster than standard Python libraries.
+- **Asynchronous Port Scanning:** Native `asyncio` TCP connect scanner that can check hundreds of ports across multiple devices concurrently.
+- **Drift Detection:** Built-in intelligence to compare historical scans and calculate exact topological drift (e.g., "Host 192.168.1.5 went offline").
+- **MAC Vendor Resolution:** Automatically translates hardware MAC addresses into human-readable manufacturer names.
+- **Standalone API & CLI:** Usable as a Python library, a Typer-powered CLI, or a FastAPI REST microservice.
+
+## 📦 Installation
+
+Since NetPulse Discovery is part of the NetPulse workspace, it relies on `uv` for dependency management and workspace resolution.
+
+```bash
+uv sync
+```
+
+## ⚡ Quickstart
+
+### As a CLI Tool
+
+The standalone CLI returns structured JSON output perfect for piping into `jq` or other tools.
+
+```bash
+# Note: Raw sockets require elevated privileges
+sudo uv run netpulse-discovery scan 192.168.1.0/24 --timeout 500
+```
+
+### As a Python Library
+
+Embed the high-performance engine directly into your own applications:
+
+```python
+import asyncio
+from netpulse.discovery.services.discovery import DiscoveryService
+from netpulse.discovery.models.discovery import DiscoveryMethod
+
+async def main():
+    service = DiscoveryService()
+    # Scans the network using ARP resolution
+    result = await service.discover_network(
+        "10.0.0.0/24", 
+        methods=[DiscoveryMethod.ARP]
+    )
+    
+    for device in result.devices:
+        print(f"[{device.ip}] {device.mac} - {device.vendor}")
+
+asyncio.run(main())
+```
+
+## 📚 Documentation
+
+For more detailed guides, check out the `docs/` folder:
+- [Usage Guide](docs/usage.md)
+- [Architecture Overview](docs/architecture.md)
+- [Contributing Guidelines](docs/contributing.md)

netpulse_discovery-0.1.0/docs/architecture.md

@@ -0,0 +1,21 @@
+# NetPulse Discovery Architecture
+
+The `netpulse-discovery` package employs a hybrid architectural design, leveraging both Python and Rust to achieve high-performance network mapping while maintaining the flexibility of Python APIs.
+
+## Core Components
+
+### 1. `netpulse-rust` Core
+At the lowest level, all blocking, packet-level network I/O is performed by a compiled Rust binary. This bypasses Python's Global Interpreter Lock (GIL) and provides near wire-speed packet generation for ARP and ICMP sweeps.
+- **ARP Sweeps:** Uses `libpcap` to broadcast ARP requests rapidly across the local link.
+- **ICMP Sweeps:** Uses raw sockets to ping targets.
+
+### 2. The Python Engine (`netpulse.discovery.engine`)
+This layer acts as the FFI (Foreign Function Interface) boundary. It imports the compiled Rust extension and exposes it to the higher-level Python services.
+
+### 3. Asynchronous Services (`netpulse.discovery.services`)
+- **DiscoveryService**: The primary orchestrator. It executes the Rust engine via `asyncio.to_thread` to ensure that Python's async event loop is never blocked by raw socket waits. It then enriches the raw results with MAC vendor lookups and port scans.
+- **PortScannerService**: A purely native-Python TCP connect scanner using `asyncio` streams.
+- **DriftService**: Implements state-aware logic to compare current discovery results against historical baselines, allowing for accurate mapping of network topological changes over time.
+
+### 4. Pydantic Domain Models (`netpulse.discovery.models`)
+The data contract layer. Raw byte responses from the network are parsed, validated, and normalized into `DiscoveryResult` and `Device` models before being returned to the user or downstream consumers.

netpulse_discovery-0.1.0/docs/contributing.md

@@ -0,0 +1,31 @@
+# Contributing to NetPulse Discovery
+
+Welcome! We appreciate your interest in contributing to the NetPulse suite. Because `netpulse-discovery` involves low-level network system permissions and bindings to a Rust engine, developing for it requires a specific local environment configuration.
+
+## Environment Setup
+
+1. **Workspace Root:** Ensure you are developing from the root `netpulse` workspace.
+2. **Install Dependencies:**
+   ```bash
+   uv sync
+   ```
+
+## Running Tests
+
+To avoid the need for `sudo` and raw socket capabilities during standard development testing, always use the `NETPULSE_MOCK` environment variable. This instructs the Rust engine and Python services to mock network traffic.
+
+```bash
+# Run unit and integration tests specific to the discovery module
+NETPULSE_MOCK=1 uv run pytest packages/netpulse-discovery/tests/
+```
+
+## Modifying the Rust Engine
+
+If you need to make modifications to the low-level Rust ARP/ICMP packet generation:
+1. Navigate to the `rust/` directory at the workspace root.
+2. Make your modifications to the `.rs` files.
+3. Because `netpulse-discovery` relies on `netpulse-rust` via `uv` workspace resolution, the Rust binary will automatically be recompiled using PyO3 and Maturin the next time you run `uv sync` or invoke the python environment.
+
+## Code Standards
+- All Python code must be typed using standard `typing` modules or Pydantic.
+- Run `uv run ruff check` before submitting a pull request.

netpulse_discovery-0.1.0/docs/usage.md

@@ -0,0 +1,50 @@
+# Usage Guide
+
+`netpulse-discovery` can be used via its standalone CLI, its standalone REST API, or programmatically as a Python library.
+
+> [!WARNING]
+> Because `netpulse-discovery` utilizes raw sockets to generate ICMP and ARP packets, the tool must either be run with elevated privileges (e.g., `sudo`) or run in Mock Mode.
+
+## Mock Mode (Development)
+If you do not have root access or want to test safely, enable mock mode:
+```bash
+export NETPULSE_MOCK=1
+```
+
+## 1. Standalone CLI
+Run a basic network scan directly from the terminal:
+
+```bash
+# Scan a local /24 subnet
+sudo uv run netpulse-discovery scan 192.168.1.0/24 --timeout 500
+```
+This returns a raw, structured JSON output containing the discovered devices, their MAC addresses, vendors, and RTT (Round Trip Time).
+
+## 2. Python Library
+Import the services to embed discovery directly into your application:
+
+```python
+import asyncio
+from netpulse.discovery.services.discovery import DiscoveryService
+from netpulse.discovery.models.discovery import DiscoveryMethod
+
+async def main():
+    service = DiscoveryService()
+    result = await service.discover_network(
+        "10.0.0.0/24", 
+        methods=[DiscoveryMethod.ARP]
+    )
+    
+    for device in result.devices:
+        print(f"Found {device.ip} ({device.mac}) - Vendor: {device.vendor}")
+
+asyncio.run(main())
+```
+
+## 3. Standalone API
+To run the decoupled REST API for microservice integration:
+
+```bash
+# Mount the router to a FastAPI app and run it with uvicorn
+sudo uv run uvicorn netpulse.discovery.api:discovery_router
+```

netpulse_discovery-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "netpulse-discovery"
+version = "0.1.0"
+description = "High-speed network discovery and drift analysis engine"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "typer>=0.9.0",
+    "rich>=13.0.0",
+    "pydantic>=2.0.0",
+    "fastapi>=0.100.0",
+    "uvicorn>=0.22.0",
+    "netpulse-rust"
+]
+
+[project.scripts]
+netpulse-discovery = "netpulse.discovery.cli:app"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/netpulse"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
+
+[tool.uv.sources]
+netpulse-rust = { workspace = true }

netpulse_discovery-0.1.0/src/netpulse/discovery/api.py

@@ -0,0 +1,20 @@
+from typing import List, Optional
+from fastapi import APIRouter, HTTPException, status
+from pydantic import BaseModel
+
+from netpulse.discovery.services.discovery import DiscoveryService
+from netpulse.discovery.models.discovery import DiscoveryResult, DiscoveryMethod
+
+discovery_router = APIRouter(prefix="/discovery", tags=["Discovery"])
+
+class ScanRequest(BaseModel):
+    target: str
+    timeout_ms: int = 1000
+
+@discovery_router.post("/scan", response_model=DiscoveryResult)
+async def scan_network(req: ScanRequest):
+    service = DiscoveryService()
+    try:
+        return await service.discover_network(req.target, [DiscoveryMethod.ARP], req.timeout_ms)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

netpulse_discovery-0.1.0/src/netpulse/discovery/cli.py

@@ -0,0 +1,26 @@
+import asyncio
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+
+from netpulse.discovery.services.discovery import DiscoveryService
+from netpulse.discovery.models.discovery import DiscoveryMethod
+
+app = typer.Typer(name="discovery", help="Standalone network discovery and drift engine.")
+console = Console()
+
+@app.command()
+def scan(
+    target: str = typer.Argument(..., help="Target CIDR network"),
+    timeout: int = typer.Option(1000, "--timeout", "-t"),
+):
+    """Stateless network scan returning raw output."""
+    with console.status(f"Scanning {target}..."):
+        service = DiscoveryService()
+        result = asyncio.run(service.discover_network(target, [DiscoveryMethod.ARP], timeout_ms=timeout))
+    
+    console.print(result.model_dump_json(indent=2))
+
+if __name__ == "__main__":
+    app()

netpulse_discovery-0.1.0/src/netpulse/discovery/engine/__init__.py

@@ -0,0 +1,48 @@
+import logging
+import os
+from typing import List, Dict, Any, Optional
+
+# Support forced mock mode via environment variable
+_force_mock = os.environ.get("NETPULSE_MOCK") == "1"
+
+# This will be imported from the compiled Rust extension
+try:
+    if _force_mock:
+        netpulse_rust = None
+        logging.info("NetPulse engine running in FORCED MOCK mode via environment variable.")
+    else:
+        import netpulse_rust
+except ImportError:
+    # Fallback for development/testing without compiled binary
+    netpulse_rust = None
+    logging.warning("netpulse_rust module not found. Engine is running in mock mode.")
+
+def scan_arp(target: str, timeout_ms: int = 1000, interface: Optional[str] = None) -> List[Dict[str, Any]]:
+    """
+    Exposes the Rust ARP scanning capability to the Core layer.
+    """
+    if netpulse_rust:
+        return netpulse_rust.scan_arp(target, timeout_ms, interface)
+    
+    # Mock fallback for environment without Rust compiled or forced mock mode
+    return [
+        {"ip": "172.19.57.1", "mac": "00:50:56:C0:00:01", "rtt_ms": 0.35, "status": "up"},
+        {"ip": "172.19.57.10", "mac": "00:0C:29:A4:B5:C6", "rtt_ms": 1.24, "status": "up"},
+        {"ip": "172.19.57.119", "mac": "00:0C:29:8F:D2:E4", "rtt_ms": 0.08, "status": "up"},
+        {"ip": "172.19.57.150", "mac": "00:50:56:E8:A1:B2", "rtt_ms": 4.52, "status": "up"},
+    ]
+
+def scan_icmp(target: str, timeout_ms: int = 1000, concurrency: int = 100) -> List[Dict[str, Any]]:
+    """
+    Exposes the Rust ICMP scanning capability to the Core layer.
+    """
+    if netpulse_rust:
+        return netpulse_rust.scan_icmp(target, timeout_ms, concurrency)
+    
+    # Mock fallback for environment without Rust compiled or forced mock mode
+    return [
+        {"ip": "172.19.57.1", "mac": None, "rtt_ms": 0.42, "status": "up"},
+        {"ip": "172.19.57.10", "mac": None, "rtt_ms": 1.58, "status": "up"},
+        {"ip": "172.19.57.119", "mac": None, "rtt_ms": 0.12, "status": "up"},
+        {"ip": "172.19.57.150", "mac": None, "rtt_ms": 5.11, "status": "up"},
+    ]

netpulse_discovery-0.1.0/src/netpulse/discovery/models/device.py

@@ -0,0 +1,88 @@
+import uuid
+from enum import Enum
+from typing import Optional, Dict, Any
+from datetime import datetime, timezone
+from pydantic import BaseModel, Field, IPvAnyAddress, ConfigDict
+
+class DeviceStatus(str, Enum):
+    """Enumeration of possible device reachability states."""
+    UP = "up"
+    DOWN = "down"
+    UNKNOWN = "unknown"
+
+class Device(BaseModel):
+    """
+    The Core data model for a network device in the NetPulse ecosystem.
+    
+    This model is designed to be:
+    1. Strongly typed (via Pydantic V2)
+    2. Extensible (via the metadata dictionary)
+    3. Persistence-ready (with UUID and UTC timestamps)
+    """
+    
+    model_config = ConfigDict(
+        use_enum_values=True,
+        validate_assignment=True,
+        populate_by_name=True,
+        arbitrary_types_allowed=True,
+        json_schema_extra={
+            "example": {
+                "id": "550e8400-e29b-41d4-a716-446655440000",
+                "ip": "192.168.1.1",
+                "mac": "00:11:22:33:44:55",
+                "hostname": "router.local",
+                "status": "up",
+                "rtt_ms": 1.5,
+                "metadata": {"vendor": "Cisco", "os": "IOS"}
+            }
+        }
+    )
+    
+    # Identification Fields
+    id: uuid.UUID = Field(
+        default_factory=uuid.uuid4,
+        description="Unique identifier for the device (UUID v4)."
+    )
+    ip: IPvAnyAddress = Field(
+        ..., 
+        description="The IP address of the device (IPv4 or IPv6)."
+    )
+    mac: Optional[str] = Field(
+        None, 
+        pattern=r"^([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2})$",
+        description="The hardware MAC address of the device."
+    )
+    hostname: Optional[str] = Field(
+        None, 
+        description="The resolved hostname or mDNS name of the device."
+    )
+    vendor: Optional[str] = Field(
+        None, 
+        description="The manufacturer/vendor name derived from the MAC OUI."
+    )
+    
+    # Discovery & State Fields
+    status: DeviceStatus = Field(
+        default=DeviceStatus.UNKNOWN, 
+        description="The current reachability status of the device."
+    )
+    rtt_ms: Optional[float] = Field(
+        None, 
+        description="The round-trip time in milliseconds recorded during discovery."
+    )
+    
+    # Audit & Lifecycle Fields
+    created_at: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc),
+        description="Timestamp when the device record was first created (UTC)."
+    )
+    last_seen: datetime = Field(
+        default_factory=lambda: datetime.now(timezone.utc), 
+        description="Timestamp when the device was last observed (UTC)."
+    )
+    
+    # Extensibility
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict, 
+        description="A dictionary for plugin-specific data (e.g., SNMP, SSH, OS details)."
+    )

netpulse_discovery-0.1.0/src/netpulse/discovery/models/discovery.py

@@ -0,0 +1,87 @@
+import uuid
+from enum import Enum
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+from pydantic import BaseModel, Field, IPvAnyNetwork, ConfigDict
+
+from .device import Device
+
+class DiscoveryMethod(str, Enum):
+    """Protocol methods used for network discovery."""
+    ARP = "arp"
+    ICMP = "icmp"
+    UDP = "udp"
+    TCP = "tcp"
+
+class DiscoveryResult(BaseModel):
+    """
+    Schema representing the complete result of a network discovery operation.
+    
+    Refined based on data consistency and observability requirements.
+    """
+    model_config = ConfigDict(
+        use_enum_values=True,
+        validate_assignment=True,
+        populate_by_name=True,
+        arbitrary_types_allowed=True
+    )
+
+    # Identification & Scope
+    id: uuid.UUID = Field(
+        default_factory=uuid.uuid4,
+        description="Unique identifier for the scan session."
+    )
+    network: IPvAnyNetwork = Field(
+        ...,
+        description="The CIDR network range targeted by the scan."
+    )
+    
+    # Execution Metadata
+    methods: List[DiscoveryMethod] = Field(
+        default_factory=list,
+        description="The discovery protocols used during this session."
+    )
+    status: str = Field(
+        default="completed",
+        description="Execution status of the scan (completed, partial, failed)."
+    )
+    errors: List[str] = Field(
+        default_factory=list,
+        description="List of error messages encountered during scanning."
+    )
+    
+    # Data
+    devices: List[Device] = Field(
+        default_factory=list,
+        description="The list of devices discovered during the scan."
+    )
+    
+    # Timing (UTC)
+    started_at: datetime = Field(
+        ...,
+        description="The timestamp when the scan was initiated."
+    )
+    finished_at: datetime = Field(
+        ...,
+        description="The timestamp when the scan was completed."
+    )
+    
+    # Analytics & Future Extensibility
+    stats: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Aggregated statistics (e.g., hosts scanned, response rate)."
+    )
+    metadata: Dict[str, Any] = Field(
+        default_factory=dict,
+        description="Additional custom data for plugins or monitoring."
+    )
+
+    @property
+    def duration_s(self) -> float:
+        """Calculates scan duration in seconds."""
+        return (self.finished_at - self.started_at).total_seconds()
+
+    @property
+    def total_discovered(self) -> int:
+        """Derived property ensuring data consistency for discovered 'up' devices."""
+        return len([d for d in self.devices if d.status == "up"])

netpulse_discovery-0.1.0/src/netpulse/discovery/models/drift.py

@@ -0,0 +1,34 @@
+import uuid
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+from netpulse.discovery.models.device import Device
+
+
+class DeviceChange(BaseModel):
+    """
+    Detailed shifts for a single host matching across both benchmark and target sweeps.
+    """
+    ip: str = Field(..., description="The IP address of the modified host.")
+    mac_old: Optional[str] = Field(None, description="The old hardware MAC address.")
+    mac_new: Optional[str] = Field(None, description="The new hardware MAC address.")
+    rtt_old: Optional[float] = Field(None, description="The old response time in milliseconds.")
+    rtt_new: Optional[float] = Field(None, description="The new response time in milliseconds.")
+    status_old: str = Field(..., description="The previous reachability status.")
+    status_new: str = Field(..., description="The updated reachability status.")
+
+
+class DriftResult(BaseModel):
+    """
+    Aggregated comparison boundaries across two historical scans.
+    """
+    network: str = Field(..., description="The targeted network CIDR block.")
+    old_scan_id: Optional[uuid.UUID] = Field(None, description="UUID of the old benchmark scan.")
+    new_scan_id: uuid.UUID = Field(..., description="UUID of the new comparison scan.")
+    old_timestamp: Optional[str] = Field(None, description="UTC ISO timestamp of the old scan.")
+    new_timestamp: str = Field(..., description="UTC ISO timestamp of the new scan.")
+    
+    joined: List[Device] = Field(default_factory=list, description="Newly discovered hosts.")
+    left: List[Device] = Field(default_factory=list, description="Hosts that went offline or vanished.")
+    modified: List[DeviceChange] = Field(default_factory=list, description="Hosts with shifts in MAC or RTT parameters.")
+    unchanged: List[Device] = Field(default_factory=list, description="Hosts present in both scans without state updates.")