gea-program 0.25.0__tar.gz → 0.27.0__tar.gz

{gea_program-0.25.0/gea_program.egg-info → gea_program-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.25.0
+Version: 0.27.0
 Summary: GEA-Program: downhole gauge monitoring - canonical measurement records, quality rules, drift evaluation with a re-fit change log, well-test validation, alarm management, model cards, store-and-forward, monthly SLA measurement, FAT/SAT protocols and a dashboard, generated from live objects in the client's reporting outline.
 Author: Daniel T. Murphy
 License: MPL-2.0
@@ -125,7 +125,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (362 checks)
+gea accept                     # the product gate (366 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -648,6 +648,31 @@ against it; `gea seedlink --config ... --hello` prints what a server says of
 itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 `rtserve.iris.washington.edu:18000`, network `TX`.
 
+### ComCat
+
+The seismicity response plan reads a TexNet export; it reads the FDSN text
+export of USGS ComCat - or any FDSN event service - the same way, with the
+contributor and magnitude type on every event. `gea comcat --lat --lon
+--radius-km --start --end` prints the query to open; `gea comcat --file`
+reads the answer; `sra-report --catalog` takes it. Proven on two verbatim
+public-domain extracts (the Delaware Basin, September 2026; the 2011
+Youngstown sequence with its M 4.0), kept as fixtures with their provenance.
+
+### Slip tendency on the mapped faults
+
+The stress state the site declares - the three gradients and the ambient
+pore pressure with their source, the SHmax azimuth with its source or from
+the World Stress Map records near the well (`add-stress-map wsm2016.csv`,
+`wsm --lat --lon`) - resolved on every mapped fault trace within the radius
+of a well at the depth of its declared interval: the slip tendency at the
+ambient and the increased pore pressure, the pressure to slip, the margin
+left after the increase, worst and best declared case. The dip comes from
+the layer where it states one (the Hennings 2021 BEG/TexNet layers do, and
+publish their own pressure-to-slip, printed beside this arithmetic); UTM and
+state-plane layers are unprojected from their .prj parameters. `set-stress`,
+`slip --well`, `gea slip`; the SRA packet's section 2e; `gea help slip`. A
+statement on declared inputs, not a probability and not a verdict.
+
 ### The catalogue accounted for
 
 `gea catalog --list` is the register of the 52 shipped public datasets: for

{gea_program-0.25.0 → gea_program-0.27.0}/README.md

@@ -86,7 +86,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (362 checks)
+gea accept                     # the product gate (366 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -609,6 +609,31 @@ against it; `gea seedlink --config ... --hello` prints what a server says of
 itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 `rtserve.iris.washington.edu:18000`, network `TX`.
 
+### ComCat
+
+The seismicity response plan reads a TexNet export; it reads the FDSN text
+export of USGS ComCat - or any FDSN event service - the same way, with the
+contributor and magnitude type on every event. `gea comcat --lat --lon
+--radius-km --start --end` prints the query to open; `gea comcat --file`
+reads the answer; `sra-report --catalog` takes it. Proven on two verbatim
+public-domain extracts (the Delaware Basin, September 2026; the 2011
+Youngstown sequence with its M 4.0), kept as fixtures with their provenance.
+
+### Slip tendency on the mapped faults
+
+The stress state the site declares - the three gradients and the ambient
+pore pressure with their source, the SHmax azimuth with its source or from
+the World Stress Map records near the well (`add-stress-map wsm2016.csv`,
+`wsm --lat --lon`) - resolved on every mapped fault trace within the radius
+of a well at the depth of its declared interval: the slip tendency at the
+ambient and the increased pore pressure, the pressure to slip, the margin
+left after the increase, worst and best declared case. The dip comes from
+the layer where it states one (the Hennings 2021 BEG/TexNet layers do, and
+publish their own pressure-to-slip, printed beside this arithmetic); UTM and
+state-plane layers are unprojected from their .prj parameters. `set-stress`,
+`slip --well`, `gea slip`; the SRA packet's section 2e; `gea help slip`. A
+statement on declared inputs, not a probability and not a verdict.
+
 ### The catalogue accounted for
 
 `gea catalog --list` is the register of the 52 shipped public datasets: for

{gea_program-0.25.0 → gea_program-0.27.0}/gea/__init__.py

@@ -123,7 +123,7 @@ from .profile_catalog import (
     read_pangaea_txt,
 )
 
-__version__ = "0.25.0"
+__version__ = "0.27.0"
 __all__ = [
     "aging_rate", "rate_psi_yr", "accuracy_psi",
     "Sensor", "SimulatorConfig", "DownholeEngine",

{gea_program-0.25.0 → gea_program-0.27.0}/gea/__main__.py

@@ -278,6 +278,19 @@ def main(argv=None) -> int:
         p_lp.add_argument("--stream-csv", type=str, default=None, help="also write a historian-style CSV the other commands ingest")
         p_lp.add_argument("--selftest", action="store_true", help="etp: the codec round-trip and a session against the simulated store on the loopback")
 
+    p_cc = sub.add_parser("comcat", help="USGS ComCat / any FDSN event service: --lat --lon --radius-km --start --end prints the text-format query to open; --file reads the export it returns")
+    p_cc.add_argument("--lat", type=float, default=None); p_cc.add_argument("--lon", type=float, default=None); p_cc.add_argument("--radius-km", type=float, default=25.0)
+    p_cc.add_argument("--start", type=str, default=None); p_cc.add_argument("--end", type=str, default=None); p_cc.add_argument("--min-mag", type=float, default=1.0)
+    p_cc.add_argument("--file", type=str, default=None, help="an FDSN text export to read and summarise")
+    p_cc.add_argument("--json", action="store_true")
+    p_sl = sub.add_parser("slip", help="slip tendency on the mapped faults of a layer at a position, from declared gradients: --layer --lat --lon --depth-ft --sv --shmin --shmax (--shmax-azimuth or --wsm)")
+    p_sl.add_argument("--layer", type=str, required=True); p_sl.add_argument("--member", type=str, default=None); p_sl.add_argument("--feature-kind", type=str, choices=["fault", "fold"], default=None)
+    p_sl.add_argument("--lat", type=float, required=True); p_sl.add_argument("--lon", type=float, required=True); p_sl.add_argument("--radius-km", type=float, default=25.0)
+    p_sl.add_argument("--depth-ft", type=float, required=True)
+    p_sl.add_argument("--sv", type=float, required=True); p_sl.add_argument("--shmin", type=float, required=True); p_sl.add_argument("--shmax", type=float, required=True)
+    p_sl.add_argument("--pp", type=float, default=0.433); p_sl.add_argument("--shmax-azimuth", type=float, default=None); p_sl.add_argument("--wsm", type=str, default=None, help="the WSM database CSV: the azimuth from its records within 100 km")
+    p_sl.add_argument("--dips", type=float, nargs="+", default=[60.0, 75.0, 90.0]); p_sl.add_argument("--mu", type=float, nargs="+", default=[0.6]); p_sl.add_argument("--delta-pp", type=float, default=0.0)
+    p_sl.add_argument("--json", action="store_true")
     p_cat = sub.add_parser("catalog", help="the shipped catalogue: --list every entry with what reads it; --unused the carried ones; --check reads every entry; --friction the measured friction envelope; --core the core check; --entry X --info | --stream-csv")
     p_cat.add_argument("--list", action="store_true"); p_cat.add_argument("--unused", action="store_true"); p_cat.add_argument("--check", action="store_true")
     p_cat.add_argument("--friction", action="store_true"); p_cat.add_argument("--core", action="store_true")
@@ -319,7 +332,8 @@ def main(argv=None) -> int:
                                "add-seismic", "refresh-seismic", "remove-seismic", "sar-film", "refresh-all", "add-track", "refresh-track", "remove-track",
                                "seismic-dataset", "seismic-field", "add-site", "sites", "site-report", "remove-site", "rename",
                                "set-well", "sra-define", "sra-report", "associate", "osdu-export", "quakeml-export", "well-identity", "vibration-report",
-                               "add-live-station", "live-fold", "live-run", "month-end", "add-layer", "layers", "remove-layer", "structure", "interval"])
+                               "add-live-station", "live-fold", "live-run", "month-end", "add-layer", "layers", "remove-layer", "structure", "interval",
+                               "set-stress", "add-stress-map", "wsm", "slip"])
     p_ws.add_argument("--stations", type=str, nargs="+", default=None, help="add-track: two or more array station ids of this workspace")
     p_ws.add_argument("--site", type=str, default=None, help="site-report/remove-site: the site id")
     p_ws.add_argument("--api", type=str, default=None, help="set-well: the API number")
@@ -399,6 +413,18 @@ def main(argv=None) -> int:
     p_ws.add_argument("--formation-name", type=str, default=None, help="add-layer: the formation a contours layer maps (Wolfcamp)")
     p_ws.add_argument("--role", type=str, choices=["top", "isopach", "base"], default=None, help="add-layer: what the contours are of that formation: its top elevation, its thickness, or its base")
     p_ws.add_argument("--base-interval-ft", type=float, default=None, help="set-well: base of the disposal interval, ft")
+    p_ws.add_argument("--feature-kind", type=str, choices=["fault", "fold"], default=None, help="add-layer: what every feature of a structure layer is when its attributes do not say")
+    p_ws.add_argument("--sv", type=float, default=None, help="set-stress: vertical stress gradient, psi/ft")
+    p_ws.add_argument("--shmin", type=float, default=None, help="set-stress: minimum horizontal stress gradient, psi/ft")
+    p_ws.add_argument("--shmax", type=float, default=None, help="set-stress: maximum horizontal stress gradient, psi/ft")
+    p_ws.add_argument("--pp", type=float, default=None, help="set-stress: ambient pore-pressure gradient, psi/ft (hydrostatic 0.433 unless declared)")
+    p_ws.add_argument("--shmax-azimuth", type=float, default=None, help="set-stress: SHmax azimuth, degrees from north (or leave it to the stress map)")
+    p_ws.add_argument("--azimuth-source", type=str, default=None, help="set-stress: where the azimuth came from")
+    p_ws.add_argument("--gradients-source", type=str, default=None, help="set-stress: where the gradients came from")
+    p_ws.add_argument("--dips", type=float, nargs="+", default=None, help="set-stress: the dips to run when the layer states none (default 60 75 90)")
+    p_ws.add_argument("--mu", type=float, nargs="+", default=None, help="set-stress: the friction coefficients to run (default 0.6)")
+    p_ws.add_argument("--delta-pp", type=float, default=None, help="set-stress / slip: the pore-pressure increase to judge at, psi")
+    p_ws.add_argument("--depth-ft", type=float, default=None, help="slip: the depth to judge at (default the midpoint of the declared interval)")
     p_ws.add_argument("--depth-ref", type=str, choices=["TVD", "MD"], default=None, help="set-well: the interval depths are true vertical (TVD) or measured (MD) depth")
     p_ws.add_argument("--ref-elev-ft", type=float, default=None, help="set-well: the reference elevation the depths are measured from, ft above sea level")
     p_ws.add_argument("--ref-elev-datum", type=str, choices=["KB", "GL", "DF"], default=None, help="set-well: what that elevation is: kelly bushing, ground level, derrick floor")
@@ -2095,7 +2121,7 @@ def main(argv=None) -> int:
             elif a.action == "add-layer":
                 if not a.layer or not a.name:
                     raise SystemExit("add-layer needs --name <display> and --layer <shapefile zip | folder | .shp>")
-                L = ws.add_layer(a.layer, a.name, actor=a.actor, citation=a.citation, member=a.member, formation=a.formation_name, role=a.role)
+                L = ws.add_layer(a.layer, a.name, actor=a.actor, citation=a.citation, member=a.member, formation=a.formation_name, role=a.role, feature_kind=a.feature_kind)
                 tc = ", ".join(f"{k} {v}" for k, v in list(L["type_counts"].items())[:6])
                 print(f"layer {L['id']} ({L['kind']}): {L['n_features']} {L['shape_type']} features, {L['crs']['kind']} {L['crs'].get('datum') or ''}, extent lon {L['bbox'][0]:.3f}..{L['bbox'][2]:.3f} lat {L['bbox'][1]:.3f}..{L['bbox'][3]:.3f}"
                       + (f"; contour value {L['value_attr']}" if L.get('value_attr') else ''))
@@ -2124,6 +2150,32 @@ def main(argv=None) -> int:
                     for line in L["lines"]:
                         print("    " + line)
                 return 0 if r["status"] == "OK" else 1
+            elif a.action == "set-stress":
+                st = ws.set_stress({"sv_psi_ft": a.sv, "shmin_psi_ft": a.shmin, "shmax_psi_ft": a.shmax, "pp_psi_ft": a.pp, "shmax_azimuth_deg": a.shmax_azimuth,
+                                    "azimuth_source": a.azimuth_source, "gradients_source": a.gradients_source, "dips_deg": a.dips, "mus": a.mu, "delta_pp_psi": a.delta_pp, "note": a.note or ""}, actor=a.actor)
+                print(f"stress: Sv {st['sv_psi_ft']} Shmin {st['shmin_psi_ft']} SHmax {st['shmax_psi_ft']} Pp {st['pp_psi_ft']} psi/ft ({st['gradients_source']}); "
+                      f"SHmax azimuth {st.get('shmax_azimuth_deg', 'from the stress map')} ({st.get('azimuth_source', '')}); dips {st['dips_deg']}; mu {st['mus']}; delta Pp {st['delta_pp_psi']} psi"); return 0
+            elif a.action == "add-stress-map":
+                if not a.file:
+                    raise SystemExit("add-stress-map needs --file <wsm.csv>")
+                r = ws.add_stress_map(a.file, actor=a.actor, citation=a.citation)
+                print(f"stress map: {r['n_records']} records kept as {r['file']} (sha256 {r['sha256'][:16]})"); return 0
+            elif a.action == "wsm":
+                if a.lat is None or a.lon is None:
+                    raise SystemExit("wsm needs --lat --lon [--radius-km]")
+                r = ws.wsm_at(a.lat, a.lon, a.radius_km if a.radius_km is not None else 100.0)
+                print(r.get("statement") or f"{r['status']}: {r.get('note', '')}")
+                for rec in r.get("records", [])[:10]:
+                    print(f"  {rec['distance_km']:7.1f} km  {rec['azimuth']:5.0f} deg  {rec['quality']}  {rec['regime'] or '?':3s}  {rec['type']:4s}  {rec['locality'][:40]}")
+                return 0 if r.get("n") else 1
+            elif a.action == "slip":
+                if not a.well:
+                    raise SystemExit("slip needs --well <id>")
+                r = ws.well_slip(a.well, a.radius_km if a.radius_km is not None else 25.0, delta_pp_psi=a.delta_pp, depth_ft=a.depth_ft, actor=a.actor)
+                print(f"slip {a.well}: {r['status']}")
+                for line in r["lines"]:
+                    print("  " + line)
+                return 0 if r["status"] == "OK" else 1
             elif a.action == "interval":
                 if not a.well:
                     raise SystemExit("interval needs --well <id>")
@@ -2304,6 +2356,62 @@ def main(argv=None) -> int:
             stop.set()
             print("etp-sim: stopped")
         return 0
+    elif a.cmd == "comcat":
+        import json as _json
+        from . import sra as _SR
+        from . import geodesy as _GD
+        if a.file:
+            c = _SR.read_catalog(a.file)
+            if c.get("format") != "fdsn-text":
+                print(f"comcat: {a.file} is not an FDSN text export (it read as a {c.get('basis', '')[:60]}...)"); return 1
+            ev = c["events"]
+            if a.lat is not None and a.lon is not None:
+                for e in ev:
+                    dm = _GD.geodesic_m(a.lat, a.lon, e["lat"], e["lon"])["distance_m"]
+                    e["distance_km"] = round(dm / 1000.0, 2) if dm is not None else None
+            if a.json:
+                print(_json.dumps(c, indent=1, default=str)); return 0
+            big = max(ev, key=lambda e: e["magnitude"]) if ev else None
+            ts = sorted(e["time"] for e in ev)
+            print(f"comcat: {c['n_events']} event(s) ({c['n_skipped']} skipped) from {ts[0][:10] if ts else '-'} to {ts[-1][:10] if ts else '-'}; "
+                  f"contributors {', '.join(c['contributors'])}; magnitude types {', '.join(c['magnitude_types'])}")
+            if big:
+                print(f"  largest: M {big['magnitude']:.1f} {big['mag_type']} {big['time']} at {big['lat']:.4f}, {big['lon']:.4f}, {big['depth_km']} km - {big['place']} ({big['event_id']})")
+            for e in sorted(ev, key=lambda x: x["time"])[:40]:
+                print(f"  {e['time'][:19]}  M {e['magnitude']:>4.1f} {e['mag_type']:<6s} {e['lat']:9.4f} {e['lon']:10.4f} {str(e['depth_km']):>7s} km " + (f"{e['distance_km']:7.2f} km  " if e.get("distance_km") is not None else "") + f"{e['place']}")
+            return 0
+        if a.lat is None or a.lon is None or not a.start or not a.end:
+            raise SystemExit("comcat needs --lat --lon --start --end (--radius-km, --min-mag), or --file <export>")
+        print(_SR.comcat_url(a.lat, a.lon, a.radius_km, a.start, a.end, a.min_mag))
+        print("  open it in a browser (this machine may not reach the service) and save the text it returns; `gea comcat --file <saved>` reads it, and sra-report --catalog takes it.")
+        return 0
+    elif a.cmd == "slip":
+        import json as _json
+        from . import shapefile as _SF, slip as _SL, friction_priors as _FP
+        try:
+            L = _SF.read(a.layer, member=a.member)
+        except (ValueError, OSError) as e:
+            raise SystemExit(f"slip: {e}")
+        if a.feature_kind:
+            L.declared_kind = a.feature_kind
+        az, az_src = a.shmax_azimuth, "declared"
+        if az is None and a.wsm:
+            nb = _SL.wsm_nearby(_SL.read_wsm(a.wsm), a.lat, a.lon, 100.0)
+            if not nb["n"]:
+                raise SystemExit("slip: no World Stress Map record of quality A/B/C within 100 km; declare --shmax-azimuth with its source")
+            az, az_src = nb["azimuth_mean"], nb["statement"]
+        if az is None:
+            raise SystemExit("slip: give --shmax-azimuth or --wsm <wsm.csv>")
+        faults = _SL.faults_in_radius(L, a.lat, a.lon, a.radius_km)
+        r = _SL.statement(faults, a.depth_ft, {"sv_psi_ft": a.sv, "shmin_psi_ft": a.shmin, "shmax_psi_ft": a.shmax, "pp_psi_ft": a.pp}, az, tuple(a.dips), tuple(a.mu), a.delta_pp,
+                          sources={"shmax_azimuth": az_src, "gradients": "the command line"})
+        r["friction_envelope"] = _FP.envelope()
+        if a.json:
+            print(_json.dumps(r, indent=1, default=str)); return 0
+        for line in r["lines"]:
+            print(line)
+        print(r["friction_envelope"].get("statement", ""))
+        return 0
     elif a.cmd == "catalog":
         import json as _json
         from . import catalog_register as _CR

{gea_program-0.25.0 → gea_program-0.27.0}/gea/acceptance_tests.py

@@ -6179,7 +6179,7 @@ def section_bo_structure(tmp: str) -> None:
         "counts_and_lines": r["counts_within"] == {"fault": 1, "fold": 1, "other": 0} and f"{g_fault:.2f} km" in ST.lines(r)[0] and "N (" in ST.lines(r)[0] and "North Fault" in ST.lines(r)[0],
         "outside_extent": out_ext["status"] == "OUTSIDE LAYER EXTENT" and "extent" in out_ext["note"] and ST.lines(out_ext)[0].startswith("Layer") and "OUTSIDE LAYER EXTENT" in ST.lines(out_ext)[0],
         "projected_unprojected": Lp.crs["kind"] == "projected" and Lp.crs["zone"] == "TX_CENTRAL" and abs(plat - (lat0 + dlat)) < 1e-6 and abs(plon - lon0) < 1e-6,
-        "refused_by_name": utm_err and "UTM" in utm_err and "Texas State Plane" in utm_err and noprj_err and "no .prj" in noprj_err,
+        "refused_by_name": utm_err and "UTM" in utm_err and "from its parameters" in utm_err and noprj_err and "no .prj" in noprj_err,
         "shx_honoured": Lbad.n == 3 and seq_err and "content length" in seq_err,
     }
     failed1 = [k for k, v in c1.items() if not v]
@@ -7072,6 +7072,254 @@ def section_bs_catalog(tmp: str) -> None:
        + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
 
 
+def section_bt_slip(tmp: str) -> None:
+    """Section BT - slip tendency on the mapped faults: the stress resolution against its identities, the regime, Ts and
+    the pressure to slip, the World Stress Map reader and the nearby azimuth; a UTM layer unprojected from its .prj
+    parameters with the fault's own dip and a published pressure-to-slip read beside this arithmetic; the workspace's
+    stress state, stress map and statement through the SRA packet, the API, the page, the CLI; the help."""
+    import http.cookiejar
+    import math as _math
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import zipfile
+    from . import shapefile as SF
+    from . import slip as SL
+    from . import geodesy as GD
+    from . import helplib as H
+    from .telemetry import TelemetryRecorder, TelemetryConfig
+    from .downhole_engine import DownholeEngine, SimulatorConfig
+    from .workspace import Workspace, WorkspaceError
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "bt"); d.mkdir()
+
+    # -- BT1: the arithmetic and the stress map -----------------------------------------------------------------------
+    st = SL.stress_at(8000.0, 1.05, 0.65, 0.95)
+    par = SL.resolve(80.0, 90.0, 80.0, st["Sv"], st["Shmin"], st["SHmax"])          # a vertical plane along SHmax: Shmin, no shear
+    per = SL.resolve(170.0, 90.0, 80.0, st["Sv"], st["Shmin"], st["SHmax"])         # across SHmax: SHmax, no shear
+    d45 = SL.resolve(35.0, 90.0, 80.0, st["Sv"], st["Shmin"], st["SHmax"])          # 45 deg: the mean and the half-difference
+    hor = SL.resolve(0.0, 0.0, 80.0, st["Sv"], st["Shmin"], st["SHmax"])            # a horizontal plane: Sv
+    ts = SL.slip_tendency(35.0, 90.0, st, 80.0, 0.6, 500.0)
+    ts_past = SL.slip_tendency(35.0, 90.0, st, 80.0, 0.6, 2000.0)
+    hdr = "ID,SITE,LAT,LON,AZI,TYPE,DEPTH,QUALITY,REGIME,LOCALITY,COUNTRY\n"
+    rows = "".join(f"w{i},S,{31.3 + 0.05 * i},{-103.6 + 0.04 * i},{(75 + 3 * (i % 5)) % 180},BO,2.5,{'ABC'[i % 3]},{'NF' if i % 2 else 'SS'},Delaware,USA\n" for i in range(12))
+    rows += "far,S,35.0,-100.0,10,FMS,3,A,TF,away,USA\nbad,S,31.4,-103.5,999,BO,2,A,NF,x,USA\nlow,S,31.42,-103.5,120,BO,2,E,NF,x,USA\n"
+    wsm_path = str(d / "wsm_like.csv")
+    Path(wsm_path).write_text(hdr + rows, encoding="utf-8")
+    recs = SL.read_wsm(wsm_path)
+    nb = SL.wsm_nearby(recs, 31.42, -103.50, 100.0)
+    nb_none = SL.wsm_nearby(recs, 45.0, -70.0, 50.0)
+    bad_wsm = None
+    try:
+        SL.read_wsm(io_bytes := b"A,B,C\n1,2,3\n")
+    except ValueError as e:
+        bad_wsm = str(e)
+    c1 = {
+        "identities": abs(par[0] - st["Shmin"]) < 1e-3 and abs(par[1]) < 1e-3 and abs(per[0] - st["SHmax"]) < 1e-3 and abs(per[1]) < 1e-3
+                      and abs(d45[0] - (st["SHmax"] + st["Shmin"]) / 2) < 1e-3 and abs(d45[1] - (st["SHmax"] - st["Shmin"]) / 2) < 1e-3 and abs(hor[0] - st["Sv"]) < 1e-3 and abs(hor[1]) < 1e-3,
+        "regime": SL.regime_of(8400, 5200, 7600) == "normal" and SL.regime_of(8000, 5200, 9000) == "strike-slip" and SL.regime_of(5000, 6000, 9000) == "reverse",
+        "tendency": ts["Ts_ambient"] == round(1200.0 / (6400.0 - 3464.0), 3) and ts["pressure_to_slip_psi"] == round(6400.0 - 3464.0 - 1200.0 / 0.6, 1) and ts["margin_after_injection_psi"] == round(ts["pressure_to_slip_psi"] - 500.0, 1)
+                    and ts["status"] == "BELOW THE FRICTION LINE" and ts_past["status"] == "PAST THE FRICTION LINE" and ts_past["Ts_injection"] > ts["Ts_injection"],
+        "wsm": len(recs) == 14 and nb["n"] == 12 and abs(nb["azimuth_mean"] - 80.25) < 0.5 and nb["by_quality"] == {"A": 4, "B": 4, "C": 4} and nb["by_regime"] == {"NF": 6, "SS": 6}
+               and nb["spread_deg_median"] <= 6 and nb_none["n"] == 0 and bad_wsm and "columns" in bad_wsm,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "BT1 the stress resolution against its identities (a vertical plane along SHmax feels Shmin and no shear, across it SHmax, at 45 degrees the mean and the "
+       "half-difference, a horizontal plane Sv), Anderson's regime from the ordering, the slip tendency and the pressure to slip by the published arithmetic, "
+       "past the friction line when the increase exceeds it; the World Stress Map CSV read by column name (a 999 azimuth and a D/E quality left out), the "
+       "records within the radius with the axial mean azimuth, spread, counts by quality and regime; no records, and a file without the columns, named"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- BT2: a UTM layer from its .prj parameters, with dip and a published pressure to slip -----------------------------
+    lat1, lon1 = 31.42, -103.50
+    utm13 = GD.utm(13, True, "WGS84")
+    wkt = ('PROJCS["WGS_1984_UTM_Zone_13N",GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]],PRIMEM["Greenwich",0.0],'
+           'UNIT["Degree",0.0174532925199433]],PROJECTION["Transverse_Mercator"],PARAMETER["False_Easting",500000.0],PARAMETER["False_Northing",0.0],'
+           'PARAMETER["Central_Meridian",-105.0],PARAMETER["Scale_Factor",0.9996],PARAMETER["Latitude_Of_Origin",0.0],UNIT["Meter",1.0]]')
+
+    def en(lat, lon):
+        p_ = GD.project(lat, lon, utm13)
+        return (p_["easting_m"], p_["northing_m"])
+    kmlat = 1.0 / 111.195
+    kmlon = 1.0 / (111.195 * _math.cos(_math.radians(lat1)))
+    # three faults: one along SHmax (92 deg) 3 km north with dip 62 and a published value; one across it; one 40 km away (outside the radius)
+    feats = [([[en(lat1 + 3 * kmlat, lon1 - 0.05), en(lat1 + 3 * kmlat - 0.1 * kmlat * 0.035 * 0, lon1 + 0.05)]], {"dip": 62.0, "note": "HIGH CONFIDENCE", "Pp2S_MPa": 5.0, "BEARING": 92.0}),
+             ([[en(lat1 - 0.05, lon1 + 6 * kmlon), en(lat1 + 0.05, lon1 + 6 * kmlon)]], {"dip": 85.0, "note": "LOW CONFIDENCE", "Pp2S_MPa": 20.0, "BEARING": 0.0}),
+             ([[en(lat1 + 0.36, lon1 - 0.02), en(lat1 + 0.36, lon1 + 0.02)]], {"dip": 70.0, "note": "FAR", "Pp2S_MPa": 9.0, "BEARING": 90.0})]
+    SF.write(str(d / "utm_faults"), "PolyLine", feats, [("dip", "F", 6, 1), ("note", "C", 20, 0), ("Pp2S_MPa", "F", 10, 4), ("BEARING", "F", 8, 2)], wkt)
+    with zipfile.ZipFile(str(d / "utm_faults.zip"), "w") as z:
+        for ext in (".shp", ".shx", ".dbf", ".prj"):
+            z.write(str(d / ("utm_faults" + ext)), "utm_faults" + ext)
+    L = SF.read(str(d / "utm_faults.zip"))
+    L.declared_kind = "fault"
+    f1 = L.features[0].parts[0][0]
+    faults = SL.faults_in_radius(L, lat1, lon1, 25.0)
+    res = SL.statement(faults, 9000.0, {"sv_psi_ft": 1.05, "shmin_psi_ft": 0.65, "shmax_psi_ft": 0.95, "pp_psi_ft": 0.45}, 92.0, (60.0, 75.0, 90.0), (0.6,), 300.0,
+                       sources={"shmax_azimuth": "the gate", "gradients": "the gate"})
+    along = next(r for r in res["faults"] if r["attrs"].get("note") == "HIGH CONFIDENCE")
+    across = next(r for r in res["faults"] if r["attrs"].get("note") == "LOW CONFIDENCE")
+    lcc_wkt = ('PROJCS["NAD_1983_Texas_Centric_Mapping_System_Lambert",GEOGCS["GCS_North_American_1983",DATUM["D_North_American_1983",SPHEROID["GRS_1980",6378137.0,298.257222101]],'
+               'PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]],PROJECTION["Lambert_Conformal_Conic"],PARAMETER["False_Easting",1500000.0],PARAMETER["False_Northing",5000000.0],'
+               'PARAMETER["Central_Meridian",-100.0],PARAMETER["Standard_Parallel_1",27.5],PARAMETER["Standard_Parallel_2",35.0],PARAMETER["Latitude_Of_Origin",18.0],UNIT["Meter",1.0]]')
+    lcc = SF.parse_prj(lcc_wkt)
+    unknown = SF.parse_prj('PROJCS["X",GEOGCS["G",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]]],PROJECTION["Mercator"],PARAMETER["Central_Meridian",0.0],UNIT["Meter",1.0]]')
+    c2 = {
+        "unprojected": L.crs["kind"] == "projected" and L.crs["usable"] and "Transverse Mercator on WGS84" in L.crs["how"] and abs(f1[1] - (lat1 + 3 * kmlat)) < 2e-6 and abs(f1[0] - (lon1 - 0.05)) < 2e-6
+                       and lcc["usable"] and lcc["zone_def"]["kind"] == "lcc" and lcc["zone_def"]["lat1"] == 27.5 and not unknown["usable"] and "MERCATOR" in unknown["note"],
+        "faults_found": len(faults) == 2 and along["attrs"]["dip_deg"] == 62.0 and along["attrs"]["published_pressure_to_slip_psi"] == round(5.0 * 145.037738, 1)
+                        and abs(along["distance_km"] - 3.0) < 0.05 and abs(along["strike_deg"] - 90.0) < 1.0 and along["dip_source"] == "the layer" and len(along["cases"]) == 1,
+        "statement": along["worst"]["dip_deg"] == 62.0 and across["worst"]["dip_deg"] == 85.0 and along["angle_to_shmax_deg"] <= 3 and across["angle_to_shmax_deg"] > 85
+                     and along["worst"]["Ts_injection"] > across["worst"]["Ts_injection"] and res["regime"] == "normal"
+                     and along["published"]["pressure_to_slip_psi"] == round(5.0 * 145.037738, 1) and along["published"]["difference_psi"] == round(along["cases"][0]["pressure_to_slip_psi"] - along["published"]["pressure_to_slip_psi"], 1)
+                     and any("The layer publishes 725 psi to slip (Pp2S_MPa)" in ln for ln in res["lines"]) and res["faults"][0] is along,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "BT2 a UTM zone 13N layer unprojected from its .prj parameters (Transverse Mercator on WGS84; a Lambert Conformal Conic parsed the same way; a "
+       "Mercator refused by name); the faults within the radius with the layer's own dip and its published pressure-to-slip read as attributes; the trace "
+       "along SHmax ranked first with the higher tendency, its dip from the layer and one case, the published value printed beside this arithmetic with the difference"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- BT3: the workspace, the SRA packet, the API, the page, the CLI, the help -------------------------------------------
+    hist = str(d / "hist.csv")
+    TelemetryRecorder(engine=DownholeEngine(SimulatorConfig()), config=TelemetryConfig(duration_hours=1.0, seed=5)).run().export_csv(hist)
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    w = ws.add_well_file(hist, display="SWD 1", actor="tester")
+    s0 = ws.well_slip(w["id"], actor="tester")
+    ws.set_well(w["id"], surface={"lat": lat1, "lon": lon1, "datum": "NAD83", "elevation": {"ft": 2950.0, "datum": "KB", "source": "completion report"}}, actor="tester")
+    ws.set_well(w["id"], disposal={"top_interval_ft": 8700.0, "base_interval_ft": 9300.0, "depth_reference": "TVD", "depth_tier": "deep", "channel_pressure": "P_surf_psi",
+                                   "channel_rate": "Q_bpm", "rate_unit": "bbl/min", "bhp_method": "probe", "channel_bhp": "P_bh_psi"}, actor="tester")
+    s1 = ws.well_slip(w["id"], actor="tester")
+    no_src = None
+    try:
+        ws.set_stress({"sv_psi_ft": 1.05, "shmin_psi_ft": 0.65, "shmax_psi_ft": 0.95}, actor="tester")
+    except WorkspaceError as e:
+        no_src = str(e)
+    stx = ws.set_stress({"sv_psi_ft": 1.05, "shmin_psi_ft": 0.65, "shmax_psi_ft": 0.95, "pp_psi_ft": 0.45, "gradients_source": "the gate's declaration", "delta_pp_psi": 300.0}, actor="tester")
+    s2 = ws.well_slip(w["id"], actor="tester")
+    lay = ws.add_layer(str(d / "utm_faults.zip"), "Gate UTM faults", actor="tester", feature_kind="fault", citation="the gate's own layer")
+    bad_fk = None
+    try:
+        ws.add_layer(str(d / "utm_faults.zip"), "Again", actor="tester", feature_kind="contour")
+    except WorkspaceError as e:
+        bad_fk = str(e)
+    s3 = ws.well_slip(w["id"], actor="tester")
+    sm = ws.add_stress_map(wsm_path, actor="tester", citation="WSM-shaped, the gate")
+    s4 = ws.well_slip(w["id"], actor="tester")
+    wsm_q = ws.wsm_at(lat1, lon1, 100.0)
+    site = ws.add_site("Pad 3 site", wells=[w["id"]], actor="tester")
+    ws.sra_define(site["id"], actor="tester", name="Pad 3 SRA", lat=lat1, lon=lon1, radius_km=9.08, plan_date="2026-01-15")
+    pk = ws.write_sra_packet(site["id"], actor="tester")
+    sra_md = open(pk["paths"]["markdown"], encoding="utf-8").read()
+    audit = [a["action"] for a in ws.audit_log()]
+    users = Users(str(Path(wsp, "users.json"))); users.add("op", "operator-pass-1", "operator")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+
+    def call(method, path, body=None):
+        req = urllib.request.Request(base_url + path, method=method, data=(json.dumps(body).encode() if body is not None else None))
+        req.add_header("Content-Type", "application/json"); req.add_header("X-GEA-Action", "1")
+        try:
+            with opener.open(req, timeout=120) as rr_:
+                return rr_.status, json.loads(rr_.read())
+        except urllib.error.HTTPError as e:
+            return e.code, json.loads(e.read())
+    try:
+        call("POST", "/api/login", {"name": "op", "password": "operator-pass-1"})
+        st_g, got = call("GET", f"/api/wells/{w['id']}/slip")
+        st_s, stt = call("GET", "/api/stress")
+        st_w, wq = call("GET", f"/api/stress/wsm?lat={lat1}&lon={lon1}")
+        st_d, dec = call("POST", "/api/stress", {"sv_psi_ft": 1.05, "shmin_psi_ft": 0.65, "shmax_psi_ft": 0.95, "gradients_source": "api", "shmax_azimuth_deg": 95.0, "azimuth_source": "api"})
+        st_bad = call("POST", "/api/stress", {"sv_psi_ft": 1.0, "shmin_psi_ft": 0.9, "shmax_psi_ft": 0.5, "gradients_source": "x"})[0]
+        st_p, wrote = call("POST", f"/api/wells/{w['id']}/slip", {"delta_pp_psi": 100.0})
+        import base64 as _b64
+        st_m, mp = call("POST", "/api/stress/map", {"citation": "again", "file": {"filename": "wsm.csv", "content_b64": _b64.b64encode(open(wsm_path, "rb").read()).decode()}})
+    finally:
+        svc.stop()
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    help_md = (pkg / "help" / "slip.md").read_text(encoding="utf-8")
+    r_cli = _sp.run([sys.executable, "-m", "gea", "workspace", "--path", wsp, "--action", "slip", "--well", w["id"], "--delta-pp", "300"], capture_output=True, text=True)
+    r_wsm = _sp.run([sys.executable, "-m", "gea", "workspace", "--path", wsp, "--action", "wsm", "--lat", str(lat1), "--lon", str(lon1)], capture_output=True, text=True)
+    r_set = _sp.run([sys.executable, "-m", "gea", "workspace", "--path", wsp, "--action", "set-stress", "--sv", "1.05", "--shmin", "0.65", "--shmax", "0.95", "--gradients-source", "cli", "--shmax-azimuth", "92", "--azimuth-source", "cli"], capture_output=True, text=True)
+    r_sa = _sp.run([sys.executable, "-m", "gea", "slip", "--layer", str(d / "utm_faults.zip"), "--feature-kind", "fault", "--lat", str(lat1), "--lon", str(lon1), "--depth-ft", "9000", "--sv", "1.05", "--shmin", "0.65", "--shmax", "0.95",
+                    "--wsm", wsm_path, "--delta-pp", "300"], capture_output=True, text=True)
+    sec2e = sra_md.split("Slip tendency on the mapped faults, from the declared stress state")[1].split("## 2d")[0] if "Slip tendency on the mapped faults" in sra_md else ""
+    c3 = {
+        "refusals_in_order": s0["status"] == "NO SURFACE POSITION" and s1["status"] == "NO STRESS STATE" and no_src and "source" in no_src and s2["status"] == "NO FAULT LAYER"
+                             and bad_fk and "'fault' or 'fold'" in bad_fk and s3["status"] == "NO SHMAX AZIMUTH" and "add-stress-map" in s3["note"],
+        "from_the_map": s4["status"] == "OK" and abs(s4["shmax_azimuth_deg"] - 80.25) < 0.5 and "World Stress Map records within 100 km (12" in s4["azimuth_source"] and s4["depth_ft"] == 9000.0
+                        and s4["depth_how"].startswith("the midpoint") and s4["delta_pp_psi"] == 300.0 and len(s4["layers"]) == 1 and len(s4["layers"][0]["faults"]) == 2
+                        and s4["layers"][0]["faults"][0]["attrs"]["note"] == "HIGH CONFIDENCE" and s4["friction_envelope"]["min"] == 0.21 and sm["n_records"] == 14
+                        and wsm_q["n"] == 12 and wsm_q["citation"] == "WSM-shaped, the gate" and os.path.isfile(Path(wsp, "reports", "wells", w["id"], "slip.json")),
+        "sra_section": "## 2e" in sra_md and "| SWD-1 | Gate UTM faults |" in sec2e and "62 (layer)" in sec2e and "published 725 psi (Pp2S_MPa)" in sec2e and "none from the Permian Basin" in sec2e,
+        "audited": "stress.declare" in audit and "stress_map.add" in audit and audit.count("well.slip") >= 4,
+        "api": st_g == 200 and got["status"] == "OK" and st_s == 200 and stt["stress"]["gradients_source"] == "the gate's declaration" and stt["stress_map"]["n_records"] == 14
+               and st_w == 200 and wq["n"] == 12 and st_d == 200 and dec["shmax_azimuth_deg"] == 95.0 and st_bad == 400 and st_p == 200 and wrote["delta_pp_psi"] == 100.0
+               and wrote["shmax_azimuth_deg"] == 95.0 and st_m == 200 and mp["citation"] == "again",
+        "page": "slipCardHtml" in page_src and "stressCardHtml" in page_src and "/api/stress/map" in page_src and "lyFK" in page_src and "'/slip'" in page_src,
+        "cli": r_cli.returncode == 0 and "Slip tendency at 9,000 ft" in r_cli.stdout and "PAST THE FRICTION LINE" in r_cli.stdout or "BELOW THE FRICTION LINE" in r_cli.stdout
+               and r_wsm.returncode == 0 and "12 World Stress Map record(s)" in r_wsm.stdout and r_set.returncode == 0 and "SHmax azimuth 92.0" in r_set.stdout
+               and r_sa.returncode == 0 and "The layer publishes 725 psi to slip" in r_sa.stdout and "run from 0.21 to 0.9" in r_sa.stdout,
+        "help": any(t["topic"] == "slip" for t in H.topics()) and not H.check("slip") and "does not say the fault exists at depth" in help_md.split("will not call a measurement")[1],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "BT3 the workspace: NO SURFACE POSITION, NO STRESS STATE (gradients without a source refused), NO FAULT LAYER (a feature kind that is not fault or fold "
+       "refused), NO SHMAX AZIMUTH naming the stress map, then OK with the azimuth from the map's records near the well and the depth from the declared interval; "
+       "the SRA packet's section 2e with the layer's dip and the published value; audited; the API declares the state, takes the map, answers the records near a "
+       "position and writes the statement; the page cards; `--action slip`, `wsm`, `set-stress` and `gea slip --wsm`; the help"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+
+def section_bu_comcat(tmp: str) -> None:
+    """Section BU - the USGS ComCat / FDSN text export read as a catalogue, proven on two verbatim public-domain
+    extracts kept as fixtures (the Delaware Basin, September 2026; the Youngstown 2011 sequence); the SRA seismicity
+    on the real Youngstown sequence; the query builder; the CLI."""
+    import subprocess as _sp
+    from . import sra as SR
+    from . import geodesy as GD
+    pkg = Path(__file__).parent
+    d = Path(tmp, "bu"); d.mkdir()
+    fx = pkg / "fixtures"
+    de = SR.read_catalog(str(fx / "comcat_delaware_basin_2026-09.txt"))
+    yo = SR.read_catalog(str(fx / "comcat_youngstown_2011-2012.txt"))
+    big = max(yo["events"], key=lambda e: e["magnitude"])
+    url = SR.comcat_url(41.1, -80.68, 25.0, "2011-03-01", "2012-03-01", 1.5)
+    # the Youngstown sequence against an SRA-shaped area around the Northstar 1 site: 10 km, M 2.0 threshold, plan date 2011-12-01
+    sra = SR.define("Youngstown", 41.12, -80.69, 10.0, "2011-12-01", threshold_m=2.0, formation_boundary="base of the Knox")
+    from datetime import datetime as _dt, timezone as _tz
+    se = SR.seismicity(sra, yo, as_of=_dt(2012, 2, 1, tzinfo=_tz.utc))
+    far = next(e for e in yo["events"] if e["event_id"] == "ld60004308")
+    dist_far = GD.geodesic_m(41.12, -80.69, far["lat"], far["lon"])["distance_m"] / 1000.0
+    r_file = _sp.run([sys.executable, "-m", "gea", "comcat", "--file", str(fx / "comcat_youngstown_2011-2012.txt"), "--lat", "41.1", "--lon", "-80.68"], capture_output=True, text=True)
+    r_url = _sp.run([sys.executable, "-m", "gea", "comcat", "--lat", "31.42", "--lon", "-103.5", "--radius-km", "30", "--start", "2026-09-01", "--end", "2026-10-01", "--min-mag", "2.5"], capture_output=True, text=True)
+    r_bad = _sp.run([sys.executable, "-m", "gea", "comcat", "--file", str(pkg / "catalog" / "collingwood_1_28_ks_complete.las")], capture_output=True, text=True)
+    help_md = (pkg / "help" / "sra.md").read_text(encoding="utf-8")
+    c1 = {
+        "delaware": de["format"] == "fdsn-text" and de["n_events"] == 28 and de["n_skipped"] == 0 and de["contributors"] == ["tx", "us"] and de["magnitude_types"] == ["mb_lg", "ml"]
+                    and max(e["magnitude"] for e in de["events"]) == 3.4 and de["events"][0]["event_id"] == "tx2026tgiogl" and de["events"][0]["time"] == "2026-09-30T13:35:58Z"
+                    and de["events"][0]["depth_km"] == 6.2024 and "mixes scales" in de["basis"] and sum(1 for e in de["events"] if e["contributor"] == "us") == 4,
+        "youngstown": yo["n_events"] == 9 and big["event_id"] == "ld60029101" and big["magnitude"] == 4.0 and big["time"] == "2011-12-31T20:05:01Z" and big["lat"] == 41.1215 and big["lon"] == -80.6843333
+                      and big["place"] == "3 km NW of Youngstown, Ohio" and yo["contributors"] == ["ld"],
+        "seismicity": se["n_inside"] == 9 and se["largest"]["event_id"] == "ld60029101" and se["largest"]["magnitude"] == 4.0 and se["n_at_or_above"] == 6 and dist_far < 10.0
+                      and se["trigger"]["status"] == "TRIGGERED" and se["trigger"]["respond_by"] == "2012-01-02T20:05:01Z" and se["goal"]["clock_started"] == "2011-12-31",
+        "url": url == "https://earthquake.usgs.gov/fdsnws/event/1/query?format=text&starttime=2011-03-01&endtime=2012-03-01&latitude=41.1000&longitude=-80.6800&maxradiuskm=25&minmagnitude=1.5&orderby=time-asc",
+        "cli": r_file.returncode == 0 and "largest: M 4.0 ml 2011-12-31T20:05:01Z at 41.1215, -80.6843" in r_file.stdout and "1.68 km" in r_file.stdout
+               and r_url.returncode == 0 and "maxradiuskm=30&minmagnitude=2.5" in r_url.stdout and r_bad.returncode == 1 and "not an FDSN text export" in r_bad.stdout,
+        "help_and_fixtures": "gea comcat" in help_md and (fx / "README.md").read_text(encoding="utf-8").count("earthquake.usgs.gov/fdsnws/event/1/query") == 2,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "BU1 the FDSN text export read as a catalogue with contributors and magnitude types: the Delaware Basin window of September 2026 (28 events, TexNet "
+       "and NEIC, ML and mb_Lg, largest M 3.4) and the Youngstown 2011 sequence (9 events, the M 4.0 of 2011-12-31 3 km NW of Youngstown); the SRA seismicity "
+       "on the real sequence inside a 10 km area (six at or above M 2.0, the M 4.0 TRIGGERED, the goal clock from 2011-12-31); the query builder; `gea comcat --file` with distances and `--lat --lon --start --end` printing the query; "
+       "a LAS refused; the help and the fixtures' provenance"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+
 def main() -> int:
     print("GEA-Program - ACCEPTANCE SUITE (the product gate)")
     # a handle a job subprocess still holds at the end must not turn a finished gate into a traceback on Windows:
@@ -7146,6 +7394,8 @@ def main() -> int:
         section_bq_field_ports(tmp)
         section_br_logs_historian(tmp)
         section_bs_catalog(tmp)
+        section_bt_slip(tmp)
+        section_bu_comcat(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

{gea_program-0.25.0 → gea_program-0.27.0}/gea/client_reports.py

@@ -1680,6 +1680,33 @@ def sra_packet_report(pk: dict, evaluated_at: Optional[datetime] = None, program
                 'arithmetic shown, and the declared depth tier (shallow or deep by the base the plan names) is CONSISTENT with the map, INCONSISTENT, or '
                 'NOT RESOLVED. A contour map is read, not interpolated; the completion report is the record of the interval.'],
                 [Table(['Well', 'Status', 'Declared interval', 'Against the mapped tops', 'Depth tier against the map'], irows, 'Interval against the tops')]))
+        slrows = []
+        sl_paras = []
+        for wid, sl in (pk.get('slip') or {}).items():
+            if sl.get('status') != 'OK':
+                slrows.append([wid, '-', '-', sl.get('status'), '-', '-', '-', (sl.get('note') or '')[:160]])
+                continue
+            if not sl_paras:
+                sl_paras.append(f"Stress state: {sl['lines'][0]}" if sl.get('lines') else '')
+            for lay in sl.get('layers', []):
+                for fr in lay.get('faults', [])[:12]:
+                    w_, b_ = fr['worst'], fr['best']
+                    pub = fr.get('published') or {}
+                    slrows.append([wid, lay.get('layer_display') or lay.get('layer_id'), fr.get('name') or fr.get('type') or f"trace {fr['index']}", f"{fr['distance_km']:.2f} km / strike {fr['strike_deg']:g}",
+                                   f"{w_['dip_deg']:g}" + (' (layer)' if fr.get('dip_source') == 'the layer' else ' (declared)'),
+                                   f"{b_['Ts_injection']:.2f}-{w_['Ts_injection']:.2f}", f"{w_['margin_after_injection_psi']:,.0f} to {b_['margin_after_injection_psi']:,.0f}",
+                                   (w_['status'] + (f"; published {pub['pressure_to_slip_psi']:,.0f} psi ({pub['field']})" if pub else ''))[:160]])
+        if slrows:
+            env = next((sl.get('friction_envelope') for sl in pk['slip'].values() if sl.get('friction_envelope')), None)
+            secs.append(Section('2e', 'Slip tendency on the mapped faults, from the declared stress state', [
+                'For each well inside the area, the mapped fault traces within the radius against the stress state the site declared - the three gradients and the '
+                'ambient pore pressure, the SHmax azimuth from the declaration or from the World Stress Map records near the well - at the depth of the declared '
+                'interval and the pore-pressure increase the plan is judged at: the shear and effective normal stress on each plane, the slip tendency, and the '
+                'pore-pressure increase that would bring the plane to the friction line (negative: past it under these inputs). The strike comes from the map; '
+                'the dip from the layer when it states one, otherwise the declared range; the friction coefficient as declared. Where a layer publishes its own '
+                'pressure-to-slip (BEG/TexNet Hennings et al. 2021), that number is printed beside this arithmetic. A statement on declared inputs, not a probability '
+                'and not a verdict.'] + sl_paras + ([env['statement']] if env else []),
+                [Table(['Well', 'Layer', 'Fault', 'Distance / strike', 'Dip', 'Ts (after)', 'Pressure to slip after (psi)', 'Worst case'], slrows[:120], 'Slip tendency')]))
         ef = pk.get('events_faults') or []
         if ef:
             paras = ['The catalogue events inside the area, each against the mapped fault traces of every structure layer: the nearest trace to the epicentre by '

gea_program-0.27.0/gea/fixtures/README.md

@@ -0,0 +1,10 @@
+# fixtures
+
+Small, verbatim, public-domain extracts kept so the gate can prove a reader on real records without a network.
+
+- `comcat_delaware_basin_2026-09.txt` - USGS ComCat, FDSN event web service text output, fetched 2026-10-12:
+  `https://earthquake.usgs.gov/fdsnws/event/1/query?format=text&starttime=2026-09-01&endtime=2026-10-01&minlatitude=30.5&maxlatitude=32.5&minlongitude=-104.5&maxlongitude=-102.0&minmagnitude=2.5&orderby=time`
+  (28 events M >= 2.5, Delaware and Midland basins; contributors tx = TexNet, us = NEIC). US Government work, public domain.
+- `comcat_youngstown_2011-2012.txt` - the same service, fetched 2026-10-12:
+  `https://earthquake.usgs.gov/fdsnws/event/1/query?format=text&starttime=2011-03-01&endtime=2012-03-01&latitude=41.1&longitude=-80.68&maxradiuskm=25&minmagnitude=1.5&orderby=time-asc`
+  (9 events within 25 km of Youngstown, Ohio: the 2011 sequence that ended with the M 4.0 of 2011-12-31; contributor ld = Lamont-Doherty). Public domain.