saterys 0.2.7__tar.gz

saterys-0.2.7/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Your Name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

saterys-0.2.7/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+include LICENSE
+recursive-include saterys/static *
+recursive-include saterys/nodes *.py

saterys-0.2.7/PKG-INFO

@@ -0,0 +1,50 @@
+Metadata-Version: 2.1
+Name: saterys
+Version: 0.2.7
+Summary: Saterys — Scalable Analysis Toolkit for Earth Remote sYStemS
+Author-email: Sebastian Sanchez Bernal <bastian@example.com>
+License: MIT
+Project-URL: Homepage, https://github.com/yourusername/saterys
+Project-URL: Repository, https://github.com/yourusername/saterys
+Project-URL: Issues, https://github.com/yourusername/saterys/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: GIS
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# SATERYS
+
+[![PyPI version](https://img.shields.io/pypi/v/saterys.svg?style=flat-square)](https://pypi.org/project/saterys/)
+[![Python versions](https://img.shields.io/pypi/pyversions/saterys.svg?style=flat-square)](https://pypi.org/project/saterys/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](LICENSE)
+[![Build](https://img.shields.io/github/actions/workflow/status/bastian6666/saterys/ci.yml?style=flat-square&label=build)](https://github.com/bastian6666/saterys/actions)
+
+**SATERYS** is a geospatial pipeline builder combining a **Svelte** frontend with a **FastAPI** backend.  
+It provides an interactive node-based canvas for connecting operations, executing Python plugins, and visualizing raster data directly on a Leaflet map.
+
+---
+
+## ✨ Features
+
+- 🎨 **Interactive Node Editor** using [Svelvet](https://svelvet.io/).
+- ⚡ **FastAPI Backend** for plugin execution and REST endpoints.
+- 🛰 **Geospatial Preview** with Leaflet, serving raster tiles via [rio-tiler](https://github.com/cogeotiff/rio-tiler).
+- 🔌 **Extensible Plugin System**: add your own nodes by dropping Python files into a `nodes/` folder.
+- 🌙 **Dark/Light Theme** toggle.
+- 📦 Fully **pip-installable** with built frontend assets included.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install saterys
+# SATERYS

saterys-0.2.7/README.md

@@ -0,0 +1,28 @@
+# SATERYS
+
+[![PyPI version](https://img.shields.io/pypi/v/saterys.svg?style=flat-square)](https://pypi.org/project/saterys/)
+[![Python versions](https://img.shields.io/pypi/pyversions/saterys.svg?style=flat-square)](https://pypi.org/project/saterys/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat-square)](LICENSE)
+[![Build](https://img.shields.io/github/actions/workflow/status/bastian6666/saterys/ci.yml?style=flat-square&label=build)](https://github.com/bastian6666/saterys/actions)
+
+**SATERYS** is a geospatial pipeline builder combining a **Svelte** frontend with a **FastAPI** backend.  
+It provides an interactive node-based canvas for connecting operations, executing Python plugins, and visualizing raster data directly on a Leaflet map.
+
+---
+
+## ✨ Features
+
+- 🎨 **Interactive Node Editor** using [Svelvet](https://svelvet.io/).
+- ⚡ **FastAPI Backend** for plugin execution and REST endpoints.
+- 🛰 **Geospatial Preview** with Leaflet, serving raster tiles via [rio-tiler](https://github.com/cogeotiff/rio-tiler).
+- 🔌 **Extensible Plugin System**: add your own nodes by dropping Python files into a `nodes/` folder.
+- 🌙 **Dark/Light Theme** toggle.
+- 📦 Fully **pip-installable** with built frontend assets included.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install saterys
+# SATERYS

saterys-0.2.7/pyproject.toml

@@ -0,0 +1,58 @@
+[build-system]
+requires = ["setuptools>=68", "wheel", "build"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "saterys"
+version = "0.2.7"  # bump each release
+description = "Saterys — Scalable Analysis Toolkit for Earth Remote sYStemS"
+readme = "README.md"
+license = { text = "MIT" }
+
+authors = [
+  { name = "Sebastian Sanchez Bernal", email = "bastian@example.com" }
+]
+
+requires-python = ">=3.9"
+
+dependencies = [
+  "fastapi>=0.110",          # modern FastAPI (with Pydantic v2 support)
+  "uvicorn[standard]>=0.23", # ASGI server
+  "pydantic>=2",             # data validation
+  "numpy>=1.26",             # wheels available for Python 3.12
+  "rio-tiler>=6",            # raster tiling & preview
+  "rasterio>=1.3",           # geospatial raster I/O
+]
+
+classifiers = [
+  "Development Status :: 3 - Alpha",
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering :: GIS",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.9",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/saterys"
+Repository = "https://github.com/yourusername/saterys"
+Issues = "https://github.com/yourusername/saterys/issues"
+
+[project.scripts]
+saterys = "saterys.cli:main"
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.packages.find]
+include = ["saterys*"]
+
+[tool.setuptools.package-data]
+saterys = [
+  "nodes/*.py",
+  "static/*",
+  "static/**/*",
+]

saterys-0.2.7/saterys/app.py

@@ -0,0 +1,225 @@
+# saterys/app.py  (Python 3.7 compatible)
+
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import Response, FileResponse
+from fastapi.staticfiles import StaticFiles
+from pydantic import BaseModel
+from typing import Any, Dict  # IMPORTANT: Dict[...] for Py3.7
+import importlib.util
+import os
+import sys
+
+# ------------------------------------------------------------------------------
+# FastAPI app + CORS
+# ------------------------------------------------------------------------------
+app = FastAPI()
+
+app.add_middleware(
+    CORSMiddleware,
+   allow_origins=["*"],            # or list specific origins if you prefer
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ------------------------------------------------------------------------------
+# Plugin discovery — load BOTH package nodes AND ./nodes
+# ------------------------------------------------------------------------------
+PKG_NODE_DIR = os.path.join(os.path.dirname(__file__), "nodes")  # built-ins
+CWD_NODE_DIR = os.path.join(os.getcwd(), "nodes")                # user workspace
+
+PLUGINS: Dict[str, Any] = {}  # name -> module
+
+def _load_dir(d: str):
+    if not os.path.isdir(d):
+        return
+    for fn in os.listdir(d):
+        if not fn.endswith(".py") or fn.startswith("__"):
+            continue
+        path = os.path.join(d, fn)
+        spec = importlib.util.spec_from_file_location(fn[:-3], path)
+        if not spec or not spec.loader:
+            continue
+        mod = importlib.util.module_from_spec(spec)
+        sys.modules[fn[:-3]] = mod
+        spec.loader.exec_module(mod)
+        name = getattr(mod, "NAME", fn[:-3])
+        PLUGINS[name] = mod
+        print(f"Loaded plugin: {name} from {path}")
+
+def discover_plugins():
+    PLUGINS.clear()
+    _load_dir(PKG_NODE_DIR)  # package built-ins
+    _load_dir(CWD_NODE_DIR)  # user ./nodes
+
+discover_plugins()
+
+# ------------------------------------------------------------------------------
+# API models + endpoints
+# ------------------------------------------------------------------------------
+class RunPayload(BaseModel):
+    nodeId: str
+    type: str         # plugin name
+    args: Dict[str, Any] = {}
+    inputs: Dict[str, Any] = {}  # optional upstream data
+
+@app.get("/node_types")
+def node_types():
+    out = []
+    for name, mod in PLUGINS.items():
+        out.append({
+            "name": name,
+            "default_args": getattr(mod, "DEFAULT_ARGS", {}),
+        })
+    return {"types": out}
+
+@app.post("/run_node")
+def run_node(p: RunPayload):
+    mod = PLUGINS.get(p.type)
+    if not mod:
+        return {"ok": False, "error": "unknown node type '%s'" % p.type}
+    try:
+        res = mod.run(p.args or {}, p.inputs or {}, {"nodeId": p.nodeId})
+        return {"ok": True, "output": res}
+    except Exception as e:
+        return {"ok": False, "error": str(e)}
+
+# ------------------------------------------------------------------------------
+# Raster preview endpoints (Leaflet tiles) — Py3.7 compatible
+# Requires: pip install "rio-tiler<6" numpy
+# ------------------------------------------------------------------------------
+from typing import Dict as _Dict  # avoid confusion with above
+import numpy as np
+
+# rio-tiler compatibility: use Reader if available (v6+), else COGReader (v<6)
+try:
+    from rio_tiler.io import Reader as _RTReader   # rio-tiler >= 6 (needs Python >= 3.8)
+except Exception:
+    try:
+        from rio_tiler.io import COGReader as _RTReader  # rio-tiler < 6 (Py3.7 OK)
+    except Exception as _e:
+        raise ImportError(
+            "rio-tiler not available. Install a Py3.7-compatible version:\n"
+            "  pip install 'rio-tiler<6' numpy"
+        ) from _e
+
+# Simple registry: preview id -> absolute path
+PREVIEWS: _Dict[str, str] = {}
+
+@app.post("/preview/register")
+def preview_register(payload: Dict[str, str]):
+    """
+    Body: { "id": "myRaster1", "path": "/abs/path/to/file.tif" }
+    """
+    rid = str(payload.get("id", "")).strip()
+    pth = str(payload.get("path", "")).strip()
+    if not rid or not pth:
+        raise HTTPException(400, "id and path are required")
+    ap = os.path.abspath(pth)
+    if not os.path.exists(ap):
+        raise HTTPException(404, "file not found: %s" % ap)
+    PREVIEWS[rid] = ap
+    return {"ok": True, "id": rid, "path": ap}
+
+@app.get("/preview/bounds/{rid}")
+def preview_bounds(rid: str):
+    path = PREVIEWS.get(rid)
+    if not path:
+        raise HTTPException(404, "unknown preview id")
+    with _RTReader(path) as r:
+        west, south, east, north = r.geographic_bounds  # lon/lat
+    return {"bounds": [west, south, east, north], "crs": "EPSG:4326"}
+
+@app.get("/preview/tile/{rid}/{z}/{x}/{y}.png")
+def preview_tile(rid: str, z: int, x: int, y: int, indexes: str = ""):
+    """
+    Return a PNG tile for the registered raster.
+    - ?indexes=4,3,2 chooses 1-based band indexes. If omitted: RGB if >=3 bands else band 1 grayscale.
+    - Per-tile p2/p98 stretch to 0..255 for a decent look without dataset stats.
+    """
+    path = PREVIEWS.get(rid)
+    if not path:
+        raise HTTPException(404, "unknown preview id")
+
+    # parse ?indexes
+    idx = None
+    if indexes:
+        try:
+            idx = tuple(int(i) for i in indexes.split(",") if i.strip())
+        except Exception:
+            raise HTTPException(400, "bad indexes param; expected comma-separated integers")
+
+    with _RTReader(path) as r:
+        # detect band count (compat across versions)
+        band_count = getattr(getattr(r, "dataset", None), "count", None)
+        if band_count is None:
+            try:
+                info = r.info()
+                band_count = len(info.get("band_metadata", []))
+            except Exception:
+                band_count = 1
+        if idx is None:
+            idx = (1, 2, 3) if (band_count and band_count >= 3) else (1,)
+
+        data, mask = r.tile(x, y, z, indexes=idx)  # data: (bands, H, W), mask: HxW
+
+    # Per-band percentile stretch
+    out_bands = []
+    for b in range(data.shape[0]):
+        arr = data[b].astype("float32")
+        if mask is not None:
+            valid = (mask != 0)  # treat 0 as nodata
+            arr = np.where(valid, arr, np.nan)
+        finite = np.isfinite(arr)
+        if not np.any(finite):
+            scaled = np.zeros_like(arr, dtype="uint8")
+        else:
+            vals = arr[finite]
+            p2, p98 = np.percentile(vals, (2, 98))
+            if not np.isfinite(p2) or not np.isfinite(p98) or (p98 <= p2):
+                scaled = np.zeros_like(arr, dtype="uint8")
+            else:
+                scaledf = (arr - p2) / (p98 - p2) * 255.0
+                scaled = np.clip(scaledf, 0, 255)
+                scaled = np.where(finite, scaled, 0).astype("uint8")
+        out_bands.append(scaled)
+
+    data8 = np.stack(out_bands, axis=0)
+
+    # Compose RGB
+    if data8.shape[0] == 1:
+        rgb = np.vstack([data8, data8, data8])
+    elif data8.shape[0] >= 3:
+        rgb = data8[:3]
+    else:  # 2 bands -> duplicate last
+        rgb = np.vstack([data8, data8[-1:]])
+
+    # Encode PNG
+    from rio_tiler.utils import render
+    img = render(rgb, mask=mask, img_format="PNG")
+    return Response(content=img, media_type="image/png")
+
+# ------------------------------------------------------------------------------
+# Serve built frontend (compiled Svelte) from saterys/static at "/"
+# ------------------------------------------------------------------------------
+
+_here = os.path.dirname(__file__)
+static_dir = os.path.join(_here, "static")
+
+if os.path.isdir(static_dir):
+    app.mount("/static", StaticFiles(directory=static_dir), name="static")
+
+    # 👇 extra mount so /assets/* works when index.html uses absolute /assets URLs
+    assets_dir = os.path.join(static_dir, "assets")
+    if os.path.isdir(assets_dir):
+        app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
+
+@app.get("/")
+def root():
+    index_path = os.path.join(static_dir, "index.html")
+    if not os.path.exists(index_path):
+        raise HTTPException(404, "Frontend not built. Run: (cd saterys/web && npm install && npm run build)")
+    return FileResponse(index_path)
+

saterys-0.2.7/saterys/cli.py

@@ -0,0 +1,26 @@
+import argparse, os, subprocess, sys, time, webbrowser
+from pathlib import Path
+import uvicorn
+
+def main():
+    ap = argparse.ArgumentParser(prog="saterys", description="Saterys runner")
+    ap.add_argument("--host", default=os.environ.get("SATERYS_HOST", "127.0.0.1"))
+    ap.add_argument("--port", type=int, default=int(os.environ.get("SATERYS_PORT", "8000")))
+    ap.add_argument("--dev", action="store_true", help="Run Vite (frontend) + Uvicorn (backend)")
+    args = ap.parse_args()
+
+    if args.dev:
+        # Frontend path is inside package: saterys/web
+        web_dir = Path(__file__).resolve().parent / "web"
+        if (web_dir / "package.json").exists():
+            os.environ.setdefault("SATERYS_DEV_ORIGIN", "http://localhost:5173")
+            print("Starting Vite (frontend) on :5173")
+            vite = subprocess.Popen(["npm", "run", "dev", "--", "--port=5173"], cwd=str(web_dir))
+            time.sleep(1.0)
+            try: webbrowser.open("http://localhost:5173")
+            except Exception: pass
+        else:
+            print("No frontend found at saterys/web. Serving built assets only.")
+
+    print(f"Starting Saterys API → http://{args.host}:{args.port}")
+    uvicorn.run("saterys.app:app", host=args.host, port=args.port, reload=bool(args.dev))

saterys-0.2.7/saterys/nodes/NDVI.py

@@ -0,0 +1,201 @@
+# nodes/ndvi.py
+"""
+NDVI node.
+- If there are TWO upstream raster inputs: uses them as RED and NIR (you can hint which one via args.prefer_upstream_*).
+- If there is ONE upstream raster input: reads specified band indices for red/nir.
+- Saves NDVI as a GeoTIFF and returns a raster payload (path + metadata).
+
+Requirements: rasterio, numpy
+"""
+
+from __future__ import annotations
+import os, hashlib
+from typing import Any, Dict, Tuple
+
+NAME = "raster.ndvi"
+DEFAULT_ARGS = {
+    # When only one upstream raster is connected, read these band indices (1-based!)
+    "red_band": 4,           # e.g. Landsat 8: B4 is red
+    "nir_band": 5,           # Landsat 8: B5 is NIR
+    # When TWO upstream rasters are connected, you can optionally hint which node id is which:
+    "prefer_upstream_red_id": "",
+    "prefer_upstream_nir_id": "",
+    # Output
+    "output_path": "",       # if empty, auto-cache to ./data/cache/ndvi-<hash>.tif
+    "dtype": "float32",
+    "nodata": -9999.0
+}
+
+def _cache_dir() -> str:
+    return os.path.abspath(os.getenv("RASTER_CACHE", "./data/cache"))
+
+def _ensure_dir(p: str):
+    os.makedirs(p, exist_ok=True)
+
+def _auto_name(paths: Tuple[str, ...], bands: Tuple[int, int]) -> str:
+    h = hashlib.sha1(("|".join(paths) + f"|{bands}").encode("utf-8")).hexdigest()[:16]
+    return f"ndvi-{h}.tif"
+
+def _first_two_rasters(inputs: Dict[str, Any]) -> Dict[str, Dict[str, Any]]:
+    """Return a dict of {up_id: raster_payload} for the first two raster inputs found."""
+    out = {}
+    for up_id, v in inputs.items():
+        if isinstance(v, dict) and v.get("type") == "raster" and v.get("path"):
+            out[up_id] = v
+            if len(out) == 2:
+                break
+    return out
+
+def _assert_same_grid(r1, r2):
+    if r1["crs"] != r2["crs"]:
+        raise ValueError(f"NDVI: CRS mismatch: {r1['crs']} vs {r2['crs']}")
+    if r1["transform"] != r2["transform"]:
+        raise ValueError("NDVI: transform (georeferencing) mismatch between inputs")
+    if r1["width"] != r2["width"] or r1["height"] != r2["height"]:
+        raise ValueError("NDVI: raster shapes differ; please resample beforehand")
+
+def run(args: Dict[str, Any], inputs: Dict[str, Any], context: Dict[str, Any]):
+    import numpy as np
+    import rasterio
+    from rasterio.enums import Resampling
+
+    # 1) Gather upstream rasters
+    rasters = _first_two_rasters(inputs)
+
+    # 2) Resolve operating mode
+    prefer_red = (args.get("prefer_upstream_red_id") or "").strip() or None
+    prefer_nir = (args.get("prefer_upstream_nir_id") or "").strip() or None
+
+    red_arr = None
+    nir_arr = None
+    meta_source = None  # template for writing output
+
+    if len(rasters) >= 2:
+        # --- Two-raster mode ---
+        # Determine which is red and which is nir
+        red_payload = None
+        nir_payload = None
+
+        # If preferences provided and present, honor them
+        if prefer_red and prefer_red in rasters:
+            red_payload = rasters[prefer_red]
+        if prefer_nir and prefer_nir in rasters:
+            nir_payload = rasters[prefer_nir]
+
+        # If not both resolved, assign remaining by order
+        remaining = [v for k, v in rasters.items() if v not in (red_payload, nir_payload)]
+        if red_payload is None and remaining:
+            red_payload = remaining.pop(0)
+        if nir_payload is None and remaining:
+            nir_payload = remaining.pop(0)
+
+        if red_payload is None or nir_payload is None:
+            raise ValueError("NDVI: need two upstream rasters or band indices")
+
+        _assert_same_grid(red_payload, nir_payload)
+
+        # Read first band from each file by default
+        with rasterio.open(red_payload["path"]) as ds_red, rasterio.open(nir_payload["path"]) as ds_nir:
+            red = ds_red.read(1, masked=True).astype("float32")
+            nir = ds_nir.read(1, masked=True).astype("float32")
+            meta_source = ds_red  # use RED for profile
+
+            # Prefer nodata masks from both
+            mask = red.mask | nir.mask
+            red_arr = np.ma.array(red, mask=mask)
+            nir_arr = np.ma.array(nir, mask=mask)
+
+        out_name_paths = (red_payload["path"], nir_payload["path"])
+        bands_used = (1, 1)
+
+    else:
+        # --- Single multiband mode ---
+        # Find a single upstream raster
+        raster = next((v for v in inputs.values() if isinstance(v, dict) and v.get("type") == "raster"), None)
+        if raster is None:
+            raise ValueError("NDVI: no upstream raster found")
+
+        red_band = int(args.get("red_band", 4))
+        nir_band = int(args.get("nir_band", 5))
+        if red_band < 1 or nir_band < 1:
+            raise ValueError("NDVI: band indices are 1-based and must be >= 1")
+
+        with rasterio.open(raster["path"]) as ds:
+            if red_band > ds.count or nir_band > ds.count:
+                raise ValueError(f"NDVI: band index out of range (count={ds.count})")
+            red = ds.read(red_band, masked=True).astype("float32")
+            nir = ds.read(nir_band, masked=True).astype("float32")
+            meta_source = ds
+            mask = red.mask | nir.mask
+            red_arr = np.ma.array(red, mask=mask)
+            nir_arr = np.ma.array(nir, mask=mask)
+
+        out_name_paths = (raster["path"],)
+        bands_used = (red_band, nir_band)
+
+    # 3) Compute NDVI = (NIR - RED) / (NIR + RED)
+    #    Handle divide-by-zero and propagate masks.
+    num = (nir_arr - red_arr)
+    den = (nir_arr + red_arr)
+    # Avoid runtime warnings; where den == 0, set masked
+    with np.errstate(divide="ignore", invalid="ignore"):
+        ndvi = np.ma.divide(num, den)
+        ndvi.mask = np.ma.getmaskarray(ndvi) | (den == 0)
+
+    out_dtype = str(args.get("dtype", "float32")).lower()
+    if out_dtype not in ("float32", "float64"):
+        out_dtype = "float32"
+    nodata_val = float(args.get("nodata", -9999.0))
+
+    # 4) Prepare output path
+    out_path = (args.get("output_path") or "").strip()
+    if not out_path:
+        cache_root = _cache_dir()
+        _ensure_dir(cache_root)
+        out_path = os.path.join(cache_root, _auto_name(out_name_paths, bands_used))
+    else:
+        _ensure_dir(os.path.dirname(os.path.abspath(out_path)))
+
+    # 5) Write GeoTIFF
+    with rasterio.open(out_path, "w",
+                       driver="GTiff",
+                       height=ndvi.shape[0],
+                       width=ndvi.shape[1],
+                       count=1,
+                       dtype=out_dtype,
+                       crs=meta_source.crs,
+                       transform=meta_source.transform,
+                       nodata=nodata_val) as dst:
+        # Fill masked pixels with nodata
+        out = ndvi.filled(nodata_val).astype(out_dtype)
+        dst.write(out, 1)
+        # Optional description
+        dst.set_band_description(1, "NDVI")
+
+    # 6) Return a raster payload for downstream nodes
+    from rasterio.coords import BoundingBox
+    with rasterio.open(out_path) as ds:
+        bb = ds.bounds
+        payload = {
+            "type": "raster",
+            "driver": ds.driver,
+            "path": os.path.abspath(out_path),
+            "width": ds.width,
+            "height": ds.height,
+            "count": ds.count,
+            "dtype": ds.dtypes[0],
+            "crs": str(ds.crs) if ds.crs else None,
+            "transform": [ds.transform.a, ds.transform.b, ds.transform.c,
+                          ds.transform.d, ds.transform.e, ds.transform.f],
+            "bounds": [bb.left, bb.bottom, bb.right, bb.top],
+            "nodata": ds.nodata,
+            "band_names": ["NDVI"],
+            "meta": {
+                "source": "ndvi",
+                "mode": "two_rasters" if len(rasters) >= 2 else "multiband",
+                "inputs": list(out_name_paths),
+                "bands_used": {"red": bands_used[0], "nir": bands_used[1]},
+            },
+        }
+
+    return payload