moonlight-triangulation 1.2.0.1 → 1.3.0.0

raw patch · 91 files changed

+11730/−5338 lines, 91 filesdep +aesondep +directorydep +filepathdep ~basedep ~containersdep ~moonlight-triangulationnew-component:exe:moonlight-triangulation-category-observatory-exportnew-component:exe:moonlight-triangulation-delaunay-comparenew-component:exe:moonlight-triangulation-delaunay-picturesPVP ok

version bump matches the API change (PVP)

Dependencies added: aeson, directory, filepath, moonlight-algebra, moonlight-category, moonlight-homology, process, tasty, tasty-bench, tasty-hunit, unix

Dependency ranges changed: base, containers, moonlight-triangulation, transformers

API changes (from Hackage documentation)

Files

• CHANGELOG.md +56/−0
• README.md +122/−23
• app/category-observatory/Main.hs +562/−0
• bench/build/Moonlight/Triangulation/BuildBench.hs +38/−6
• bench/delaunay-compare/Main.hs +27/−0
• bench/delaunay-compare/Moonlight/Triangulation/Bench/DelaunayCompare/Domain.hs +244/−0
• bench/delaunay-compare/Moonlight/Triangulation/Bench/DelaunayCompare/Native.hs +307/−0
• bench/delaunay-compare/Moonlight/Triangulation/Bench/DelaunayCompare/Picture.hs +526/−0
• bench/delaunay-compare/Moonlight/Triangulation/Bench/DelaunayCompare/Suite.hs +260/−0
• bench/delaunay-compare/PictureMain.hs +75/−0
• bench/delaunay-compare/README.md +183/−0
• bench/delaunay-compare/rust/Cargo.lock +264/−0
• bench/delaunay-compare/rust/Cargo.toml +20/−0
• bench/delaunay-compare/rust/src/lib.rs +397/−0
• bench/support/BenchSupport.hs +18/−8
• bindings/README.md +62/−26
• bindings/python/pyproject.toml +2/−2
• bindings/python/src/moonlight_triangulation/__init__.py +457/−80
• bindings/python/tests/test_binding.py +41/−6
• bindings/rust/Cargo.toml +2/−2
• bindings/rust/src/lib.rs +628/−35
• bindings/rust/tests/binding.rs +74/−7
• bindings/typescript/package.json +2/−2
• bindings/typescript/src/index.ts +527/−74
• bindings/typescript/test/binding.test.ts +57/−21
• cbits/moonlight-triangulation.def +21/−4
• cbits/moonlight_runtime.c +1/−1
• include/moonlight_triangulation.h +100/−6
• moonlight-triangulation.cabal +157/−32
• src-build/Moonlight/Triangulation/BulkLoad.hs +43/−55
• src-build/Moonlight/Triangulation/Cdt.hs +6/−4
• src-build/Moonlight/Triangulation/Insertion.hs +12/−1
• src-build/Moonlight/Triangulation/Internal/Cdt/Batch.hs +1/−0
• src-build/Moonlight/Triangulation/Internal/Cdt/Build.hs +9/−12
• src-build/Moonlight/Triangulation/Internal/Cdt/Combinators.hs +1/−5
• src-build/Moonlight/Triangulation/Internal/Cdt/Recovery.hs +3/−1
• src-build/Moonlight/Triangulation/Internal/Cdt/Segment.hs +49/−72
• src-build/Moonlight/Triangulation/Internal/Cdt/Split.hs +54/−65
• src-build/Moonlight/Triangulation/Internal/Cdt/Types.hs +27/−52
• src-build/Moonlight/Triangulation/Internal/Cdt/Union.hs +13/−13
• src-build/Moonlight/Triangulation/Internal/CircleSweep.hs +31/−41
• src-build/Moonlight/Triangulation/Internal/Excision.hs +5/−1
• src-build/Moonlight/Triangulation/Internal/Join/Seam.hs +3/−2
• src-build/Moonlight/Triangulation/Internal/Location.hs +2/−6
• src-build/Moonlight/Triangulation/Internal/Minkowski/Convex.hs +0/−326
• src-build/Moonlight/Triangulation/Internal/Minkowski/Types.hs +0/−80
• src-build/Moonlight/Triangulation/Internal/Overlay/Arrangement.hs +0/−807
• src-build/Moonlight/Triangulation/Internal/Overlay/Resident.hs +0/−869
• src-build/Moonlight/Triangulation/Internal/Overlay/Types.hs +0/−267
• src-build/Moonlight/Triangulation/Internal/Refinement.hs +3/−6
• src-build/Moonlight/Triangulation/Internal/Transaction.hs +44/−5
• src-build/Moonlight/Triangulation/Minkowski.hs +0/−584
• src-build/Moonlight/Triangulation/Overlay.hs +0/−291
• src-build/Moonlight/Triangulation/Refinement.hs +26/−41
• src-capi/Moonlight/Triangulation/Foreign/Exports.hs +58/−17
• src-cell-complex/Moonlight/Triangulation/CellComplex.hs +100/−0
• src-core/Moonlight/Triangulation/Internal/ExactRational.hs +1/−1
• src-core/Moonlight/Triangulation/Scalar.hs +3/−1
• src-dcel/Moonlight/Triangulation/FloodFillIterator.hs +203/−52
• src-dcel/Moonlight/Triangulation/Handles.hs +0/−11
• src-dcel/Moonlight/Triangulation/Handles/Iterators.hs +0/−13
• src-dcel/Moonlight/Triangulation/Internal/BoundaryCycle.hs +123/−5
• src-dcel/Moonlight/Triangulation/Internal/DcelOperations.hs +0/−83
• src-dcel/Moonlight/Triangulation/Internal/DcelOperations/CandidateArena.hs +1/−4
• src-dcel/Moonlight/Triangulation/Internal/DcelOperations/FlipRule.hs +1/−7
• src-dcel/Moonlight/Triangulation/Internal/DcelOperations/Hull.hs +1/−1
• src-dcel/Moonlight/Triangulation/Internal/DcelOperations/Legalize.hs +2/−5
• src-dcel/Moonlight/Triangulation/Internal/DcelOperations/Normalize.hs +2/−5
• src-dcel/Moonlight/Triangulation/Internal/Mutable.hs +5/−0
• src-dcel/Moonlight/Triangulation/Internal/OperationState.hs +5/−0
• src-dcel/Moonlight/Triangulation/Validation.hs +1/−3
• src-dcel/Moonlight/Triangulation/Valuation.hs +7/−4
• src-dual/Moonlight/Triangulation/HintGenerator.hs +0/−492
• src-embedding/Moonlight/Triangulation/Internal/Overlay/Embedding.hs +0/−502
• src-ffi/Moonlight/Triangulation/Foreign/ABI.hs +762/−105
• src-planar/Moonlight/Triangulation/Internal/Minkowski/Convex.hs +326/−0
• src-planar/Moonlight/Triangulation/Internal/Minkowski/Types.hs +80/−0
• src-planar/Moonlight/Triangulation/Internal/Overlay/Arrangement.hs +814/−0
• src-planar/Moonlight/Triangulation/Internal/Overlay/Embedding.hs +533/−0
• src-planar/Moonlight/Triangulation/Internal/Overlay/Resident.hs +923/−0
• src-planar/Moonlight/Triangulation/Internal/Overlay/Types.hs +274/−0
• src-planar/Moonlight/Triangulation/Minkowski.hs +595/−0
• src-planar/Moonlight/Triangulation/Overlay.hs +296/−0
• src-public/Moonlight/Triangulation.hs +18/−6
• src-public/Moonlight/Triangulation/HintGenerator.hs +492/−0
• test/algebra/Moonlight/Triangulation/MinkowskiSpec.hs +58/−0
• test/cell-complex/Main.hs +95/−0
• test/ffi/Main.hs +227/−24
• test/native/Moonlight/Triangulation/ExactEmbeddingSpec.hs +85/−33
• test/native/Moonlight/Triangulation/NativeSpec.hs +76/−21
• weeder.toml +1/−2

@@ -6,6 +6,62 @@ The serialization format carries its own version tag, independent of the package version; any change to it is recorded here explicitly. +## 1.3.0.0++* Add the public GHC-9.14 `cell-complex` component. It interprets an admitted+  `ExactCellSet` as Homology's generic `CellComplex2D` without copying the mesh+  or introducing a second cell inventory, and the accompanying observatory+  executable derives its incidence category and normalized flag nerve.+* Keep the LLVM-optimized hot modules buildable with GHC 9.8 by restoring the+  legacy LLVM pass manager that its supported LLVM 15 toolchain requires.+* Withdraw `constrainedExtensionTriangulation`,+  `constrainedExtensionConstraintOutcomes` and+  `constrainedExtensionConstraintStats`. A constrained extension now publishes+  one `ConstraintBatchResult` through `constrainedExtensionConstraintBatch`,+  read with `constraintBatchTriangulation`, `constraintBatchOutcomes` and+  `constraintBatchStats`; `constrainedExtensionBuildStats` is unchanged. The+  batch is the same value `recoverConstraints` returns, so extension and+  standalone recovery are now read through one accessor set instead of two.+* Withdraw the aggregator modules `Moonlight.Triangulation.Handles`,+  `Moonlight.Triangulation.Handles.Iterators` and+  `Moonlight.Triangulation.Internal.DcelOperations` from the exposed module+  list. Every leaf they re-exported remains exposed under its own name; import+  the leaf.+* Add `BoundaryOrientation`, `boundaryLoopOrientation` and+  `componentBoundaryLoops`, so a face component publishes all of its boundary+  loops with each loop's orientation rather than only the outer one.+* Add `planarValuationsPerimeter`, the certified perimeter of a planar region+  taken directly from its valuations.+* Advance the C boundary to ABI version 2 with opaque exact-region and reusable+  structuring-element handles, one-call bulk authoring/projection, exact region+  union/intersection/difference/symmetric difference, point location, exact+  area plus Euler and certified perimeter observations, and existing polygonal+  Minkowski morphology with fixed-width receipts.+* Rename the former mesh Boolean symbols and Python, TypeScript, and Rust+  methods to `site_*`; they combine Delaunay site sets and are deliberately not+  compatibility aliases for the new polygonal region operations.+* Restore `-O0` for ordinary test bodies while retaining the filtered-predicate+  allocation witness at module-local `-O1`.+* Move the existing exact Overlay/Minkowski implementations from the `build`+  sublibrary into the main library and move `HintGenerator` from `dual` into+  that same apex owner. The `dual` sublibrary is now dcel-only and can compile+  concurrently with `build`; direct `:dual` consumers of `HintGenerator` must+  depend on the main library instead. No geometry type or runtime operation is+  duplicated.+* Reserve the planar DCEL bound rather than the general one when joining two+  separated triangulations. The separated seam copies two planar sources and+  then only adds, so its peak is its published result; the general reservation+  was a third again as much arena as the merge can ever reach. Measured at+  twenty thousand sites over twenty-one processes per arm, the separated join+  lanes fall 36.4% to 41.3% in allocation and 10.2% to 22.0% in elapsed time,+  with every unaffected lane byte-identical.+* Stop materializing an intermediate validated vector in `mesh_insert_many_f64`.+  Admission is unchanged — a malformed point anywhere still refuses the whole+  batch before any insertion — but the canonical coordinate is now applied+  where the point is used. Against a fifty-thousand-site mesh, allocation falls+  5.3% at a thousand added points and 26.5% at fifty thousand; wall time is+  unmoved, because geometric insertion, not admission, is the critical path.+ ## 1.2.0.1  * Admit GHC 9.8 as a tested compiler by spelling the package language as

@@ -36,6 +36,7 @@ | `cellValuations` / `regionValuations` | intrinsic measurement | Exact Euler characteristic and rational area plus symbolic radical length with certified bounds. | | `minkowskiSum` | polygonal convolution | Exact convex or general polygonal Minkowski addition, with work recorded in a receipt. | | `erodeBy` / `openWith` / `closeWith` | regularized morphology | Full-dimensional polygonal erosion and its opening/closing compositions for an origin-anchored convex kernel. |+| `fromExactCellSet` | topology interpretation | An opaque `DCELComplex` view of the already-admitted cell inventory; no mesh copy or second validation authority. |  ### Choose the operation @@ -70,16 +71,55 @@ | Keep Delaunay faces below an alpha threshold | `alphaShapeContainsFace threshold mesh` | This is the filled-face filtration, not palette logic and not a claim to expose every simplex of a full alpha-complex carrier. | | Require construction-independent numbering | `canonicalize` at the observation boundary | Do not canonicalize every intermediate value; it is intentionally global work. | +### Cell-complex and category interpretation++The `cell-complex` component interprets an `ExactCellSet` as+Homology's generic `CellComplex2D`. The carrier is opaque and retains the+authoritative selected handles and resident DCEL; `fromExactCellSet` is total+because `ExactCellSet` construction has already discharged downward closure and+handle validity.++The interpretation is available on GHC 9.14 and newer. Existing Triangulation+components retain the package's GHC 9.8–9.14 support range: below 9.14 Cabal+marks only `cell-complex`, its focused test, and the category-observatory+exporter unbuildable. Hackage aggregates dependencies from every component on+the package page, but an ordinary main-library consumer does not inherit the+Homology or Category closure.++```cabal+-- the consumer package+build-depends:+  moonlight-triangulation:cell-complex >= 1.3 && < 1.4,+  moonlight-homology:cell-category >= 0.1 && < 0.2+```++```haskell+import Moonlight.Homology.Pure.Topology.CellCategory (complexCategory)+import Moonlight.Triangulation.CellComplex (fromExactCellSet)++incidenceCategory = complexCategory . fromExactCellSet+```++`moonlight-triangulation-category-observatory-export` is the executable witness:+it constructs a real Delaunay mesh, selects its bounded cells, derives the finite+incidence category and normalized nerve, validates their overlap counts, and emits+only the checked visualization projection.+ ## Foreign bindings  The `moonlight-triangulation-c` foreign-library component exposes opaque-immutable geometry meshes, batch insertion, finite-set operations, and dense-vertex and triangle projections through one versioned C ABI. Python,-TypeScript, and Rust bindings live beneath [`bindings/`](bindings/README.md)-and descend through that same ABI; none restates the triangulation engine or-introduces a second mesh representation.+immutable geometry meshes, admitted exact planar regions, and reusable+polygonal structuring elements through ABI version 2. Mesh `site_*` operations+combine Delaunay sites; region operations perform actual polygonal Boolean+selection through the exact overlay owner. Regions cross in one bulk call as+coordinates plus loop/component counts and project back as components, loops,+and binary64 rendering points. Exact area remains lossless as a reduced ratio;+Euler is integral and perimeter carries certified bounds. Python, TypeScript,+and Rust bindings live beneath [`bindings/`](bindings/README.md) and descend+through that same ABI; none restates overlay, publication, valuation, or+morphology. -`union a a` is `a`; commutativity and associativity hold after explicit+For the Haskell mesh algebra, `union a a` is `a`; commutativity and associativity hold after explicit `canonicalize`; and a join adds no sites: the result carries `|A| + |B| − |A ∩ B|` of them. Structural `Eq` remains exact resident equality for caches and serialization rather than secretly rebuilding the mesh.@@ -103,19 +143,54 @@ | `extendConstrainedWith` | Copy-on-write only for a base of at least 200,000 sites, at most 128 incoming sites, exactly one incoming segment, and a pre-thaw corridor with no resident intersection. Every unmeasured or resident-corridor case stays dense. | | `refineWithinDomain` | Dense publication. The local transaction candidate preserved semantics but did not improve wall time, so it was removed. | -### Benchmark highlights+### Overall Moonlight–Spade comparison -Fresh source build on 2026-08-12. The comparison binaries passed exact-canonical-output agreement before seven interleaved fresh-process timing-rounds; brackets are the observed range. Lower is better.+The overall referent is broader than the construction board below. Its live+inventory contains 17 parity lanes and eight diagnostic cliff lanes. Every+timing descends through its declared artifact gate first: cross-language+canonical equality where the result is unique, and pinned per-side artifacts+where valid refinement or floating-point accumulation may differ. -| Operation | Workload | Moonlight | Spade 2.15.1 | Result |-| --- | ---: | ---: | ---: | ---: |-| Removal | remove 125k / 500k sites | 522.067 ms [514.481–539.392] | 16.576 s [15.304–17.308] | **31.75× faster** |-| Removal | remove 25k / 100k sites | 72.164 ms [67.604–78.116] | 360.899 ms [264.639–406.783] | **5.00× faster** median |-| Natural-neighbour interpolation | 2k queries / 400k sites | 192.792 ms [178.064–201.805] | 233.688 ms [214.695–250.986] | **1.21× faster** |-| Incremental insertion | 500k sites | 33.403 s [32.592–36.813] | 30.506 s [28.809–31.688] | within **1.09×** |+| Surface | Parity workloads |+| --- | --- |+| Construction | bulk load at 1k and 10k sites; incremental insertion at 1k, 10k, and 500k sites |+| Search and dual | 5k nearest-neighbour queries over 20k sites; Voronoi dual sweep over 1k sites; DCEL traversal over 2k sites |+| Constraints | recover 800 constraints over 8k sites; refine with 625 and 2,500 Steiner-site budgets |+| Persistent update | remove 250 / 1k, 2.5k / 10k, and 25k / 100k sites |+| Natural-neighbour interpolation | 1k queries over 10k sites; 2k queries over 100k sites |+| Segment traversal | 500 line intersections over 10k sites | +The eight diagnostic lanes cover one-at-a-time constraint recovery, constraint+splitting, hierarchy insertion, duplicate insertion, hierarchy removal,+single-angle sweep collapse, exactly collinear construction with face-less+location, and line intersection from outside the hull. They expose known+complexity cliffs; they are not omitted merely because the numbers are ugly.++The package-owned [operation suite](bench/spade-compare/README.md) documents the+complete inventory, semantic descent, timing protocol, and evidence rules. Its+`scorecard.sh` entry point consumes the closed Haskell lane registry directly;+`list` exposes the operation surface, while only a complete, attributable+`refresh` may create a retained performance board.++```console+compiler/foundation/moonlight-triangulation/bench/spade-compare/scorecard.sh list+compiler/foundation/moonlight-triangulation/bench/spade-compare/scorecard.sh check+```++### Package-owned Delaunay construction board++The Haskell-owned port of Spade's construction matrix lives with the+triangulation library at [`bench/delaunay-compare`](bench/delaunay-compare/README.md).+It appends Moonlight to Spade, Spade hierarchy, `cdt`, and `delaunator`, checks+all 24 fixture summaries across all five implementations before timing, and+derives both pictures from the retained 120-case CSV.++![Moonlight Delaunay construction over the small Spade fixtures](https://raw.githubusercontent.com/PaleRoses/moonlight/main/moonlight-triangulation/bench/delaunay-compare/results/moonlight-delaunay-compare-small.svg)++The [benchmark README](bench/delaunay-compare/README.md) owns the single+retained board, its result, receipt, big-point picture, and reproduction+procedure. This package overview does not maintain a second benchmark history.+ Spade exposes no public triangulation set algebra corresponding to these operations. Their independently witnessed Moonlight publication costs are: @@ -199,10 +274,11 @@ * One half-edge mesh underneath. `Cdt` is a mode index on it, not a second   structure. -The Haskell facade carries the exact region, overlay, valuation, and morphology-algebra. `ExactCellSet` preserves closed point, edge, and face selections;-`PlanarRegion` is its full-dimensional polygonal publication. The C ABI and-Python, TypeScript, and Rust bindings carry the immutable binary64 mesh surface.+The Haskell facade is the authority for exact region, overlay, valuation, and+morphology. `ExactCellSet` preserves closed point, edge, and face selections;+`PlanarRegion` is its full-dimensional polygonal publication. ABI version 2+retains that admitted region behind an opaque handle; foreign binary64 points+are authoring/rendering boundaries, not a competing exact representation.  ## Use @@ -517,11 +593,34 @@ | --- | --- | | `core` | Exact-arithmetic scalars (`Scalar`, `LineSideInfo`) over paged, copy-on-write storage (`Internal.Dyadic`, `.Paged`, `.BoxedPaged`, `.PageDirectory`, `.Growable`, `.PackedIndex`, `.FaceQueue`). Depends only on `base`/`containers`/`deepseq`/`vector` — no other sublibrary. | | `dcel` | The finite half-edge mesh and its whole read surface: `Types`, `Math`, exact geometry, closed `CellSet`, `Region`, `Valuation`, `Interop`, `Dcel`, `Payload`, `JoinSemilattice`, `Handles` with its iterator family, `PointLocation`, `Validation`, `FloodFillIterator`, `IntersectionIterator`. Adds `primitive` and `vector-algorithms` over `core`. |-| `build` | Everything that *constructs*: `BulkLoad`, `Session`, `Removal`, typed `SetAlgebra`, `Cdt` constraint recovery, `Overlay`, `Minkowski`, and `Refinement`. Adds no external dependency over `core` and `dcel`. |+| `build` | The construction kernel: `BulkLoad`, `Session`, `Removal`, typed `SetAlgebra`, `Cdt` constraint recovery, and `Refinement`. Adds no external dependency over `core` and `dcel`. | | `parallel` | Concurrent evaluation of the pure union plan. Adds `async` at this effect boundary rather than below it. | | `serialize` | `Serialization` — the versioned binary envelope, and the only sublibrary that costs you `binary`, `bytestring`, and `transformers`. Deliberately absent from the facade. |-| `dual` | The Voronoi dual and what reads it: `Voronoi`, `Voronoi.Handles`, `Interpolation` (natural-neighbour), `HintGenerator` (Delaunay hierarchy hints). Sits over `core`, `dcel` and `build`. |-| facade (`moonlight-triangulation`) | `Moonlight.Triangulation` alone: the equational surface, one export list stating a theory. It re-exports selected names from `core`/`dcel`/`build`/`dual` — and *not* `serialize`. A caller who wants more than the theory names the machine-room module directly. |+| `dual` | The dcel-only Voronoi dual and its readers: `Voronoi`, `Voronoi.Handles`, and `Interpolation` (natural-neighbour). It can compile concurrently with `build`. |+| facade (`moonlight-triangulation`) | The equational surface plus the two real overlaps: exact `Overlay`/`Minkowski` operations that descend through `build`, and `HintGenerator`, which glues construction to the dual. It re-exports the theory and deliberately excludes `serialize`; there is no duplicate facade implementation beneath it. |++### Fast local feedback++Run exact components through the repository build guard so a local edit never+silently expands into the complete package. From the repository's `compiler/`+directory, the optimized construction kernel is:++    ../scripts/safe-cabal.sh build moonlight-triangulation:lib:build \+      --project-file=cabal.project.triangulation-dev \+      --builddir=dist-newstyle-triangulation-dev++For type-and-interface feedback where no benchmarkable artifact is required,+use the same component and cache at `-O0`:++    ../scripts/safe-cabal.sh build moonlight-triangulation:lib:build \+      --project-file=cabal.project.triangulation-dev \+      --builddir=dist-newstyle-triangulation-fast \+      --disable-optimization++The full facade is still an admitted five-component closure. Release and+runtime claims use the optimized profile; the `-O0` command is deliberately a+different feedback workload, not counterfeit evidence of a faster production+build.  ## Surface 

@@ -0,0 +1,562 @@+{-# LANGUAGE DeriveAnyClass #-}++module Main (main) where++import Data.Aeson (ToJSON)+import Data.Aeson qualified as Aeson+import Data.Bifunctor (first)+import Data.ByteString.Lazy.Char8 qualified as LazyByteString+import Data.Containers.ListUtils (nubOrd)+import Data.List.NonEmpty (NonEmpty (..))+import Data.Vector qualified as Vector+import GHC.Generics (Generic)+import Moonlight.Homology.Pure.Topology.CellCategory+  ( ComplexCat,+    ComplexMor (..),+    ComplexOb (..),+    complexCategory,+  )+import Moonlight.Triangulation.CellComplex+  ( DCELComplex,+    fromExactCellSet,+  )+import Moonlight.Category+  ( Category (..),+    FiniteComposableCategory (..),+    chainVertices,+  )+import Moonlight.Category.Simplicial+  ( GeneratedSSet,+    NerveSimplex,+    TruncatedNormalizedSSet,+    generatedSimplicesAtDimension,+    nerveSimplexChain,+    normalizedNerve,+    simplicesAtDimension,+    unnormalizedNerve,+  )+import Moonlight.Homology.Pure.Topology.CellComplex+  ( CellComplex2D (..),+    CellTypes (..),+    OrientedEdge (..),+  )+import Moonlight.Triangulation.BulkLoad (delaunayGeometry)+import Moonlight.Triangulation.CellSet+  ( CellSelectionError,+    ExactCellSet,+    closeFaceCellSet,+    exactCellSetEdgeCount,+    exactCellSetFaceCount,+    exactCellSetVertexCount,+  )+import Moonlight.Triangulation.Dcel+  ( faceVertices,+    undirectedEndpoints,+    vertexPoint,+  )+import Moonlight.Triangulation.Handles.HandleDefs+  ( FaceId,+    UndirectedEdgeId,+    VertexId,+    unFaceId,+    unUndirectedEdgeId,+    unVertexId,+  )+import Moonlight.Triangulation.Handles.Iterators.FixedIterators (innerFaces)+import Moonlight.Triangulation.Types+  ( BuildError,+    DelaunayTriangulation,+    Point (..),+  )+import Numeric.Natural (Natural)+import System.Exit (die)++main :: IO ()+main =+  either+    (die . renderExhibitError)+    (LazyByteString.putStrLn . Aeson.encode)+    buildExhibit++data ExhibitError+  = ExhibitTriangulationBuildFailed BuildError+  | ExhibitCellSelectionFailed CellSelectionError+  | ExhibitMorphismEndpointUnavailable MorphismEndpoint Int+  | ExhibitFaceWithoutVertices FaceId+  | ExhibitMalformedTwoSimplex Int+  | ExhibitInventoryMismatch (Int, Int, Int) (Int, Int, Int)+  | ExhibitCategoryEnumerationMismatch (Int, Int, Int, Int) (Int, Int, Int, Int)+  | ExhibitNerveCountMismatch Int Int+  deriving stock (Show)++data MorphismEndpoint+  = MorphismSource+  | MorphismTarget+  deriving stock (Show)++renderExhibitError :: ExhibitError -> String+renderExhibitError = show++data Exhibit = Exhibit+  { schemaVersion :: Int,+    exhibitTitle :: String,+    mesh :: MeshProjection,+    category :: CategoryProjection,+    nerve :: NerveProjection+  }+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data MeshProjection = MeshProjection+  { meshVertices :: [MeshVertex],+    meshEdges :: [MeshEdge],+    meshFaces :: [MeshFace]+  }+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data MeshVertex = MeshVertex+  { meshVertexIdentifier :: String,+    meshVertexObjectIdentifier :: String,+    meshVertexPosition :: Position+  }+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data MeshEdge = MeshEdge+  { meshEdgeIdentifier :: String,+    meshEdgeObjectIdentifier :: String,+    meshEdgeVertexIdentifiers :: [String]+  }+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data MeshFace = MeshFace+  { meshFaceIdentifier :: String,+    meshFaceObjectIdentifier :: String,+    meshFaceVertexIdentifiers :: [String]+  }+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data Position = Position+  { positionX :: Double,+    positionY :: Double+  }+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data CategoryProjection = CategoryProjection+  { categoryObjects :: [CategoryObject],+    categoryMorphisms :: [CategoryMorphism]+  }+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data CategoryObject = CategoryObject+  { categoryObjectIdentifier :: String,+    categoryObjectKind :: CategoryObjectKind,+    categoryObjectLabel :: String,+    categoryObjectPosition :: Position+  }+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data CategoryObjectKind+  = VertexObject+  | EdgeObject+  | FaceObject+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data CategoryMorphism = CategoryMorphism+  { categoryMorphismIdentifier :: String,+    categoryMorphismKind :: CategoryMorphismKind,+    categoryMorphismSourceObject :: String,+    categoryMorphismTargetObject :: String+  }+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data CategoryMorphismKind+  = IdentityMorphism+  | FaceEdgeMorphism+  | EdgeVertexMorphism+  | FaceVertexComposite+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data NerveProjection = NerveProjection+  { nerveTwoSimplices :: [NerveTwoSimplex],+    nerveSimplexCounts :: [NerveSimplexCount]+  }+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data NerveSimplexCount = NerveSimplexCount+  { nerveDimension :: Natural,+    normalizedSimplexCount :: Int,+    unnormalizedSimplexCount :: Int+  }+  deriving stock (Generic)+  deriving anyclass (ToJSON)++data NerveTwoSimplex = NerveTwoSimplex+  { nerveSimplexIdentifier :: String,+    nerveSimplexObjectIdentifiers :: [String]+  }+  deriving stock (Generic)+  deriving anyclass (ToJSON)++buildExhibit :: Either ExhibitError Exhibit+buildExhibit = do+  triangulation <- first ExhibitTriangulationBuildFailed (delaunayGeometry exhibitPoints)+  selectedCells <-+    first ExhibitCellSelectionFailed+      (closeFaceCellSet triangulation (innerFaces triangulation))+  let complexValue = fromExactCellSet selectedCells+      categoryValue = complexCategory complexValue+  validateInventory selectedCells complexValue+  validateCategoryEnumeration complexValue categoryValue+  categoryProjection <- projectCategory triangulation categoryValue+  nerveProjection <- projectNerve categoryValue+  validateNerveCount complexValue nerveProjection+  pure+    Exhibit+      { schemaVersion = 2,+        exhibitTitle = "Triangulation, incidence category, and flag nerve",+        mesh = projectMesh triangulation complexValue,+        category = categoryProjection,+        nerve = nerveProjection+      }++validateInventory :: ExactCellSet -> DCELComplex -> Either ExhibitError ()+validateInventory cellSet complexValue =+  let expectedCounts =+        ( exactCellSetVertexCount cellSet,+          exactCellSetEdgeCount cellSet,+          exactCellSetFaceCount cellSet+        )+      observedCounts =+        ( length (vertices complexValue),+          length (edges complexValue),+          length (faces complexValue)+        )+   in if observedCounts == expectedCounts+        then Right ()+        else Left (ExhibitInventoryMismatch expectedCounts observedCounts)++validateCategoryEnumeration ::+  DCELComplex ->+  ComplexCat DCELComplex ->+  Either ExhibitError ()+validateCategoryEnumeration complexValue categoryValue =+  let morphisms = enumerateMorphisms categoryValue+      expectedCounts =+        ( length (vertices complexValue) + length (edges complexValue) + length (faces complexValue),+          sum (fmap (length . faceBoundary complexValue) (faces complexValue)),+          sum (fmap (edgeEndpointCount complexValue) (edges complexValue)),+          sum (fmap (faceFlagCount complexValue) (faces complexValue))+        )+      observedCounts =+        ( length (filter isIdentityMorphism morphisms),+          length (filter isFaceEdgeMorphism morphisms),+          length (filter isEdgeVertexMorphism morphisms),+          length (filter isFaceVertexMorphism morphisms)+        )+   in if observedCounts == expectedCounts+        then Right ()+        else Left (ExhibitCategoryEnumerationMismatch expectedCounts observedCounts)++validateNerveCount :: DCELComplex -> NerveProjection -> Either ExhibitError ()+validateNerveCount complexValue nerveProjection =+  let expectedCount = sum (fmap (faceFlagCount complexValue) (faces complexValue))+      observedCount = length (nerveTwoSimplices nerveProjection)+   in if observedCount == expectedCount+        then Right ()+        else Left (ExhibitNerveCountMismatch expectedCount observedCount)++edgeEndpointCount :: DCELComplex -> Edge DCELComplex -> Int+edgeEndpointCount complexValue edgeValue =+  let (sourceVertex, targetVertex) = edgeBoundary complexValue edgeValue+   in length (nubOrd [sourceVertex, targetVertex])++faceFlagCount :: DCELComplex -> Face DCELComplex -> Int+faceFlagCount complexValue faceValue =+  sum+    ( fmap+        (edgeEndpointCount complexValue . orientedEdge)+        (faceBoundary complexValue faceValue)+    )++isIdentityMorphism :: ComplexMor DCELComplex -> Bool+isIdentityMorphism morphismValue =+  case morphismValue of+    IdentityMor _ -> True+    _ -> False++isFaceEdgeMorphism :: ComplexMor DCELComplex -> Bool+isFaceEdgeMorphism morphismValue =+  case morphismValue of+    FaceToEdge _ _ _ -> True+    _ -> False++isEdgeVertexMorphism :: ComplexMor DCELComplex -> Bool+isEdgeVertexMorphism morphismValue =+  case morphismValue of+    EdgeToVertex _ _ -> True+    _ -> False++isFaceVertexMorphism :: ComplexMor DCELComplex -> Bool+isFaceVertexMorphism morphismValue =+  case morphismValue of+    FaceToVertex _ _ _ -> True+    _ -> False++projectMesh :: DelaunayTriangulation () -> DCELComplex -> MeshProjection+projectMesh triangulation complexValue =+  MeshProjection+    { meshVertices = fmap (projectMeshVertex triangulation) (vertices complexValue),+      meshEdges = fmap (projectMeshEdge triangulation) (edges complexValue),+      meshFaces = fmap (projectMeshFace triangulation) (faces complexValue)+    }++projectMeshVertex :: DelaunayTriangulation () -> VertexId -> MeshVertex+projectMeshVertex triangulation vertexValue =+  MeshVertex+    { meshVertexIdentifier = vertexIdentifier vertexValue,+      meshVertexObjectIdentifier = vertexObjectIdentifier vertexValue,+      meshVertexPosition = pointPosition (vertexPoint triangulation vertexValue)+    }++projectMeshEdge :: DelaunayTriangulation () -> UndirectedEdgeId -> MeshEdge+projectMeshEdge triangulation edgeValue =+  let (sourceVertex, targetVertex) = undirectedEndpoints triangulation edgeValue+   in MeshEdge+        { meshEdgeIdentifier = edgeIdentifier edgeValue,+          meshEdgeObjectIdentifier = edgeObjectIdentifier edgeValue,+          meshEdgeVertexIdentifiers = fmap vertexIdentifier [sourceVertex, targetVertex]+        }++projectMeshFace :: DelaunayTriangulation () -> FaceId -> MeshFace+projectMeshFace triangulation faceValue =+  MeshFace+    { meshFaceIdentifier = faceIdentifier faceValue,+      meshFaceObjectIdentifier = faceObjectIdentifier faceValue,+      meshFaceVertexIdentifiers = fmap vertexIdentifier (faceVertices triangulation faceValue)+    }++projectCategory ::+  DelaunayTriangulation () ->+  ComplexCat DCELComplex ->+  Either ExhibitError CategoryProjection+projectCategory triangulation categoryValue = do+  objectProjections <-+    traverse+      (projectCategoryObject triangulation)+      (enumerateObjects categoryValue)+  morphismProjections <-+    traverse+      (projectCategoryMorphism categoryValue)+      (zip [0 ..] (enumerateMorphisms categoryValue))+  pure+    CategoryProjection+      { categoryObjects = objectProjections,+        categoryMorphisms = morphismProjections+      }++projectCategoryObject ::+  DelaunayTriangulation () ->+  ComplexOb DCELComplex ->+  Either ExhibitError CategoryObject+projectCategoryObject triangulation objectValue = do+  objectPosition <- positionForObject triangulation objectValue+  pure+    CategoryObject+      { categoryObjectIdentifier = objectIdentifier objectValue,+        categoryObjectKind = objectKind objectValue,+        categoryObjectLabel = objectLabel objectValue,+        categoryObjectPosition = objectPosition+      }++projectCategoryMorphism ::+  ComplexCat DCELComplex ->+  (Int, ComplexMor DCELComplex) ->+  Either ExhibitError CategoryMorphism+projectCategoryMorphism categoryValue (morphismIndex, morphismValue) = do+  sourceObject <-+    first+      (const (ExhibitMorphismEndpointUnavailable MorphismSource morphismIndex))+      (source categoryValue morphismValue)+  targetObject <-+    first+      (const (ExhibitMorphismEndpointUnavailable MorphismTarget morphismIndex))+      (target categoryValue morphismValue)+  pure+    CategoryMorphism+      { categoryMorphismIdentifier = "morphism-" <> show morphismIndex,+        categoryMorphismKind = morphismKind morphismValue,+        categoryMorphismSourceObject = objectIdentifier sourceObject,+        categoryMorphismTargetObject = objectIdentifier targetObject+      }++projectNerve :: ComplexCat DCELComplex -> Either ExhibitError NerveProjection+projectNerve categoryValue = do+  let normalizedNerveValue = normalizedNerve categoryValue nerveObservationBound+      unnormalizedNerveValue = unnormalizedNerve categoryValue nerveObservationBound+  twoSimplices <-+    traverse+      projectTwoSimplex+      (zip [0 ..] (simplicesAtDimension normalizedNerveValue nerveObservationBound))+  pure+    NerveProjection+      { nerveTwoSimplices = twoSimplices,+        nerveSimplexCounts =+          fmap+            (projectNerveSimplexCount normalizedNerveValue unnormalizedNerveValue)+            nerveObservationDimensions+      }++nerveObservationBound :: Natural+nerveObservationBound = 2++nerveObservationDimensions :: [Natural]+nerveObservationDimensions = [0, 1, 2]++projectNerveSimplexCount ::+  TruncatedNormalizedSSet (NerveSimplex (ComplexCat DCELComplex)) ->+  GeneratedSSet (NerveSimplex (ComplexCat DCELComplex)) ->+  Natural ->+  NerveSimplexCount+projectNerveSimplexCount normalizedNerveValue unnormalizedNerveValue dimensionValue =+  NerveSimplexCount+    { nerveDimension = dimensionValue,+      normalizedSimplexCount = length (simplicesAtDimension normalizedNerveValue dimensionValue),+      unnormalizedSimplexCount = length (generatedSimplicesAtDimension unnormalizedNerveValue dimensionValue)+    }++projectTwoSimplex ::+  (Int, NerveSimplex (ComplexCat DCELComplex)) ->+  Either ExhibitError NerveTwoSimplex+projectTwoSimplex (simplexIndex, simplexValue) =+  case chainVertices (nerveSimplexChain simplexValue) of+    faceObject :| [edgeObject, vertexObject] ->+      pure+        NerveTwoSimplex+          { nerveSimplexIdentifier = "simplex-" <> show simplexIndex,+            nerveSimplexObjectIdentifiers =+              fmap objectIdentifier [faceObject, edgeObject, vertexObject]+          }+    _ -> Left (ExhibitMalformedTwoSimplex simplexIndex)++positionForObject ::+  DelaunayTriangulation () ->+  ComplexOb DCELComplex ->+  Either ExhibitError Position+positionForObject triangulation objectValue =+  case objectValue of+    VertexOb vertexValue ->+      Right (pointPosition (vertexPoint triangulation vertexValue))+    EdgeOb edgeValue ->+      let (sourceVertex, targetVertex) = undirectedEndpoints triangulation edgeValue+       in Right+            ( midpoint+                (pointPosition (vertexPoint triangulation sourceVertex))+                (pointPosition (vertexPoint triangulation targetVertex))+            )+    FaceOb faceValue ->+      centroid faceValue+        (fmap (pointPosition . vertexPoint triangulation) (faceVertices triangulation faceValue))++centroid :: FaceId -> [Position] -> Either ExhibitError Position+centroid faceValue positions =+  case positions of+    [] -> Left (ExhibitFaceWithoutVertices faceValue)+    _ ->+      let (totalX, totalY) =+            foldl'+              (\(accumulatedX, accumulatedY) positionValue ->+                 ( accumulatedX + positionX positionValue,+                   accumulatedY + positionY positionValue+                 )+              )+              (0, 0)+              positions+          positionCount = fromIntegral (length positions)+       in Right (Position (totalX / positionCount) (totalY / positionCount))++midpoint :: Position -> Position -> Position+midpoint firstPosition secondPosition =+  Position+    { positionX = (positionX firstPosition + positionX secondPosition) / 2,+      positionY = (positionY firstPosition + positionY secondPosition) / 2+    }++pointPosition :: Point -> Position+pointPosition pointValue =+  Position+    { positionX = pointX pointValue,+      positionY = pointY pointValue+    }++objectIdentifier :: ComplexOb DCELComplex -> String+objectIdentifier objectValue =+  case objectValue of+    VertexOb vertexValue -> vertexObjectIdentifier vertexValue+    EdgeOb edgeValue -> edgeObjectIdentifier edgeValue+    FaceOb faceValue -> faceObjectIdentifier faceValue++objectKind :: ComplexOb DCELComplex -> CategoryObjectKind+objectKind objectValue =+  case objectValue of+    VertexOb _ -> VertexObject+    EdgeOb _ -> EdgeObject+    FaceOb _ -> FaceObject++objectLabel :: ComplexOb DCELComplex -> String+objectLabel objectValue =+  case objectValue of+    VertexOb vertexValue -> "v" <> show (unVertexId vertexValue)+    EdgeOb edgeValue -> "e" <> show (unUndirectedEdgeId edgeValue)+    FaceOb faceValue -> "f" <> show (unFaceId faceValue)++morphismKind :: ComplexMor DCELComplex -> CategoryMorphismKind+morphismKind morphismValue =+  case morphismValue of+    IdentityMor _ -> IdentityMorphism+    FaceToEdge _ _ _ -> FaceEdgeMorphism+    EdgeToVertex _ _ -> EdgeVertexMorphism+    FaceToVertex _ _ _ -> FaceVertexComposite++vertexIdentifier :: VertexId -> String+vertexIdentifier vertexValue = "vertex-" <> show (unVertexId vertexValue)++edgeIdentifier :: UndirectedEdgeId -> String+edgeIdentifier edgeValue = "edge-" <> show (unUndirectedEdgeId edgeValue)++faceIdentifier :: FaceId -> String+faceIdentifier faceValue = "face-" <> show (unFaceId faceValue)++vertexObjectIdentifier :: VertexId -> String+vertexObjectIdentifier vertexValue = "object-" <> vertexIdentifier vertexValue++edgeObjectIdentifier :: UndirectedEdgeId -> String+edgeObjectIdentifier edgeValue = "object-" <> edgeIdentifier edgeValue++faceObjectIdentifier :: FaceId -> String+faceObjectIdentifier faceValue = "object-" <> faceIdentifier faceValue++exhibitPoints :: Vector.Vector Point+exhibitPoints =+  Vector.fromList+    [ Point 80 72,+      Point 222 48,+      Point 362 92,+      Point 52 208,+      Point 176 166,+      Point 310 190,+      Point 414 232,+      Point 112 330,+      Point 258 314,+      Point 380 354+    ]

@@ -18,12 +18,13 @@ import qualified Data.Vector as V import Moonlight.Triangulation import Moonlight.Triangulation.BulkLoad (empty, insert)-import Moonlight.Triangulation.Cdt (constraintBatchStats, recoverConstraints)+import Moonlight.Triangulation.Cdt (recoverConstraints)+import Moonlight.Triangulation.Foreign.ABI (insertGeometryBatch) -- The facade withholds this constructor. The benchmark indexes the builder's -- own input mapping, so every handle it forges is one the builder issued, and -- it owns that obligation explicitly by naming the module that grants it. import Moonlight.Triangulation.Handles.HandleDefs (VertexId (VertexId))-import Moonlight.Triangulation.Session (insertVertex, withLocalSession, withSession)+import Moonlight.Triangulation.Session (insertVertex, insertVertexAt, withLocalSession, withSession) import Moonlight.Triangulation.Types   ( InsertionResult (insertionTriangulation)   , refinementStats@@ -38,9 +39,38 @@   putStrLn "moonlight-triangulation native construction benchmark"   forM_ [1_000, 10_000, 50_000] benchmarkConstruction   forM_ [1_000, 10_000, 50_000, 100_000, 1_000_000] benchmarkSingletonInsertionCrossover-  benchmarkConstraints 8_000 800+  forM_ [(50_000, 1_000), (50_000, 10_000), (50_000, 50_000)] benchmarkGeometryBatchInsertion+  benchmarkConstraints   benchmarkRefinement 2_500 +-- | What the geometry-only foreign batch entrance costs against the session+-- insertion it is built out of. The two arms differ by exactly one thing: the+-- ABI route validates every point into an intermediate boxed vector before it+-- opens the session, and the session arm receives the same points with that+-- pass already paid. Their difference is therefore the price of admission,+-- and it is the number that decides whether a fused geometry entrance is worth+-- designing at all. Inserting into an existing mesh is not the law of fresh+-- circle sweep, so nothing here transfers from the construction lanes above.+benchmarkGeometryBatchInsertion :: (Int, Int) -> IO ()+benchmarkGeometryBatchInsertion (baseCount, addedCount) = do+  let label suffix = "geometry-batch-" <> suffix <> "/" <> show baseCount <> "+" <> show addedCount+      basePoints = V.fromList (randomPoints 0x9e3779b97f4a7c15 baseCount)+      addedPoints = V.fromList (randomPoints 0xbf58476d1ce4e5b9 addedCount)+  base <- evaluate . force =<< requireRight (delaunayGeometry basePoints)+  _ <- evaluate (force addedPoints)+  admitted <- timedValue (label "abi") $ requireRight (insertGeometryBatch base addedPoints)+  (_, sessioned, _) <- timedValue (label "session") $+    requireRight+      ( withSession base (V.length addedPoints) $+          V.mapM_ (\point -> () <$ insertVertexAt point ()) addedPoints+      )+  admittedCanonical <- requireRight (canonicalize admitted)+  sessionedCanonical <- requireRight (canonicalize sessioned)+  equal <- evaluate (force (admittedCanonical == sessionedCanonical))+  unless equal $+    fail (label "witness" <> ": the admitted and session arms disagree")+  putStrLn (label "witness" <> ": ok")+ benchmarkConstruction :: Int -> IO () benchmarkConstruction count = do   let points = V.fromList (randomPoints 0x9e3779b97f4a7c15 count)@@ -74,8 +104,10 @@     fail ("scheduled and local singleton insertion disagree semantically at " <> show count <> " sites")   putStrLn ("singleton-insertion-crossover/" <> show count <> "-semantic-witness: ok") -benchmarkConstraints :: Int -> Int -> IO ()-benchmarkConstraints pointCount constraintCount = do+benchmarkConstraints :: IO ()+benchmarkConstraints = do+  let pointCount = 8_000+      constraintCount = 800   built <- requireRight (delaunay unitElementDefaults (V.fromList (randomPoints 0x94d049bb133111eb pointCount)))   let cdt = fromDelaunay (buildTriangulation built)       inputMapping = buildInputVertices built@@ -83,7 +115,7 @@         V.fromList           ( take constraintCount               [ (a, b)-              | index <- [0 ..]+              | index <- [0 .. pointCount * constraintCount - 1]               , let a = index `mod` pointCount                     b = (index * 6151 + pointCount `quot` 2) `mod` pointCount               , a /= b

@@ -0,0 +1,27 @@+-- | Haskell owner of the upstream-compatible construction comparison.+module Main (main) where++import Moonlight.Triangulation.Bench.DelaunayCompare.Domain (renderCompareObstruction)+import Moonlight.Triangulation.Bench.DelaunayCompare.Native (withNativeApi)+import Moonlight.Triangulation.Bench.DelaunayCompare.Suite+  ( preflightSuite+  , suiteAgreementMessage+  , suiteBenchmarks+  , withPreparedSuite+  )+import System.Exit (die)+import Test.Tasty.Bench (defaultMain)++main :: IO ()+main = do+  outcome <-+    withNativeApi $ \api ->+      withPreparedSuite api $ \suite -> do+        agreement <- preflightSuite api suite+        case agreement of+          Left obstruction -> pure (Left obstruction)+          Right () -> do+            putStrLn suiteAgreementMessage+            defaultMain (suiteBenchmarks api suite)+            pure (Right ())+  either (die . renderCompareObstruction) pure outcome

@@ -0,0 +1,244 @@+{-# LANGUAGE DeriveAnyClass #-}+{-# LANGUAGE DeriveGeneric #-}+{-# LANGUAGE DerivingStrategies #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE NumericUnderscores #-}++-- | The closed case matrix and typed obstruction surface for the comparison.+module Moonlight.Triangulation.Bench.DelaunayCompare.Domain+  ( SizeBand (..)+  , allSizeBands+  , sizeBandLabel+  , PointDistribution (..)+  , allPointDistributions+  , pointDistributionLabel+  , Implementation (..)+  , allImplementations+  , implementationLabel+  , NativeImplementation (..)+  , nativeImplementationLabel+  , implementationOfNative+  , PointCount+  , pointCountValue+  , pointCountsFor+  , FixtureSpec (..)+  , allFixtureSpecs+  , DelaunaySummary (..)+  , NativeStatus (..)+  , NativePreparationFailure (..)+  , NativeRunFailure (..)+  , CompareObstruction (..)+  , renderCompareObstruction+  ) where++import Control.DeepSeq (NFData)+import Data.List.NonEmpty (NonEmpty)+import qualified Data.List.NonEmpty as NonEmpty+import GHC.Generics (Generic)+import Moonlight.Triangulation.Types (BuildError)++data SizeBand+  = Small+  | Big+  deriving stock (Eq, Ord, Show, Generic)+  deriving anyclass (NFData)++allSizeBands :: [SizeBand]+allSizeBands = [Small, Big]++sizeBandLabel :: SizeBand -> String+sizeBandLabel = \case+  Small -> "small"+  Big -> "big"++data PointDistribution+  = LocalInsertion+  | Uniform+  deriving stock (Eq, Ord, Show, Generic)+  deriving anyclass (NFData)++allPointDistributions :: [PointDistribution]+allPointDistributions = [LocalInsertion, Uniform]++pointDistributionLabel :: PointDistribution -> String+pointDistributionLabel = \case+  LocalInsertion -> "local insertion"+  Uniform -> "uniform"++data Implementation+  = Spade+  | SpadeHierarchy+  | Cdt+  | Delaunator+  | Moonlight+  deriving stock (Eq, Ord, Show, Generic)+  deriving anyclass (NFData)++-- | Upstream order, with Moonlight appended rather than interposed.+allImplementations :: [Implementation]+allImplementations = [Spade, SpadeHierarchy, Cdt, Delaunator, Moonlight]++implementationLabel :: Implementation -> String+implementationLabel = \case+  Spade -> "spade 2"+  SpadeHierarchy -> "spade 2 hierarchy"+  Cdt -> "cdt"+  Delaunator -> "delaunator"+  Moonlight -> "moonlight-triangulation"++data NativeImplementation+  = NativeSpade+  | NativeSpadeHierarchy+  | NativeCdt+  | NativeDelaunator+  deriving stock (Eq, Ord, Show, Generic)+  deriving anyclass (NFData)++nativeImplementationLabel :: NativeImplementation -> String+nativeImplementationLabel = implementationLabel . implementationOfNative++implementationOfNative :: NativeImplementation -> Implementation+implementationOfNative = \case+  NativeSpade -> Spade+  NativeSpadeHierarchy -> SpadeHierarchy+  NativeCdt -> Cdt+  NativeDelaunator -> Delaunator++newtype PointCount = PointCount Int+  deriving stock (Eq, Ord, Show, Generic)+  deriving anyclass (NFData)++pointCountValue :: PointCount -> Int+pointCountValue (PointCount count) = count++data FixtureSpec = FixtureSpec+  { fixtureSizeBand :: !SizeBand+  , fixturePointDistribution :: !PointDistribution+  , fixturePointCount :: !PointCount+  }+  deriving stock (Eq, Ord, Show, Generic)+  deriving anyclass (NFData)++allFixtureSpecs :: [FixtureSpec]+allFixtureSpecs =+  concatMap+    ( \sizeBand ->+        liftA2+          (FixtureSpec sizeBand)+          allPointDistributions+          (pointCountsFor sizeBand)+    )+    allSizeBands++pointCountsFor :: SizeBand -> [PointCount]+pointCountsFor = \case+  Small -> PointCount <$> [2_000, 4_000, 6_000, 8_000, 10_000, 12_000, 14_000]+  Big -> PointCount <$> [50_000, 100_000, 150_000, 200_000, 250_000]++data DelaunaySummary = DelaunaySummary+  { summaryVertexCount :: !Int+  , summaryTriangleCount :: !Int+  }+  deriving stock (Eq, Ord, Show, Generic)+  deriving anyclass (NFData)++data NativeStatus+  = NativeNullPointer+  | NativeUnknownTag+  | NativeCoordinateCountMismatch+  | NativeDistributionConstructionFailed+  | NativeTriangulationFailed+  | NativePanicked+  | NativeUnknownStatus !Int+  deriving stock (Eq, Ord, Show, Generic)+  deriving anyclass (NFData)++data NativePreparationFailure+  = NativePreparationStatus !NativeStatus+  | NativePreparationReturnedNull+  deriving stock (Eq, Ord, Show, Generic)+  deriving anyclass (NFData)++data NativeRunFailure+  = NativeRunStatus !NativeStatus+  | NativeCountExceedsHaskellInt !Integer+  deriving stock (Eq, Ord, Show, Generic)+  deriving anyclass (NFData)++data CompareObstruction+  = RustManifestNotFound !(NonEmpty FilePath)+  | CargoInvocationFailed !FilePath !String+  | CargoBuildFailed !FilePath !Int !String+  | UnsupportedDynamicLibraryHost !String+  | DynamicLibraryOpenFailed !FilePath !String+  | DynamicSymbolLoadFailed !FilePath !String !String+  | FixtureGenerationFailed !FixtureSpec !NativeStatus+  | FixturePreparationFailed !FixtureSpec !NativeImplementation !NativeStatus+  | NativePreparedNull !FixtureSpec !NativeImplementation+  | MoonlightConstructionFailed !FixtureSpec !BuildError+  | NativeConstructionFailed !FixtureSpec !NativeImplementation !NativeRunFailure+  | SummaryDisagreement !FixtureSpec !Implementation !DelaunaySummary !DelaunaySummary+  | ComparisonObstructions !(NonEmpty CompareObstruction)+  deriving stock (Eq, Show, Generic)+  deriving anyclass (NFData)++renderCompareObstruction :: CompareObstruction -> String+renderCompareObstruction = \case+  RustManifestNotFound candidates ->+    "Rust referent manifest not found; checked " <> show (NonEmpty.toList candidates)+  CargoInvocationFailed manifest details ->+    "could not invoke Cargo for " <> manifest <> ": " <> details+  CargoBuildFailed manifest exitCode details ->+    "Cargo failed for "+      <> manifest+      <> " with exit code "+      <> show exitCode+      <> if null details then "" else ":\n" <> details+  UnsupportedDynamicLibraryHost host ->+    "delaunay-compare does not know the dynamic-library suffix for host " <> show host+  DynamicLibraryOpenFailed path details ->+    "could not load Rust referent library " <> path <> ": " <> details+  DynamicSymbolLoadFailed path symbol details ->+    "could not load symbol " <> symbol <> " from " <> path <> ": " <> details+  FixtureGenerationFailed fixture status ->+    "upstream fixture generation failed for " <> renderFixture fixture <> ": " <> show status+  FixturePreparationFailed fixture implementation status ->+    "native preparation failed for "+      <> nativeImplementationLabel implementation+      <> " on "+      <> renderFixture fixture+      <> ": "+      <> show status+  NativePreparedNull fixture implementation ->+    "native preparation returned a null handle for "+      <> nativeImplementationLabel implementation+      <> " on "+      <> renderFixture fixture+  MoonlightConstructionFailed fixture buildError ->+    "Moonlight construction failed for " <> renderFixture fixture <> ": " <> show buildError+  NativeConstructionFailed fixture implementation failure ->+    "native construction failed for "+      <> nativeImplementationLabel implementation+      <> " on "+      <> renderFixture fixture+      <> ": "+      <> show failure+  SummaryDisagreement fixture implementation expected observed ->+    "construction summary disagreement for "+      <> implementationLabel implementation+      <> " on "+      <> renderFixture fixture+      <> "; Moonlight="+      <> show expected+      <> ", observed="+      <> show observed+  ComparisonObstructions obstructions ->+    unlines ("delaunay comparison obstructed:" : fmap (("  - " <>) . renderCompareObstruction) (NonEmpty.toList obstructions))++renderFixture :: FixtureSpec -> String+renderFixture fixture =+  sizeBandLabel (fixtureSizeBand fixture)+    <> "/"+    <> pointDistributionLabel (fixturePointDistribution fixture)+    <> "/"+    <> show (pointCountValue (fixturePointCount fixture))

@@ -0,0 +1,307 @@+{-# LANGUAGE ForeignFunctionInterface #-}+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE ScopedTypeVariables #-}+{-# LANGUAGE TypeApplications #-}++-- | Resource-safe dynamic boundary to the Rust crates under comparison.+module Moonlight.Triangulation.Bench.DelaunayCompare.Native+  ( NativeApi+  , NativeFixture+  , GeneratedCoordinates+  , withNativeApi+  , generateCoordinates+  , generatedCoordinatePairs+  , prepareNativeFixture+  , runNativeFixture+  , releaseNativeFixture+  ) where++import Control.Exception (IOException, bracket, displayException, try)+import Control.Monad (filterM)+import Control.Monad.Trans.Except (ExceptT (ExceptT), runExceptT)+import Data.Bifunctor (first)+import Data.Int (Int32)+import Data.List (unfoldr)+import Data.List.NonEmpty (NonEmpty (..))+import qualified Data.List.NonEmpty as NonEmpty+import Moonlight.Triangulation.Bench.DelaunayCompare.Domain+import Foreign.C.Types (CDouble, CInt (..), CSize (..))+import Foreign.Marshal.Alloc (alloca)+import Foreign.Ptr (FunPtr, Ptr, nullPtr)+import Foreign.Storable (peek, poke)+import qualified Data.Vector as Vector+import qualified Data.Vector.Storable as StorableVector+import qualified Data.Vector.Storable.Mutable as MutableStorableVector+import System.Directory (doesFileExist, makeAbsolute)+import System.Environment (lookupEnv)+import System.Exit (ExitCode (..))+import System.FilePath ((</>), takeDirectory)+import System.Info (os)+import System.Posix.DynamicLinker+  ( DL+  , RTLDFlags (RTLD_LOCAL, RTLD_NOW)+  , dlclose+  , dlopen+  , dlsym+  )+import System.Process+  ( CreateProcess (cwd)+  , proc+  , readCreateProcessWithExitCode+  )++type GenerateFunction = CInt -> CSize -> Ptr CDouble -> CSize -> IO CInt+type PrepareFunction = CInt -> Ptr CDouble -> CSize -> Ptr (Ptr ()) -> IO CInt+type RunFunction = Ptr () -> Ptr CSize -> Ptr CSize -> IO CInt+type ReleaseFunction = Ptr () -> IO ()++foreign import ccall safe "dynamic"+  bindGenerateFunction :: FunPtr GenerateFunction -> GenerateFunction++foreign import ccall safe "dynamic"+  bindPrepareFunction :: FunPtr PrepareFunction -> PrepareFunction++foreign import ccall safe "dynamic"+  bindRunFunction :: FunPtr RunFunction -> RunFunction++foreign import ccall unsafe "dynamic"+  bindReleaseFunction :: FunPtr ReleaseFunction -> ReleaseFunction++data NativeApi = NativeApi+  { nativeGenerate :: !GenerateFunction+  , nativePrepare :: !PrepareFunction+  , nativeRun :: !RunFunction+  , nativeRelease :: !ReleaseFunction+  }++newtype NativeFixture = NativeFixture (Ptr ())++data GeneratedCoordinates = GeneratedCoordinates+  { generatedPointCount :: !PointCount+  , generatedCoordinateValues :: !(StorableVector.Vector CDouble)+  }++withNativeApi+  :: (NativeApi -> IO (Either CompareObstruction result))+  -> IO (Either CompareObstruction result)+withNativeApi action = do+  manifestResult <- resolveRustManifest+  case manifestResult of+    Left obstruction -> pure (Left obstruction)+    Right manifest -> do+      libraryResult <- buildRustLibrary manifest+      case libraryResult of+        Left obstruction -> pure (Left obstruction)+        Right libraryPath -> withLoadedNativeApi libraryPath action++resolveRustManifest :: IO (Either CompareObstruction FilePath)+resolveRustManifest = do+  configured <- lookupEnv "MOONLIGHT_DELAUNAY_COMPARE_RUST_MANIFEST"+  let candidates =+        case configured of+          Just path -> path :| []+          Nothing ->+            "bench/delaunay-compare/rust/Cargo.toml"+              :| [ "foundation/moonlight-triangulation/bench/delaunay-compare/rust/Cargo.toml"+                 , "compiler/foundation/moonlight-triangulation/bench/delaunay-compare/rust/Cargo.toml"+                 ]+  existing <- filterM doesFileExist (NonEmpty.toList candidates)+  case existing of+    manifest : _ -> Right <$> makeAbsolute manifest+    [] -> pure (Left (RustManifestNotFound candidates))++buildRustLibrary :: FilePath -> IO (Either CompareObstruction FilePath)+buildRustLibrary manifest = do+  libraryNameResult <- dynamicLibraryName+  case libraryNameResult of+    Left obstruction -> pure (Left obstruction)+    Right libraryName -> do+      let rustRoot = takeDirectory manifest+          targetDirectory = rustRoot </> "target"+          command =+            ( proc+                "cargo"+                [ "build"+                , "--quiet"+                , "--release"+                , "--lib"+                , "--manifest-path"+                , manifest+                , "--target-dir"+                , targetDirectory+                ]+            )+              { cwd = Just rustRoot+              }+      invocation <- try @IOException (readCreateProcessWithExitCode command "")+      pure $+        case invocation of+          Left exception ->+            Left (CargoInvocationFailed manifest (displayException exception))+          Right (ExitFailure exitCode, standardOutput, standardError) ->+            Left+              ( CargoBuildFailed+                  manifest+                  exitCode+                  (standardError <> standardOutput)+              )+          Right (ExitSuccess, _, _) ->+            Right (targetDirectory </> "release" </> libraryName)++dynamicLibraryName :: IO (Either CompareObstruction FilePath)+dynamicLibraryName =+  pure $+    case os of+      "darwin" -> Right "libmoonlight_delaunay_compare_referents.dylib"+      "linux" -> Right "libmoonlight_delaunay_compare_referents.so"+      host -> Left (UnsupportedDynamicLibraryHost host)++withLoadedNativeApi+  :: FilePath+  -> (NativeApi -> IO (Either CompareObstruction result))+  -> IO (Either CompareObstruction result)+withLoadedNativeApi libraryPath action = do+  opened <- try @IOException (dlopen libraryPath [RTLD_NOW, RTLD_LOCAL])+  case opened of+    Left exception ->+      pure (Left (DynamicLibraryOpenFailed libraryPath (displayException exception)))+    Right handle ->+      bracket+        (pure handle)+        dlclose+        ( \loadedHandle -> do+            apiResult <- loadNativeApi libraryPath loadedHandle+            case apiResult of+              Left obstruction -> pure (Left obstruction)+              Right api -> action api+        )++loadNativeApi :: FilePath -> DL -> IO (Either CompareObstruction NativeApi)+loadNativeApi libraryPath handle =+  runExceptT $+    NativeApi+      <$> loadSymbol libraryPath handle "delaunay_compare_generate" bindGenerateFunction+      <*> loadSymbol libraryPath handle "delaunay_compare_prepare" bindPrepareFunction+      <*> loadSymbol libraryPath handle "delaunay_compare_run" bindRunFunction+      <*> loadSymbol libraryPath handle "delaunay_compare_release" bindReleaseFunction++loadSymbol+  :: FilePath+  -> DL+  -> String+  -> (FunPtr function -> boundFunction)+  -> ExceptT CompareObstruction IO boundFunction+loadSymbol libraryPath handle symbol bind =+  ExceptT $ do+    loaded <- try @IOException (dlsym handle symbol)+    pure $+      first+        (DynamicSymbolLoadFailed libraryPath symbol . displayException)+        (bind <$> loaded)++generateCoordinates+  :: NativeApi+  -> FixtureSpec+  -> IO (Either NativeStatus GeneratedCoordinates)+generateCoordinates api fixture = do+  let pointCount = fixturePointCount fixture+      coordinateCount = 2 * pointCountValue pointCount+  mutableCoordinates <- MutableStorableVector.new coordinateCount+  statusCode <-+    MutableStorableVector.unsafeWith mutableCoordinates $ \coordinatePointer ->+      nativeGenerate api+        (distributionTag (fixturePointDistribution fixture))+        (fromIntegral (pointCountValue pointCount))+        coordinatePointer+        (fromIntegral coordinateCount)+  case decodeNativeStatus statusCode of+    Left status -> pure (Left status)+    Right () -> do+      coordinates <- StorableVector.unsafeFreeze mutableCoordinates+      pure (Right (GeneratedCoordinates pointCount coordinates))++generatedCoordinatePairs :: GeneratedCoordinates -> Vector.Vector (Double, Double)+generatedCoordinatePairs generated =+  Vector.fromList+    ( unfoldr+        takeCoordinatePair+        (realToFrac <$> StorableVector.toList (generatedCoordinateValues generated))+    )+ where+  takeCoordinatePair :: [Double] -> Maybe ((Double, Double), [Double])+  takeCoordinatePair = \case+    x : y : remaining -> Just ((x, y), remaining)+    _ -> Nothing++prepareNativeFixture+  :: NativeApi+  -> NativeImplementation+  -> GeneratedCoordinates+  -> IO (Either NativePreparationFailure NativeFixture)+prepareNativeFixture api implementation coordinates =+  alloca $ \preparedOutput -> do+    poke preparedOutput nullPtr+    statusCode <-+      StorableVector.unsafeWith (generatedCoordinateValues coordinates) $ \coordinatePointer ->+        nativePrepare api+          (implementationTag implementation)+          coordinatePointer+          (fromIntegral (pointCountValue (generatedPointCount coordinates)))+          preparedOutput+    case decodeNativeStatus statusCode of+      Left status -> pure (Left (NativePreparationStatus status))+      Right () -> do+        prepared <- peek preparedOutput+        pure $+          if prepared == nullPtr+            then Left NativePreparationReturnedNull+            else Right (NativeFixture prepared)++runNativeFixture+  :: NativeApi+  -> NativeFixture+  -> IO (Either NativeRunFailure DelaunaySummary)+runNativeFixture api (NativeFixture prepared) =+  alloca $ \vertexCountOutput ->+    alloca $ \triangleCountOutput -> do+      statusCode <- nativeRun api prepared vertexCountOutput triangleCountOutput+      case decodeNativeStatus statusCode of+        Left status -> pure (Left (NativeRunStatus status))+        Right () -> do+          vertexCount <- peek vertexCountOutput+          triangleCount <- peek triangleCountOutput+          pure $ DelaunaySummary <$> cSizeToInt vertexCount <*> cSizeToInt triangleCount++releaseNativeFixture :: NativeApi -> NativeFixture -> IO ()+releaseNativeFixture api (NativeFixture prepared) = nativeRelease api prepared++decodeNativeStatus :: CInt -> Either NativeStatus ()+decodeNativeStatus statusCode =+  case fromIntegral statusCode :: Int32 of+    0 -> Right ()+    1 -> Left NativeNullPointer+    2 -> Left NativeUnknownTag+    3 -> Left NativeCoordinateCountMismatch+    4 -> Left NativeDistributionConstructionFailed+    5 -> Left NativeTriangulationFailed+    6 -> Left NativePanicked+    unknown -> Left (NativeUnknownStatus (fromIntegral unknown))++cSizeToInt :: CSize -> Either NativeRunFailure Int+cSizeToInt value =+  let integerValue = toInteger value+   in if integerValue > toInteger (maxBound :: Int)+        then Left (NativeCountExceedsHaskellInt integerValue)+        else Right (fromInteger integerValue)++distributionTag :: PointDistribution -> CInt+distributionTag = \case+  LocalInsertion -> 0+  Uniform -> 1++implementationTag :: NativeImplementation -> CInt+implementationTag = \case+  NativeSpade -> 0+  NativeSpadeHierarchy -> 1+  NativeCdt -> 2+  NativeDelaunator -> 3

@@ -0,0 +1,526 @@+{-# LANGUAGE LambdaCase #-}++-- | Typed receipt parsing and pure Spade-style SVG projection.+module Moonlight.Triangulation.Bench.DelaunayCompare.Picture+  ( BenchmarkReceipt+  , PictureObstruction (..)+  , parseBenchmarkReceipt+  , pictureFileName+  , renderComparisonPicture+  , renderPictureObstruction+  ) where++import Data.List (group, sort, sortOn)+import qualified Data.Map.Strict as Map+import Data.Maybe (mapMaybe)+import qualified Data.Set as Set+import Moonlight.Triangulation.Bench.DelaunayCompare.Domain+import Numeric (showFFloat)+import Text.Read (readMaybe)++data ObservationKey = ObservationKey+  { observationFixture :: !FixtureSpec+  , observationImplementation :: !Implementation+  }+  deriving stock (Eq, Ord, Show)++data BenchmarkObservation = BenchmarkObservation+  { benchmarkKey :: !ObservationKey+  , benchmarkMeanPicoseconds :: !Double+  , benchmarkSpreadPicoseconds :: !Double+  }+  deriving stock (Eq, Show)++newtype BenchmarkReceipt = BenchmarkReceipt+  { receiptObservations :: Map.Map ObservationKey BenchmarkObservation+  }++data PictureObstruction+  = MissingCsvHeader+  | UnexpectedCsvHeader !String+  | MalformedCsvRow !Int !String+  | UnknownBenchmarkName !Int !String+  | InvalidBenchmarkScalar !Int !String !String+  | DuplicateBenchmarkObservations ![ObservationKey]+  | MissingBenchmarkObservations ![ObservationKey]+  deriving stock (Eq, Show)++parseBenchmarkReceipt :: String -> Either PictureObstruction BenchmarkReceipt+parseBenchmarkReceipt source =+  case lines source of+    [] -> Left MissingCsvHeader+    header : rows+      | header /= expectedCsvHeader -> Left (UnexpectedCsvHeader header)+      | otherwise -> do+          observations <- traverse (uncurry parseObservationRow) (zip [2 ..] rows)+          let keys = benchmarkKey <$> observations+              duplicateKeys =+                mapMaybe+                  ( \case+                      key : _ : _ -> Just key+                      _ -> Nothing+                  )+                  (group (sort keys))+              observationMap = Map.fromList ((\observation -> (benchmarkKey observation, observation)) <$> observations)+              missingKeys = Set.toList (expectedObservationKeys `Set.difference` Map.keysSet observationMap)+          case (duplicateKeys, missingKeys) of+            (duplicate : duplicates, _) -> Left (DuplicateBenchmarkObservations (duplicate : duplicates))+            ([], missing : remaining) -> Left (MissingBenchmarkObservations (missing : remaining))+            ([], []) -> Right (BenchmarkReceipt observationMap)++renderComparisonPicture+  :: SizeBand+  -> BenchmarkReceipt+  -> String+renderComparisonPicture sizeBand receipt =+  renderSvg sizeBand pointCounts axisMaximum panels+ where+  pointCounts = pointCountValue <$> pointCountsFor sizeBand+  panels = picturePanel receipt sizeBand <$> allPointDistributions+  allObservations = concatMap (concatMap pictureSeriesObservations . picturePanelSeries) panels+  maximumMilliseconds =+    foldr+      (max . observationUpperMilliseconds)+      0+      allObservations+  axisMaximum = niceCeiling maximumMilliseconds++pictureFileName :: SizeBand -> FilePath+pictureFileName = \case+  Small -> "moonlight-delaunay-compare-small.svg"+  Big -> "moonlight-delaunay-compare-big.svg"++renderPictureObstruction :: PictureObstruction -> String+renderPictureObstruction = \case+  MissingCsvHeader -> "benchmark CSV has no header"+  UnexpectedCsvHeader header ->+    "benchmark CSV header was " <> show header <> "; expected " <> show expectedCsvHeader+  MalformedCsvRow lineNumber row ->+    "benchmark CSV row " <> show lineNumber <> " is not a three-column tasty-bench row: " <> show row+  UnknownBenchmarkName lineNumber name ->+    "benchmark CSV row " <> show lineNumber <> " names an unknown comparison case: " <> show name+  InvalidBenchmarkScalar lineNumber field value ->+    "benchmark CSV row "+      <> show lineNumber+      <> " has invalid "+      <> field+      <> ": "+      <> show value+  DuplicateBenchmarkObservations keys ->+    "benchmark CSV repeats comparison cases: " <> show keys+  MissingBenchmarkObservations keys ->+    "benchmark CSV omits comparison cases: " <> show keys++expectedCsvHeader :: String+expectedCsvHeader = "Name,Mean (ps),2*Stdev (ps)"++expectedObservationKeys :: Set.Set ObservationKey+expectedObservationKeys =+  Set.fromList (liftA2 ObservationKey allFixtureSpecs allImplementations)++expectedBenchmarkNames :: Map.Map String ObservationKey+expectedBenchmarkNames =+  Map.fromList ((\key -> (benchmarkName key, key)) <$> Set.toList expectedObservationKeys)++benchmarkName :: ObservationKey -> String+benchmarkName key =+  "All.comparison: creation benchmark ("+    <> sizeBandLabel (fixtureSizeBand fixture)+    <> ")."+    <> implementationLabel (observationImplementation key)+    <> "."+    <> pointDistributionLabel (fixturePointDistribution fixture)+    <> "."+    <> show (pointCountValue (fixturePointCount fixture))+ where+  fixture = observationFixture key++parseObservationRow :: Int -> String -> Either PictureObstruction BenchmarkObservation+parseObservationRow lineNumber row =+  case csvTriple row of+    Nothing -> Left (MalformedCsvRow lineNumber row)+    Just (name, rawMean, rawSpread) -> do+      key <- maybe (Left (UnknownBenchmarkName lineNumber name)) Right (Map.lookup name expectedBenchmarkNames)+      meanPicoseconds <- parseNonNegativeScalar lineNumber "mean picoseconds" rawMean+      spreadPicoseconds <- parseNonNegativeScalar lineNumber "two-standard-deviation spread" rawSpread+      pure+        BenchmarkObservation+          { benchmarkKey = key+          , benchmarkMeanPicoseconds = meanPicoseconds+          , benchmarkSpreadPicoseconds = spreadPicoseconds+          }++csvTriple :: String -> Maybe (String, String, String)+csvTriple row =+  case break (== ',') row of+    (firstColumn, ',' : remaining) ->+      case break (== ',') remaining of+        (secondColumn, ',' : thirdColumn)+          | ',' `notElem` thirdColumn -> Just (firstColumn, secondColumn, thirdColumn)+        _ -> Nothing+    _ -> Nothing++parseNonNegativeScalar :: Int -> String -> String -> Either PictureObstruction Double+parseNonNegativeScalar lineNumber field rawValue =+  case readMaybe rawValue of+    Just value+      | value >= 0 && not (isInfinite value) && not (isNaN value) -> Right value+    _ -> Left (InvalidBenchmarkScalar lineNumber field rawValue)++data PictureSeries = PictureSeries+  { pictureSeriesImplementation :: !Implementation+  , pictureSeriesObservations :: ![BenchmarkObservation]+  }++data PicturePanel = PicturePanel+  { picturePanelDistribution :: !PointDistribution+  , picturePanelSeries :: ![PictureSeries]+  }++picturePanel+  :: BenchmarkReceipt+  -> SizeBand+  -> PointDistribution+  -> PicturePanel+picturePanel receipt sizeBand distribution =+  PicturePanel distribution (pictureSeries receipt sizeBand distribution <$> allImplementations)++pictureSeries+  :: BenchmarkReceipt+  -> SizeBand+  -> PointDistribution+  -> Implementation+  -> PictureSeries+pictureSeries receipt sizeBand distribution implementation =+  PictureSeries implementation observations+ where+  observations =+    sortOn (pointCountValue . fixturePointCount . observationFixture . benchmarkKey)+      [ observation+      | observation <- Map.elems (receiptObservations receipt)+      , let key = benchmarkKey observation+            fixture = observationFixture key+      , fixtureSizeBand fixture == sizeBand+      , fixturePointDistribution fixture == distribution+      , observationImplementation key == implementation+      ]++data PictureLayout = PictureLayout+  { pictureWidth :: !Double+  , pictureHeight :: !Double+  , picturePlotTop :: !Double+  , picturePlotBottom :: !Double+  , picturePanelWidth :: !Double+  , picturePanelLefts :: ![Double]+  }++pictureLayout :: PictureLayout+pictureLayout =+  PictureLayout+    { pictureWidth = 1280+    , pictureHeight = 720+    , picturePlotTop = 168+    , picturePlotBottom = 610+    , picturePanelWidth = 540+    , picturePanelLefts = [70, 670]+    }++renderSvg :: SizeBand -> [Int] -> Double -> [PicturePanel] -> String+renderSvg sizeBand pointCounts axisMaximum panels =+  unlines+    ( [ "<?xml version=\"1.0\" encoding=\"utf-8\"?>"+      , "<svg xmlns=\"http://www.w3.org/2000/svg\" viewBox=\"0 0 "+          <> coordinate (pictureWidth pictureLayout)+          <> " "+          <> coordinate (pictureHeight pictureLayout)+          <> "\" role=\"img\" aria-labelledby=\"title description\">"+      , "<title id=\"title\">" <> pictureTitle sizeBand <> "</title>"+      , "<desc id=\"description\">CPU construction time for Spade, cdt, delaunator, and Moonlight over the upstream Delaunay comparison fixtures. Lower lines are faster.</desc>"+      , "<defs>"+      , "  <pattern id=\"triangulation-mesh\" width=\"54\" height=\"46\" patternUnits=\"userSpaceOnUse\">"+      , "    <path d=\"M0 46L27 0L54 46ZM0 46L54 46M27 0L27 46\" fill=\"none\" stroke=\"rgb(255,140,0)\" stroke-width=\"0.7\"/>"+      , "  </pattern>"+      , "  <clipPath id=\"header-mesh-clip\"><rect x=\"955\" y=\"8\" width=\"290\" height=\"82\" rx=\"20\"/></clipPath>"+      , "</defs>"+      , "<rect width=\""+          <> coordinate (pictureWidth pictureLayout)+          <> "\" height=\""+          <> coordinate (pictureHeight pictureLayout)+          <> "\" fill=\"white\"/>"+      , "<rect x=\"955\" y=\"8\" width=\"290\" height=\"82\" fill=\"url(#triangulation-mesh)\" opacity=\"0.10\" clip-path=\"url(#header-mesh-clip)\"/>"+      , svgText 640 34 "middle" 24 "500" (pictureTitle sizeBand)+      , svgText 640 61 "middle" 13 "400" "Moonlight against Spade's construction referents · CPU time · lower is faster"+      ]+        <> renderLegend+        <> concat (zipWith (renderPanel pointCounts axisMaximum) (picturePanelLefts pictureLayout) panels)+        <> [ svgText 640 704 "middle" 11 "400" "Whiskers show tasty-bench's reported 2× standard-deviation spread."+           , "</svg>"+           ]+    )++pictureTitle :: SizeBand -> String+pictureTitle = \case+  Small -> "Moonlight Delaunay construction · small point sets"+  Big -> "Moonlight Delaunay construction · big point sets"++renderLegend :: [String]+renderLegend =+  concat+    ( zipWith+        renderLegendItem+        [105, 315, 560, 735, 940]+        allImplementations+    )++renderLegendItem :: Double -> Implementation -> [String]+renderLegendItem x implementation =+  [ "<g aria-label=\"" <> implementationLabel implementation <> "\">"+  , "  <line x1=\"" <> coordinate x <> "\" y1=\"101\" x2=\"" <> coordinate (x + 34) <> "\" y2=\"101\" stroke=\"" <> implementationColor implementation <> "\" stroke-width=\"" <> seriesStrokeWidth implementation <> "\"" <> seriesDash implementation <> "/>"+  , "  " <> renderMarker implementation (x + 17) 101+  , "  " <> svgText (x + 43) 105 "start" 12 "400" (implementationLabel implementation)+  , "</g>"+  ]++renderPanel :: [Int] -> Double -> Double -> PicturePanel -> [String]+renderPanel pointCounts axisMaximum panelLeft panel =+  [ "<g aria-label=\"" <> panelLabel <> "\">"+  , svgText (panelLeft + panelWidth / 2) 144 "middle" 15 "500" panelLabel+  ]+    <> concatMap (renderHorizontalGrid panelLeft panelWidth axisMaximum) [0 .. 5]+    <> concatMap (renderVerticalTick panelLeft panelWidth pointCounts) pointCounts+    <> [ "<rect x=\"" <> coordinate panelLeft <> "\" y=\"" <> coordinate plotTop <> "\" width=\"" <> coordinate panelWidth <> "\" height=\"" <> coordinate plotHeight <> "\" fill=\"none\" stroke=\"rgb(25,25,25)\" stroke-width=\"1\"/>"+       , svgText (panelLeft + panelWidth / 2) 664 "middle" 12 "400" "input size (points)"+       , "<text x=\"" <> coordinate (panelLeft - 55) <> "\" y=\"" <> coordinate (plotTop + plotHeight / 2) <> "\" text-anchor=\"middle\" font-family=\"Helvetica, Arial, sans-serif\" font-size=\"12\" fill=\"rgb(20,20,20)\" transform=\"rotate(-90 " <> coordinate (panelLeft - 55) <> " " <> coordinate (plotTop + plotHeight / 2) <> ")\">CPU time (ms)</text>"+       ]+    <> concatMap (renderSeries panelLeft panelWidth pointCounts axisMaximum) (picturePanelSeries panel)+    <> maybe+      []+      (renderAdvantageCallout panelLeft panelWidth pointCounts axisMaximum)+      (bestReportedSpreadAdvantage (picturePanelSeries panel))+    <> ["</g>"]+ where+  panelLabel = pointDistributionLabel (picturePanelDistribution panel)+  panelWidth = picturePanelWidth pictureLayout+  plotTop = picturePlotTop pictureLayout+  plotHeight = picturePlotBottom pictureLayout - plotTop++renderHorizontalGrid :: Double -> Double -> Double -> Int -> [String]+renderHorizontalGrid panelLeft panelWidth axisMaximum tickIndex =+  [ "<line x1=\"" <> coordinate panelLeft <> "\" y1=\"" <> coordinate y <> "\" x2=\"" <> coordinate (panelLeft + panelWidth) <> "\" y2=\"" <> coordinate y <> "\" stroke=\"rgb(170,170,170)\" stroke-width=\"0.7\" stroke-dasharray=\"2 4\"/>"+  , svgText (panelLeft - 10) (y + 4) "end" 11 "400" (axisLabel tickValue)+  ]+ where+  tickValue = axisMaximum * fromIntegral tickIndex / 5+  y = pictureY axisMaximum tickValue++renderVerticalTick :: Double -> Double -> [Int] -> Int -> [String]+renderVerticalTick panelLeft panelWidth pointCounts pointCount =+  [ "<line x1=\"" <> coordinate x <> "\" y1=\"610\" x2=\"" <> coordinate x <> "\" y2=\"616\" stroke=\"rgb(25,25,25)\" stroke-width=\"1\"/>"+  , svgText x 635 "middle" 11 "400" (pointCountLabel pointCount)+  ]+ where+  x = pictureX panelLeft panelWidth pointCounts pointCount++renderSeries :: Double -> Double -> [Int] -> Double -> PictureSeries -> [String]+renderSeries panelLeft panelWidth pointCounts axisMaximum series =+  [ "<g aria-label=\"" <> implementationLabel implementation <> "\">"+  , "  <polyline points=\"" <> unwords (observationPoint <$> observations) <> "\" fill=\"none\" stroke=\"" <> implementationColor implementation <> "\" stroke-width=\"" <> seriesStrokeWidth implementation <> "\" stroke-linecap=\"round\" stroke-linejoin=\"round\"" <> seriesDash implementation <> "/>"+  ]+    <> concatMap renderObservation observations+    <> ["</g>"]+ where+  implementation = pictureSeriesImplementation series+  observations = pictureSeriesObservations series+  observationPoint observation =+    coordinate (observationX observation) <> "," <> coordinate (observationY observation)+  observationX =+    pictureX panelLeft panelWidth pointCounts+      . pointCountValue+      . fixturePointCount+      . observationFixture+      . benchmarkKey+  observationY = pictureY axisMaximum . observationMeanMilliseconds+  renderObservation observation =+    [ "  <line x1=\"" <> coordinate x <> "\" y1=\"" <> coordinate upperY <> "\" x2=\"" <> coordinate x <> "\" y2=\"" <> coordinate lowerY <> "\" stroke=\"" <> implementationColor implementation <> "\" stroke-width=\"0.9\" opacity=\"0.48\"/>"+    , "  <line x1=\"" <> coordinate (x - 3) <> "\" y1=\"" <> coordinate upperY <> "\" x2=\"" <> coordinate (x + 3) <> "\" y2=\"" <> coordinate upperY <> "\" stroke=\"" <> implementationColor implementation <> "\" stroke-width=\"0.9\" opacity=\"0.48\"/>"+    , "  <line x1=\"" <> coordinate (x - 3) <> "\" y1=\"" <> coordinate lowerY <> "\" x2=\"" <> coordinate (x + 3) <> "\" y2=\"" <> coordinate lowerY <> "\" stroke=\"" <> implementationColor implementation <> "\" stroke-width=\"0.9\" opacity=\"0.48\"/>"+    , "  " <> renderMarker implementation x y+    ]+   where+    x = observationX observation+    y = observationY observation+    upperY = pictureY axisMaximum (observationUpperMilliseconds observation)+    lowerY = pictureY axisMaximum (observationLowerMilliseconds observation)++data ReportedSpreadAdvantage = ReportedSpreadAdvantage+  { advantagePointCount :: !Int+  , advantageMoonlight :: !BenchmarkObservation+  , advantageCompetitor :: !Implementation+  , advantageReduction :: !Double+  }++bestReportedSpreadAdvantage :: [PictureSeries] -> Maybe ReportedSpreadAdvantage+bestReportedSpreadAdvantage series = foldr selectLargerReduction Nothing reportedSpreadAdvantages+ where+  moonlightObservations =+    concatMap pictureSeriesObservations (filter ((== Moonlight) . pictureSeriesImplementation) series)+  spadeSeries =+    filter+      ((`elem` [Spade, SpadeHierarchy]) . pictureSeriesImplementation)+      series+  reportedSpreadAdvantages =+    [ ReportedSpreadAdvantage+        { advantagePointCount = pointCountValue (fixturePointCount moonlightFixture)+        , advantageMoonlight = moonlight+        , advantageCompetitor = pictureSeriesImplementation competitorSeries+        , advantageReduction = 1 - benchmarkMeanPicoseconds moonlight / benchmarkMeanPicoseconds competitor+        }+    | moonlight <- moonlightObservations+    , let moonlightFixture = observationFixture (benchmarkKey moonlight)+    , competitorSeries <- spadeSeries+    , competitor <- pictureSeriesObservations competitorSeries+    , fixturePointCount (observationFixture (benchmarkKey competitor)) == fixturePointCount moonlightFixture+    , benchmarkMeanPicoseconds moonlight + benchmarkSpreadPicoseconds moonlight+        < benchmarkMeanPicoseconds competitor - benchmarkSpreadPicoseconds competitor+    ]+  selectLargerReduction candidate = \case+    Nothing -> Just candidate+    Just incumbent ->+      Just+        ( if advantageReduction candidate > advantageReduction incumbent+            then candidate+            else incumbent+        )++renderAdvantageCallout :: Double -> Double -> [Int] -> Double -> ReportedSpreadAdvantage -> [String]+renderAdvantageCallout panelLeft panelWidth pointCounts axisMaximum advantage =+  [ "<g aria-label=\"Moonlight comparison highlight\">"+  , "  <line x1=\"" <> coordinate pointX <> "\" y1=\"" <> coordinate pointY <> "\" x2=\"" <> coordinate (labelX + 8) <> "\" y2=\"" <> coordinate (labelY + 18) <> "\" stroke=\"rgb(255,140,0)\" stroke-width=\"1.2\"/>"+  , "  <rect x=\"" <> coordinate labelX <> "\" y=\"" <> coordinate labelY <> "\" width=\"250\" height=\"38\" rx=\"6\" fill=\"white\" stroke=\"rgb(255,140,0)\" stroke-width=\"1.2\"/>"+  , "  " <> svgText (labelX + 10) (labelY + 16) "start" 11 "500" (show reductionPercent <> "% less time than " <> implementationLabel (advantageCompetitor advantage))+  , "  " <> svgText (labelX + 10) (labelY + 31) "start" 10 "400" (pointCountLabel (advantagePointCount advantage) <> " points · reported spreads do not overlap")+  , "</g>"+  ]+ where+  pointX = pictureX panelLeft panelWidth pointCounts (advantagePointCount advantage)+  pointY = pictureY axisMaximum (observationMeanMilliseconds (advantageMoonlight advantage))+  labelX = min (panelLeft + panelWidth - 258) (pointX + 28)+  labelY = max (picturePlotTop pictureLayout + 12) (pointY - 58)+  reductionPercent = round (100 * advantageReduction advantage) :: Int++implementationColor :: Implementation -> String+implementationColor = \case+  Spade -> "rgb(0,0,139)"+  SpadeHierarchy -> "rgb(139,0,139)"+  Cdt -> "rgb(178,34,34)"+  Delaunator -> "rgb(0,139,139)"+  Moonlight -> "rgb(255,140,0)"++seriesStrokeWidth :: Implementation -> String+seriesStrokeWidth = \case+  Moonlight -> "3.2"+  _ -> "2.0"++seriesDash :: Implementation -> String+seriesDash = \case+  SpadeHierarchy -> " stroke-dasharray=\"7 4\""+  _ -> ""++renderMarker :: Implementation -> Double -> Double -> String+renderMarker implementation x y =+  case implementation of+    Spade -> circle 3.2+    SpadeHierarchy ->+      "<path d=\"M " <> coordinate x <> " " <> coordinate (y - 4.3) <> " L " <> coordinate (x - 4.1) <> " " <> coordinate (y + 3.5) <> " L " <> coordinate (x + 4.1) <> " " <> coordinate (y + 3.5) <> " Z\" fill=\"white\" stroke=\"" <> color <> "\" stroke-width=\"1.6\"/>"+    Cdt ->+      "<rect x=\"" <> coordinate (x - 3.2) <> "\" y=\"" <> coordinate (y - 3.2) <> "\" width=\"6.4\" height=\"6.4\" fill=\"white\" stroke=\"" <> color <> "\" stroke-width=\"1.6\"/>"+    Delaunator ->+      "<path d=\"M " <> coordinate x <> " " <> coordinate (y - 4.2) <> " L " <> coordinate (x + 4.2) <> " " <> coordinate y <> " L " <> coordinate x <> " " <> coordinate (y + 4.2) <> " L " <> coordinate (x - 4.2) <> " " <> coordinate y <> " Z\" fill=\"white\" stroke=\"" <> color <> "\" stroke-width=\"1.6\"/>"+    Moonlight ->+      "<path d=\"M " <> coordinate x <> " " <> coordinate (y - 5.4) <> " L " <> coordinate (x + 1.7) <> " " <> coordinate (y - 1.7) <> " L " <> coordinate (x + 5.4) <> " " <> coordinate y <> " L " <> coordinate (x + 1.7) <> " " <> coordinate (y + 1.7) <> " L " <> coordinate x <> " " <> coordinate (y + 5.4) <> " L " <> coordinate (x - 1.7) <> " " <> coordinate (y + 1.7) <> " L " <> coordinate (x - 5.4) <> " " <> coordinate y <> " L " <> coordinate (x - 1.7) <> " " <> coordinate (y - 1.7) <> " Z\" fill=\"" <> color <> "\" stroke=\"white\" stroke-width=\"1\"/>"+ where+  color = implementationColor implementation+  circle radius =+    "<circle cx=\"" <> coordinate x <> "\" cy=\"" <> coordinate y <> "\" r=\"" <> coordinate radius <> "\" fill=\"white\" stroke=\"" <> color <> "\" stroke-width=\"1.6\"/>"++pictureX :: Double -> Double -> [Int] -> Int -> Double+pictureX panelLeft panelWidth pointCounts pointCount =+  case pointCounts of+    [] -> panelLeft+    firstCount : remainingCounts ->+      let minimumCount = firstCount+          maximumCount = foldr max firstCount remainingCounts+          countRange = maximumCount - minimumCount+       in if countRange == 0+            then panelLeft + panelWidth / 2+            else+              panelLeft+                + panelWidth+                  * fromIntegral (pointCount - minimumCount)+                  / fromIntegral countRange++pictureY :: Double -> Double -> Double+pictureY axisMaximum milliseconds =+  picturePlotBottom pictureLayout+    - plotHeight * min axisMaximum (max 0 milliseconds) / axisMaximum+ where+  plotHeight = picturePlotBottom pictureLayout - picturePlotTop pictureLayout++observationMeanMilliseconds :: BenchmarkObservation -> Double+observationMeanMilliseconds = picosecondsToMilliseconds . benchmarkMeanPicoseconds++observationUpperMilliseconds :: BenchmarkObservation -> Double+observationUpperMilliseconds observation =+  picosecondsToMilliseconds+    (benchmarkMeanPicoseconds observation + benchmarkSpreadPicoseconds observation)++observationLowerMilliseconds :: BenchmarkObservation -> Double+observationLowerMilliseconds observation =+  picosecondsToMilliseconds+    (max 0 (benchmarkMeanPicoseconds observation - benchmarkSpreadPicoseconds observation))++picosecondsToMilliseconds :: Double -> Double+picosecondsToMilliseconds picoseconds = picoseconds / 1.0e9++niceCeiling :: Double -> Double+niceCeiling value+  | value <= 0 = 1+  | otherwise = niceFraction * magnitude+ where+  magnitude = 10 ** fromIntegral (floor (logBase 10 value) :: Int)+  fraction = value / magnitude+  niceFraction+    | fraction <= 1 = 1+    | fraction <= 2 = 2+    | fraction <= 5 = 5+    | otherwise = 10++axisLabel :: Double -> String+axisLabel value+  | value >= 10 = showFFloat (Just 0) value ""+  | value >= 1 = showFFloat (Just 1) value ""+  | otherwise = showFFloat (Just 2) value ""++pointCountLabel :: Int -> String+pointCountLabel pointCount+  | pointCount `mod` 1000 == 0 = show (pointCount `div` 1000) <> "k"+  | otherwise = show pointCount++coordinate :: Double -> String+coordinate value = showFFloat (Just 1) value ""++svgText :: Double -> Double -> String -> Int -> String -> String -> String+svgText x y anchor fontSize fontWeight content =+  "<text x=\""+    <> coordinate x+    <> "\" y=\""+    <> coordinate y+    <> "\" text-anchor=\""+    <> anchor+    <> "\" font-family=\"Helvetica, Arial, sans-serif\" font-size=\""+    <> show fontSize+    <> "\" font-weight=\""+    <> fontWeight+    <> "\" fill=\"rgb(20,20,20)\">"+    <> content+    <> "</text>"

@@ -0,0 +1,260 @@+{-# LANGUAGE DeriveFoldable #-}+{-# LANGUAGE DeriveFunctor #-}+{-# LANGUAGE DeriveTraversable #-}+{-# LANGUAGE DerivingStrategies #-}++-- | Fixture descent, compatibility gluing, and the authoritative benchmark view.+module Moonlight.Triangulation.Bench.DelaunayCompare.Suite+  ( PreparedSuite+  , withPreparedSuite+  , preflightSuite+  , suiteBenchmarks+  , suiteAgreementMessage+  ) where++import Control.DeepSeq (force)+import Control.Exception (bracket, evaluate)+import Data.Bifunctor (first)+import Data.Either (lefts, rights)+import Data.Foldable (toList, traverse_)+import qualified Data.List.NonEmpty as NonEmpty+import qualified Data.Vector as Vector+import Moonlight.Triangulation.Bench.DelaunayCompare.Domain+import Moonlight.Triangulation.Bench.DelaunayCompare.Native+import Moonlight.Triangulation.BulkLoad (delaunayGeometry)+import Moonlight.Triangulation.Dcel (numInnerFaces, numVertices)+import Moonlight.Triangulation.Types (BuildError, Point (Point))+import Test.Tasty.Bench (Benchmark, bench, bgroup, nf, nfIO)++data NativeSections value = NativeSections+  { nativeSpadeSection :: !value+  , nativeSpadeHierarchySection :: !value+  , nativeCdtSection :: !value+  , nativeDelaunatorSection :: !value+  }+  deriving stock (Functor, Foldable, Traversable)++nativeImplementationSections :: NativeSections NativeImplementation+nativeImplementationSections =+  NativeSections+    { nativeSpadeSection = NativeSpade+    , nativeSpadeHierarchySection = NativeSpadeHierarchy+    , nativeCdtSection = NativeCdt+    , nativeDelaunatorSection = NativeDelaunator+    }++nativeSectionAt :: NativeImplementation -> NativeSections value -> value+nativeSectionAt implementation sections =+  case implementation of+    NativeSpade -> nativeSpadeSection sections+    NativeSpadeHierarchy -> nativeSpadeHierarchySection sections+    NativeCdt -> nativeCdtSection sections+    NativeDelaunator -> nativeDelaunatorSection sections++data PreparedFixture = PreparedFixture+  { preparedSpec :: !FixtureSpec+  , preparedMoonlightPoints :: !(Vector.Vector Point)+  , preparedNativeFixtures :: !(NativeSections NativeFixture)+  }++newtype PreparedSuite = PreparedSuite [PreparedFixture]++withPreparedSuite+  :: NativeApi+  -> (PreparedSuite -> IO (Either CompareObstruction result))+  -> IO (Either CompareObstruction result)+withPreparedSuite api action = do+  prepared <- prepareSuite api+  case prepared of+    Left obstruction -> pure (Left obstruction)+    Right suite -> bracket (pure suite) (releaseSuite api) action++prepareSuite :: NativeApi -> IO (Either CompareObstruction PreparedSuite)+prepareSuite api = do+  outcomes <- traverse (prepareFixture api) allFixtureSpecs+  case NonEmpty.nonEmpty (lefts outcomes) of+    Just obstructions -> do+      traverse_ (releasePreparedFixture api) (rights outcomes)+      pure (Left (ComparisonObstructions obstructions))+    Nothing -> pure (Right (PreparedSuite (rights outcomes)))++prepareFixture :: NativeApi -> FixtureSpec -> IO (Either CompareObstruction PreparedFixture)+prepareFixture api fixture = do+  generated <- generateCoordinates api fixture+  case generated of+    Left status -> pure (Left (FixtureGenerationFailed fixture status))+    Right coordinates -> do+      nativeFixtures <- prepareNativeFixtures api fixture coordinates+      pure $+        PreparedFixture+          fixture+          (Vector.map (uncurry Point) (generatedCoordinatePairs coordinates))+          <$> nativeFixtures++prepareNativeFixtures+  :: NativeApi+  -> FixtureSpec+  -> GeneratedCoordinates+  -> IO (Either CompareObstruction (NativeSections NativeFixture))+prepareNativeFixtures api fixture coordinates = do+  outcomes <- traverse prepareSection nativeImplementationSections+  case sequenceA outcomes of+    Right nativeFixtures -> pure (Right nativeFixtures)+    Left obstruction -> do+      traverse_ (releaseNativeFixture api) (rights (toList outcomes))+      pure (Left obstruction)+ where+  prepareSection implementation = do+    prepared <- prepareNativeFixture api implementation coordinates+    pure $+      first+        (preparationObstruction implementation)+        prepared++  preparationObstruction implementation failure =+    case failure of+      NativePreparationStatus status -> FixturePreparationFailed fixture implementation status+      NativePreparationReturnedNull -> NativePreparedNull fixture implementation++releaseSuite :: NativeApi -> PreparedSuite -> IO ()+releaseSuite api (PreparedSuite fixtures) =+  traverse_ (releasePreparedFixture api) fixtures++releasePreparedFixture :: NativeApi -> PreparedFixture -> IO ()+releasePreparedFixture api = releasePreparedNativeFixtures api . preparedNativeFixtures++releasePreparedNativeFixtures :: NativeApi -> NativeSections NativeFixture -> IO ()+releasePreparedNativeFixtures api = traverse_ (releaseNativeFixture api)++preflightSuite :: NativeApi -> PreparedSuite -> IO (Either CompareObstruction ())+preflightSuite api (PreparedSuite fixtures) = do+  outcomes <- traverse (preflightFixture api) fixtures+  pure $+    case NonEmpty.nonEmpty (lefts outcomes) of+      Just obstructions -> Left (ComparisonObstructions obstructions)+      Nothing -> Right ()++preflightFixture :: NativeApi -> PreparedFixture -> IO (Either CompareObstruction ())+preflightFixture api fixture = do+  moonlightResult <-+    evaluate+      ( force+          (moonlightConstructionSummary (preparedMoonlightPoints fixture))+      )+  nativeOutcomes <- traverse runSection nativeImplementationSections+  pure $ do+    moonlightSummary <-+      first+        (MoonlightConstructionFailed spec)+        moonlightResult+    nativeSummaries <- sequenceA nativeOutcomes+    traverse_+      ( \implementation ->+          requireSummaryAgreement+            spec+            moonlightSummary+            ( implementationOfNative implementation+            , nativeSectionAt implementation nativeSummaries+            )+      )+      nativeImplementationSections+ where+  spec = preparedSpec fixture+  nativeFixtures = preparedNativeFixtures fixture+  runSection implementation =+    first (NativeConstructionFailed spec implementation)+      <$> runNativeFixture api (nativeSectionAt implementation nativeFixtures)++requireSummaryAgreement+  :: FixtureSpec+  -> DelaunaySummary+  -> (Implementation, DelaunaySummary)+  -> Either CompareObstruction ()+requireSummaryAgreement fixture expected (implementation, observed) =+  if observed == expected+    then Right ()+    else Left (SummaryDisagreement fixture implementation expected observed)++moonlightConstructionSummary+  :: Vector.Vector Point+  -> Either BuildError DelaunaySummary+moonlightConstructionSummary points = do+  triangulation <- delaunayGeometry points+  pure+    DelaunaySummary+      { summaryVertexCount = numVertices triangulation+      , summaryTriangleCount = numInnerFaces triangulation+      }++suiteBenchmarks :: NativeApi -> PreparedSuite -> [Benchmark]+suiteBenchmarks api (PreparedSuite fixtures) =+  fmap (sizeBandBenchmarks api fixtures) allSizeBands++sizeBandBenchmarks+  :: NativeApi+  -> [PreparedFixture]+  -> SizeBand+  -> Benchmark+sizeBandBenchmarks api fixtures sizeBand =+  bgroup+    ("comparison: creation benchmark (" <> sizeBandLabel sizeBand <> ")")+    (fmap (implementationBenchmarks api fixtures sizeBand) allImplementations)++implementationBenchmarks+  :: NativeApi+  -> [PreparedFixture]+  -> SizeBand+  -> Implementation+  -> Benchmark+implementationBenchmarks api fixtures sizeBand implementation =+  bgroup+    (implementationLabel implementation)+    ( fmap+        (distributionBenchmarks api fixtures sizeBand implementation)+        allPointDistributions+    )++distributionBenchmarks+  :: NativeApi+  -> [PreparedFixture]+  -> SizeBand+  -> Implementation+  -> PointDistribution+  -> Benchmark+distributionBenchmarks api fixtures sizeBand implementation distribution =+  bgroup+    (pointDistributionLabel distribution)+    ( fmap+        (fixtureBenchmark api implementation)+        ( filter+            (matchesFixture sizeBand distribution . preparedSpec)+            fixtures+        )+    )++matchesFixture :: SizeBand -> PointDistribution -> FixtureSpec -> Bool+matchesFixture sizeBand distribution fixture =+  fixtureSizeBand fixture == sizeBand+    && fixturePointDistribution fixture == distribution++fixtureBenchmark :: NativeApi -> Implementation -> PreparedFixture -> Benchmark+fixtureBenchmark api implementation fixture =+  bench (show (pointCountValue (fixturePointCount (preparedSpec fixture)))) $+    case implementation of+      Moonlight -> nf moonlightConstructionSummary (preparedMoonlightPoints fixture)+      Spade -> nativeBenchmark NativeSpade+      SpadeHierarchy -> nativeBenchmark NativeSpadeHierarchy+      Cdt -> nativeBenchmark NativeCdt+      Delaunator -> nativeBenchmark NativeDelaunator+ where+  nativeFixtures = preparedNativeFixtures fixture+  nativeBenchmark nativeImplementation =+    nfIO (runNativeFixture api (nativeSectionAt nativeImplementation nativeFixtures))++suiteAgreementMessage :: String+suiteAgreementMessage =+  "delaunay-compare agreement: "+    <> show (length allFixtureSpecs)+    <> " fixtures agree on vertex and triangle counts across "+    <> show (length allImplementations)+    <> " implementations"

@@ -0,0 +1,75 @@+{-# LANGUAGE LambdaCase #-}+{-# LANGUAGE TypeApplications #-}++-- | Thin effect boundary for rendering benchmark receipts as SVG pictures.+module Main (main) where++import Control.Exception (IOException, displayException, try)+import Control.Monad.Trans.Except (ExceptT (ExceptT), except, runExceptT)+import Data.Bifunctor (first)+import Data.Foldable (traverse_)+import Moonlight.Triangulation.Bench.DelaunayCompare.Domain (allSizeBands)+import Moonlight.Triangulation.Bench.DelaunayCompare.Picture+import System.Directory (createDirectoryIfMissing)+import System.Environment (getArgs)+import System.Exit (die)+import System.FilePath ((</>))+import System.IO (readFile')++data PictureCommandFailure+  = PictureCommandUsage+  | PictureCommandReadFailed !FilePath !String+  | PictureCommandCreateDirectoryFailed !FilePath !String+  | PictureCommandReceiptObstructed !PictureObstruction+  | PictureCommandWriteFailed !FilePath !String++main :: IO ()+main = do+  arguments <- getArgs+  outcome <- runExceptT (runPictureCommand arguments)+  either (die . renderPictureCommandFailure) pure outcome++runPictureCommand :: [String] -> ExceptT PictureCommandFailure IO ()+runPictureCommand = \case+  [inputCsv, outputDirectory] -> do+    source <-+      ExceptT+        ( first+            (PictureCommandReadFailed inputCsv . displayException)+            <$> try @IOException (readFile' inputCsv)+        )+    receipt <- except (first PictureCommandReceiptObstructed (parseBenchmarkReceipt source))+    let pictures =+          ( \sizeBand ->+              (pictureFileName sizeBand, renderComparisonPicture sizeBand receipt)+          )+            <$> allSizeBands+    ExceptT+      ( first+          (PictureCommandCreateDirectoryFailed outputDirectory . displayException)+          <$> try @IOException (createDirectoryIfMissing True outputDirectory)+      )+    traverse_ (writePicture outputDirectory) pictures+  _ -> except (Left PictureCommandUsage)++writePicture :: FilePath -> (FilePath, String) -> ExceptT PictureCommandFailure IO ()+writePicture outputDirectory (fileName, svgDocument) =+  let outputPath = outputDirectory </> fileName+   in ExceptT+        ( first+            (PictureCommandWriteFailed outputPath . displayException)+            <$> try @IOException (writeFile outputPath svgDocument)+        )++renderPictureCommandFailure :: PictureCommandFailure -> String+renderPictureCommandFailure = \case+  PictureCommandUsage ->+    "usage: moonlight-triangulation-delaunay-pictures INPUT.csv OUTPUT_DIRECTORY"+  PictureCommandReadFailed path details ->+    "could not read benchmark CSV " <> path <> ": " <> details+  PictureCommandCreateDirectoryFailed path details ->+    "could not create picture directory " <> path <> ": " <> details+  PictureCommandReceiptObstructed obstruction ->+    renderPictureObstruction obstruction+  PictureCommandWriteFailed path details ->+    "could not write comparison picture " <> path <> ": " <> details

@@ -0,0 +1,183 @@+# Moonlight Delaunay Compare++`moonlight-triangulation-delaunay-compare` is Moonlight's package-owned port of Spade's+[`delaunay_compare`](https://github.com/Stoeoef/spade/tree/c8befc96bbbc1898a89cb19f9f3104a848936374/delaunay_compare)+construction suite. It retains the upstream case matrix and appends+`moonlight-triangulation` to the implementation list:++1. `spade 2`+2. `spade 2 hierarchy`+3. `cdt`+4. `delaunator`+5. `moonlight-triangulation`++Haskell owns fixture selection, grouping, compatibility descent, timing, and+reporting. The Rust library under `rust/src/lib.rs` is only a typed foreign+boundary to the four Rust implementations and to the exact upstream `rand`+fixture stream; it contains no benchmark policy.++This executable is the construction slice, not the package's overall+comparison. The [package benchmark overview](../../README.md#overall-moonlightspade-comparison)+also exposes insertion, removal, nearest-neighbour search, CDT recovery,+refinement, natural-neighbour interpolation, Voronoi, DCEL, and segment+traversal lanes.++## Pictures++Both pictures are derived from the single retained board.++![Small-point Delaunay construction comparison](results/moonlight-delaunay-compare-small.svg)++![Big-point Delaunay construction comparison](results/moonlight-delaunay-compare-big.svg)++These retain Spade's plain GNUPLOT idiom: white field, Helvetica, dashed grey+grid, jewel-coloured point series, and the same small/big split. Moonlight is+the heavier orange star. The faint triangulation mesh is the sole bit of+levity; benchmark charts need not resemble tax forms.++## Result++- timed cases: `120`+- fixture summaries agreeing across all five implementations: `24 / 24`+- Moonlight mean below plain Spade: `12 / 24`+- Moonlight mean below Spade hierarchy: `17 / 24`+- Moonlight below plain Spade with non-overlapping reported 2σ: `0 / 24`+- Moonlight below Spade hierarchy with non-overlapping reported 2σ: `1 / 24`+- lowest fixture mean: `delaunator` `23 / 24`; `cdt` `1 / 24`+- median reported 2σ / mean: Moonlight `7.86%`; plain Spade `6.74%`++Selected means are in milliseconds. Δ is+`100 × (Moonlight / competitor − 1)`.++| fixture | points | Moonlight | plain Spade | Δ | Spade hierarchy | Δ |+|---|---:|---:|---:|---:|---:|---:|+| local insertion | 4,000 | 0.663 | 0.748 | −11.3% | 0.784 | −15.4% |+| local insertion | 6,000 | 1.121 | 1.245 | −10.0% | 1.320 | −15.1% |+| local insertion | 8,000 | 1.552 | 1.736 | −10.6% | 1.824 | −14.9% |+| local insertion | 250,000 | 68.017 | 71.675 | −5.1% | 76.208 | −10.7% |+| uniform | 4,000 | 0.676 | 0.693 | −2.4% | 0.729 | −7.3% |+| uniform | 14,000 | 3.591 | 2.959 | +21.4% | 3.171 | +13.3% |+| uniform | 250,000 | 73.329 | 72.076 | +1.7% | 76.447 | −4.1% |++The measured Moonlight path is the canonical circle-sweep bulk loader. Its+local descent carries an already-read hull angle through candidate search,+rejects incompatible closure sections before paying for exact orientation,+and compiles the exact predicate and repair kernels at their LLVM `-O3`+boundary.++Receipt identity:++- command completed: `2026-08-17T10:39:30Z`, 297.39 s over 120 cases+- host: Apple M4 Pro, arm64, macOS 26.5.2, GHC 9.14.1, rustc 1.92.0+- Haskell build: Cabal `-O1` package profile, comparison executable `-O2`, hot+  predicate, sweep, and repair modules LLVM `-O3`+- checkout HEAD: `6da6feb1a6`, with seven modified files in the tree, none of+  them on the measured path+- CSV: [`moonlight-delaunay-compare-2026-08-17.csv`](results/moonlight-delaunay-compare-2026-08-17.csv), SHA-256+  `eba77eb960790f2e1cbe3f82c112e8690721de4e5aa3c69961925670e0822162`+- benchmark runtime-source hashes:+  [`moonlight-delaunay-compare-2026-08-17.source-sha256`](results/moonlight-delaunay-compare-2026-08-17.source-sha256)++The Haskell projection in+`Moonlight.Triangulation.Bench.DelaunayCompare.Picture` parses the tasty-bench+CSV against the exact closed 120-case registry and reports typed obstructions+for malformed, unknown, duplicated, or missing observations before gluing+either picture.++## Run++From the repository root, list the complete benchmark tree:++```console+scripts/safe-cabal.sh run \+  moonlight-triangulation:exe:moonlight-triangulation-delaunay-compare \+  -- --list-tests+```++Run the comparison on one uncontended thread with wall-clock timing:++```console+scripts/safe-cabal.sh run \+  moonlight-triangulation:exe:moonlight-triangulation-delaunay-compare \+  -- --time-mode wall -j1+```++The Haskell executable builds the pinned Rust library through Cargo before it+loads the library. Cargo's incremental no-op is cheap after the first run. Set+`MOONLIGHT_DELAUNAY_COMPARE_RUST_MANIFEST` only when invoking an installed executable+outside this repository layout.++## Reproduce a board++Every candidate run uses one CPU-time worker, a 30-second per-case timeout, and+tasty-bench's `--stdev 5` calibration target. Name the candidate by the date it+completed; after validation, it replaces the retained CSV and source manifest+rather than accumulating a benchmark diary.++```console+caffeinate -i scripts/safe-cabal.sh run \+  moonlight-triangulation:exe:moonlight-triangulation-delaunay-compare -- \+  --stdev 5 --timeout 30s --time-mode cpu -j1 \+  --csv foundation/moonlight-triangulation/bench/delaunay-compare/results/moonlight-delaunay-compare-YYYY-MM-DD.csv \+  --color never --hide-progress --min-duration-to-report 1h+```++Both pictures are then regenerated from the candidate CSV, which is the only+CSV they may be derived from:++```console+scripts/safe-cabal.sh run \+  moonlight-triangulation:exe:moonlight-triangulation-delaunay-pictures -- \+  foundation/moonlight-triangulation/bench/delaunay-compare/results/moonlight-delaunay-compare-YYYY-MM-DD.csv \+  foundation/moonlight-triangulation/bench/delaunay-compare/results+```++The runtime-source manifest beside the CSV is the list of files that entered+timed actions, hashed at run time; picture sources and package-only metadata+are excluded because they do not. The receipt and SVGs stay package-owned+beside the benchmark but are not Cabal package inputs, because taking a+measurement must not rebuild the triangulation library.++## Upstream-compatible fixtures++Both distributions use the 32-byte `StdRng` seed from upstream, including its+embedded newline byte. Rust unit tests pin the first three points of both+streams by their exact binary64 bit patterns.++- `local insertion` starts at `(0, 1)` and adds independent inclusive steps+  from `[-1, 1]`.+- `uniform` draws each coordinate independently and inclusively from+  `[-1e9, 1e9]`.+- `small` contains 2,000 through 14,000 points in increments of 2,000.+- `big` contains 50,000 through 250,000 points in increments of 50,000.++Native input conversion happens once during suite preparation, outside every+timed action, exactly as upstream's `DelaunayCrate.init` separates conversion+from `run_creation`. Spade still clones its owned vertex vector inside each+construction call because that is what its bulk-load API and upstream adapter+require; `cdt`, `delaunator`, and Moonlight consume their prepared vectors by+reference.++## Compatibility gate++Before `tasty-bench` runs, every one of the 24 fixtures descends across all five+implementations. The sections glue only when vertex and inner-triangle counts+agree. A generator, preparation, construction, foreign-boundary, or summary+failure is a typed obstruction and terminates the command before timing.++This count gate is deliberately not a second topology authority. The stronger+Moonlight-versus-Spade canonical-edge and operation agreement owner is the+[`spade-compare` operation suite](../spade-compare/README.md); use it when making semantic parity claims. This command answers+the narrower upstream question: bulk construction time over the upstream point+distributions and sizes.++The upstream `examples/real_data_benchmark.rs` CDT/shapefile program is a+separate executable and is not folded into this creation suite. No 45 MB dataset+or network fetch is concealed in benchmark startup.++## Harness difference++Upstream uses Rust Criterion. This port uses Haskell `tasty-bench`, so it does+not pretend Criterion's warm-up seconds or sample-count knobs map one-to-one to+another calibrator. The inputs, sizes, implementation calls, and timed/setup+boundary are preserved; calibration and reporting are honestly Haskell.

@@ -0,0 +1,264 @@+# This file is automatically @generated by Cargo.+# It is not intended for manual editing.+version = 4++[[package]]+name = "allocator-api2"+version = "0.2.21"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"++[[package]]+name = "autocfg"+version = "1.5.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"++[[package]]+name = "cdt"+version = "0.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b91b872294f63ef586b32aa94141561681aa35ca2d703960cca4f661f4e18184"+dependencies = [+ "geometry-predicates",+ "thiserror",+]++[[package]]+name = "cfg-if"+version = "1.0.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"++[[package]]+name = "delaunator"+version = "1.1.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3e1ee323c1275374f7e612d3724d12707079fb6a2117349fe144def656f5a880"+dependencies = [+ "robust",+]++[[package]]+name = "equivalent"+version = "1.0.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"++[[package]]+name = "foldhash"+version = "0.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "77ce24cb58228fbb8aa041425bb1050850ac19177686ea6e0f41a70416f56fdb"++[[package]]+name = "geometry-predicates"+version = "0.3.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8dba84198cf199c11b83f1cb9243eaeb70dc50b719d2835ebf34bf2481bca010"++[[package]]+name = "getrandom"+version = "0.3.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"+dependencies = [+ "cfg-if",+ "libc",+ "r-efi",+ "wasip2",+]++[[package]]+name = "hashbrown"+version = "0.16.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"+dependencies = [+ "allocator-api2",+ "equivalent",+ "foldhash",+]++[[package]]+name = "libc"+version = "0.2.189"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"++[[package]]+name = "moonlight-delaunay-compare-referents"+version = "0.1.0"+dependencies = [+ "cdt",+ "delaunator",+ "rand",+ "spade",+]++[[package]]+name = "num-traits"+version = "0.2.19"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"+dependencies = [+ "autocfg",+]++[[package]]+name = "ppv-lite86"+version = "0.2.21"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"+dependencies = [+ "zerocopy",+]++[[package]]+name = "proc-macro2"+version = "1.0.107"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"+dependencies = [+ "unicode-ident",+]++[[package]]+name = "quote"+version = "1.0.47"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"+dependencies = [+ "proc-macro2",+]++[[package]]+name = "r-efi"+version = "5.3.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"++[[package]]+name = "rand"+version = "0.9.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"+dependencies = [+ "rand_chacha",+ "rand_core",+]++[[package]]+name = "rand_chacha"+version = "0.9.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"+dependencies = [+ "ppv-lite86",+ "rand_core",+]++[[package]]+name = "rand_core"+version = "0.9.5"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"+dependencies = [+ "getrandom",+]++[[package]]+name = "robust"+version = "1.2.0"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4e27ee8bb91ca0adcf0ecb116293afa12d393f9c2b9b9cd54d33e8078fe19839"++[[package]]+name = "smallvec"+version = "1.15.2"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "8ed6a63f02c8539c91a8685a86f4099661ba3da017932f6ebbea6de3f0fa7c90"++[[package]]+name = "spade"+version = "2.15.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "9699399fd9349b00b184f5635b074f9ec93afffef30c853f8c875b32c0f8c7fa"+dependencies = [+ "hashbrown",+ "num-traits",+ "robust",+ "smallvec",+]++[[package]]+name = "syn"+version = "2.0.119"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"+dependencies = [+ "proc-macro2",+ "quote",+ "unicode-ident",+]++[[package]]+name = "thiserror"+version = "1.0.69"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"+dependencies = [+ "thiserror-impl",+]++[[package]]+name = "thiserror-impl"+version = "1.0.69"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]++[[package]]+name = "unicode-ident"+version = "1.0.24"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"++[[package]]+name = "wasip2"+version = "1.0.4+wasi-0.2.12"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"+dependencies = [+ "wit-bindgen",+]++[[package]]+name = "wit-bindgen"+version = "0.57.1"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"++[[package]]+name = "zerocopy"+version = "0.8.56"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "556764e583adb45a9f8d413c2a147fa7e8d821e48e12b14fd560b607998b75eb"+dependencies = [+ "zerocopy-derive",+]++[[package]]+name = "zerocopy-derive"+version = "0.8.56"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "f2ab42fc20575779bd240faa45f94a74256f755c0fa9e89f0ede20d91d0cdfc1"+dependencies = [+ "proc-macro2",+ "quote",+ "syn",+]

@@ -0,0 +1,20 @@+[workspace]++[package]+name = "moonlight-delaunay-compare-referents"+version = "0.1.0"+edition = "2021"++[lib]+name = "moonlight_delaunay_compare_referents"+crate-type = ["cdylib"]++[dependencies]+cdt = "0.1"+delaunator = "1.0.1"+rand = "0.9.1"+spade = "2.15"++[profile.release]+opt-level = 3+lto = "thin"

@@ -0,0 +1,397 @@+//! Rust referent boundary for Moonlight's Delaunay construction comparison.+//!+//! Fixture choice, benchmark grouping, agreement, timing, and reporting belong+//! to Haskell. This library retains only the operations that cannot move there:+//! Spade's exact seeded generator and direct calls into the Rust crates under+//! comparison.++use core::ffi::c_void;+use core::hint::black_box;+use core::ptr;+use rand::distr::{Distribution, Uniform};+use rand::rngs::StdRng;+use rand::SeedableRng;+use spade::{HierarchyHintGenerator, Point2, Triangulation};+use std::panic::{catch_unwind, AssertUnwindSafe};++const UPSTREAM_SEED: [u8; 32] = [+    0xfb, 0xdc, 0x4e, 0xa0, 0x30, 0xde, 0x82, 0xba, 0x69, 0x97, 0x3c, 0x52, 0x49, 0x4d, 0x00, 0xca,+    0x0a, 0x5c, 0x21, 0xa3, 0x8d, 0x5c, 0xf2, 0x34, 0x4e, 0x58, 0x7d, 0x80, 0x16, 0x66, 0x23, 0x30,+];++const UNIFORM_RANGE: f64 = 1.0e9;+const LOCAL_STEP_RANGE: f64 = 1.0;++type PlainSpade = spade::DelaunayTriangulation<Point2<f64>>;+type HierarchySpade =+    spade::DelaunayTriangulation<Point2<f64>, (), (), (), HierarchyHintGenerator<f64>>;++#[repr(i32)]+#[derive(Clone, Copy, Debug)]+enum BoundaryStatus {+    Success = 0,+    NullPointer = 1,+    UnknownTag = 2,+    CoordinateCountMismatch = 3,+    DistributionConstructionFailed = 4,+    TriangulationFailed = 5,+    Panicked = 6,+}++impl BoundaryStatus {+    const fn code(self) -> i32 {+        self as i32+    }+}++#[derive(Clone, Copy)]+enum PointDistribution {+    LocalInsertion,+    Uniform,+}++impl TryFrom<i32> for PointDistribution {+    type Error = BoundaryStatus;++    fn try_from(tag: i32) -> Result<Self, Self::Error> {+        match tag {+            0 => Ok(Self::LocalInsertion),+            1 => Ok(Self::Uniform),+            _ => Err(BoundaryStatus::UnknownTag),+        }+    }+}++#[derive(Clone, Copy)]+enum NativeImplementation {+    Spade,+    SpadeHierarchy,+    Cdt,+    Delaunator,+}++impl TryFrom<i32> for NativeImplementation {+    type Error = BoundaryStatus;++    fn try_from(tag: i32) -> Result<Self, Self::Error> {+        match tag {+            0 => Ok(Self::Spade),+            1 => Ok(Self::SpadeHierarchy),+            2 => Ok(Self::Cdt),+            3 => Ok(Self::Delaunator),+            _ => Err(BoundaryStatus::UnknownTag),+        }+    }+}++enum PreparedImplementation {+    Spade(Vec<Point2<f64>>),+    SpadeHierarchy(Vec<Point2<f64>>),+    Cdt(Vec<(f64, f64)>),+    Delaunator(Vec<delaunator::Point>),+}++#[derive(Clone, Copy)]+struct ConstructionSummary {+    vertices: usize,+    triangles: usize,+}++impl PreparedImplementation {+    fn from_coordinates(implementation: NativeImplementation, coordinates: &[[f64; 2]]) -> Self {+        match implementation {+            NativeImplementation::Spade => {+                Self::Spade(coordinates.iter().copied().map(Point2::from).collect())+            }+            NativeImplementation::SpadeHierarchy => {+                Self::SpadeHierarchy(coordinates.iter().copied().map(Point2::from).collect())+            }+            NativeImplementation::Cdt => {+                Self::Cdt(coordinates.iter().map(|[x, y]| (*x, *y)).collect())+            }+            NativeImplementation::Delaunator => Self::Delaunator(+                coordinates+                    .iter()+                    .map(|[x, y]| delaunator::Point { x: *x, y: *y })+                    .collect(),+            ),+        }+    }++    fn run(&self) -> Result<ConstructionSummary, BoundaryStatus> {+        match self {+            Self::Spade(vertices) => {+                let triangulation = PlainSpade::bulk_load(vertices.clone())+                    .map_err(|_| BoundaryStatus::TriangulationFailed)?;+                let summary = ConstructionSummary {+                    vertices: triangulation.num_vertices(),+                    triangles: triangulation.num_inner_faces(),+                };+                black_box(triangulation);+                Ok(summary)+            }+            Self::SpadeHierarchy(vertices) => {+                let triangulation = HierarchySpade::bulk_load(vertices.clone())+                    .map_err(|_| BoundaryStatus::TriangulationFailed)?;+                let summary = ConstructionSummary {+                    vertices: triangulation.num_vertices(),+                    triangles: triangulation.num_inner_faces(),+                };+                black_box(triangulation);+                Ok(summary)+            }+            Self::Cdt(vertices) => {+                let triangles = cdt::triangulate_points(vertices)+                    .map_err(|_| BoundaryStatus::TriangulationFailed)?;+                let summary = ConstructionSummary {+                    vertices: vertices.len(),+                    triangles: triangles.len(),+                };+                black_box(triangles);+                Ok(summary)+            }+            Self::Delaunator(vertices) => {+                let triangulation = delaunator::triangulate(vertices);+                let summary = ConstructionSummary {+                    vertices: vertices.len(),+                    triangles: triangulation.triangles.len() / 3,+                };+                black_box(triangulation);+                Ok(summary)+            }+        }+    }+}++fn boundary_status(action: impl FnOnce() -> Result<(), BoundaryStatus>) -> i32 {+    match catch_unwind(AssertUnwindSafe(action)) {+        Ok(Ok(())) => BoundaryStatus::Success.code(),+        Ok(Err(status)) => status.code(),+        Err(_) => BoundaryStatus::Panicked.code(),+    }+}++fn coordinate_count(point_count: usize) -> Result<usize, BoundaryStatus> {+    point_count+        .checked_mul(2)+        .ok_or(BoundaryStatus::CoordinateCountMismatch)+}++fn uniform_samples(point_count: usize) -> Result<impl Iterator<Item = [f64; 2]>, BoundaryStatus> {+    let distribution = Uniform::new_inclusive(-UNIFORM_RANGE, UNIFORM_RANGE)+        .map_err(|_| BoundaryStatus::DistributionConstructionFailed)?;+    let mut generator = StdRng::from_seed(UPSTREAM_SEED);+    Ok(core::iter::from_fn(move || {+        Some([+            distribution.sample(&mut generator),+            distribution.sample(&mut generator),+        ])+    })+    .take(point_count))+}++fn local_insertion_samples(+    point_count: usize,+) -> Result<impl Iterator<Item = [f64; 2]>, BoundaryStatus> {+    let distribution = Uniform::new_inclusive(-LOCAL_STEP_RANGE, LOCAL_STEP_RANGE)+        .map_err(|_| BoundaryStatus::DistributionConstructionFailed)?;+    let mut generator = StdRng::from_seed(UPSTREAM_SEED);+    let mut previous = [0.0, 1.0];+    Ok(core::iter::from_fn(move || {+        previous = [+            previous[0] + distribution.sample(&mut generator),+            previous[1] + distribution.sample(&mut generator),+        ];+        Some(previous)+    })+    .take(point_count))+}++fn write_coordinates(+    distribution: PointDistribution,+    point_count: usize,+    output: &mut [f64],+) -> Result<(), BoundaryStatus> {+    let expected_count = coordinate_count(point_count)?;+    if output.len() != expected_count {+        return Err(BoundaryStatus::CoordinateCountMismatch);+    }++    let samples: Box<dyn Iterator<Item = [f64; 2]>> = match distribution {+        PointDistribution::LocalInsertion => Box::new(local_insertion_samples(point_count)?),+        PointDistribution::Uniform => Box::new(uniform_samples(point_count)?),+    };++    output+        .chunks_exact_mut(2)+        .zip(samples)+        .for_each(|(coordinate_pair, [x, y])| {+            coordinate_pair.copy_from_slice(&[x, y]);+        });+    Ok(())+}++/// Fill `coordinates` with Spade's exact seeded benchmark distribution.+///+/// # Safety+///+/// A non-null `coordinates` pointer must be writable for `coordinate_count`+/// consecutive `f64` values.+#[no_mangle]+pub unsafe extern "C" fn delaunay_compare_generate(+    distribution_tag: i32,+    point_count: usize,+    coordinates: *mut f64,+    supplied_coordinate_count: usize,+) -> i32 {+    boundary_status(|| {+        let distribution = PointDistribution::try_from(distribution_tag)?;+        let expected_count = coordinate_count(point_count)?;+        if supplied_coordinate_count != expected_count {+            return Err(BoundaryStatus::CoordinateCountMismatch);+        }+        if coordinates.is_null() && supplied_coordinate_count != 0 {+            return Err(BoundaryStatus::NullPointer);+        }+        let output = if supplied_coordinate_count == 0 {+            &mut []+        } else {+            // SAFETY: the caller contract and checks above establish a non-null+            // writable region of exactly `supplied_coordinate_count` values.+            unsafe { core::slice::from_raw_parts_mut(coordinates, supplied_coordinate_count) }+        };+        write_coordinates(distribution, point_count, output)+    })+}++/// Prepare the implementation-specific native input outside the timed region.+///+/// # Safety+///+/// A non-null `coordinates` pointer must be readable for `2 * point_count`+/// consecutive `f64` values. `prepared_output` must be writable for one pointer.+#[no_mangle]+pub unsafe extern "C" fn delaunay_compare_prepare(+    implementation_tag: i32,+    coordinates: *const f64,+    point_count: usize,+    prepared_output: *mut *mut c_void,+) -> i32 {+    boundary_status(|| {+        let implementation = NativeImplementation::try_from(implementation_tag)?;+        if prepared_output.is_null() {+            return Err(BoundaryStatus::NullPointer);+        }+        let supplied_coordinate_count = coordinate_count(point_count)?;+        if coordinates.is_null() && supplied_coordinate_count != 0 {+            return Err(BoundaryStatus::NullPointer);+        }+        let flat_coordinates = if supplied_coordinate_count == 0 {+            &[]+        } else {+            // SAFETY: the caller contract and checks above establish a non-null+            // readable region of exactly `supplied_coordinate_count` values.+            unsafe { core::slice::from_raw_parts(coordinates, supplied_coordinate_count) }+        };+        let coordinate_pairs = flat_coordinates.as_chunks::<2>().0;+        let prepared = PreparedImplementation::from_coordinates(implementation, coordinate_pairs);+        // SAFETY: `prepared_output` was checked non-null and points to writable+        // storage for one opaque pointer by the caller contract.+        unsafe {+            ptr::write(prepared_output, Box::into_raw(Box::new(prepared)).cast());+        }+        Ok(())+    })+}++/// Construct one triangulation from a prepared native input.+///+/// # Safety+///+/// `prepared` must be a live pointer returned by `delaunay_compare_prepare`.+/// Both output pointers must be writable for one `usize`.+#[no_mangle]+pub unsafe extern "C" fn delaunay_compare_run(+    prepared: *const c_void,+    vertex_count_output: *mut usize,+    triangle_count_output: *mut usize,+) -> i32 {+    boundary_status(|| {+        if prepared.is_null() || vertex_count_output.is_null() || triangle_count_output.is_null() {+            return Err(BoundaryStatus::NullPointer);+        }+        // SAFETY: the caller contract requires a live pointer produced by the+        // matching prepare function and keeps it alive for this call.+        let prepared_implementation = unsafe { &*prepared.cast::<PreparedImplementation>() };+        let summary = prepared_implementation.run()?;+        // SAFETY: both output pointers were checked non-null and the caller+        // contract gives writable storage for one value at each address.+        unsafe {+            ptr::write(vertex_count_output, summary.vertices);+            ptr::write(triangle_count_output, summary.triangles);+        }+        Ok(())+    })+}++/// Release one prepared native input. A null pointer is a no-op.+///+/// # Safety+///+/// A non-null pointer must have been returned by `delaunay_compare_prepare`+/// and must not have been released before.+#[no_mangle]+pub unsafe extern "C" fn delaunay_compare_release(prepared: *mut c_void) {+    if !prepared.is_null() {+        // SAFETY: the caller contract transfers the one remaining ownership of+        // the allocation produced by `Box::into_raw` in the prepare function.+        unsafe {+            drop(Box::from_raw(prepared.cast::<PreparedImplementation>()));+        }+    }+}++#[cfg(test)]+mod tests {+    use super::{local_insertion_samples, uniform_samples};++    #[test]+    fn local_insertion_prefix_matches_upstream_fixture_bits() {+        let observed = local_insertion_samples(3)+            .expect("the fixed local-insertion distribution is valid")+            .flatten()+            .map(f64::to_bits)+            .collect::<Vec<_>>();+        assert_eq!(+            observed,+            [+                0xbfe28b04856ac6db,+                0x3ff8c718b563a19a,+                0x3fc014ab09d22a14,+                0x4003a1ee45dc4712,+                0xbfd097c41d82adc4,+                0x4008d420538d5c3d,+            ]+        );+    }++    #[test]+    fn uniform_prefix_matches_upstream_fixture_bits() {+        let observed = uniform_samples(3)+            .expect("the fixed uniform distribution is valid")+            .flatten()+            .map(f64::to_bits)+            .collect::<Vec<_>>();+        assert_eq!(+            observed,+            [+                0xc1c1450134a5bd5a,+                0x41c0598b1e249a72,+                0x41c5037dbf1c0b38,+                0x41cafc1cf53845c8,+                0xc1b6f1036f0b1386,+                0x41c35b5d4df8b356,+            ]+        );+    }+}

@@ -18,8 +18,9 @@ import Data.Word (Word64) import qualified Data.Vector as V import GHC.Clock (getMonotonicTimeNSec)+import GHC.Conc.Sync (getAllocationCounter) import GHC.Stats-  ( RTSStats (allocated_bytes, max_live_bytes)+  ( RTSStats (max_live_bytes)   , getRTSStats   , getRTSStatsEnabled   )@@ -40,24 +41,33 @@ -- on one capability the two agree, and where they diverge the ratio is the -- parallelism actually obtained. Reporting CPU alone, as this did, would let a -- change that halves elapsed time and doubles total work read as a regression.+-- Allocation comes from the per-thread counter, not from @RTSStats@. The RTS+-- field is only refreshed at a collection, so a lane whose whole allocation+-- fits between two GCs reports a delta of exactly zero — the instrument+-- saturates at the bottom and reads as a perfect result. The thread counter is+-- block-granular and monotone, so a lane that allocates less says so.+--+-- @max_live_bytes@ is left as the RTS reports it and is a whole-process running+-- maximum sampled at major collections, never this lane's residency. Read it+-- as the watermark up to here, and only against a run with the same GC+-- schedule; @-G1@ is what makes two schedules comparable. timedValue :: NFData value => String -> IO value -> IO value timedValue label action = do   statsEnabled <- getRTSStatsEnabled-  before <- if statsEnabled then Just <$> getRTSStats else pure Nothing+  allocationStart <- getAllocationCounter   wallStart <- getMonotonicTimeNSec   cpuStart <- getCPUTime   value <- action >>= evaluate . force   cpuEnd <- getCPUTime   wallEnd <- getMonotonicTimeNSec+  allocationEnd <- getAllocationCounter   after <- if statsEnabled then Just <$> getRTSStats else pure Nothing   putStrLn (label <> "-elapsed: " <> show (fromIntegral (wallEnd - wallStart) / 1.0e9 :: Double) <> "s")   putStrLn (label <> "-cpu: " <> show (fromIntegral (cpuEnd - cpuStart) / 1.0e12 :: Double) <> "s")-  case (before, after) of-    (Just left, Just right) ->-      do-        putStrLn (label <> "-allocated-bytes: " <> show (allocated_bytes right - allocated_bytes left))-        putStrLn (label <> "-max-live-bytes: " <> show (max_live_bytes right))-    _ -> pure ()+  putStrLn (label <> "-allocated-bytes: " <> show (allocationStart - allocationEnd))+  case after of+    Just right -> putStrLn (label <> "-process-max-live-bytes: " <> show (max_live_bytes right))+    Nothing -> pure ()   pure value  requireRight :: Show error => Either error value -> IO value

@@ -1,55 +1,91 @@ # Foreign bindings -`moonlight-triangulation.cabal` owns a private Haskell `ffi` sublibrary and the+`moonlight-triangulation.cabal` owns the private Haskell `ffi` sublibrary and `moonlight-triangulation-c` foreign library. Python, TypeScript, and Rust are-leaf bindings over that sole C ABI; none restates the engine or mesh.+thin lifecycle and bulk-layout leaves over that sole ABI; none implements+triangulation, overlay, publication, valuation, or morphology.  From `compiler`, build and locate the shared library:  ```bash-cabal build moonlight-triangulation:flib:moonlight-triangulation-c --enable-shared --project-file=cabal.project.triangulation-dev-cabal list-bin moonlight-triangulation:flib:moonlight-triangulation-c --enable-shared --project-file=cabal.project.triangulation-dev+../scripts/safe-cabal.sh build \+  moonlight-triangulation:flib:moonlight-triangulation-c \+  --project-file=cabal.project.triangulation-dev --enable-shared -j1+cabal list-bin moonlight-triangulation:flib:moonlight-triangulation-c \+  --project-file=cabal.project.triangulation-dev --enable-shared ```  Set `MOONLIGHT_TRIANGULATION_LIBRARY` to that `.dylib`, `.so`, or `.dll`; Rust linking also reads its directory from `MOONLIGHT_TRIANGULATION_LIB_DIR`. -The ABI accepts interleaved binary64 coordinates and publishes opaque immutable-mesh handles. Set operations and batch insertion return new handles, leaving-inputs valid until freed. Dense vertices and triangles follow vertex-handle and-bounded-face-handle order. Every status-returning call accepts an optional-`ml_obstruction` distinguishing API misuse, capacity refusal, geometric-obstruction, and runtime failure, with retained index, value, coordinate, and-message witnesses. `UINT64_MAX` means no input index applies.+## ABI version 2 -Batch related edits into one `insert_many` call; each call publishes a new mesh,-so repeated singleton calls pay repeated publication costs.+Three opaque immutable carriers cross the boundary: -`ml_runtime_initialize` is idempotent and process-lifetime. There is no shutdown-call because GHC cannot reliably restart after its outermost `hs_exit`.+- `ml_mesh` retains a binary64 Delaunay mesh. Its `ml_mesh_site_*` algebra+  combines sites, not polygon interiors.+- `ml_region` retains the authoritative exact rational `PlanarRegion`.+  `ml_region_create_f64` admits every input coordinate exactly as its binary64+  dyadic value in one call, using point counts per loop and loop counts per+  component. The inverse bulk projection returns component/loop offsets and+  binary64 rendering points; it does not replace the exact retained geometry.+- `ml_structuring_element` retains one admitted origin-containing convex+  polygon for repeated offset, inset, opening, and closing calls. +Region union, intersection, difference, and symmetric difference call the one+Haskell overlay and grouped-publication path. Point location is exact. A single+valuation call returns Euler characteristic, exact reduced area as+`numerator/denominator`, and certified conventional-perimeter bounds. Morphology+returns a new region plus the existing operation/work receipt.++Every status-returning call accepts an optional `ml_obstruction` distinguishing+pointer/count/buffer failures from region layout, validation, overlay,+publication, valuation, projection, morphology, and runtime failures. Handles+remain valid until explicitly freed; every operation publishes a fresh output+handle. `ml_runtime_initialize` is idempotent and process-lifetime.++Batch related mesh edits into one `insert_many` call. Author a whole region with+one component list; there is deliberately no mutable builder or per-vertex FFI+surface.+ ## Python  ```python-from moonlight_triangulation import Moonlight-mesh = Moonlight().delaunay([(0, 0), (1, 0), (0, 1)])-print(mesh.vertices, mesh.triangles)-mesh.close()+from fractions import Fraction+from moonlight_triangulation import Moonlight, PolygonComponent++moonlight = Moonlight()+left = moonlight.region([+    PolygonComponent(((0, 0), (2, 0), (2, 2), (0, 2)))+])+right = moonlight.region([+    PolygonComponent(((1, 0), (3, 0), (3, 2), (1, 2)))+])+intersection = left.intersection(right)+assert intersection.valuations.area == Fraction(2, 1) ```  ## TypeScript  ```typescript-import { Moonlight } from "@moonlight/triangulation";-const mesh = new Moonlight().delaunay([[0, 0], [1, 0], [0, 1]]);-console.log(mesh.vertices(), mesh.triangles());-mesh.close();+import { Moonlight, RegionLocation } from "@moonlight/triangulation";++const moonlight = new Moonlight();+const region = moonlight.region([+  { outer: [[0, 0], [2, 0], [2, 2], [0, 2]] },+]);+console.log(region.valuations().area, region.locate([1, 1]) === RegionLocation.Interior); ```  ## Rust  ```rust-use moonlight_triangulation::Moonlight;-let mesh = Moonlight::initialize()?.delaunay(&[[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]])?;-println!("{:?} {:?}", mesh.vertices()?, mesh.triangles()?);+use moonlight_triangulation::{Moonlight, PolygonComponent};++let moonlight = Moonlight::initialize()?;+let region = moonlight.region(&[PolygonComponent {+    outer: vec![[0.0, 0.0], [2.0, 0.0], [2.0, 2.0], [0.0, 2.0]],+    holes: vec![],+}])?;+println!("{:?}", region.valuations()?.area); ```

@@ -4,8 +4,8 @@  [project] name = "moonlight-triangulation"-version = "1.0.0"-description = "Python bindings for Moonlight's immutable Delaunay mesh algebra."+version = "2.0.0"+description = "Python bindings for Moonlight exact regions and immutable Delaunay meshes." requires-python = ">=3.11" license = { text = "MIT" } 

@@ -3,9 +3,13 @@ import ctypes import os import weakref-from collections.abc import Callable, Sequence+from array import array+from collections.abc import Callable, Iterable, Sequence+from dataclasses import dataclass+from enum import IntEnum+from fractions import Fraction from pathlib import Path-from typing import Final+from typing import Final, Self   class _Obstruction(ctypes.Structure):@@ -23,6 +27,21 @@     ]  +class _NativeMinkowskiReceipt(ctypes.Structure):+    _fields_ = [+        ("operation", ctypes.c_uint32),+        ("reserved", ctypes.c_uint32),+        ("input_components", ctypes.c_uint64),+        ("convex_pieces", ctypes.c_uint64),+        ("generated_pieces", ctypes.c_uint64),+        ("generated_convolution_edges", ctypes.c_uint64),+        ("overlay_passes", ctypes.c_uint64),+        ("exact_crossings", ctypes.c_uint64),+        ("output_cells", ctypes.c_uint64),+        ("exact_coordinate_bit_growth", ctypes.c_uint64),+    ]++ class MoonlightError(RuntimeError):     def __init__(self, status: int, obstruction: _Obstruction) -> None:         self.status = status@@ -40,32 +59,94 @@  class _NativeApi:     _OK: Final = 0+    _ABI_VERSION: Final = 2      def __init__(self, library_path: Path) -> None:         library = ctypes.CDLL(str(library_path))-        mesh = ctypes.c_void_p-        mesh_output = ctypes.POINTER(mesh)+        handle = ctypes.c_void_p+        handle_output = ctypes.POINTER(handle)         obstruction = ctypes.POINTER(_Obstruction)         count_output = ctypes.POINTER(ctypes.c_size_t)+        receipt_output = ctypes.POINTER(_NativeMinkowskiReceipt)+        binary_operation = (handle, handle, handle_output, obstruction)+        morphology_operation = (handle, handle, handle_output, receipt_output, obstruction)+         _configure(library, "ml_abi_version", ())         _configure(library, "ml_runtime_initialize", ())-        _configure(library, "ml_delaunay_f64", (ctypes.POINTER(ctypes.c_double), ctypes.c_size_t, mesh_output, obstruction))-        _configure(library, "ml_mesh_insert_many_f64", (mesh, ctypes.POINTER(ctypes.c_double), ctypes.c_size_t, mesh_output, obstruction))-        _configure(library, "ml_mesh_union", (mesh, mesh, mesh_output, obstruction))-        _configure(library, "ml_mesh_intersection", (mesh, mesh, mesh_output, obstruction))-        _configure(library, "ml_mesh_difference", (mesh, mesh, mesh_output, obstruction))-        _configure(library, "ml_mesh_symmetric_difference", (mesh, mesh, mesh_output, obstruction))-        _configure(library, "ml_mesh_vertex_count", (mesh, count_output, obstruction))-        _configure(library, "ml_mesh_triangle_count", (mesh, count_output, obstruction))-        _configure(library, "ml_mesh_copy_vertices_f64", (mesh, ctypes.POINTER(ctypes.c_double), ctypes.c_size_t, count_output, obstruction))-        _configure(library, "ml_mesh_copy_triangles_u32", (mesh, ctypes.POINTER(ctypes.c_uint32), ctypes.c_size_t, count_output, obstruction))-        _configure(library, "ml_mesh_free", (mesh,), None)+        _configure(library, "ml_delaunay_f64", (ctypes.POINTER(ctypes.c_double), ctypes.c_size_t, handle_output, obstruction))+        _configure(library, "ml_mesh_insert_many_f64", (handle, ctypes.POINTER(ctypes.c_double), ctypes.c_size_t, handle_output, obstruction))+        _configure(library, "ml_mesh_site_union", binary_operation)+        _configure(library, "ml_mesh_site_intersection", binary_operation)+        _configure(library, "ml_mesh_site_difference", binary_operation)+        _configure(library, "ml_mesh_site_symmetric_difference", binary_operation)+        _configure(library, "ml_mesh_vertex_count", (handle, count_output, obstruction))+        _configure(library, "ml_mesh_triangle_count", (handle, count_output, obstruction))+        _configure(library, "ml_mesh_copy_vertices_f64", (handle, ctypes.POINTER(ctypes.c_double), ctypes.c_size_t, count_output, obstruction))+        _configure(library, "ml_mesh_copy_triangles_u32", (handle, ctypes.POINTER(ctypes.c_uint32), ctypes.c_size_t, count_output, obstruction))+        _configure(library, "ml_mesh_free", (handle,), None) +        _configure(+            library,+            "ml_region_create_f64",+            (+                ctypes.POINTER(ctypes.c_double),+                ctypes.c_size_t,+                ctypes.POINTER(ctypes.c_size_t),+                ctypes.c_size_t,+                ctypes.POINTER(ctypes.c_size_t),+                ctypes.c_size_t,+                handle_output,+                obstruction,+            ),+        )+        _configure(library, "ml_region_counts", (handle, count_output, count_output, count_output, obstruction))+        _configure(+            library,+            "ml_region_copy_f64",+            (+                handle,+                ctypes.POINTER(ctypes.c_double),+                ctypes.c_size_t,+                ctypes.POINTER(ctypes.c_size_t),+                ctypes.c_size_t,+                ctypes.POINTER(ctypes.c_size_t),+                ctypes.c_size_t,+                obstruction,+            ),+        )+        _configure(library, "ml_region_union", binary_operation)+        _configure(library, "ml_region_intersection", binary_operation)+        _configure(library, "ml_region_difference", binary_operation)+        _configure(library, "ml_region_symmetric_difference", binary_operation)+        _configure(library, "ml_region_locate_point_f64", (handle, ctypes.c_double, ctypes.c_double, ctypes.POINTER(ctypes.c_uint32), obstruction))+        _configure(+            library,+            "ml_region_measure",+            (+                handle,+                ctypes.POINTER(ctypes.c_int64),+                ctypes.POINTER(ctypes.c_char),+                ctypes.c_size_t,+                count_output,+                ctypes.POINTER(ctypes.c_double),+                ctypes.POINTER(ctypes.c_double),+                obstruction,+            ),+        )+        _configure(library, "ml_region_free", (handle,), None)+        _configure(library, "ml_structuring_element_create_f64", (ctypes.POINTER(ctypes.c_double), ctypes.c_size_t, handle_output, obstruction))+        _configure(library, "ml_structuring_element_free", (handle,), None)+        _configure(library, "ml_region_minkowski_sum", morphology_operation)+        _configure(library, "ml_region_offset", morphology_operation)+        _configure(library, "ml_region_inset", morphology_operation)+        _configure(library, "ml_region_open", morphology_operation)+        _configure(library, "ml_region_close", morphology_operation)+         status = int(library.ml_runtime_initialize())         if status != self._OK:             raise RuntimeError(f"Moonlight runtime initialization failed with status {status}")         abi_version = int(library.ml_abi_version())-        if abi_version != 1:+        if abi_version != self._ABI_VERSION:             raise RuntimeError(f"unsupported Moonlight ABI version {abi_version}")         self.library = library @@ -77,8 +158,48 @@ Point = tuple[float, float] Triangle = tuple[int, int, int] _BinaryNativeOperation = Callable[[ctypes.c_void_p, ctypes.c_void_p, object, object], int]+_MorphologyNativeOperation = Callable[[ctypes.c_void_p, ctypes.c_void_p, object, object, object], int]  +@dataclass(frozen=True)+class PolygonComponent:+    outer: tuple[Point, ...]+    holes: tuple[tuple[Point, ...], ...] = ()+++class RegionLocation(IntEnum):+    EXTERIOR = 0+    BOUNDARY = 1+    INTERIOR = 2+++class MinkowskiOperation(IntEnum):+    ADDITION = 0+    EROSION = 1+    OPENING = 2+    CLOSING = 3+++@dataclass(frozen=True)+class RegionValuations:+    euler_characteristic: int+    area: Fraction+    perimeter_bounds: tuple[float, float]+++@dataclass(frozen=True)+class MinkowskiReceipt:+    operation: MinkowskiOperation+    input_components: int+    convex_pieces: int+    generated_pieces: int+    generated_convolution_edges: int+    overlay_passes: int+    exact_crossings: int+    output_cells: int+    exact_coordinate_bit_growth: int++ class Moonlight:     def __init__(self, library_path: str | os.PathLike[str] | None = None) -> None:         configured_path = library_path or os.environ.get("MOONLIGHT_TRIANGULATION_LIBRARY")@@ -88,38 +209,82 @@      def delaunay(self, points: Sequence[Point]) -> Mesh:         coordinates, pointer = _coordinate_buffer(points)-        output = ctypes.c_void_p()-        obstruction = _Obstruction()-        status = int(-            self._native.library.ml_delaunay_f64(-                pointer,-                len(points),-                ctypes.byref(output),-                ctypes.byref(obstruction),-            )+        handle = _produce_handle(+            self._native,+            lambda output, obstruction: self._native.library.ml_delaunay_f64(+                pointer, len(points), output, obstruction+            ),         )-        self._native.check(status, obstruction)-        return Mesh(self._native, _required_handle(output))+        return Mesh(self._native, handle) +    def region(self, components: Sequence[PolygonComponent]) -> Region:+        loops, loop_counts, component_counts = _component_layout(components)+        coordinates, coordinate_pointer = _coordinate_buffer(+            point for loop in loops for point in loop+        )+        loop_buffer = _size_buffer(loop_counts)+        component_buffer = _size_buffer(component_counts)+        handle = _produce_handle(+            self._native,+            lambda output, obstruction: self._native.library.ml_region_create_f64(+                coordinate_pointer,+                sum(loop_counts),+                loop_buffer,+                len(loop_counts),+                component_buffer,+                len(component_counts),+                output,+                obstruction,+            ),+        )+        return Region(self._native, handle) -class Mesh:-    __slots__ = ("_native", "_handle", "_finalizer", "__weakref__")+    def structuring_element(self, points: Sequence[Point]) -> StructuringElement:+        coordinates, pointer = _coordinate_buffer(points)+        handle = _produce_handle(+            self._native,+            lambda output, obstruction: self._native.library.ml_structuring_element_create_f64(+                pointer, len(points), output, obstruction+            ),+        )+        return StructuringElement(self._native, handle) -    def __init__(self, native: _NativeApi, handle: ctypes.c_void_p) -> None:++class _OwnedHandle:+    __slots__ = ("_native", "_handle", "_finalizer", "_kind", "__weakref__")++    def __init__(self, native: _NativeApi, handle: ctypes.c_void_p, free: Callable[[ctypes.c_void_p], None], kind: str) -> None:         self._native = native         self._handle = handle-        self._finalizer = weakref.finalize(self, native.library.ml_mesh_free, handle)+        self._kind = kind+        self._finalizer = weakref.finalize(self, free, handle)      def close(self) -> None:         self._finalizer()         self._handle = ctypes.c_void_p() -    def __enter__(self) -> Mesh:+    def __enter__(self) -> Self:         return self      def __exit__(self, _type: object, _value: object, _traceback: object) -> None:         self.close() +    def _live_handle(self) -> ctypes.c_void_p:+        if not self._finalizer.alive:+            raise RuntimeError(f"{self._kind} is closed")+        return self._handle++    def _require_same_runtime(self, other: _OwnedHandle) -> None:+        if self._native is not other._native:+            raise ValueError("both values must belong to the same Moonlight runtime")+++class Mesh(_OwnedHandle):+    __slots__ = ()++    def __init__(self, native: _NativeApi, handle: ctypes.c_void_p) -> None:+        super().__init__(native, handle, native.library.ml_mesh_free, "mesh")+     @property     def vertex_count(self) -> int:         return self._count(self._native.library.ml_mesh_vertex_count)@@ -136,11 +301,7 @@         obstruction = _Obstruction()         status = int(             self._native.library.ml_mesh_copy_vertices_f64(-                self._live_handle(),-                output,-                count,-                ctypes.byref(written),-                ctypes.byref(obstruction),+                self._live_handle(), output, count, ctypes.byref(written), ctypes.byref(obstruction)             )         )         self._native.check(status, obstruction)@@ -154,11 +315,7 @@         obstruction = _Obstruction()         status = int(             self._native.library.ml_mesh_copy_triangles_u32(-                self._live_handle(),-                output,-                count,-                ctypes.byref(written),-                ctypes.byref(obstruction),+                self._live_handle(), output, count, ctypes.byref(written), ctypes.byref(obstruction)             )         )         self._native.check(status, obstruction)@@ -169,72 +326,279 @@      def insert_many(self, points: Sequence[Point]) -> Mesh:         coordinates, pointer = _coordinate_buffer(points)-        output = ctypes.c_void_p()+        handle = _produce_handle(+            self._native,+            lambda output, obstruction: self._native.library.ml_mesh_insert_many_f64(+                self._live_handle(), pointer, len(points), output, obstruction+            ),+        )+        return Mesh(self._native, handle)++    def site_union(self, other: Mesh) -> Mesh:+        return self._binary(other, self._native.library.ml_mesh_site_union)++    def site_intersection(self, other: Mesh) -> Mesh:+        return self._binary(other, self._native.library.ml_mesh_site_intersection)++    def site_difference(self, other: Mesh) -> Mesh:+        return self._binary(other, self._native.library.ml_mesh_site_difference)++    def site_symmetric_difference(self, other: Mesh) -> Mesh:+        return self._binary(other, self._native.library.ml_mesh_site_symmetric_difference)++    def _binary(self, other: Mesh, operation: _BinaryNativeOperation) -> Mesh:+        self._require_same_runtime(other)+        handle = _produce_handle(+            self._native,+            lambda output, obstruction: operation(+                self._live_handle(), other._live_handle(), output, obstruction+            ),+        )+        return Mesh(self._native, handle)++    def _count(self, operation: Callable[[ctypes.c_void_p, object, object], int]) -> int:+        output = ctypes.c_size_t()         obstruction = _Obstruction()+        status = int(operation(self._live_handle(), ctypes.byref(output), ctypes.byref(obstruction)))+        self._native.check(status, obstruction)+        return int(output.value)+++class Region(_OwnedHandle):+    __slots__ = ()++    def __init__(self, native: _NativeApi, handle: ctypes.c_void_p) -> None:+        super().__init__(native, handle, native.library.ml_region_free, "region")++    @property+    def components(self) -> tuple[PolygonComponent, ...]:+        component_count, loop_count, point_count = self._counts()+        coordinates = (ctypes.c_double * (point_count * 2))()+        loop_offsets = (ctypes.c_size_t * (loop_count + 1))()+        component_offsets = (ctypes.c_size_t * (component_count + 1))()+        obstruction = _Obstruction()         status = int(-            self._native.library.ml_mesh_insert_many_f64(+            self._native.library.ml_region_copy_f64(                 self._live_handle(),-                pointer,-                len(points),-                ctypes.byref(output),+                coordinates,+                point_count,+                loop_offsets,+                loop_count + 1,+                component_offsets,+                component_count + 1,                 ctypes.byref(obstruction),             )         )         self._native.check(status, obstruction)-        return Mesh(self._native, _required_handle(output))+        points = tuple((float(coordinates[index * 2]), float(coordinates[index * 2 + 1])) for index in range(point_count))+        loops = tuple(+            points[int(loop_offsets[index]) : int(loop_offsets[index + 1])]+            for index in range(loop_count)+        )+        component_ranges = tuple(+            (int(component_offsets[index]), int(component_offsets[index + 1]))+            for index in range(component_count)+        )+        if any(start >= end for start, end in component_ranges):+            raise RuntimeError("Moonlight returned a component without an outer loop")+        return tuple(+            PolygonComponent(loops[start], loops[start + 1 : end])+            for start, end in component_ranges+        ) -    def union(self, other: Mesh) -> Mesh:-        return self._binary(other, self._native.library.ml_mesh_union)+    @property+    def valuations(self) -> RegionValuations:+        return self._measure_with_capacity(128) -    def intersection(self, other: Mesh) -> Mesh:-        return self._binary(other, self._native.library.ml_mesh_intersection)+    def locate(self, point: Point) -> RegionLocation:+        output = ctypes.c_uint32()+        obstruction = _Obstruction()+        status = int(+            self._native.library.ml_region_locate_point_f64(+                self._live_handle(), point[0], point[1], ctypes.byref(output), ctypes.byref(obstruction)+            )+        )+        self._native.check(status, obstruction)+        return RegionLocation(output.value) -    def difference(self, other: Mesh) -> Mesh:-        return self._binary(other, self._native.library.ml_mesh_difference)+    def union(self, other: Region) -> Region:+        return self._binary(other, self._native.library.ml_region_union) -    def symmetric_difference(self, other: Mesh) -> Mesh:-        return self._binary(other, self._native.library.ml_mesh_symmetric_difference)+    def intersection(self, other: Region) -> Region:+        return self._binary(other, self._native.library.ml_region_intersection) -    def _binary(self, other: Mesh, operation: _BinaryNativeOperation) -> Mesh:-        if self._native is not other._native:-            raise ValueError("both meshes must belong to the same Moonlight runtime")-        output = ctypes.c_void_p()+    def difference(self, other: Region) -> Region:+        return self._binary(other, self._native.library.ml_region_difference)++    def symmetric_difference(self, other: Region) -> Region:+        return self._binary(other, self._native.library.ml_region_symmetric_difference)++    def minkowski_sum(self, other: Region) -> tuple[Region, MinkowskiReceipt]:+        self._require_same_runtime(other)+        return self._morph(+            lambda output, receipt, obstruction: self._native.library.ml_region_minkowski_sum(+                self._live_handle(), other._live_handle(), output, receipt, obstruction+            )+        )++    def offset(self, element: StructuringElement) -> tuple[Region, MinkowskiReceipt]:+        return self._with_element(element, self._native.library.ml_region_offset)++    def inset(self, element: StructuringElement) -> tuple[Region, MinkowskiReceipt]:+        return self._with_element(element, self._native.library.ml_region_inset)++    def open(self, element: StructuringElement) -> tuple[Region, MinkowskiReceipt]:+        return self._with_element(element, self._native.library.ml_region_open)++    def close_with(self, element: StructuringElement) -> tuple[Region, MinkowskiReceipt]:+        return self._with_element(element, self._native.library.ml_region_close)++    def _binary(self, other: Region, operation: _BinaryNativeOperation) -> Region:+        self._require_same_runtime(other)+        handle = _produce_handle(+            self._native,+            lambda output, obstruction: operation(+                self._live_handle(), other._live_handle(), output, obstruction+            ),+        )+        return Region(self._native, handle)++    def _with_element(+        self, element: StructuringElement, operation: _MorphologyNativeOperation+    ) -> tuple[Region, MinkowskiReceipt]:+        self._require_same_runtime(element)+        return self._morph(+            lambda output, receipt, obstruction: operation(+                element._live_handle(), self._live_handle(), output, receipt, obstruction+            )+        )++    def _morph(+        self,+        operation: Callable[[object, object, object], int],+    ) -> tuple[Region, MinkowskiReceipt]:+        handle, native_receipt = _produce_morphology(self._native, operation)+        return Region(self._native, handle), _receipt(native_receipt)++    def _counts(self) -> tuple[int, int, int]:+        component_count = ctypes.c_size_t()+        loop_count = ctypes.c_size_t()+        point_count = ctypes.c_size_t()         obstruction = _Obstruction()         status = int(-            operation(+            self._native.library.ml_region_counts(                 self._live_handle(),-                other._live_handle(),-                ctypes.byref(output),+                ctypes.byref(component_count),+                ctypes.byref(loop_count),+                ctypes.byref(point_count),                 ctypes.byref(obstruction),             )         )         self._native.check(status, obstruction)-        return Mesh(self._native, _required_handle(output))+        return int(component_count.value), int(loop_count.value), int(point_count.value) -    def _count(self, operation: Callable[[ctypes.c_void_p, object, object], int]) -> int:-        output = ctypes.c_size_t()+    def _measure_with_capacity(self, capacity: int) -> RegionValuations:+        euler = ctypes.c_int64()+        area = ctypes.create_string_buffer(capacity)+        area_bytes = ctypes.c_size_t()+        lower = ctypes.c_double()+        upper = ctypes.c_double()         obstruction = _Obstruction()-        status = int(operation(self._live_handle(), ctypes.byref(output), ctypes.byref(obstruction)))+        status = int(+            self._native.library.ml_region_measure(+                self._live_handle(),+                ctypes.byref(euler),+                area,+                capacity,+                ctypes.byref(area_bytes),+                ctypes.byref(lower),+                ctypes.byref(upper),+                ctypes.byref(obstruction),+            )+        )+        if status == 3 and obstruction.code == 102:+            return self._measure_with_capacity(int(area_bytes.value) + 1)         self._native.check(status, obstruction)-        return int(output.value)+        numerator, separator, denominator = area.value.decode("ascii").partition("/")+        if separator != "/":+            raise RuntimeError("Moonlight returned a malformed exact-area ratio")+        return RegionValuations(int(euler.value), Fraction(int(numerator), int(denominator)), (lower.value, upper.value)) -    def _live_handle(self) -> ctypes.c_void_p:-        if not self._finalizer.alive:-            raise RuntimeError("mesh is closed")-        return self._handle +class StructuringElement(_OwnedHandle):+    __slots__ = () -def _coordinate_buffer(points: Sequence[Point]) -> tuple[object, object]:-    values = tuple(component for x, y in points for component in (x, y))-    if not values:-        return (), None-    coordinates = (ctypes.c_double * len(values))(*values)-    return coordinates, coordinates+    def __init__(self, native: _NativeApi, handle: ctypes.c_void_p) -> None:+        super().__init__(native, handle, native.library.ml_structuring_element_free, "structuring element")  +def _component_layout(+    components: Sequence[PolygonComponent],+) -> tuple[tuple[Sequence[Point], ...], tuple[int, ...], tuple[int, ...]]:+    loops = tuple(+        loop+        for component in components+        for loop in (component.outer, *component.holes)+    )+    loop_counts = tuple(len(loop) for loop in loops)+    component_counts = tuple(len(component.holes) + 1 for component in components)+    return loops, loop_counts, component_counts+++def _coordinate_buffer(points: Iterable[Point]) -> tuple[array, object]:+    coordinates = array("d", (component for x, y in points for component in (x, y)))+    if coordinates.itemsize != ctypes.sizeof(ctypes.c_double):+        raise RuntimeError("Python's native double width does not match the Moonlight ABI")+    if not coordinates:+        return coordinates, None+    pointer = (ctypes.c_double * len(coordinates)).from_buffer(coordinates)+    return coordinates, pointer+++def _size_buffer(values: Sequence[int]) -> object:+    return (ctypes.c_size_t * len(values))(*values)+++def _produce_handle(+    native: _NativeApi,+    operation: Callable[[object, object], int],+) -> ctypes.c_void_p:+    output = ctypes.c_void_p()+    obstruction = _Obstruction()+    status = int(operation(ctypes.byref(output), ctypes.byref(obstruction)))+    native.check(status, obstruction)+    return _required_handle(output)+++def _produce_morphology(+    native: _NativeApi,+    operation: Callable[[object, object, object], int],+) -> tuple[ctypes.c_void_p, _NativeMinkowskiReceipt]:+    output = ctypes.c_void_p()+    receipt = _NativeMinkowskiReceipt()+    obstruction = _Obstruction()+    status = int(operation(ctypes.byref(output), ctypes.byref(receipt), ctypes.byref(obstruction)))+    native.check(status, obstruction)+    return _required_handle(output), receipt+++def _receipt(native: _NativeMinkowskiReceipt) -> MinkowskiReceipt:+    return MinkowskiReceipt(+        MinkowskiOperation(native.operation),+        int(native.input_components),+        int(native.convex_pieces),+        int(native.generated_pieces),+        int(native.generated_convolution_edges),+        int(native.overlay_passes),+        int(native.exact_crossings),+        int(native.output_cells),+        int(native.exact_coordinate_bit_growth),+    )++ def _required_handle(handle: ctypes.c_void_p) -> ctypes.c_void_p:     if not handle.value:-        raise RuntimeError("Moonlight returned success without a mesh handle")+        raise RuntimeError("Moonlight returned success without a handle")     return handle  @@ -244,4 +608,17 @@     setattr(function, "restype", result)  -__all__ = ["Mesh", "Moonlight", "MoonlightError", "Point", "Triangle"]+__all__ = [+    "Mesh",+    "MinkowskiOperation",+    "MinkowskiReceipt",+    "Moonlight",+    "MoonlightError",+    "Point",+    "PolygonComponent",+    "Region",+    "RegionLocation",+    "RegionValuations",+    "StructuringElement",+    "Triangle",+]

@@ -3,9 +3,16 @@ import math import os import unittest+from fractions import Fraction from typing import ClassVar -from moonlight_triangulation import Moonlight, MoonlightError+from moonlight_triangulation import (+    MinkowskiOperation,+    Moonlight,+    MoonlightError,+    PolygonComponent,+    RegionLocation,+)   class MoonlightBindingTest(unittest.TestCase):@@ -15,13 +22,13 @@     def setUpClass(cls) -> None:         cls.engine = Moonlight(os.environ["MOONLIGHT_TRIANGULATION_LIBRARY"]) -    def test_immutable_mesh_algebra_and_dense_projection(self) -> None:+    def test_immutable_site_set_algebra_and_dense_projection(self) -> None:         left = self.engine.delaunay([(0, 0), (2, 0), (0, 2), (2, 2)])         right = self.engine.delaunay([(2, 0), (4, 0), (2, 2), (4, 2)])-        union = left.union(right)-        intersection = left.intersection(right)-        difference = left.difference(right)-        symmetric = left.symmetric_difference(right)+        union = left.site_union(right)+        intersection = left.site_intersection(right)+        difference = left.site_difference(right)+        symmetric = left.site_symmetric_difference(right)         extended = left.insert_many([(1, 1), (3, 1)])         self.addCleanup(left.close)         self.addCleanup(right.close)@@ -40,6 +47,34 @@         self.assertEqual(len(left.vertices), left.vertex_count)         self.assertEqual(len(left.triangles), left.triangle_count)         self.assertTrue(all(max(triangle) < left.vertex_count for triangle in left.triangles))++    def test_exact_region_boolean_valuation_and_morphology(self) -> None:+        left = self.engine.region([PolygonComponent(((0, 0), (2, 0), (2, 2), (0, 2)))])+        right = self.engine.region([PolygonComponent(((1, 0), (3, 0), (3, 2), (1, 2)))])+        intersection = left.intersection(right)+        difference = left.difference(right)+        symmetric = left.symmetric_difference(right)+        kernel = self.engine.structuring_element(((-0.5, -0.5), (0.5, -0.5), (0.5, 0.5), (-0.5, 0.5)))+        offset, receipt = left.offset(kernel)+        self.addCleanup(left.close)+        self.addCleanup(right.close)+        self.addCleanup(intersection.close)+        self.addCleanup(difference.close)+        self.addCleanup(symmetric.close)+        self.addCleanup(kernel.close)+        self.addCleanup(offset.close)++        self.assertEqual(len(left.components), 1)+        self.assertEqual(len(left.components[0].outer), 4)+        self.assertEqual(intersection.valuations.area, Fraction(2, 1))+        self.assertEqual(difference.valuations.euler_characteristic, 1)+        self.assertEqual(symmetric.valuations.euler_characteristic, 2)+        self.assertEqual(left.locate((1, 1)), RegionLocation.INTERIOR)+        self.assertEqual(left.locate((0, 1)), RegionLocation.BOUNDARY)+        self.assertEqual(left.locate((3, 1)), RegionLocation.EXTERIOR)+        self.assertEqual(offset.valuations.area, Fraction(9, 1))+        self.assertEqual(receipt.operation, MinkowskiOperation.ADDITION)+        self.assertGreaterEqual(receipt.generated_pieces, 1)      def test_invalid_coordinate_preserves_typed_witness(self) -> None:         with self.assertRaises(MoonlightError) as raised:

@@ -1,9 +1,9 @@ [package] name = "moonlight-triangulation"-version = "1.0.0"+version = "2.0.0" edition = "2024" license = "MIT"-description = "Rust bindings for Moonlight's immutable Delaunay mesh algebra."+description = "Rust bindings for Moonlight exact regions and immutable Delaunay meshes." repository = "https://github.com/PaleRoses/moonlight.git" build = "build.rs" links = "moonlight-triangulation-c"

@@ -6,7 +6,8 @@ use std::rc::Rc;  const STATUS_OK: u32 = 0;-const ABI_VERSION: u32 = 1;+const STATUS_BUFFER_TOO_SMALL: u32 = 3;+const ABI_VERSION: u32 = 2;  #[repr(C)] struct NativeMesh {@@ -14,6 +15,16 @@ }  #[repr(C)]+struct NativeRegion {+    _private: [u8; 0],+}++#[repr(C)]+struct NativeStructuringElement {+    _private: [u8; 0],+}++#[repr(C)] struct NativeObstruction {     code: u32,     coordinate_error: u32,@@ -44,6 +55,21 @@     } } +#[repr(C)]+#[derive(Default)]+struct NativeMinkowskiReceipt {+    operation: u32,+    reserved: u32,+    input_components: u64,+    convex_pieces: u64,+    generated_pieces: u64,+    generated_convolution_edges: u64,+    overlay_passes: u64,+    exact_crossings: u64,+    output_cells: u64,+    exact_coordinate_bit_growth: u64,+}+ #[link(name = "moonlight-triangulation-c")] unsafe extern "C" {     fn ml_abi_version() -> c_uint;@@ -61,25 +87,25 @@         result: *mut *mut NativeMesh,         obstruction: *mut NativeObstruction,     ) -> c_uint;-    fn ml_mesh_union(+    fn ml_mesh_site_union(         left: *const NativeMesh,         right: *const NativeMesh,         result: *mut *mut NativeMesh,         obstruction: *mut NativeObstruction,     ) -> c_uint;-    fn ml_mesh_intersection(+    fn ml_mesh_site_intersection(         left: *const NativeMesh,         right: *const NativeMesh,         result: *mut *mut NativeMesh,         obstruction: *mut NativeObstruction,     ) -> c_uint;-    fn ml_mesh_difference(+    fn ml_mesh_site_difference(         left: *const NativeMesh,         right: *const NativeMesh,         result: *mut *mut NativeMesh,         obstruction: *mut NativeObstruction,     ) -> c_uint;-    fn ml_mesh_symmetric_difference(+    fn ml_mesh_site_symmetric_difference(         left: *const NativeMesh,         right: *const NativeMesh,         result: *mut *mut NativeMesh,@@ -110,6 +136,119 @@         obstruction: *mut NativeObstruction,     ) -> c_uint;     fn ml_mesh_free(mesh: *mut NativeMesh);++    fn ml_region_create_f64(+        coordinates: *const c_double,+        point_count: usize,+        loop_point_counts: *const usize,+        loop_count: usize,+        component_loop_counts: *const usize,+        component_count: usize,+        result: *mut *mut NativeRegion,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_counts(+        region: *const NativeRegion,+        component_count: *mut usize,+        loop_count: *mut usize,+        point_count: *mut usize,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_copy_f64(+        region: *const NativeRegion,+        coordinates: *mut c_double,+        point_capacity: usize,+        loop_point_offsets: *mut usize,+        loop_offset_capacity: usize,+        component_loop_offsets: *mut usize,+        component_offset_capacity: usize,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_union(+        left: *const NativeRegion,+        right: *const NativeRegion,+        result: *mut *mut NativeRegion,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_intersection(+        left: *const NativeRegion,+        right: *const NativeRegion,+        result: *mut *mut NativeRegion,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_difference(+        left: *const NativeRegion,+        right: *const NativeRegion,+        result: *mut *mut NativeRegion,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_symmetric_difference(+        left: *const NativeRegion,+        right: *const NativeRegion,+        result: *mut *mut NativeRegion,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_locate_point_f64(+        region: *const NativeRegion,+        x: c_double,+        y: c_double,+        location: *mut u32,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_measure(+        region: *const NativeRegion,+        euler_characteristic: *mut i64,+        area_ratio_utf8: *mut c_char,+        area_capacity: usize,+        area_bytes_written: *mut usize,+        perimeter_lower: *mut c_double,+        perimeter_upper: *mut c_double,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_free(region: *mut NativeRegion);++    fn ml_structuring_element_create_f64(+        coordinates: *const c_double,+        point_count: usize,+        result: *mut *mut NativeStructuringElement,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_structuring_element_free(element: *mut NativeStructuringElement);+    fn ml_region_minkowski_sum(+        left: *const NativeRegion,+        right: *const NativeRegion,+        result: *mut *mut NativeRegion,+        receipt: *mut NativeMinkowskiReceipt,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_offset(+        element: *const NativeStructuringElement,+        region: *const NativeRegion,+        result: *mut *mut NativeRegion,+        receipt: *mut NativeMinkowskiReceipt,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_inset(+        element: *const NativeStructuringElement,+        region: *const NativeRegion,+        result: *mut *mut NativeRegion,+        receipt: *mut NativeMinkowskiReceipt,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_open(+        element: *const NativeStructuringElement,+        region: *const NativeRegion,+        result: *mut *mut NativeRegion,+        receipt: *mut NativeMinkowskiReceipt,+        obstruction: *mut NativeObstruction,+    ) -> c_uint;+    fn ml_region_close(+        element: *const NativeStructuringElement,+        region: *const NativeRegion,+        result: *mut *mut NativeRegion,+        receipt: *mut NativeMinkowskiReceipt,+        obstruction: *mut NativeObstruction,+    ) -> c_uint; }  type BinaryMeshOperation = unsafe extern "C" fn(@@ -119,6 +258,21 @@     *mut NativeObstruction, ) -> c_uint; +type BinaryRegionOperation = unsafe extern "C" fn(+    *const NativeRegion,+    *const NativeRegion,+    *mut *mut NativeRegion,+    *mut NativeObstruction,+) -> c_uint;++type ElementRegionOperation = unsafe extern "C" fn(+    *const NativeStructuringElement,+    *const NativeRegion,+    *mut *mut NativeRegion,+    *mut NativeMinkowskiReceipt,+    *mut NativeObstruction,+) -> c_uint;+ #[derive(Debug, Clone, PartialEq)] pub struct MoonlightError {     pub status: u32,@@ -141,6 +295,53 @@  impl Error for MoonlightError {} +#[derive(Debug, Clone, PartialEq)]+pub struct PolygonComponent {+    pub outer: Vec<[f64; 2]>,+    pub holes: Vec<Vec<[f64; 2]>>,+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum RegionLocation {+    Exterior,+    Boundary,+    Interior,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub struct ExactRational {+    pub numerator: String,+    pub denominator: String,+}++#[derive(Debug, Clone, PartialEq)]+pub struct RegionValuations {+    pub euler_characteristic: i64,+    pub area: ExactRational,+    pub perimeter_bounds: [f64; 2],+}++#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum MinkowskiOperation {+    Addition,+    Erosion,+    Opening,+    Closing,+}++#[derive(Debug, Clone, PartialEq, Eq)]+pub struct MinkowskiReceipt {+    pub operation: MinkowskiOperation,+    pub input_components: u64,+    pub convex_pieces: u64,+    pub generated_pieces: u64,+    pub generated_convolution_edges: u64,+    pub overlay_passes: u64,+    pub exact_crossings: u64,+    pub output_cells: u64,+    pub exact_coordinate_bit_growth: u64,+}+ pub struct Moonlight;  impl Moonlight {@@ -168,10 +369,58 @@      pub fn delaunay(&self, points: &[[f64; 2]]) -> Result<Mesh, MoonlightError> {         let coordinates = flatten_points(points);-        create_mesh(|output, obstruction| unsafe {+        create_handle(|output, obstruction| unsafe {             ml_delaunay_f64(coordinates.as_ptr(), points.len(), output, obstruction)         })+        .map(Mesh::from_handle)     }++    pub fn region(&self, components: &[PolygonComponent]) -> Result<Region, MoonlightError> {+        let loop_point_counts = components+            .iter()+            .flat_map(|component| std::iter::once(&component.outer).chain(component.holes.iter()))+            .map(Vec::len)+            .collect::<Vec<_>>();+        let component_loop_counts = components+            .iter()+            .map(|component| component.holes.len() + 1)+            .collect::<Vec<_>>();+        let coordinates = components+            .iter()+            .flat_map(|component| std::iter::once(&component.outer).chain(component.holes.iter()))+            .flat_map(|loop_points| loop_points.iter())+            .flat_map(|[x, y]| [*x, *y])+            .collect::<Vec<_>>();+        create_handle(|output, obstruction| unsafe {+            ml_region_create_f64(+                coordinates.as_ptr(),+                coordinates.len() / 2,+                loop_point_counts.as_ptr(),+                loop_point_counts.len(),+                component_loop_counts.as_ptr(),+                components.len(),+                output,+                obstruction,+            )+        })+        .map(Region::from_handle)+    }++    pub fn structuring_element(+        &self,+        points: &[[f64; 2]],+    ) -> Result<StructuringElement, MoonlightError> {+        let coordinates = flatten_points(points);+        create_handle(|output, obstruction| unsafe {+            ml_structuring_element_create_f64(+                coordinates.as_ptr(),+                points.len(),+                output,+                obstruction,+            )+        })+        .map(StructuringElement::from_handle)+    } }  pub struct Mesh {@@ -180,6 +429,13 @@ }  impl Mesh {+    fn from_handle(handle: NonNull<NativeMesh>) -> Self {+        Self {+            handle,+            _thread_affinity: PhantomData,+        }+    }+     pub fn vertex_count(&self) -> Result<usize, MoonlightError> {         self.count(ml_mesh_vertex_count)     }@@ -204,10 +460,7 @@         };         status_result(status, obstruction)?;         coordinates.truncate(written * 2);-        Ok(coordinates-            .chunks_exact(2)-            .map(|point| [point[0], point[1]])-            .collect())+        coordinate_pairs(&coordinates)     }      pub fn triangles(&self) -> Result<Vec<[u32; 3]>, MoonlightError> {@@ -226,15 +479,21 @@         };         status_result(status, obstruction)?;         triangles.truncate(written * 3);-        Ok(triangles+        triangles             .chunks_exact(3)-            .map(|triangle| [triangle[0], triangle[1], triangle[2]])-            .collect())+            .map(|triangle| {+                Ok([+                    *triangle.first().ok_or_else(projection_shape_error)?,+                    *triangle.get(1).ok_or_else(projection_shape_error)?,+                    *triangle.get(2).ok_or_else(projection_shape_error)?,+                ])+            })+            .collect()     }      pub fn insert_many(&self, points: &[[f64; 2]]) -> Result<Self, MoonlightError> {         let coordinates = flatten_points(points);-        create_mesh(|output, obstruction| unsafe {+        create_handle(|output, obstruction| unsafe {             ml_mesh_insert_many_f64(                 self.handle.as_ptr(),                 coordinates.as_ptr(),@@ -243,26 +502,27 @@                 obstruction,             )         })+        .map(Self::from_handle)     } -    pub fn union(&self, other: &Self) -> Result<Self, MoonlightError> {-        self.binary(other, ml_mesh_union)+    pub fn site_union(&self, other: &Self) -> Result<Self, MoonlightError> {+        self.binary(other, ml_mesh_site_union)     } -    pub fn intersection(&self, other: &Self) -> Result<Self, MoonlightError> {-        self.binary(other, ml_mesh_intersection)+    pub fn site_intersection(&self, other: &Self) -> Result<Self, MoonlightError> {+        self.binary(other, ml_mesh_site_intersection)     } -    pub fn difference(&self, other: &Self) -> Result<Self, MoonlightError> {-        self.binary(other, ml_mesh_difference)+    pub fn site_difference(&self, other: &Self) -> Result<Self, MoonlightError> {+        self.binary(other, ml_mesh_site_difference)     } -    pub fn symmetric_difference(&self, other: &Self) -> Result<Self, MoonlightError> {-        self.binary(other, ml_mesh_symmetric_difference)+    pub fn site_symmetric_difference(&self, other: &Self) -> Result<Self, MoonlightError> {+        self.binary(other, ml_mesh_site_symmetric_difference)     }      fn binary(&self, other: &Self, operation: BinaryMeshOperation) -> Result<Self, MoonlightError> {-        create_mesh(|output, obstruction| unsafe {+        create_handle(|output, obstruction| unsafe {             operation(                 self.handle.as_ptr(),                 other.handle.as_ptr(),@@ -270,6 +530,7 @@                 obstruction,             )         })+        .map(Self::from_handle)     }      fn count(@@ -294,26 +555,351 @@     } } +pub struct Region {+    handle: NonNull<NativeRegion>,+    _thread_affinity: PhantomData<Rc<()>>,+}++impl Region {+    fn from_handle(handle: NonNull<NativeRegion>) -> Self {+        Self {+            handle,+            _thread_affinity: PhantomData,+        }+    }++    pub fn components(&self) -> Result<Vec<PolygonComponent>, MoonlightError> {+        let (component_count, loop_count, point_count) = self.counts()?;+        let mut coordinates = vec![0.0; point_count * 2];+        let mut loop_point_offsets = vec![0; loop_count + 1];+        let mut component_loop_offsets = vec![0; component_count + 1];+        let mut obstruction = NativeObstruction::default();+        let status = unsafe {+            ml_region_copy_f64(+                self.handle.as_ptr(),+                coordinates.as_mut_ptr(),+                point_count,+                loop_point_offsets.as_mut_ptr(),+                loop_point_offsets.len(),+                component_loop_offsets.as_mut_ptr(),+                component_loop_offsets.len(),+                &mut obstruction,+            )+        };+        status_result(status, obstruction)?;+        let points = coordinate_pairs(&coordinates)?;+        component_loop_offsets+            .windows(2)+            .map(|window| {+                let (start, end) = offset_window(window)?;+                if start >= end {+                    return Err(projection_shape_error());+                }+                let outer = projected_loop(&points, &loop_point_offsets, start)?;+                let holes = (start + 1..end)+                    .map(|index| projected_loop(&points, &loop_point_offsets, index))+                    .collect::<Result<Vec<_>, _>>()?;+                Ok(PolygonComponent { outer, holes })+            })+            .collect()+    }++    pub fn valuations(&self) -> Result<RegionValuations, MoonlightError> {+        self.measure_with_capacity(128)+    }++    pub fn locate(&self, [x, y]: [f64; 2]) -> Result<RegionLocation, MoonlightError> {+        let mut location = 0;+        let mut obstruction = NativeObstruction::default();+        let status = unsafe {+            ml_region_locate_point_f64(self.handle.as_ptr(), x, y, &mut location, &mut obstruction)+        };+        status_result(status, obstruction)?;+        region_location(location)+    }++    pub fn union(&self, other: &Self) -> Result<Self, MoonlightError> {+        self.binary(other, ml_region_union)+    }++    pub fn intersection(&self, other: &Self) -> Result<Self, MoonlightError> {+        self.binary(other, ml_region_intersection)+    }++    pub fn difference(&self, other: &Self) -> Result<Self, MoonlightError> {+        self.binary(other, ml_region_difference)+    }++    pub fn symmetric_difference(&self, other: &Self) -> Result<Self, MoonlightError> {+        self.binary(other, ml_region_symmetric_difference)+    }++    pub fn minkowski_sum(&self, other: &Self) -> Result<(Self, MinkowskiReceipt), MoonlightError> {+        produce_morphology(|output, receipt, obstruction| unsafe {+            ml_region_minkowski_sum(+                self.handle.as_ptr(),+                other.handle.as_ptr(),+                output,+                receipt,+                obstruction,+            )+        })+    }++    pub fn offset(+        &self,+        element: &StructuringElement,+    ) -> Result<(Self, MinkowskiReceipt), MoonlightError> {+        self.with_element(element, ml_region_offset)+    }++    pub fn inset(+        &self,+        element: &StructuringElement,+    ) -> Result<(Self, MinkowskiReceipt), MoonlightError> {+        self.with_element(element, ml_region_inset)+    }++    pub fn open(+        &self,+        element: &StructuringElement,+    ) -> Result<(Self, MinkowskiReceipt), MoonlightError> {+        self.with_element(element, ml_region_open)+    }++    pub fn close_with(+        &self,+        element: &StructuringElement,+    ) -> Result<(Self, MinkowskiReceipt), MoonlightError> {+        self.with_element(element, ml_region_close)+    }++    fn binary(+        &self,+        other: &Self,+        operation: BinaryRegionOperation,+    ) -> Result<Self, MoonlightError> {+        create_handle(|output, obstruction| unsafe {+            operation(+                self.handle.as_ptr(),+                other.handle.as_ptr(),+                output,+                obstruction,+            )+        })+        .map(Self::from_handle)+    }++    fn with_element(+        &self,+        element: &StructuringElement,+        operation: ElementRegionOperation,+    ) -> Result<(Self, MinkowskiReceipt), MoonlightError> {+        produce_morphology(|output, receipt, obstruction| unsafe {+            operation(+                element.handle.as_ptr(),+                self.handle.as_ptr(),+                output,+                receipt,+                obstruction,+            )+        })+    }++    fn counts(&self) -> Result<(usize, usize, usize), MoonlightError> {+        let mut component_count = 0;+        let mut loop_count = 0;+        let mut point_count = 0;+        let mut obstruction = NativeObstruction::default();+        let status = unsafe {+            ml_region_counts(+                self.handle.as_ptr(),+                &mut component_count,+                &mut loop_count,+                &mut point_count,+                &mut obstruction,+            )+        };+        status_result(status, obstruction)?;+        Ok((component_count, loop_count, point_count))+    }++    fn measure_with_capacity(&self, capacity: usize) -> Result<RegionValuations, MoonlightError> {+        let mut euler_characteristic = 0;+        let mut area_ratio = vec![0; capacity];+        let mut area_bytes_written = 0;+        let mut perimeter_lower = 0.0;+        let mut perimeter_upper = 0.0;+        let mut obstruction = NativeObstruction::default();+        let status = unsafe {+            ml_region_measure(+                self.handle.as_ptr(),+                &mut euler_characteristic,+                area_ratio.as_mut_ptr(),+                capacity,+                &mut area_bytes_written,+                &mut perimeter_lower,+                &mut perimeter_upper,+                &mut obstruction,+            )+        };+        if status == STATUS_BUFFER_TOO_SMALL && obstruction.code == 102 {+            return self.measure_with_capacity(area_bytes_written + 1);+        }+        status_result(status, obstruction)?;+        let area_bytes = area_ratio+            .get(..area_bytes_written)+            .ok_or_else(projection_shape_error)?+            .iter()+            .map(|byte| *byte as u8)+            .collect::<Vec<_>>();+        let area_text = String::from_utf8(area_bytes)+            .map_err(|failure| synthetic_error(5, failure.to_string(), 0, 0))?;+        let (numerator, denominator) = area_text+            .split_once('/')+            .ok_or_else(|| synthetic_error(5, "malformed exact-area ratio", 0, 0))?;+        Ok(RegionValuations {+            euler_characteristic,+            area: ExactRational {+                numerator: numerator.to_owned(),+                denominator: denominator.to_owned(),+            },+            perimeter_bounds: [perimeter_lower, perimeter_upper],+        })+    }+}++impl Drop for Region {+    fn drop(&mut self) {+        unsafe { ml_region_free(self.handle.as_ptr()) }+    }+}++pub struct StructuringElement {+    handle: NonNull<NativeStructuringElement>,+    _thread_affinity: PhantomData<Rc<()>>,+}++impl StructuringElement {+    fn from_handle(handle: NonNull<NativeStructuringElement>) -> Self {+        Self {+            handle,+            _thread_affinity: PhantomData,+        }+    }+}++impl Drop for StructuringElement {+    fn drop(&mut self) {+        unsafe { ml_structuring_element_free(self.handle.as_ptr()) }+    }+}+ fn flatten_points(points: &[[f64; 2]]) -> Vec<f64> {     points.iter().flat_map(|[x, y]| [*x, *y]).collect() } -#[inline]-fn create_mesh(-    operation: impl FnOnce(*mut *mut NativeMesh, *mut NativeObstruction) -> u32,-) -> Result<Mesh, MoonlightError> {+fn coordinate_pairs(coordinates: &[f64]) -> Result<Vec<[f64; 2]>, MoonlightError> {+    coordinates+        .chunks_exact(2)+        .map(|point| {+            Ok([+                *point.first().ok_or_else(projection_shape_error)?,+                *point.get(1).ok_or_else(projection_shape_error)?,+            ])+        })+        .collect()+}++fn offset_window(window: &[usize]) -> Result<(usize, usize), MoonlightError> {+    Ok((+        *window.first().ok_or_else(projection_shape_error)?,+        *window.get(1).ok_or_else(projection_shape_error)?,+    ))+}++fn projected_loop(+    points: &[[f64; 2]],+    offsets: &[usize],+    index: usize,+) -> Result<Vec<[f64; 2]>, MoonlightError> {+    let start = *offsets.get(index).ok_or_else(projection_shape_error)?;+    let end = *offsets.get(index + 1).ok_or_else(projection_shape_error)?;+    points+        .get(start..end)+        .map(<[_]>::to_vec)+        .ok_or_else(projection_shape_error)+}++fn create_handle<Native>(+    operation: impl FnOnce(*mut *mut Native, *mut NativeObstruction) -> u32,+) -> Result<NonNull<Native>, MoonlightError> {     let mut output = std::ptr::null_mut();     let mut obstruction = NativeObstruction::default();     let status = operation(&mut output, &mut obstruction);     status_result(status, obstruction)?;-    NonNull::new(output)-        .map(|handle| Mesh {-            handle,-            _thread_affinity: PhantomData,-        })-        .ok_or_else(success_without_handle_error)+    NonNull::new(output).ok_or_else(success_without_handle_error) } +fn produce_morphology(+    operation: impl FnOnce(+        *mut *mut NativeRegion,+        *mut NativeMinkowskiReceipt,+        *mut NativeObstruction,+    ) -> u32,+) -> Result<(Region, MinkowskiReceipt), MoonlightError> {+    let mut output = std::ptr::null_mut();+    let mut receipt = NativeMinkowskiReceipt::default();+    let mut obstruction = NativeObstruction::default();+    let status = operation(&mut output, &mut receipt, &mut obstruction);+    status_result(status, obstruction)?;+    let handle = NonNull::new(output).ok_or_else(success_without_handle_error)?;+    Ok((Region::from_handle(handle), minkowski_receipt(receipt)?))+}++fn minkowski_receipt(receipt: NativeMinkowskiReceipt) -> Result<MinkowskiReceipt, MoonlightError> {+    Ok(MinkowskiReceipt {+        operation: minkowski_operation(receipt.operation)?,+        input_components: receipt.input_components,+        convex_pieces: receipt.convex_pieces,+        generated_pieces: receipt.generated_pieces,+        generated_convolution_edges: receipt.generated_convolution_edges,+        overlay_passes: receipt.overlay_passes,+        exact_crossings: receipt.exact_crossings,+        output_cells: receipt.output_cells,+        exact_coordinate_bit_growth: receipt.exact_coordinate_bit_growth,+    })+}++fn minkowski_operation(code: u32) -> Result<MinkowskiOperation, MoonlightError> {+    match code {+        0 => Ok(MinkowskiOperation::Addition),+        1 => Ok(MinkowskiOperation::Erosion),+        2 => Ok(MinkowskiOperation::Opening),+        3 => Ok(MinkowskiOperation::Closing),+        _ => Err(synthetic_error(+            5,+            format!("unknown morphology operation {code}"),+            u64::from(code),+            0,+        )),+    }+}++fn region_location(code: u32) -> Result<RegionLocation, MoonlightError> {+    match code {+        0 => Ok(RegionLocation::Exterior),+        1 => Ok(RegionLocation::Boundary),+        2 => Ok(RegionLocation::Interior),+        _ => Err(synthetic_error(+            5,+            format!("unknown region location {code}"),+            u64::from(code),+            0,+        )),+    }+}+ fn status_result(status: u32, obstruction: NativeObstruction) -> Result<(), MoonlightError> {     if status == STATUS_OK {         Ok(())@@ -329,7 +915,10 @@             .iter()             .position(|character| *character == 0)             .unwrap_or(obstruction.message.len());-        let message_bytes = obstruction.message[..message_end]+        let message_bytes = obstruction+            .message+            .get(..message_end)+            .unwrap_or_default()             .iter()             .map(|character| *character as u8)             .collect::<Vec<_>>();@@ -348,8 +937,12 @@     } } +fn projection_shape_error() -> MoonlightError {+    synthetic_error(5, "Moonlight returned a malformed bulk projection", 0, 0)+}+ fn success_without_handle_error() -> MoonlightError {-    synthetic_error(5, "Moonlight returned success without a mesh handle", 0, 0)+    synthetic_error(5, "Moonlight returned success without a handle", 0, 0) }  fn synthetic_error(

@@ -1,7 +1,9 @@-use moonlight_triangulation::Moonlight;+use moonlight_triangulation::{+    ExactRational, MinkowskiOperation, Moonlight, PolygonComponent, RegionLocation,+};  #[test]-fn immutable_mesh_algebra_and_dense_projection() {+fn immutable_site_set_algebra_and_dense_projection() {     let engine = Moonlight::initialize().expect("runtime");     let left = engine         .delaunay(&[[0.0, 0.0], [2.0, 0.0], [0.0, 2.0], [2.0, 2.0]])@@ -9,12 +11,12 @@     let right = engine         .delaunay(&[[2.0, 0.0], [4.0, 0.0], [2.0, 2.0], [4.0, 2.0]])         .expect("right mesh");-    let union = left.union(&right).expect("union");-    let intersection = left.intersection(&right).expect("intersection");-    let difference = left.difference(&right).expect("difference");+    let union = left.site_union(&right).expect("site union");+    let intersection = left.site_intersection(&right).expect("site intersection");+    let difference = left.site_difference(&right).expect("site difference");     let symmetric = left-        .symmetric_difference(&right)-        .expect("symmetric difference");+        .site_symmetric_difference(&right)+        .expect("site symmetric difference");     let extended = left         .insert_many(&[[1.0, 1.0], [3.0, 1.0]])         .expect("batch insertion");@@ -33,6 +35,71 @@         left.triangles().expect("triangles").len(),         left.triangle_count().expect("triangle count")     );+}++#[test]+fn exact_region_boolean_valuation_and_morphology() {+    let engine = Moonlight::initialize().expect("runtime");+    let left = engine+        .region(&[PolygonComponent {+            outer: vec![[0.0, 0.0], [2.0, 0.0], [2.0, 2.0], [0.0, 2.0]],+            holes: vec![],+        }])+        .expect("left region");+    let right = engine+        .region(&[PolygonComponent {+            outer: vec![[1.0, 0.0], [3.0, 0.0], [3.0, 2.0], [1.0, 2.0]],+            holes: vec![],+        }])+        .expect("right region");+    let intersection = left.intersection(&right).expect("intersection");+    let symmetric = left+        .symmetric_difference(&right)+        .expect("symmetric difference");+    let kernel = engine+        .structuring_element(&[[-0.5, -0.5], [0.5, -0.5], [0.5, 0.5], [-0.5, 0.5]])+        .expect("structuring element");+    let (offset, receipt) = left.offset(&kernel).expect("offset");++    assert_eq!(left.components().expect("components").len(), 1);+    assert_eq!(+        intersection+            .valuations()+            .expect("intersection valuation")+            .area,+        ExactRational {+            numerator: "2".to_owned(),+            denominator: "1".to_owned(),+        }+    );+    assert_eq!(+        symmetric+            .valuations()+            .expect("symmetric valuation")+            .euler_characteristic,+        2+    );+    assert_eq!(+        left.locate([1.0, 1.0]).expect("interior"),+        RegionLocation::Interior+    );+    assert_eq!(+        left.locate([0.0, 1.0]).expect("boundary"),+        RegionLocation::Boundary+    );+    assert_eq!(+        left.locate([3.0, 1.0]).expect("exterior"),+        RegionLocation::Exterior+    );+    assert_eq!(+        offset.valuations().expect("offset valuation").area,+        ExactRational {+            numerator: "9".to_owned(),+            denominator: "1".to_owned(),+        }+    );+    assert_eq!(receipt.operation, MinkowskiOperation::Addition);+    assert!(receipt.generated_pieces >= 1); }  #[test]

@@ -1,7 +1,7 @@ {   "name": "@moonlight/triangulation",-  "version": "1.0.0",-  "description": "TypeScript bindings for Moonlight's immutable Delaunay mesh algebra.",+  "version": "2.0.0",+  "description": "TypeScript bindings for Moonlight exact regions and immutable Delaunay meshes.",   "type": "module",   "main": "./dist/src/index.js",   "types": "./dist/src/index.d.ts",

@@ -1,13 +1,56 @@ import koffi from "koffi";  const STATUS_OK = 0;-const ABI_VERSION = 1;+const STATUS_BUFFER_TOO_SMALL = 3;+const ABI_VERSION = 2;  export type Point = readonly [x: number, y: number]; export type Triangle = readonly [first: number, second: number, third: number]; -type MeshHandle = object;+export interface PolygonComponent {+  readonly outer: readonly Point[];+  readonly holes?: readonly (readonly Point[])[];+}++export enum RegionLocation {+  Exterior = 0,+  Boundary = 1,+  Interior = 2,+}++export interface ExactRational {+  readonly numerator: bigint;+  readonly denominator: bigint;+}++export interface RegionValuations {+  readonly eulerCharacteristic: bigint;+  readonly area: ExactRational;+  readonly perimeterBounds: readonly [lower: number, upper: number];+}++export enum MinkowskiOperation {+  Addition = 0,+  Erosion = 1,+  Opening = 2,+  Closing = 3,+}++export interface MinkowskiReceipt {+  readonly operation: MinkowskiOperation;+  readonly inputComponents: bigint;+  readonly convexPieces: bigint;+  readonly generatedPieces: bigint;+  readonly generatedConvolutionEdges: bigint;+  readonly overlayPasses: bigint;+  readonly exactCrossings: bigint;+  readonly outputCells: bigint;+  readonly exactCoordinateBitGrowth: bigint;+}++type NativeHandle = object; type NativeInteger = number | bigint;+type HandleOutput = Array<NativeHandle | null>;  interface NativeObstruction {   code?: number;@@ -22,33 +65,103 @@   message?: string | readonly number[]; } -type BuildOperation = (coordinates: Float64Array, pointCount: number, output: Array<MeshHandle | null>, obstruction: NativeObstruction) => number;-type InsertOperation = (mesh: MeshHandle, coordinates: Float64Array, pointCount: number, output: Array<MeshHandle | null>, obstruction: NativeObstruction) => number;-type BinaryOperation = (left: MeshHandle, right: MeshHandle, output: Array<MeshHandle | null>, obstruction: NativeObstruction) => number;-type CountOperation = (mesh: MeshHandle, output: number[], obstruction: NativeObstruction) => number;+interface NativeMinkowskiReceipt {+  operation?: number;+  reserved?: number;+  input_components?: NativeInteger;+  convex_pieces?: NativeInteger;+  generated_pieces?: NativeInteger;+  generated_convolution_edges?: NativeInteger;+  overlay_passes?: NativeInteger;+  exact_crossings?: NativeInteger;+  output_cells?: NativeInteger;+  exact_coordinate_bit_growth?: NativeInteger;+} +type BuildOperation = (coordinates: Float64Array, pointCount: number, output: HandleOutput, obstruction: NativeObstruction) => number;+type InsertOperation = (mesh: NativeHandle, coordinates: Float64Array, pointCount: number, output: HandleOutput, obstruction: NativeObstruction) => number;+type BinaryOperation = (left: NativeHandle, right: NativeHandle, output: HandleOutput, obstruction: NativeObstruction) => number;+type CountOperation = (handle: NativeHandle, output: NativeInteger[], obstruction: NativeObstruction) => number;+type MorphologyOperation = (+  first: NativeHandle,+  second: NativeHandle,+  output: HandleOutput,+  receipt: NativeMinkowskiReceipt,+  obstruction: NativeObstruction,+) => number;+ interface NativeApi {   readonly abiVersion: () => number;   readonly runtimeInitialize: () => number;   readonly delaunay: BuildOperation;   readonly insertMany: InsertOperation;-  readonly union: BinaryOperation;-  readonly intersection: BinaryOperation;-  readonly difference: BinaryOperation;-  readonly symmetricDifference: BinaryOperation;+  readonly meshSiteUnion: BinaryOperation;+  readonly meshSiteIntersection: BinaryOperation;+  readonly meshSiteDifference: BinaryOperation;+  readonly meshSiteSymmetricDifference: BinaryOperation;   readonly vertexCount: CountOperation;   readonly triangleCount: CountOperation;-  readonly copyVertices: (mesh: MeshHandle, coordinates: Float64Array, capacity: number, written: number[], obstruction: NativeObstruction) => number;-  readonly copyTriangles: (mesh: MeshHandle, triangles: Uint32Array, capacity: number, written: number[], obstruction: NativeObstruction) => number;-  readonly free: (mesh: MeshHandle) => void;+  readonly copyVertices: (mesh: NativeHandle, coordinates: Float64Array, capacity: number, written: NativeInteger[], obstruction: NativeObstruction) => number;+  readonly copyTriangles: (mesh: NativeHandle, triangles: Uint32Array, capacity: number, written: NativeInteger[], obstruction: NativeObstruction) => number;+  readonly meshFree: (mesh: NativeHandle) => void;+  readonly regionCreate: (+    coordinates: Float64Array,+    pointCount: number,+    loopPointCounts: BigUint64Array,+    loopCount: number,+    componentLoopCounts: BigUint64Array,+    componentCount: number,+    output: HandleOutput,+    obstruction: NativeObstruction,+  ) => number;+  readonly regionCounts: (+    region: NativeHandle,+    componentCount: NativeInteger[],+    loopCount: NativeInteger[],+    pointCount: NativeInteger[],+    obstruction: NativeObstruction,+  ) => number;+  readonly regionCopy: (+    region: NativeHandle,+    coordinates: Float64Array,+    pointCapacity: number,+    loopPointOffsets: BigUint64Array,+    loopOffsetCapacity: number,+    componentLoopOffsets: BigUint64Array,+    componentOffsetCapacity: number,+    obstruction: NativeObstruction,+  ) => number;+  readonly regionUnion: BinaryOperation;+  readonly regionIntersection: BinaryOperation;+  readonly regionDifference: BinaryOperation;+  readonly regionSymmetricDifference: BinaryOperation;+  readonly regionLocate: (region: NativeHandle, x: number, y: number, location: number[], obstruction: NativeObstruction) => number;+  readonly regionMeasure: (+    region: NativeHandle,+    euler: NativeInteger[],+    areaRatio: Buffer,+    areaCapacity: number,+    areaBytes: NativeInteger[],+    perimeterLower: number[],+    perimeterUpper: number[],+    obstruction: NativeObstruction,+  ) => number;+  readonly regionFree: (region: NativeHandle) => void;+  readonly structuringElementCreate: BuildOperation;+  readonly structuringElementFree: (element: NativeHandle) => void;+  readonly regionMinkowskiSum: MorphologyOperation;+  readonly regionOffset: MorphologyOperation;+  readonly regionInset: MorphologyOperation;+  readonly regionOpen: MorphologyOperation;+  readonly regionClose: MorphologyOperation; }  interface FinalizerState {-  readonly free: (mesh: MeshHandle) => void;-  readonly handle: MeshHandle;+  readonly free: (handle: NativeHandle) => void;+  readonly handle: NativeHandle; } -const meshFinalizer = new FinalizationRegistry<FinalizerState>(({ free, handle }) => free(handle));+const handleFinalizer = new FinalizationRegistry<FinalizerState>(({ free, handle }) => free(handle));  export class MoonlightError extends Error {   readonly status: number;@@ -96,49 +209,117 @@   }    delaunay(points: readonly Point[]): Mesh {-    const output: Array<MeshHandle | null> = [null];-    const obstruction: NativeObstruction = {};-    const status = this.#native.delaunay(flattenPoints(points), points.length, output, obstruction);-    checkStatus(status, obstruction);-    return new Mesh(this.#native, requiredHandle(output[0]));+    const coordinates = flattenPoints(points);+    return new Mesh(+      this.#native,+      produceHandle((output, obstruction) =>+        this.#native.delaunay(coordinates, points.length, output, obstruction),+      ),+    );   }++  region(components: readonly PolygonComponent[]): Region {+    const loops = components.flatMap(({ outer, holes = [] }) => [outer, ...holes]);+    const loopPointCounts = BigUint64Array.from(loops.map((loop) => BigInt(loop.length)));+    const componentLoopCounts = BigUint64Array.from(+      components.map(({ holes = [] }) => BigInt(holes.length + 1)),+    );+    const coordinates = flattenLoops(loops);+    return new Region(+      this.#native,+      produceHandle((output, obstruction) =>+        this.#native.regionCreate(+          coordinates,+          coordinates.length / 2,+          loopPointCounts,+          loops.length,+          componentLoopCounts,+          components.length,+          output,+          obstruction,+        ),+      ),+    );+  }++  structuringElement(points: readonly Point[]): StructuringElement {+    const coordinates = flattenPoints(points);+    return new StructuringElement(+      this.#native,+      produceHandle((output, obstruction) =>+        this.#native.structuringElementCreate(coordinates, points.length, output, obstruction),+      ),+    );+  } } -export class Mesh {+abstract class OwnedHandle {   readonly #native: NativeApi;-  #handle: MeshHandle | null;+  readonly #free: (handle: NativeHandle) => void;+  readonly #kind: string;+  #handle: NativeHandle | null; -  constructor(native: NativeApi, handle: MeshHandle) {+  protected constructor(+    native: NativeApi,+    handle: NativeHandle,+    free: (handle: NativeHandle) => void,+    kind: string,+  ) {     this.#native = native;+    this.#free = free;+    this.#kind = kind;     this.#handle = handle;-    meshFinalizer.register(this, { free: native.free, handle }, this);+    handleFinalizer.register(this, { free, handle }, this);   }    close(): void {     const handle = this.#handle;     if (handle !== null) {-      meshFinalizer.unregister(this);-      this.#native.free(handle);+      handleFinalizer.unregister(this);+      this.#free(handle);       this.#handle = null;     }   } +  native(): NativeApi {+    return this.#native;+  }++  nativeHandle(): NativeHandle {+    if (this.#handle === null) {+      throw new Error(`${this.#kind} is closed`);+    }+    return this.#handle;+  }++  requireSameRuntime(other: OwnedHandle): void {+    if (this.#native !== other.#native) {+      throw new Error("both values must belong to the same Moonlight runtime");+    }+  }+}++export class Mesh extends OwnedHandle {+  constructor(native: NativeApi, handle: NativeHandle) {+    super(native, handle, native.meshFree, "mesh");+  }+   vertexCount(): number {-    return this.#count(this.#native.vertexCount);+    return this.count(this.native().vertexCount);   }    triangleCount(): number {-    return this.#count(this.#native.triangleCount);+    return this.count(this.native().triangleCount);   }    vertices(): readonly Point[] {     const count = this.vertexCount();     const coordinates = new Float64Array(count * 2);-    const written = [0];+    const written: NativeInteger[] = [0];     const obstruction: NativeObstruction = {};-    const status = this.#native.copyVertices(this.#liveHandle(), coordinates, count, written, obstruction);+    const status = this.native().copyVertices(this.nativeHandle(), coordinates, count, written, obstruction);     checkStatus(status, obstruction);-    return Array.from({ length: written[0] ?? 0 }, (_unused, index): Point => [+    return Array.from({ length: toSafeNumber(written[0]) }, (_unused, index): Point => [       coordinates[index * 2] ?? 0,       coordinates[index * 2 + 1] ?? 0,     ]);@@ -147,11 +328,11 @@   triangles(): readonly Triangle[] {     const count = this.triangleCount();     const triangles = new Uint32Array(count * 3);-    const written = [0];+    const written: NativeInteger[] = [0];     const obstruction: NativeObstruction = {};-    const status = this.#native.copyTriangles(this.#liveHandle(), triangles, count, written, obstruction);+    const status = this.native().copyTriangles(this.nativeHandle(), triangles, count, written, obstruction);     checkStatus(status, obstruction);-    return Array.from({ length: written[0] ?? 0 }, (_unused, index): Triangle => [+    return Array.from({ length: toSafeNumber(written[0]) }, (_unused, index): Triangle => [       triangles[index * 3] ?? 0,       triangles[index * 3 + 1] ?? 0,       triangles[index * 3 + 2] ?? 0,@@ -159,61 +340,235 @@   }    insertMany(points: readonly Point[]): Mesh {-    const output: Array<MeshHandle | null> = [null];+    const coordinates = flattenPoints(points);+    return new Mesh(+      this.native(),+      produceHandle((output, obstruction) =>+        this.native().insertMany(this.nativeHandle(), coordinates, points.length, output, obstruction),+      ),+    );+  }++  siteUnion(other: Mesh): Mesh {+    return this.binary(other, this.native().meshSiteUnion);+  }++  siteIntersection(other: Mesh): Mesh {+    return this.binary(other, this.native().meshSiteIntersection);+  }++  siteDifference(other: Mesh): Mesh {+    return this.binary(other, this.native().meshSiteDifference);+  }++  siteSymmetricDifference(other: Mesh): Mesh {+    return this.binary(other, this.native().meshSiteSymmetricDifference);+  }++  private binary(other: Mesh, operation: BinaryOperation): Mesh {+    this.requireSameRuntime(other);+    return new Mesh(+      this.native(),+      produceHandle((output, obstruction) =>+        operation(this.nativeHandle(), other.nativeHandle(), output, obstruction),+      ),+    );+  }++  private count(operation: CountOperation): number {+    const output: NativeInteger[] = [0];     const obstruction: NativeObstruction = {};-    const status = this.#native.insertMany(this.#liveHandle(), flattenPoints(points), points.length, output, obstruction);+    const status = operation(this.nativeHandle(), output, obstruction);     checkStatus(status, obstruction);-    return new Mesh(this.#native, requiredHandle(output[0]));+    return toSafeNumber(output[0]);   }+} -  union(other: Mesh): Mesh {-    return this.#binary(other, this.#native.union);+export class Region extends OwnedHandle {+  constructor(native: NativeApi, handle: NativeHandle) {+    super(native, handle, native.regionFree, "region");   } -  intersection(other: Mesh): Mesh {-    return this.#binary(other, this.#native.intersection);+  components(): readonly PolygonComponent[] {+    const [componentCount, loopCount, pointCount] = this.counts();+    const coordinates = new Float64Array(pointCount * 2);+    const loopPointOffsets = new BigUint64Array(loopCount + 1);+    const componentLoopOffsets = new BigUint64Array(componentCount + 1);+    const obstruction: NativeObstruction = {};+    const status = this.native().regionCopy(+      this.nativeHandle(),+      coordinates,+      pointCount,+      loopPointOffsets,+      loopCount + 1,+      componentLoopOffsets,+      componentCount + 1,+      obstruction,+    );+    checkStatus(status, obstruction);+    const points = Array.from({ length: pointCount }, (_unused, index): Point => [+      coordinates[index * 2] ?? 0,+      coordinates[index * 2 + 1] ?? 0,+    ]);+    const loops = Array.from({ length: loopCount }, (_unused, index) =>+      points.slice(toSafeNumber(loopPointOffsets[index]), toSafeNumber(loopPointOffsets[index + 1])),+    );+    return Array.from({ length: componentCount }, (_unused, index): PolygonComponent => {+      const start = toSafeNumber(componentLoopOffsets[index]);+      const end = toSafeNumber(componentLoopOffsets[index + 1]);+      const outer = loops[start];+      if (outer === undefined || start >= end) {+        throw new Error("Moonlight returned a component without an outer loop");+      }+      return { outer, holes: loops.slice(start + 1, end) };+    });   } -  difference(other: Mesh): Mesh {-    return this.#binary(other, this.#native.difference);+  valuations(): RegionValuations {+    return this.measureWithCapacity(128);   } -  symmetricDifference(other: Mesh): Mesh {-    return this.#binary(other, this.#native.symmetricDifference);+  locate([x, y]: Point): RegionLocation {+    const location = [0];+    const obstruction: NativeObstruction = {};+    const status = this.native().regionLocate(this.nativeHandle(), x, y, location, obstruction);+    checkStatus(status, obstruction);+    return locationCode(location[0]);   } -  #binary(other: Mesh, operation: BinaryOperation): Mesh {-    if (this.#native !== other.#native) {-      throw new Error("both meshes must belong to the same Moonlight runtime");-    }-    const output: Array<MeshHandle | null> = [null];+  union(other: Region): Region {+    return this.binary(other, this.native().regionUnion);+  }++  intersection(other: Region): Region {+    return this.binary(other, this.native().regionIntersection);+  }++  difference(other: Region): Region {+    return this.binary(other, this.native().regionDifference);+  }++  symmetricDifference(other: Region): Region {+    return this.binary(other, this.native().regionSymmetricDifference);+  }++  minkowskiSum(other: Region): readonly [Region, MinkowskiReceipt] {+    this.requireSameRuntime(other);+    return this.morph(this.native().regionMinkowskiSum, this.nativeHandle(), other.nativeHandle());+  }++  offset(element: StructuringElement): readonly [Region, MinkowskiReceipt] {+    return this.withElement(element, this.native().regionOffset);+  }++  inset(element: StructuringElement): readonly [Region, MinkowskiReceipt] {+    return this.withElement(element, this.native().regionInset);+  }++  open(element: StructuringElement): readonly [Region, MinkowskiReceipt] {+    return this.withElement(element, this.native().regionOpen);+  }++  closeWith(element: StructuringElement): readonly [Region, MinkowskiReceipt] {+    return this.withElement(element, this.native().regionClose);+  }++  private binary(other: Region, operation: BinaryOperation): Region {+    this.requireSameRuntime(other);+    return new Region(+      this.native(),+      produceHandle((output, obstruction) =>+        operation(this.nativeHandle(), other.nativeHandle(), output, obstruction),+      ),+    );+  }++  private withElement(+    element: StructuringElement,+    operation: MorphologyOperation,+  ): readonly [Region, MinkowskiReceipt] {+    this.requireSameRuntime(element);+    return this.morph(operation, element.nativeHandle(), this.nativeHandle());+  }++  private morph(+    operation: MorphologyOperation,+    first: NativeHandle,+    second: NativeHandle,+  ): readonly [Region, MinkowskiReceipt] {+    const [handle, receipt] = produceMorphology((output, nativeReceipt, obstruction) =>+      operation(first, second, output, nativeReceipt, obstruction),+    );+    return [new Region(this.native(), handle), receipt];+  }++  private counts(): readonly [number, number, number] {+    const componentCount: NativeInteger[] = [0];+    const loopCount: NativeInteger[] = [0];+    const pointCount: NativeInteger[] = [0];     const obstruction: NativeObstruction = {};-    const status = operation(this.#liveHandle(), other.#liveHandle(), output, obstruction);+    const status = this.native().regionCounts(+      this.nativeHandle(),+      componentCount,+      loopCount,+      pointCount,+      obstruction,+    );     checkStatus(status, obstruction);-    return new Mesh(this.#native, requiredHandle(output[0]));+    return [toSafeNumber(componentCount[0]), toSafeNumber(loopCount[0]), toSafeNumber(pointCount[0])];   } -  #count(operation: CountOperation): number {-    const output = [0];+  private measureWithCapacity(capacity: number): RegionValuations {+    const euler: NativeInteger[] = [0];+    const areaRatio = Buffer.alloc(capacity);+    const areaBytes: NativeInteger[] = [0];+    const perimeterLower = [0];+    const perimeterUpper = [0];     const obstruction: NativeObstruction = {};-    const status = operation(this.#liveHandle(), output, obstruction);+    const status = this.native().regionMeasure(+      this.nativeHandle(),+      euler,+      areaRatio,+      capacity,+      areaBytes,+      perimeterLower,+      perimeterUpper,+      obstruction,+    );+    if (status === STATUS_BUFFER_TOO_SMALL && obstruction.code === 102) {+      return this.measureWithCapacity(toSafeNumber(areaBytes[0]) + 1);+    }     checkStatus(status, obstruction);-    return output[0] ?? 0;+    const ratio = areaRatio.subarray(0, toSafeNumber(areaBytes[0])).toString("ascii");+    const [numerator, denominator, remainder] = ratio.split("/");+    if (numerator === undefined || denominator === undefined || remainder !== undefined) {+      throw new Error("Moonlight returned a malformed exact-area ratio");+    }+    return {+      eulerCharacteristic: toBigInt(euler[0]),+      area: { numerator: BigInt(numerator), denominator: BigInt(denominator) },+      perimeterBounds: [perimeterLower[0] ?? 0, perimeterUpper[0] ?? 0],+    };   }+} -  #liveHandle(): MeshHandle {-    if (this.#handle === null) {-      throw new Error("mesh is closed");-    }-    return this.#handle;+export class StructuringElement extends OwnedHandle {+  constructor(native: NativeApi, handle: NativeHandle) {+    super(native, handle, native.structuringElementFree, "structuring element");   } }  function createNativeApi(libraryPath: string): NativeApi {   const library = koffi.load(libraryPath);   const mesh = koffi.opaque();+  const region = koffi.opaque();+  const structuringElement = koffi.opaque();   const meshPointer = koffi.pointer(mesh);+  const regionPointer = koffi.pointer(region);+  const structuringElementPointer = koffi.pointer(structuringElement);   const meshOutput = koffi.out(koffi.pointer(mesh, 2));+  const regionOutput = koffi.out(koffi.pointer(region, 2));+  const structuringElementOutput = koffi.out(koffi.pointer(structuringElement, 2));   const obstruction = koffi.struct({     code: "uint32_t",     coordinate_error: "uint32_t",@@ -226,22 +581,56 @@     point_y: "double",     message: koffi.array("char", 256),   });+  const receipt = koffi.struct({+    operation: "uint32_t",+    reserved: "uint32_t",+    input_components: "uint64_t",+    convex_pieces: "uint64_t",+    generated_pieces: "uint64_t",+    generated_convolution_edges: "uint64_t",+    overlay_passes: "uint64_t",+    exact_crossings: "uint64_t",+    output_cells: "uint64_t",+    exact_coordinate_bit_growth: "uint64_t",+  });   const obstructionOutput = koffi.out(koffi.pointer(obstruction));-  const meshCountOutput = koffi.out(koffi.pointer("size_t"));+  const receiptOutput = koffi.out(koffi.pointer(receipt));+  const sizeOutput = koffi.out(koffi.pointer("size_t"));+  const uint32Output = koffi.out(koffi.pointer("uint32_t"));+  const int64Output = koffi.out(koffi.pointer("int64_t"));+  const doubleOutput = koffi.out(koffi.pointer("double"));+  const sizeArray = koffi.pointer("size_t");   return {     abiVersion: library.func("ml_abi_version", "uint32_t", []),     runtimeInitialize: library.func("ml_runtime_initialize", "uint32_t", []),     delaunay: library.func("ml_delaunay_f64", "uint32_t", [koffi.pointer("double"), "size_t", meshOutput, obstructionOutput]),     insertMany: library.func("ml_mesh_insert_many_f64", "uint32_t", [meshPointer, koffi.pointer("double"), "size_t", meshOutput, obstructionOutput]),-    union: library.func("ml_mesh_union", "uint32_t", [meshPointer, meshPointer, meshOutput, obstructionOutput]),-    intersection: library.func("ml_mesh_intersection", "uint32_t", [meshPointer, meshPointer, meshOutput, obstructionOutput]),-    difference: library.func("ml_mesh_difference", "uint32_t", [meshPointer, meshPointer, meshOutput, obstructionOutput]),-    symmetricDifference: library.func("ml_mesh_symmetric_difference", "uint32_t", [meshPointer, meshPointer, meshOutput, obstructionOutput]),-    vertexCount: library.func("ml_mesh_vertex_count", "uint32_t", [meshPointer, meshCountOutput, obstructionOutput]),-    triangleCount: library.func("ml_mesh_triangle_count", "uint32_t", [meshPointer, meshCountOutput, obstructionOutput]),-    copyVertices: library.func("ml_mesh_copy_vertices_f64", "uint32_t", [meshPointer, koffi.out(koffi.pointer("double")), "size_t", meshCountOutput, obstructionOutput]),-    copyTriangles: library.func("ml_mesh_copy_triangles_u32", "uint32_t", [meshPointer, koffi.out(koffi.pointer("uint32_t")), "size_t", meshCountOutput, obstructionOutput]),-    free: library.func("ml_mesh_free", "void", [meshPointer]),+    meshSiteUnion: library.func("ml_mesh_site_union", "uint32_t", [meshPointer, meshPointer, meshOutput, obstructionOutput]),+    meshSiteIntersection: library.func("ml_mesh_site_intersection", "uint32_t", [meshPointer, meshPointer, meshOutput, obstructionOutput]),+    meshSiteDifference: library.func("ml_mesh_site_difference", "uint32_t", [meshPointer, meshPointer, meshOutput, obstructionOutput]),+    meshSiteSymmetricDifference: library.func("ml_mesh_site_symmetric_difference", "uint32_t", [meshPointer, meshPointer, meshOutput, obstructionOutput]),+    vertexCount: library.func("ml_mesh_vertex_count", "uint32_t", [meshPointer, sizeOutput, obstructionOutput]),+    triangleCount: library.func("ml_mesh_triangle_count", "uint32_t", [meshPointer, sizeOutput, obstructionOutput]),+    copyVertices: library.func("ml_mesh_copy_vertices_f64", "uint32_t", [meshPointer, koffi.out(koffi.pointer("double")), "size_t", sizeOutput, obstructionOutput]),+    copyTriangles: library.func("ml_mesh_copy_triangles_u32", "uint32_t", [meshPointer, koffi.out(koffi.pointer("uint32_t")), "size_t", sizeOutput, obstructionOutput]),+    meshFree: library.func("ml_mesh_free", "void", [meshPointer]),+    regionCreate: library.func("ml_region_create_f64", "uint32_t", [koffi.pointer("double"), "size_t", sizeArray, "size_t", sizeArray, "size_t", regionOutput, obstructionOutput]),+    regionCounts: library.func("ml_region_counts", "uint32_t", [regionPointer, sizeOutput, sizeOutput, sizeOutput, obstructionOutput]),+    regionCopy: library.func("ml_region_copy_f64", "uint32_t", [regionPointer, koffi.out(koffi.pointer("double")), "size_t", koffi.out(sizeArray), "size_t", koffi.out(sizeArray), "size_t", obstructionOutput]),+    regionUnion: library.func("ml_region_union", "uint32_t", [regionPointer, regionPointer, regionOutput, obstructionOutput]),+    regionIntersection: library.func("ml_region_intersection", "uint32_t", [regionPointer, regionPointer, regionOutput, obstructionOutput]),+    regionDifference: library.func("ml_region_difference", "uint32_t", [regionPointer, regionPointer, regionOutput, obstructionOutput]),+    regionSymmetricDifference: library.func("ml_region_symmetric_difference", "uint32_t", [regionPointer, regionPointer, regionOutput, obstructionOutput]),+    regionLocate: library.func("ml_region_locate_point_f64", "uint32_t", [regionPointer, "double", "double", uint32Output, obstructionOutput]),+    regionMeasure: library.func("ml_region_measure", "uint32_t", [regionPointer, int64Output, koffi.out(koffi.pointer("char")), "size_t", sizeOutput, doubleOutput, doubleOutput, obstructionOutput]),+    regionFree: library.func("ml_region_free", "void", [regionPointer]),+    structuringElementCreate: library.func("ml_structuring_element_create_f64", "uint32_t", [koffi.pointer("double"), "size_t", structuringElementOutput, obstructionOutput]),+    structuringElementFree: library.func("ml_structuring_element_free", "void", [structuringElementPointer]),+    regionMinkowskiSum: library.func("ml_region_minkowski_sum", "uint32_t", [regionPointer, regionPointer, regionOutput, receiptOutput, obstructionOutput]),+    regionOffset: library.func("ml_region_offset", "uint32_t", [structuringElementPointer, regionPointer, regionOutput, receiptOutput, obstructionOutput]),+    regionInset: library.func("ml_region_inset", "uint32_t", [structuringElementPointer, regionPointer, regionOutput, receiptOutput, obstructionOutput]),+    regionOpen: library.func("ml_region_open", "uint32_t", [structuringElementPointer, regionPointer, regionOutput, receiptOutput, obstructionOutput]),+    regionClose: library.func("ml_region_close", "uint32_t", [structuringElementPointer, regionPointer, regionOutput, receiptOutput, obstructionOutput]),   }; } @@ -249,21 +638,85 @@   return Float64Array.from(points.flatMap(([x, y]) => [x, y])); } +function flattenLoops(loops: readonly (readonly Point[])[]): Float64Array {+  return Float64Array.from(loops.flatMap((loop) => loop.flatMap(([x, y]) => [x, y])));+}++function produceHandle(+  operation: (output: HandleOutput, obstruction: NativeObstruction) => number,+): NativeHandle {+  const output: HandleOutput = [null];+  const obstruction: NativeObstruction = {};+  checkStatus(operation(output, obstruction), obstruction);+  return requiredHandle(output[0]);+}++function produceMorphology(+  operation: (+    output: HandleOutput,+    receipt: NativeMinkowskiReceipt,+    obstruction: NativeObstruction,+  ) => number,+): readonly [NativeHandle, MinkowskiReceipt] {+  const output: HandleOutput = [null];+  const receipt: NativeMinkowskiReceipt = {};+  const obstruction: NativeObstruction = {};+  checkStatus(operation(output, receipt, obstruction), obstruction);+  return [requiredHandle(output[0]), morphologyReceipt(receipt)];+}++function morphologyReceipt(receipt: NativeMinkowskiReceipt): MinkowskiReceipt {+  return {+    operation: operationCode(receipt.operation),+    inputComponents: toBigInt(receipt.input_components),+    convexPieces: toBigInt(receipt.convex_pieces),+    generatedPieces: toBigInt(receipt.generated_pieces),+    generatedConvolutionEdges: toBigInt(receipt.generated_convolution_edges),+    overlayPasses: toBigInt(receipt.overlay_passes),+    exactCrossings: toBigInt(receipt.exact_crossings),+    outputCells: toBigInt(receipt.output_cells),+    exactCoordinateBitGrowth: toBigInt(receipt.exact_coordinate_bit_growth),+  };+}++function operationCode(value: number | undefined): MinkowskiOperation {+  if (value === undefined || value < MinkowskiOperation.Addition || value > MinkowskiOperation.Closing) {+    throw new Error(`Moonlight returned an unknown morphology operation ${value ?? "missing"}`);+  }+  return value;+}++function locationCode(value: number | undefined): RegionLocation {+  if (value === undefined || value < RegionLocation.Exterior || value > RegionLocation.Interior) {+    throw new Error(`Moonlight returned an unknown region location ${value ?? "missing"}`);+  }+  return value;+}+ function checkStatus(status: number, obstruction: NativeObstruction): void {   if (status !== STATUS_OK) {     throw new MoonlightError(status, obstruction);   } } -function requiredHandle(handle: MeshHandle | null | undefined): MeshHandle {+function requiredHandle(handle: NativeHandle | null | undefined): NativeHandle {   if (handle === null || handle === undefined) {-    throw new Error("Moonlight returned success without a mesh handle");+    throw new Error("Moonlight returned success without a handle");   }   return handle; }  function toBigInt(value: NativeInteger | undefined): bigint {   return value === undefined ? 0n : BigInt(value);+}++function toSafeNumber(value: NativeInteger | undefined): number {+  const exact = toBigInt(value);+  const projected = Number(exact);+  if (!Number.isSafeInteger(projected)) {+    throw new Error(`Moonlight count ${exact} exceeds JavaScript's safe integer range`);+  }+  return projected; }  function obstructionMessage(obstruction: NativeObstruction): string {

@@ -1,31 +1,67 @@ import assert from "node:assert/strict"; import test from "node:test"; -import { Moonlight, MoonlightError } from "../src/index.js";+import {+  MinkowskiOperation,+  Moonlight,+  MoonlightError,+  RegionLocation,+} from "../src/index.js"; -test("immutable mesh algebra and dense projection", () => {+test("immutable site-set algebra and dense projection", () => {   const engine = new Moonlight();   const left = engine.delaunay([[0, 0], [2, 0], [0, 2], [2, 2]]);   const right = engine.delaunay([[2, 0], [4, 0], [2, 2], [4, 2]]);-  const meshes = [-    left,-    right,-    left.union(right),-    left.intersection(right),-    left.difference(right),-    left.symmetricDifference(right),-    left.insertMany([[1, 1], [3, 1]]),-  ];-  const [original, _right, union, intersection, difference, symmetric, extended] = meshes;-  assert.equal(original?.vertexCount(), 4);-  assert.equal(union?.vertexCount(), 6);-  assert.equal(intersection?.vertexCount(), 2);-  assert.equal(difference?.vertexCount(), 2);-  assert.equal(symmetric?.vertexCount(), 4);-  assert.equal(extended?.vertexCount(), 6);-  assert.equal(original?.vertices().length, original?.vertexCount());-  assert.equal(original?.triangles().length, original?.triangleCount());-  meshes.forEach((mesh) => mesh.close());+  const union = left.siteUnion(right);+  const intersection = left.siteIntersection(right);+  const difference = left.siteDifference(right);+  const symmetric = left.siteSymmetricDifference(right);+  const extended = left.insertMany([[1, 1], [3, 1]]);++  assert.equal(left.vertexCount(), 4);+  assert.equal(union.vertexCount(), 6);+  assert.equal(intersection.vertexCount(), 2);+  assert.equal(difference.vertexCount(), 2);+  assert.equal(symmetric.vertexCount(), 4);+  assert.equal(extended.vertexCount(), 6);+  assert.equal(left.vertices().length, left.vertexCount());+  assert.equal(left.triangles().length, left.triangleCount());++  left.close();+  right.close();+  union.close();+  intersection.close();+  difference.close();+  symmetric.close();+  extended.close();+});++test("exact region Boolean, valuation, and morphology", () => {+  const engine = new Moonlight();+  const left = engine.region([{ outer: [[0, 0], [2, 0], [2, 2], [0, 2]] }]);+  const right = engine.region([{ outer: [[1, 0], [3, 0], [3, 2], [1, 2]] }]);+  const intersection = left.intersection(right);+  const symmetric = left.symmetricDifference(right);+  const kernel = engine.structuringElement([[-0.5, -0.5], [0.5, -0.5], [0.5, 0.5], [-0.5, 0.5]]);+  const [offset, receipt] = left.offset(kernel);++  assert.equal(left.components().length, 1);+  assert.equal(left.components()[0]?.outer.length, 4);+  assert.deepEqual(intersection.valuations().area, { numerator: 2n, denominator: 1n });+  assert.equal(symmetric.valuations().eulerCharacteristic, 2n);+  assert.equal(left.locate([1, 1]), RegionLocation.Interior);+  assert.equal(left.locate([0, 1]), RegionLocation.Boundary);+  assert.equal(left.locate([3, 1]), RegionLocation.Exterior);+  assert.deepEqual(offset.valuations().area, { numerator: 9n, denominator: 1n });+  assert.equal(receipt.operation, MinkowskiOperation.Addition);+  assert(receipt.generatedPieces >= 1n);++  left.close();+  right.close();+  intersection.close();+  symmetric.close();+  kernel.close();+  offset.close(); });  test("invalid coordinate preserves typed witness", () => {

@@ -4,12 +4,29 @@   ml_runtime_initialize   ml_delaunay_f64   ml_mesh_insert_many_f64-  ml_mesh_union-  ml_mesh_intersection-  ml_mesh_difference-  ml_mesh_symmetric_difference+  ml_mesh_site_union+  ml_mesh_site_intersection+  ml_mesh_site_difference+  ml_mesh_site_symmetric_difference   ml_mesh_vertex_count   ml_mesh_triangle_count   ml_mesh_copy_vertices_f64   ml_mesh_copy_triangles_u32   ml_mesh_free+  ml_region_create_f64+  ml_region_counts+  ml_region_copy_f64+  ml_region_union+  ml_region_intersection+  ml_region_difference+  ml_region_symmetric_difference+  ml_region_locate_point_f64+  ml_region_measure+  ml_region_free+  ml_structuring_element_create_f64+  ml_structuring_element_free+  ml_region_minkowski_sum+  ml_region_offset+  ml_region_inset+  ml_region_open+  ml_region_close

@@ -44,5 +44,5 @@ #endif  ML_API uint32_t ml_abi_version(void) {-  return 1;+  return 2; }

@@ -15,16 +15,20 @@ #endif  typedef struct ml_mesh ml_mesh;+typedef struct ml_region ml_region;+typedef struct ml_structuring_element ml_structuring_element; typedef uint32_t ml_status; typedef uint32_t ml_obstruction_code; typedef uint32_t ml_coordinate_error;+typedef uint32_t ml_region_location;+typedef uint32_t ml_minkowski_operation;  enum {   ML_STATUS_OK = 0,   ML_STATUS_NULL_POINTER = 1,   ML_STATUS_COUNT_OVERFLOW = 2,   ML_STATUS_BUFFER_TOO_SMALL = 3,-  ML_STATUS_BUILD_OBSTRUCTION = 4,+  ML_STATUS_GEOMETRY_OBSTRUCTION = 4,   ML_STATUS_RUNTIME_FAILURE = 5 }; @@ -84,10 +88,18 @@   ML_OBSTRUCTION_FACE_CAPACITY_EXCEEDED = 52,   ML_OBSTRUCTION_PAYLOAD_STORAGE_FAILURE = 53,   ML_OBSTRUCTION_COORDINATE_PAYLOAD_COUNT_MISMATCH = 54,+  ML_OBSTRUCTION_CIRCLE_SWEEP_REQUIRES_DENSE_STORAGE = 55,   ML_OBSTRUCTION_NULL_POINTER = 100,   ML_OBSTRUCTION_COUNT_OVERFLOW = 101,   ML_OBSTRUCTION_BUFFER_TOO_SMALL = 102,-  ML_OBSTRUCTION_RUNTIME_FAILURE = 103+  ML_OBSTRUCTION_RUNTIME_FAILURE = 103,+  ML_OBSTRUCTION_REGION_LAYOUT_INVALID = 200,+  ML_OBSTRUCTION_REGION_VALIDATION_FAILED = 201,+  ML_OBSTRUCTION_OVERLAY_FAILED = 202,+  ML_OBSTRUCTION_REGION_PUBLICATION_FAILED = 203,+  ML_OBSTRUCTION_VALUATION_FAILED = 204,+  ML_OBSTRUCTION_MINKOWSKI_FAILED = 205,+  ML_OBSTRUCTION_REGION_PROJECTION_FAILED = 206 };  enum {@@ -98,6 +110,19 @@   ML_COORDINATE_ERROR_TOO_LARGE = 4 }; +enum {+  ML_REGION_EXTERIOR = 0,+  ML_REGION_BOUNDARY = 1,+  ML_REGION_INTERIOR = 2+};++enum {+  ML_MINKOWSKI_ADDITION = 0,+  ML_MINKOWSKI_EROSION = 1,+  ML_MINKOWSKI_OPENING = 2,+  ML_MINKOWSKI_CLOSING = 3+};+ typedef struct ml_obstruction {   uint32_t code;   uint32_t coordinate_error;@@ -111,19 +136,88 @@   char message[256]; } ml_obstruction; +typedef struct ml_minkowski_receipt {+  uint32_t operation;+  uint32_t reserved;+  uint64_t input_components;+  uint64_t convex_pieces;+  uint64_t generated_pieces;+  uint64_t generated_convolution_edges;+  uint64_t overlay_passes;+  uint64_t exact_crossings;+  uint64_t output_cells;+  uint64_t exact_coordinate_bit_growth;+} ml_minkowski_receipt;+ ML_API uint32_t ml_abi_version(void); ML_API ml_status ml_runtime_initialize(void);++/* Immutable Delaunay meshes; these operations combine site sets, not regions. */ ML_API ml_status ml_delaunay_f64(const double *coordinates, size_t point_count, ml_mesh **result, ml_obstruction *obstruction); ML_API ml_status ml_mesh_insert_many_f64(const ml_mesh *mesh, const double *coordinates, size_t point_count, ml_mesh **result, ml_obstruction *obstruction);-ML_API ml_status ml_mesh_union(const ml_mesh *left, const ml_mesh *right, ml_mesh **result, ml_obstruction *obstruction);-ML_API ml_status ml_mesh_intersection(const ml_mesh *left, const ml_mesh *right, ml_mesh **result, ml_obstruction *obstruction);-ML_API ml_status ml_mesh_difference(const ml_mesh *left, const ml_mesh *right, ml_mesh **result, ml_obstruction *obstruction);-ML_API ml_status ml_mesh_symmetric_difference(const ml_mesh *left, const ml_mesh *right, ml_mesh **result, ml_obstruction *obstruction);+ML_API ml_status ml_mesh_site_union(const ml_mesh *left, const ml_mesh *right, ml_mesh **result, ml_obstruction *obstruction);+ML_API ml_status ml_mesh_site_intersection(const ml_mesh *left, const ml_mesh *right, ml_mesh **result, ml_obstruction *obstruction);+ML_API ml_status ml_mesh_site_difference(const ml_mesh *left, const ml_mesh *right, ml_mesh **result, ml_obstruction *obstruction);+ML_API ml_status ml_mesh_site_symmetric_difference(const ml_mesh *left, const ml_mesh *right, ml_mesh **result, ml_obstruction *obstruction); ML_API ml_status ml_mesh_vertex_count(const ml_mesh *mesh, size_t *count, ml_obstruction *obstruction); ML_API ml_status ml_mesh_triangle_count(const ml_mesh *mesh, size_t *count, ml_obstruction *obstruction); ML_API ml_status ml_mesh_copy_vertices_f64(const ml_mesh *mesh, double *coordinates, size_t point_capacity, size_t *points_written, ml_obstruction *obstruction); ML_API ml_status ml_mesh_copy_triangles_u32(const ml_mesh *mesh, uint32_t *triangles, size_t triangle_capacity, size_t *triangles_written, ml_obstruction *obstruction); ML_API void ml_mesh_free(ml_mesh *mesh);++/*+ * Bulk exact-region authoring. loop_point_counts gives the number of points in+ * each loop; component_loop_counts gives the number of loops in each component.+ * Within each component, the first loop is a CCW outer loop and subsequent+ * loops are CW holes.+ */+ML_API ml_status ml_region_create_f64(+  const double *coordinates,+  size_t point_count,+  const size_t *loop_point_counts,+  size_t loop_count,+  const size_t *component_loop_counts,+  size_t component_count,+  ml_region **result,+  ml_obstruction *obstruction+);+ML_API ml_status ml_region_counts(const ml_region *region, size_t *component_count, size_t *loop_count, size_t *point_count, ml_obstruction *obstruction);+/* Capacities count points or offset entries; copied coordinates are a derived binary64 rendering projection. */+ML_API ml_status ml_region_copy_f64(+  const ml_region *region,+  double *coordinates,+  size_t point_capacity,+  size_t *loop_point_offsets,+  size_t loop_offset_capacity,+  size_t *component_loop_offsets,+  size_t component_offset_capacity,+  ml_obstruction *obstruction+);+ML_API ml_status ml_region_union(const ml_region *left, const ml_region *right, ml_region **result, ml_obstruction *obstruction);+ML_API ml_status ml_region_intersection(const ml_region *left, const ml_region *right, ml_region **result, ml_obstruction *obstruction);+ML_API ml_status ml_region_difference(const ml_region *left, const ml_region *right, ml_region **result, ml_obstruction *obstruction);+ML_API ml_status ml_region_symmetric_difference(const ml_region *left, const ml_region *right, ml_region **result, ml_obstruction *obstruction);+ML_API ml_status ml_region_locate_point_f64(const ml_region *region, double x, double y, ml_region_location *location, ml_obstruction *obstruction);+/* area_bytes_written excludes the trailing NUL; area_capacity includes it. */+ML_API ml_status ml_region_measure(+  const ml_region *region,+  int64_t *euler_characteristic,+  char *area_ratio_utf8,+  size_t area_capacity,+  size_t *area_bytes_written,+  double *perimeter_lower,+  double *perimeter_upper,+  ml_obstruction *obstruction+);+ML_API void ml_region_free(ml_region *region);++ML_API ml_status ml_structuring_element_create_f64(const double *coordinates, size_t point_count, ml_structuring_element **result, ml_obstruction *obstruction);+ML_API void ml_structuring_element_free(ml_structuring_element *element);+ML_API ml_status ml_region_minkowski_sum(const ml_region *left, const ml_region *right, ml_region **result, ml_minkowski_receipt *receipt, ml_obstruction *obstruction);+ML_API ml_status ml_region_offset(const ml_structuring_element *element, const ml_region *region, ml_region **result, ml_minkowski_receipt *receipt, ml_obstruction *obstruction);+ML_API ml_status ml_region_inset(const ml_structuring_element *element, const ml_region *region, ml_region **result, ml_minkowski_receipt *receipt, ml_obstruction *obstruction);+ML_API ml_status ml_region_open(const ml_structuring_element *element, const ml_region *region, ml_region **result, ml_minkowski_receipt *receipt, ml_obstruction *obstruction);+ML_API ml_status ml_region_close(const ml_structuring_element *element, const ml_region *region, ml_region **result, ml_minkowski_receipt *receipt, ml_obstruction *obstruction);  #ifdef __cplusplus }

@@ -1,6 +1,6 @@ cabal-version:       3.4 name:                moonlight-triangulation-version:             1.2.0.1+version:             1.3.0.0 synopsis:            Delaunay meshes and exact planar-region algebra. description:         Delaunay and constrained Delaunay triangulation as a lawful                      finite-set algebra, together with exact rational planar@@ -19,6 +19,8 @@                      with natural-neighbour interpolation and Delaunay hierarchy                      hints; a bounded-concurrency interpreter for the join                      tournament; and a versioned binary serialization surface.+                     On GHC 9.14, a public cell-complex component interprets+                     admitted exact cell selections for Homology and Category.                      Failure is values: every refusal names its witness. license:             MIT license-file:        LICENSE@@ -38,6 +40,12 @@   CHANGELOG.md extra-source-files:   weeder.toml+  bench/delaunay-compare/README.md+  -- Receipts and their SVG projections remain beside the benchmark, but are+  -- not package inputs: taking a new measurement must not rebuild the library.+  bench/delaunay-compare/rust/Cargo.lock+  bench/delaunay-compare/rust/Cargo.toml+  bench/delaunay-compare/rust/src/lib.rs   include/moonlight_triangulation.h   bindings/README.md   bindings/python/pyproject.toml@@ -58,6 +66,12 @@   location: https://github.com/PaleRoses/moonlight.git   subdir:   moonlight-triangulation +source-repository this+  type:     git+  location: https://github.com/PaleRoses/moonlight.git+  tag:      moonlight-triangulation-1.3.0.0+  subdir:   moonlight-triangulation+ flag warnings-as-errors   description: Treat compiler warnings as errors in package validation.   default: False@@ -78,11 +92,19 @@     -Wno-missing-import-lists   if flag(warnings-as-errors)     ghc-options: -Werror+  -- The hot modules that request LLVM O3 replace GHC's default optimiser+  -- recipe. GHC 9.8 therefore needs its supported legacy pass manager stated+  -- explicitly; LLVM 15 otherwise combines the new manager with old TBAA+  -- pass flags and refuses before code generation.+  if impl(ghc < 9.10)+    ghc-options: -optlo-enable-new-pm=0  -- ── the tower ────────────────────────────────────────────────────────────────--- The main tower is core <- dcel <- build <- dual <- facade.  Serialize branches+-- The main construction tower is core <- dcel <- build.  Dual branches directly+-- from dcel; the apex owns only the genuine overlaps: planar algebra descends+-- through build, while hierarchy hints glue build and dual. Serialize branches -- from dcel and parallel branches from build, keeping their effect dependencies--- out of the tower.  The graph is acyclic and uses no @.hs-boot@ files.+-- out of the tower. The graph is acyclic and uses no @.hs-boot@ files.  library core   import: shared-properties@@ -121,10 +143,8 @@     Moonlight.Triangulation.Dcel     Moonlight.Triangulation.Payload     Moonlight.Triangulation.JoinSemilattice-    Moonlight.Triangulation.Handles     Moonlight.Triangulation.Handles.HandleDefs     Moonlight.Triangulation.Handles.Dynamic-    Moonlight.Triangulation.Handles.Iterators     Moonlight.Triangulation.Handles.Iterators.CircularIterator     Moonlight.Triangulation.Handles.Iterators.DynamicIterators     Moonlight.Triangulation.Handles.Iterators.FixedIterators@@ -146,7 +166,6 @@     Moonlight.Triangulation.Internal.Mutable     Moonlight.Triangulation.Internal.OperationState     Moonlight.Triangulation.Internal.Probe-    Moonlight.Triangulation.Internal.DcelOperations     Moonlight.Triangulation.Internal.DcelOperations.CandidateArena     Moonlight.Triangulation.Internal.DcelOperations.Chain     Moonlight.Triangulation.Internal.DcelOperations.FlipRewrite@@ -169,27 +188,42 @@     , moonlight-triangulation:core   ghc-options: -fexpose-all-unfoldings +-- An ExactCellSet already carries every handle and closure witness needed to+-- interpret it as a generic finite cell complex. This component is the+-- canonical owner of that interpretation and deliberately remains outside the+-- portable geometry tower because its Homology dependency requires GHC 9.14.+library cell-complex+  import: shared-properties+  visibility: public+  hs-source-dirs: src-cell-complex+  default-extensions:+    TypeFamilies+  exposed-modules:+    Moonlight.Triangulation.CellComplex+  if impl(ghc < 9.14)+    buildable: False+  build-depends:+    base >= 4.22 && < 5+    , containers >= 0.6 && < 0.9+    , moonlight-algebra:abstract >= 0.1 && < 0.2+    , moonlight-homology:cell-complex >= 0.1 && < 0.2+    , moonlight-triangulation:dcel+ library build   import: shared-properties   visibility: public-  hs-source-dirs:-    src-build-    src-embedding+  hs-source-dirs: src-build   exposed-modules:     Moonlight.Triangulation.BulkLoad     Moonlight.Triangulation.Removal     Moonlight.Triangulation.Session     Moonlight.Triangulation.Cdt-    Moonlight.Triangulation.Minkowski-    Moonlight.Triangulation.Overlay     Moonlight.Triangulation.Refinement     Moonlight.Triangulation.SetAlgebra     Moonlight.Triangulation.Internal.Cdt.Build     Moonlight.Triangulation.Internal.Cdt.Query     Moonlight.Triangulation.Internal.Cdt.Types     Moonlight.Triangulation.Internal.Cdt.Union-    Moonlight.Triangulation.Internal.Overlay.Arrangement-    Moonlight.Triangulation.Internal.Overlay.Resident     Moonlight.Triangulation.Internal.Join     Moonlight.Triangulation.Internal.Join.Seam   other-modules:@@ -213,10 +247,6 @@     Moonlight.Triangulation.Internal.Join.Plan     Moonlight.Triangulation.Internal.Join.Rebuild     Moonlight.Triangulation.Internal.Join.SiteSet-    Moonlight.Triangulation.Internal.Overlay.Embedding-    Moonlight.Triangulation.Internal.Overlay.Types-    Moonlight.Triangulation.Internal.Minkowski.Convex-    Moonlight.Triangulation.Internal.Minkowski.Types   build-depends:     base >= 4.19 && < 5     , containers >= 0.8 && < 0.9@@ -240,7 +270,6 @@     base >= 4.19 && < 5     , async >= 2.2 && < 2.3     , deepseq >= 1.5 && < 1.6-    , moonlight-triangulation:core     , moonlight-triangulation:build     , moonlight-triangulation:dcel   ghc-options: -fexpose-all-unfoldings@@ -277,7 +306,6 @@     Moonlight.Triangulation.Voronoi     Moonlight.Triangulation.Voronoi.Handles     Moonlight.Triangulation.Interpolation-    Moonlight.Triangulation.HintGenerator   other-modules:     Moonlight.Triangulation.Internal.InterpolationWorkspace   build-depends:@@ -287,16 +315,30 @@     , vector >= 0.13 && < 0.14     , moonlight-triangulation:core     , moonlight-triangulation:dcel-    , moonlight-triangulation:build   ghc-options: -fexpose-all-unfoldings  library   import: shared-properties-  hs-source-dirs: src-public+  hs-source-dirs:+    src-public+    src-planar   exposed-modules:     Moonlight.Triangulation+    Moonlight.Triangulation.HintGenerator+    Moonlight.Triangulation.Minkowski+    Moonlight.Triangulation.Overlay+    Moonlight.Triangulation.Internal.Overlay.Arrangement+    Moonlight.Triangulation.Internal.Overlay.Embedding+    Moonlight.Triangulation.Internal.Overlay.Resident+  other-modules:+    Moonlight.Triangulation.Internal.Minkowski.Convex+    Moonlight.Triangulation.Internal.Minkowski.Types+    Moonlight.Triangulation.Internal.Overlay.Types   build-depends:     base >= 4.19 && < 5+    , containers >= 0.8 && < 0.9+    , deepseq >= 1.5 && < 1.6+    , vector >= 0.13 && < 0.14     , moonlight-triangulation:core     , moonlight-triangulation:dcel     , moonlight-triangulation:build@@ -311,6 +353,7 @@     Moonlight.Triangulation.Foreign.ABI   build-depends:     base >= 4.19 && < 5+    , containers >= 0.8 && < 0.9     , vector >= 0.13 && < 0.14     , moonlight-triangulation     , moonlight-triangulation:build@@ -330,7 +373,7 @@     moonlight_triangulation.h   build-depends:     base >= 4.19 && < 5-    , moonlight-triangulation:ffi >= 1.2 && < 1.3+    , moonlight-triangulation:ffi >= 1.3 && < 1.4   ghc-options: -threaded   if os(windows)     options: standalone@@ -338,7 +381,7 @@   else     extra-libraries: pthread   if os(linux)-    lib-version-info: 1:0:0+    lib-version-info: 2:0:0  -- ── test slices ────────────────────────────────────────────────────────────── @@ -350,28 +393,22 @@  common triangulation-test-properties   import: shared-properties+  ghc-options: -O0   build-depends:     base >= 4.19 && < 5-    , deepseq >= 1.5 && < 1.6     , vector >= 0.13 && < 0.14-    , primitive >= 0.9 && < 0.10     , moonlight-triangulation  common triangulation-test-support-slice   other-modules: Support  common triangulation-native-test-slice-  -- The focused milestone spec reaches into the dedicated @src-embedding@-  -- root for exactly this one hidden certifier. Keeping that source root-  -- singular prevents package modules from becoming duplicate test home modules.-  hs-source-dirs: src-embedding   other-modules:     Moonlight.Triangulation.NativeSpec     Moonlight.Triangulation.FilteredPredicateOptimizationSpec     Moonlight.Triangulation.ExactEmbeddingSpec     Moonlight.Triangulation.OverlaySpec     Moonlight.Triangulation.RegionSpec-    Moonlight.Triangulation.Internal.Overlay.Embedding   -- The RTS options this module needs are named on the SUITES rather than   -- here, which is the one place the slice-owns-its-requirements rule cannot   -- hold.  @-with-rtsopts@ is CONCATENATED by GHC across repetitions, so a@@ -382,6 +419,8 @@   ghc-options: -threaded -rtsopts   build-depends:     containers >= 0.8 && < 0.9+    , deepseq >= 1.5 && < 1.6+    , primitive >= 0.9 && < 0.10     , moonlight-triangulation:core     , moonlight-triangulation:dcel     , moonlight-triangulation:build@@ -392,6 +431,7 @@   build-depends:     binary >= 0.8 && < 0.9     , bytestring >= 0.12 && < 0.13+    , deepseq >= 1.5 && < 1.6     , moonlight-triangulation:dcel     , moonlight-triangulation:serialize @@ -420,14 +460,12 @@     containers >= 0.8 && < 0.9     , moonlight-triangulation:core     , moonlight-triangulation:dcel-    , moonlight-triangulation:build  common triangulation-minkowski-law-slice   other-modules: Moonlight.Triangulation.MinkowskiSpec   build-depends:     moonlight-triangulation:core     , moonlight-triangulation:dcel-    , moonlight-triangulation:build  -- The agreement between the seam schedule and the reference rebuild.  It names -- an internal schedule, so it reaches below the wall and travels with the@@ -441,6 +479,25 @@   ghc-options: -threaded -rtsopts   build-depends: moonlight-triangulation:parallel +test-suite moonlight-triangulation-cell-complex-test+  import: shared-properties+  type: exitcode-stdio-1.0+  main-is: Main.hs+  hs-source-dirs: test/cell-complex+  default-extensions:+    TypeFamilies+  if impl(ghc < 9.14)+    buildable: False+  build-depends:+    base >= 4.22 && < 5+    , moonlight-homology:cell-complex >= 0.1 && < 0.2+    , moonlight-triangulation:build+    , moonlight-triangulation:cell-complex+    , moonlight-triangulation:dcel+    , tasty >= 1.4 && < 1.6+    , tasty-hunit >= 0.10 && < 0.11+    , vector >= 0.13 && < 0.14+ -- The single statement of the RTS environment every suite runs under: -N so -- that the concurrent tournament has more than one capability to be scheduled -- onto, -T so that the filtered-predicate test can read allocation counters.@@ -570,6 +627,7 @@     primitive >= 0.9 && < 0.10     , moonlight-triangulation:dcel     , moonlight-triangulation:build+    , moonlight-triangulation:ffi  common triangulation-dcel-benchmark-slice   other-modules: Moonlight.Triangulation.DcelBench@@ -591,7 +649,74 @@     containers >= 0.8 && < 0.9     , moonlight-triangulation:core     , moonlight-triangulation:dcel++-- The package-owned external construction board deliberately uses tasty-bench:+-- unlike the native work-counter slices above, its only lawful common metric+-- across Haskell and four Rust referents is elapsed or CPU time.  The Rust+-- crate is a foreign adapter; Moonlight owns the case algebra, agreement+-- descent, timing, receipt parser, and derived pictures here.+common triangulation-delaunay-compare-properties+  import: shared-properties+  ghc-options: -O2+  build-depends:+    base >= 4.19 && < 5+    , deepseq >= 1.5 && < 1.6     , moonlight-triangulation:build+    , moonlight-triangulation:dcel++executable moonlight-triangulation-delaunay-compare+  import: triangulation-delaunay-compare-properties+  ghc-options: -threaded -rtsopts+  main-is: Main.hs+  hs-source-dirs: bench/delaunay-compare+  other-modules:+    Moonlight.Triangulation.Bench.DelaunayCompare.Domain+    Moonlight.Triangulation.Bench.DelaunayCompare.Native+    Moonlight.Triangulation.Bench.DelaunayCompare.Suite+  build-depends:+    directory >= 1.3 && < 1.4+    , filepath >= 1.4 && < 1.6+    , process >= 1.6 && < 1.7+    , tasty-bench >= 0.3 && < 0.6+    , transformers >= 0.5 && < 0.7+    , unix >= 2.8 && < 2.9+    , vector >= 0.13 && < 0.14++executable moonlight-triangulation-delaunay-pictures+  import: triangulation-delaunay-compare-properties+  main-is: PictureMain.hs+  hs-source-dirs: bench/delaunay-compare+  other-modules:+    Moonlight.Triangulation.Bench.DelaunayCompare.Domain+    Moonlight.Triangulation.Bench.DelaunayCompare.Picture+  build-depends:+    containers >= 0.8 && < 0.9+    , directory >= 1.3 && < 1.4+    , filepath >= 1.4 && < 1.6+    , transformers >= 0.5 && < 0.7++executable moonlight-triangulation-category-observatory-export+  import: shared-properties+  main-is: Main.hs+  hs-source-dirs: app/category-observatory+  ghc-options: -Wall -Wcompat+  default-extensions:+    TypeFamilies+  if impl(ghc < 9.14)+    buildable: False+  build-depends:+    aeson >= 2.2 && < 2.4+    , base >= 4.22 && < 5+    , bytestring >= 0.12 && < 0.13+    , containers >= 0.6 && < 0.9+    , moonlight-category >= 1.1.0.0 && < 1.2+    , moonlight-category:simplicial >= 1.1.0.0 && < 1.2+    , moonlight-homology:cell-category >= 0.1 && < 0.2+    , moonlight-homology:cell-complex >= 0.1 && < 0.2+    , moonlight-triangulation:build+    , moonlight-triangulation:cell-complex+    , moonlight-triangulation:dcel+    , vector >= 0.13 && < 0.14  benchmark moonlight-triangulation-build-bench   import:

@@ -627,61 +627,49 @@   -> Either BuildError (BuildResult mode vertex directed undirected face) insertMany triangulation input = do   validateVertices input-  ensureCapacity (numVertices triangulation + V.length input)-  runST $ do-    mutable <--      thawTriangulationDense-        (numVertices triangulation + V.length input)-        triangulation-    operation <- newOperationState (halfEdgeCapacity mutable)-    table <- newMutablePointIndex (numVertices triangulation + V.length input)-    seeded <- seedPointTable mutable table-    case seeded of-      Left failure -> pure (Left failure)-      Right () -> do-        mapping <- newPrimArray (V.length input)-        freshBuffer <- MUV.new (V.length input)-        filled <- fill mutable operation table mapping freshBuffer 0 0 0 0-        case filled of-          Left failure -> pure (Left failure)-          Right (sumX, sumY, freshCount) -> do-            let !existingCount = V.length input - freshCount-            setCounter operation CounterInputPoints (V.length input)-            setCounter operation CounterUniquePoints freshCount-            setCounter operation CounterExistingPoints existingCount-            setCounter operation CounterDuplicatePoints existingCount-            inserted <--              if freshCount == 0-                then pure (Right 0)-                else do-                  let !scale = recip (fromIntegral freshCount)-                  arena <--                    fillRadialArena-                      mutable-                      (sumX * scale)-                      (sumY * scale)-                      (MUV.unsafeRead freshBuffer)-                      freshCount-                  orderedArena <- radiallyOrderArena arena-                  circleSweepInsert mutable operation orderedArena-            case inserted of-              Left failure -> pure (Left failure)-              Right seedCount -> do-                setCounter operation CounterSpatialSeedPoints seedCount-                frozenOutcome <- freezeTriangulation mutable-                case frozenOutcome of-                  Left failure -> pure (Left failure)-                  Right frozen -> do-                    mapped <- unsafeFreezePrimArray mapping-                    stats <- freezeBuildStats operation-                    pure-                      ( Right-                          BuildResult-                            { buildTriangulation = frozen-                            , buildInputVertices = mapped-                            , buildStats = stats-                            }-                      )+  (mapped, frozen, stats) <-+    runTransaction id DenseTransaction triangulation (V.length input) $ \mutable operation -> do+      table <- newMutablePointIndex (pointCapacity mutable)+      seeded <- seedPointTable mutable table+      case seeded of+        Left failure -> pure (Left failure)+        Right () -> do+          mapping <- newPrimArray (V.length input)+          freshBuffer <- MUV.new (V.length input)+          filled <- fill mutable operation table mapping freshBuffer 0 0 0 0+          case filled of+            Left failure -> pure (Left failure)+            Right (sumX, sumY, freshCount) -> do+              let !existingCount = V.length input - freshCount+              setCounter operation CounterInputPoints (V.length input)+              setCounter operation CounterUniquePoints freshCount+              setCounter operation CounterExistingPoints existingCount+              setCounter operation CounterDuplicatePoints existingCount+              inserted <-+                if freshCount == 0+                  then pure (Right 0)+                  else do+                    let !scale = recip (fromIntegral freshCount)+                    arena <-+                      fillRadialArena+                        mutable+                        (sumX * scale)+                        (sumY * scale)+                        (MUV.unsafeRead freshBuffer)+                        freshCount+                    orderedArena <- radiallyOrderArena arena+                    circleSweepInsert mutable operation orderedArena+              case inserted of+                Left failure -> pure (Left failure)+                Right seedCount -> do+                  setCounter operation CounterSpatialSeedPoints seedCount+                  Right <$> unsafeFreezePrimArray mapping+  pure+    BuildResult+      { buildTriangulation = frozen+      , buildInputVertices = mapped+      , buildStats = stats+      }  where   fill     :: forall s

@@ -4,7 +4,8 @@   ( ConstrainedDelaunayTriangulation   , CdtError (..)   , CorridorObstruction (..)-  , ConstraintResult (..)+  , ConstraintRecoveryResult (..)+  , ConstraintResult   , ConstraintOutcome (..)   , ConstraintBatchStats (..)   , ConstraintBatchResult (..)@@ -28,7 +29,7 @@   , constrainedSeamRightConstraintEvidence   , constrainedSeamConstraintStats   , constrainedSeamBuildStats-  , ConstraintSplitBatchResult (..)+  , ConstraintSplitBatchResult   , CdtBuildResult (..)   , constrainedDelaunay   , constrainedDelaunayMaximal@@ -104,8 +105,9 @@   , ConstrainedSeamSource (..)   , ConstraintConflict (..)   , ConstraintOutcome (..)-  , ConstraintResult (..)-  , ConstraintSplitBatchResult (..)+  , ConstraintRecoveryResult (..)+  , ConstraintResult+  , ConstraintSplitBatchResult   , CorridorObstruction (..)   ) import Moonlight.Triangulation.Internal.Cdt.Union

@@ -14,7 +14,18 @@  import Control.Monad.ST (ST) import Moonlight.Triangulation.Handles.HandleDefs (VertexId (..))-import Moonlight.Triangulation.Internal.DcelOperations+import Moonlight.Triangulation.Internal.DcelOperations.Chain+  ( extendLine+  , lineToArea+  , setupFirstVertex+  , setupSecondVertex+  , splitLineEdge+  )+import Moonlight.Triangulation.Internal.DcelOperations.Hull (insertOutsideHull)+import Moonlight.Triangulation.Internal.DcelOperations.Subdivide+  ( insertIntoFace+  , insertOnEdge+  ) import Moonlight.Triangulation.Internal.Location import Moonlight.Triangulation.Internal.Mutable import Moonlight.Triangulation.Internal.OperationState

@@ -6,6 +6,7 @@ module Moonlight.Triangulation.Internal.Cdt.Batch   ( recoverConstraints   , recoverConstraintBatch+  , finalizeConstraintBatch   , initialConstraintBatchStats   , interpretConstraintRequest   , interpretConstraintRequests

@@ -9,13 +9,13 @@   , constrainedDelaunayMaximal   ) where +import Data.Bifunctor (first) import qualified Data.Vector as V import Data.Primitive.PrimArray (PrimArray, indexPrimArray, sizeofPrimArray) import Data.Word (Word32) import Moonlight.Triangulation.BulkLoad (delaunay) import Moonlight.Triangulation.Handles.HandleDefs import Moonlight.Triangulation.Internal.Cdt.Batch (recoverConstraints)-import Moonlight.Triangulation.Internal.Cdt.Combinators (mapLeft) import Moonlight.Triangulation.Internal.Cdt.Types import Moonlight.Triangulation.Internal.Representation import Moonlight.Triangulation.Internal.Types@@ -37,13 +37,7 @@ constrainedDelaunay defaults inputVertices constraints = do   result <- constrainedDelaunayMaximal defaults inputVertices constraints   if V.null (cdtRejectedConstraints result)-    then-      Right-        BuildResult-          { buildTriangulation = cdtBuildTriangulation result-          , buildInputVertices = cdtBuildInputVertices result-          , buildStats = cdtBuildStats result-          }+    then Right (cdtAcceptedBuild result)     else Left (ConstraintInputConflicts (cdtRejectedConstraints result))  -- | Stable constrained bulk loading. Duplicate input vertices are rerouted to@@ -56,7 +50,7 @@   -> V.Vector (Int, Int)   -> Either (CdtError) (CdtBuildResult vertex directed undirected face) constrainedDelaunayMaximal defaults inputVertices constraints = do-  built <- mapLeft CdtBuildError (delaunay defaults inputVertices)+  built <- first CdtBuildError (delaunay defaults inputVertices)   let !mapping = buildInputVertices built       !initial = fromDelaunay (buildTriangulation built)   requests <- V.mapM (mapConstraintRequest mapping) constraints@@ -71,9 +65,12 @@           (V.zip constraints (constraintBatchOutcomes batch))   pure     CdtBuildResult-      { cdtBuildTriangulation = constraintBatchTriangulation batch-      , cdtBuildInputVertices = mapping-      , cdtBuildStats = buildStats built+      { cdtAcceptedBuild =+          BuildResult+            { buildTriangulation = constraintBatchTriangulation batch+            , buildInputVertices = mapping+            , buildStats = buildStats built+            }       , cdtRejectedConstraints = rejected       }  where

@@ -7,7 +7,6 @@   ( foldWhileM   , bindMutable   , asConstraintStep-  , mapLeft   , vertexInt   , directedInt   ) where@@ -57,11 +56,8 @@ -- | Relabel a step whose refusal is a build failure, so it composes with the -- constraint layer's own. asConstraintStep :: Functor f => f (Either BuildError a) -> f (Either (CdtError) a)-asConstraintStep = fmap (mapLeft CdtBuildError)+asConstraintStep = fmap (either (Left . CdtBuildError) Right) {-# INLINE asConstraintStep #-}--mapLeft :: (left -> right) -> Either left value -> Either right value-mapLeft convert = either (Left . convert) Right  vertexInt :: VertexId -> Int vertexInt (VertexId value) = fromIntegral value

@@ -32,7 +32,9 @@   ) import Moonlight.Triangulation.Internal.Cdt.Query (findMutableEdge) import Moonlight.Triangulation.Internal.Cdt.Types-import Moonlight.Triangulation.Internal.DcelOperations+import Moonlight.Triangulation.Internal.DcelOperations.FlipRewrite (flipEdge)+import Moonlight.Triangulation.Internal.DcelOperations.FlipRule (isFlippableEdge)+import Moonlight.Triangulation.Internal.DcelOperations.Legalize (legalizeEdges) import Moonlight.Triangulation.Internal.Growable (GrowableWord32) import Moonlight.Triangulation.Internal.Mutable import Moonlight.Triangulation.Internal.OperationState

@@ -6,21 +6,17 @@ module Moonlight.Triangulation.Internal.Cdt.Segment   ( addConstraintEdge   , addConstraintEdges-  , applyConstraintToExistingEndpoints-  , applyAndPublishConstraint-  , publishConstraintResult-  , insertPolylineVertices   , removeConstraintEdge   , retireConstraintEdge   ) where -import Control.Monad.ST (ST, runST)+import Control.Monad.ST (ST)+import Data.Bifunctor (first) import qualified Data.Vector as V import Data.Primitive.PrimArray (indexPrimArray, sizeofPrimArray) import Moonlight.Triangulation.BulkLoad (insertMany) import qualified Moonlight.Triangulation.Dcel as Dcel import Moonlight.Triangulation.Handles.HandleDefs-import Moonlight.Triangulation.Internal.Capacity (ensureCapacity) import Moonlight.Triangulation.Internal.Cdt.Admission   ( ConstraintAdmission (..)   , constraintAdmission@@ -29,7 +25,6 @@ import Moonlight.Triangulation.Internal.Cdt.Combinators   ( asConstraintStep   , bindMutable-  , mapLeft   ) import Moonlight.Triangulation.Internal.Cdt.Recovery (applyMutableConstraint) import Moonlight.Triangulation.Internal.Cdt.Site@@ -37,19 +32,16 @@   , placeConstraintEndpoint   ) import Moonlight.Triangulation.Internal.Cdt.Types-import Moonlight.Triangulation.Internal.DcelOperations+import Moonlight.Triangulation.Internal.DcelOperations.Legalize (legalizeEdges) import Moonlight.Triangulation.Internal.Growable   ( GrowableWord32   , newGrowableWord32   ) import Moonlight.Triangulation.Internal.Mutable-import Moonlight.Triangulation.Internal.OperationState-  ( Counter (..)-  , OperationState-  , addCounter-  , newOperationState-  )+import Moonlight.Triangulation.Internal.OperationState (OperationState)+import Moonlight.Triangulation.Internal.Paged (TransactionShape (LocalTransaction)) import Moonlight.Triangulation.Internal.Representation+import Moonlight.Triangulation.Internal.Transaction (runUnmeasuredTransaction) import Moonlight.Triangulation.Internal.Types import Moonlight.Triangulation.Math @@ -63,8 +55,8 @@   -> vertex   -> Either (CdtError) (ConstraintResult vertex directed undirected face) addConstraintEdge triangulation fromVertex toVertex = do-  _ <- mapLeft CdtBuildError (validatePoint Nothing fromPoint)-  _ <- mapLeft CdtBuildError (validatePoint Nothing toPoint)+  _ <- first CdtBuildError (validatePoint Nothing fromPoint)+  _ <- first CdtBuildError (validatePoint Nothing toPoint)   result <-     case         ( lookupExistingConstraintEndpoint triangulation fromPoint@@ -85,23 +77,21 @@  where   !fromPoint = position fromVertex   !toPoint = position toVertex-  -- Both endpoints may be new; neither may be. The reservation is for the peak.-  !capacity = Dcel.numVertices triangulation + 2    addConstraintWithEndpointPlacement = do-    mapLeft CdtBuildError (ensureCapacity capacity)-    runST $ do-      mutable <- thawTriangulation capacity triangulation-      operation <- newOperationState (halfEdgeCapacity mutable)-      programWords <- newGrowableWord32 256-      asConstraintStep (placeConstraintEndpoint mutable operation Nothing fromPoint fromVertex)-        `bindMutable` \from ->-          asConstraintStep (placeConstraintEndpoint mutable operation Nothing toPoint toVertex)-            `bindMutable` \to ->-              applyAndPublishConstraint programWords mutable operation from to+    (request, frozen) <-+      runUnmeasuredTransaction CdtBuildError LocalTransaction triangulation 2 $ \mutable operation -> do+        programWords <- newGrowableWord32 256+        asConstraintStep (placeConstraintEndpoint mutable operation Nothing fromPoint fromVertex)+          `bindMutable` \from ->+            asConstraintStep (placeConstraintEndpoint mutable operation Nothing toPoint toVertex)+              `bindMutable` \to ->+                recoverConstraintRequest programWords mutable operation from to+    pure (publishConstraintResult frozen request)+ -- | The common singleton case already owns both sites. Resolve them before--- opening topology, then retain the original payload and counter semantics in--- the transaction. The corridor worker is unchanged; only two redundant point+-- opening topology, then retain the original payload semantics in the+-- transaction. The corridor worker is unchanged; only two redundant point -- locations and two unused vertex-capacity reservations disappear. applyConstraintToExistingEndpoints   :: Triangulation 'Constrained vertex directed undirected face@@ -111,55 +101,42 @@   -> vertex   -> Either (CdtError) (ConstraintResult vertex directed undirected face) applyConstraintToExistingEndpoints triangulation from@(VertexId rawFrom) fromPayload to@(VertexId rawTo) toPayload =-  runST $ do-    mutable <- thawTriangulation (Dcel.numVertices triangulation) triangulation-    operation <- newOperationState (halfEdgeCapacity mutable)-    programWords <- newGrowableWord32 256-    addCounter operation CounterInputPoints 2-    addCounter operation CounterExistingPoints 2-    addCounter operation CounterDuplicatePoints 2-    writeVertexData mutable (fromIntegral rawFrom) fromPayload-    writeVertexData mutable (fromIntegral rawTo) toPayload-    applyAndPublishConstraint programWords mutable operation from to+  do+    (request, frozen) <-+      runUnmeasuredTransaction CdtBuildError LocalTransaction triangulation 0 $ \mutable operation -> do+        programWords <- newGrowableWord32 256+        writeVertexData mutable (fromIntegral rawFrom) fromPayload+        writeVertexData mutable (fromIntegral rawTo) toPayload+        recoverConstraintRequest programWords mutable operation from to+    pure (publishConstraintResult frozen request) -applyAndPublishConstraint+recoverConstraintRequest   :: GrowableWord32 s   -> MutableDcel s vertex directed undirected face   -> OperationState s   -> VertexId   -> VertexId-  -> ST s (Either (CdtError) (ConstraintResult vertex directed undirected face))-applyAndPublishConstraint programWords mutable operation from to =+  -> ST s (Either CdtError ConstraintRequestAccumulator)+recoverConstraintRequest programWords mutable operation from to =   applyMutableConstraint programWords mutable operation from to     `bindMutable` \applied ->       case applied of         MutableConstraintRejected blocking ->           pure (Left (ConstraintIntersection blocking))-        MutableConstraintAccepted request ->-          publishConstraintResult-            mutable-            (accumulatedRequestPath request)-            (accumulatedRequestAddedEdges request)-{-# INLINE applyAndPublishConstraint #-}+        MutableConstraintAccepted request -> pure (Right request)+{-# INLINE recoverConstraintRequest #-} --- | Close the transaction on an accepted request. The accumulated path runs--- newest-first, so it is reversed exactly once, here.+-- | Attach one accepted local result to the mesh published by the transaction. publishConstraintResult-  :: MutableDcel s vertex directed undirected face-  -> [DirectedEdgeId]-  -> Int-  -> ST s (Either (CdtError) (ConstraintResult vertex directed undirected face))-publishConstraintResult mutable reversedPath added = do-  frozenOutcome <- freezeTriangulation mutable-  pure $ case frozenOutcome of-    Left obstruction -> Left (CdtBuildError obstruction)-    Right frozen ->-      Right-        ConstraintResult-          { constraintTriangulation = frozen-          , constraintPath = V.fromList (reverse reversedPath)-          , constraintAddedEdges = added-          }+  :: Triangulation 'Constrained vertex directed undirected face+  -> ConstraintRequestAccumulator+  -> ConstraintResult vertex directed undirected face+publishConstraintResult frozen request =+  ConstraintRecoveryResult+    { constraintRecoveryTriangulation = frozen+    , constraintRecoveryPathReceipt = V.fromList (reverse (accumulatedRequestPath request))+    , constraintRecoveryAddedEdges = accumulatedRequestAddedEdges request+    }  -- | Insert a polyline's vertices and recover each adjacent segment as a -- constraint, optionally closing the final segment back to the first.@@ -199,7 +176,7 @@   -> V.Vector vertex   -> Either (CdtError) (Triangulation 'Constrained vertex directed undirected face, V.Vector VertexId) insertPolylineVertices triangulation points = do-  result <- mapLeft CdtBuildError (insertMany triangulation points)+  result <- first CdtBuildError (insertMany triangulation points)   let !mapping = buildInputVertices result   pure (buildTriangulation result, V.generate (sizeofPrimArray mapping) (VertexId . indexPrimArray mapping)) @@ -214,11 +191,11 @@   -- An edge carrying no constraint has nothing to retire, and answering that   -- without thawing is the difference between O(1) and a republished mesh.   | not (Dcel.isConstraintEdge triangulation edge) = Right triangulation-  | otherwise = runST $ do-      mutable <- thawTriangulation (Dcel.numVertices triangulation) triangulation-      operation <- newOperationState (halfEdgeCapacity mutable)-      retireConstraintEdge mutable operation edge `bindMutable` \() ->-        fmap (mapLeft CdtBuildError) (freezeTriangulation mutable)+  | otherwise = do+      (_, frozen) <-+        runUnmeasuredTransaction CdtBuildError LocalTransaction triangulation 0 $ \mutable operation ->+          retireConstraintEdge mutable operation edge+      pure frozen  where   edgeCount = Dcel.numUndirectedEdges triangulation 

@@ -1,39 +1,24 @@ {-# LANGUAGE BangPatterns #-} {-# LANGUAGE DataKinds #-}+{-# LANGUAGE ScopedTypeVariables #-}  -- | The splitting program: corridors that divide every constraint they cross, -- driven across as few sealed transactions as the vertex reservation allows. module Moonlight.Triangulation.Internal.Cdt.Split-  ( SplitChunkShape (..)-  , SplitReceipt (..)-  , SplitChunkOutcome (..)-  , SplitRequest (..)-  , SplitCursor (..)-  , SplitStep (..)-  , addConstraintAndSplit+  ( addConstraintAndSplit   , addConstraintsAndSplit-  , splitCensus-  , driveConstraintSplits-  , runSplitChunk-  , splitConstraintCorridor-  , mutableEdgeWasSplit-  , mutableConstraintBetween-  , repairRoundedSplit-  , lineIntersection   ) where -import Control.Monad.ST (ST, runST)+import Control.Monad.ST (ST) import Data.Bits (xor) import qualified Data.List as List import qualified Data.Vector as V import qualified Moonlight.Triangulation.Dcel as Dcel import Moonlight.Triangulation.Handles.HandleDefs-import Moonlight.Triangulation.Internal.Capacity (ensureCapacity) import Moonlight.Triangulation.Internal.Cdt.Combinators   ( asConstraintStep   , bindMutable   , directedInt-  , mapLeft   , vertexInt   ) import Moonlight.Triangulation.Internal.Cdt.Corridor@@ -57,11 +42,12 @@   , newGrowableWord32   ) import Moonlight.Triangulation.Internal.Mutable-import Moonlight.Triangulation.Internal.OperationState-  ( OperationState-  , newOperationState+import Moonlight.Triangulation.Internal.OperationState (OperationState)+import Moonlight.Triangulation.Internal.Paged+  ( TransactionShape (DenseTransaction, LocalTransaction)   ) import Moonlight.Triangulation.Internal.Representation+import Moonlight.Triangulation.Internal.Transaction (runUnmeasuredTransaction) import Moonlight.Triangulation.Internal.Types import Moonlight.Triangulation.Math @@ -95,22 +81,12 @@   = SplitSettled !SplitCursor   | SplitSuspended !SplitCursor --- | The singleton opens corridor-local copy-on-write pages; the batch pays one--- dense copy up front and writes flat.-data SplitChunkShape = SparseSplitChunk | DenseSplitChunk- -- | What one settled request leaves behind. data SplitReceipt = SplitReceipt   { splitReceiptPath :: !(V.Vector DirectedEdgeId)   , splitReceiptAdded :: {-# UNPACK #-} !Int   } -data SplitChunkOutcome vertex directed undirected face = SplitChunkOutcome-  { splitChunkTriangulation :: !(Triangulation 'Constrained vertex directed undirected face)-  , splitChunkReceipts :: ![SplitReceipt]-  , splitChunkSuspended :: !(Maybe SplitCursor)-  }- -- | Glue the requested segment, dividing every constraint it crosses at the -- crossing point rather than refusing it. One transaction carries the whole -- corridor: a singleton is a batch of one under the shared driver.@@ -123,19 +99,19 @@ addConstraintAndSplit makeVertex triangulation from to = do   validateEndpoints triangulation from to   if from == to-    then pure (ConstraintResult triangulation V.empty 0)+    then pure (ConstraintRecoveryResult triangulation V.empty 0)     else do       (published, receipts) <--        driveConstraintSplits SparseSplitChunk makeVertex triangulation (V.singleton (from, to))+        driveConstraintSplits LocalTransaction makeVertex triangulation (V.singleton (from, to))       pure         ( case receipts V.!? 0 of             Just receipt ->-              ConstraintResult-                { constraintTriangulation = published-                , constraintPath = splitReceiptPath receipt-                , constraintAddedEdges = splitReceiptAdded receipt+              ConstraintRecoveryResult+                { constraintRecoveryTriangulation = published+                , constraintRecoveryPathReceipt = splitReceiptPath receipt+                , constraintRecoveryAddedEdges = splitReceiptAdded receipt                 }-            Nothing -> ConstraintResult published V.empty 0+            Nothing -> ConstraintRecoveryResult published V.empty 0         )  -- | Divide every requested segment inside as few transactions as the vertex@@ -151,12 +127,12 @@   -> V.Vector (VertexId, VertexId)   -> Either (CdtError) (ConstraintSplitBatchResult vertex directed undirected face) addConstraintsAndSplit makeVertex triangulation requests = do-  (published, receipts) <- driveConstraintSplits DenseSplitChunk makeVertex triangulation requests+  (published, receipts) <- driveConstraintSplits DenseTransaction makeVertex triangulation requests   pure-    ConstraintSplitBatchResult-      { splitBatchTriangulation = published-      , splitBatchPaths = V.map splitReceiptPath receipts-      , splitBatchAddedEdges = V.sum (V.map splitReceiptAdded receipts)+    ConstraintRecoveryResult+      { constraintRecoveryTriangulation = published+      , constraintRecoveryPathReceipt = V.map splitReceiptPath receipts+      , constraintRecoveryAddedEdges = V.sum (V.map splitReceiptAdded receipts)       }  -- | The obstruction census for one request against a published mesh: how many@@ -191,7 +167,8 @@ -- that census ran against the very mesh the chunk thawed and is exact before -- any in-session rewrite. Termination follows. driveConstraintSplits-  :: SplitChunkShape+  :: forall vertex directed undirected face.+     TransactionShape   -> (Point -> vertex)   -> Triangulation 'Constrained vertex directed undirected face   -> V.Vector (VertexId, VertexId)@@ -204,6 +181,16 @@   V.mapM_ (uncurry (validateEndpoints base)) requests   advance base 0 [] Nothing  where+  advance+    :: Triangulation 'Constrained vertex directed undirected face+    -> Int+    -> [SplitReceipt]+    -> Maybe SplitCursor+    -> Either+        CdtError+        ( Triangulation 'Constrained vertex directed undirected face+        , V.Vector SplitReceipt+        )   advance triangulation start settled resumed     | start >= V.length requests =         Right (triangulation, V.fromList (reverse settled))@@ -222,24 +209,32 @@               | firstRound = V.replicate (V.length remaining) (1, Nothing)               | otherwise = V.map (splitCensus triangulation) remaining             !reservedSites = V.sum (V.map fst censuses)-            !capacity = Dcel.numVertices triangulation + 2 * reservedSites + 8+            !additionalCapacity = 2 * reservedSites + 8             -- The walk budget bounds divisions per request; constraints born             -- inside the chunk are covered by the reservation term.             !budget =               2 * (Dcel.numConstraints triangulation + 2 * reservedSites + V.length remaining)                 + Dcel.numUndirectedEdges triangulation                 + 8-        mapLeft CdtBuildError (ensureCapacity capacity)-        outcome <- runST $ do-          mutable <- case shape of-            SparseSplitChunk -> thawTriangulation capacity triangulation-            DenseSplitChunk -> thawTriangulationDense capacity triangulation-          operation <- newOperationState (halfEdgeCapacity mutable)-          programWords <- newGrowableWord32 32-          runSplitChunk makeVertex mutable operation programWords remaining censuses capacity budget resumed-        case outcome of-          SplitChunkOutcome published receipts suspended ->-            advance published (start + length receipts) (receipts ++ settled) suspended+        ((receipts, suspended), published) <-+          runUnmeasuredTransaction+            CdtBuildError+            shape+            triangulation+            additionalCapacity+            $ \mutable operation -> do+            programWords <- newGrowableWord32 32+            runSplitChunk+              makeVertex+              mutable+              operation+              programWords+              remaining+              censuses+              (pointCapacity mutable)+              budget+              resumed+        advance published (start + length receipts) (receipts ++ settled) suspended  -- | One sealed transaction over a prefix of the remaining requests. Receipts -- run newest-first; a suspension carries no receipt, so the settled count is@@ -254,12 +249,12 @@   -> Int   -> Int   -> Maybe SplitCursor-  -> ST s (Either (CdtError) (SplitChunkOutcome vertex directed undirected face))+  -> ST s (Either CdtError ([SplitReceipt], Maybe SplitCursor)) runSplitChunk makeVertex mutable operation programWords requests censuses capacity budget resumed =   go 0 [] resumed  where   go offset receipts pending-    | offset >= V.length requests = seal receipts Nothing+    | offset >= V.length requests = pure (Right (receipts, Nothing))     | otherwise =         let (from, to) = requests V.! offset         in case pending of@@ -285,19 +280,13 @@                         SplitSettled settledCursor ->                           go (offset + 1) (receiptOf settledCursor : receipts) Nothing                         SplitSuspended suspendedCursor ->-                          seal receipts (Just suspendedCursor)+                          pure (Right (receipts, Just suspendedCursor))    receiptOf cursor =     SplitReceipt       { splitReceiptPath = V.fromList (reverse (splitCursorPath cursor))       , splitReceiptAdded = splitCursorAdded cursor       }--  seal receipts suspended = do-    frozenOutcome <- freezeTriangulation mutable-    pure $ case frozenOutcome of-      Left obstruction -> Left (CdtBuildError obstruction)-      Right frozen -> Right (SplitChunkOutcome frozen receipts suspended)  splitConstraintCorridor   :: SplitRequest vertex