peteksim 0.1.0__tar.gz

peteksim-0.1.0/.cargo/config.toml

@@ -0,0 +1,9 @@
+# PyO3 builds `srs-py` as a cdylib that resolves CPython symbols at load time.
+# Plain `cargo build`/`cargo test` (no maturin) must tell the macOS linker to
+# defer those symbols, or the link fails with "_Py* not found". Maturin sets
+# this itself; this config makes the bare cargo gate work too.
+[target.x86_64-apple-darwin]
+rustflags = ["-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup"]
+
+[target.aarch64-apple-darwin]
+rustflags = ["-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup"]

peteksim-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,84 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  rust:
+    name: cargo build / clippy / test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy, rustfmt
+      - uses: Swatinem/rust-cache@v2
+      - name: fmt
+        run: cargo fmt --all --check
+      - name: clippy (warnings = errors)
+        run: cargo clippy --workspace --all-targets -- -D warnings
+      - name: build
+        run: cargo build --workspace
+      - name: test
+        run: cargo test --workspace
+
+  python:
+    name: maturin develop + import
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: install maturin
+        run: pip install maturin
+      - name: build + import smoke test
+        run: |
+          maturin develop -m crates/srs-py/Cargo.toml
+          python -c "import peteksim; print(peteksim.version())"
+
+  wheels:
+    # Build the abi3 wheel and import + run it across a Python matrix so a
+    # toolchain regression (e.g. a pyo3 that can't link a new CPython — the
+    # 0.24-vs-3.14 blocker) is caught here, not by users. abi3-py39 means one
+    # wheel spans 3.9+, but we still build AND import on each interpreter so a
+    # per-version link/ABI break surfaces.
+    name: wheel build + run (py ${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        # 3.9 = oldest abi3 floor; through the latest stable CPython.
+        python-version: ["3.9", "3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
+      - name: install maturin
+        run: pip install maturin
+      - name: build release wheel
+        run: maturin build --release -m crates/srs-py/Cargo.toml --out dist
+      - name: install wheel + run run_box_model
+        run: |
+          pip install --find-links dist --no-index peteksim
+          python - <<'PY'
+          import peteksim
+          r = peteksim.run_box_model(
+              area_acres=(80, 100, 130), gross_height_ft=(40, 50, 65),
+              porosity=0.25, net_to_gross=0.8, water_saturation=0.3, fvf=1.25,
+              fluid="oil", contact_depth_ft=9000, realizations=2000, seed=1,
+          )
+          assert r.p90 < r.p50 < r.p10, (r.p90, r.p50, r.p10)
+          assert len(r.samples) == r.realizations == 2000
+          print("peteksim", peteksim.version(), "ok:", r)
+          PY

peteksim-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,77 @@
+name: Release
+
+# Tag-triggered PyPI publish (v* tags) via OIDC trusted publishing — no secret.
+# The `peteksim` wheel is built from crates/srs-py (its pyproject.toml). The
+# crates.io publish of the consolidated `peteksim` library crate is done from the
+# local runbook (ordered, cross-repo deps), not here.
+#
+# Configure a pending publisher on PyPI: project `peteksim`, owner kkollsga, repo
+# peteksim, workflow release.yml, environment pypi.
+#
+# NOTE: before pushing a v* tag, the sibling path dep on `petekstatic`
+# (`../petekStatic` in the root Cargo.toml [workspace.dependencies]) must resolve
+# from crates.io — its version pin (0.1.0) does; by release time the upstream
+# family crates are all published so the registry pins resolve on the CI runner.
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  sdist:
+    name: build sdist
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: PyO3/maturin-action@v1
+        with:
+          command: sdist
+          args: --out dist
+          working-directory: crates/srs-py
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-sdist
+          path: crates/srs-py/dist
+
+  wheels:
+    name: build wheels ${{ matrix.runner }} ${{ matrix.target }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { runner: ubuntu-latest, target: x86_64 }
+          - { runner: ubuntu-latest, target: aarch64 }
+          - { runner: macos-14, target: universal2-apple-darwin }
+          - { runner: windows-latest, target: x64 }
+    steps:
+      - uses: actions/checkout@v4
+      - uses: PyO3/maturin-action@v1
+        with:
+          target: ${{ matrix.target }}
+          args: --release --out dist
+          sccache: "true"
+          manylinux: auto
+          working-directory: crates/srs-py
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.runner }}-${{ matrix.target }}
+          path: crates/srs-py/dist
+
+  publish-pypi:
+    name: PyPI (trusted publishing)
+    needs: [sdist, wheels]
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: wheels-*
+          path: dist
+          merge-multiple: true
+      - uses: pypa/gh-action-pypi-publish@release/v1

peteksim-0.1.0/.gitignore

@@ -0,0 +1,29 @@
+# Local working folders + internal tooling (not part of the published library)
+/dev-docs/
+/inbox/
+/research/
+/tools/
+/notes/
+/.claude/
+/.mcp.json
+/CLAUDE.local.md
+/Makefile.local
+
+# Python env / caches
+/.venv-srs/
+**/__pycache__/
+*.pyc
+
+# Build artifacts
+/target/
+**/*.rs.bk
+*.tmp
+
+# maturin editable-install artifact (built extension placed in the source pkg)
+crates/srs-py/python/peteksim/_core*.so
+
+# macOS
+.DS_Store
+**/.DS_Store
+dist/
+dist-launch/

peteksim-0.1.0/API.md

@@ -0,0 +1,311 @@
+# petekSim — locked public API (`peteksim`)
+
+> **This file is the contract.** The `peteksim` wheel must expose exactly these
+> names and signatures (arguments, defaults, return shapes). Bodies are the
+> implementer's; the *surface* is fixed. Changing a signature here requires
+> sign-off (coordinator + any downstream consumer for a cross-library seam) and an
+> edit to this file — the code must never silently drift from it. See
+> [SPEC.md](SPEC.md) for the design constitution.
+
+**Rust is canonical; the Python surface mirrors it.** The compute lives in the Rust
+core (`peteksim._core`, over the petekStatic/petekIO/petekTools crates); this
+document specifies the **Python facade** — the product surface. The v2 spec layer is
+a thin Python facade over `_core`; a handful of names (`Project`, `collocated`)
+override the raw `_core` binding with a v2 wrapper.
+
+**Conventions:**
+- **SI / metric everywhere** (`decision_si_units_standard`): areas km², lengths /
+  depths **metres, positive-down**, volumes Sm³ (reported MSm³ oil / bcm gas), GRV
+  mcm (10⁶ m³), FVF dimensionless Rm³/Sm³. Imperial is caller-side, never a default.
+- **A spec holds NAMES, resolved at apply.** A spec value is declarative and
+  project-independent: it references horizons / surfaces / picks / properties by
+  name, and those names are resolved against a loaded project only at the apply
+  moment (`geom.build`, `grid.model`, `model.zoned_uncertainty`). Resolution errors
+  are loud and name **both** the missing project object and the spec entry.
+- **Value semantics.** Every spec supports `to_dict()` / `from_dict()` /
+  `ps.spec_from_dict()`, value `==` + `hash`, `.replace(...)` derivation, and a
+  domain-table `repr`. A scenario is a savable, diffable file.
+- **`import peteksim as ps`** throughout.
+
+---
+
+## Module
+
+```python
+ps.version() -> str                 # the peteksim/crate version string
+```
+
+**Exceptions** (both `from peteksim import ...`):
+
+```python
+ps.NotYetSupported(NotImplementedError)   # a spec field serializes but the engine
+                                          # capability has not landed — raised loudly
+                                          # at apply, naming the carrying task
+ps.ApplyError(ValueError)                 # a spec could not resolve against the
+                                          # project (missing name / illegal combo);
+                                          # the message names object AND spec entry
+```
+
+## Project & geometry
+
+```python
+ps.Project.load(path: str, crs: str | None = None,
+                aliases: dict[str, str] | None = None,
+                settings: ps.LoadSettings | None = None) -> Project
+    # Load a project tree. Pass settings=ps.LoadSettings(...) (v2) OR the legacy
+    # crs=/aliases= kwargs — not both (ApplyError on both).
+
+proj.grid_geometry(cell, extent=None, orient: float = 0.0) -> GridGeometry
+    # Open the v2 build. `cell` is the output cell size (scalar or (dx, dy);
+    # anisotropic dx != dy -> NotYetSupported). `orient` must be 0 (rotation is
+    # NotYetSupported). `extent` is advisory.
+
+# v1 / shared project accessors (forwarded unchanged):
+proj.inventory() -> Inventory           # what loaded + what was skipped-with-reason
+proj.wells() -> Wells                    # .ids(), .heads() -> [(id, x, y)]
+proj.surface(name: str) -> Surface       # .value_at(x, y), .values_at(points)
+proj.tops -> Tops                        # .pick(name, wells=None) -> TopsPick
+proj.crossplot_bundle(x, y, wells=None, color_by="well",
+                      x_log=False, y_log=False, regression=False)
+proj.framework(...) -> Framework         # DEPRECATED (v1 chain); see "v1" below
+
+geom.build(horizons: Horizons, subzones: Subzones | None = None,
+           layering: Layering | None = None, collapse_negative: bool = True,
+           outline: str = "ModelEdge", min_thickness_m: float = 0.0,
+           ties: TieSettings | None = None,
+           gridding: Gridding | None = None) -> Grid
+    # Freeze geometry + structure specs. Resolves horizon names early (loud on a
+    # miss); the engine build is deferred to grid.model so contacts + props land
+    # in one construction. `ties`/`gridding` default to the ones on `horizons`.
+```
+
+## Structure specs
+
+```python
+ps.Horizons(*rows: HorizonRow, zones=None, ties=None, gridding=None) -> Horizons
+    # The ordered stratigraphic column (top->down) + the zones between horizons;
+    # zone i sits between rows[i] and rows[i+1]. .replace("H1"|glob, surface=...)
+    # derives a changed column.
+ps.hz(name: str, surface: str | None = None, tie: str | None = None,
+      sd: float = 0.0, vgm: tuple[str, float] | None = None) -> HorizonRow
+    # One horizon. `surface` defaults to `name` (a loaded point-set -> Scatter, a
+    # loaded grid -> Mapped). `tie` names the pick set (defaults to `name`).
+    # `sd`(m) + `vgm`=(model, range) declare the structural-uncertainty field
+    # (applied through the zoned MC path).
+
+ps.Subzones(mapping: dict[str, Split] | None = None) -> Subzones   # per-zone splits
+ps.splits(*entries, conformity: str = "proportional") -> Split
+    # each entry: a name, or (name, dict(surface=, tie=)).
+    # conformity: "proportional" | "follow_top" | "follow_base".
+ps.zone(name: str, color: str | None = None) -> ZoneColor          # a zone's colour
+
+ps.Layering(dz: float | None = None, nk: int | None = None,
+            min_cell: float | None = None) -> Layering
+    # Layer allocation; dz XOR nk set the default. .replace("Z*", dz=0.5) adds a
+    # per-glob override. min_cell(m) = sub-threshold cell-collapse floor.
+
+ps.Contacts(mapping: dict[str, dict[str, float]] | None = None) -> Contacts
+    # Per-zone fluid contacts by glob: {"Z4": dict(goc=.., fwl=..), "Z2": dict(owc=..)}.
+    # A zone with no matching entry is contactless. .replace("Z4", fwl=...) derives.
+```
+
+## Settings specs (the HOW objects)
+
+```python
+ps.TieSettings(method: str = "convergent", radius_m: float | None = None) -> TieSettings
+    # method: "convergent" (control-replacement) | "radius" (tie-locality; radius_m).
+
+ps.Gridding(fidelity_m=None, extrapolation: Extrapolation | None = None,
+            collapse: bool = True, min_cell: float | None = None) -> Gridding
+ps.decay_to_flat(range_m: float) -> Extrapolation
+ps.flat() -> Extrapolation
+ps.nearest() -> Extrapolation
+
+ps.Run(memory_budget: int | None = None, workers: int = 0) -> Run
+    # Run resources. memory_budget (BYTES) forwards to the engine out-of-core
+    # switch (loud spill, never an OOM kill); workers shards the MC realize loop.
+
+ps.LoadSettings(crs: str | None = None,
+                aliases: dict[str, str] | None = None) -> LoadSettings
+ps.ViewSettings(property=None, open_browser: bool = True,
+                port: int = 0, block: bool = False) -> ViewSettings
+```
+
+## Property specs
+
+```python
+ps.Props(*items: Prop) -> Props                         # the set applied at grid.model(props=)
+ps.Prop(name: str, zone: str | None = None, upscale_method: str = "arithmetic",
+        net_only: bool = False, net_cutoff: float = 0.5,
+        propagate: Propagate | None = None) -> Prop
+    # One cube's population: upscale (from wells) then propagate (SGS). `zone`
+    # scopes the pipe to one zone of a stack.
+ps.Propagate(variogram: Variogram = Variogram(), seed: int = 1,
+             max_neighbours: int | None = None, radius_m: float | None = None,
+             trend: CollocatedTrend | None = None, mode: str = "level_shift",
+             allow_mean_fill: bool = False) -> Propagate
+    # mode: "level_shift" | "resimulate".
+ps.variogram(model: str, range_m: float, sill: float = 1.0,
+             nugget: float = 0.0) -> Variogram
+    # model: "spherical" | "exponential" | "gaussian".
+ps.collocated(surface, corr: float, as_depth: bool = False)
+    # surface a NAME (str) -> a CollocatedTrend spec resolved at apply (the v2 form).
+    # surface a _core.Surface -> the v1 eager trend (DEPRECATED — bind by name).
+```
+
+## Monte-Carlo specs
+
+```python
+ps.Mc(porosity=None, net_to_gross=None, water_saturation=None,
+      fvf=None, gas_fvf=None, contacts=None, goc=None,
+      per_zone: dict[str, Mc] | None = None,
+      settings: McSettings | None = None, n: int = 10_000, seed: int = 42) -> Mc
+    # Property fields take a scalar sd / ps.shift(...) / ps.dist(...); contact
+    # fields (contacts = lower FWL/OWC, goc) take a scalar sd_m / ps.pick_spread(...).
+    # per_zone overrides by zone. Auto-routes to zoned_uncertainty on a zoned model,
+    # else uncertainty.
+ps.McSettings(lo_pct: float = 10.0, hi_pct: float = 90.0, workers: int = 0) -> McSettings
+ps.shift(sd: float) -> Uncertain                        # a zero-mean level shift
+ps.dist(kind: str, *params: float) -> Uncertain
+    # kind: "level_shift"(sd) | "normal"(mean,sd) | "lognormal"(mean,sd) |
+    #       "uniform"(lo,hi) | "triangular"(lo,mode,hi) |
+    #       "truncated_normal"(mean,sd,lo,hi).
+
+# Distribution builders (the _core samplers, for the v1 kwargs and Uncertain.resolve):
+ps.normal(mean, sd);  ps.lognormal(mean, sd);  ps.uniform(lo, hi)
+ps.triangular(lo, mode, hi);  ps.truncated_normal(mean, sd, lo, hi)
+ps.level_shift(sd);  ps.pick_spread(sd_m)               # .clamped(lo, hi) on samplers
+```
+
+## Chart specs + the asset bundle
+
+```python
+ps.Crossplot(x, y, wells=(), color_by="well", x_log=False, y_log=False,
+             regression=False) -> Crossplot     # applied on proj.crossplot_bundle
+ps.Tornado(base=None, units: str = "MSm³", fold_count: int = 8) -> Tornado
+ps.Distribution(gas=False, zone=None, name=None) -> Distribution
+
+ps.AssetSpec(name="", load=None, horizons=None, subzones=None, layering=None,
+             contacts=None, ties=None, gridding=None, props=None, mc=None,
+             run=None, view=None) -> AssetSpec
+    # A whole modelling scenario as one durable value; every field is a spec, so
+    # asset.to_dict() is a total, savable scenario file.
+```
+
+## The apply moments
+
+```python
+grid.model(props: Props | None = None, con: Contacts | dict | None = None, *,
+           fluid: str = "oil", fvf: float = 1.25, gas_fvf: float | None = None,
+           wells=None, run: Run | None = None, sugar_cube: bool = False) -> Model
+    # Execute the build with the property + contact specs -> a populated Model.
+    # Zoned (Horizons.zones present) -> contacts fold into the zonation; non-zoned
+    # -> contacts go to the model. `run` carries memory_budget + workers.
+
+model.zoned_uncertainty(mc: Mc | None = None, **legacy) -> ZonedUncertainty
+model.uncertainty(mc: Mc | None = None, **legacy) -> Uncertainty
+model.mc(spec: Mc)                       # auto-routes on model.is_zoned()
+    # Pass EITHER a ps.Mc spec OR the legacy kwargs — not both. Legacy kwargs emit
+    # a DeprecationWarning.
+```
+
+## The result surface — `Model`
+
+```python
+model.summary() -> dict                  # STOIIP / GIIP [MSm³], GRV [mcm]
+model.in_place_by_zone() -> dict         # {"zones": [...], "total": {...}}
+model.zone_stats(property: str) -> list  # per-zone count/mean/min/max
+model.well_tie_residuals() -> list       # [{well, horizon, measured_depth_m,
+                                         #   model_depth_m, residual_m}]
+model.property_names() -> list[str]
+model.is_zoned() -> bool
+model.well_ids() -> list[str]
+model.warnings() -> list
+
+# viewer bundles + render:
+model.map_bundle(property=None, k_slice=None) -> dict
+model.intersection_bundle(line=None, well=None, property=None) -> dict
+model.volume_bundle(property=None) -> dict
+model.wells_bundle() -> dict
+model.view(settings: ViewSettings | None = None, *, open_browser=True, port=0,
+           block=False, property=None, lines=None, charts=None) -> str   # URL
+model.save_view(path: str, property=None, lines=None, charts=None) -> None
+```
+
+## The result surface — uncertainty
+
+```python
+# flat (non-zoned) — model.uncertainty(...):
+unc.stoiip -> dict                       # {p90, p50, p10, mean, *_msm3, samples}
+unc.giip -> dict
+unc.tornado() -> list                    # ranked input swings
+unc.tornado_bundle(base=None, units="MSm³", fold_count=8) -> dict
+unc.distribution_bundle(gas=False, name=None) -> dict
+unc.view(open_browser=True, port=0, block=False, charts=None) -> str
+unc.save_view(path, charts=None) -> None
+
+# zoned — model.zoned_uncertainty(...):
+zunc.total -> dict                       # {"stoiip": {..}, "giip": {..}, "two_contact": bool}
+zunc.zones -> list                       # [{"zone", "stoiip", "giip", "two_contact"}, ...]
+zunc.distribution_bundle(gas=False, zone=None, name=None) -> dict
+```
+
+## Spec value semantics (shared)
+
+```python
+spec.to_dict() -> dict                   # tagged with "spec"; JSON-able
+Spec.from_dict(d) -> Spec                # per class
+ps.spec_from_dict(d) -> Spec             # dispatch on the "spec" tag
+ps.registered_specs() -> tuple[type, ...]
+spec.replace(**changes) -> Spec          # collection specs also accept a leading
+                                         # name/glob: hz.replace("H1", surface=...)
+spec == other;  hash(spec);  repr(spec)  # value equality; domain-table repr
+```
+
+## The analytic box model
+
+```python
+ps.run_box_model(area_km2, gross_height_m, porosity, net_to_gross,
+                 water_saturation, fvf, *, fluid="oil", top_m=0.0,
+                 contact_m=math.inf, ni=10, nj=10, nk=5,
+                 realizations=10_000, seed=1) -> ModelResult
+    # Each volumetric input: a number (constant) | (min, mode, max) triangular |
+    # {"normal"|"lognormal"|"uniform"|"triangular": [...]} tagged dict.
+    # contact_m is REQUIRED and finite (a non-finite contact is a loud error).
+
+m.samples -> list[float]                 # per-realization in-place [Sm³]
+m.summary_msm3 -> dict                    # {p90, p50, p10, mean} in MSm³ (oil)
+m.summary_bcm -> dict                     # the same in bcm (gas)
+m.scaled_summary(per: float) -> dict
+m.view(open_browser=True, port=0, block=False, property=None) -> str
+m.save_view(path, property=None) -> None
+m.save_json(path, property=None) -> None
+repr(m)                                   # P90 / P50 / P10 / mean / deterministic [Sm³]
+
+ps.Model(area_km2, gross_height_m, *, ni=20, nj=20, nk=8, top_m=1500.0,
+         contact_m=math.inf, porosity=0.25, net_to_gross=0.8,
+         water_saturation=0.3, fvf=1.25, fluid="oil")     # a structured box
+sm.add_control(ip: int, jp: int, depth_m: float) -> None  # a structural high
+sm.solve() -> Refined
+sm.view(...) ; sm.save_view(...) ; sm.save_json(...)
+```
+
+## Aggregation + standalone charts
+
+```python
+ps.aggregate(segments, correlation: str = "independent") -> list[float]
+    # correlation: "independent" | "comonotonic". Sum per-segment realization
+    # vectors under an explicit dependence assumption.
+ps.distribution_bundle(segments, aggregate=None, names=None, gas=False,
+                       title=None) -> dict
+```
+
+## v1 (deprecated)
+
+The v1 eight-call staged chain — `proj.framework(horizons=[...])` → `set_zones` /
+`set_zonation` / `set_layering` / `set_well_ties` → `build_grid` → per-property
+`grid.property(...).upscale(...).propagate(...)` → `grid.model(contacts=...)` →
+`model.uncertainty(...)` / `model.zoned_uncertainty(...)` → `mc.tornado()` — remains
+callable for a **two-minor** window and emits a `DeprecationWarning`. New code uses
+the declarative v2 surface above. The runnable staged example is
+`examples/staged_build.py`.

peteksim-0.1.0/CHANGELOG.md

@@ -0,0 +1,128 @@
+# Changelog
+
+All notable changes to petekSim are documented here. The format is based on
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and this project adheres
+to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Changed — packaging (internal, behaviour-neutral)
+
+- **Consolidated the three published library crates into one.** `srs-units`,
+  `srs-pvt` and `srs-core` were merged into a single crate, **`peteksim`**
+  (0.1.0), at the repo root. Their boundaries are preserved as modules —
+  `peteksim::{units, pvt, core}` — and the headline Rust API (`run_model`, the
+  appraisal facade types, the `Distribution` seam, the view bundles) is
+  re-exported at the crate root. File moves + mechanical path rewrites only; no
+  logic changed. The workspace keeps its `crates/srs-py` member (the `peteksim`
+  wheel source), which now binds the `peteksim` crate; the published PyPI wheel
+  surface (`peteksim`) is unchanged.
+- **Repointed the geomodel dependency at petekStatic's consolidated crate.** The
+  former per-crate path deps on petekStatic's `srs-*` crates are now a single
+  `petekstatic = "0.1.0"` (path `../petekStatic`); the `srs_model::` /
+  `srs_grid::` / `srs_wireframe::` (…) imports rewrote to
+  `petekstatic::{model, grid, wireframe, …}::`. petekio / petekTools pins
+  unchanged.
+
+## [0.1.0] - 2026-07-05
+
+First public release of **`peteksim`** — the Python-facing appraisal toolkit: a
+pure-Rust reservoir core with thin bindings that presents the whole
+subsurface-modelling stack (ingest → geomodel → volumetrics → uncertainty) as one
+facade. From a Petrel export to a STOIIP P-curve in a handful of calls.
+
+All inputs and outputs are **SI/metric**: areas in km², lengths/depths in metres
+(positive-down), volumes in Sm³ (reported in MSm³ for oil, bcm for gas), GRV in
+mcm (10⁶ m³), FVF as dimensionless Rm³/Sm³. Imperial is opt-in on your side, never
+a default.
+
+### Added — the declarative modelling API (v2, the primary surface)
+
+- **Specs applied at explicit moments.** A model is built from immutable, declarative
+  **spec** values that say WHAT (`Horizons`, `Subzones`, `Layering`, `Contacts`,
+  `Props`, `Mc`) or HOW (`TieSettings`, `Gridding`, `Run`, `LoadSettings`,
+  `ViewSettings`). A spec holds **names**, not project objects — so it is
+  project-independent, reusable across re-exports and synthetic assets. It is applied
+  at three explicit moments: `proj.grid_geometry(...)` → `geom.build(...)` →
+  `grid.model(...)` → `model.zoned_uncertainty(...)`.
+- **Loud at apply.** Errors when a spec is applied name **both** the missing project
+  object and the spec entry. A spec field the engine cannot yet honour raises
+  `NotYetSupported` (never a silent no-op); an unresolvable name raises `ApplyError`.
+- **Value semantics.** Every spec round-trips through a dict (`to_dict` / `from_dict`
+  / `ps.spec_from_dict`), compares and hashes by value, derives with `.replace(...)`,
+  and pretty-prints as its own domain table — so a scenario is a savable, diffable
+  file. `ps.AssetSpec` bundles a whole scenario (load + structure + props + mc) into
+  one durable value.
+- **Structure specs:** `ps.Horizons(ps.hz(...), zones=[...])` (the ordered
+  stratigraphic column + the zones between horizons; per-row well ties and structural
+  uncertainty via `ps.hz(tie=, sd=, vgm=)`), `ps.Subzones` / `ps.splits` (intra-zone
+  splits + conformity), `ps.Layering(dz= | nk=)`, `ps.Contacts({zone: {...}})`, and
+  `ps.zone(name, color=)`.
+- **Property specs:** `ps.Props(ps.Prop("PORO", net_only=True, propagate=...))` — a
+  visible per-property pipeline of well upscaling then SGS propagation
+  (`ps.Propagate` + `ps.variogram(...)` + optional `ps.collocated(name, corr=)` trend,
+  `level_shift` / `resimulate` MC modes).
+
+### Added — volumetrics, zoned Monte-Carlo, and P-curves
+
+- **In-place volumes.** `grid.model(...)` returns a populated model; `model.summary()`
+  reports STOIIP / GIIP (MSm³) and GRV (mcm). Two-contact columns (gas cap + oil rim)
+  split automatically from the contact picks.
+- **Zoned uncertainty.** `model.zoned_uncertainty(ps.Mc(...))` runs Monte-Carlo over
+  static-model realizations — per-zone contact draws and per-zone property level shifts
+  — and returns per-zone and total **P-curves** (`p90` / `p50` / `p10` / `mean`, with
+  `*_msm3` reporting scales) plus the full per-realization sample vectors.
+- **Multi-zone stacks.** A multi-horizon stack unlocks per-zone layering, per-zone
+  contacts (a contactless zone contributes GRV with zero hydrocarbon), and per-zone
+  property pipelines. `model.in_place_by_zone()`, `model.zone_stats(prop)`, and
+  `model.well_tie_residuals()` report the breakdown; well ties tie each horizon to its
+  tops picks.
+- **Tornado + aggregation.** A flat `model.uncertainty(...)` result exposes
+  `.tornado()` (ranked input swings); `ps.aggregate([...], correlation=...)` sums
+  segment realizations under an explicit dependence assumption.
+
+### Added — the analytic box model
+
+- **`ps.run_box_model(...)`** — a quick STOIIP/GIIP estimate with Monte-Carlo on each
+  volumetric input (a constant, a `(min, mode, max)` triangular, or a tagged
+  `{"normal"|"lognormal"|"uniform"|"triangular": [...]}` distribution). Returns
+  P90/P50/P10/mean/deterministic plus the full sample vector.
+- **`ps.Model(...)`** — a structured box with real structural relief built in code
+  (`add_control(i, j, depth_m)` seeds a high), for a first look before a full project.
+
+### Added — the browser viewer
+
+- **`model.view()`** opens a tabbed, bundle-driven inspection viewer: **Map** (areal
+  rasters, outline, contact subcrop masks, well markers, draw-a-fence to cut a
+  section), **Intersection** (the vertical cross-section with horizon + contact traces
+  and the bore path), and **Volume** (the corner-point mesh in three.js with property
+  colouring, threshold, zone toggles, i/j/k clip planes). `view()` is non-blocking
+  (prints a URL and returns).
+- **`model.save_view("m.html")`** writes ONE self-contained HTML file that opens off
+  `file://` with all data + JS inlined — no server, no network (confidential-data
+  safe). Bundle accessors `map_bundle` / `intersection_bundle` / `volume_bundle`
+  return the JSON directly. The renderer is petekTools' horizontal `petektools.viewer`
+  unit, which `peteksim` consumes.
+
+### Added — resources and out-of-core
+
+- **`ps.Run(memory_budget=<bytes>, workers=N)`** carries the run resources: `workers`
+  shards the MC realize loop; `memory_budget` forwards to the engine's out-of-core
+  switch (a larger-than-memory model spills to disk with a loud notice, never an OOM
+  kill).
+
+### Deprecated
+
+- **The v1 eight-call model-build chain** (`proj.framework(...)` → `set_zones` →
+  `build_grid` → per-property `upscale`/`propagate` → `grid.model` → `uncertainty` →
+  `tornado`) is deprecated in favour of the declarative v2 API, with a two-minor
+  window. It keeps working and emits a `DeprecationWarning`; new code should use
+  `proj.grid_geometry(...).build(ps.Horizons(...))`.
+
+### Licensing
+
+- petekSim is licensed under the **Business Source License 1.1** (BUSL-1.1); each
+  released version converts to Apache-2.0 four years after publication. See `LICENSE`.
+
+[Unreleased]: https://github.com/kkollsga/peteksim/compare/v0.1.0...HEAD
+[0.1.0]: https://github.com/kkollsga/peteksim/releases/tag/v0.1.0