diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,88 @@
 
 ---
 
+## [0.17.7] - 2026-09-14
+
+Correctness-hardening point release on the 0.17.x line, consolidating the 0.17.6 breaking batch. It
+closes a family of silent cross-host correctness bugs in the equality, ordering, integer-narrowing
+and string primitives, and adds the systematic test coverage that exposed them. No kernel-surface
+breaking changes.
+
+### Highlights
+
+- **Silent-wrong primitives corrected across hosts**
+  ([#745](https://github.com/CategoricalData/hydra/issues/745),
+  [#742](https://github.com/CategoricalData/hydra/issues/742)): new shared cross-host fixtures
+  uncovered ~a dozen primitives (`equal`/`compare` on collections, float equality, `bigintToIntN`
+  narrowing, `parseUint*` bounds, astral-plane string ops) that returned wrong results on one or more
+  non-Haskell hosts while appearing to pass. All are now correct and verified per-host against the
+  Haskell reference oracle.
+- **Systematic test-coverage hardening**
+  ([#749](https://github.com/CategoricalData/hydra/issues/749)): new kernel coverage for previously
+  untested primitive behavior (equality/ordering collection depth, `notEqual`, `functions.const`/`flip`),
+  which drove wiring those primitives into every host's default-implementation fallback.
+- **Scale-preserving decimals across every lossy-double host**
+  ([#727](https://github.com/CategoricalData/hydra/issues/727),
+  [#719](https://github.com/CategoricalData/hydra/issues/719)): `Literal.decimal` gains a real
+  scale-preserving representation (coefficient + scale) in the Scheme, Emacs Lisp, Common Lisp and
+  TypeScript runtimes and coders, and the generated `Literal.Decimal` `equals`/`compareTo` on Java,
+  Python and Scala stop ignoring scale. The `scaleDistinctTestNames` skip list — which had been
+  masking the gap on five hosts — is deleted, so decimal scale is now verified everywhere rather
+  than excused.
+
+### Bug fixes
+
+- **[#745](https://github.com/CategoricalData/hydra/issues/745)** silent-wrong equality/ordering,
+  `bigintToIntN` narrowing, `parseUint32/64` bounds, and astral-plane `charAt`/`splitOn`/`compare`
+  across the eight non-Haskell hosts.
+- **[#742](https://github.com/CategoricalData/hydra/issues/742)** structural `equal`/`compare` on
+  maps, sets and nested decimals no longer falls back to scale-blind or print-based comparison
+  (including a hand-inlined Scala primitive that shadowed the overlay fix).
+- **[#743](https://github.com/CategoricalData/hydra/issues/743)** kernel JSON decoder now rejects an
+  `Either` object carrying both `left` and `right` keys instead of silently resolving one arm.
+- **[#740](https://github.com/CategoricalData/hydra/issues/740)** the recursive parametric union decoder
+  now emits an explicit type application instead of an untyped lambda, so recursive parametric-union
+  types generate and compile on the Java host; also fixes `update-json-kernel` reconcile to build a
+  complete inference universe so drifted kernel modules re-infer.
+- **[#720](https://github.com/CategoricalData/hydra/issues/720)** Python's
+  `hydra.lib.equality`/`ordering` did not satisfy IEEE `totalOrder` for floats, mis-ordering `NaN`
+  and signed zero.
+- **[#722](https://github.com/CategoricalData/hydra/issues/722)** two `kernelDefaultCoreProfile`
+  correctness defects: rule ids that referred to rules no longer present, and a stubbed
+  `isValidName` that accepted every name.
+
+### Improvements
+
+- **[#749](https://github.com/CategoricalData/hydra/issues/749)** `notEqual`/`const`/`flip` wired
+  into each host's `#609` default-implementation fallback; orphaned Avro coder test suite recovered.
+- **[#730](https://github.com/CategoricalData/hydra/issues/730)** a shared `~/.stack` build slot
+  (`bin/with-stack-slot.sh`) replaces the pgrep slot mechanic, serializing concurrent GHC builds
+  across the fleet behind a real mutex. The wrapper is now portable to macOS: `flock(1)` is
+  util-linux and absent there, so it is emulated via Perl's `flock()` where missing, and the
+  GNU-only `date -Is`/`date -d` calls are replaced with portable equivalents. Its bypass path also
+  no longer re-execs forever. Without these, every entry point that routes through the slot —
+  `bin/sync.sh`, `bin/test.sh`, `bin/run-bootstrapping-demo.sh` and `bin/prepare-release.sh` —
+  failed immediately on macOS.
+- **[#600](https://github.com/CategoricalData/hydra/issues/600)** the five published TypeScript
+  packages are subpath-import-only (uniform export surface).
+- **[#716](https://github.com/CategoricalData/hydra/issues/716)** `hydra.paths` reshaped onto the
+  term-graph model (`TermGraph`/`TypeGraph`), aligning path steps with the term and type grammars
+  and adding the link view of a graph; `mapKey`/`mapValue` collapse into a single `mapEntry` step.
+- **[#701](https://github.com/CategoricalData/hydra/issues/701)** module cache freshness is now a
+  Merkle hash over each module's dependency closure, so a change deep in the closure correctly
+  invalidates dependents.
+- **[#559](https://github.com/CategoricalData/hydra/issues/559)** host-agnostic build: the
+  remaining hand-coded host build logic is promoted into `hydra.build.*`, with Java as the
+  definitive second host.
+- **[#721](https://github.com/CategoricalData/hydra/issues/721)** `checkNestedModuleNames` packaging
+  check enforces the module-namespace no-prefix rule.
+
+### Documentation
+
+- **[#508](https://github.com/CategoricalData/hydra/issues/508)** de-Claude-speak documentation pass:
+  style-guide section added, stale paths and dead links repaired, agent-operations wiki pages moved
+  into `claude/`, and a `getting-started.md` guardrail against re-adding a TypeScript root export.
+
 ## [0.17.6] - 2026-08-30
 
 Point release on the 0.17.x line, and the last backward-incompatible batch before the 1.0 surface
diff --git a/hydra-build.cabal b/hydra-build.cabal
--- a/hydra-build.cabal
+++ b/hydra-build.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           hydra-build
-version:        0.17.6
+version:        0.17.7
 synopsis:       Hydra's build system, promoted into Hydra
 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 build system, promoted into Hydra itself: the manifest-derived module-to-package router, kernel/host reconciliation utilities, and pure module-list helpers, expressed as Hydra modules and generated into every self-hosting dialect. It builds on hydra-kernel.
 category:       Data
@@ -64,6 +64,6 @@
   build-depends:
       base >=4.19.0 && <4.22
     , containers >=0.6.7 && <0.8
-    , hydra-kernel ==0.17.6
+    , hydra-kernel ==0.17.7
     , scientific >=0.3.7 && <0.4
   default-language: Haskell2010
diff --git a/src/main/haskell/Hydra/Build/Format.hs b/src/main/haskell/Hydra/Build/Format.hs
--- a/src/main/haskell/Hydra/Build/Format.hs
+++ b/src/main/haskell/Hydra/Build/Format.hs
@@ -203,6 +203,25 @@
 
 _LanguageName = Core.Name "hydra.build.format.LanguageName"
 
+-- | The build identity of a source/target language: how the build system treats it. See https://github.com/CategoricalData/hydra/issues/559
+data LanguageProfile =
+  LanguageProfile {
+    -- | The canonical language token, e.g. "haskell", "java", "clojure"
+    languageProfileName :: String,
+    -- | The distribution package the language's coder lives in (the four Lisp dialects share hydra-lisp)
+    languageProfileCoderPackage :: String,
+    -- | The build-treatment group the language belongs to, e.g. "jvm", "python", "lisp" (an open string: adding a host must not edit a type)
+    languageProfileFamily :: String}
+  deriving (Eq, Ord, Read, Show)
+
+_LanguageProfile = Core.Name "hydra.build.format.LanguageProfile"
+
+_LanguageProfile_name = Core.Name "name"
+
+_LanguageProfile_coderPackage = Core.Name "coderPackage"
+
+_LanguageProfile_family = Core.Name "family"
+
 -- | Validation rules applying to a module as a whole. Absent fields mean the corresponding check is not configured.
 data ModuleValidationProfile =
   ModuleValidationProfile {
diff --git a/src/main/haskell/Hydra/Build/Registry.hs b/src/main/haskell/Hydra/Build/Registry.hs
--- a/src/main/haskell/Hydra/Build/Registry.hs
+++ b/src/main/haskell/Hydra/Build/Registry.hs
@@ -1,10 +1,11 @@
 -- Note: this is an automatically generated file. Do not edit.
 
--- | The translingual language registry: per-language build identity (name, coder package, family) as data, so the build drivers read language properties instead of hardcoding name literals. See https://github.com/CategoricalData/hydra/issues/416
+-- | The translingual language registry: per-language build identity (name, coder package, family) as LanguageProfile records, so the build drivers read language properties instead of hardcoding name literals. See https://github.com/CategoricalData/hydra/issues/416 and https://github.com/CategoricalData/hydra/issues/559
 
 module Hydra.Build.Registry where
 
 import qualified Hydra.Ast as Ast
+import qualified Hydra.Build.Format as Format
 import qualified Hydra.Coders as Coders
 import qualified Hydra.Core as Core
 import qualified Hydra.Docs as Docs
@@ -20,7 +21,6 @@
 import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality
 import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists
 import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals
-import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs
 import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings
 import qualified Hydra.Packaging as Packaging
 import qualified Hydra.Parsing as Parsing
@@ -45,7 +45,7 @@
 
 -- | Every language name in the registry (the former ALL_LANGS constant)
 allLanguageNames :: [String]
-allLanguageNames = Lists.map (\p -> Pairs.first p) languageProfiles
+allLanguageNames = Lists.map (\p -> Format.languageProfileName p) languageProfiles
 
 -- | Default bench scope (sync-bench.sh DEFAULT_HOSTS; the haskell/java/python triad)
 benchDefaultNames :: [String]
@@ -70,12 +70,12 @@
 -- | The distribution package for a language's coder (data-driven; hydra-<name> fallback)
 coderPackageFor :: String -> String
 coderPackageFor name =
-    Optionals.match (Lists.head (Lists.filter (\p -> Equality.equal (Pairs.first p) name) languageProfiles)) (Strings.concat2 "hydra-" name) (\p -> Pairs.first (Pairs.second p))
+    Optionals.match (Lists.head (Lists.filter (\p -> Equality.equal (Format.languageProfileName p) name) languageProfiles)) (Strings.concat2 "hydra-" name) (\p -> Format.languageProfileCoderPackage p)
 
 -- | The build family of a language (jvm/python/lisp/haskell/typescript/go; empty for unknown)
 familyFor :: String -> String
 familyFor name =
-    Optionals.match (Lists.head (Lists.filter (\p -> Equality.equal (Pairs.first p) name) languageProfiles)) "" (\p -> Pairs.second (Pairs.second p))
+    Optionals.match (Lists.head (Lists.filter (\p -> Equality.equal (Format.languageProfileName p) name) languageProfiles)) "" (\p -> Format.languageProfileFamily p)
 
 -- | Hosts with an inference benchmark (run-inference-bench.sh ALL_HOSTS; includes python-pypy pseudo-host)
 inferenceBenchHostNames :: [String]
@@ -92,20 +92,50 @@
 isLispDialect :: String -> Bool
 isLispDialect name = Equality.equal (familyFor name) "lisp"
 
--- | Per-language build identity as (name, coderPackage, family) triples, in native ALL_LANGS order: the single source of language names
-languageProfiles :: [(String, (String, String))]
+-- | Per-language build identity as LanguageProfile records, in native ALL_LANGS order: the single source of language names
+languageProfiles :: [Format.LanguageProfile]
 languageProfiles =
     [
-      ("haskell", ("hydra-haskell", "haskell")),
-      ("java", ("hydra-java", "jvm")),
-      ("python", ("hydra-python", "python")),
-      ("scala", ("hydra-scala", "jvm")),
-      ("go", ("hydra-go", "go")),
-      ("typescript", ("hydra-typescript", "typescript")),
-      ("clojure", ("hydra-lisp", "lisp")),
-      ("scheme", ("hydra-lisp", "lisp")),
-      ("common-lisp", ("hydra-lisp", "lisp")),
-      ("emacs-lisp", ("hydra-lisp", "lisp"))]
+      Format.LanguageProfile {
+        Format.languageProfileName = "haskell",
+        Format.languageProfileCoderPackage = "hydra-haskell",
+        Format.languageProfileFamily = "haskell"},
+      Format.LanguageProfile {
+        Format.languageProfileName = "java",
+        Format.languageProfileCoderPackage = "hydra-java",
+        Format.languageProfileFamily = "jvm"},
+      Format.LanguageProfile {
+        Format.languageProfileName = "python",
+        Format.languageProfileCoderPackage = "hydra-python",
+        Format.languageProfileFamily = "python"},
+      Format.LanguageProfile {
+        Format.languageProfileName = "scala",
+        Format.languageProfileCoderPackage = "hydra-scala",
+        Format.languageProfileFamily = "jvm"},
+      Format.LanguageProfile {
+        Format.languageProfileName = "go",
+        Format.languageProfileCoderPackage = "hydra-go",
+        Format.languageProfileFamily = "go"},
+      Format.LanguageProfile {
+        Format.languageProfileName = "typescript",
+        Format.languageProfileCoderPackage = "hydra-typescript",
+        Format.languageProfileFamily = "typescript"},
+      Format.LanguageProfile {
+        Format.languageProfileName = "clojure",
+        Format.languageProfileCoderPackage = "hydra-lisp",
+        Format.languageProfileFamily = "lisp"},
+      Format.LanguageProfile {
+        Format.languageProfileName = "scheme",
+        Format.languageProfileCoderPackage = "hydra-lisp",
+        Format.languageProfileFamily = "lisp"},
+      Format.LanguageProfile {
+        Format.languageProfileName = "common-lisp",
+        Format.languageProfileCoderPackage = "hydra-lisp",
+        Format.languageProfileFamily = "lisp"},
+      Format.LanguageProfile {
+        Format.languageProfileName = "emacs-lisp",
+        Format.languageProfileCoderPackage = "hydra-lisp",
+        Format.languageProfileFamily = "lisp"}]
 
 -- | The Lisp-dialect names in native 'lisp'-alias order (clojure, common-lisp, emacs-lisp, scheme)
 lispDialectNames :: [String]
diff --git a/src/main/haskell/Hydra/Decode/Build/Format.hs b/src/main/haskell/Hydra/Decode/Build/Format.hs
--- a/src/main/haskell/Hydra/Decode/Build/Format.hs
+++ b/src/main/haskell/Hydra/Decode/Build/Format.hs
@@ -197,6 +197,30 @@
         _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx raw2)) (Core.wrappedTermBody v0))
       _ -> Left (Errors.DecodingError "expected wrapped type")) (ExtractCore.stripWithDecodingError cx raw)
 
+-- | Decoder for hydra.build.format.LanguageProfile
+languageProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.LanguageProfile
+languageProfile cx raw =
+    Eithers.either (\err -> Left err) (\stripped -> case stripped of
+      Core.TermRecord v0 ->
+        let fieldMap = ExtractCore.toFieldMap v0
+        in (Eithers.bind (ExtractCore.requireField "name" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of
+          Core.TermLiteral v1 -> case v1 of
+            Core.LiteralString v2 -> Right v2
+            _ -> Left (Errors.DecodingError "expected string literal")
+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_name -> Eithers.bind (ExtractCore.requireField "coderPackage" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of
+          Core.TermLiteral v1 -> case v1 of
+            Core.LiteralString v2 -> Right v2
+            _ -> Left (Errors.DecodingError "expected string literal")
+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_coderPackage -> Eithers.bind (ExtractCore.requireField "family" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of
+          Core.TermLiteral v1 -> case v1 of
+            Core.LiteralString v2 -> Right v2
+            _ -> Left (Errors.DecodingError "expected string literal")
+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_family -> Right (Format.LanguageProfile {
+          Format.languageProfileName = field_name,
+          Format.languageProfileCoderPackage = field_coderPackage,
+          Format.languageProfileFamily = field_family})))))
+      _ -> Left (Errors.DecodingError "expected a record of type hydra.build.format.LanguageProfile")) (ExtractCore.stripWithDecodingError cx raw)
+
 -- | Decoder for hydra.build.format.ModuleValidationProfile
 moduleValidationProfile :: Graph.Graph -> Core.Term -> Either Errors.DecodingError Format.ModuleValidationProfile
 moduleValidationProfile cx raw =
diff --git a/src/main/haskell/Hydra/Dsl/Build/Format.hs b/src/main/haskell/Hydra/Dsl/Build/Format.hs
--- a/src/main/haskell/Hydra/Dsl/Build/Format.hs
+++ b/src/main/haskell/Hydra/Dsl/Build/Format.hs
@@ -1204,6 +1204,125 @@
 languageNameLanguageName :: Typed.TypedName Format.LanguageName
 languageNameLanguageName = Typed.TypedName (Core.Name "hydra.build.format.LanguageName")
 
+-- | DSL constructor for hydra.build.format.LanguageProfile
+languageProfile :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile
+languageProfile name coderPackage family =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm name)},
+        Core.Field {
+          Core.fieldName = (Core.Name "coderPackage"),
+          Core.fieldTerm = (Typed.unTypedTerm coderPackage)},
+        Core.Field {
+          Core.fieldName = (Core.Name "family"),
+          Core.fieldTerm = (Typed.unTypedTerm family)}]}))
+
+-- | DSL accessor for the coderPackage field of hydra.build.format.LanguageProfile
+languageProfileCoderPackage :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String
+languageProfileCoderPackage x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+        Core.projectionFieldName = (Core.Name "coderPackage")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL accessor for the family field of hydra.build.format.LanguageProfile
+languageProfileFamily :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String
+languageProfileFamily x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+        Core.projectionFieldName = (Core.Name "family")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL name token for hydra.build.format.LanguageProfile
+languageProfileLanguageProfile :: Typed.TypedName Format.LanguageProfile
+languageProfileLanguageProfile = Typed.TypedName (Core.Name "hydra.build.format.LanguageProfile")
+
+-- | DSL accessor for the name field of hydra.build.format.LanguageProfile
+languageProfileName :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String
+languageProfileName x =
+    Typed.TypedTerm (Core.TermApplication (Core.Application {
+      Core.applicationFunction = (Core.TermProject (Core.Projection {
+        Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+        Core.projectionFieldName = (Core.Name "name")})),
+      Core.applicationArgument = (Typed.unTypedTerm x)}))
+
+-- | DSL updater for the coderPackage field of hydra.build.format.LanguageProfile
+languageProfileWithCoderPackage :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile
+languageProfileWithCoderPackage original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "coderPackage"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "family"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+              Core.projectionFieldName = (Core.Name "family")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
+-- | DSL updater for the family field of hydra.build.format.LanguageProfile
+languageProfileWithFamily :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile
+languageProfileWithFamily original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+              Core.projectionFieldName = (Core.Name "name")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "coderPackage"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+              Core.projectionFieldName = (Core.Name "coderPackage")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "family"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)}]}))
+
+-- | DSL updater for the name field of hydra.build.format.LanguageProfile
+languageProfileWithName :: Typed.TypedTerm Format.LanguageProfile -> Typed.TypedTerm String -> Typed.TypedTerm Format.LanguageProfile
+languageProfileWithName original newVal =
+    Typed.TypedTerm (Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = (Typed.unTypedTerm newVal)},
+        Core.Field {
+          Core.fieldName = (Core.Name "coderPackage"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+              Core.projectionFieldName = (Core.Name "coderPackage")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))},
+        Core.Field {
+          Core.fieldName = (Core.Name "family"),
+          Core.fieldTerm = (Core.TermApplication (Core.Application {
+            Core.applicationFunction = (Core.TermProject (Core.Projection {
+              Core.projectionTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+              Core.projectionFieldName = (Core.Name "family")})),
+            Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))
+
 -- | DSL constructor for hydra.build.format.ModuleValidationProfile
 moduleValidationProfile :: Typed.TypedTerm (Maybe Format.DefinitionValidationProfile) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm (Maybe Format.Severity) -> Typed.TypedTerm Format.ModuleValidationProfile
 moduleValidationProfile definitions nameConvention conflictingVariantName =
diff --git a/src/main/haskell/Hydra/Encode/Build/Format.hs b/src/main/haskell/Hydra/Encode/Build/Format.hs
--- a/src/main/haskell/Hydra/Encode/Build/Format.hs
+++ b/src/main/haskell/Hydra/Encode/Build/Format.hs
@@ -189,6 +189,22 @@
       Core.wrappedTermTypeName = (Core.Name "hydra.build.format.LanguageName"),
       Core.wrappedTermBody = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.unLanguageName x))})
 
+-- | Encoder for hydra.build.format.LanguageProfile
+languageProfile :: Format.LanguageProfile -> Core.Term
+languageProfile x =
+    Core.TermRecord (Core.Record {
+      Core.recordTypeName = (Core.Name "hydra.build.format.LanguageProfile"),
+      Core.recordFields = [
+        Core.Field {
+          Core.fieldName = (Core.Name "name"),
+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.languageProfileName x))},
+        Core.Field {
+          Core.fieldName = (Core.Name "coderPackage"),
+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.languageProfileCoderPackage x))},
+        Core.Field {
+          Core.fieldName = (Core.Name "family"),
+          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Format.languageProfileFamily x))}]})
+
 -- | Encoder for hydra.build.format.ModuleValidationProfile
 moduleValidationProfile :: Format.ModuleValidationProfile -> Core.Term
 moduleValidationProfile x =