diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,88 @@
 
 ---
 
+## [0.17.7] - 2026-09-14
+
+Correctness-hardening point release on the 0.17.x line, consolidating the 0.17.6 breaking batch. It
+closes a family of silent cross-host correctness bugs in the equality, ordering, integer-narrowing
+and string primitives, and adds the systematic test coverage that exposed them. No kernel-surface
+breaking changes.
+
+### Highlights
+
+- **Silent-wrong primitives corrected across hosts**
+  ([#745](https://github.com/CategoricalData/hydra/issues/745),
+  [#742](https://github.com/CategoricalData/hydra/issues/742)): new shared cross-host fixtures
+  uncovered ~a dozen primitives (`equal`/`compare` on collections, float equality, `bigintToIntN`
+  narrowing, `parseUint*` bounds, astral-plane string ops) that returned wrong results on one or more
+  non-Haskell hosts while appearing to pass. All are now correct and verified per-host against the
+  Haskell reference oracle.
+- **Systematic test-coverage hardening**
+  ([#749](https://github.com/CategoricalData/hydra/issues/749)): new kernel coverage for previously
+  untested primitive behavior (equality/ordering collection depth, `notEqual`, `functions.const`/`flip`),
+  which drove wiring those primitives into every host's default-implementation fallback.
+- **Scale-preserving decimals across every lossy-double host**
+  ([#727](https://github.com/CategoricalData/hydra/issues/727),
+  [#719](https://github.com/CategoricalData/hydra/issues/719)): `Literal.decimal` gains a real
+  scale-preserving representation (coefficient + scale) in the Scheme, Emacs Lisp, Common Lisp and
+  TypeScript runtimes and coders, and the generated `Literal.Decimal` `equals`/`compareTo` on Java,
+  Python and Scala stop ignoring scale. The `scaleDistinctTestNames` skip list — which had been
+  masking the gap on five hosts — is deleted, so decimal scale is now verified everywhere rather
+  than excused.
+
+### Bug fixes
+
+- **[#745](https://github.com/CategoricalData/hydra/issues/745)** silent-wrong equality/ordering,
+  `bigintToIntN` narrowing, `parseUint32/64` bounds, and astral-plane `charAt`/`splitOn`/`compare`
+  across the eight non-Haskell hosts.
+- **[#742](https://github.com/CategoricalData/hydra/issues/742)** structural `equal`/`compare` on
+  maps, sets and nested decimals no longer falls back to scale-blind or print-based comparison
+  (including a hand-inlined Scala primitive that shadowed the overlay fix).
+- **[#743](https://github.com/CategoricalData/hydra/issues/743)** kernel JSON decoder now rejects an
+  `Either` object carrying both `left` and `right` keys instead of silently resolving one arm.
+- **[#740](https://github.com/CategoricalData/hydra/issues/740)** the recursive parametric union decoder
+  now emits an explicit type application instead of an untyped lambda, so recursive parametric-union
+  types generate and compile on the Java host; also fixes `update-json-kernel` reconcile to build a
+  complete inference universe so drifted kernel modules re-infer.
+- **[#720](https://github.com/CategoricalData/hydra/issues/720)** Python's
+  `hydra.lib.equality`/`ordering` did not satisfy IEEE `totalOrder` for floats, mis-ordering `NaN`
+  and signed zero.
+- **[#722](https://github.com/CategoricalData/hydra/issues/722)** two `kernelDefaultCoreProfile`
+  correctness defects: rule ids that referred to rules no longer present, and a stubbed
+  `isValidName` that accepted every name.
+
+### Improvements
+
+- **[#749](https://github.com/CategoricalData/hydra/issues/749)** `notEqual`/`const`/`flip` wired
+  into each host's `#609` default-implementation fallback; orphaned Avro coder test suite recovered.
+- **[#730](https://github.com/CategoricalData/hydra/issues/730)** a shared `~/.stack` build slot
+  (`bin/with-stack-slot.sh`) replaces the pgrep slot mechanic, serializing concurrent GHC builds
+  across the fleet behind a real mutex. The wrapper is now portable to macOS: `flock(1)` is
+  util-linux and absent there, so it is emulated via Perl's `flock()` where missing, and the
+  GNU-only `date -Is`/`date -d` calls are replaced with portable equivalents. Its bypass path also
+  no longer re-execs forever. Without these, every entry point that routes through the slot —
+  `bin/sync.sh`, `bin/test.sh`, `bin/run-bootstrapping-demo.sh` and `bin/prepare-release.sh` —
+  failed immediately on macOS.
+- **[#600](https://github.com/CategoricalData/hydra/issues/600)** the five published TypeScript
+  packages are subpath-import-only (uniform export surface).
+- **[#716](https://github.com/CategoricalData/hydra/issues/716)** `hydra.paths` reshaped onto the
+  term-graph model (`TermGraph`/`TypeGraph`), aligning path steps with the term and type grammars
+  and adding the link view of a graph; `mapKey`/`mapValue` collapse into a single `mapEntry` step.
+- **[#701](https://github.com/CategoricalData/hydra/issues/701)** module cache freshness is now a
+  Merkle hash over each module's dependency closure, so a change deep in the closure correctly
+  invalidates dependents.
+- **[#559](https://github.com/CategoricalData/hydra/issues/559)** host-agnostic build: the
+  remaining hand-coded host build logic is promoted into `hydra.build.*`, with Java as the
+  definitive second host.
+- **[#721](https://github.com/CategoricalData/hydra/issues/721)** `checkNestedModuleNames` packaging
+  check enforces the module-namespace no-prefix rule.
+
+### Documentation
+
+- **[#508](https://github.com/CategoricalData/hydra/issues/508)** de-Claude-speak documentation pass:
+  style-guide section added, stale paths and dead links repaired, agent-operations wiki pages moved
+  into `claude/`, and a `getting-started.md` guardrail against re-adding a TypeScript root export.
+
 ## [0.17.6] - 2026-08-30
 
 Point release on the 0.17.x line, and the last backward-incompatible batch before the 1.0 surface
diff --git a/hydra-pg.cabal b/hydra-pg.cabal
--- a/hydra-pg.cabal
+++ b/hydra-pg.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           hydra-pg
-version:        0.17.6
+version:        0.17.7
 synopsis:       Hydra's property-graph (TinkerPop/Gremlin) model and coder support
 description:    Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". Property graph support for Hydra
 category:       Data
@@ -77,7 +77,7 @@
       base >=4.19.0 && <4.22
     , bytestring >=0.11.5 && <0.13
     , containers >=0.6.7 && <0.8
-    , hydra-kernel ==0.17.6
-    , hydra-rdf ==0.17.6
+    , hydra-kernel ==0.17.7
+    , hydra-rdf ==0.17.7
     , scientific >=0.3.7 && <0.4
   default-language: Haskell2010
diff --git a/src/main/haskell/Com/Gdblab/PathAlgebra/Expressions.hs b/src/main/haskell/Com/Gdblab/PathAlgebra/Expressions.hs
--- a/src/main/haskell/Com/Gdblab/PathAlgebra/Expressions.hs
+++ b/src/main/haskell/Com/Gdblab/PathAlgebra/Expressions.hs
@@ -35,6 +35,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | A conjunction of two selection conditions
 data AndCondition =
diff --git a/src/main/haskell/Com/Gdblab/PathAlgebra/Syntax.hs b/src/main/haskell/Com/Gdblab/PathAlgebra/Syntax.hs
--- a/src/main/haskell/Com/Gdblab/PathAlgebra/Syntax.hs
+++ b/src/main/haskell/Com/Gdblab/PathAlgebra/Syntax.hs
@@ -7,6 +7,7 @@
 import qualified Hydra.Core as Core
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | An RPQ alternation: either of two sub-expressions
 data Alternation =
diff --git a/src/main/haskell/Hydra/Cypher/Features.hs b/src/main/haskell/Hydra/Cypher/Features.hs
--- a/src/main/haskell/Hydra/Cypher/Features.hs
+++ b/src/main/haskell/Hydra/Cypher/Features.hs
@@ -7,6 +7,7 @@
 import qualified Hydra.Core as Core
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Aggregate functions
 data AggregateFunctionFeatures =
diff --git a/src/main/haskell/Hydra/Cypher/OpenCypher.hs b/src/main/haskell/Hydra/Cypher/OpenCypher.hs
--- a/src/main/haskell/Hydra/Cypher/OpenCypher.hs
+++ b/src/main/haskell/Hydra/Cypher/OpenCypher.hs
@@ -8,6 +8,7 @@
 import qualified Hydra.Core as Core
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | An additive expression: a multiply/divide/modulo expression with zero or more +/- terms
 data AddOrSubtractExpression =
diff --git a/src/main/haskell/Hydra/Decode/Neo4j/Model.hs b/src/main/haskell/Hydra/Decode/Neo4j/Model.hs
--- a/src/main/haskell/Hydra/Decode/Neo4j/Model.hs
+++ b/src/main/haskell/Hydra/Decode/Neo4j/Model.hs
@@ -19,6 +19,7 @@
 import qualified Hydra.Util as Util
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Decoder for hydra.neo4j.model.Constraint
 constraint :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Model.Constraint
diff --git a/src/main/haskell/Hydra/Decode/Pg/Mapping.hs b/src/main/haskell/Hydra/Decode/Pg/Mapping.hs
--- a/src/main/haskell/Hydra/Decode/Pg/Mapping.hs
+++ b/src/main/haskell/Hydra/Decode/Pg/Mapping.hs
@@ -21,6 +21,7 @@
 import qualified Hydra.Util as Util
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Decoder for hydra.pg.mapping.AnnotationSchema
 annotationSchema :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Mapping.AnnotationSchema
diff --git a/src/main/haskell/Hydra/Decode/Pg/Model.hs b/src/main/haskell/Hydra/Decode/Pg/Model.hs
--- a/src/main/haskell/Hydra/Decode/Pg/Model.hs
+++ b/src/main/haskell/Hydra/Decode/Pg/Model.hs
@@ -19,6 +19,7 @@
 import qualified Hydra.Util as Util
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Decoder for hydra.pg.model.AdjacentEdge
 adjacentEdge :: (Graph.Graph -> Core.Term -> Either Errors.DecodingError v) -> Graph.Graph -> Core.Term -> Either Errors.DecodingError (Model.AdjacentEdge v)
diff --git a/src/main/haskell/Hydra/Demos/Genpg/Transform.hs b/src/main/haskell/Hydra/Demos/Genpg/Transform.hs
--- a/src/main/haskell/Hydra/Demos/Genpg/Transform.hs
+++ b/src/main/haskell/Hydra/Demos/Genpg/Transform.hs
@@ -51,6 +51,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Map as M
 import qualified Data.Set as S
 
diff --git a/src/main/haskell/Hydra/Dsl/Pg/Model.hs b/src/main/haskell/Hydra/Dsl/Pg/Model.hs
--- a/src/main/haskell/Hydra/Dsl/Pg/Model.hs
+++ b/src/main/haskell/Hydra/Dsl/Pg/Model.hs
@@ -13,6 +13,7 @@
 import qualified Hydra.Typed as Typed
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Map as M
 
 -- | DSL constructor for hydra.pg.model.AdjacentEdge
@@ -1186,7 +1187,7 @@
       Core.applicationArgument = (Typed.unTypedTerm v)}))
 
 -- | DSL constructor for hydra.pg.model.Graph
-graph :: Ord v => (Typed.TypedTerm (M.Map v (Model.Vertex v)) -> Typed.TypedTerm (M.Map v (Model.Edge v)) -> Typed.TypedTerm (Model.Graph v))
+graph :: Typed.TypedTerm (M.Map v (Model.Vertex v)) -> Typed.TypedTerm (M.Map v (Model.Edge v)) -> Typed.TypedTerm (Model.Graph v)
 graph vertices edges =
     Typed.TypedTerm (Core.TermRecord (Core.Record {
       Core.recordTypeName = (Core.Name "hydra.pg.model.Graph"),
@@ -1199,7 +1200,7 @@
           Core.fieldTerm = (Typed.unTypedTerm edges)}]}))
 
 -- | DSL accessor for the edges field of hydra.pg.model.Graph
-graphEdges :: Ord v => (Typed.TypedTerm (Model.Graph v) -> Typed.TypedTerm (M.Map v (Model.Edge v)))
+graphEdges :: Typed.TypedTerm (Model.Graph v) -> Typed.TypedTerm (M.Map v (Model.Edge v))
 graphEdges x =
     Typed.TypedTerm (Core.TermApplication (Core.Application {
       Core.applicationFunction = (Core.TermProject (Core.Projection {
@@ -1281,7 +1282,7 @@
             Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
 
 -- | DSL accessor for the vertices field of hydra.pg.model.Graph
-graphVertices :: Ord v => (Typed.TypedTerm (Model.Graph v) -> Typed.TypedTerm (M.Map v (Model.Vertex v)))
+graphVertices :: Typed.TypedTerm (Model.Graph v) -> Typed.TypedTerm (M.Map v (Model.Vertex v))
 graphVertices x =
     Typed.TypedTerm (Core.TermApplication (Core.Application {
       Core.applicationFunction = (Core.TermProject (Core.Projection {
@@ -1290,7 +1291,7 @@
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
 -- | DSL updater for the edges field of hydra.pg.model.Graph
-graphWithEdges :: Ord v => (Typed.TypedTerm (Model.Graph v) -> Typed.TypedTerm (M.Map v (Model.Edge v)) -> Typed.TypedTerm (Model.Graph v))
+graphWithEdges :: Typed.TypedTerm (Model.Graph v) -> Typed.TypedTerm (M.Map v (Model.Edge v)) -> Typed.TypedTerm (Model.Graph v)
 graphWithEdges original newVal =
     Typed.TypedTerm (Core.TermRecord (Core.Record {
       Core.recordTypeName = (Core.Name "hydra.pg.model.Graph"),
@@ -1307,7 +1308,7 @@
           Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
 
 -- | DSL updater for the vertices field of hydra.pg.model.Graph
-graphWithVertices :: Ord v => (Typed.TypedTerm (Model.Graph v) -> Typed.TypedTerm (M.Map v (Model.Vertex v)) -> Typed.TypedTerm (Model.Graph v))
+graphWithVertices :: Typed.TypedTerm (Model.Graph v) -> Typed.TypedTerm (M.Map v (Model.Vertex v)) -> Typed.TypedTerm (Model.Graph v)
 graphWithVertices original newVal =
     Typed.TypedTerm (Core.TermRecord (Core.Record {
       Core.recordTypeName = (Core.Name "hydra.pg.model.Graph"),
diff --git a/src/main/haskell/Hydra/Encode/Neo4j/Model.hs b/src/main/haskell/Hydra/Encode/Neo4j/Model.hs
--- a/src/main/haskell/Hydra/Encode/Neo4j/Model.hs
+++ b/src/main/haskell/Hydra/Encode/Neo4j/Model.hs
@@ -13,6 +13,7 @@
 import qualified Hydra.Neo4j.Model as Model
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Encoder for hydra.neo4j.model.Constraint
 constraint :: Model.Constraint -> Core.Term
diff --git a/src/main/haskell/Hydra/Encode/Pg/Mapping.hs b/src/main/haskell/Hydra/Encode/Pg/Mapping.hs
--- a/src/main/haskell/Hydra/Encode/Pg/Mapping.hs
+++ b/src/main/haskell/Hydra/Encode/Pg/Mapping.hs
@@ -12,6 +12,7 @@
 import qualified Hydra.Pg.Mapping as Mapping
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Encoder for hydra.pg.mapping.AnnotationSchema
 annotationSchema :: Mapping.AnnotationSchema -> Core.Term
diff --git a/src/main/haskell/Hydra/Encode/Pg/Model.hs b/src/main/haskell/Hydra/Encode/Pg/Model.hs
--- a/src/main/haskell/Hydra/Encode/Pg/Model.hs
+++ b/src/main/haskell/Hydra/Encode/Pg/Model.hs
@@ -11,6 +11,7 @@
 import qualified Hydra.Pg.Model as Model
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Encoder for hydra.pg.model.AdjacentEdge
 adjacentEdge :: (v -> Core.Term) -> Model.AdjacentEdge v -> Core.Term
diff --git a/src/main/haskell/Hydra/Error/Neo4j.hs b/src/main/haskell/Hydra/Error/Neo4j.hs
--- a/src/main/haskell/Hydra/Error/Neo4j.hs
+++ b/src/main/haskell/Hydra/Error/Neo4j.hs
@@ -8,6 +8,7 @@
 import qualified Hydra.Neo4j.Model as Model
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | An error indicating that a Neo4j property graph is invalid
 data InvalidGraphError =
diff --git a/src/main/haskell/Hydra/Error/Pg.hs b/src/main/haskell/Hydra/Error/Pg.hs
--- a/src/main/haskell/Hydra/Error/Pg.hs
+++ b/src/main/haskell/Hydra/Error/Pg.hs
@@ -8,6 +8,7 @@
 import qualified Hydra.Pg.Model as Model
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | An error indicating that an edge is invalid
 data InvalidEdgeError =
diff --git a/src/main/haskell/Hydra/Graphviz/Coder.hs b/src/main/haskell/Hydra/Graphviz/Coder.hs
--- a/src/main/haskell/Hydra/Graphviz/Coder.hs
+++ b/src/main/haskell/Hydra/Graphviz/Coder.hs
@@ -37,7 +37,7 @@
 import qualified Hydra.Regex as Regex
 import qualified Hydra.Relational as Relational
 import qualified Hydra.Rewriting as Rewriting
-import qualified Hydra.Shredding as Shredding
+import qualified Hydra.Subterms as Subterms
 import qualified Hydra.System as System
 import qualified Hydra.Tabular as Tabular
 import qualified Hydra.Testing as Testing
@@ -50,8 +50,26 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Map as M
 
+-- | Collect (target binding, printed path) for every let-reference in a term node's tree
+collectLetRefs :: Paths.SubtermPath -> Paths.TermNode -> [(Core.Name, String)]
+collectLetRefs path node =
+
+      let steps = Paths.unSubtermPath path
+      in (Lists.concat (Lists.map (\link -> case link of
+        Paths.TermLinkReference v0 -> case (Paths.termReferenceLinkTarget v0) of
+          Paths.TermReferenceLet v1 -> [
+            (
+              Paths.letVariableReferenceVariable v1,
+              (PrintPaths.subtermPath (Paths.SubtermPath (Lists.concat2 steps [
+                Paths.termReferenceLinkStep v0]))))]
+          _ -> []
+        Paths.TermLinkSubterm v0 -> collectLetRefs (Paths.SubtermPath (Lists.concat2 steps [
+          Paths.subtermLinkStep v0])) (Paths.subtermLinkChild v0)
+        _ -> []) (Paths.termNodeLinks node)))
+
 -- | Convert a typed graph to a subterm-style (link-view) DOT graph
 graphToSubtermDotGraph :: Graph.Graph -> Dot.Graph
 graphToSubtermDotGraph graph =
@@ -61,40 +79,34 @@
       Dot.graphId = Nothing,
       Dot.graphStatements = (graphToSubtermDotStmts standardNamespaces graph)}
 
--- | Convert a typed graph to subterm-style (link-view) DOT statements
+-- | Convert a typed graph to binding-level DOT statements over the term graph
 graphToSubtermDotStmts :: M.Map Packaging.ModuleName String -> Graph.Graph -> [Dot.Stmt]
 graphToSubtermDotStmts namespaces graph =
-    Eithers.either (\_ -> []) (\sg ->
-      let nodes = Paths.subtermGraphNodes sg
+    Eithers.either (\_ -> []) (\tg ->
+      let roots = Paths.termGraphRoots tg
+          names = Maps.keys roots
           labelsVisited =
-                  Lists.foldl (\acc -> \node ->
+                  Lists.foldl (\acc -> \name ->
                     let accLabels = Pairs.first acc
                         accVisited = Pairs.second acc
-                        name = Paths.subtermNodeName node
                         raw = Names.compactName namespaces name
                         uniq = Names.chooseUniqueLabel accVisited raw
-                    in (Maps.insert name uniq accLabels, (Sets.insert uniq accVisited))) (Maps.empty, Sets.empty) nodes
+                    in (Maps.insert name uniq accLabels, (Sets.insert uniq accVisited))) (Maps.empty, Sets.empty) names
           labels = Pairs.first labelsVisited
           labelOf = \name -> Optionals.withDefault (Core.unName name) (Maps.lookup name labels)
           nodeStmt =
-                  \node -> Dot.StmtNode (Dot.NodeStmt {
-                    Dot.nodeStmtId = (toNodeId (Dot.Id (labelOf (Paths.subtermNodeName node)))),
+                  \name -> Dot.StmtNode (Dot.NodeStmt {
+                    Dot.nodeStmtId = (toNodeId (Dot.Id (labelOf name))),
                     Dot.nodeStmtAttributes = (Just (Dot.AttrList [
                       [
-                        labelAttr (labelOf (Paths.subtermNodeName node))]]))})
-          edgeStmtsForNode =
-                  \node ->
-                    let srcLabel = labelOf (Paths.subtermNodeName node)
-                        links = Paths.subtermNodeLinks node
-                    in (Optionals.mapOptional (\link -> case link of
-                      Paths.SubtermLinkEdge v0 ->
-                        let tgtLabel = labelOf (Paths.subtermEdgeTarget v0)
-                            showPath = PrintPaths.subtermPath (Paths.subtermEdgePath v0)
-                        in (Just (toEdgeStmt (Dot.Id srcLabel) (Dot.Id tgtLabel) (Just (Dot.AttrList [
-                          [
-                            labelAttr showPath]]))))
-                      _ -> Nothing) links)
-      in (Lists.concat2 (Lists.map nodeStmt nodes) (Lists.concat (Lists.map edgeStmtsForNode nodes)))) (Shredding.shredGraph graph)
+                        labelAttr (labelOf name)]]))})
+          edgeStmtsForRoot =
+                  \nm -> \node ->
+                    let srcLabel = labelOf nm
+                    in (Lists.map (\nt -> toEdgeStmt (Dot.Id srcLabel) (Dot.Id (labelOf (Pairs.first nt))) (Just (Dot.AttrList [
+                      [
+                        labelAttr (Pairs.second nt)]]))) (collectLetRefs (Paths.SubtermPath []) node))
+      in (Lists.concat2 (Lists.map nodeStmt names) (Lists.concat (Lists.map (\nt -> edgeStmtsForRoot (Pairs.first nt) (Pairs.second nt)) (Maps.toList roots))))) (Subterms.graphToTermGraph graph)
 
 -- | Create a DOT label attribute
 labelAttr :: String -> Dot.EqualityPair
diff --git a/src/main/haskell/Hydra/Graphviz/Dot.hs b/src/main/haskell/Hydra/Graphviz/Dot.hs
--- a/src/main/haskell/Hydra/Graphviz/Dot.hs
+++ b/src/main/haskell/Hydra/Graphviz/Dot.hs
@@ -7,6 +7,7 @@
 import qualified Hydra.Core as Core
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | A Graphviz DOT attribute list: one or more comma/semicolon-separated lists of key-value pairs
 newtype AttrList =
diff --git a/src/main/haskell/Hydra/Graphviz/Serde.hs b/src/main/haskell/Hydra/Graphviz/Serde.hs
--- a/src/main/haskell/Hydra/Graphviz/Serde.hs
+++ b/src/main/haskell/Hydra/Graphviz/Serde.hs
@@ -41,6 +41,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Convert an attribute list to an expression
 attrListToExpr :: Dot.AttrList -> Ast.Expr
diff --git a/src/main/haskell/Hydra/Neo4j/Model.hs b/src/main/haskell/Hydra/Neo4j/Model.hs
--- a/src/main/haskell/Hydra/Neo4j/Model.hs
+++ b/src/main/haskell/Hydra/Neo4j/Model.hs
@@ -7,6 +7,7 @@
 import qualified Hydra.Core as Core
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.ByteString as B
 import qualified Data.Int as I
 import qualified Data.Map as M
diff --git a/src/main/haskell/Hydra/Neo4j/Pg.hs b/src/main/haskell/Hydra/Neo4j/Pg.hs
--- a/src/main/haskell/Hydra/Neo4j/Pg.hs
+++ b/src/main/haskell/Hydra/Neo4j/Pg.hs
@@ -21,6 +21,7 @@
 import qualified Hydra.Util as Util
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Compute the property-graph edge label for a Neo4j relationship type, given the schema and endpoint labels.
 edgeLabelForRelationship :: Neo4jModel.GraphType -> Neo4jModel.NodeLabel -> Neo4jModel.NodeLabel -> Neo4jModel.RelationshipType -> PgModel.EdgeLabel
diff --git a/src/main/haskell/Hydra/Pg/Coder.hs b/src/main/haskell/Hydra/Pg/Coder.hs
--- a/src/main/haskell/Hydra/Pg/Coder.hs
+++ b/src/main/haskell/Hydra/Pg/Coder.hs
@@ -52,6 +52,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Map as M
 
 -- | Check a condition, returning an error if false
diff --git a/src/main/haskell/Hydra/Pg/Graphson/Coder.hs b/src/main/haskell/Hydra/Pg/Graphson/Coder.hs
--- a/src/main/haskell/Hydra/Pg/Graphson/Coder.hs
+++ b/src/main/haskell/Hydra/Pg/Graphson/Coder.hs
@@ -43,6 +43,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Map as M
 
 -- | Convert a GraphSON AdjacentEdge to a JSON Value. The Bool indicates whether this is an outgoing edge.
diff --git a/src/main/haskell/Hydra/Pg/Graphson/Construct.hs b/src/main/haskell/Hydra/Pg/Graphson/Construct.hs
--- a/src/main/haskell/Hydra/Pg/Graphson/Construct.hs
+++ b/src/main/haskell/Hydra/Pg/Graphson/Construct.hs
@@ -43,6 +43,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Map as M
 
 -- | Convert a property graph adjacent edge to a GraphSON adjacent edge
diff --git a/src/main/haskell/Hydra/Pg/Graphson/Syntax.hs b/src/main/haskell/Hydra/Pg/Graphson/Syntax.hs
--- a/src/main/haskell/Hydra/Pg/Graphson/Syntax.hs
+++ b/src/main/haskell/Hydra/Pg/Graphson/Syntax.hs
@@ -7,6 +7,7 @@
 import qualified Hydra.Core as Core
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Int as I
 import qualified Data.Map as M
 
diff --git a/src/main/haskell/Hydra/Pg/Graphson/Utils.hs b/src/main/haskell/Hydra/Pg/Graphson/Utils.hs
--- a/src/main/haskell/Hydra/Pg/Graphson/Utils.hs
+++ b/src/main/haskell/Hydra/Pg/Graphson/Utils.hs
@@ -45,6 +45,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Convert a list of property graph elements to a list of vertices with their adjacent edges
 elementsToVerticesWithAdjacentEdges :: Ord t0 => ([PgModel.Element t0] -> [PgModel.VertexWithAdjacentEdges t0])
diff --git a/src/main/haskell/Hydra/Pg/Mapping.hs b/src/main/haskell/Hydra/Pg/Mapping.hs
--- a/src/main/haskell/Hydra/Pg/Mapping.hs
+++ b/src/main/haskell/Hydra/Pg/Mapping.hs
@@ -9,6 +9,7 @@
 import qualified Hydra.Pg.Model as Model
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Configurable annotation keys for property graph mapping specifications
 data AnnotationSchema =
diff --git a/src/main/haskell/Hydra/Pg/Model.hs b/src/main/haskell/Hydra/Pg/Model.hs
--- a/src/main/haskell/Hydra/Pg/Model.hs
+++ b/src/main/haskell/Hydra/Pg/Model.hs
@@ -7,6 +7,7 @@
 import qualified Hydra.Core as Core
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Map as M
 
 -- | An edge which is adjacent to a given vertex. Only the other endpoint of the edge is provided.
diff --git a/src/main/haskell/Hydra/Pg/Printing.hs b/src/main/haskell/Hydra/Pg/Printing.hs
--- a/src/main/haskell/Hydra/Pg/Printing.hs
+++ b/src/main/haskell/Hydra/Pg/Printing.hs
@@ -40,6 +40,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Print an edge using the provided value printer
 printEdge :: (t0 -> String) -> PgModel.Edge t0 -> String
diff --git a/src/main/haskell/Hydra/Pg/Query.hs b/src/main/haskell/Hydra/Pg/Query.hs
--- a/src/main/haskell/Hydra/Pg/Query.hs
+++ b/src/main/haskell/Hydra/Pg/Query.hs
@@ -8,6 +8,7 @@
 import qualified Hydra.Pg.Model as Model
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | An aggregation query over a property graph
 data AggregationQuery =
diff --git a/src/main/haskell/Hydra/Pg/Rdf/Environment.hs b/src/main/haskell/Hydra/Pg/Rdf/Environment.hs
--- a/src/main/haskell/Hydra/Pg/Rdf/Environment.hs
+++ b/src/main/haskell/Hydra/Pg/Rdf/Environment.hs
@@ -9,6 +9,7 @@
 import qualified Hydra.Rdf.Syntax as Syntax
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | The environment for property graph to RDF mapping
 data PgRdfEnvironment v =
diff --git a/src/main/haskell/Hydra/Pg/Rdf/Mappings.hs b/src/main/haskell/Hydra/Pg/Rdf/Mappings.hs
--- a/src/main/haskell/Hydra/Pg/Rdf/Mappings.hs
+++ b/src/main/haskell/Hydra/Pg/Rdf/Mappings.hs
@@ -46,6 +46,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Convert edge types into property shape constraints for a given vertex label
 edgeTypesToPropertyShapes :: t0 -> (PgModel.EdgeLabel -> Syntax.Iri) -> PgModel.VertexLabel -> [PgModel.EdgeType t1] -> [ShaclModel.CommonConstraint]
diff --git a/src/main/haskell/Hydra/Pg/TermsToElements.hs b/src/main/haskell/Hydra/Pg/TermsToElements.hs
--- a/src/main/haskell/Hydra/Pg/TermsToElements.hs
+++ b/src/main/haskell/Hydra/Pg/TermsToElements.hs
@@ -51,6 +51,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Map as M
 
 -- | Apply a parsed pattern to a term, producing string terms
diff --git a/src/main/haskell/Hydra/Pg/Utils.hs b/src/main/haskell/Hydra/Pg/Utils.hs
--- a/src/main/haskell/Hydra/Pg/Utils.hs
+++ b/src/main/haskell/Hydra/Pg/Utils.hs
@@ -47,6 +47,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Default Tinkerpop annotation schema
 defaultTinkerpopAnnotations :: Mapping.AnnotationSchema
diff --git a/src/main/haskell/Hydra/Print/Error/Pg.hs b/src/main/haskell/Hydra/Print/Error/Pg.hs
--- a/src/main/haskell/Hydra/Print/Error/Pg.hs
+++ b/src/main/haskell/Hydra/Print/Error/Pg.hs
@@ -38,6 +38,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Show an invalid edge error as a string
 invalidEdgeError :: Pg.InvalidEdgeError -> String
diff --git a/src/main/haskell/Hydra/Tinkerpop/Examples/Modern.hs b/src/main/haskell/Hydra/Tinkerpop/Examples/Modern.hs
--- a/src/main/haskell/Hydra/Tinkerpop/Examples/Modern.hs
+++ b/src/main/haskell/Hydra/Tinkerpop/Examples/Modern.hs
@@ -8,6 +8,7 @@
 import qualified Hydra.Pg.Model as Model
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Map as M
 
 -- | The TinkerPop Modern property graph data, with int32 Literal ids
diff --git a/src/main/haskell/Hydra/Tinkerpop/Features.hs b/src/main/haskell/Hydra/Tinkerpop/Features.hs
--- a/src/main/haskell/Hydra/Tinkerpop/Features.hs
+++ b/src/main/haskell/Hydra/Tinkerpop/Features.hs
@@ -13,6 +13,7 @@
 import qualified Hydra.Core as Core
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Base interface for features that relate to supporting different data types.
 data DataTypeFeatures =
diff --git a/src/main/haskell/Hydra/Tinkerpop/Gremlin.hs b/src/main/haskell/Hydra/Tinkerpop/Gremlin.hs
--- a/src/main/haskell/Hydra/Tinkerpop/Gremlin.hs
+++ b/src/main/haskell/Hydra/Tinkerpop/Gremlin.hs
@@ -7,6 +7,7 @@
 import qualified Hydra.Core as Core
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Int as I
 
 -- | The arguments of a Gremlin as() step
diff --git a/src/main/haskell/Hydra/Tinkerpop/Language.hs b/src/main/haskell/Hydra/Tinkerpop/Language.hs
--- a/src/main/haskell/Hydra/Tinkerpop/Language.hs
+++ b/src/main/haskell/Hydra/Tinkerpop/Language.hs
@@ -40,6 +40,7 @@
 import qualified Hydra.Variants as Variants
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | Populate language constraints based on TinkerPop Graph.Features
 tinkerpopLanguage :: Coders.LanguageName -> Features.Features -> Features.ExtraFeatures t0 -> Coders.Language
diff --git a/src/main/haskell/Hydra/Validate/Neo4j.hs b/src/main/haskell/Hydra/Validate/Neo4j.hs
--- a/src/main/haskell/Hydra/Validate/Neo4j.hs
+++ b/src/main/haskell/Hydra/Validate/Neo4j.hs
@@ -18,6 +18,7 @@
 import qualified Hydra.Validation as Validation
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Set as S
 
 -- | All Neo4j validation rule names, as fully qualified 'hydra.error.neo4j.<UnionType>.<variant>' strings.
diff --git a/src/main/haskell/Hydra/Validate/Pg.hs b/src/main/haskell/Hydra/Validate/Pg.hs
--- a/src/main/haskell/Hydra/Validate/Pg.hs
+++ b/src/main/haskell/Hydra/Validate/Pg.hs
@@ -18,6 +18,7 @@
 import qualified Hydra.Validation as Validation
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 import qualified Data.Map as M
 
 -- | Append a rule-tagged InvalidEdgeError finding to a ValidationResult.
diff --git a/src/main/haskell/OpenGql/Grammar.hs b/src/main/haskell/OpenGql/Grammar.hs
--- a/src/main/haskell/OpenGql/Grammar.hs
+++ b/src/main/haskell/OpenGql/Grammar.hs
@@ -7,6 +7,7 @@
 import qualified Hydra.Core as Core
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines)
 import qualified Data.Scientific as Sci
+import Data.Void
 
 -- | A GQL abbreviated edge pattern: one of a fixed set of alternatives
 data AbbreviatedEdgePattern =