diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,145 @@
 
 ---
 
+## [0.17.1] - unreleased
+
+Development version. Opens the 0.17.x line — the first release built entirely against
+published 0.17.0 hosts (Hackage / PyPI / Maven Central), with the `hostOverrides` shims
+that were needed while 0.16.1 lacked the effect type and I/O primitives removed.
+
+### New features
+
+- **Generated term-reference DSLs** ([#467](https://github.com/CategoricalData/hydra/issues/467)):
+  kernel *term* modules now project generated DSL surfaces, completing the story begun with
+  type-module DSLs and the generated primitive wrappers (`hydra.dsl.lib.*`, 0.17.0). A
+  signature read-back in the DSL pass reuses the main pass's inference, and a demand-curated
+  set of 19 kernel term modules (plus the json/test/extract modules) emits one typed,
+  rename-safe reference per definition into every target language — e.g. Haskell
+  `Hydra.Dsl.Strip.deannotateType`, Java `hydra.dsl.Strip.deannotateType(...)`, Python
+  `hydra.dsl.strip.deannotate_type(...)`. The Java and Python coder sources were pivoted onto
+  the generated references, retiring ~700 stringly-typed inline `var("hydra....")` references
+  and shrinking Python's hand registry to the non-generatable remainder (byte-identical
+  generated output before and after). Follow-ups:
+  [#555](https://github.com/CategoricalData/hydra/issues/555) (typed references to derived
+  encode/decode/show functions via `TypedName`),
+  [#556](https://github.com/CategoricalData/hydra/issues/556) (non-kernel packages).
+- **Package validation** ([#574](https://github.com/CategoricalData/hydra/issues/574),
+  [#575](https://github.com/CategoricalData/hydra/issues/575)): a translingual `hydra.validate.*`
+  framework carries per-package `ValidationProfile`s (error/warning rules, error/warning caps) and a
+  catalog of checks — undeclared-package-dependency detection (now a fatal gate, #574),
+  definition-name convention (PascalCase), definition ordering, documentation completeness, and
+  conflicting-variant-name detection — layered on the existing core term/type well-formedness rules.
+  A kernel-strict / others-relaxed policy keeps `/sync` green fleet-wide while the documentation
+  backlog drains. See the new [Validation](https://github.com/CategoricalData/hydra/wiki/Validation)
+  wiki page for the full per-package constraint specification.
+- **DSL-authoring registration guards** ([#554](https://github.com/CategoricalData/hydra/issues/554)):
+  fail-fast authoring-time validation for the host-native DSL sources — every DSL-authoring module in
+  Java/`hydra-jvm`, Python, and Scala now asserts its definitions are fully registered
+  (`Defs.checkComplete` / `check_complete`), backed by a Haskell kernel-source registration-completeness
+  scanner, so a definition added to a source file but omitted from its `definitions` list fails loudly
+  instead of silently vanishing from the generated output.
+- **`hydra-build` package** ([#546](https://github.com/CategoricalData/hydra/issues/546),
+  [#529](https://github.com/CategoricalData/hydra/issues/529),
+  [#530](https://github.com/CategoricalData/hydra/issues/530)): the build-orchestration logic that had
+  lived only in host scripts is now translingual Hydra. Pure module-list utilities became
+  `hydra.build.modules` (#529) and the orphan-reconcile decision became `hydra.build.reconcile` (#530),
+  each with a translingual test suite; the `hydra.build.*` modules were then extracted into a dedicated
+  `hydra-build` package (#546), separate from the kernel.
+- **Metadata sidecar + content/version-addressed freshness**
+  ([#415](https://github.com/CategoricalData/hydra/issues/415)): dist manifests now carry a
+  `moduleFormatVersion` field, and the generator's freshness basis is content/version-addressed — the
+  groundwork for reproducible, cache-correct incremental generation.
+- **Structured generation-provenance record**
+  ([#523](https://github.com/CategoricalData/hydra/issues/523)): each generation run now records a
+  structured `Generation` provenance entry (digest v2), replacing the ad-hoc shell threading of
+  generation metadata.
+- **Worker + issue hierarchy** ([#557](https://github.com/CategoricalData/hydra/issues/557)): a
+  principled agent/worker framework — roles and parentage mirroring the GitHub issue tree, a
+  cross-worktree message transport with a verify-after-copy protocol, a blocking-aware design-question
+  (`decisions/`) channel, an issue-proposal queue with the `/issues` command, an autonomy-dial banner,
+  and cross-machine staging coordination. Contributor-facing process only; no change to generated code.
+
+### API and usability
+
+- **DSL usability passes** ([#430](https://github.com/CategoricalData/hydra/issues/430),
+  [#553](https://github.com/CategoricalData/hydra/issues/553)): reviewed the host-native Java, Python,
+  and Scala DSL surfaces for ergonomics and cross-host parity (documented def shapes, added a Scala
+  projection helper), bringing the three authoring dialects into closer alignment.
+
+### Fixed
+
+Bug fixes landed this cycle, grouped by area (see each issue for detail):
+
+- **TypeScript** — reactivated `hydra.lib.*` primitive tests surfaced encoder gaps: lazy show-calling
+  let bindings and compact bare-string `LiteralType` expansion in the test converter
+  ([#564](https://github.com/CategoricalData/hydra/issues/564)),
+  `binaryToBytes` registration + base64 binary decode in `decodeUtf8`
+  ([#561](https://github.com/CategoricalData/hydra/issues/561)),
+  `hydra.test.build.*` emission after the #546 split
+  ([#570](https://github.com/CategoricalData/hydra/issues/570)), and `HYDRA_DEFAULT_IMPLS` support in
+  the test runner ([#536](https://github.com/CategoricalData/hydra/issues/536)).
+- **Tests and CI** — restored the default-primitive-implementation testing solution
+  ([#388](https://github.com/CategoricalData/hydra/issues/388),
+  [#549](https://github.com/CategoricalData/hydra/issues/549)), reactivated previously-ignored kernel
+  test cases ([#513](https://github.com/CategoricalData/hydra/issues/513),
+  [#550](https://github.com/CategoricalData/hydra/issues/550)), wired the regression harnesses into CI
+  and split them out of the monolithic Haskell job for timeout headroom
+  ([#535](https://github.com/CategoricalData/hydra/issues/535),
+  [#563](https://github.com/CategoricalData/hydra/issues/563)), added Scala/Go/Lisp
+  self-containment gates to `verify-distribution.sh`
+  ([#537](https://github.com/CategoricalData/hydra/issues/537)), a manifest-JSON-tracked CI check
+  ([#541](https://github.com/CategoricalData/hydra/issues/541)), a per-package test-digest freshness
+  fix ([#551](https://github.com/CategoricalData/hydra/issues/551)), overlay-file restoration in
+  `test-stale-output-prune.sh` ([#558](https://github.com/CategoricalData/hydra/issues/558)), and a
+  sync-freshness fingerprint that now sees host-native DSL sources
+  ([#562](https://github.com/CategoricalData/hydra/issues/562)).
+- **Kernel and coders** — Java binary-literal signed-byte emission
+  ([#528](https://github.com/CategoricalData/hydra/issues/528)), `hydra.json.Decode.fromJson`
+  parametric-type (Application/Forall) support
+  ([#531](https://github.com/CategoricalData/hydra/issues/531)), stale 2-param `Coder` shape in
+  Java/Scala test bootstrap ([#552](https://github.com/CategoricalData/hydra/issues/552)), and a
+  kernel dead-code/TODO cleanup ([#538](https://github.com/CategoricalData/hydra/issues/538)).
+- **Lib and build** — `hydra.lib.files` copy/removeDirectory/status overlays across all nine hosts
+  ([#525](https://github.com/CategoricalData/hydra/issues/525)), `hydra.build.*` regeneration into the
+  Lisp dialects ([#544](https://github.com/CategoricalData/hydra/issues/544)), Scheme maps
+  last-writer-wins in `union` ([#545](https://github.com/CategoricalData/hydra/issues/545)),
+  standalone-kernel SHA dependency ([#542](https://github.com/CategoricalData/hydra/issues/542)),
+  the lexicon's empty Types section ([#539](https://github.com/CategoricalData/hydra/issues/539)), and
+  a duplicated generated-file header in `generate-head-haskell-build.py`
+  ([#540](https://github.com/CategoricalData/hydra/issues/540)).
+
+- **TypeScript overlay-import rewrite** ([#565](https://github.com/CategoricalData/hydra/issues/565)):
+  the TypeScript coder's lib overlay-import rewrite no longer captures `hydra.lib.defaults`, which is a
+  generated (not overlaid) module; excluding it fixes spurious import references in generated TypeScript.
+
+- **Lexicon generation** (`bin/regenerate-lexicon.sh`): the generator had been failing
+  silently since the encoder/decoder modules moved to in-memory synthesis
+  ([#448](https://github.com/CategoricalData/hydra/issues/448)) — the script masked the
+  failure and left a stale `docs/hydra-lexicon.txt` missing the four effectful primitive
+  libraries (`hydra.lib.{effects,files,system,text}`). The synthesized coder modules are
+  now included in the lexicon universe, the script fails loudly, and the regenerated
+  lexicon covers all 267 primitives across 17 library modules.
+- **`bin/prepare-release.sh`**: the non-blocking Java quality check invoked Gradle
+  subprojects (`:hydra-rdf4j:test` etc.) that were removed in
+  [#511](https://github.com/CategoricalData/hydra/issues/511), so it always warned without
+  checking anything; it now runs the `dist/java/hydra-pg` package tests (the current home
+  of the former binding tests).
+- **`.gitignore`**: the ignore rules for the overlaid hand-written Haskell runtime still
+  named pre-[#501](https://github.com/CategoricalData/hydra/issues/501) paths, so 41
+  duplicate copies under `dist/haskell/` had become tracked; the rules now match the
+  `Hydra/Overlay/` location and the duplicates are untracked.
+
+### Documentation
+
+- Corrected the 0.17.0 Maven coordinates throughout (Java artifacts publish under group
+  `net.fortytwo.hydra.java`, Scala under `net.fortytwo.hydra.scala`,
+  [#519](https://github.com/CategoricalData/hydra/issues/519)); added the npm and Scala
+  release channels to the README; added TypeScript/Scala/Lisp sections to Getting started;
+  repointed stale pre-#418/#501 DSL paths in the architecture docs; added GitHub issue and
+  PR templates.
+
+---
+
 ## [0.17.0] - 2026-07-01
 
 Major themes: first-class support for effects and I/O in the kernel, TypeScript and
diff --git a/hydra-haskell.cabal b/hydra-haskell.cabal
--- a/hydra-haskell.cabal
+++ b/hydra-haskell.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           hydra-haskell
-version:        0.17.0
+version:        0.17.1
 synopsis:       Hydra's Haskell coder: emit Haskell source from Hydra modules
 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". This package is Hydra's Haskell coder: it translates Hydra modules into Haskell source. The top-level entry point is moduleToHaskell (and moduleToHaskellModule for the structured AST). It builds on hydra-kernel.
 category:       Data
@@ -44,6 +44,6 @@
   build-depends:
       base >=4.19.0 && <4.22
     , containers >=0.6.7 && <0.8
-    , hydra-kernel ==0.17.0
+    , hydra-kernel ==0.17.1
     , scientific >=0.3.7 && <0.4
   default-language: Haskell2010
diff --git a/src/main/haskell/Hydra/Dsl/Haskell/Environment.hs b/src/main/haskell/Hydra/Dsl/Haskell/Environment.hs
--- a/src/main/haskell/Hydra/Dsl/Haskell/Environment.hs
+++ b/src/main/haskell/Hydra/Dsl/Haskell/Environment.hs
@@ -29,6 +29,10 @@
           Core.fieldName = (Core.Name "usesSet"),
           Core.fieldTerm = (Typed.unTypedTerm usesSet)}]}))
 
+-- | DSL name token for hydra.haskell.environment.HaskellModuleMetadata
+haskellModuleMetadataHaskellModuleMetadata :: Typed.TypedName Environment.HaskellModuleMetadata
+haskellModuleMetadataHaskellModuleMetadata = Typed.TypedName (Core.Name "hydra.haskell.environment.HaskellModuleMetadata")
+
 -- | DSL accessor for the usesByteString field of hydra.haskell.environment.HaskellModuleMetadata
 haskellModuleMetadataUsesByteString :: Typed.TypedTerm Environment.HaskellModuleMetadata -> Typed.TypedTerm Bool
 haskellModuleMetadataUsesByteString x =
diff --git a/src/main/haskell/Hydra/Dsl/Haskell/Syntax.hs b/src/main/haskell/Hydra/Dsl/Haskell/Syntax.hs
--- a/src/main/haskell/Hydra/Dsl/Haskell/Syntax.hs
+++ b/src/main/haskell/Hydra/Dsl/Haskell/Syntax.hs
@@ -27,6 +27,10 @@
           Core.fieldName = (Core.Name "binds"),
           Core.fieldTerm = (Typed.unTypedTerm binds)}]}))
 
+-- | DSL name token for hydra.haskell.syntax.Alternative
+alternativeAlternative :: Typed.TypedName Syntax.Alternative
+alternativeAlternative = Typed.TypedName (Core.Name "hydra.haskell.syntax.Alternative")
+
 -- | DSL accessor for the binds field of hydra.haskell.syntax.Alternative
 alternativeBinds :: Typed.TypedTerm Syntax.Alternative -> Typed.TypedTerm (Maybe Syntax.LocalBindings)
 alternativeBinds x =
@@ -139,6 +143,11 @@
           Core.fieldName = (Core.Name "operand"),
           Core.fieldTerm = (Typed.unTypedTerm operand)}]}))
 
+-- | DSL name token for hydra.haskell.syntax.ApplicationDeclarationHead
+applicationDeclarationHeadApplicationDeclarationHead :: Typed.TypedName Syntax.ApplicationDeclarationHead
+applicationDeclarationHeadApplicationDeclarationHead =
+    Typed.TypedName (Core.Name "hydra.haskell.syntax.ApplicationDeclarationHead")
+
 -- | DSL accessor for the function field of hydra.haskell.syntax.ApplicationDeclarationHead
 applicationDeclarationHeadFunction :: Typed.TypedTerm Syntax.ApplicationDeclarationHead -> Typed.TypedTerm Syntax.DeclarationHead
 applicationDeclarationHeadFunction x =
@@ -204,6 +213,10 @@
           Core.fieldName = (Core.Name "argument"),
           Core.fieldTerm = (Typed.unTypedTerm argument)}]}))
 
+-- | DSL name token for hydra.haskell.syntax.ApplicationExpression
+applicationExpressionApplicationExpression :: Typed.TypedName Syntax.ApplicationExpression
+applicationExpressionApplicationExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.ApplicationExpression")
+
 -- | DSL accessor for the argument field of hydra.haskell.syntax.ApplicationExpression
 applicationExpressionArgument :: Typed.TypedTerm Syntax.ApplicationExpression -> Typed.TypedTerm Syntax.Expression
 applicationExpressionArgument x =
@@ -269,6 +282,10 @@
           Core.fieldName = (Core.Name "args"),
           Core.fieldTerm = (Typed.unTypedTerm args)}]}))
 
+-- | DSL name token for hydra.haskell.syntax.ApplicationPattern
+applicationPatternApplicationPattern :: Typed.TypedName Syntax.ApplicationPattern
+applicationPatternApplicationPattern = Typed.TypedName (Core.Name "hydra.haskell.syntax.ApplicationPattern")
+
 -- | DSL accessor for the args field of hydra.haskell.syntax.ApplicationPattern
 applicationPatternArgs :: Typed.TypedTerm Syntax.ApplicationPattern -> Typed.TypedTerm [Syntax.Pattern]
 applicationPatternArgs x =
@@ -334,6 +351,10 @@
           Core.fieldName = (Core.Name "argument"),
           Core.fieldTerm = (Typed.unTypedTerm argument)}]}))
 
+-- | DSL name token for hydra.haskell.syntax.ApplicationType
+applicationTypeApplicationType :: Typed.TypedName Syntax.ApplicationType
+applicationTypeApplicationType = Typed.TypedName (Core.Name "hydra.haskell.syntax.ApplicationType")
+
 -- | DSL accessor for the argument field of hydra.haskell.syntax.ApplicationType
 applicationTypeArgument :: Typed.TypedTerm Syntax.ApplicationType -> Typed.TypedTerm Syntax.Type
 applicationTypeArgument x =
@@ -399,6 +420,10 @@
           Core.fieldName = (Core.Name "inner"),
           Core.fieldTerm = (Typed.unTypedTerm inner)}]}))
 
+-- | DSL name token for hydra.haskell.syntax.AsPattern
+asPatternAsPattern :: Typed.TypedName Syntax.AsPattern
+asPatternAsPattern = Typed.TypedName (Core.Name "hydra.haskell.syntax.AsPattern")
+
 -- | DSL accessor for the inner field of hydra.haskell.syntax.AsPattern
 asPatternInner :: Typed.TypedTerm Syntax.AsPattern -> Typed.TypedTerm Syntax.Pattern
 asPatternInner x =
@@ -482,6 +507,10 @@
         Core.projectionFieldName = (Core.Name "case")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.CaseExpression
+caseExpressionCaseExpression :: Typed.TypedName Syntax.CaseExpression
+caseExpressionCaseExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.CaseExpression")
+
 -- | DSL updater for the alternatives field of hydra.haskell.syntax.CaseExpression
 caseExpressionWithAlternatives :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm [Syntax.Alternative] -> Typed.TypedTerm Syntax.CaseExpression
 caseExpressionWithAlternatives original newVal =
@@ -523,6 +552,10 @@
       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.CaseRhs"),
       Core.wrappedTermBody = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.CaseRhs
+caseRhsCaseRhs :: Typed.TypedName Syntax.CaseRhs
+caseRhsCaseRhs = Typed.TypedName (Core.Name "hydra.haskell.syntax.CaseRhs")
+
 -- | DSL constructor for hydra.haskell.syntax.ClassConstraint
 classConstraint :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm [Syntax.Type] -> Typed.TypedTerm Syntax.ClassConstraint
 classConstraint name types =
@@ -536,6 +569,10 @@
           Core.fieldName = (Core.Name "types"),
           Core.fieldTerm = (Typed.unTypedTerm types)}]}))
 
+-- | DSL name token for hydra.haskell.syntax.ClassConstraint
+classConstraintClassConstraint :: Typed.TypedName Syntax.ClassConstraint
+classConstraintClassConstraint = Typed.TypedName (Core.Name "hydra.haskell.syntax.ClassConstraint")
+
 -- | DSL accessor for the name field of hydra.haskell.syntax.ClassConstraint
 classConstraintName :: Typed.TypedTerm Syntax.ClassConstraint -> Typed.TypedTerm Syntax.Name
 classConstraintName x =
@@ -601,6 +638,10 @@
           Core.fieldName = (Core.Name "type"),
           Core.fieldTerm = (Typed.unTypedTerm type_)}]}))
 
+-- | DSL name token for hydra.haskell.syntax.ConstrainedType
+constrainedTypeConstrainedType :: Typed.TypedName Syntax.ConstrainedType
+constrainedTypeConstrainedType = Typed.TypedName (Core.Name "hydra.haskell.syntax.ConstrainedType")
+
 -- | DSL accessor for the ctx field of hydra.haskell.syntax.ConstrainedType
 constrainedTypeCtx :: Typed.TypedTerm Syntax.ConstrainedType -> Typed.TypedTerm Syntax.Constraint
 constrainedTypeCtx x =
@@ -662,6 +703,10 @@
         Core.fieldName = (Core.Name "class"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.Constraint
+constraintConstraint :: Typed.TypedName Syntax.Constraint
+constraintConstraint = Typed.TypedName (Core.Name "hydra.haskell.syntax.Constraint")
+
 -- | DSL injection for the tuple variant of hydra.haskell.syntax.Constraint
 constraintTuple :: Typed.TypedTerm [Syntax.Constraint] -> Typed.TypedTerm Syntax.Constraint
 constraintTuple x =
@@ -671,6 +716,10 @@
         Core.fieldName = (Core.Name "tuple"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.Constructor
+constructorConstructor :: Typed.TypedName Syntax.Constructor
+constructorConstructor = Typed.TypedName (Core.Name "hydra.haskell.syntax.Constructor")
+
 -- | DSL injection for the ordinary variant of hydra.haskell.syntax.Constructor
 constructorOrdinary :: Typed.TypedTerm Syntax.PositionalConstructor -> Typed.TypedTerm Syntax.Constructor
 constructorOrdinary x =
@@ -741,6 +790,10 @@
         Core.projectionFieldName = (Core.Name "context")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.DataDeclaration
+dataDeclarationDataDeclaration :: Typed.TypedName Syntax.DataDeclaration
+dataDeclarationDataDeclaration = Typed.TypedName (Core.Name "hydra.haskell.syntax.DataDeclaration")
+
 -- | DSL accessor for the deriving field of hydra.haskell.syntax.DataDeclaration
 dataDeclarationDeriving :: Typed.TypedTerm Syntax.DataDeclaration -> Typed.TypedTerm [Syntax.DerivingClause]
 dataDeclarationDeriving x =
@@ -1047,6 +1100,10 @@
         Core.fieldName = (Core.Name "data"),
         Core.fieldTerm = Core.TermUnit}}))
 
+-- | DSL name token for hydra.haskell.syntax.DataKeyword
+dataKeywordDataKeyword :: Typed.TypedName Syntax.DataKeyword
+dataKeywordDataKeyword = Typed.TypedName (Core.Name "hydra.haskell.syntax.DataKeyword")
+
 -- | DSL injection for the newtype variant of hydra.haskell.syntax.DataKeyword
 dataKeywordNewtype :: Typed.TypedTerm Syntax.DataKeyword
 dataKeywordNewtype =
@@ -1065,6 +1122,10 @@
         Core.fieldName = (Core.Name "data"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.Declaration
+declarationDeclaration :: Typed.TypedName Syntax.Declaration
+declarationDeclaration = Typed.TypedName (Core.Name "hydra.haskell.syntax.Declaration")
+
 -- | DSL injection for the application variant of hydra.haskell.syntax.DeclarationHead
 declarationHeadApplication :: Typed.TypedTerm Syntax.ApplicationDeclarationHead -> Typed.TypedTerm Syntax.DeclarationHead
 declarationHeadApplication x =
@@ -1074,6 +1135,10 @@
         Core.fieldName = (Core.Name "application"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.DeclarationHead
+declarationHeadDeclarationHead :: Typed.TypedName Syntax.DeclarationHead
+declarationHeadDeclarationHead = Typed.TypedName (Core.Name "hydra.haskell.syntax.DeclarationHead")
+
 -- | DSL injection for the simple variant of hydra.haskell.syntax.DeclarationHead
 declarationHeadSimple :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.DeclarationHead
 declarationHeadSimple x =
@@ -1117,6 +1182,10 @@
       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.DerivingClause"),
       Core.wrappedTermBody = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.DerivingClause
+derivingClauseDerivingClause :: Typed.TypedName Syntax.DerivingClause
+derivingClauseDerivingClause = Typed.TypedName (Core.Name "hydra.haskell.syntax.DerivingClause")
+
 -- | DSL injection for the declaration variant of hydra.haskell.syntax.Export
 exportDeclaration :: Typed.TypedTerm Syntax.NamedImportExport -> Typed.TypedTerm Syntax.Export
 exportDeclaration x =
@@ -1126,6 +1195,10 @@
         Core.fieldName = (Core.Name "declaration"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.Export
+exportExport :: Typed.TypedName Syntax.Export
+exportExport = Typed.TypedName (Core.Name "hydra.haskell.syntax.Export")
+
 -- | DSL injection for the module variant of hydra.haskell.syntax.Export
 exportModule :: Typed.TypedTerm Syntax.ModuleName -> Typed.TypedTerm Syntax.Export
 exportModule x =
@@ -1171,6 +1244,10 @@
         Core.fieldName = (Core.Name "do"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.Expression
+expressionExpression :: Typed.TypedName Syntax.Expression
+expressionExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.Expression")
+
 -- | DSL injection for the if variant of hydra.haskell.syntax.Expression
 expressionIf :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression
 expressionIf x =
@@ -1304,6 +1381,10 @@
         Core.projectionFieldName = (Core.Name "comments")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.Field
+fieldField :: Typed.TypedName Syntax.Field
+fieldField = Typed.TypedName (Core.Name "hydra.haskell.syntax.Field")
+
 -- | DSL accessor for the name field of hydra.haskell.syntax.Field
 fieldName :: Typed.TypedTerm Syntax.Field -> Typed.TypedTerm Syntax.Name
 fieldName x =
@@ -1335,6 +1416,10 @@
           Core.fieldName = (Core.Name "value"),
           Core.fieldTerm = (Typed.unTypedTerm value)}]}))
 
+-- | DSL name token for hydra.haskell.syntax.FieldUpdate
+fieldUpdateFieldUpdate :: Typed.TypedName Syntax.FieldUpdate
+fieldUpdateFieldUpdate = Typed.TypedName (Core.Name "hydra.haskell.syntax.FieldUpdate")
+
 -- | DSL accessor for the name field of hydra.haskell.syntax.FieldUpdate
 fieldUpdateName :: Typed.TypedTerm Syntax.FieldUpdate -> Typed.TypedTerm Syntax.Name
 fieldUpdateName x =
@@ -1490,6 +1575,10 @@
         Core.projectionFieldName = (Core.Name "domain")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.FunctionType
+functionTypeFunctionType :: Typed.TypedName Syntax.FunctionType
+functionTypeFunctionType = Typed.TypedName (Core.Name "hydra.haskell.syntax.FunctionType")
+
 -- | DSL updater for the codomain field of hydra.haskell.syntax.FunctionType
 functionTypeWithCodomain :: Typed.TypedTerm Syntax.FunctionType -> Typed.TypedTerm Syntax.Type -> Typed.TypedTerm Syntax.FunctionType
 functionTypeWithCodomain original newVal =
@@ -1558,6 +1647,10 @@
         Core.projectionFieldName = (Core.Name "else")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.IfExpression
+ifExpressionIfExpression :: Typed.TypedName Syntax.IfExpression
+ifExpressionIfExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.IfExpression")
+
 -- | DSL accessor for the then field of hydra.haskell.syntax.IfExpression
 ifExpressionThen :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression
 ifExpressionThen x =
@@ -1676,6 +1769,10 @@
         Core.fieldName = (Core.Name "all"),
         Core.fieldTerm = Core.TermUnit}}))
 
+-- | DSL name token for hydra.haskell.syntax.ImportExportSubspec
+importExportSubspecImportExportSubspec :: Typed.TypedName Syntax.ImportExportSubspec
+importExportSubspecImportExportSubspec = Typed.TypedName (Core.Name "hydra.haskell.syntax.ImportExportSubspec")
+
 -- | DSL injection for the list variant of hydra.haskell.syntax.ImportExportSubspec
 importExportSubspecList :: Typed.TypedTerm [Syntax.Name] -> Typed.TypedTerm Syntax.ImportExportSubspec
 importExportSubspecList x =
@@ -1685,6 +1782,14 @@
         Core.fieldName = (Core.Name "list"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.Import
+importImport :: Typed.TypedName Syntax.Import
+importImport = Typed.TypedName (Core.Name "hydra.haskell.syntax.Import")
+
+-- | DSL name token for hydra.haskell.syntax.ImportModifier
+importModifierImportModifier :: Typed.TypedName Syntax.ImportModifier
+importModifierImportModifier = Typed.TypedName (Core.Name "hydra.haskell.syntax.ImportModifier")
+
 -- | DSL injection for the pattern variant of hydra.haskell.syntax.ImportModifier
 importModifierPattern :: Typed.TypedTerm Syntax.ImportModifier
 importModifierPattern =
@@ -1739,6 +1844,10 @@
         Core.fieldName = (Core.Name "hiding"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.ImportSpec
+importSpecImportSpec :: Typed.TypedName Syntax.ImportSpec
+importSpecImportSpec = Typed.TypedName (Core.Name "hydra.haskell.syntax.ImportSpec")
+
 -- | DSL injection for the list variant of hydra.haskell.syntax.ImportSpec
 importSpecList :: Typed.TypedTerm [Syntax.NamedImportExport] -> Typed.TypedTerm Syntax.ImportSpec
 importSpecList x =
@@ -1888,6 +1997,10 @@
           Core.fieldName = (Core.Name "rhs"),
           Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
 
+-- | DSL name token for hydra.haskell.syntax.InfixExpression
+infixExpressionInfixExpression :: Typed.TypedName Syntax.InfixExpression
+infixExpressionInfixExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.InfixExpression")
+
 -- | DSL accessor for the lhs field of hydra.haskell.syntax.InfixExpression
 infixExpressionLhs :: Typed.TypedTerm Syntax.InfixExpression -> Typed.TypedTerm Syntax.Expression
 infixExpressionLhs x =
@@ -2003,6 +2116,10 @@
           Core.fieldName = (Core.Name "rhs"),
           Core.fieldTerm = (Typed.unTypedTerm rhs)}]}))
 
+-- | DSL name token for hydra.haskell.syntax.InfixType
+infixTypeInfixType :: Typed.TypedName Syntax.InfixType
+infixTypeInfixType = Typed.TypedName (Core.Name "hydra.haskell.syntax.InfixType")
+
 -- | DSL accessor for the lhs field of hydra.haskell.syntax.InfixType
 infixTypeLhs :: Typed.TypedTerm Syntax.InfixType -> Typed.TypedTerm Syntax.Type
 infixTypeLhs x =
@@ -2133,6 +2250,10 @@
         Core.projectionFieldName = (Core.Name "inner")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.LambdaExpression
+lambdaExpressionLambdaExpression :: Typed.TypedName Syntax.LambdaExpression
+lambdaExpressionLambdaExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.LambdaExpression")
+
 -- | DSL updater for the bindings field of hydra.haskell.syntax.LambdaExpression
 lambdaExpressionWithBindings :: Typed.TypedTerm Syntax.LambdaExpression -> Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.LambdaExpression
 lambdaExpressionWithBindings original newVal =
@@ -2198,6 +2319,10 @@
         Core.projectionFieldName = (Core.Name "inner")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.LetExpression
+letExpressionLetExpression :: Typed.TypedName Syntax.LetExpression
+letExpressionLetExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.LetExpression")
+
 -- | DSL updater for the bindings field of hydra.haskell.syntax.LetExpression
 letExpressionWithBindings :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm [Syntax.LocalBinding] -> Typed.TypedTerm Syntax.LetExpression
 letExpressionWithBindings original newVal =
@@ -2277,6 +2402,10 @@
         Core.fieldName = (Core.Name "integer"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.Literal
+literalLiteral :: Typed.TypedName Syntax.Literal
+literalLiteral = Typed.TypedName (Core.Name "hydra.haskell.syntax.Literal")
+
 -- | DSL injection for the string variant of hydra.haskell.syntax.Literal
 literalString :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.Literal
 literalString x =
@@ -2286,6 +2415,10 @@
         Core.fieldName = (Core.Name "string"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.LocalBinding
+localBindingLocalBinding :: Typed.TypedName Syntax.LocalBinding
+localBindingLocalBinding = Typed.TypedName (Core.Name "hydra.haskell.syntax.LocalBinding")
+
 -- | DSL injection for the signature variant of hydra.haskell.syntax.LocalBinding
 localBindingSignature :: Typed.TypedTerm Syntax.TypeSignature -> Typed.TypedTerm Syntax.LocalBinding
 localBindingSignature x =
@@ -2311,6 +2444,10 @@
       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.LocalBindings"),
       Core.wrappedTermBody = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.LocalBindings
+localBindingsLocalBindings :: Typed.TypedName Syntax.LocalBindings
+localBindingsLocalBindings = Typed.TypedName (Core.Name "hydra.haskell.syntax.LocalBindings")
+
 -- | DSL constructor for hydra.haskell.syntax.Module
 module_ :: Typed.TypedTerm (Maybe Syntax.ModuleHead) -> Typed.TypedTerm [Syntax.Import] -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.Module
 module_ head imports declarations =
@@ -2379,6 +2516,10 @@
         Core.projectionFieldName = (Core.Name "exports")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.ModuleHead
+moduleHeadModuleHead :: Typed.TypedName Syntax.ModuleHead
+moduleHeadModuleHead = Typed.TypedName (Core.Name "hydra.haskell.syntax.ModuleHead")
+
 -- | DSL accessor for the name field of hydra.haskell.syntax.ModuleHead
 moduleHeadName :: Typed.TypedTerm Syntax.ModuleHead -> Typed.TypedTerm Syntax.ModuleName
 moduleHeadName x =
@@ -2469,6 +2610,10 @@
         Core.projectionFieldName = (Core.Name "imports")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.Module
+moduleModule :: Typed.TypedName Syntax.Module
+moduleModule = Typed.TypedName (Core.Name "hydra.haskell.syntax.Module")
+
 -- | DSL constructor for the hydra.haskell.syntax.ModuleName wrapper
 moduleName :: Typed.TypedTerm String -> Typed.TypedTerm Syntax.ModuleName
 moduleName x =
@@ -2476,6 +2621,10 @@
       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.ModuleName"),
       Core.wrappedTermBody = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.ModuleName
+moduleNameModuleName :: Typed.TypedName Syntax.ModuleName
+moduleNameModuleName = Typed.TypedName (Core.Name "hydra.haskell.syntax.ModuleName")
+
 -- | DSL updater for the declarations field of hydra.haskell.syntax.Module
 moduleWithDeclarations :: Typed.TypedTerm Syntax.Module -> Typed.TypedTerm [Syntax.Declaration] -> Typed.TypedTerm Syntax.Module
 moduleWithDeclarations original newVal =
@@ -2557,6 +2706,10 @@
         Core.fieldName = (Core.Name "implicit"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.Name
+nameName :: Typed.TypedName Syntax.Name
+nameName = Typed.TypedName (Core.Name "hydra.haskell.syntax.Name")
+
 -- | DSL injection for the normal variant of hydra.haskell.syntax.Name
 nameNormal :: Typed.TypedTerm Syntax.QualifiedName -> Typed.TypedTerm Syntax.Name
 nameNormal x =
@@ -2573,6 +2726,10 @@
       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.NamePart"),
       Core.wrappedTermBody = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.NamePart
+namePartNamePart :: Typed.TypedName Syntax.NamePart
+namePartNamePart = Typed.TypedName (Core.Name "hydra.haskell.syntax.NamePart")
+
 -- | DSL constructor for hydra.haskell.syntax.NamedImportExport
 namedImportExport :: Typed.TypedTerm (Maybe Syntax.ImportModifier) -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm (Maybe Syntax.ImportExportSubspec) -> Typed.TypedTerm Syntax.NamedImportExport
 namedImportExport modifier name subspec =
@@ -2607,6 +2764,10 @@
         Core.projectionFieldName = (Core.Name "name")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.NamedImportExport
+namedImportExportNamedImportExport :: Typed.TypedName Syntax.NamedImportExport
+namedImportExportNamedImportExport = Typed.TypedName (Core.Name "hydra.haskell.syntax.NamedImportExport")
+
 -- | DSL accessor for the subspec field of hydra.haskell.syntax.NamedImportExport
 namedImportExportSubspec :: Typed.TypedTerm Syntax.NamedImportExport -> Typed.TypedTerm (Maybe Syntax.ImportExportSubspec)
 namedImportExportSubspec x =
@@ -2706,6 +2867,10 @@
         Core.fieldName = (Core.Name "normal"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.Operator
+operatorOperator :: Typed.TypedName Syntax.Operator
+operatorOperator = Typed.TypedName (Core.Name "hydra.haskell.syntax.Operator")
+
 -- | DSL injection for the application variant of hydra.haskell.syntax.Pattern
 patternApplication :: Typed.TypedTerm Syntax.ApplicationPattern -> Typed.TypedTerm Syntax.Pattern
 patternApplication x =
@@ -2755,6 +2920,10 @@
         Core.projectionFieldName = (Core.Name "pattern")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.PatternField
+patternFieldPatternField :: Typed.TypedName Syntax.PatternField
+patternFieldPatternField = Typed.TypedName (Core.Name "hydra.haskell.syntax.PatternField")
+
 -- | DSL updater for the name field of hydra.haskell.syntax.PatternField
 patternFieldWithName :: Typed.TypedTerm Syntax.PatternField -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.PatternField
 patternFieldWithName original newVal =
@@ -2816,6 +2985,10 @@
         Core.fieldName = (Core.Name "name"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.Pattern
+patternPattern :: Typed.TypedName Syntax.Pattern
+patternPattern = Typed.TypedName (Core.Name "hydra.haskell.syntax.Pattern")
+
 -- | DSL injection for the record variant of hydra.haskell.syntax.Pattern
 patternRecord :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm Syntax.Pattern
 patternRecord x =
@@ -2895,6 +3068,10 @@
         Core.projectionFieldName = (Core.Name "name")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.PositionalConstructor
+positionalConstructorPositionalConstructor :: Typed.TypedName Syntax.PositionalConstructor
+positionalConstructorPositionalConstructor = Typed.TypedName (Core.Name "hydra.haskell.syntax.PositionalConstructor")
+
 -- | DSL updater for the comments field of hydra.haskell.syntax.PositionalConstructor
 positionalConstructorWithComments :: Typed.TypedTerm Syntax.PositionalConstructor -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.PositionalConstructor
 positionalConstructorWithComments original newVal =
@@ -2980,6 +3157,10 @@
           Core.fieldName = (Core.Name "unqualified"),
           Core.fieldTerm = (Typed.unTypedTerm unqualified)}]}))
 
+-- | DSL name token for hydra.haskell.syntax.QualifiedName
+qualifiedNameQualifiedName :: Typed.TypedName Syntax.QualifiedName
+qualifiedNameQualifiedName = Typed.TypedName (Core.Name "hydra.haskell.syntax.QualifiedName")
+
 -- | DSL accessor for the qualifiers field of hydra.haskell.syntax.QualifiedName
 qualifiedNameQualifiers :: Typed.TypedTerm Syntax.QualifiedName -> Typed.TypedTerm [Syntax.NamePart]
 qualifiedNameQualifiers x =
@@ -3075,6 +3256,10 @@
         Core.projectionFieldName = (Core.Name "name")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.RecordConstructor
+recordConstructorRecordConstructor :: Typed.TypedName Syntax.RecordConstructor
+recordConstructorRecordConstructor = Typed.TypedName (Core.Name "hydra.haskell.syntax.RecordConstructor")
+
 -- | DSL updater for the comments field of hydra.haskell.syntax.RecordConstructor
 recordConstructorWithComments :: Typed.TypedTerm Syntax.RecordConstructor -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.RecordConstructor
 recordConstructorWithComments original newVal =
@@ -3178,6 +3363,10 @@
         Core.projectionFieldName = (Core.Name "name")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.RecordExpression
+recordExpressionRecordExpression :: Typed.TypedName Syntax.RecordExpression
+recordExpressionRecordExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.RecordExpression")
+
 -- | DSL updater for the fields field of hydra.haskell.syntax.RecordExpression
 recordExpressionWithFields :: Typed.TypedTerm Syntax.RecordExpression -> Typed.TypedTerm [Syntax.FieldUpdate] -> Typed.TypedTerm Syntax.RecordExpression
 recordExpressionWithFields original newVal =
@@ -3243,6 +3432,10 @@
         Core.projectionFieldName = (Core.Name "name")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.RecordPattern
+recordPatternRecordPattern :: Typed.TypedName Syntax.RecordPattern
+recordPatternRecordPattern = Typed.TypedName (Core.Name "hydra.haskell.syntax.RecordPattern")
+
 -- | DSL updater for the fields field of hydra.haskell.syntax.RecordPattern
 recordPatternWithFields :: Typed.TypedTerm Syntax.RecordPattern -> Typed.TypedTerm [Syntax.PatternField] -> Typed.TypedTerm Syntax.RecordPattern
 recordPatternWithFields original newVal =
@@ -3308,6 +3501,10 @@
         Core.projectionFieldName = (Core.Name "inner")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.RecordUpdateExpression
+recordUpdateExpressionRecordUpdateExpression :: Typed.TypedName Syntax.RecordUpdateExpression
+recordUpdateExpressionRecordUpdateExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.RecordUpdateExpression")
+
 -- | DSL updater for the fields field of hydra.haskell.syntax.RecordUpdateExpression
 recordUpdateExpressionWithFields :: Typed.TypedTerm Syntax.RecordUpdateExpression -> Typed.TypedTerm [Syntax.FieldUpdate] -> Typed.TypedTerm Syntax.RecordUpdateExpression
 recordUpdateExpressionWithFields original newVal =
@@ -3349,6 +3546,10 @@
       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.RightHandSide"),
       Core.wrappedTermBody = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.RightHandSide
+rightHandSideRightHandSide :: Typed.TypedName Syntax.RightHandSide
+rightHandSideRightHandSide = Typed.TypedName (Core.Name "hydra.haskell.syntax.RightHandSide")
+
 -- | DSL constructor for hydra.haskell.syntax.SectionExpression
 sectionExpression :: Typed.TypedTerm Syntax.Operator -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SectionExpression
 sectionExpression operator expression =
@@ -3380,6 +3581,10 @@
         Core.projectionFieldName = (Core.Name "operator")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.SectionExpression
+sectionExpressionSectionExpression :: Typed.TypedName Syntax.SectionExpression
+sectionExpressionSectionExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.SectionExpression")
+
 -- | DSL updater for the expression field of hydra.haskell.syntax.SectionExpression
 sectionExpressionWithExpression :: Typed.TypedTerm Syntax.SectionExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SectionExpression
 sectionExpressionWithExpression original newVal =
@@ -3469,6 +3674,10 @@
         Core.projectionFieldName = (Core.Name "rhs")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.SimpleValueBinding
+simpleValueBindingSimpleValueBinding :: Typed.TypedName Syntax.SimpleValueBinding
+simpleValueBindingSimpleValueBinding = Typed.TypedName (Core.Name "hydra.haskell.syntax.SimpleValueBinding")
+
 -- | DSL updater for the comments field of hydra.haskell.syntax.SimpleValueBinding
 simpleValueBindingWithComments :: Typed.TypedTerm Syntax.SimpleValueBinding -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.SimpleValueBinding
 simpleValueBindingWithComments original newVal =
@@ -3600,6 +3809,10 @@
       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.Statement"),
       Core.wrappedTermBody = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.Statement
+statementStatement :: Typed.TypedName Syntax.Statement
+statementStatement = Typed.TypedName (Core.Name "hydra.haskell.syntax.Statement")
+
 -- | DSL injection for the application variant of hydra.haskell.syntax.Type
 typeApplication :: Typed.TypedTerm Syntax.ApplicationType -> Typed.TypedTerm Syntax.Type
 typeApplication x =
@@ -3676,6 +3889,10 @@
         Core.projectionFieldName = (Core.Name "type")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.TypeSignature
+typeSignatureTypeSignature :: Typed.TypedName Syntax.TypeSignature
+typeSignatureTypeSignature = Typed.TypedName (Core.Name "hydra.haskell.syntax.TypeSignature")
+
 -- | DSL updater for the name field of hydra.haskell.syntax.TypeSignature
 typeSignatureWithName :: Typed.TypedTerm Syntax.TypeSignature -> Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.TypeSignature
 typeSignatureWithName original newVal =
@@ -3753,6 +3970,10 @@
         Core.projectionFieldName = (Core.Name "type")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.TypeSynonymDeclaration
+typeSynonymDeclarationTypeSynonymDeclaration :: Typed.TypedName Syntax.TypeSynonymDeclaration
+typeSynonymDeclarationTypeSynonymDeclaration = Typed.TypedName (Core.Name "hydra.haskell.syntax.TypeSynonymDeclaration")
+
 -- | DSL updater for the comments field of hydra.haskell.syntax.TypeSynonymDeclaration
 typeSynonymDeclarationWithComments :: Typed.TypedTerm Syntax.TypeSynonymDeclaration -> Typed.TypedTerm (Maybe String) -> Typed.TypedTerm Syntax.TypeSynonymDeclaration
 typeSynonymDeclarationWithComments original newVal =
@@ -3834,6 +4055,10 @@
         Core.fieldName = (Core.Name "tuple"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.Type
+typeType :: Typed.TypedName Syntax.Type
+typeType = Typed.TypedName (Core.Name "hydra.haskell.syntax.Type")
+
 -- | DSL injection for the variable variant of hydra.haskell.syntax.Type
 typeVariable :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Type
 typeVariable x =
@@ -3877,6 +4102,10 @@
         Core.projectionFieldName = (Core.Name "typeSignature")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.TypedBinding
+typedBindingTypedBinding :: Typed.TypedName Syntax.TypedBinding
+typedBindingTypedBinding = Typed.TypedName (Core.Name "hydra.haskell.syntax.TypedBinding")
+
 -- | DSL accessor for the valueBinding field of hydra.haskell.syntax.TypedBinding
 typedBindingValueBinding :: Typed.TypedTerm Syntax.TypedBinding -> Typed.TypedTerm Syntax.ValueBinding
 typedBindingValueBinding x =
@@ -3989,6 +4218,10 @@
         Core.projectionFieldName = (Core.Name "type")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.TypedExpression
+typedExpressionTypedExpression :: Typed.TypedName Syntax.TypedExpression
+typedExpressionTypedExpression = Typed.TypedName (Core.Name "hydra.haskell.syntax.TypedExpression")
+
 -- | DSL updater for the inner field of hydra.haskell.syntax.TypedExpression
 typedExpressionWithInner :: Typed.TypedTerm Syntax.TypedExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypedExpression
 typedExpressionWithInner original newVal =
@@ -4054,6 +4287,10 @@
         Core.projectionFieldName = (Core.Name "type")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.haskell.syntax.TypedPattern
+typedPatternTypedPattern :: Typed.TypedName Syntax.TypedPattern
+typedPatternTypedPattern = Typed.TypedName (Core.Name "hydra.haskell.syntax.TypedPattern")
+
 -- | DSL updater for the inner field of hydra.haskell.syntax.TypedPattern
 typedPatternWithInner :: Typed.TypedTerm Syntax.TypedPattern -> Typed.TypedTerm Syntax.Pattern -> Typed.TypedTerm Syntax.TypedPattern
 typedPatternWithInner original newVal =
@@ -4153,9 +4390,17 @@
         Core.fieldName = (Core.Name "simple"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.haskell.syntax.ValueBinding
+valueBindingValueBinding :: Typed.TypedName Syntax.ValueBinding
+valueBindingValueBinding = Typed.TypedName (Core.Name "hydra.haskell.syntax.ValueBinding")
+
 -- | DSL constructor for the hydra.haskell.syntax.Variable wrapper
 variable :: Typed.TypedTerm Syntax.Name -> Typed.TypedTerm Syntax.Variable
 variable x =
     Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {
       Core.wrappedTermTypeName = (Core.Name "hydra.haskell.syntax.Variable"),
       Core.wrappedTermBody = (Typed.unTypedTerm x)}))
+
+-- | DSL name token for hydra.haskell.syntax.Variable
+variableVariable :: Typed.TypedName Syntax.Variable
+variableVariable = Typed.TypedName (Core.Name "hydra.haskell.syntax.Variable")
diff --git a/src/main/haskell/Hydra/Haskell/Coder.hs b/src/main/haskell/Hydra/Haskell/Coder.hs
--- a/src/main/haskell/Hydra/Haskell/Coder.hs
+++ b/src/main/haskell/Hydra/Haskell/Coder.hs
@@ -102,9 +102,9 @@
                   \namespace ->
                     let raw = Packaging.unModuleName namespace
                         parts = Strings.splitOn "." raw
-                    in (Logic.ifElse (Logic.and (Equality.equal (Lists.length parts) 3) (Equality.equal (Lists.take 2 parts) [
+                    in (Logic.ifElse (Logic.and (Logic.and (Equality.equal (Lists.length parts) 3) (Equality.equal (Lists.take 2 parts) [
                       "hydra",
-                      "lib"])) (Strings.cat2 "hydra.overlay.haskell.lib." (Strings.intercalate "." (Lists.drop 2 parts))) raw)
+                      "lib"])) (Logic.not (Equality.equal raw "hydra.lib.defaults"))) (Strings.cat2 "hydra.overlay.haskell.lib." (Strings.intercalate "." (Lists.drop 2 parts))) raw)
           createDeclarations =
                   \def -> case def of
                     Packaging.DefinitionType v0 ->
@@ -620,6 +620,7 @@
                     in (constantForFieldName name fname, (Core.unName fname))
       in (Logic.ifElse useCoreImport (Lists.cons (toDecl (Core.Name "hydra.core.Name") nameDecl) (Lists.map (toDecl (Core.Name "hydra.core.Name")) fieldDecls)) [])
 
+-- | Set the usesByteString flag in Haskell module metadata
 setMetaUsesByteString :: Bool -> Environment.HaskellModuleMetadata -> Environment.HaskellModuleMetadata
 setMetaUsesByteString b m =
     Environment.HaskellModuleMetadata {
@@ -628,6 +629,7 @@
       Environment.haskellModuleMetadataUsesMap = (Environment.haskellModuleMetadataUsesMap m),
       Environment.haskellModuleMetadataUsesSet = (Environment.haskellModuleMetadataUsesSet m)}
 
+-- | Set the usesInt flag in Haskell module metadata
 setMetaUsesInt :: Bool -> Environment.HaskellModuleMetadata -> Environment.HaskellModuleMetadata
 setMetaUsesInt b m =
     Environment.HaskellModuleMetadata {
@@ -636,6 +638,7 @@
       Environment.haskellModuleMetadataUsesMap = (Environment.haskellModuleMetadataUsesMap m),
       Environment.haskellModuleMetadataUsesSet = (Environment.haskellModuleMetadataUsesSet m)}
 
+-- | Set the usesMap flag in Haskell module metadata
 setMetaUsesMap :: Bool -> Environment.HaskellModuleMetadata -> Environment.HaskellModuleMetadata
 setMetaUsesMap b m =
     Environment.HaskellModuleMetadata {
@@ -644,6 +647,7 @@
       Environment.haskellModuleMetadataUsesMap = b,
       Environment.haskellModuleMetadataUsesSet = (Environment.haskellModuleMetadataUsesSet m)}
 
+-- | Set the usesSet flag in Haskell module metadata
 setMetaUsesSet :: Bool -> Environment.HaskellModuleMetadata -> Environment.HaskellModuleMetadata
 setMetaUsesSet b m =
     Environment.HaskellModuleMetadata {
diff --git a/src/main/haskell/Hydra/Haskell/Syntax.hs b/src/main/haskell/Hydra/Haskell/Syntax.hs
--- a/src/main/haskell/Hydra/Haskell/Syntax.hs
+++ b/src/main/haskell/Hydra/Haskell/Syntax.hs
@@ -27,20 +27,104 @@
 
 _Alternative_binds = Core.Name "binds"
 
--- | A type constraint
-data Constraint =
-  -- | A class constraint
-  ConstraintClass ClassConstraint |
-  -- | A tuple of constraints
-  ConstraintTuple [Constraint]
+-- | An application-style declaration head
+data ApplicationDeclarationHead =
+  ApplicationDeclarationHead {
+    -- | The function being applied
+    applicationDeclarationHeadFunction :: DeclarationHead,
+    -- | The type variable operand
+    applicationDeclarationHeadOperand :: Variable}
   deriving (Eq, Ord, Read, Show)
 
-_Constraint = Core.Name "hydra.haskell.syntax.Constraint"
+_ApplicationDeclarationHead = Core.Name "hydra.haskell.syntax.ApplicationDeclarationHead"
 
-_Constraint_class = Core.Name "class"
+_ApplicationDeclarationHead_function = Core.Name "function"
 
-_Constraint_tuple = Core.Name "tuple"
+_ApplicationDeclarationHead_operand = Core.Name "operand"
 
+-- | An application expression
+data ApplicationExpression =
+  ApplicationExpression {
+    -- | The function being applied
+    applicationExpressionFunction :: Expression,
+    -- | The argument
+    applicationExpressionArgument :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_ApplicationExpression = Core.Name "hydra.haskell.syntax.ApplicationExpression"
+
+_ApplicationExpression_function = Core.Name "function"
+
+_ApplicationExpression_argument = Core.Name "argument"
+
+-- | An application pattern
+data ApplicationPattern =
+  ApplicationPattern {
+    -- | The constructor name
+    applicationPatternName :: Name,
+    -- | The pattern arguments
+    applicationPatternArgs :: [Pattern]}
+  deriving (Eq, Ord, Read, Show)
+
+_ApplicationPattern = Core.Name "hydra.haskell.syntax.ApplicationPattern"
+
+_ApplicationPattern_name = Core.Name "name"
+
+_ApplicationPattern_args = Core.Name "args"
+
+-- | An application type
+data ApplicationType =
+  ApplicationType {
+    -- | The type being applied
+    applicationTypeContext :: Type,
+    -- | The type argument
+    applicationTypeArgument :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_ApplicationType = Core.Name "hydra.haskell.syntax.ApplicationType"
+
+_ApplicationType_context = Core.Name "context"
+
+_ApplicationType_argument = Core.Name "argument"
+
+-- | An 'as' pattern
+data AsPattern =
+  AsPattern {
+    -- | The bound name
+    asPatternName :: Name,
+    -- | The inner pattern
+    asPatternInner :: Pattern}
+  deriving (Eq, Ord, Read, Show)
+
+_AsPattern = Core.Name "hydra.haskell.syntax.AsPattern"
+
+_AsPattern_name = Core.Name "name"
+
+_AsPattern_inner = Core.Name "inner"
+
+-- | A case expression
+data CaseExpression =
+  CaseExpression {
+    -- | The expression being matched
+    caseExpressionCase :: Expression,
+    -- | The pattern-matching alternatives
+    caseExpressionAlternatives :: [Alternative]}
+  deriving (Eq, Ord, Read, Show)
+
+_CaseExpression = Core.Name "hydra.haskell.syntax.CaseExpression"
+
+_CaseExpression_case = Core.Name "case"
+
+_CaseExpression_alternatives = Core.Name "alternatives"
+
+-- | The right-hand side of a pattern-matching alternative
+newtype CaseRhs =
+  CaseRhs {
+    unCaseRhs :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_CaseRhs = Core.Name "hydra.haskell.syntax.CaseRhs"
+
 -- | A class constraint
 data ClassConstraint =
   ClassConstraint {
@@ -56,14 +140,35 @@
 
 _ClassConstraint_types = Core.Name "types"
 
--- | The right-hand side of a pattern-matching alternative
-newtype CaseRhs =
-  CaseRhs {
-    unCaseRhs :: Expression}
+-- | A type with a context (type class constraints)
+data ConstrainedType =
+  ConstrainedType {
+    -- | The type class context
+    constrainedTypeCtx :: Constraint,
+    -- | The constrained type
+    constrainedTypeType :: Type}
   deriving (Eq, Ord, Read, Show)
 
-_CaseRhs = Core.Name "hydra.haskell.syntax.CaseRhs"
+_ConstrainedType = Core.Name "hydra.haskell.syntax.ConstrainedType"
 
+_ConstrainedType_ctx = Core.Name "ctx"
+
+_ConstrainedType_type = Core.Name "type"
+
+-- | A type constraint
+data Constraint =
+  -- | A class constraint
+  ConstraintClass ClassConstraint |
+  -- | A tuple of constraints
+  ConstraintTuple [Constraint]
+  deriving (Eq, Ord, Read, Show)
+
+_Constraint = Core.Name "hydra.haskell.syntax.Constraint"
+
+_Constraint_class = Core.Name "class"
+
+_Constraint_tuple = Core.Name "tuple"
+
 -- | A data constructor
 data Constructor =
   -- | An ordinary (positional) constructor
@@ -78,44 +183,6 @@
 
 _Constructor_record = Core.Name "record"
 
--- | An ordinary (positional) data constructor
-data PositionalConstructor =
-  PositionalConstructor {
-    -- | The name of the constructor
-    positionalConstructorName :: Name,
-    -- | The types of the positional fields
-    positionalConstructorFields :: [Type],
-    -- | Optional comments
-    positionalConstructorComments :: (Maybe String)}
-  deriving (Eq, Ord, Read, Show)
-
-_PositionalConstructor = Core.Name "hydra.haskell.syntax.PositionalConstructor"
-
-_PositionalConstructor_name = Core.Name "name"
-
-_PositionalConstructor_fields = Core.Name "fields"
-
-_PositionalConstructor_comments = Core.Name "comments"
-
--- | A record-style data constructor
-data RecordConstructor =
-  RecordConstructor {
-    -- | The name of the constructor
-    recordConstructorName :: Name,
-    -- | The named fields of the record
-    recordConstructorFields :: [Field],
-    -- | Optional comments
-    recordConstructorComments :: (Maybe String)}
-  deriving (Eq, Ord, Read, Show)
-
-_RecordConstructor = Core.Name "hydra.haskell.syntax.RecordConstructor"
-
-_RecordConstructor_name = Core.Name "name"
-
-_RecordConstructor_fields = Core.Name "fields"
-
-_RecordConstructor_comments = Core.Name "comments"
-
 -- | A data type declaration
 data DataDeclaration =
   DataDeclaration {
@@ -195,21 +262,6 @@
 
 _DeclarationHead_simple = Core.Name "simple"
 
--- | An application-style declaration head
-data ApplicationDeclarationHead =
-  ApplicationDeclarationHead {
-    -- | The function being applied
-    applicationDeclarationHeadFunction :: DeclarationHead,
-    -- | The type variable operand
-    applicationDeclarationHeadOperand :: Variable}
-  deriving (Eq, Ord, Read, Show)
-
-_ApplicationDeclarationHead = Core.Name "hydra.haskell.syntax.ApplicationDeclarationHead"
-
-_ApplicationDeclarationHead_function = Core.Name "function"
-
-_ApplicationDeclarationHead_operand = Core.Name "operand"
-
 -- | A 'deriving' clause
 newtype DerivingClause =
   DerivingClause {
@@ -302,164 +354,6 @@
 
 _Expression_variable = Core.Name "variable"
 
--- | An application expression
-data ApplicationExpression =
-  ApplicationExpression {
-    -- | The function being applied
-    applicationExpressionFunction :: Expression,
-    -- | The argument
-    applicationExpressionArgument :: Expression}
-  deriving (Eq, Ord, Read, Show)
-
-_ApplicationExpression = Core.Name "hydra.haskell.syntax.ApplicationExpression"
-
-_ApplicationExpression_function = Core.Name "function"
-
-_ApplicationExpression_argument = Core.Name "argument"
-
--- | A case expression
-data CaseExpression =
-  CaseExpression {
-    -- | The expression being matched
-    caseExpressionCase :: Expression,
-    -- | The pattern-matching alternatives
-    caseExpressionAlternatives :: [Alternative]}
-  deriving (Eq, Ord, Read, Show)
-
-_CaseExpression = Core.Name "hydra.haskell.syntax.CaseExpression"
-
-_CaseExpression_case = Core.Name "case"
-
-_CaseExpression_alternatives = Core.Name "alternatives"
-
--- | A record constructor expression
-data RecordExpression =
-  RecordExpression {
-    -- | The constructor name
-    recordExpressionName :: Name,
-    -- | The field assignments
-    recordExpressionFields :: [FieldUpdate]}
-  deriving (Eq, Ord, Read, Show)
-
-_RecordExpression = Core.Name "hydra.haskell.syntax.RecordExpression"
-
-_RecordExpression_name = Core.Name "name"
-
-_RecordExpression_fields = Core.Name "fields"
-
--- | An 'if' expression
-data IfExpression =
-  IfExpression {
-    -- | The condition expression
-    ifExpressionCondition :: Expression,
-    -- | The 'then' branch
-    ifExpressionThen :: Expression,
-    -- | The 'else' branch
-    ifExpressionElse :: Expression}
-  deriving (Eq, Ord, Read, Show)
-
-_IfExpression = Core.Name "hydra.haskell.syntax.IfExpression"
-
-_IfExpression_condition = Core.Name "condition"
-
-_IfExpression_then = Core.Name "then"
-
-_IfExpression_else = Core.Name "else"
-
--- | An infix application expression
-data InfixExpression =
-  InfixExpression {
-    -- | The left-hand operand
-    infixExpressionLhs :: Expression,
-    -- | The infix operator
-    infixExpressionOperator :: Operator,
-    -- | The right-hand operand
-    infixExpressionRhs :: Expression}
-  deriving (Eq, Ord, Read, Show)
-
-_InfixExpression = Core.Name "hydra.haskell.syntax.InfixExpression"
-
-_InfixExpression_lhs = Core.Name "lhs"
-
-_InfixExpression_operator = Core.Name "operator"
-
-_InfixExpression_rhs = Core.Name "rhs"
-
--- | A lambda expression
-data LambdaExpression =
-  LambdaExpression {
-    -- | The patterns binding parameters
-    lambdaExpressionBindings :: [Pattern],
-    -- | The body of the lambda
-    lambdaExpressionInner :: Expression}
-  deriving (Eq, Ord, Read, Show)
-
-_LambdaExpression = Core.Name "hydra.haskell.syntax.LambdaExpression"
-
-_LambdaExpression_bindings = Core.Name "bindings"
-
-_LambdaExpression_inner = Core.Name "inner"
-
--- | A 'let' expression
-data LetExpression =
-  LetExpression {
-    -- | The local bindings
-    letExpressionBindings :: [LocalBinding],
-    -- | The body of the let expression
-    letExpressionInner :: Expression}
-  deriving (Eq, Ord, Read, Show)
-
-_LetExpression = Core.Name "hydra.haskell.syntax.LetExpression"
-
-_LetExpression_bindings = Core.Name "bindings"
-
-_LetExpression_inner = Core.Name "inner"
-
--- | A section expression
-data SectionExpression =
-  SectionExpression {
-    -- | The operator
-    sectionExpressionOperator :: Operator,
-    -- | The operand
-    sectionExpressionExpression :: Expression}
-  deriving (Eq, Ord, Read, Show)
-
-_SectionExpression = Core.Name "hydra.haskell.syntax.SectionExpression"
-
-_SectionExpression_operator = Core.Name "operator"
-
-_SectionExpression_expression = Core.Name "expression"
-
--- | A type signature expression
-data TypedExpression =
-  TypedExpression {
-    -- | The expression being typed
-    typedExpressionInner :: Expression,
-    -- | The type signature
-    typedExpressionType :: Type}
-  deriving (Eq, Ord, Read, Show)
-
-_TypedExpression = Core.Name "hydra.haskell.syntax.TypedExpression"
-
-_TypedExpression_inner = Core.Name "inner"
-
-_TypedExpression_type = Core.Name "type"
-
--- | An update record expression
-data RecordUpdateExpression =
-  RecordUpdateExpression {
-    -- | The record being updated
-    recordUpdateExpressionInner :: Expression,
-    -- | The field updates
-    recordUpdateExpressionFields :: [FieldUpdate]}
-  deriving (Eq, Ord, Read, Show)
-
-_RecordUpdateExpression = Core.Name "hydra.haskell.syntax.RecordUpdateExpression"
-
-_RecordUpdateExpression_inner = Core.Name "inner"
-
-_RecordUpdateExpression_fields = Core.Name "fields"
-
 -- | A field (name/type pair)
 data Field =
   Field {
@@ -494,6 +388,40 @@
 
 _FieldUpdate_value = Core.Name "value"
 
+-- | A function type
+data FunctionType =
+  FunctionType {
+    -- | The domain type
+    functionTypeDomain :: Type,
+    -- | The codomain type
+    functionTypeCodomain :: Type}
+  deriving (Eq, Ord, Read, Show)
+
+_FunctionType = Core.Name "hydra.haskell.syntax.FunctionType"
+
+_FunctionType_domain = Core.Name "domain"
+
+_FunctionType_codomain = Core.Name "codomain"
+
+-- | An 'if' expression
+data IfExpression =
+  IfExpression {
+    -- | The condition expression
+    ifExpressionCondition :: Expression,
+    -- | The 'then' branch
+    ifExpressionThen :: Expression,
+    -- | The 'else' branch
+    ifExpressionElse :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_IfExpression = Core.Name "hydra.haskell.syntax.IfExpression"
+
+_IfExpression_condition = Core.Name "condition"
+
+_IfExpression_then = Core.Name "then"
+
+_IfExpression_else = Core.Name "else"
+
 -- | An import statement
 data Import =
   Import {
@@ -517,6 +445,32 @@
 
 _Import_spec = Core.Name "spec"
 
+-- | A subspecification within an import/export
+data ImportExportSubspec =
+  -- | Import/export all
+  ImportExportSubspecAll |
+  -- | Import/export specific names
+  ImportExportSubspecList [Name]
+  deriving (Eq, Ord, Read, Show)
+
+_ImportExportSubspec = Core.Name "hydra.haskell.syntax.ImportExportSubspec"
+
+_ImportExportSubspec_all = Core.Name "all"
+
+_ImportExportSubspec_list = Core.Name "list"
+
+-- | An import modifier ('pattern' or 'type')
+data ImportModifier =
+  ImportModifierPattern |
+  ImportModifierType
+  deriving (Eq, Ord, Read, Show)
+
+_ImportModifier = Core.Name "hydra.haskell.syntax.ImportModifier"
+
+_ImportModifier_pattern = Core.Name "pattern"
+
+_ImportModifier_type = Core.Name "type"
+
 -- | An import specification
 data ImportSpec =
   -- | A list of imports to include
@@ -531,51 +485,74 @@
 
 _ImportSpec_hiding = Core.Name "hiding"
 
--- | An import modifier ('pattern' or 'type')
-data ImportModifier =
-  ImportModifierPattern |
-  ImportModifierType
+-- | An infix application expression
+data InfixExpression =
+  InfixExpression {
+    -- | The left-hand operand
+    infixExpressionLhs :: Expression,
+    -- | The infix operator
+    infixExpressionOperator :: Operator,
+    -- | The right-hand operand
+    infixExpressionRhs :: Expression}
   deriving (Eq, Ord, Read, Show)
 
-_ImportModifier = Core.Name "hydra.haskell.syntax.ImportModifier"
+_InfixExpression = Core.Name "hydra.haskell.syntax.InfixExpression"
 
-_ImportModifier_pattern = Core.Name "pattern"
+_InfixExpression_lhs = Core.Name "lhs"
 
-_ImportModifier_type = Core.Name "type"
+_InfixExpression_operator = Core.Name "operator"
 
--- | An import or export specification
-data NamedImportExport =
-  NamedImportExport {
-    -- | Optional import modifier
-    namedImportExportModifier :: (Maybe ImportModifier),
-    -- | The name being imported or exported
-    namedImportExportName :: Name,
-    -- | Optional subspecification
-    namedImportExportSubspec :: (Maybe ImportExportSubspec)}
+_InfixExpression_rhs = Core.Name "rhs"
+
+-- | An infix type application
+data InfixType =
+  InfixType {
+    -- | The left-hand type
+    infixTypeLhs :: Type,
+    -- | The type operator
+    infixTypeOperator :: Operator,
+    -- | The right-hand type
+    infixTypeRhs :: Type}
   deriving (Eq, Ord, Read, Show)
 
-_NamedImportExport = Core.Name "hydra.haskell.syntax.NamedImportExport"
+_InfixType = Core.Name "hydra.haskell.syntax.InfixType"
 
-_NamedImportExport_modifier = Core.Name "modifier"
+_InfixType_lhs = Core.Name "lhs"
 
-_NamedImportExport_name = Core.Name "name"
+_InfixType_operator = Core.Name "operator"
 
-_NamedImportExport_subspec = Core.Name "subspec"
+_InfixType_rhs = Core.Name "rhs"
 
--- | A subspecification within an import/export
-data ImportExportSubspec =
-  -- | Import/export all
-  ImportExportSubspecAll |
-  -- | Import/export specific names
-  ImportExportSubspecList [Name]
+-- | A lambda expression
+data LambdaExpression =
+  LambdaExpression {
+    -- | The patterns binding parameters
+    lambdaExpressionBindings :: [Pattern],
+    -- | The body of the lambda
+    lambdaExpressionInner :: Expression}
   deriving (Eq, Ord, Read, Show)
 
-_ImportExportSubspec = Core.Name "hydra.haskell.syntax.ImportExportSubspec"
+_LambdaExpression = Core.Name "hydra.haskell.syntax.LambdaExpression"
 
-_ImportExportSubspec_all = Core.Name "all"
+_LambdaExpression_bindings = Core.Name "bindings"
 
-_ImportExportSubspec_list = Core.Name "list"
+_LambdaExpression_inner = Core.Name "inner"
 
+-- | A 'let' expression
+data LetExpression =
+  LetExpression {
+    -- | The local bindings
+    letExpressionBindings :: [LocalBinding],
+    -- | The body of the let expression
+    letExpressionInner :: Expression}
+  deriving (Eq, Ord, Read, Show)
+
+_LetExpression = Core.Name "hydra.haskell.syntax.LetExpression"
+
+_LetExpression_bindings = Core.Name "bindings"
+
+_LetExpression_inner = Core.Name "inner"
+
 -- | A literal value
 data Literal =
   -- | A character literal
@@ -696,6 +673,25 @@
 
 _NamePart = Core.Name "hydra.haskell.syntax.NamePart"
 
+-- | An import or export specification
+data NamedImportExport =
+  NamedImportExport {
+    -- | Optional import modifier
+    namedImportExportModifier :: (Maybe ImportModifier),
+    -- | The name being imported or exported
+    namedImportExportName :: Name,
+    -- | Optional subspecification
+    namedImportExportSubspec :: (Maybe ImportExportSubspec)}
+  deriving (Eq, Ord, Read, Show)
+
+_NamedImportExport = Core.Name "hydra.haskell.syntax.NamedImportExport"
+
+_NamedImportExport_modifier = Core.Name "modifier"
+
+_NamedImportExport_name = Core.Name "name"
+
+_NamedImportExport_subspec = Core.Name "subspec"
+
 -- | An operator
 data Operator =
   -- | A function used as an infix operator
@@ -752,36 +748,89 @@
 
 _Pattern_wildcard = Core.Name "wildcard"
 
--- | An application pattern
-data ApplicationPattern =
-  ApplicationPattern {
-    -- | The constructor name
-    applicationPatternName :: Name,
-    -- | The pattern arguments
-    applicationPatternArgs :: [Pattern]}
+-- | A pattern field
+data PatternField =
+  PatternField {
+    -- | The field name
+    patternFieldName :: Name,
+    -- | The field pattern
+    patternFieldPattern :: Pattern}
   deriving (Eq, Ord, Read, Show)
 
-_ApplicationPattern = Core.Name "hydra.haskell.syntax.ApplicationPattern"
+_PatternField = Core.Name "hydra.haskell.syntax.PatternField"
 
-_ApplicationPattern_name = Core.Name "name"
+_PatternField_name = Core.Name "name"
 
-_ApplicationPattern_args = Core.Name "args"
+_PatternField_pattern = Core.Name "pattern"
 
--- | An 'as' pattern
-data AsPattern =
-  AsPattern {
-    -- | The bound name
-    asPatternName :: Name,
-    -- | The inner pattern
-    asPatternInner :: Pattern}
+-- | An ordinary (positional) data constructor
+data PositionalConstructor =
+  PositionalConstructor {
+    -- | The name of the constructor
+    positionalConstructorName :: Name,
+    -- | The types of the positional fields
+    positionalConstructorFields :: [Type],
+    -- | Optional comments
+    positionalConstructorComments :: (Maybe String)}
   deriving (Eq, Ord, Read, Show)
 
-_AsPattern = Core.Name "hydra.haskell.syntax.AsPattern"
+_PositionalConstructor = Core.Name "hydra.haskell.syntax.PositionalConstructor"
 
-_AsPattern_name = Core.Name "name"
+_PositionalConstructor_name = Core.Name "name"
 
-_AsPattern_inner = Core.Name "inner"
+_PositionalConstructor_fields = Core.Name "fields"
 
+_PositionalConstructor_comments = Core.Name "comments"
+
+-- | A qualified name
+data QualifiedName =
+  QualifiedName {
+    -- | The qualifier parts
+    qualifiedNameQualifiers :: [NamePart],
+    -- | The unqualified name part
+    qualifiedNameUnqualified :: NamePart}
+  deriving (Eq, Ord, Read, Show)
+
+_QualifiedName = Core.Name "hydra.haskell.syntax.QualifiedName"
+
+_QualifiedName_qualifiers = Core.Name "qualifiers"
+
+_QualifiedName_unqualified = Core.Name "unqualified"
+
+-- | A record-style data constructor
+data RecordConstructor =
+  RecordConstructor {
+    -- | The name of the constructor
+    recordConstructorName :: Name,
+    -- | The named fields of the record
+    recordConstructorFields :: [Field],
+    -- | Optional comments
+    recordConstructorComments :: (Maybe String)}
+  deriving (Eq, Ord, Read, Show)
+
+_RecordConstructor = Core.Name "hydra.haskell.syntax.RecordConstructor"
+
+_RecordConstructor_name = Core.Name "name"
+
+_RecordConstructor_fields = Core.Name "fields"
+
+_RecordConstructor_comments = Core.Name "comments"
+
+-- | A record constructor expression
+data RecordExpression =
+  RecordExpression {
+    -- | The constructor name
+    recordExpressionName :: Name,
+    -- | The field assignments
+    recordExpressionFields :: [FieldUpdate]}
+  deriving (Eq, Ord, Read, Show)
+
+_RecordExpression = Core.Name "hydra.haskell.syntax.RecordExpression"
+
+_RecordExpression_name = Core.Name "name"
+
+_RecordExpression_fields = Core.Name "fields"
+
 -- | A record pattern
 data RecordPattern =
   RecordPattern {
@@ -797,58 +846,66 @@
 
 _RecordPattern_fields = Core.Name "fields"
 
--- | A typed pattern
-data TypedPattern =
-  TypedPattern {
-    -- | The inner pattern
-    typedPatternInner :: Pattern,
-    -- | The type annotation
-    typedPatternType :: Type}
+-- | An update record expression
+data RecordUpdateExpression =
+  RecordUpdateExpression {
+    -- | The record being updated
+    recordUpdateExpressionInner :: Expression,
+    -- | The field updates
+    recordUpdateExpressionFields :: [FieldUpdate]}
   deriving (Eq, Ord, Read, Show)
 
-_TypedPattern = Core.Name "hydra.haskell.syntax.TypedPattern"
+_RecordUpdateExpression = Core.Name "hydra.haskell.syntax.RecordUpdateExpression"
 
-_TypedPattern_inner = Core.Name "inner"
+_RecordUpdateExpression_inner = Core.Name "inner"
 
-_TypedPattern_type = Core.Name "type"
+_RecordUpdateExpression_fields = Core.Name "fields"
 
--- | A pattern field
-data PatternField =
-  PatternField {
-    -- | The field name
-    patternFieldName :: Name,
-    -- | The field pattern
-    patternFieldPattern :: Pattern}
+-- | A right-hand side of a binding
+newtype RightHandSide =
+  RightHandSide {
+    unRightHandSide :: Expression}
   deriving (Eq, Ord, Read, Show)
 
-_PatternField = Core.Name "hydra.haskell.syntax.PatternField"
+_RightHandSide = Core.Name "hydra.haskell.syntax.RightHandSide"
 
-_PatternField_name = Core.Name "name"
+-- | A section expression
+data SectionExpression =
+  SectionExpression {
+    -- | The operator
+    sectionExpressionOperator :: Operator,
+    -- | The operand
+    sectionExpressionExpression :: Expression}
+  deriving (Eq, Ord, Read, Show)
 
-_PatternField_pattern = Core.Name "pattern"
+_SectionExpression = Core.Name "hydra.haskell.syntax.SectionExpression"
 
--- | A qualified name
-data QualifiedName =
-  QualifiedName {
-    -- | The qualifier parts
-    qualifiedNameQualifiers :: [NamePart],
-    -- | The unqualified name part
-    qualifiedNameUnqualified :: NamePart}
+_SectionExpression_operator = Core.Name "operator"
+
+_SectionExpression_expression = Core.Name "expression"
+
+-- | A simple value binding
+data SimpleValueBinding =
+  SimpleValueBinding {
+    -- | The pattern being bound
+    simpleValueBindingPattern :: Pattern,
+    -- | The right-hand side
+    simpleValueBindingRhs :: RightHandSide,
+    -- | Optional local bindings (where clause)
+    simpleValueBindingLocalBindings :: (Maybe LocalBindings),
+    -- | Optional comments
+    simpleValueBindingComments :: (Maybe String)}
   deriving (Eq, Ord, Read, Show)
 
-_QualifiedName = Core.Name "hydra.haskell.syntax.QualifiedName"
+_SimpleValueBinding = Core.Name "hydra.haskell.syntax.SimpleValueBinding"
 
-_QualifiedName_qualifiers = Core.Name "qualifiers"
+_SimpleValueBinding_pattern = Core.Name "pattern"
 
-_QualifiedName_unqualified = Core.Name "unqualified"
+_SimpleValueBinding_rhs = Core.Name "rhs"
 
--- | A right-hand side of a binding
-newtype RightHandSide =
-  RightHandSide {
-    unRightHandSide :: Expression}
-  deriving (Eq, Ord, Read, Show)
+_SimpleValueBinding_localBindings = Core.Name "localBindings"
 
-_RightHandSide = Core.Name "hydra.haskell.syntax.RightHandSide"
+_SimpleValueBinding_comments = Core.Name "comments"
 
 -- | A do-notation statement
 newtype Statement =
@@ -892,69 +949,20 @@
 
 _Type_variable = Core.Name "variable"
 
--- | An application type
-data ApplicationType =
-  ApplicationType {
-    -- | The type being applied
-    applicationTypeContext :: Type,
-    -- | The type argument
-    applicationTypeArgument :: Type}
-  deriving (Eq, Ord, Read, Show)
-
-_ApplicationType = Core.Name "hydra.haskell.syntax.ApplicationType"
-
-_ApplicationType_context = Core.Name "context"
-
-_ApplicationType_argument = Core.Name "argument"
-
--- | A type with a context (type class constraints)
-data ConstrainedType =
-  ConstrainedType {
-    -- | The type class context
-    constrainedTypeCtx :: Constraint,
-    -- | The constrained type
-    constrainedTypeType :: Type}
-  deriving (Eq, Ord, Read, Show)
-
-_ConstrainedType = Core.Name "hydra.haskell.syntax.ConstrainedType"
-
-_ConstrainedType_ctx = Core.Name "ctx"
-
-_ConstrainedType_type = Core.Name "type"
-
--- | A function type
-data FunctionType =
-  FunctionType {
-    -- | The domain type
-    functionTypeDomain :: Type,
-    -- | The codomain type
-    functionTypeCodomain :: Type}
-  deriving (Eq, Ord, Read, Show)
-
-_FunctionType = Core.Name "hydra.haskell.syntax.FunctionType"
-
-_FunctionType_domain = Core.Name "domain"
-
-_FunctionType_codomain = Core.Name "codomain"
-
--- | An infix type application
-data InfixType =
-  InfixType {
-    -- | The left-hand type
-    infixTypeLhs :: Type,
-    -- | The type operator
-    infixTypeOperator :: Operator,
-    -- | The right-hand type
-    infixTypeRhs :: Type}
+-- | A type signature
+data TypeSignature =
+  TypeSignature {
+    -- | The name being typed
+    typeSignatureName :: Name,
+    -- | The type
+    typeSignatureType :: Type}
   deriving (Eq, Ord, Read, Show)
 
-_InfixType = Core.Name "hydra.haskell.syntax.InfixType"
-
-_InfixType_lhs = Core.Name "lhs"
+_TypeSignature = Core.Name "hydra.haskell.syntax.TypeSignature"
 
-_InfixType_operator = Core.Name "operator"
+_TypeSignature_name = Core.Name "name"
 
-_InfixType_rhs = Core.Name "rhs"
+_TypeSignature_type = Core.Name "type"
 
 -- | A type synonym declaration
 data TypeSynonymDeclaration =
@@ -975,21 +983,6 @@
 
 _TypeSynonymDeclaration_comments = Core.Name "comments"
 
--- | A type signature
-data TypeSignature =
-  TypeSignature {
-    -- | The name being typed
-    typeSignatureName :: Name,
-    -- | The type
-    typeSignatureType :: Type}
-  deriving (Eq, Ord, Read, Show)
-
-_TypeSignature = Core.Name "hydra.haskell.syntax.TypeSignature"
-
-_TypeSignature_name = Core.Name "name"
-
-_TypeSignature_type = Core.Name "type"
-
 -- | A binding with its type signature
 data TypedBinding =
   TypedBinding {
@@ -1009,38 +1002,45 @@
 
 _TypedBinding_comments = Core.Name "comments"
 
--- | A value binding
-data ValueBinding =
-  -- | A simple value binding
-  ValueBindingSimple SimpleValueBinding
+-- | A type signature expression
+data TypedExpression =
+  TypedExpression {
+    -- | The expression being typed
+    typedExpressionInner :: Expression,
+    -- | The type signature
+    typedExpressionType :: Type}
   deriving (Eq, Ord, Read, Show)
 
-_ValueBinding = Core.Name "hydra.haskell.syntax.ValueBinding"
+_TypedExpression = Core.Name "hydra.haskell.syntax.TypedExpression"
 
-_ValueBinding_simple = Core.Name "simple"
+_TypedExpression_inner = Core.Name "inner"
 
--- | A simple value binding
-data SimpleValueBinding =
-  SimpleValueBinding {
-    -- | The pattern being bound
-    simpleValueBindingPattern :: Pattern,
-    -- | The right-hand side
-    simpleValueBindingRhs :: RightHandSide,
-    -- | Optional local bindings (where clause)
-    simpleValueBindingLocalBindings :: (Maybe LocalBindings),
-    -- | Optional comments
-    simpleValueBindingComments :: (Maybe String)}
+_TypedExpression_type = Core.Name "type"
+
+-- | A typed pattern
+data TypedPattern =
+  TypedPattern {
+    -- | The inner pattern
+    typedPatternInner :: Pattern,
+    -- | The type annotation
+    typedPatternType :: Type}
   deriving (Eq, Ord, Read, Show)
 
-_SimpleValueBinding = Core.Name "hydra.haskell.syntax.SimpleValueBinding"
+_TypedPattern = Core.Name "hydra.haskell.syntax.TypedPattern"
 
-_SimpleValueBinding_pattern = Core.Name "pattern"
+_TypedPattern_inner = Core.Name "inner"
 
-_SimpleValueBinding_rhs = Core.Name "rhs"
+_TypedPattern_type = Core.Name "type"
 
-_SimpleValueBinding_localBindings = Core.Name "localBindings"
+-- | A value binding
+data ValueBinding =
+  -- | A simple value binding
+  ValueBindingSimple SimpleValueBinding
+  deriving (Eq, Ord, Read, Show)
 
-_SimpleValueBinding_comments = Core.Name "comments"
+_ValueBinding = Core.Name "hydra.haskell.syntax.ValueBinding"
+
+_ValueBinding_simple = Core.Name "simple"
 
 -- | A type variable
 newtype Variable =