processforge 0.3.11__tar.gz → 0.3.12__tar.gz

{processforge-0.3.11/src/processforge.egg-info → processforge-0.3.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: processforge
-Version: 0.3.11
+Version: 0.3.12
 Summary: A Python-based process simulation framework for chemical engineering applications.
 Author-email: Processforge Team <team@processforge.dev>
 License-Expression: BSD-3-Clause
@@ -28,6 +28,7 @@ Requires-Dist: jsonschema>=4.20
 Requires-Dist: graphviz>=0.20
 Requires-Dist: pandas>=2.2
 Requires-Dist: zarr>=3.0
+Requires-Dist: pint<1.0,>=0.24
 Requires-Dist: coolprop>=7.2.0
 Requires-Dist: typer>=0.12
 Provides-Extra: api
@@ -48,8 +49,6 @@ Provides-Extra: cantera
 Requires-Dist: cantera>=3.0; extra == "cantera"
 Provides-Extra: coolprop
 Requires-Dist: coolprop>=6.6; extra == "coolprop"
-Provides-Extra: pcl
-Requires-Dist: pint>=0.24; extra == "pcl"
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: black; extra == "dev"

{processforge-0.3.11 → processforge-0.3.12}/flowsheets/festim/hydrogen_transport_1d.json

@@ -25,31 +25,30 @@
     "festim_solver": {
       "type": "SolverUnit",
       "provider": "festim",
-      "sim_type": "hydrogen_transport",
-      "mesh": {
-        "vertices": [0.0, 0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009, 0.01]
-      },
-      "species": [
-        { "name": "H" }
-      ],
-      "subdomains": {
-        "volume": [
-          { "id": 1, "borders": [0.0, 0.01], "material": "default" }
-        ],
-        "surface": [
-          { "id": 2, "x": 0.0 },
-          { "id": 3, "x": 0.01 }
-        ]
-      },
-      "boundary_conditions": [
-        { "type": "fixed_concentration", "subdomain_id": 2, "species": "H", "value": 1 },
-        { "type": "fixed_concentration", "subdomain_id": 3, "species": "H", "value": 0 }
-      ],
-      "exports": [
-        { "type": "vtx_species", "field": "H", "filename": "hydrogen_concentration.bp", "times": "milestones" },
-        { "type": "profile_1d", "field": "H", "volume_id": 1, "times": "milestones" }
-      ],
+      "sim_type": "hydrogen_transport_tds",
       "solver_config": {
+        "mesh": {
+          "vertices": [0.0, 0.001, 0.002, 0.003, 0.004, 0.005, 0.006, 0.007, 0.008, 0.009, 0.01]
+        },
+        "subdomains": {
+          "volume": [
+            { "id": 1, "borders": [0.0, 0.01], "material": "default" }
+          ],
+          "surface": [
+            { "id": 2, "x": 0.0 },
+            { "id": 3, "x": 0.01 }
+          ]
+        },
+        "species": [
+          { "name": "H", "mobile": true }
+        ],
+        "boundary_conditions": [
+          { "type": "fixed_concentration", "subdomain": 2, "species": "H", "value": 1 },
+          { "type": "fixed_concentration", "subdomain": 3, "species": "H", "value": 0 }
+        ],
+        "exports": [
+          { "type": "profile_1d", "field": "H", "volume": 1, "times": [0.05, 0.1, 0.2, 0.5, 1] }
+        ],
         "atol": 1e-10,
         "rtol": 1e-10,
         "final_time": 2,
@@ -67,4 +66,4 @@
   "simulation": {
     "mode": "steady"
   }
-}
+}

processforge-0.3.12/flowsheets/festim/tds_tungsten.json

@@ -0,0 +1,136 @@
+{
+  "metadata": {
+    "name": "FESTIM TDS — Tungsten Thermal Desorption",
+    "description": "Thermo-desorption spectra (TDS) for a tungsten sample. Gaussian implantation source (400 s), resting phase, then a temperature ramp from 300 K at 8 K/s to desorb trapped hydrogen. Two trapping sites modelled via implicit empty-trap species. Reproduces notebooks_task02.ipynb.py.",
+    "version": "1.0"
+  },
+  "providers": {
+    "festim": {
+      "type": "festim",
+      "url": "http://localhost:9002",
+      "output_dir": "festim"
+    }
+  },
+  "materials": {
+    "tungsten": {
+      "id": 1,
+      "extra": {
+        "D_0": 4.1e-7,
+        "E_D": 0.39
+      }
+    }
+  },
+  "streams": {},
+  "units": {
+    "tds_solver": {
+      "type": "SolverUnit",
+      "provider": "festim",
+      "sim_type": "hydrogen_transport_tds",
+      "solver_config": {
+        "mesh": {
+          "segments": [
+            { "start": 0.0, "stop": 30e-9, "num": 200 },
+            { "start": 30e-9, "stop": 3e-6, "num": 300 },
+            { "start": 3e-6, "stop": 20e-6, "num": 200 }
+          ]
+        },
+        "subdomains": {
+          "volume": [
+            { "id": 1, "borders": [0.0, 20e-6], "material": "tungsten" }
+          ],
+          "surface": [
+            { "id": 1, "x": 0.0 },
+            { "id": 2, "x": 20e-6 }
+          ]
+        },
+        "species": [
+          { "name": "H", "mobile": true },
+          { "name": "trapped_H1", "mobile": false },
+          { "name": "trapped_H2", "mobile": false }
+        ],
+        "implicit_species": [
+          { "name": "empty_trap1", "n": 135.99814960153805, "others": ["trapped_H1"] },
+          { "name": "empty_trap2", "n": 41.84558449278094, "others": ["trapped_H2"] }
+        ],
+        "reactions": [
+          {
+            "type": "arrhenius",
+            "reactant": ["H", "empty_trap1"],
+            "product": ["trapped_H1"],
+            "k_0": 53983071.22305305,
+            "E_k": 0.39,
+            "p_0": 1e13,
+            "E_p": 0.87,
+            "volume": 1
+          },
+          {
+            "type": "arrhenius",
+            "reactant": ["H", "empty_trap2"],
+            "product": ["trapped_H2"],
+            "k_0": 53983071.22305305,
+            "E_k": 0.39,
+            "p_0": 1e13,
+            "E_p": 1.0,
+            "volume": 1
+          }
+        ],
+        "sources": [
+          {
+            "type": "particle",
+            "species": "H",
+            "volume": 1,
+            "value": {
+              "type": "gaussian",
+              "amplitude": 4.151347667934617e-05,
+              "center": 4.5e-9,
+              "width": 2.5e-9,
+              "active_until": 400
+            }
+          }
+        ],
+        "boundary_conditions": [
+          { "type": "fixed_concentration", "subdomain": 1, "species": "H", "value": 0 },
+          { "type": "fixed_concentration", "subdomain": 2, "species": "H", "value": 0 }
+        ],
+        "temperature": {
+          "type": "ramp",
+          "T0": 300,
+          "start_t": 450,
+          "ramp_rate": 8
+        },
+        "exports": [
+          { "type": "surface_flux", "field": "H", "surface": 1, "filename": "flux_left.csv" },
+          { "type": "surface_flux", "field": "H", "surface": 2, "filename": "flux_right.csv" },
+          { "type": "total_volume", "field": "H", "volume": 1, "filename": "total_mobile_H.csv" },
+          { "type": "total_volume", "field": "trapped_H1", "volume": 1, "filename": "total_trapped_H1.csv" },
+          { "type": "total_volume", "field": "trapped_H2", "volume": 1, "filename": "total_trapped_H2.csv" },
+          { "type": "profile_1d", "field": "H", "volume": 1, "times": [400, 450, 500] },
+          { "type": "profile_1d", "field": "trapped_H1", "volume": 1, "times": [400, 450, 500] },
+          { "type": "profile_1d", "field": "trapped_H2", "volume": 1, "times": [400, 450, 500] }
+        ],
+        "atol": 1e-10,
+        "rtol": 1e-10,
+        "max_iterations": 30,
+        "transient": true,
+        "final_time": 500,
+        "element_degree": 1,
+        "stepsize": {
+          "initial_value": 0.5,
+          "growth_factor": 1.1,
+          "cutback_factor": 0.9,
+          "target_nb_iterations": 4,
+          "max_stepsize": {
+            "type": "after_t",
+            "after_t": 450,
+            "value": 0.5
+          },
+          "milestones": [400, 450, 500]
+        },
+        "convergence_criterion": "residual"
+      }
+    }
+  },
+  "simulation": {
+    "mode": "steady"
+  }
+}

{processforge-0.3.11 → processforge-0.3.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "processforge"
-version = "0.3.11"
+version = "0.3.12"
 description = "A Python-based process simulation framework for chemical engineering applications."
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -34,6 +34,7 @@ dependencies = [
     "graphviz>=0.20",
     "pandas>=2.2",
     "zarr>=3.0",
+    "pint>=0.24,<1.0",
     "coolprop>=7.2.0",
     "typer>=0.12",
 ]
@@ -64,9 +65,6 @@ cantera = [
 coolprop = [
     "coolprop>=6.6",
 ]
-pcl = [
-    "pint>=0.24",
-]
 dev = [
     "pytest>=7.0",
     "black",

{processforge-0.3.11 → processforge-0.3.12}/src/processforge/api/serve.py

@@ -74,11 +74,20 @@ def run(body: dict):
     # Build a minimal flowsheet config holding materials.
     flowsheet_config = type("FS", (), {"materials": materials})()
 
+    run_id = body.get("run_id", "")
+    flowsheet_hash = body.get("flowsheet_hash", "")
+
     try:
         provider.initialize(provider_config, flowsheet_config)
         result = provider.run_simulation(unit_cfg, body.get("inlet", {}))
-        _maybe_upload_run_outputs(result)
-        return result.as_dict() | {"metadata": result.metadata}
+        # Upload any declared artifacts to object storage (fills remote_uris).
+        # No-op when S3 is not configured.
+        from processforge.persistence.artifact_store import ArtifactStore
+
+        ArtifactStore().persist_outputs(
+            result, run_id=run_id, flowsheet_hash=flowsheet_hash, unit=getattr(result, "unit", "")
+        )
+        return result.model_dump()
     except HTTPException:
         raise
     except Exception as exc:
@@ -90,26 +99,6 @@ def run(body: dict):
         provider.teardown()
 
 
-def _maybe_upload_run_outputs(result) -> None:
-    """Upload the provider's run_dir to S3 when configured.
-
-    No-op unless ``S3_BUCKET`` is set in the container environment and the
-    provider recorded a ``run_dir`` in its result metadata. Upload failures are
-    logged and never fail the run.
-    """
-    run_dir = result.metadata.get("run_dir")
-    if not run_dir:
-        return
-    try:
-        from processforge.utils.s3_upload import upload_directory_to_s3
-
-        s3_uri = upload_directory_to_s3(run_dir)
-        if s3_uri:
-            result.metadata["s3_uri"] = s3_uri
-    except Exception as exc:  # noqa: BLE001
-        logger.warning(f"S3 upload of {run_dir} failed: {exc}")
-
-
 if __name__ == "__main__":
     import uvicorn
 

{processforge-0.3.11 → processforge-0.3.12}/src/processforge/cli/apply.py

@@ -6,13 +6,32 @@ import os
 import time
 from typing import Literal
 
+import hashlib
+import json
+import os
 import typer
+from datetime import datetime, timezone
 from loguru import logger
 
+
+def _persist_run(archive, fs, results, run_info, config, base_name, snapshot_id):
+    """Build a standardized RunManifest and persist it to the archive."""
+    run_id = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ") + "_" + os.urandom(3).hex()
+    flowsheet_hash = hashlib.sha256(
+        json.dumps(config, sort_keys=True, default=str).encode("utf-8")
+    ).hexdigest()[:16]
+    manifest = fs.collect_outputs(
+        run_id, config.get("simulation", {}).get("mode", "steady"),
+        base_name, provenance=run_info.model_dump(),
+    )
+    manifest.snapshot_id = snapshot_id
+    stream_results = {k: v for k, v in results.items() if not hasattr(v, "fields")}
+    archive.save_run(manifest, stream_results=stream_results)
+    logger.info(f"Run saved    : {run_id}")
+    return run_id
+
 from ..eo import EOFlowsheet
 from ..provenance import build_run_info
-from ..result import save_results_zarr
-from ..state import StateManager
 from .common import (
     build_divergence_report,
     build_run_metadata,
@@ -127,15 +146,14 @@ def apply(
             label="converged state",
         )
         run_info = build_run_info(config, x0=fs.x0, var_names=fs.var_names)
-        zarr_path = os.path.join(outputs_dir, f"{base_name}_results.zarr")
-        save_results_zarr(results, zarr_path, run_info=run_info)
+        saved_run_id = _persist_run(sm, fs, results, run_info, config, base_name, snapshot_id)
         logger.info("=== Apply Summary ===")
         logger.info("  Status       : CONVERGED")
         logger.info(f"  Final ||F||  : {fs.solver_stats.get('final_norm', '?'):.3e}")
         logger.info(f"  Iterations   : {fs.solver_stats.get('iterations', '?')}")
         logger.info(f"  Backend      : {display_backend(config, fs.backend)}")
         logger.info(f"  Snapshot ID  : {snapshot_id}")
-        logger.info(f"  Results zarr : {zarr_path}")
+        logger.info(f"  Run ID       : {saved_run_id}")
         logger.info(f"  Elapsed (s)  : {elapsed:.2f}")
         return
 
@@ -168,11 +186,7 @@ def apply(
                 label="homotopy solution",
             )
             run_info = build_run_info(config, x0=fs.x0, var_names=fs.var_names)
-            save_results_zarr(
-                results,
-                os.path.join(outputs_dir, f"{base_name}_results.zarr"),
-                run_info=run_info,
-            )
+            _persist_run(sm, fs, results, run_info, config, base_name, snapshot_id)
             logger.info("Homotopy apply succeeded. New snapshot saved.")
             return
 

{processforge-0.3.11 → processforge-0.3.12}/src/processforge/cli/common.py

@@ -15,7 +15,7 @@ from loguru import logger
 
 from .. import __version__ as _pf_version
 from ..utils.validate_flowsheet import validate_flowsheet
-from ..state import StateManager
+from ..persistence.archive import ProcessStateArchive
 
 if TYPE_CHECKING:
     from ..state import SnapshotState
@@ -133,12 +133,12 @@ def extract_providers(flowsheet_path: str) -> dict:
 # State management
 # ---------------------------------------------------------------------------
 
-def load_state_manager(outputs_dir: str, base_name: str) -> tuple[StateManager, "SnapshotState | None"]:
-    """Create a StateManager and load the snapshot (if it exists)."""
-    state_path = os.path.join(outputs_dir, f"{base_name}.pfstate")
-    sm = StateManager(state_path)
-    state = sm.load_state()
-    return sm, state
+def load_state_manager(outputs_dir: str, base_name: str) -> tuple[ProcessStateArchive, "SnapshotState | None"]:
+    """Create a ProcessStateArchive and load the snapshot (if it exists)."""
+    archive_path = os.path.join(outputs_dir, f"{base_name}.pfarchive")
+    archive = ProcessStateArchive(archive_path)
+    state = archive.load_snapshot()
+    return archive, state
 
 
 # ---------------------------------------------------------------------------
@@ -307,7 +307,7 @@ def write_divergence_report(outputs_dir: str, base_name: str, divergence: dict)
 # ---------------------------------------------------------------------------
 
 def save_snapshot(
-    sm: StateManager,
+    archive: ProcessStateArchive,
     config: dict,
     x_converged: Any,
     var_names: list[str],
@@ -318,7 +318,7 @@ def save_snapshot(
 ) -> str:
     """Save a state snapshot, logging a clear message on failure."""
     try:
-        return sm.save_state(
+        return archive.save_snapshot(
             config, x_converged, var_names,
             metadata=metadata,
             parent_snapshot_id=parent_snapshot_id,

{processforge-0.3.11 → processforge-0.3.12}/src/processforge/cli/run.py

@@ -1,17 +1,17 @@
 """``pf run`` — run a process simulation from a flowsheet JSON file."""
-
 from __future__ import annotations
 
+import hashlib
 import os
+from datetime import datetime, timezone
 
 import typer
 from loguru import logger
 
-from ..flowsheet import Flowsheet
 from ..eo import EOFlowsheet
+from ..flowsheet import Flowsheet
+from ..persistence.archive import ProcessStateArchive
 from ..provenance import build_dynamic_x0, build_run_info
-from ..result import plot_results, plot_timeseries, save_results_zarr
-from ..state import StateManager
 from .common import (
     check_providers,
     display_backend,
@@ -22,6 +22,22 @@ from .common import (
 )
 
 
+def _flowsheet_hash(config: dict) -> str:
+    return hashlib.sha256(
+        json_dumps(config).encode("utf-8")
+    ).hexdigest()[:16]
+
+
+def json_dumps(obj) -> str:
+    import json
+
+    return json.dumps(obj, sort_keys=True, default=str)
+
+
+def _run_id() -> str:
+    return datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ") + "_" + os.urandom(3).hex()
+
+
 def run(
     flowsheet: str = typer.Argument(help="Path to the flowsheet JSON file"),
     export_images: bool = typer.Option(
@@ -44,13 +60,17 @@ def run(
     mode = sim_cfg.get("mode", "steady")
     is_dynamic = mode == "dynamic"
 
+    # Standardized run id, shared with container-side artifact uploads.
+    run_id = _run_id()
+    flowsheet_hash = _flowsheet_hash(config)
+
     if is_dynamic:
-        # Load .pfstate as t=0 if available
-        state_path = os.path.join(outputs_dir, f"{base_name}.pfstate")
-        sm = StateManager(state_path)
-        state = sm.load_state()
+        # Load .pfarchive snapshot as t=0 if available.
+        archive_path = os.path.join(outputs_dir, f"{base_name}.pfarchive")
+        archive = ProcessStateArchive(archive_path)
+        state = archive.load_snapshot()
         if state is not None:
-            stream_inits = sm.state_to_stream_dicts(state)
+            stream_inits = archive.state_to_stream_dicts(state)
             streams_cfg = config.get("streams", {})
             for s_name, s_vals in stream_inits.items():
                 if s_name in streams_cfg:
@@ -59,9 +79,9 @@ def run(
                     logger.debug(
                         f"Stream '{s_name}' from snapshot not in current flowsheet — skipped."
                     )
-            logger.info("Using .pfstate converged state as dynamic t=0.")
+            logger.info("Using .pfarchive converged state as dynamic t=0.")
         else:
-            logger.debug("No .pfstate found — starting dynamic run from flowsheet defaults.")
+            logger.debug("No .pfarchive found — starting dynamic run from flowsheet defaults.")
 
         fs = Flowsheet(config)
         logger.info("=== Dynamic Results ===")
@@ -94,20 +114,42 @@ def run(
 
         run_info = build_run_info(config, x0=fs.x0, var_names=fs.var_names)
 
-    os.makedirs(outputs_dir, exist_ok=True)
-    zarr_path = os.path.join(outputs_dir, f"{base_name}_results.zarr")
-    save_results_zarr(results, zarr_path, run_info=run_info)
-    logger.info(f"  Backend      : {display_backend(config, getattr(fs, 'backend', 'dynamic'))}")
-    logger.info(f"Results saved to {zarr_path}")
-
-    for name, res in results.items():
-        if isinstance(res, dict) and (s3_uri := res.get("metadata", {}).get("s3_uri")):
-            logger.info(f"  Run outputs (S3): {s3_uri}")
+    # Propagate run context to any containerized providers so their S3 uploads
+    # are keyed by the same run_id/flowsheet_hash as this archive run.
+    for provider in getattr(fs, "_provider_map", {}).values():
+        if hasattr(provider, "set_run_context"):
+            provider.set_run_context(run_id, flowsheet_hash)
+
+    # Build + persist the standardized run manifest.
+    archive_path = os.path.join(outputs_dir, f"{base_name}.pfarchive")
+    archive = ProcessStateArchive(archive_path)
+    manifest = fs.collect_outputs(run_id, mode, base_name, provenance=run_info.model_dump())
+    stream_results = {
+        k: v for k, v in results.items()
+        if not hasattr(v, "fields")  # exclude EngineOutput objects
+    }
+    archive.save_run(manifest, stream_results=stream_results)
+
+    logger.info(f"Backend      : {display_backend(config, getattr(fs, 'backend', 'dynamic'))}")
+    logger.info(f"Run saved    : {os.path.join(archive_path, 'runs', run_id + '.json')}")
+
+    # Summarize standardized outputs.
+    for unit_name, out in manifest.units.items():
+        for f in out.fields:
+            logger.info(f"  [{unit_name}] {f.name} = {f.quantity.value} {f.quantity.unit}")
+        for art in out.artifacts:
+            if art.remote_uris:
+                logger.info(f"  [{unit_name}] artifact {art.name} → {art.remote_uris[0]}")
+    for stream_name, out in manifest.streams.items():
+        for f in out.fields:
+            logger.info(f"  [{stream_name}] {f.name} = {f.quantity.value} {f.quantity.unit}")
 
     if export_images:
         try:
-            plot_results(results, fname=f"{base_name}_results.png")
-            plot_timeseries(results, fname=f"{base_name}_timeseries.png")
+            from ..result import plot_results, plot_timeseries
+
+            plot_results(stream_results, fname=f"{base_name}_results.png")
+            plot_timeseries(stream_results, fname=f"{base_name}_timeseries.png")
             logger.info(f"Plots saved: {base_name}_results.png, {base_name}_timeseries.png")
         except Exception as e:
             logger.warning(f"Failed to generate plots: {type(e).__name__}: {e}")

{processforge-0.3.11 → processforge-0.3.12}/src/processforge/eo/flowsheet.py

@@ -12,7 +12,7 @@ if TYPE_CHECKING:
 
 from .jacobian import GlobalJacobianManager
 from .solver import EOSolver
-from ..types import SnapshotState
+from ..types import EngineOutput, SnapshotState
 from ..utils.topology import get_inlets, get_outlets
 
 
@@ -70,6 +70,7 @@ class EOFlowsheet:
         """
         from processforge.providers.manager import teardown_providers
         manager = self._build()
+        self.engine_outputs: dict = {}
         try:
             x0 = self._warm_start(manager)
             self.x0: "np.ndarray" = x0.copy()
@@ -102,12 +103,46 @@ class EOFlowsheet:
                     logger.info(f"EOFlowsheet: running standalone SolverUnit '{unit_name}'")
                     unit_result = unit._run_impl({})
                     results[unit_name] = unit_result
+                    self.engine_outputs[unit_name] = unit_result
 
             logger.info("EOFlowsheet: simulation complete.")
+            self.results = results
             return results
         finally:
             teardown_providers(self._provider_map)
 
+    # ------------------------------------------------------------------
+    # Standardized output collection
+    # ------------------------------------------------------------------
+    def _thermo_provider(self):
+        """Return the first provider capable of stream thermo properties."""
+        provider_map = getattr(self, "_provider_map", None) or {}
+        for provider in provider_map.values():
+            name = type(provider).__name__
+            if "Container" in name:
+                continue
+            if callable(getattr(provider, "get_thermo_properties", None)):
+                return provider
+        return None
+
+    def collect_outputs(self, run_id: str, mode: str, flowsheet_name: str, provenance: dict | None = None):
+        """Assemble a :class:`RunManifest` from this run's results."""
+        from ..output_collector import build_run_manifest
+
+        stream_results = {
+            k: v for k, v in getattr(self, "results", {}).items()
+            if not isinstance(v, EngineOutput)
+        }
+        return build_run_manifest(
+            run_id=run_id,
+            mode=mode,
+            flowsheet_name=flowsheet_name,
+            provenance=provenance or {},
+            engine_outputs=getattr(self, "engine_outputs", {}),
+            stream_results=stream_results,
+            thermo_provider=self._thermo_provider(),
+        )
+
     # ------------------------------------------------------------------
     # Build phase
     # ------------------------------------------------------------------

{processforge-0.3.11 → processforge-0.3.12}/src/processforge/eo/jacobian.py

@@ -332,12 +332,16 @@ class GlobalJacobianManager:
             return {}
         return self.scalars_from_results(self._results)
 
-    def scalars_from_results(self, results: dict[str, dict]) -> dict[str, dict]:
-        """Extract scalars from unit results dict."""
+    def scalars_from_results(self, results: dict) -> dict:
+        """Extract solver-unit outputs from a results dict.
+
+        Solver-unit results are :class:`~processforge.types.EngineOutput`
+        instances; stream entries are plain dicts and are ignored here.
+        """
+        from processforge.types import EngineOutput
+
         return {
-            k: v
-            for k, v in results.items()
-            if isinstance(v, dict) and "status" in v
+            k: v for k, v in results.items() if isinstance(v, EngineOutput)
         }
 
     # ------------------------------------------------------------------