diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,144 @@
 
 ---
 
+## [0.18.1] - 2026-11-20
+
+Textual-sources release: the whole `hydra-kernel` is now authored as textual `.hydra` files, including the
+primitive library `hydra.core.lib.*`, and the textual syntax gains the sugar, parsers, and tooling needed to carry it.
+Also lands translingual tail-call optimization for the Scala and TypeScript coders, named provisions and
+primitive parameter names, the property-graph encoding of term graphs, and a large body of host-specific bootstrap
+and CI fixes.
+
+### Breaking changes
+
+- **Type renames** ([#837](https://github.com/CategoricalData/hydra/issues/837)): four types whose variant names clashed with other kernel types are renamed.
+  Any code, JSON, or `.hydra` text that names them must be updated.
+  - `hydra.core.regex.QuantifierRange` is now `hydra.core.regex.Range`.
+  - `hydra.ext.azure.dtld.SchemaPrimitive` is now `PrimitiveSchema`, and `SchemaComplex` is now `ComplexSchema`.
+  - `hydra.rust.syntax.TypePath` is now `PathType`.
+- **New primitive signature syntax in `.hydra`** ([#837](https://github.com/CategoricalData/hydra/issues/837)): a `primitive` definition names its parameters,
+  `primitive ifElse ∀x.(p: boolean, t: lazy x, f: lazy x) : x`, instead of the old arrow chain
+  (`primitive ifElse : ∀t. boolean → lazy t → lazy t → t`).
+  Parameter and result descriptions move into `@param` and `@return` doc lines.
+  The arrow-chain form is for `term` signatures only.
+- **Raw `case` keyword is now `cases`** ([#810](https://github.com/CategoricalData/hydra/issues/810)): the textual-syntax case statement keyword matches `Term.cases`.
+- **`hydra.core.json.bootstrap` is now `hydra.core.bootstrap`** ([#791](https://github.com/CategoricalData/hydra/issues/791)).
+- **`and` and `or` are lazy in their second operand** ([#802](https://github.com/CategoricalData/hydra/issues/802)): both are marked lazy, mirroring `ifElse`, and the
+  Java and Python hosts add thunk-accepting overloads.
+
+### Highlights
+
+- **The whole kernel is `.hydra`-sourced** ([#837](https://github.com/CategoricalData/hydra/issues/837), [#711](https://github.com/CategoricalData/hydra/issues/711), [#710](https://github.com/CategoricalData/hydra/issues/710), [#497](https://github.com/CategoricalData/hydra/issues/497)):
+  every `hydra-kernel` module, including all `hydra.core.lib.*` primitive modules and the test modules, is sourced from
+  `packages/hydra-kernel/src/main/hydra/**/*.hydra`; Phase 1 reads that text instead of the Haskell DSL.
+  The Haskell DSL modules remain as a twin that must stay byte-identical (the dual-edit rule).
+  `bin/verify-hydra-sources.sh` is the identity guard (it is not run by CI),
+  and `heads/haskell/bin/print-hydra-sources.sh` regenerates the text from the DSL.
+  A package may textually source only modules it owns.
+- **Named primitive parameters** ([#837](https://github.com/CategoricalData/hydra/issues/837)): all 292 primitives print with named parameters and `@param`/`@return`
+  descriptions, carried through the kernel metadata.
+- **`parseModules`** ([#842](https://github.com/CategoricalData/hydra/issues/842)): `hydra.core.parse.packaging.parseModules` reads `.hydra` text into modules and is the
+  supported entry point for downstream code generation from textual sources
+  (see `docs/recipes/downstream-codegen.md`).
+- **Kernel JSON on the classpath** ([#786](https://github.com/CategoricalData/hydra/issues/786)): the published `hydra-kernel` jar bundles the kernel's JSON modules, so
+  Java downstream projects no longer need a source checkout to load the kernel.
+- **Tail-call optimization on more hosts** ([#709](https://github.com/CategoricalData/hydra/issues/709)): shared `TcoLoopPlan`/`TcoStep` kernel types and a
+  `lowerSelfTailRecursion` pass, consumed by the new Scala (`@tailrec`) and TypeScript lowerings.
+- **Named provisions** ([#725](https://github.com/CategoricalData/hydra/issues/725)): primitives and tests carry named requirements and recommendations,
+  spec prose is ported into module and primitive metadata, and the generated spec pages render comments and lifecycle.
+- **Term graphs as property graphs** ([#738](https://github.com/CategoricalData/hydra/issues/738)): `hydra.pg.subtermGraph` encodes a term graph as a property graph,
+  with specification pages (`docs/specification/pg/subterm-graph.md`).
+
+### New features
+
+- **Textual syntax sugar** ([#809](https://github.com/CategoricalData/hydra/issues/809), [#811](https://github.com/CategoricalData/hydra/issues/811)): nominal construction and elimination sugar
+  (`record`/`inject`/`wrap {...}`, `project`/`unwrap [...]`), applied `case` sugar, and monadic `do` blocks
+  (`do either`, `do list`, `do optional`, `do effect`).
+- **Source spans** ([#815](https://github.com/CategoricalData/hydra/issues/815)): the parsers track source offsets and record term spans through the new
+  `hydra.core.positions` module; spans are round-trip-exempt surface trivia.
+- **Parsers and printers** ([#710](https://github.com/CategoricalData/hydra/issues/710), [#497](https://github.com/CategoricalData/hydra/issues/497)): `hydra.core.parse.core` (term, type, and type scheme parser),
+  parse/print for packaging, doc-comment parsing into `EntityMetadata`, and `line:col` parse errors.
+  A signature-level `lazy` keyword round-trips `Parameter.isLazy` ([#800](https://github.com/CategoricalData/hydra/issues/800)),
+  and raw `cases(...)` accepts the `_` default field ([#822](https://github.com/CategoricalData/hydra/issues/822)).
+- **JSON** ([#776](https://github.com/CategoricalData/hydra/issues/776), [#777](https://github.com/CategoricalData/hydra/issues/777)): `JsonWriterOptions` and `printJsonWith` for configurable JSON layout,
+  and `\uXXXX` escapes with surrogate pairs in the JSON parser.
+- **Error printers** ([#778](https://github.com/CategoricalData/hydra/issues/778)): real printers for inference and extraction errors replace placeholder constants.
+- **Spec generator** ([#723](https://github.com/CategoricalData/hydra/issues/723)): the `hydra.RegenerateSpec` driver and `bin/regenerate-spec.sh` now exist,
+  and the module-reference pages under `docs/specification/` are generated by them.
+  The module reference is still partial (only the primitives and four kernel type modules are covered).
+  Primitive pages show named signatures (`isAlpha(char: int32) → boolean`) with Parameters and Returns entries,
+  type pages list fields and variants, and headings use local names so in-page links work.
+- **Build system in Hydra** ([#788](https://github.com/CategoricalData/hydra/issues/788)): the lib-pass partition (`isLibModule`, `partitionLibModules`) moves into the
+  translingual `hydra.build.modules`, consumed by the Java, Scala, and Haskell drivers.
+- **Bootstrap matrix** ([#769](https://github.com/CategoricalData/hydra/issues/769)): `docs/bootstrap-matrix.md` persists the N×N cross-host generation matrix.
+- **Build slot tooling** ([#730](https://github.com/CategoricalData/hydra/issues/730), [#814](https://github.com/CategoricalData/hydra/issues/814)): `with-stack-slot.sh` gains a second lane, priorities, pinning, and a memory guard,
+  and scripts that run bare `stack` re-exec under it.
+- **CI** ([#821](https://github.com/CategoricalData/hydra/issues/821), [#700](https://github.com/CategoricalData/hydra/issues/700)): an inference-cost guard (time and peak memory) and a dedicated haskell-tests job.
+
+### Bug fixes
+
+- [#799](https://github.com/CategoricalData/hydra/issues/799): shadow-renaming of variables was decoupled across three layers (`unshadowVariables`,
+  `analyzeFunctionTermWithGather`, the Java coder's `dedupBindings`).
+- [#803](https://github.com/CategoricalData/hydra/issues/803), [#804](https://github.com/CategoricalData/hydra/issues/804), [#805](https://github.com/CategoricalData/hydra/issues/805): printed import aliases and bare names now round-trip.
+- [#798](https://github.com/CategoricalData/hydra/issues/798): a `Term.variable` encodes and decodes as `{"@var": "name"}` at any JSON position.
+- [#817](https://github.com/CategoricalData/hydra/issues/817): `printFloat32`/`printFloat64` for subnormals in the Common Lisp, Emacs Lisp, and Clojure hosts.
+- [#779](https://github.com/CategoricalData/hydra/issues/779): the Python coder no longer breaks on nested module names.
+- [#752](https://github.com/CategoricalData/hydra/issues/752): `PropertyType.required` was hardcoded to true.
+- [#751](https://github.com/CategoricalData/hydra/issues/751), [#832](https://github.com/CategoricalData/hydra/issues/832), [#838](https://github.com/CategoricalData/hydra/issues/838): the SHACL serializer emits blank nodes for anonymous shape references, RDF lists for
+  `sh:in`/`sh:and`/`sh:or`/`sh:xone`, definition references under `sh:node`/`sh:not`/`sh:and`/`sh:or`/`sh:xone`,
+  and qualified value shapes with their counts.
+- [#754](https://github.com/CategoricalData/hydra/issues/754): IRI strings are escaped in the rdf4j serializer.
+- [#748](https://github.com/CategoricalData/hydra/issues/748), [#781](https://github.com/CategoricalData/hydra/issues/781): `inferInGraphContext` routes through the discharge-and-finalize tail, and
+  `inferModules` seeds its graph from both universe and target modules.
+- [#764](https://github.com/CategoricalData/hydra/issues/764): `refreshModule` fails loudly on dropped bindings; binding dedup and primitive shadowing are fixed.
+- [#649](https://github.com/CategoricalData/hydra/issues/649): the Python coder merges a type and a term that share a module path.
+- [#780](https://github.com/CategoricalData/hydra/issues/780): generated Javadoc escapes backslashes and `*/`.
+- [#782](https://github.com/CategoricalData/hydra/issues/782): simple Unicode case mapping on the Common Lisp and Emacs Lisp hosts.
+- [#775](https://github.com/CategoricalData/hydra/issues/775): `mapSet` is unregistered on hosts that never implemented it.
+- [#289](https://github.com/CategoricalData/hydra/issues/289), [#762](https://github.com/CategoricalData/hydra/issues/762), [#801](https://github.com/CategoricalData/hydra/issues/801): stale post-rename paths in the Go overlay imports, the TypeScript bootstrap driver,
+  and the Common Lisp and Emacs Lisp test loaders.
+- [#741](https://github.com/CategoricalData/hydra/issues/741), [#747](https://github.com/CategoricalData/hydra/issues/747), [#757](https://github.com/CategoricalData/hydra/issues/757), [#771](https://github.com/CategoricalData/hydra/issues/771), [#787](https://github.com/CategoricalData/hydra/issues/787), [#823](https://github.com/CategoricalData/hydra/issues/823), [#831](https://github.com/CategoricalData/hydra/issues/831): sync and cold-seed fixes
+  (target assembly order, `hostOverrides` immunity, overlay hashing in the freshness gate, downstream assembly after
+  overlay re-apply, the generator stamp's coder-copy component).
+- [#736](https://github.com/CategoricalData/hydra/issues/736): CI pins JDK 11 for the Haskell job after `ubuntu-latest` moved to JDK 25.
+- [#755](https://github.com/CategoricalData/hydra/issues/755): effects fixes (Type.effect encoder arms, Python `map_list`, Emacs Lisp loading).
+- [#812](https://github.com/CategoricalData/hydra/issues/812): the Clojure/Scheme `testEnv` redirect applies to generated test trees only.
+- [#768](https://github.com/CategoricalData/hydra/issues/768): the cold-seed driver step fails fast when its local fallback cannot succeed.
+- [#825](https://github.com/CategoricalData/hydra/issues/825): `dist/haskell/hydra-kernel` is reseeded when stale relative to `dist/json`.
+- [#839](https://github.com/CategoricalData/hydra/issues/839): the assemble freshness gate refreshes a stale input digest after a rebase instead of failing, and never rewrites a current one.
+- [#826](https://github.com/CategoricalData/hydra/issues/826): Lisp coders reference nullary effect primitives by call.
+- [#827](https://github.com/CategoricalData/hydra/issues/827): overlay variant-order tables are checked against `model.json`.
+- [#772](https://github.com/CategoricalData/hydra/issues/772), [#756](https://github.com/CategoricalData/hydra/issues/756): several silent failures in the sync scripts and vitest/Scala drivers now fail loudly.
+
+### Improvements
+
+- Python DSL phantom types are threaded through combinator signatures ([#731](https://github.com/CategoricalData/hydra/issues/731), [#732](https://github.com/CategoricalData/hydra/issues/732), [#818](https://github.com/CategoricalData/hydra/issues/818)).
+- Hackage and PyPI batch publish sets are derived from the package registry ([#573](https://github.com/CategoricalData/hydra/issues/573), [#577](https://github.com/CategoricalData/hydra/issues/577)).
+- Pre-existing namespace leftovers from the 0.18.0 rename are cleaned up in Lisp, Scala, TypeScript, and Java bootstrap
+  drivers ([#767](https://github.com/CategoricalData/hydra/issues/767), [#729](https://github.com/CategoricalData/hydra/issues/729)).
+- `/bootstrap`, `/sync-default`, `/test`, and the pre-push gate default to Java and Python, with Haskell opt-in
+  ([#773](https://github.com/CategoricalData/hydra/issues/773)); the bootstrap demo holds the build slot only for its own `stack` calls ([#797](https://github.com/CategoricalData/hydra/issues/797)).
+- `bin/sync.sh` prints per-phase timing ([#824](https://github.com/CategoricalData/hydra/issues/824)), and the CI Haskell job is split to stay within the runner time limit.
+- `with-stack-slot.sh` fails fast on low disk before a build ([#789](https://github.com/CategoricalData/hydra/issues/789)).
+- `bin/verify-hydra-sources.sh --dsl` runs the dual-edit guard in reverse, regenerating from the Haskell DSL twins and
+  comparing with the committed JSON ([#837](https://github.com/CategoricalData/hydra/issues/837)).
+- `docs/hydra-lexicon.txt` prints primitives with named parameters, matching the generated spec pages
+  ([#723](https://github.com/CategoricalData/hydra/issues/723)).
+
+### Documentation
+
+- `docs/specification/syntax.md` gains the module-level grammar, doc comments, import aliasing, file layout,
+  `@param`/`@return`, and the named-parameter primitive signature.
+- The kernel README, `docs/implementation.md`, `docs/build-system.md`, and the test and primitive recipes describe the
+  `.hydra` sources and the dual-edit rule.
+- The hand-written primitive spec pages use the `hydra.core.lib.*` namespace.
+- Recipes and READMEs document the decoder/encoder fixpoint guard ([#760](https://github.com/CategoricalData/hydra/issues/760)), keeping derived modules out of
+  re-inference ([#758](https://github.com/CategoricalData/hydra/issues/758)), the hydra-ext coder testing pattern ([#699](https://github.com/CategoricalData/hydra/issues/699)), scripts with no automated caller
+  ([#714](https://github.com/CategoricalData/hydra/issues/714)), overlay-versus-prune ordering ([#645](https://github.com/CategoricalData/hydra/issues/645)), the Phase 1 memory envelope ([#592](https://github.com/CategoricalData/hydra/issues/592)),
+  and the Rust coder's home in `hydra-rust` ([#382](https://github.com/CategoricalData/hydra/issues/382)).
+
+---
+
 ## [0.18.0] - 2026-09-29
 
 Module-naming systematization release: every kernel and package module moves onto a uniform
@@ -48,9 +186,11 @@
   JSON-Schema/Avro/GraphQL/GraphSON/Protobuf coders (extended integer widths, map-key handling), the
   kernel's encode/decode generators (reversed type-parameter order on 2+-param polymorphic types), and
   the Python coder (silently dropping a module's types when types and terms share a file path).
-- **Self-hosted specification docs** ([#723](https://github.com/CategoricalData/hydra/issues/723)):
-  the module-reference pages under `docs/specification/` are now generated directly from the kernel
-  (`bin/regenerate-spec.sh`) via a new metadata-only doc coder, rather than hand-maintained.
+- **Specification-docs generator, kernel side** ([#723](https://github.com/CategoricalData/hydra/issues/723)):
+  a new metadata-only doc coder (`generateModuleDoc`) and `hydra.markdown` model, the translingual core
+  for generating the module-reference pages under `docs/specification/`. *Erratum:* the Java driver that
+  `bin/regenerate-spec.sh` invokes (`hydra.RegenerateSpec`) did not ship in 0.18.0, so the pages are still
+  hand-maintained; the driver is pending under #723.
 
 ### New features
 
@@ -58,7 +198,7 @@
   suite covering the minimal-core grammar (literals, classes, quantifiers, alternation, anchors,
   grouping) across all 9 hosts.
 - **[#723](https://github.com/CategoricalData/hydra/issues/723)** `hydra.markdown` type module and
-  `generateModuleDoc`, the metadata-only doc coder backing the self-generated spec pages.
+  `generateModuleDoc`, the metadata-only doc coder intended to back self-generated spec pages.
 - **[#382](https://github.com/CategoricalData/hydra/issues/382)** the Rust coder is split out of
   `hydra-ext` into its own first-class `hydra-rust` package.
 
diff --git a/hydra-typescript.cabal b/hydra-typescript.cabal
--- a/hydra-typescript.cabal
+++ b/hydra-typescript.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           hydra-typescript
-version:        0.18.0
+version:        0.18.1
 synopsis:       Hydra's TypeScript coder: emit TypeScript 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". TypeScript support for Hydra
 category:       Data
@@ -41,6 +41,6 @@
   build-depends:
       base >=4.19.0 && <4.22
     , containers >=0.6.7 && <0.8
-    , hydra-kernel ==0.18.0
+    , hydra-kernel ==0.18.1
     , scientific >=0.3.7 && <0.4
   default-language: Haskell2010
diff --git a/src/main/haskell/Hydra/Typescript/Coder.hs b/src/main/haskell/Hydra/Typescript/Coder.hs
--- a/src/main/haskell/Hydra/Typescript/Coder.hs
+++ b/src/main/haskell/Hydra/Typescript/Coder.hs
@@ -132,18 +132,6 @@
           sign = Logic.ifElse isNeg "-" ""
       in (Logic.ifElse (Ordering.lt rawScale 0) ((sign, (Strings.concat2 rawDigits (Strings.fromList (Lists.replicate (Math.negate rawScale) 48)))), 0) ((sign, rawDigits), rawScale))
 
--- | Find the free variables of a term that are referenced eagerly, i.e. outside of any nested lambda body; used to break false dependency cycles caused by DSL-level thunks such as hydra.core.parsers.lazy
-eagerFreeVariablesInTerm :: Model.Term -> S.Set Model.Name
-eagerFreeVariablesInTerm term =
-
-      let dfltVars =
-              \_ -> Lists.foldl (\s -> \t -> Sets.union s (eagerFreeVariablesInTerm t)) Sets.empty (Rewriting.subterms term)
-      in case term of
-        Model.TermLambda _ -> Sets.empty
-        Model.TermLet v0 -> Sets.difference (dfltVars ()) (Sets.fromList (Lists.map (\b -> Model.bindingName b) (Model.letBindings v0)))
-        Model.TermVariable v0 -> Sets.singleton v0
-        _ -> dfltVars ()
-
 -- | Encode a let-binding as a TS statement inside an enclosing function body, hoisting lambda-valued bindings as nested function declarations
 encodeBindingAsStatement :: Typing.InferenceContext -> Graph.Graph -> Packaging.ModuleName -> Model.Binding -> Syntax.Statement
 encodeBindingAsStatement cx g currentNs b =
@@ -155,7 +143,7 @@
       in case dterm of
         Model.TermLambda _ ->
           let innerFunDecl =
-                  functionDeclarationFromTerm cx g currentNs lname bterm (Optionals.bind (Model.bindingTypeScheme b) (\ts -> Just (Model.typeSchemeBody ts)))
+                  functionDeclarationFromTerm cx g currentNs bname lname bterm (Optionals.bind (Model.bindingTypeScheme b) (\ts -> Just (Model.typeSchemeBody ts)))
           in (Syntax.StatementFunctionDeclaration innerFunDecl)
         _ ->
           let expr = encodeTerm cx g currentNs bterm
@@ -261,6 +249,82 @@
         Model.TypeVariable _ -> tsTypedIdent nstr Syntax.TypeExpressionAny
         _ -> tsTypedIdent nstr (encodeTypeOrAny cx g currentNs dom)
 
+-- | Lower a TcoStep into TS statements: continue -> assignments + continue, return -> return, cases -> switch, let_ -> const bindings then recurse
+encodeTcoStep :: Typing.InferenceContext -> Graph.Graph -> Packaging.ModuleName -> [String] -> Coders.TcoStep -> [Syntax.Statement]
+encodeTcoStep cx g currentNs loopVars step =
+    case step of
+      Coders.TcoStepContinue v0 ->
+        let newExprs = Lists.map (\a -> encodeTerm cx g currentNs a) v0
+            tmpNames = Lists.map (\lv -> Strings.concat2 "_tco_tmp_" lv) loopVars
+            tmpDecls =
+                    Lists.map (\pair ->
+                      let tmpName = Pairs.first pair
+                          expr = Pairs.second pair
+                      in (tsConstDeclStatement tmpName expr)) (Lists.zip tmpNames newExprs)
+            assignStmts =
+                    Lists.map (\pair ->
+                      let loopVar = Pairs.first pair
+                          tmpName = Pairs.second pair
+                      in (Syntax.StatementExpression (Syntax.ExpressionAssignment (Syntax.AssignmentExpression {
+                        Syntax.assignmentExpressionOperator = Syntax.AssignmentOperatorAssign,
+                        Syntax.assignmentExpressionLeft = (Syntax.PatternIdentifier (tsIdent loopVar)),
+                        Syntax.assignmentExpressionRight = (tsExprIdent tmpName)})))) (Lists.zip loopVars tmpNames)
+        in (Lists.concat2 tmpDecls (Lists.concat2 assignStmts [
+          Syntax.StatementContinue (Optionals.map (\label -> Syntax.Identifier label) Nothing)]))
+      Coders.TcoStepReturn v0 -> [
+        Syntax.StatementReturn (Just (encodeTerm cx g currentNs v0))]
+      Coders.TcoStepCases v0 ->
+        let tname_ = Coders.tcoCaseStatementTypeName v0
+            ignoreTname = tname_
+            scrutinee_ = Coders.tcoCaseStatementScrutinee v0
+            armFields = Coders.tcoCaseStatementCases v0
+            defaultMaybe = Coders.tcoCaseStatementDefault v0
+            uVar = "u"
+            uInitExpr = encodeTerm cx g currentNs scrutinee_
+            uDecl = tsConstDeclStatement uVar uInitExpr
+            uExpr = tsAsAny (tsExprIdent uVar)
+            uTag = tsMember uExpr "tag"
+            uValue = tsMember uExpr "value"
+            armCases =
+                    Lists.map (\f ->
+                      let fname = Model.unName (Coders.tcoCaseAlternativeName f)
+                          payloadVar = sanitizeParamName (Coders.tcoCaseAlternativeParameter f)
+                          payloadDecl = tsConstDeclStatement payloadVar uValue
+                          armStmts = encodeTcoStep cx g currentNs loopVars (Coders.tcoCaseAlternativeHandler f)
+                      in Syntax.SwitchCase {
+                        Syntax.switchCaseTest = (Just (tsExprStr fname)),
+                        Syntax.switchCaseConsequent = [
+                          Syntax.StatementBlock (Lists.concat2 [
+                            payloadDecl] armStmts)]}) armFields
+            defaultCase =
+                    Optionals.match defaultMaybe (Syntax.SwitchCase {
+                      Syntax.switchCaseTest = Nothing,
+                      Syntax.switchCaseConsequent = [
+                        Syntax.StatementReturn (Just (tsCall (tsExprIdent "(() => { throw new Error('unmatched case'); })") []))]}) (\dflt ->
+                      let dStmts = encodeTcoStep cx g currentNs loopVars dflt
+                      in Syntax.SwitchCase {
+                        Syntax.switchCaseTest = Nothing,
+                        Syntax.switchCaseConsequent = [
+                          Syntax.StatementBlock dStmts]})
+            allCases = Lists.concat2 armCases [
+                  defaultCase]
+            switchStmt =
+                    Syntax.StatementSwitch (Syntax.SwitchStatement {
+                      Syntax.switchStatementDiscriminant = uTag,
+                      Syntax.switchStatementCases = allCases})
+        in [
+          uDecl,
+          switchStmt]
+      Coders.TcoStepLet_ v0 ->
+        let bindings = Coders.tcoLetBindings v0
+            bindingStmts =
+                    Lists.map (\b ->
+                      let bname = sanitizeParamName (Coders.tcoBindingName b)
+                          bexpr = encodeTerm cx g currentNs (Coders.tcoBindingTerm b)
+                      in (tsConstDeclStatement bname bexpr)) bindings
+            bodyStmts = encodeTcoStep cx g currentNs loopVars (Coders.tcoLetBody v0)
+        in (Lists.concat2 bindingStmts bodyStmts)
+
 -- | Render a Hydra term as a TypeScript expression
 encodeTerm :: Typing.InferenceContext -> Graph.Graph -> Packaging.ModuleName -> Model.Term -> Syntax.Expression
 encodeTerm cx g currentNs term =
@@ -346,7 +410,7 @@
               let headExpr = encodeTerm cx g currentNs headTerm
               in (tsCall headExpr encArgs)) (\e -> e))
       Model.TermUnit -> tsUndefined
-      Model.TermList v0 -> tsArray (Lists.map (encodeTerm cx g currentNs) v0)
+      Model.TermList v0 -> Logic.ifElse (Lists.isEmpty v0) (tsAsAny (tsArray [])) (tsArray (Lists.map (encodeTerm cx g currentNs) v0))
       Model.TermSet v0 -> tsNew (tsExprIdent "Set") [
         tsArray (Lists.map (encodeTerm cx g currentNs) (Sets.toList v0))]
       Model.TermMap v0 -> tsNew (tsExprIdent "Map") [
@@ -459,7 +523,7 @@
           mScheme =
                   Optionals.bind (Packaging.termDefinitionSignature td) (\sig -> Just (Model.typeSchemeBody (Scoping.termSignatureToTypeScheme sig)))
           dterm = Strip.deannotateTerm rawTerm
-          funDecl = functionDeclarationFromTerm cx g currentNs lname rawTerm mScheme
+          funDecl = functionDeclarationFromTerm cx g currentNs name lname rawTerm mScheme
           asFunDecl = asExport (Syntax.StatementFunctionDeclaration funDecl)
           item =
                   case dterm of
@@ -661,8 +725,8 @@
       _ -> recurse0 targets term) targets0 term0
 
 -- | Build a TS function declaration from a Hydra term by peeling lambdas and let bindings into explicit parameters, statements, and a body
-functionDeclarationFromTerm :: Typing.InferenceContext -> Graph.Graph -> Packaging.ModuleName -> String -> Model.Term -> Maybe Model.Type -> Syntax.FunctionDeclaration
-functionDeclarationFromTerm cx g currentNs lname term _mScheme =
+functionDeclarationFromTerm :: Typing.InferenceContext -> Graph.Graph -> Packaging.ModuleName -> Model.Name -> String -> Model.Term -> Maybe Model.Type -> Syntax.FunctionDeclaration
+functionDeclarationFromTerm cx g currentNs fname lname term _mScheme =
 
       let fsE = analyzeTypeScriptFunction cx g term
           fs =
@@ -688,10 +752,27 @@
                   Lists.map (\pair -> encodeParam cx fsEnv currentNs (Pairs.first pair) (Pairs.second pair)) (Lists.zip fsParams fsDomsPadded)
           sortedBindings = sortBindingsTopologically fsBindings
           bindingStmts = Lists.map (\b -> encodeBindingAsStatement cx fsEnv currentNs b) sortedBindings
-          bodyExpr = encodeTerm cx fsEnv currentNs fsBody
-          returnStmt = Syntax.StatementReturn (Just bodyExpr)
-          block = Lists.concat2 bindingStmts [
-                returnStmt]
+          loopVarNames = Lists.map (\p -> sanitizeParamName p) fsParams
+          tcoBody =
+                  Logic.ifElse (Lists.isEmpty fsBindings) fsBody (Model.TermLet (Model.Let {
+                    Model.letBindings = sortedBindings,
+                    Model.letBody = fsBody}))
+          mPlan = Analysis.lowerSelfTailRecursion fname fsParams tcoBody
+          block =
+                  Optionals.match mPlan (
+                    let bodyExpr = encodeTerm cx fsEnv currentNs fsBody
+                        returnStmt = Syntax.StatementReturn (Just bodyExpr)
+                    in (Lists.concat2 bindingStmts [
+                      returnStmt])) (\plan ->
+                    let loopStmts = encodeTcoStep cx fsEnv currentNs loopVarNames (Coders.tcoLoopPlanBody plan)
+                        loopBody = Syntax.StatementBlock loopStmts
+                        trueExpr = Syntax.ExpressionLiteral (Syntax.LiteralBoolean True)
+                        whileStmt =
+                                Syntax.StatementWhile (Syntax.WhileStatement {
+                                  Syntax.whileStatementTest = trueExpr,
+                                  Syntax.whileStatementBody = loopBody})
+                    in [
+                      whileStmt])
       in Syntax.FunctionDeclaration {
         Syntax.functionDeclarationId = (tsIdent lname),
         Syntax.functionDeclarationParams = paramPatterns,
@@ -985,7 +1066,7 @@
                   Lists.map (\td ->
                     let tname = Packaging.termDefinitionName td
                         tterm = Packaging.termDefinitionBody td
-                        freeVars = eagerFreeVariablesInTerm tterm
+                        freeVars = Variables.eagerFreeVariablesInTerm tterm
                         deps = Lists.filter (\n -> Maps.member n byName) (Sets.toList freeVars)
                     in (tname, deps)) tdefs
           sccs = Sorting.topologicalSortComponents adjacency
@@ -1081,6 +1162,21 @@
       Syntax.conditionalExpressionTest = test,
       Syntax.conditionalExpressionConsequent = cons,
       Syntax.conditionalExpressionAlternate = alt})
+
+-- | A const variable-declaration statement
+tsConstDeclStatement :: String -> Syntax.Expression -> Syntax.Statement
+tsConstDeclStatement name expr =
+
+      let declarator =
+              Syntax.VariableDeclarator {
+                Syntax.variableDeclaratorId = (Syntax.PatternIdentifier (tsIdent name)),
+                Syntax.variableDeclaratorInit = (Just expr)}
+          varDecl =
+                  Syntax.VariableDeclaration {
+                    Syntax.variableDeclarationKind = Syntax.VariableKindConst,
+                    Syntax.variableDeclarationDeclarations = [
+                      declarator]}
+      in (Syntax.StatementVariableDeclaration varDecl)
 
 -- | Render a 'EntityReference' as TSDoc link syntax
 tsDocEntityRef :: Packaging.EntityReference -> String
