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-lisp.cabal b/hydra-lisp.cabal
--- a/hydra-lisp.cabal
+++ b/hydra-lisp.cabal
@@ -1,11 +1,11 @@
 cabal-version: 1.12
 
--- This file has been generated from package.yaml by hpack version 0.39.1.
+-- This file has been generated from package.yaml by hpack version 0.38.1.
 --
 -- see: https://github.com/sol/hpack
 
 name:           hydra-lisp
-version:        0.17.0
+version:        0.17.1
 synopsis:       Hydra's Lisp coder: emit Clojure/Scheme/Common-Lisp/Emacs-Lisp source
 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". Lisp support for Hydra (shared across Clojure, Scheme, Common Lisp, and Emacs Lisp)
 category:       Data
@@ -39,6 +39,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/Lisp/Syntax.hs b/src/main/haskell/Hydra/Dsl/Lisp/Syntax.hs
--- a/src/main/haskell/Hydra/Dsl/Lisp/Syntax.hs
+++ b/src/main/haskell/Hydra/Dsl/Lisp/Syntax.hs
@@ -21,6 +21,10 @@
           Core.fieldName = (Core.Name "expressions"),
           Core.fieldTerm = (Typed.unTypedTerm expressions)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.AndExpression
+andExpressionAndExpression :: Typed.TypedName Syntax.AndExpression
+andExpressionAndExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.AndExpression")
+
 -- | DSL accessor for the expressions field of hydra.lisp.syntax.AndExpression
 andExpressionExpressions :: Typed.TypedTerm Syntax.AndExpression -> Typed.TypedTerm [Syntax.Expression]
 andExpressionExpressions x =
@@ -53,6 +57,10 @@
           Core.fieldName = (Core.Name "arguments"),
           Core.fieldTerm = (Typed.unTypedTerm arguments)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.Application
+applicationApplication :: Typed.TypedName Syntax.Application
+applicationApplication = Typed.TypedName (Core.Name "hydra.lisp.syntax.Application")
+
 -- | DSL accessor for the arguments field of hydra.lisp.syntax.Application
 applicationArguments :: Typed.TypedTerm Syntax.Application -> Typed.TypedTerm [Syntax.Expression]
 applicationArguments x =
@@ -115,6 +123,10 @@
           Core.fieldName = (Core.Name "expressions"),
           Core.fieldTerm = (Typed.unTypedTerm expressions)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.BeginExpression
+beginExpressionBeginExpression :: Typed.TypedName Syntax.BeginExpression
+beginExpressionBeginExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.BeginExpression")
+
 -- | DSL accessor for the expressions field of hydra.lisp.syntax.BeginExpression
 beginExpressionExpressions :: Typed.TypedTerm Syntax.BeginExpression -> Typed.TypedTerm [Syntax.Expression]
 beginExpressionExpressions x =
@@ -134,6 +146,10 @@
           Core.fieldName = (Core.Name "expressions"),
           Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.BooleanStyle
+booleanStyleBooleanStyle :: Typed.TypedName Syntax.BooleanStyle
+booleanStyleBooleanStyle = Typed.TypedName (Core.Name "hydra.lisp.syntax.BooleanStyle")
+
 -- | DSL injection for the hashTF variant of hydra.lisp.syntax.BooleanStyle
 booleanStyleHashTF :: Typed.TypedTerm Syntax.BooleanStyle
 booleanStyleHashTF =
@@ -183,6 +199,10 @@
         Core.projectionFieldName = (Core.Name "body")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.CaseClause
+caseClauseCaseClause :: Typed.TypedName Syntax.CaseClause
+caseClauseCaseClause = Typed.TypedName (Core.Name "hydra.lisp.syntax.CaseClause")
+
 -- | DSL accessor for the keys field of hydra.lisp.syntax.CaseClause
 caseClauseKeys :: Typed.TypedTerm Syntax.CaseClause -> Typed.TypedTerm [Syntax.Expression]
 caseClauseKeys x =
@@ -242,6 +262,10 @@
           Core.fieldName = (Core.Name "default"),
           Core.fieldTerm = (Typed.unTypedTerm default_)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.CaseExpression
+caseExpressionCaseExpression :: Typed.TypedName Syntax.CaseExpression
+caseExpressionCaseExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.CaseExpression")
+
 -- | DSL accessor for the clauses field of hydra.lisp.syntax.CaseExpression
 caseExpressionClauses :: Typed.TypedTerm Syntax.CaseExpression -> Typed.TypedTerm [Syntax.CaseClause]
 caseExpressionClauses x =
@@ -351,6 +375,10 @@
           Core.fieldName = (Core.Name "value"),
           Core.fieldTerm = (Typed.unTypedTerm value)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.CharacterLiteral
+characterLiteralCharacterLiteral :: Typed.TypedName Syntax.CharacterLiteral
+characterLiteralCharacterLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.CharacterLiteral")
+
 -- | DSL accessor for the value field of hydra.lisp.syntax.CharacterLiteral
 characterLiteralValue :: Typed.TypedTerm Syntax.CharacterLiteral -> Typed.TypedTerm String
 characterLiteralValue x =
@@ -383,6 +411,10 @@
           Core.fieldName = (Core.Name "text"),
           Core.fieldTerm = (Typed.unTypedTerm text)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.Comment
+commentComment :: Typed.TypedName Syntax.Comment
+commentComment = Typed.TypedName (Core.Name "hydra.lisp.syntax.Comment")
+
 -- | DSL accessor for the style field of hydra.lisp.syntax.Comment
 commentStyle :: Typed.TypedTerm Syntax.Comment -> Typed.TypedTerm Syntax.CommentStyle
 commentStyle x =
@@ -401,6 +433,10 @@
         Core.fieldName = (Core.Name "block"),
         Core.fieldTerm = Core.TermUnit}}))
 
+-- | DSL name token for hydra.lisp.syntax.CommentStyle
+commentStyleCommentStyle :: Typed.TypedName Syntax.CommentStyle
+commentStyleCommentStyle = Typed.TypedName (Core.Name "hydra.lisp.syntax.CommentStyle")
+
 -- | DSL injection for the datum variant of hydra.lisp.syntax.CommentStyle
 commentStyleDatum :: Typed.TypedTerm Syntax.CommentStyle
 commentStyleDatum =
@@ -484,6 +520,10 @@
         Core.projectionFieldName = (Core.Name "body")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.CondClause
+condClauseCondClause :: Typed.TypedName Syntax.CondClause
+condClauseCondClause = Typed.TypedName (Core.Name "hydra.lisp.syntax.CondClause")
+
 -- | DSL accessor for the condition field of hydra.lisp.syntax.CondClause
 condClauseCondition :: Typed.TypedTerm Syntax.CondClause -> Typed.TypedTerm Syntax.Expression
 condClauseCondition x =
@@ -549,6 +589,10 @@
         Core.projectionFieldName = (Core.Name "clauses")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.CondExpression
+condExpressionCondExpression :: Typed.TypedName Syntax.CondExpression
+condExpressionCondExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.CondExpression")
+
 -- | DSL accessor for the default field of hydra.lisp.syntax.CondExpression
 condExpressionDefault :: Typed.TypedTerm Syntax.CondExpression -> Typed.TypedTerm (Maybe Syntax.Expression)
 condExpressionDefault x =
@@ -605,6 +649,10 @@
           Core.fieldName = (Core.Name "tail"),
           Core.fieldTerm = (Typed.unTypedTerm tail)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.ConsExpression
+consExpressionConsExpression :: Typed.TypedName Syntax.ConsExpression
+consExpressionConsExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.ConsExpression")
+
 -- | DSL accessor for the head field of hydra.lisp.syntax.ConsExpression
 consExpressionHead :: Typed.TypedTerm Syntax.ConsExpression -> Typed.TypedTerm Syntax.Expression
 consExpressionHead x =
@@ -673,6 +721,10 @@
           Core.fieldName = (Core.Name "doc"),
           Core.fieldTerm = (Typed.unTypedTerm doc)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.ConstantDefinition
+constantDefinitionConstantDefinition :: Typed.TypedName Syntax.ConstantDefinition
+constantDefinitionConstantDefinition = Typed.TypedName (Core.Name "hydra.lisp.syntax.ConstantDefinition")
+
 -- | DSL accessor for the doc field of hydra.lisp.syntax.ConstantDefinition
 constantDefinitionDoc :: Typed.TypedTerm Syntax.ConstantDefinition -> Typed.TypedTerm (Maybe Syntax.Docstring)
 constantDefinitionDoc x =
@@ -803,6 +855,10 @@
         Core.projectionFieldName = (Core.Name "constructor")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.ConstructorPattern
+constructorPatternConstructorPattern :: Typed.TypedName Syntax.ConstructorPattern
+constructorPatternConstructorPattern = Typed.TypedName (Core.Name "hydra.lisp.syntax.ConstructorPattern")
+
 -- | DSL updater for the arguments field of hydra.lisp.syntax.ConstructorPattern
 constructorPatternWithArguments :: Typed.TypedTerm Syntax.ConstructorPattern -> Typed.TypedTerm [Syntax.Pattern] -> Typed.TypedTerm Syntax.ConstructorPattern
 constructorPatternWithArguments original newVal =
@@ -850,6 +906,10 @@
           Core.fieldName = (Core.Name "value"),
           Core.fieldTerm = (Typed.unTypedTerm value)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.DestructuringBinding
+destructuringBindingDestructuringBinding :: Typed.TypedName Syntax.DestructuringBinding
+destructuringBindingDestructuringBinding = Typed.TypedName (Core.Name "hydra.lisp.syntax.DestructuringBinding")
+
 -- | DSL accessor for the pattern field of hydra.lisp.syntax.DestructuringBinding
 destructuringBindingPattern :: Typed.TypedTerm Syntax.DestructuringBinding -> Typed.TypedTerm Syntax.DestructuringPattern
 destructuringBindingPattern x =
@@ -911,6 +971,10 @@
         Core.fieldName = (Core.Name "associative"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.lisp.syntax.DestructuringPattern
+destructuringPatternDestructuringPattern :: Typed.TypedName Syntax.DestructuringPattern
+destructuringPatternDestructuringPattern = Typed.TypedName (Core.Name "hydra.lisp.syntax.DestructuringPattern")
+
 -- | DSL injection for the rest variant of hydra.lisp.syntax.DestructuringPattern
 destructuringPatternRest :: Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.DestructuringPattern
 destructuringPatternRest x =
@@ -947,6 +1011,10 @@
         Core.fieldName = (Core.Name "commonLisp"),
         Core.fieldTerm = Core.TermUnit}}))
 
+-- | DSL name token for hydra.lisp.syntax.Dialect
+dialectDialect :: Typed.TypedName Syntax.Dialect
+dialectDialect = Typed.TypedName (Core.Name "hydra.lisp.syntax.Dialect")
+
 -- | DSL injection for the emacsLisp variant of hydra.lisp.syntax.Dialect
 dialectEmacsLisp :: Typed.TypedTerm Syntax.Dialect
 dialectEmacsLisp =
@@ -975,6 +1043,10 @@
           Core.fieldName = (Core.Name "expressions"),
           Core.fieldTerm = (Typed.unTypedTerm expressions)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.DoExpression
+doExpressionDoExpression :: Typed.TypedName Syntax.DoExpression
+doExpressionDoExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.DoExpression")
+
 -- | DSL accessor for the expressions field of hydra.lisp.syntax.DoExpression
 doExpressionExpressions :: Typed.TypedTerm Syntax.DoExpression -> Typed.TypedTerm [Syntax.Expression]
 doExpressionExpressions x =
@@ -1001,6 +1073,10 @@
       Core.wrappedTermTypeName = (Core.Name "hydra.lisp.syntax.Docstring"),
       Core.wrappedTermBody = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.Docstring
+docstringDocstring :: Typed.TypedName Syntax.Docstring
+docstringDocstring = Typed.TypedName (Core.Name "hydra.lisp.syntax.Docstring")
+
 -- | DSL constructor for hydra.lisp.syntax.DottedPair
 dottedPair :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DottedPair
 dottedPair car cdr =
@@ -1032,6 +1108,10 @@
         Core.projectionFieldName = (Core.Name "cdr")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.DottedPair
+dottedPairDottedPair :: Typed.TypedName Syntax.DottedPair
+dottedPairDottedPair = Typed.TypedName (Core.Name "hydra.lisp.syntax.DottedPair")
+
 -- | DSL updater for the car field of hydra.lisp.syntax.DottedPair
 dottedPairWithCar :: Typed.TypedTerm Syntax.DottedPair -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.DottedPair
 dottedPairWithCar original newVal =
@@ -1076,6 +1156,10 @@
           Core.fieldName = (Core.Name "symbols"),
           Core.fieldTerm = (Typed.unTypedTerm symbols)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.ExportDeclaration
+exportDeclarationExportDeclaration :: Typed.TypedName Syntax.ExportDeclaration
+exportDeclarationExportDeclaration = Typed.TypedName (Core.Name "hydra.lisp.syntax.ExportDeclaration")
+
 -- | DSL accessor for the symbols field of hydra.lisp.syntax.ExportDeclaration
 exportDeclarationSymbols :: Typed.TypedTerm Syntax.ExportDeclaration -> Typed.TypedTerm [Syntax.Symbol]
 exportDeclarationSymbols x =
@@ -1167,6 +1251,10 @@
         Core.fieldName = (Core.Name "dottedPair"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.lisp.syntax.Expression
+expressionExpression :: Typed.TypedName Syntax.Expression
+expressionExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.Expression")
+
 -- | DSL injection for the fieldAccess variant of hydra.lisp.syntax.Expression
 expressionFieldAccess :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Expression
 expressionFieldAccess x =
@@ -1354,6 +1442,10 @@
         Core.projectionFieldName = (Core.Name "field")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.FieldAccess
+fieldAccessFieldAccess :: Typed.TypedName Syntax.FieldAccess
+fieldAccessFieldAccess = Typed.TypedName (Core.Name "hydra.lisp.syntax.FieldAccess")
+
 -- | DSL accessor for the recordType field of hydra.lisp.syntax.FieldAccess
 fieldAccessRecordType :: Typed.TypedTerm Syntax.FieldAccess -> Typed.TypedTerm Syntax.Symbol
 fieldAccessRecordType x =
@@ -1466,6 +1558,10 @@
         Core.projectionFieldName = (Core.Name "defaultValue")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.FieldDefinition
+fieldDefinitionFieldDefinition :: Typed.TypedName Syntax.FieldDefinition
+fieldDefinitionFieldDefinition = Typed.TypedName (Core.Name "hydra.lisp.syntax.FieldDefinition")
+
 -- | DSL accessor for the name field of hydra.lisp.syntax.FieldDefinition
 fieldDefinitionName :: Typed.TypedTerm Syntax.FieldDefinition -> Typed.TypedTerm Syntax.Symbol
 fieldDefinitionName x =
@@ -1522,6 +1618,10 @@
           Core.fieldName = (Core.Name "precision"),
           Core.fieldTerm = (Typed.unTypedTerm precision)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.FloatLiteral
+floatLiteralFloatLiteral :: Typed.TypedName Syntax.FloatLiteral
+floatLiteralFloatLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.FloatLiteral")
+
 -- | DSL accessor for the precision field of hydra.lisp.syntax.FloatLiteral
 floatLiteralPrecision :: Typed.TypedTerm Syntax.FloatLiteral -> Typed.TypedTerm (Maybe String)
 floatLiteralPrecision x =
@@ -1617,6 +1717,10 @@
         Core.projectionFieldName = (Core.Name "doc")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.FunctionDefinition
+functionDefinitionFunctionDefinition :: Typed.TypedName Syntax.FunctionDefinition
+functionDefinitionFunctionDefinition = Typed.TypedName (Core.Name "hydra.lisp.syntax.FunctionDefinition")
+
 -- | DSL accessor for the name field of hydra.lisp.syntax.FunctionDefinition
 functionDefinitionName :: Typed.TypedTerm Syntax.FunctionDefinition -> Typed.TypedTerm Syntax.Symbol
 functionDefinitionName x =
@@ -1957,6 +2061,10 @@
         Core.projectionFieldName = (Core.Name "else")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.IfExpression
+ifExpressionIfExpression :: Typed.TypedName Syntax.IfExpression
+ifExpressionIfExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.IfExpression")
+
 -- | DSL accessor for the then field of hydra.lisp.syntax.IfExpression
 ifExpressionThen :: Typed.TypedTerm Syntax.IfExpression -> Typed.TypedTerm Syntax.Expression
 ifExpressionThen x =
@@ -2051,6 +2159,10 @@
           Core.fieldName = (Core.Name "spec"),
           Core.fieldTerm = (Typed.unTypedTerm spec)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.ImportDeclaration
+importDeclarationImportDeclaration :: Typed.TypedName Syntax.ImportDeclaration
+importDeclarationImportDeclaration = Typed.TypedName (Core.Name "hydra.lisp.syntax.ImportDeclaration")
+
 -- | DSL accessor for the module field of hydra.lisp.syntax.ImportDeclaration
 importDeclarationModule :: Typed.TypedTerm Syntax.ImportDeclaration -> Typed.TypedTerm Syntax.NamespaceName
 importDeclarationModule x =
@@ -2121,6 +2233,10 @@
         Core.fieldName = (Core.Name "all"),
         Core.fieldTerm = Core.TermUnit}}))
 
+-- | DSL name token for hydra.lisp.syntax.ImportSpec
+importSpecImportSpec :: Typed.TypedName Syntax.ImportSpec
+importSpecImportSpec = Typed.TypedName (Core.Name "hydra.lisp.syntax.ImportSpec")
+
 -- | DSL injection for the only variant of hydra.lisp.syntax.ImportSpec
 importSpecOnly :: Typed.TypedTerm [Syntax.Symbol] -> Typed.TypedTerm Syntax.ImportSpec
 importSpecOnly x =
@@ -2161,6 +2277,10 @@
         Core.projectionFieldName = (Core.Name "bigint")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.IntegerLiteral
+integerLiteralIntegerLiteral :: Typed.TypedName Syntax.IntegerLiteral
+integerLiteralIntegerLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.IntegerLiteral")
+
 -- | DSL accessor for the value field of hydra.lisp.syntax.IntegerLiteral
 integerLiteralValue :: Typed.TypedTerm Syntax.IntegerLiteral -> Typed.TypedTerm Integer
 integerLiteralValue x =
@@ -2217,6 +2337,10 @@
           Core.fieldName = (Core.Name "namespace"),
           Core.fieldTerm = (Typed.unTypedTerm namespace)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.Keyword
+keywordKeyword :: Typed.TypedName Syntax.Keyword
+keywordKeyword = Typed.TypedName (Core.Name "hydra.lisp.syntax.Keyword")
+
 -- | DSL accessor for the name field of hydra.lisp.syntax.Keyword
 keywordName :: Typed.TypedTerm Syntax.Keyword -> Typed.TypedTerm String
 keywordName x =
@@ -2297,6 +2421,10 @@
         Core.projectionFieldName = (Core.Name "body")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.Lambda
+lambdaLambda :: Typed.TypedName Syntax.Lambda
+lambdaLambda = Typed.TypedName (Core.Name "hydra.lisp.syntax.Lambda")
+
 -- | DSL accessor for the name field of hydra.lisp.syntax.Lambda
 lambdaName :: Typed.TypedTerm Syntax.Lambda -> Typed.TypedTerm (Maybe Syntax.Symbol)
 lambdaName x =
@@ -2457,6 +2585,10 @@
         Core.fieldName = (Core.Name "destructuring"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.lisp.syntax.LetBinding
+letBindingLetBinding :: Typed.TypedName Syntax.LetBinding
+letBindingLetBinding = Typed.TypedName (Core.Name "hydra.lisp.syntax.LetBinding")
+
 -- | DSL injection for the simple variant of hydra.lisp.syntax.LetBinding
 letBindingSimple :: Typed.TypedTerm Syntax.SimpleBinding -> Typed.TypedTerm Syntax.LetBinding
 letBindingSimple x =
@@ -2509,6 +2641,10 @@
         Core.projectionFieldName = (Core.Name "kind")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.LetExpression
+letExpressionLetExpression :: Typed.TypedName Syntax.LetExpression
+letExpressionLetExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.LetExpression")
+
 -- | DSL updater for the bindings field of hydra.lisp.syntax.LetExpression
 letExpressionWithBindings :: Typed.TypedTerm Syntax.LetExpression -> Typed.TypedTerm [Syntax.LetBinding] -> Typed.TypedTerm Syntax.LetExpression
 letExpressionWithBindings original newVal =
@@ -2581,6 +2717,10 @@
               Core.projectionFieldName = (Core.Name "body")})),
             Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
 
+-- | DSL name token for hydra.lisp.syntax.LetKind
+letKindLetKind :: Typed.TypedName Syntax.LetKind
+letKindLetKind = Typed.TypedName (Core.Name "hydra.lisp.syntax.LetKind")
+
 -- | DSL injection for the parallel variant of hydra.lisp.syntax.LetKind
 letKindParallel :: Typed.TypedTerm Syntax.LetKind
 letKindParallel =
@@ -2630,6 +2770,10 @@
         Core.projectionFieldName = (Core.Name "elements")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.ListLiteral
+listLiteralListLiteral :: Typed.TypedName Syntax.ListLiteral
+listLiteralListLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.ListLiteral")
+
 -- | DSL accessor for the quoted field of hydra.lisp.syntax.ListLiteral
 listLiteralQuoted :: Typed.TypedTerm Syntax.ListLiteral -> Typed.TypedTerm Bool
 listLiteralQuoted x =
@@ -2718,6 +2862,10 @@
         Core.fieldName = (Core.Name "keyword"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.lisp.syntax.Literal
+literalLiteral :: Typed.TypedName Syntax.Literal
+literalLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.Literal")
+
 -- | DSL injection for the nil variant of hydra.lisp.syntax.Literal
 literalNil :: Typed.TypedTerm Syntax.Literal
 literalNil =
@@ -2737,6 +2885,10 @@
           Core.fieldName = (Core.Name "value"),
           Core.fieldTerm = (Typed.unTypedTerm value)}]}))
 
+-- | DSL name token for hydra.lisp.syntax.LiteralPattern
+literalPatternLiteralPattern :: Typed.TypedName Syntax.LiteralPattern
+literalPatternLiteralPattern = Typed.TypedName (Core.Name "hydra.lisp.syntax.LiteralPattern")
+
 -- | DSL accessor for the value field of hydra.lisp.syntax.LiteralPattern
 literalPatternValue :: Typed.TypedTerm Syntax.LiteralPattern -> Typed.TypedTerm Syntax.Literal
 literalPatternValue x =
@@ -2802,6 +2954,10 @@
         Core.projectionFieldName = (Core.Name "body")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.MacroDefinition
+macroDefinitionMacroDefinition :: Typed.TypedName Syntax.MacroDefinition
+macroDefinitionMacroDefinition = Typed.TypedName (Core.Name "hydra.lisp.syntax.MacroDefinition")
+
 -- | DSL accessor for the name field of hydra.lisp.syntax.MacroDefinition
 macroDefinitionName :: Typed.TypedTerm Syntax.MacroDefinition -> Typed.TypedTerm Syntax.Symbol
 macroDefinitionName x =
@@ -2975,6 +3131,10 @@
         Core.projectionFieldName = (Core.Name "key")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.MapEntry
+mapEntryMapEntry :: Typed.TypedName Syntax.MapEntry
+mapEntryMapEntry = Typed.TypedName (Core.Name "hydra.lisp.syntax.MapEntry")
+
 -- | DSL accessor for the value field of hydra.lisp.syntax.MapEntry
 mapEntryValue :: Typed.TypedTerm Syntax.MapEntry -> Typed.TypedTerm Syntax.Expression
 mapEntryValue x =
@@ -3037,6 +3197,10 @@
         Core.projectionFieldName = (Core.Name "entries")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.MapLiteral
+mapLiteralMapLiteral :: Typed.TypedName Syntax.MapLiteral
+mapLiteralMapLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.MapLiteral")
+
 -- | DSL updater for the entries field of hydra.lisp.syntax.MapLiteral
 mapLiteralWithEntries :: Typed.TypedTerm Syntax.MapLiteral -> Typed.TypedTerm [Syntax.MapEntry] -> Typed.TypedTerm Syntax.MapLiteral
 mapLiteralWithEntries original newVal =
@@ -3069,6 +3233,10 @@
         Core.projectionFieldName = (Core.Name "doc")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.ModuleDeclaration
+moduleDeclarationModuleDeclaration :: Typed.TypedName Syntax.ModuleDeclaration
+moduleDeclarationModuleDeclaration = Typed.TypedName (Core.Name "hydra.lisp.syntax.ModuleDeclaration")
+
 -- | DSL accessor for the name field of hydra.lisp.syntax.ModuleDeclaration
 moduleDeclarationName :: Typed.TypedTerm Syntax.ModuleDeclaration -> Typed.TypedTerm Syntax.NamespaceName
 moduleDeclarationName x =
@@ -3119,6 +3287,10 @@
       Core.wrappedTermTypeName = (Core.Name "hydra.lisp.syntax.NamespaceName"),
       Core.wrappedTermBody = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.NamespaceName
+namespaceNameNamespaceName :: Typed.TypedName Syntax.NamespaceName
+namespaceNameNamespaceName = Typed.TypedName (Core.Name "hydra.lisp.syntax.NamespaceName")
+
 -- | DSL injection for the emptyList variant of hydra.lisp.syntax.NilStyle
 nilStyleEmptyList :: Typed.TypedTerm Syntax.NilStyle
 nilStyleEmptyList =
@@ -3137,6 +3309,10 @@
         Core.fieldName = (Core.Name "nil"),
         Core.fieldTerm = Core.TermUnit}}))
 
+-- | DSL name token for hydra.lisp.syntax.NilStyle
+nilStyleNilStyle :: Typed.TypedName Syntax.NilStyle
+nilStyleNilStyle = Typed.TypedName (Core.Name "hydra.lisp.syntax.NilStyle")
+
 -- | DSL constructor for hydra.lisp.syntax.NotExpression
 notExpression :: Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.NotExpression
 notExpression expression =
@@ -3156,6 +3332,10 @@
         Core.projectionFieldName = (Core.Name "expression")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.NotExpression
+notExpressionNotExpression :: Typed.TypedName Syntax.NotExpression
+notExpressionNotExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.NotExpression")
+
 -- | DSL updater for the expression field of hydra.lisp.syntax.NotExpression
 notExpressionWithExpression :: Typed.TypedTerm Syntax.NotExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.NotExpression
 notExpressionWithExpression original newVal =
@@ -3185,6 +3365,10 @@
         Core.projectionFieldName = (Core.Name "expressions")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.OrExpression
+orExpressionOrExpression :: Typed.TypedName Syntax.OrExpression
+orExpressionOrExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.OrExpression")
+
 -- | DSL updater for the expressions field of hydra.lisp.syntax.OrExpression
 orExpressionWithExpressions :: Typed.TypedTerm Syntax.OrExpression -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.OrExpression
 orExpressionWithExpressions original newVal =
@@ -3213,6 +3397,10 @@
         Core.fieldName = (Core.Name "literal"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.lisp.syntax.Pattern
+patternPattern :: Typed.TypedName Syntax.Pattern
+patternPattern = Typed.TypedName (Core.Name "hydra.lisp.syntax.Pattern")
+
 -- | DSL injection for the variable variant of hydra.lisp.syntax.Pattern
 patternVariable :: Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.Pattern
 patternVariable x =
@@ -3298,6 +3486,10 @@
         Core.projectionFieldName = (Core.Name "module")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.Program
+programProgram :: Typed.TypedName Syntax.Program
+programProgram = Typed.TypedName (Core.Name "hydra.lisp.syntax.Program")
+
 -- | DSL updater for the dialect field of hydra.lisp.syntax.Program
 programWithDialect :: Typed.TypedTerm Syntax.Program -> Typed.TypedTerm Syntax.Dialect -> Typed.TypedTerm Syntax.Program
 programWithDialect original newVal =
@@ -3519,6 +3711,10 @@
         Core.projectionFieldName = (Core.Name "namespace")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.QualifiedSymbol
+qualifiedSymbolQualifiedSymbol :: Typed.TypedName Syntax.QualifiedSymbol
+qualifiedSymbolQualifiedSymbol = Typed.TypedName (Core.Name "hydra.lisp.syntax.QualifiedSymbol")
+
 -- | DSL updater for the name field of hydra.lisp.syntax.QualifiedSymbol
 qualifiedSymbolWithName :: Typed.TypedTerm Syntax.QualifiedSymbol -> Typed.TypedTerm String -> Typed.TypedTerm Syntax.QualifiedSymbol
 qualifiedSymbolWithName original newVal =
@@ -3572,6 +3768,10 @@
         Core.projectionFieldName = (Core.Name "body")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.QuasiquoteExpression
+quasiquoteExpressionQuasiquoteExpression :: Typed.TypedName Syntax.QuasiquoteExpression
+quasiquoteExpressionQuasiquoteExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.QuasiquoteExpression")
+
 -- | DSL updater for the body field of hydra.lisp.syntax.QuasiquoteExpression
 quasiquoteExpressionWithBody :: Typed.TypedTerm Syntax.QuasiquoteExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.QuasiquoteExpression
 quasiquoteExpressionWithBody original newVal =
@@ -3601,6 +3801,10 @@
         Core.projectionFieldName = (Core.Name "body")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.QuoteExpression
+quoteExpressionQuoteExpression :: Typed.TypedName Syntax.QuoteExpression
+quoteExpressionQuoteExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.QuoteExpression")
+
 -- | DSL updater for the body field of hydra.lisp.syntax.QuoteExpression
 quoteExpressionWithBody :: Typed.TypedTerm Syntax.QuoteExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.QuoteExpression
 quoteExpressionWithBody original newVal =
@@ -3654,6 +3858,10 @@
         Core.projectionFieldName = (Core.Name "name")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.RecordTypeDefinition
+recordTypeDefinitionRecordTypeDefinition :: Typed.TypedName Syntax.RecordTypeDefinition
+recordTypeDefinitionRecordTypeDefinition = Typed.TypedName (Core.Name "hydra.lisp.syntax.RecordTypeDefinition")
+
 -- | DSL updater for the doc field of hydra.lisp.syntax.RecordTypeDefinition
 recordTypeDefinitionWithDoc :: Typed.TypedTerm Syntax.RecordTypeDefinition -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm Syntax.RecordTypeDefinition
 recordTypeDefinitionWithDoc original newVal =
@@ -3744,6 +3952,10 @@
         Core.fieldName = (Core.Name "list"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.lisp.syntax.SExpression
+sExpressionSExpression :: Typed.TypedName Syntax.SExpression
+sExpressionSExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.SExpression")
+
 -- | DSL constructor for hydra.lisp.syntax.SetLiteral
 setLiteral :: Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.SetLiteral
 setLiteral elements =
@@ -3763,6 +3975,10 @@
         Core.projectionFieldName = (Core.Name "elements")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.SetLiteral
+setLiteralSetLiteral :: Typed.TypedName Syntax.SetLiteral
+setLiteralSetLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.SetLiteral")
+
 -- | DSL updater for the elements field of hydra.lisp.syntax.SetLiteral
 setLiteralWithElements :: Typed.TypedTerm Syntax.SetLiteral -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.SetLiteral
 setLiteralWithElements original newVal =
@@ -3795,6 +4011,10 @@
         Core.projectionFieldName = (Core.Name "name")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.SimpleBinding
+simpleBindingSimpleBinding :: Typed.TypedName Syntax.SimpleBinding
+simpleBindingSimpleBinding = Typed.TypedName (Core.Name "hydra.lisp.syntax.SimpleBinding")
+
 -- | DSL accessor for the value field of hydra.lisp.syntax.SimpleBinding
 simpleBindingValue :: Typed.TypedTerm Syntax.SimpleBinding -> Typed.TypedTerm Syntax.Expression
 simpleBindingValue x =
@@ -3857,6 +4077,11 @@
         Core.projectionFieldName = (Core.Name "body")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.SplicingUnquoteExpression
+splicingUnquoteExpressionSplicingUnquoteExpression :: Typed.TypedName Syntax.SplicingUnquoteExpression
+splicingUnquoteExpressionSplicingUnquoteExpression =
+    Typed.TypedName (Core.Name "hydra.lisp.syntax.SplicingUnquoteExpression")
+
 -- | DSL updater for the body field of hydra.lisp.syntax.SplicingUnquoteExpression
 splicingUnquoteExpressionWithBody :: Typed.TypedTerm Syntax.SplicingUnquoteExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.SplicingUnquoteExpression
 splicingUnquoteExpressionWithBody original newVal =
@@ -3874,6 +4099,10 @@
       Core.wrappedTermTypeName = (Core.Name "hydra.lisp.syntax.Symbol"),
       Core.wrappedTermBody = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.Symbol
+symbolSymbol :: Typed.TypedName Syntax.Symbol
+symbolSymbol = Typed.TypedName (Core.Name "hydra.lisp.syntax.Symbol")
+
 -- | DSL injection for the constant variant of hydra.lisp.syntax.TopLevelForm
 topLevelFormConstant :: Typed.TypedTerm Syntax.ConstantDefinition -> Typed.TypedTerm Syntax.TopLevelForm
 topLevelFormConstant x =
@@ -3919,6 +4148,10 @@
         Core.fieldName = (Core.Name "recordType"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.lisp.syntax.TopLevelForm
+topLevelFormTopLevelForm :: Typed.TypedName Syntax.TopLevelForm
+topLevelFormTopLevelForm = Typed.TypedName (Core.Name "hydra.lisp.syntax.TopLevelForm")
+
 -- | DSL injection for the variable variant of hydra.lisp.syntax.TopLevelForm
 topLevelFormVariable :: Typed.TypedTerm Syntax.VariableDefinition -> Typed.TypedTerm Syntax.TopLevelForm
 topLevelFormVariable x =
@@ -3971,6 +4204,11 @@
         Core.projectionFieldName = (Core.Name "form")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.TopLevelFormWithComments
+topLevelFormWithCommentsTopLevelFormWithComments :: Typed.TypedName Syntax.TopLevelFormWithComments
+topLevelFormWithCommentsTopLevelFormWithComments =
+    Typed.TypedName (Core.Name "hydra.lisp.syntax.TopLevelFormWithComments")
+
 -- | DSL updater for the comment field of hydra.lisp.syntax.TopLevelFormWithComments
 topLevelFormWithCommentsWithComment :: Typed.TypedTerm Syntax.TopLevelFormWithComments -> Typed.TypedTerm (Maybe Syntax.Comment) -> Typed.TypedTerm Syntax.TopLevelFormWithComments
 topLevelFormWithCommentsWithComment original newVal =
@@ -4074,6 +4312,10 @@
         Core.projectionFieldName = (Core.Name "type")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.TypeAnnotation
+typeAnnotationTypeAnnotation :: Typed.TypedName Syntax.TypeAnnotation
+typeAnnotationTypeAnnotation = Typed.TypedName (Core.Name "hydra.lisp.syntax.TypeAnnotation")
+
 -- | DSL updater for the expression field of hydra.lisp.syntax.TypeAnnotation
 typeAnnotationWithExpression :: Typed.TypedTerm Syntax.TypeAnnotation -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.TypeAnnotation
 typeAnnotationWithExpression original newVal =
@@ -4139,6 +4381,10 @@
         Core.projectionFieldName = (Core.Name "type")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.TypeHint
+typeHintTypeHint :: Typed.TypedName Syntax.TypeHint
+typeHintTypeHint = Typed.TypedName (Core.Name "hydra.lisp.syntax.TypeHint")
+
 -- | DSL updater for the name field of hydra.lisp.syntax.TypeHint
 typeHintWithName :: Typed.TypedTerm Syntax.TypeHint -> Typed.TypedTerm Syntax.Symbol -> Typed.TypedTerm Syntax.TypeHint
 typeHintWithName original newVal =
@@ -4245,6 +4491,10 @@
         Core.fieldName = (Core.Name "set"),
         Core.fieldTerm = (Typed.unTypedTerm x)}}))
 
+-- | DSL name token for hydra.lisp.syntax.TypeSpecifier
+typeSpecifierTypeSpecifier :: Typed.TypedName Syntax.TypeSpecifier
+typeSpecifierTypeSpecifier = Typed.TypedName (Core.Name "hydra.lisp.syntax.TypeSpecifier")
+
 -- | DSL injection for the unit variant of hydra.lisp.syntax.TypeSpecifier
 typeSpecifierUnit :: Typed.TypedTerm Syntax.TypeSpecifier
 typeSpecifierUnit =
@@ -4294,6 +4544,10 @@
         Core.projectionFieldName = (Core.Name "body")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.UnquoteExpression
+unquoteExpressionUnquoteExpression :: Typed.TypedName Syntax.UnquoteExpression
+unquoteExpressionUnquoteExpression = Typed.TypedName (Core.Name "hydra.lisp.syntax.UnquoteExpression")
+
 -- | DSL updater for the body field of hydra.lisp.syntax.UnquoteExpression
 unquoteExpressionWithBody :: Typed.TypedTerm Syntax.UnquoteExpression -> Typed.TypedTerm Syntax.Expression -> Typed.TypedTerm Syntax.UnquoteExpression
 unquoteExpressionWithBody original newVal =
@@ -4347,6 +4601,10 @@
         Core.projectionFieldName = (Core.Name "value")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.VariableDefinition
+variableDefinitionVariableDefinition :: Typed.TypedName Syntax.VariableDefinition
+variableDefinitionVariableDefinition = Typed.TypedName (Core.Name "hydra.lisp.syntax.VariableDefinition")
+
 -- | DSL updater for the doc field of hydra.lisp.syntax.VariableDefinition
 variableDefinitionWithDoc :: Typed.TypedTerm Syntax.VariableDefinition -> Typed.TypedTerm (Maybe Syntax.Docstring) -> Typed.TypedTerm Syntax.VariableDefinition
 variableDefinitionWithDoc original newVal =
@@ -4450,6 +4708,10 @@
         Core.projectionFieldName = (Core.Name "name")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.VariableReference
+variableReferenceVariableReference :: Typed.TypedName Syntax.VariableReference
+variableReferenceVariableReference = Typed.TypedName (Core.Name "hydra.lisp.syntax.VariableReference")
+
 -- | DSL updater for the functionNamespace field of hydra.lisp.syntax.VariableReference
 variableReferenceWithFunctionNamespace :: Typed.TypedTerm Syntax.VariableReference -> Typed.TypedTerm Bool -> Typed.TypedTerm Syntax.VariableReference
 variableReferenceWithFunctionNamespace original newVal =
@@ -4503,6 +4765,10 @@
         Core.projectionFieldName = (Core.Name "elements")})),
       Core.applicationArgument = (Typed.unTypedTerm x)}))
 
+-- | DSL name token for hydra.lisp.syntax.VectorLiteral
+vectorLiteralVectorLiteral :: Typed.TypedName Syntax.VectorLiteral
+vectorLiteralVectorLiteral = Typed.TypedName (Core.Name "hydra.lisp.syntax.VectorLiteral")
+
 -- | DSL updater for the elements field of hydra.lisp.syntax.VectorLiteral
 vectorLiteralWithElements :: Typed.TypedTerm Syntax.VectorLiteral -> Typed.TypedTerm [Syntax.Expression] -> Typed.TypedTerm Syntax.VectorLiteral
 vectorLiteralWithElements original newVal =
@@ -4512,10 +4778,3 @@
         Core.Field {
           Core.fieldName = (Core.Name "elements"),
           Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
-
--- | DSL constructor for hydra.lisp.syntax.WildcardPattern
-wildcardPattern :: Typed.TypedTerm Syntax.WildcardPattern
-wildcardPattern =
-    Typed.TypedTerm (Core.TermRecord (Core.Record {
-      Core.recordTypeName = (Core.Name "hydra.lisp.syntax.WildcardPattern"),
-      Core.recordFields = []}))
diff --git a/src/main/haskell/Hydra/Lisp/Coder.hs b/src/main/haskell/Hydra/Lisp/Coder.hs
--- a/src/main/haskell/Hydra/Lisp/Coder.hs
+++ b/src/main/haskell/Hydra/Lisp/Coder.hs
@@ -57,24 +57,28 @@
 import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
 import qualified Data.Scientific as Sci
 
+-- | Dialect-aware name for "cadr" (second element of a list); Clojure uses "second", other dialects use "cadr"
 dialectCadr :: Syntax.Dialect -> String
 dialectCadr d =
     case d of
       Syntax.DialectClojure -> "second"
       _ -> "cadr"
 
+-- | Dialect-aware name for "car" (first element of a list); Clojure uses "first", other dialects use "car"
 dialectCar :: Syntax.Dialect -> String
 dialectCar d =
     case d of
       Syntax.DialectClojure -> "first"
       _ -> "car"
 
+-- | Dialect-aware constructor prefix for record types; Clojure uses "->", other dialects use "make-"
 dialectConstructorPrefix :: Syntax.Dialect -> String
 dialectConstructorPrefix d =
     case d of
       Syntax.DialectClojure -> "->"
       _ -> "make-"
 
+-- | Dialect-aware name for "equal?" (equality test): Clojure uses "=", Common Lisp/Emacs Lisp use "equal", Scheme uses "equal?"
 dialectEqual :: Syntax.Dialect -> String
 dialectEqual d =
     case d of
@@ -83,12 +87,14 @@
       Syntax.DialectEmacsLisp -> "equal"
       _ -> "equal?"
 
+-- | Whether a dialect provides a native letrec (mutually recursive let); Clojure has only sequential let
 dialectSupportsLetrec :: Syntax.Dialect -> Bool
 dialectSupportsLetrec d =
     case d of
       Syntax.DialectClojure -> False
       _ -> True
 
+-- | Encode a function application, detecting ifElse and other lazy primitives; transforms (((hydra.lib.logic.ifElse C) T) E) into native (if C T E)
 encodeApplication :: Syntax.Dialect -> t0 -> Graph.Graph -> Core.Term -> Core.Term -> Either t1 Syntax.Expression
 encodeApplication dialect cx g rawFun rawArg =
 
diff --git a/src/main/haskell/Hydra/Lisp/Serde.hs b/src/main/haskell/Hydra/Lisp/Serde.hs
--- a/src/main/haskell/Hydra/Lisp/Serde.hs
+++ b/src/main/haskell/Hydra/Lisp/Serde.hs
@@ -805,8 +805,13 @@
           exports = Syntax.programExports prog
           forms = Syntax.programForms prog
           formPart = Lists.map (topLevelFormWithCommentsToExpr d) forms
-          warning = [
-                Serialization.cst (Strings.cat2 "; " Constants.warningAutoGeneratedFile)]
+          warning =
+                  case d of
+                    Syntax.DialectEmacsLisp -> [
+                      Serialization.cst ";; -*- lexical-binding: t -*-",
+                      (Serialization.cst (Strings.cat2 "; " Constants.warningAutoGeneratedFile))]
+                    _ -> [
+                      Serialization.cst (Strings.cat2 "; " Constants.warningAutoGeneratedFile)]
           importNames = Lists.map (\idecl -> Syntax.unNamespaceName (Syntax.importDeclarationModule idecl)) imports
           exportSyms = Lists.concat (Lists.map (\edecl -> Lists.map symbolToExpr (Syntax.exportDeclarationSymbols edecl)) exports)
       in case d of
diff --git a/src/main/haskell/Hydra/Lisp/Syntax.hs b/src/main/haskell/Hydra/Lisp/Syntax.hs
--- a/src/main/haskell/Hydra/Lisp/Syntax.hs
+++ b/src/main/haskell/Hydra/Lisp/Syntax.hs
@@ -734,9 +734,7 @@
 _LiteralPattern_value = Core.Name "value"
 
 -- | A wildcard pattern that matches any value
-data WildcardPattern =
-  WildcardPattern {}
-  deriving (Eq, Ord, Read, Show)
+type WildcardPattern = ()
 
 _WildcardPattern = Core.Name "hydra.lisp.syntax.WildcardPattern"