diff --git a/src/lake/.gitignore b/src/lake/.gitignore
index 3f78e1de4a..b58912d59c 100644
--- a/src/lake/.gitignore
+++ b/src/lake/.gitignore
@@ -1,3 +1,3 @@
 .lake
 lake-manifest.json
-*produced.out
+*produced.*
diff --git a/src/lake/Lake.lean b/src/lake/Lake.lean
index 2c05f7a86d..09633bb524 100644
--- a/src/lake/Lake.lean
+++ b/src/lake/Lake.lean
@@ -8,3 +8,4 @@ import Lake.Config
 import Lake.DSL
 import Lake.Version
 import Lake.CLI.Actions
+import Lake.Toml
diff --git a/src/lake/Lake/Build/Topological.lean b/src/lake/Lake/Build/Topological.lean
index 90faeb3370..5fb2d3c4cb 100644
--- a/src/lake/Lake/Build/Topological.lean
+++ b/src/lake/Lake/Build/Topological.lean
@@ -84,7 +84,7 @@ We use `keyOf` to the derive the unique key of a fetch from its descriptor
 `a : α`. We do this because descriptors may not be comparable and/or contain
 more information than necessary to determine uniqueness.
 -/
-@[inline] partial def recFetchAcyclic [BEq κ] [Monad m]
+@[inline] def recFetchAcyclic [BEq κ] [Monad m]
 (keyOf : α → κ) (fetch : DRecFetchFn α β (CycleT κ m)) : DFetchFn α β (CycleT κ m) :=
   recFetch fun a recurse =>
     /-
@@ -110,30 +110,3 @@ memoize fetch results and thus avoid computing the same result twice.
 : DFetchFn α (fun a => β (keyOf a)) (CycleT κ m) :=
   recFetchAcyclic keyOf fun a recurse =>
     fetchOrCreate (keyOf a) do fetch a recurse
-
-/-!
-## Building
-
-In this section, we use the abstractions we have just created to define
-the desired topological recursive build function (a.k.a. a suspending scheduler).
--/
-
-/-- Recursively builds objects for the keys `κ`, avoiding cycles. -/
-@[inline] def buildAcyclic [BEq κ] [Monad m]
-(keyOf : α → κ) (a : α) (build : RecFetchFn α β (CycleT κ m)) : ExceptT (Cycle κ) m β :=
-  recFetchAcyclic (β := fun _ => β) keyOf build a []
-
-/-- Dependently typed version of `buildTop`. -/
-@[inline] def buildDTop (β) [BEq κ] [Monad m] [MonadDStore κ β m]
-(keyOf : α → κ) (a : α) (build : DRecFetchFn α (fun a => β (keyOf a)) (CycleT κ m))
-: ExceptT (Cycle κ) m (β (keyOf a)) :=
-  recFetchMemoize keyOf build a []
-
-/--
-Recursively fills a `MonadStore` of key-object pairs by
-building objects topologically (ι.e., depth-first with memoization).
-If a cycle is detected, the list of keys traversed is thrown.
--/
-@[inline] def buildTop [BEq κ] [Monad m] [MonadStore κ β m]
-(keyOf : α → κ) (a : α) (build : RecFetchFn α β (CycleT κ m)) : ExceptT (Cycle κ) m β :=
-  recFetchMemoize (β := fun _ => β) keyOf build a []
diff --git a/src/lake/Lake/Build/Trace.lean b/src/lake/Lake/Build/Trace.lean
index 8191536372..68b6321fa0 100644
--- a/src/lake/Lake/Build/Trace.lean
+++ b/src/lake/Lake/Build/Trace.lean
@@ -3,6 +3,7 @@ Copyright (c) 2021 Mac Malone. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mac Malone
 -/
+import Lake.Util.Newline
 
 open System
 namespace Lake
@@ -128,23 +129,6 @@ def computeFileHash (file : FilePath) : IO Hash :=
 
 instance : ComputeHash FilePath IO := ⟨computeFileHash⟩
 
-/-- This is the same as `String.replace text "\r\n" "\n"`, but more efficient. -/
-@[inline] partial def crlf2lf (text : String) : String :=
-  go "" 0 0
-where
-  go (acc : String) (accStop pos : String.Pos) : String :=
-    if h : text.atEnd pos then
-      -- note: if accStop = 0 then acc is empty
-      if accStop = 0 then text else acc ++ text.extract accStop pos
-    else
-      let c := text.get' pos h
-      let pos' := text.next' pos h
-      if c == '\r' && text.get pos' == '\n' then
-        let acc := acc ++ text.extract accStop pos
-        go acc pos' (text.next pos')
-      else
-        go acc accStop pos'
-
 def computeTextFileHash (file : FilePath) : IO Hash := do
   let text ← IO.FS.readFile file
   let text := crlf2lf text
diff --git a/src/lake/Lake/CLI/Error.lean b/src/lake/Lake/CLI/Error.lean
index 6061244cfa..d2899bf05e 100644
--- a/src/lake/Lake/CLI/Error.lean
+++ b/src/lake/Lake/CLI/Error.lean
@@ -18,6 +18,7 @@ inductive CliError
 | unexpectedArguments (args : List String)
 /- Init CLI Errors -/
 | unknownTemplate (spec : String)
+| unknownConfigLang (spec : String)
 /- Build CLI Errors -/
 | unknownModule (mod : Name)
 | unknownPackage (spec : String)
@@ -31,10 +32,12 @@ inductive CliError
 | invalidFacet (target : Name) (facet : Name)
 /- Executable CLI Errors -/
 | unknownExe (spec : String)
-/- Script CLI Error -/
+/- Script CLI Error  -/
 | unknownScript (script : String)
 | missingScriptDoc (script : String)
 | invalidScriptSpec (spec : String)
+/-- Translate Errors -/
+| outputConfigExists (path : System.FilePath)
 /- Config Errors -/
 | unknownLeanInstall
 | unknownLakeInstall
@@ -53,6 +56,7 @@ def toString : CliError → String
 | unknownLongOption opt   => s!"unknown long option '{opt}'"
 | unexpectedArguments as  => s!"unexpected arguments: {" ".intercalate as}"
 | unknownTemplate spec    => s!"unknown package template `{spec}`"
+| unknownConfigLang spec  => s!"unknown configuration language `{spec}`"
 | unknownModule mod       => s!"unknown module `{mod.toString false}`"
 | unknownPackage spec     => s!"unknown package `{spec}`"
 | unknownFacet ty f       => s!"unknown {ty} facet `{f.toString false}`"
@@ -67,6 +71,7 @@ def toString : CliError → String
 | unknownScript s         => s!"unknown script {s}"
 | missingScriptDoc s      => s!"no documentation provided for `{s}`"
 | invalidScriptSpec s     => s!"invalid script spec '{s}' (too many '/')"
+| outputConfigExists f    => s!"output configuration file already exists: {f}"
 | unknownLeanInstall      => "could not detect a Lean installation"
 | unknownLakeInstall      => "could not detect the configuration of the Lake installation"
 | leanRevMismatch e a     => s!"expected Lean commit {e}, but got {if a.isEmpty then "nothing" else a}"
diff --git a/src/lake/Lake/CLI/Help.lean b/src/lake/Lake/CLI/Help.lean
index c33050c41d..6729f43995 100644
--- a/src/lake/Lake/CLI/Help.lean
+++ b/src/lake/Lake/CLI/Help.lean
@@ -25,6 +25,7 @@ COMMANDS:
   script                manage and run workspace scripts
   scripts               shorthand for `lake script list`
   run <script>          shorthand for `lake script run`
+  translate-config      change language of the package configuration
   serve                 start the Lean language server
 
 OPTIONS:
@@ -49,13 +50,16 @@ s!"The initial configuration and starter files are based on the template:
   std                   library and executable; default
   exe                   executable only
   lib                   library only
-  math                  library only with a mathlib dependency"
+  math                  library only with a mathlib dependency
+
+Templates can be suffixed with `.lean` or `.toml` to produce a Lean or TOML
+version of the configuration file, respectively. The default is Lean."
 
 def helpNew :=
 s!"Create a Lean package in a new directory
 
 USAGE:
-  lake new <name> [<template>]
+  lake new <name> [<template>][.<language>]
 
 {templateHelp}"
 
@@ -63,7 +67,7 @@ def helpInit :=
 s!"Create a Lean package in the current directory
 
 USAGE:
-  lake init [<name>] [<template>]
+  lake init [<name>] [<template>][.<language>]
 
 {templateHelp}
 
@@ -244,6 +248,21 @@ learn how to specify targets), builds it if it is out of date, and then runs
 it with the given `args` in Lake's environment (see `lake help env` for how
 the environment is set up)."
 
+def helpTranslateConfig :=
+"Translate a Lake configuration file into a different language
+
+USAGE:
+  lake translate-config <lang> [<out-file>]
+
+Translates the loaded package's configuration into another of
+Lake's supported configuration languages (i.e., either `lean` or `toml`).
+The produced file is written to `out-file` or, if not provided, the path of
+the configuration file with the new language's extension. If the output file
+already exists, Lake will error.
+
+Translation is lossy. It does not preserve comments or formatting and
+non-declarative configuration will be discarded."
+
 def helpScript : (cmd : String) → String
 | "list"                => helpScriptList
 | "run"                 => helpScriptRun
@@ -263,4 +282,5 @@ def help : (cmd : String) → String
 | "serve"               => helpServe
 | "env"                 => helpEnv
 | "exe" | "exec"        => helpExe
+| "translate-config"    => helpTranslateConfig
 | _                     => usage
diff --git a/src/lake/Lake/CLI/Init.lean b/src/lake/Lake/CLI/Init.lean
index ccb05192b1..c7ac571d6b 100644
--- a/src/lake/Lake/CLI/Init.lean
+++ b/src/lake/Lake/CLI/Init.lean
@@ -5,6 +5,7 @@ Authors: Gabriel Ebner, Sebastian Ullrich, Mac Malone
 -/
 import Lake.Util.Git
 import Lake.Util.Sugar
+import Lake.Config.Lang
 import Lake.Config.Package
 import Lake.Config.Workspace
 import Lake.Load.Config
@@ -46,7 +47,7 @@ s!"def main : IO Unit :=
   IO.println s!\"Hello, world!\"
 "
 
-def stdConfigFileContents (pkgName libRoot exeName : String) :=
+def stdLeanConfigFileContents (pkgName libRoot exeName : String) :=
 s!"import Lake
 open Lake DSL
 
@@ -61,7 +62,19 @@ lean_exe {exeName} where
   root := `Main
 "
 
-def exeConfigFileContents (pkgName exeRoot : String) :=
+def stdTomlConfigFileContents (pkgName libRoot exeName : String) :=
+s!"name = {repr pkgName}
+defaultTargets = [{repr exeName}]
+
+[[lean_lib]]
+name = {repr libRoot}
+
+[[lean_exe]]
+name = {repr exeName}
+root = \"Main\"
+"
+
+def exeLeanConfigFileContents (pkgName exeRoot : String) :=
 s!"import Lake
 open Lake DSL
 
@@ -70,13 +83,18 @@ package {pkgName} where
 
 @[default_target]
 lean_exe {exeRoot} where
-  -- Enables the use of the Lean interpreter by the executable (e.g.,
-  -- `runFrontend`) at the expense of increased binary size on Linux.
-  -- Remove this line if you do not need such functionality.
-  supportInterpreter := true
+  -- add executable configuration options here
 "
 
-def libConfigFileContents (pkgName libRoot : String) :=
+def exeTomlConfigFileContents (pkgName exeRoot : String) :=
+s!"name = {repr pkgName}
+defaultTargets = [{repr exeRoot}]
+
+[[lean_exe]]
+name = {repr exeRoot}
+"
+
+def libLeanConfigFileContents (pkgName libRoot : String) :=
 s!"import Lake
 open Lake DSL
 
@@ -88,15 +106,22 @@ lean_lib {libRoot} where
   -- add library configuration options here
 "
 
-def mathConfigFileContents (pkgName libRoot : String) :=
+def libTomlConfigFileContents (pkgName libRoot : String) :=
+s!"name = {repr pkgName}
+defaultTargets = [{repr libRoot}]
+
+[[lean_lib]]
+name = {repr libRoot}
+"
+
+def mathLeanConfigFileContents (pkgName libRoot : String) :=
 s!"import Lake
 open Lake DSL
 
 package {pkgName} where
   -- Settings applied to both builds and interactive editing
   leanOptions := #[
-    ⟨`pp.unicode.fun, true⟩, -- pretty-prints `fun a ↦ b`
-    ⟨`pp.proofs.withType, false⟩
+    ⟨`pp.unicode.fun, true⟩ -- pretty-prints `fun a ↦ b`
   ]
   -- add any additional package configuration options here
 
@@ -108,17 +133,32 @@ lean_lib {libRoot} where
   -- add any library configuration options here
 "
 
+def mathTomlConfigFileContents (pkgName libRoot : String) :=
+s!"name = {repr pkgName}
+defaultTargets = [{repr libRoot}]
+
+[leanOptions]
+pp.unicode.fun = true # pretty-prints `fun a ↦ b`
+
+[[require]]
+name = \"mathlib\"
+git = \"https://github.com/leanprover-community/mathlib4.git\"
+
+[[lean_lib]]
+name = {repr libRoot}
+"
+
 def mathToolchainUrl : String :=
   "https://raw.githubusercontent.com/leanprover-community/mathlib4/master/lean-toolchain"
 
-/-- The options for the template argument to `initPkg`. -/
+/-- Lake package template identifier. -/
 inductive InitTemplate
 | std | exe | lib | math
 deriving Repr, DecidableEq
 
 instance : Inhabited InitTemplate := ⟨.std⟩
 
-def InitTemplate.parse? : String → Option InitTemplate
+def InitTemplate.ofString? : String → Option InitTemplate
 | "std" => some .std
 | "exe" => some .exe
 | "lib" => some .lib
@@ -134,15 +174,21 @@ def escapeName! : Name → String
 | .str n s          => escapeName! n ++ "." ++ escapeIdent s
 | _                 => unreachable!
 
-def InitTemplate.configFileContents (pkgName : Name) (root : String) : InitTemplate → String
-| .std => stdConfigFileContents (escapeName! pkgName) root
-  (escapeIdent <| pkgName.toStringWithSep "-" false).toLower
-| .lib => libConfigFileContents (escapeName! pkgName) root
-| .exe => exeConfigFileContents (escapeName! pkgName) root
-| .math => mathConfigFileContents (escapeName! pkgName) root
+def InitTemplate.configFileContents  (tmp : InitTemplate) (lang : ConfigLang) (pkgName : Name) (root : Name) : String :=
+  match tmp, lang with
+  | .std, .lean => stdLeanConfigFileContents (escapeName! pkgName) (escapeName! root)
+    (escapeIdent <| pkgName.toStringWithSep "-" false).toLower
+  | .std, .toml => stdTomlConfigFileContents pkgName.toString root.toString
+    (pkgName.toStringWithSep "-" false).toLower
+  | .lib, .lean => libLeanConfigFileContents (escapeName! pkgName) (escapeName! root)
+  | .lib, .toml => libTomlConfigFileContents pkgName.toString root.toString
+  | .exe, .lean => exeLeanConfigFileContents (escapeName! pkgName) (escapeName! root)
+  | .exe, .toml => exeTomlConfigFileContents pkgName.toString root.toString
+  | .math, .lean => mathLeanConfigFileContents (escapeName! pkgName) (escapeName! root)
+  | .math, .toml => mathTomlConfigFileContents pkgName.toString root.toString
 
 /-- Initialize a new Lake package in the given directory with the given name. -/
-def initPkg (dir : FilePath) (name : String) (tmp : InitTemplate) (env : Lake.Env) : LogIO PUnit := do
+def initPkg (dir : FilePath) (name : String) (tmp : InitTemplate) (lang : ConfigLang) (env : Lake.Env) : LogIO PUnit := do
   let pkgName := stringToLegalOrSimpleName name
 
   -- determine the name to use for the root
@@ -159,14 +205,15 @@ def initPkg (dir : FilePath) (name : String) (tmp : InitTemplate) (env : Lake.En
       pure (root, rootFile, ← rootFile.pathExists)
 
   -- write default configuration file
-  let configFile := dir / defaultConfigFile
+  let configFile :=  dir / match lang with
+    | .lean => defaultLeanConfigFile | .toml => defaultTomlConfigFile
   if (← configFile.pathExists) then
     error  "package already initialized"
-  let rootNameStr := escapeName! root
-  let contents := tmp.configFileContents pkgName rootNameStr
+  let contents := tmp.configFileContents lang pkgName root
   IO.FS.writeFile configFile contents
 
   -- write example code if the files do not already exist
+  let rootNameStr := escapeName! root
   if tmp = .exe then
     unless (← rootFile.pathExists) do
       createParentDirs rootFile
@@ -225,7 +272,7 @@ def validatePkgName (pkgName : String) : LogIO PUnit := do
   if pkgName.toLower ∈ ["init", "lean", "lake", "main"] then
     error "reserved package name"
 
-def init (pkgName : String) (tmp : InitTemplate) (env : Lake.Env) (cwd : FilePath := ".") : LogIO PUnit := do
+def init (pkgName : String) (tmp : InitTemplate) (lang : ConfigLang) (env : Lake.Env) (cwd : FilePath := ".") : LogIO PUnit := do
   let pkgName ← do
     if pkgName == "." then
       let path ← IO.FS.realPath cwd
@@ -237,11 +284,11 @@ def init (pkgName : String) (tmp : InitTemplate) (env : Lake.Env) (cwd : FilePat
   let pkgName := pkgName.trim
   validatePkgName pkgName
   IO.FS.createDirAll cwd
-  initPkg cwd pkgName tmp env
+  initPkg cwd pkgName tmp lang env
 
-def new (pkgName : String) (tmp : InitTemplate) (env : Lake.Env) (cwd : FilePath := ".") : LogIO PUnit := do
+def new (pkgName : String) (tmp : InitTemplate) (lang : ConfigLang)  (env : Lake.Env) (cwd : FilePath := ".") : LogIO PUnit := do
   let pkgName := pkgName.trim
   validatePkgName pkgName
   let dirName := cwd / pkgName.map fun chr => if chr == '.' then '-' else chr
   IO.FS.createDirAll dirName
-  initPkg dirName pkgName tmp env
+  initPkg dirName pkgName tmp lang env
diff --git a/src/lake/Lake/CLI/Main.lean b/src/lake/Lake/CLI/Main.lean
index e230bb785d..b993a7bf28 100644
--- a/src/lake/Lake/CLI/Main.lean
+++ b/src/lake/Lake/CLI/Main.lean
@@ -13,6 +13,7 @@ import Lake.CLI.Help
 import Lake.CLI.Build
 import Lake.CLI.Error
 import Lake.CLI.Actions
+import Lake.CLI.Translate
 import Lake.CLI.Serve
 
 -- # CLI
@@ -64,10 +65,10 @@ def LakeOptions.computeEnv (opts : LakeOptions) : EIO CliError Lake.Env := do
 /-- Make a `LoadConfig` from a `LakeOptions`. -/
 def LakeOptions.mkLoadConfig (opts : LakeOptions) : EIO CliError LoadConfig :=
   return {
-    env := ← opts.computeEnv
-    rootDir := opts.rootDir
-    configFile := opts.rootDir / opts.configFile
-    configOpts := opts.configOpts
+    lakeEnv := ← opts.computeEnv
+    wsDir := opts.rootDir
+    relConfigFile := opts.configFile
+    lakeOpts := opts.configOpts
     leanOpts := Lean.Options.empty
     reconfigure := opts.reconfigure
   }
@@ -200,14 +201,29 @@ def parseScriptSpec (ws : Workspace) (spec : String) : Except CliError Script :=
     | none => throw <| CliError.unknownScript spec
   | _ => throw <| CliError.invalidScriptSpec spec
 
-def parseTemplateSpec (spec : String) : Except CliError InitTemplate :=
+def parseTemplateSpec (spec : String) : Except CliError InitTemplate := do
   if spec.isEmpty then
-    pure default
-  else if let some tmp := InitTemplate.parse? spec then
-    pure tmp
+    return default
+  else if let some tmp := InitTemplate.ofString? spec.toLower then
+    return tmp
   else
     throw <| CliError.unknownTemplate spec
 
+def parseLangSpec (spec : String) : Except CliError ConfigLang :=
+  if spec.isEmpty then
+    return default
+  else if let some lang := ConfigLang.ofString? spec.toLower then
+    return lang
+  else
+    throw <| CliError.unknownConfigLang spec
+
+def parseTemplateLangSpec (spec : String) : Except CliError (InitTemplate × ConfigLang) := do
+  match spec.splitOn "." with
+  | [tmp, lang] => return (← parseTemplateSpec tmp, ← parseLangSpec lang)
+  | [tmp] => return (← parseTemplateSpec tmp, default)
+  | _ => return default
+
+
 /-! ## Commands -/
 
 namespace lake
@@ -267,15 +283,15 @@ protected def new : CliM PUnit := do
   processOptions lakeOption
   let opts ← getThe LakeOptions
   let name ← takeArg "package name"
-  let tmp ← parseTemplateSpec <| (← takeArg?).getD ""
-  noArgsRem do MainM.runLogIO (new name tmp (← opts.computeEnv) opts.rootDir) opts.verbosity
+  let (tmp, lang) ← parseTemplateLangSpec <| (← takeArg?).getD ""
+  noArgsRem do MainM.runLogIO (new name tmp lang (← opts.computeEnv) opts.rootDir) opts.verbosity
 
 protected def init : CliM PUnit := do
   processOptions lakeOption
   let opts ← getThe LakeOptions
   let name := (← takeArg?).getD "."
-  let tmp ← parseTemplateSpec <| (← takeArg?).getD ""
-  noArgsRem do MainM.runLogIO (init name tmp (← opts.computeEnv) opts.rootDir) opts.verbosity
+  let (tmp, lang) ← parseTemplateLangSpec <| (← takeArg?).getD ""
+  noArgsRem do MainM.runLogIO (init name tmp lang (← opts.computeEnv) opts.rootDir) opts.verbosity
 
 protected def build : CliM PUnit := do
   processOptions lakeOption
@@ -353,10 +369,10 @@ protected def serve : CliM PUnit := do
 protected def env : CliM PUnit := do
   let config ← mkLoadConfig (← getThe LakeOptions)
   let env ← do
-    if (← config.configFile.pathExists) then
+    if (← configFileExists config.configFile) then
       pure (← loadWorkspace config).augmentedEnvVars
     else
-      pure config.env.vars
+      pure config.lakeEnv.vars
   if let some cmd ← takeArg? then
     let child ← IO.Process.spawn {cmd, args := (← takeArgs).toArray, env}
     exit <| ← child.wait
@@ -375,6 +391,22 @@ protected def exe : CliM PUnit := do
   let exeFile ← ws.runBuild (exe.build >>= (·.await)) <| mkBuildConfig opts
   exit <| ← (env exeFile.toString args.toArray).run <| mkLakeContext ws
 
+protected def translateConfig : CliM PUnit := do
+  processOptions lakeOption
+  let opts ← getThe LakeOptions
+  let cfg ← mkLoadConfig opts
+  let lang ← parseLangSpec (← takeArg "configuration language")
+  let outFile? := (← takeArg?).map FilePath.mk
+  noArgsRem do
+  Lean.searchPathRef.set cfg.lakeEnv.leanSearchPath
+  let (pkg, _) ← loadPackage "[root]" cfg
+  let outFile := outFile?.getD <| pkg.configFile.withExtension lang.fileExtension
+  if (← outFile.pathExists) then
+    throw (.outputConfigExists outFile)
+  IO.FS.writeFile outFile (← pkg.mkConfigString lang)
+  if outFile?.isNone then
+    IO.FS.rename pkg.configFile (pkg.configFile.addExtension "bak")
+
 protected def selfCheck : CliM PUnit := do
   processOptions lakeOption
   noArgsRem do verifyInstall (← getThe LakeOptions)
@@ -399,6 +431,7 @@ def lakeCli : (cmd : String) → CliM PUnit
 | "serve"               => lake.serve
 | "env"                 => lake.env
 | "exe" | "exec"        => lake.exe
+| "translate-config"    => lake.translateConfig
 | "self-check"          => lake.selfCheck
 | "help"                => lake.help
 | cmd                   => throw <| CliError.unknownCommand cmd
diff --git a/src/lake/Lake/CLI/Serve.lean b/src/lake/Lake/CLI/Serve.lean
index de1f497743..bfe6eb7dd9 100644
--- a/src/lake/Lake/CLI/Serve.lean
+++ b/src/lake/Lake/CLI/Serve.lean
@@ -28,7 +28,7 @@ The `setup-file` command is used internally by Lean 4 server.
 -/
 def setupFile (loadConfig : LoadConfig) (path : FilePath) (imports : List String := [])
 (buildConfig : BuildConfig := {}) (verbosity : Verbosity := .normal) : MainM PUnit := do
-  if (← loadConfig.configFile.pathExists) then
+  if (← configFileExists loadConfig.configFile) then
     if let some errLog := (← IO.getEnv invalidConfigEnvVar) then
       IO.eprint errLog
       IO.eprintln s!"Invalid Lake configuration.  Please restart the server after fixing the Lake configuration file."
@@ -70,9 +70,9 @@ def serve (config : LoadConfig) (args : Array String) : IO UInt32 := do
       pure (← LakeT.run ctx getAugmentedEnv, ws.root.moreGlobalServerArgs)
     else
       IO.eprintln "warning: package configuration has errors, falling back to plain `lean --server`"
-      pure (config.env.baseVars.push (invalidConfigEnvVar, log), #[])
+      pure (config.lakeEnv.baseVars.push (invalidConfigEnvVar, log), #[])
   (← IO.Process.spawn {
-    cmd := config.env.lean.lean.toString
+    cmd := config.lakeEnv.lean.lean.toString
     args := #["--server"] ++ moreServerArgs ++ args
     env := extraEnv
   }).wait
diff --git a/src/lake/Lake/CLI/Translate.lean b/src/lake/Lake/CLI/Translate.lean
new file mode 100644
index 0000000000..41175786bf
--- /dev/null
+++ b/src/lake/Lake/CLI/Translate.lean
@@ -0,0 +1,34 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Load.Elab
+import Lake.Config.Lang
+import Lake.Config.Package
+import Lake.CLI.Translate.Toml
+import Lake.CLI.Translate.Lean
+import Lean.PrettyPrinter
+
+namespace Lake
+open Toml Lean System PrettyPrinter
+
+private partial def descopeSyntax : Syntax → Syntax
+| .ident info rawVal val preresolved =>
+  .ident info rawVal val.eraseMacroScopes preresolved
+| .node info k args => .node info k <| args.map descopeSyntax
+| stx => stx
+
+private def descopeTSyntax (stx : TSyntax k) : TSyntax k :=
+  ⟨descopeSyntax stx.raw⟩
+
+def Package.mkConfigString (pkg : Package) (lang : ConfigLang) : LogIO String := do
+  match lang with
+  | .toml => pure <| ppTable pkg.mkTomlConfig
+  | .lean => do
+    let env ← importModulesUsingCache #[`Lake] {} 1024
+    let pp := ppModule <| descopeTSyntax <| pkg.mkLeanConfig
+    match (← pp.toIO {fileName := "", fileMap := default} {env} |>.toBaseIO) with
+    | .ok (fmt, _) => pure <| (toString fmt).trim ++ "\n"
+    | .error ex =>
+      error s!"(internal) failed to pretty print Lean configuration: {ex.toString}"
diff --git a/src/lake/Lake/CLI/Translate/Lean.lean b/src/lake/Lake/CLI/Translate/Lean.lean
new file mode 100644
index 0000000000..242fe17c27
--- /dev/null
+++ b/src/lake/Lake/CLI/Translate/Lean.lean
@@ -0,0 +1,187 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.DSL
+import Lake.Config.Package
+import Lean.Parser.Module
+
+/-! # Lean Translation
+
+Converts a declarative Lake configuration into a Lean module.
+-/
+
+namespace Lake
+open DSL System Lean Syntax Parser Module
+
+/-! ## General Helpers -/
+
+private local instance : Quote FilePath where
+  quote path := quote path.toString
+
+private local instance : BEq FilePath where
+  beq a b := a.normalize == b.normalize
+
+private local instance : Quote Bool where
+  quote b := mkIdent <| if b then `true else `false
+
+@[inline] def addDeclField [Quote α] (name : Name) (val : α) (fs : Array DeclField) : Array DeclField :=
+  fs.push <| Unhygienic.run `(declField|$(mkIdent name) := $(quote val))
+
+@[inline] def addDeclField? [Quote α] (name : Name) (val? : Option α) (fs : Array DeclField) : Array DeclField :=
+  if let some val := val? then addDeclField name val fs else fs
+
+@[inline] def addDeclFieldD [Quote α] [BEq α] (name : Name) (val : α) (default : α) (fs : Array DeclField) : Array DeclField :=
+  if val == default then fs else addDeclField name val fs
+
+@[inline] def addDeclFieldNotEmpty [Quote α] (name : Name) (val : Array α) (fs : Array DeclField) : Array DeclField :=
+  if val.isEmpty then fs else addDeclField name val fs
+
+/-! ## Value Encoders -/
+
+protected def BuildType.quote : BuildType → Term
+| .debug => mkCIdent ``debug
+| .minSizeRel => mkCIdent ``minSizeRel
+| .relWithDebInfo => mkCIdent ``relWithDebInfo
+| .release => mkCIdent ``release
+
+instance : Quote BuildType := ⟨BuildType.quote⟩
+
+protected def Backend.quote : Backend → Term
+| .c => mkCIdent ``c
+| .llvm => mkCIdent ``llvm
+| .default => mkCIdent ``default
+
+instance : Quote Backend := ⟨Backend.quote⟩
+
+def quoteLeanOptionValue : LeanOptionValue → Term
+| .ofString v => quote v
+| .ofBool v => quote v
+| .ofNat v => quote v
+
+private local instance : Quote LeanOptionValue := ⟨quoteLeanOptionValue⟩
+
+def quoteLeanOption (opt : LeanOption) : Term := Unhygienic.run do
+  `(⟨$(quote opt.name), $(quote opt.value)⟩)
+
+private local instance : Quote LeanOption := ⟨quoteLeanOption⟩
+
+/-! ## Configuration Encoders -/
+
+def WorkspaceConfig.addDeclFields (cfg : WorkspaceConfig) (fs : Array DeclField) : Array DeclField :=
+  addDeclFieldD `packagesDir cfg.packagesDir defaultPackagesDir fs
+
+def LeanConfig.addDeclFields (cfg : LeanConfig) (fs : Array DeclField) : Array DeclField :=
+  fs
+  |> addDeclFieldD `buildType  cfg.buildType .release
+  |> addDeclFieldD `backend cfg.backend .default
+  |> addDeclField? `platformIndependent cfg.platformIndependent
+  |> addDeclFieldNotEmpty `leanOptions cfg.leanOptions
+  |> addDeclFieldNotEmpty `moreServerOptions cfg.moreServerOptions
+  |> addDeclFieldNotEmpty `moreLeanArgs cfg.moreLeanArgs
+  |> addDeclFieldNotEmpty `weakLeanArgs cfg.weakLeanArgs
+  |> addDeclFieldNotEmpty `moreLeancArgs cfg.moreLeancArgs
+  |> addDeclFieldNotEmpty `weakLeancArgs cfg.weakLeancArgs
+  |> addDeclFieldNotEmpty `moreLinkArgs cfg.moreLinkArgs
+  |> addDeclFieldNotEmpty `weakLinkArgs cfg.weakLinkArgs
+
+@[inline] def mkDeclValWhere? (fields : Array DeclField) : Option (TSyntax ``declValWhere) :=
+  if fields.isEmpty then none else Unhygienic.run `(declValWhere|where $fields*)
+
+def PackageConfig.mkSyntax (cfg : PackageConfig) : PackageDecl := Unhygienic.run do
+  let declVal? := mkDeclValWhere? <|Array.empty
+    |> addDeclFieldD `precompileModules cfg.precompileModules false
+    |> addDeclFieldD `moreGlobalServerArgs cfg.moreGlobalServerArgs #[]
+    |> addDeclFieldD `srcDir cfg.srcDir "."
+    |> addDeclFieldD `buildDir cfg.buildDir defaultBuildDir
+    |> addDeclFieldD `leanLibDir cfg.leanLibDir defaultLeanLibDir
+    |> addDeclFieldD `nativeLibDir cfg.nativeLibDir defaultNativeLibDir
+    |> addDeclFieldD `binDir cfg.binDir defaultBinDir
+    |> addDeclFieldD `irDir cfg.irDir defaultIrDir
+    |> addDeclField? `releaseRepo (cfg.releaseRepo <|> cfg.releaseRepo?)
+    |> addDeclFieldD `buildArchive (cfg.buildArchive?.getD cfg.buildArchive) (defaultBuildArchive cfg.name)
+    |> addDeclFieldD `preferReleaseBuild cfg.preferReleaseBuild false
+    |> cfg.toWorkspaceConfig.addDeclFields
+    |> cfg.toLeanConfig.addDeclFields
+  `(packageDecl|package $(mkIdent cfg.name) $[$declVal?]?)
+
+private def getEscapedNameParts? (acc : List String) : Name → Option (List String)
+  | Name.anonymous => if acc.isEmpty then none else some acc
+  | Name.str n s => do
+    let s ← Name.escapePart s
+    getEscapedNameParts? (s::acc) n
+  | Name.num _ _ => none
+
+def mkNameLit? (n : Name) : Option NameLit :=
+  getEscapedNameParts? [] n  |>.map fun ss => mkNameLit ("`" ++ ".".intercalate ss)
+
+protected def Glob.quote (glob : Glob) : Term := Unhygienic.run do
+  match glob with
+  | .one n => return quote n
+  | .submodules n =>
+    match mkNameLit? n with
+    | some lit =>`($lit:name.+)
+    | none => return mkCApp ``submodules #[quote n]
+  | .andSubmodules n =>
+    match mkNameLit? n with
+    | some lit =>`($lit:name.*)
+    | none => return mkCApp ``andSubmodules #[quote n]
+
+local instance : Quote Glob := ⟨Glob.quote⟩
+
+@[inline] private def mkConfigAttrs? (defaultTarget : Bool) : Option Attributes :=
+  if defaultTarget then Unhygienic.run `(Term.attributes|@[default_target]) else none
+
+protected def LeanLibConfig.mkSyntax (cfg : LeanLibConfig) (defaultTarget := false) : LeanLibDecl := Unhygienic.run do
+  let declVal? := mkDeclValWhere? <| Array.empty
+    |> addDeclFieldD `srcDir cfg.srcDir "."
+    |> addDeclFieldD `roots cfg.roots #[cfg.name]
+    |> addDeclFieldD `globs cfg.globs (cfg.roots.map .one)
+    |> addDeclFieldD `libName cfg.libName (cfg.name.toString (escape := false))
+    |> addDeclFieldD `precompileModules cfg.precompileModules false
+    |> addDeclFieldD `defaultFacets cfg.defaultFacets #[LeanLib.leanArtsFacet]
+    |> cfg.toLeanConfig.addDeclFields
+  let attrs? := mkConfigAttrs? defaultTarget
+  `(leanLibDecl|$[$attrs?:attributes]? lean_lib $(mkIdent cfg.name) $[$declVal?]?)
+
+protected def LeanExeConfig.mkSyntax (cfg : LeanExeConfig) (defaultTarget := false) : LeanExeDecl := Unhygienic.run do
+  let declVal? := mkDeclValWhere? <| Array.empty
+    |> addDeclFieldD `srcDir cfg.srcDir "."
+    |> addDeclFieldD `root cfg.root cfg.name
+    |> addDeclFieldD `exeName cfg.exeName (cfg.name.toStringWithSep "-" (escape := false))
+    |> addDeclFieldD `supportInterpreter cfg.supportInterpreter false
+    |> cfg.toLeanConfig.addDeclFields
+  let attrs? := mkConfigAttrs? defaultTarget
+  `(leanExeDecl|$[$attrs?:attributes]? lean_exe $(mkIdent cfg.name) $[$declVal?]?)
+
+protected def Dependency.mkSyntax (cfg : Dependency) : RequireDecl:= Unhygienic.run do
+  let opts? := if cfg.opts.isEmpty then none else some <| Unhygienic.run do
+    cfg.opts.foldM (init := mkCIdent ``NameMap.empty) fun stx opt val =>
+      `($stx |>.insert $(quote opt) $(quote val))
+  match cfg.src with
+  | .path dir =>
+    `(requireDecl|require $(mkIdent cfg.name) from $(quote dir):term $[with $opts?]?)
+  | .git url rev? subDir? =>
+    `(requireDecl|require $(mkIdent cfg.name) from git $(quote url)
+      $[@ $(rev?.map quote)]? $[/ $(subDir?.map quote)]? $[with $opts?]?)
+
+/-! ## Root Encoder -/
+
+/-- Create a Lean module that encodes the declarative configuration of the package. -/
+def Package.mkLeanConfig (pkg : Package) : TSyntax ``module := Unhygienic.run do
+  let pkgConfig := pkg.config.mkSyntax
+  let defaultTargets := pkg.defaultTargets.foldl NameSet.insert NameSet.empty
+  let requires := pkg.depConfigs.map (·.mkSyntax)
+  let leanLibs := pkg.leanLibConfigs.toArray.map fun cfg =>
+    cfg.mkSyntax (defaultTargets.contains cfg.name)
+  let leanExes := pkg.leanExeConfigs.toArray.map fun cfg =>
+    cfg.mkSyntax (defaultTargets.contains cfg.name)
+  `(module|
+  import $(mkIdent `Lake)
+  open $(mkIdent `System) $(mkIdent `Lake) $(mkIdent `DSL)
+  $pkgConfig:command
+  $[$requires:command]*
+  $[$leanLibs:command]*
+  $[$leanExes:command]*
+  )
diff --git a/src/lake/Lake/CLI/Translate/Toml.lean b/src/lake/Lake/CLI/Translate/Toml.lean
new file mode 100644
index 0000000000..d1a70f7aae
--- /dev/null
+++ b/src/lake/Lake/CLI/Translate/Toml.lean
@@ -0,0 +1,128 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Toml.Encode
+import Lake.Config.Package
+
+/-! # TOML Translation
+
+Converts a declarative Lake configuration into a TOML table.
+-/
+
+namespace Lake
+open Lean System Toml
+
+/-! ## Helper Encoders -/
+
+private local instance : BEq FilePath where
+  beq a b := a.normalize == b.normalize
+
+instance : ToToml Backend := ⟨(toToml ·.toString)⟩
+instance : SmartInsert Backend where
+  smartInsert k v t := match v with | .default => t | v => t.insert k (toToml v)
+
+instance : ToToml BuildType := ⟨(toToml ·.toString)⟩
+
+def Toml.encodeLeanOptionValue (v : LeanOptionValue) : Value :=
+  match v with
+  | .ofString s => toToml s
+  | .ofBool b => toToml b
+  | .ofNat n => toToml n
+
+instance : ToToml LeanOptionValue := ⟨encodeLeanOptionValue⟩
+
+def Toml.encodeLeanOptions (opts : Array LeanOption) : Table :=
+  opts.foldl (init := {}) fun vs ⟨k,v⟩ => vs.insert k (toToml v)
+
+def Toml.leanOptionsEncoder : ToToml (Array LeanOption) where
+  toToml opts := .table .missing <| encodeLeanOptions opts
+
+/-! ## Configuration Encoders -/
+
+protected def WorkspaceConfig.toToml (cfg : WorkspaceConfig) (t : Table := {}) : Table :=
+  t.insertD `packagesDir cfg.packagesDir defaultPackagesDir
+
+instance : ToToml WorkspaceConfig := ⟨(toToml ·.toToml)⟩
+
+def LeanConfig.toToml (cfg : LeanConfig) (t : Table := {}) : Table :=
+  have : ToToml (Array LeanOption) := leanOptionsEncoder
+  t.insertD `buildType cfg.buildType .release
+  |>.smartInsert `backend cfg.backend
+  |>.smartInsert `platformIndependent cfg.platformIndependent
+  |>.smartInsert `leanOptions cfg.leanOptions
+  |>.smartInsert `moreServerOptions cfg.moreServerOptions
+  |>.smartInsert `moreLeanArgs cfg.moreLeanArgs
+  |>.smartInsert `weakLeanArgs cfg.weakLeanArgs
+  |>.smartInsert `moreLeancArgs cfg.moreLeancArgs
+  |>.smartInsert `weakLeancArgs cfg.weakLeancArgs
+  |>.smartInsert `moreLinkArgs cfg.moreLinkArgs
+  |>.smartInsert `weakLinkArgs cfg.weakLinkArgs
+
+instance : ToToml LeanConfig := ⟨(toToml ·.toToml)⟩
+
+protected def PackageConfig.toToml (cfg : PackageConfig) (t : Table := {}) : Table :=
+  t.insert `name cfg.name
+  |>.insertD `precompileModules cfg.precompileModules false
+  |>.smartInsert `moreGlobalServerArgs cfg.moreGlobalServerArgs
+  |>.insertD `srcDir cfg.srcDir "."
+  |>.insertD `buildDir cfg.buildDir defaultBuildDir
+  |>.insertD `leanLibDir cfg.leanLibDir defaultLeanLibDir
+  |>.insertD `nativeLibDir cfg.nativeLibDir defaultNativeLibDir
+  |>.insertD `binDir cfg.binDir defaultBinDir
+  |>.insertD `irDir cfg.irDir defaultIrDir
+  |>.smartInsert `releaseRepo (cfg.releaseRepo <|> cfg.releaseRepo?)
+  |>.insertD `buildArchive (cfg.buildArchive?.getD cfg.buildArchive) (defaultBuildArchive cfg.name)
+  |>.insertD `preferReleaseBuild cfg.preferReleaseBuild false
+  |> cfg.toWorkspaceConfig.toToml
+  |> cfg.toLeanConfig.toToml
+
+instance : ToToml PackageConfig := ⟨(toToml ·.toToml)⟩
+
+instance : ToToml Glob := ⟨(toToml ·.toString)⟩
+
+protected def LeanLibConfig.toToml (cfg : LeanLibConfig) (t : Table := {}) : Table :=
+  t.insert `name cfg.name
+  |>.insertD `srcDir cfg.srcDir "."
+  |>.insertD `roots cfg.roots #[cfg.name]
+  |>.insertD `globs cfg.globs (cfg.roots.map .one)
+  |>.insertD `libName cfg.libName (cfg.name.toString (escape := false))
+  |>.insertD `precompileModules cfg.precompileModules false
+  |>.insertD `defaultFacets cfg.defaultFacets #[LeanLib.leanArtsFacet]
+  |> cfg.toLeanConfig.toToml
+
+instance : ToToml LeanLibConfig := ⟨(toToml ·.toToml)⟩
+
+protected def LeanExeConfig.toToml (cfg : LeanExeConfig) (t : Table  := {}) : Table :=
+  t.insert `name cfg.name
+  |>.insertD `srcDir cfg.srcDir "."
+  |>.insertD `root cfg.root cfg.name
+  |>.insertD `exeName cfg.exeName (cfg.name.toStringWithSep "-" (escape := false))
+  |>.insertD `supportInterpreter cfg.supportInterpreter false
+  |> cfg.toLeanConfig.toToml
+
+instance : ToToml LeanExeConfig := ⟨(toToml ·.toToml)⟩
+
+protected def Dependency.toToml (dep : Dependency) (t : Table  := {}) : Table :=
+  let t := t.insert `name dep.name
+  let t :=
+    match dep.src with
+    | .path dir => t.insert `path (toToml dir)
+    | .git url rev subDir? =>
+      t.insert `git url
+      |>.smartInsert `rev rev
+      |>.smartInsert `subDir subDir?
+  t.smartInsert `options <| dep.opts.fold (·.insert · ·) Table.empty
+
+instance : ToToml Dependency := ⟨(toToml ·.toToml)⟩
+
+/-! ## Root Encoder -/
+
+/-- Create a TOML table that encodes the declarative configuration of the package. -/
+def Package.mkTomlConfig (pkg : Package) (t : Table := {}) : Table :=
+  pkg.config.toToml t
+  |>.smartInsert `defaultTargets pkg.defaultTargets
+  |>.smartInsert `require pkg.depConfigs
+  |>.smartInsert `lean_lib pkg.leanLibConfigs.toArray
+  |>.smartInsert `lean_exe pkg.leanExeConfigs.toArray
diff --git a/src/lake/Lake/Config/Defaults.lean b/src/lake/Lake/Config/Defaults.lean
index 431aaf7eb8..60ff94095f 100644
--- a/src/lake/Lake/Config/Defaults.lean
+++ b/src/lake/Lake/Config/Defaults.lean
@@ -14,10 +14,16 @@ Currently not configurable.
 def defaultLakeDir : FilePath := ".lake"
 
 /-- The default setting for a `WorkspaceConfig`'s `packagesDir` option. -/
-def defaultPackagesDir : FilePath := "packages"
+def defaultPackagesDir := defaultLakeDir / "packages"
 
-/-- The default name of the Lake configuration file (i.e., `lakefile.lean`). -/
-def defaultConfigFile : FilePath := "lakefile.lean"
+/-- The default name of the Lake configuration file (i.e., `lakefile`). -/
+def defaultConfigFile : FilePath := "lakefile"
+
+/-- The default name of the Lean Lake configuration file (i.e., `lakefile.lean`). -/
+def defaultLeanConfigFile : FilePath := defaultConfigFile |>.addExtension "lean"
+
+/-- The default name of the TOML Lake configuration file (i.e., `lakefile.toml`). -/
+def defaultTomlConfigFile : FilePath := defaultConfigFile |>.addExtension "toml"
 
 /-- The default name of the Lake manifest file (i.e., `lake-manifest.json`). -/
 def defaultManifestFile : FilePath := "lake-manifest.json"
diff --git a/src/lake/Lake/Config/Glob.lean b/src/lake/Lake/Config/Glob.lean
index bb05ad3770..26637af7e7 100644
--- a/src/lake/Lake/Config/Glob.lean
+++ b/src/lake/Lake/Config/Glob.lean
@@ -19,12 +19,28 @@ inductive Glob
   | submodules : Name → Glob
   /-- Selects the specified module and all submodules. -/
   | andSubmodules : Name → Glob
-deriving Inhabited, Repr
+deriving Inhabited, Repr, DecidableEq
 
 instance : Coe Name Glob := ⟨Glob.one⟩
+instance : Coe Glob (Array Glob) := ⟨Array.singleton⟩
+
+/-- A name glob which matches all names with the prefix, including itself. -/
+scoped macro:max n:name noWs ".*" : term =>
+  ``(Glob.andSubmodules $(⟨Lean.mkNode `Lean.Parser.Term.quotedName #[n]⟩))
+
+/-- A name glob which matches all names with the prefix, but not the prefix itself. -/
+scoped macro:max n:name noWs ".+" : term =>
+  ``(Glob.submodules $(⟨Lean.mkNode `Lean.Parser.Term.quotedName #[n]⟩))
 
 namespace Glob
 
+protected def toString : Glob → String
+| .one n => n.toString
+| .submodules n => n.toString ++ ".+"
+| .andSubmodules n => n.toString ++ ".*"
+
+instance : ToString Glob := ⟨Glob.toString⟩
+
 def «matches» (m : Name) : (self : Glob) → Bool
 | one n => n == m
 | submodules n => n.isPrefixOf m && n != m
diff --git a/src/lake/Lake/Config/Lang.lean b/src/lake/Lake/Config/Lang.lean
new file mode 100644
index 0000000000..c831a7e036
--- /dev/null
+++ b/src/lake/Lake/Config/Lang.lean
@@ -0,0 +1,24 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+namespace Lake
+
+/-- Lake configuration language identifier. -/
+inductive ConfigLang
+| lean | toml
+deriving Repr, DecidableEq
+
+instance : Inhabited ConfigLang := ⟨.lean⟩
+
+def ConfigLang.ofString? : String → Option ConfigLang
+| "lean" => some .lean
+| "toml" => some .toml
+| _ => none
+
+def ConfigLang.fileExtension : ConfigLang → String
+| .lean => "lean"
+| .toml => "toml"
+
+instance : ToString ConfigLang := ⟨ConfigLang.fileExtension⟩
diff --git a/src/lake/Lake/Config/LeanConfig.lean b/src/lake/Lake/Config/LeanConfig.lean
index f1135d35a5..464b9907f6 100644
--- a/src/lake/Lake/Config/LeanConfig.lean
+++ b/src/lake/Lake/Config/LeanConfig.lean
@@ -61,7 +61,24 @@ inductive Backend
   Use the default backend. Can be overridden by more specific configuration.
   -/
   | default
-deriving Inhabited, Repr, DecidableEq
+deriving Repr, DecidableEq
+
+instance : Inhabited Backend := ⟨.default⟩
+
+def Backend.ofString? (s : String) : Option Backend :=
+  match s with
+  | "c" => some .c
+  | "llvm" => some .llvm
+  | "default" => some .default
+  | _ => none
+
+protected def Backend.toString (bt : Backend) : String :=
+  match bt with
+  | .c => "c"
+  | .llvm => "llvm"
+  | .default => "default"
+
+instance : ToString Backend := ⟨Backend.toString⟩
 
 /--
 If the left backend is default, choose the right one.
@@ -74,7 +91,6 @@ def Backend.orPreferLeft : Backend → Backend → Backend
 | .default, b => b
 | b, _ => b
 
-
 /-- The arguments to pass to `leanc` based on the build type. -/
 def BuildType.leancArgs : BuildType → Array String
 | debug => #["-Og", "-g"]
@@ -82,6 +98,23 @@ def BuildType.leancArgs : BuildType → Array String
 | minSizeRel => #["-Os", "-DNDEBUG"]
 | release => #["-O3", "-DNDEBUG"]
 
+def BuildType.ofString? (s : String) : Option BuildType :=
+  match s with
+  | "debug" => some .debug
+  | "relWithDebInfo" => some .relWithDebInfo
+  | "minSizeRel" => some .minSizeRel
+  | "release" => some .release
+  | _ => none
+
+protected def BuildType.toString (bt : BuildType) : String :=
+  match bt with
+  | .debug => "debug"
+  | .relWithDebInfo => "relWithDebInfo"
+  | .minSizeRel => "minSizeRel"
+  | .release => "release"
+
+instance : ToString BuildType := ⟨BuildType.toString⟩
+
 /-- Option that is used by Lean as if it was passed using `-D`. -/
 structure LeanOption where
   name  : Lean.Name
diff --git a/src/lake/Lake/Config/Package.lean b/src/lake/Lake/Config/Package.lean
index 34e30c4090..ec04c7530e 100644
--- a/src/lake/Lake/Config/Package.lean
+++ b/src/lake/Lake/Config/Package.lean
@@ -27,6 +27,11 @@ Currently used for package and target names taken from the CLI.
 def stringToLegalOrSimpleName (s : String) : Name :=
   if s.toName.isAnonymous then Lean.Name.mkSimple s else s.toName
 
+
+/-- The default `buildArchive` configuration for a package with `name`. -/
+@[inline] def defaultBuildArchive (name : Name) : String :=
+  s!"{name.toString false}-{System.Platform.target}.tar.gz"
+
 --------------------------------------------------------------------------------
 /-! # PackageConfig -/
 --------------------------------------------------------------------------------
@@ -141,8 +146,7 @@ structure PackageConfig extends WorkspaceConfig, LeanConfig where
   Defaults to `{(pkg-)name}-{System.Platform.target}.tar.gz`.
   -/
   buildArchive : String :=
-    if let some name := buildArchive? then name else
-    s!"{name.toString false}-{System.Platform.target}.tar.gz"
+    if let some name := buildArchive? then name else defaultBuildArchive name
 
   /--
   Whether to prefer downloading a prebuilt release (from GitHub) rather than
@@ -167,18 +171,16 @@ structure Package where
   relDir : FilePath
   /-- The package's user-defined configuration. -/
   config : PackageConfig
-  /-- The elaboration environment of the package's configuration file. -/
-  configEnv : Environment
-  /-- The Lean `Options` the package configuration was elaborated with. -/
-  leanOpts : Options
-  /-- The path to the package's configuration file. -/
-  configFile : FilePath
+  /-- The path to the package's configuration file (relative to `dir`). -/
+  relConfigFile : FilePath
   /-- The path to the package's JSON manifest of remote dependencies (relative to `dir`). -/
   relManifestFile : FilePath := config.manifestFile.getD defaultManifestFile
   /-- The URL to this package's Git remote. -/
   remoteUrl? : Option String := none
   /-- (Opaque references to) the package's direct dependencies. -/
   opaqueDeps : Array OpaquePackage := #[]
+  /-- Dependency configurations for the package. -/
+  depConfigs : Array Dependency := #[]
   /-- Lean library configurations for the package. -/
   leanLibConfigs : OrdNameMap LeanLibConfig := {}
   /-- Lean binary executable configurations for the package. -/
@@ -271,6 +273,10 @@ namespace Package
 @[inline] def pkgsDir (self : Package) : FilePath :=
   self.dir / self.relPkgsDir
 
+/-- The full path to the package's configuration file. -/
+@[inline] def configFile (self : Package) : FilePath :=
+  self.dir / self.relConfigFile
+
 /-- The path to the package's JSON manifest of remote dependencies. -/
 @[inline] def manifestFile (self : Package) : FilePath :=
   self.dir / self.relManifestFile
diff --git a/src/lake/Lake/Config/WorkspaceConfig.lean b/src/lake/Lake/Config/WorkspaceConfig.lean
index 5c11972903..b5250d9536 100644
--- a/src/lake/Lake/Config/WorkspaceConfig.lean
+++ b/src/lake/Lake/Config/WorkspaceConfig.lean
@@ -12,7 +12,7 @@ namespace Lake
 structure WorkspaceConfig where
   /--
   The directory to which Lake should download remote dependencies.
-  Defaults to `defaultLakeDir / defaultPackagesDir` (i.e., `.lake/packages`).
+  Defaults to `defaultPackagesDir` (i.e., `.lake/packages`).
   -/
-  packagesDir : FilePath := defaultLakeDir / defaultPackagesDir
+  packagesDir : FilePath := defaultPackagesDir
   deriving Inhabited, Repr
diff --git a/src/lake/Lake/DSL/DeclUtil.lean b/src/lake/Lake/DSL/DeclUtil.lean
index d9183e7fc2..a2a86c79ee 100644
--- a/src/lake/Lake/DSL/DeclUtil.lean
+++ b/src/lake/Lake/DSL/DeclUtil.lean
@@ -25,8 +25,11 @@ def expandAttrs (attrs? : Option Attributes) : Array AttrInstance :=
   else
     #[]
 
+/-- A single field assignment in a declarative configuration. -/
 syntax declField :=
-  ident ":=" term
+  ident " := " term
+
+@[inherit_doc declField] abbrev DeclField := TSyntax ``declField
 
 syntax structVal :=
   "{" manyIndent(group(declField ", "?)) "}"
diff --git a/src/lake/Lake/DSL/Meta.lean b/src/lake/Lake/DSL/Meta.lean
index c58b9113b3..91cb3540bd 100644
--- a/src/lake/Lake/DSL/Meta.lean
+++ b/src/lake/Lake/DSL/Meta.lean
@@ -5,6 +5,7 @@ Authors: Mac Malone
 -/
 import Lean.Elab.Eval
 import Lean.Elab.ElabRules
+import Lake.Util.FilePath
 
 /-!
 Syntax for elaboration time control flow.
@@ -95,10 +96,3 @@ def elabRunIO : TermElab := fun stx expectedType? =>
     | .ok x => return x
     | .error e => throwErrorAt tk e.toString
   | _ => Elab.throwUnsupportedSyntax
-
-/-! ## ToExpr Instances -/
-
-instance : ToExpr System.FilePath where
-  toExpr p := mkApp (mkConst ``System.FilePath.mk) (toExpr p.toString)
-  toTypeExpr := mkConst ``System.FilePath
-
diff --git a/src/lake/Lake/DSL/Package.lean b/src/lake/Lake/DSL/Package.lean
index 7c1941ca7b..41a73e8b45 100644
--- a/src/lake/Lake/DSL/Package.lean
+++ b/src/lake/Lake/DSL/Package.lean
@@ -37,6 +37,11 @@ doc?:optional(docComment) attrs?:optional(Term.attributes)
   let attrs := #[attr] ++ expandAttrs attrs?
   mkConfigDecl packageDeclName doc? attrs ty sig
 
+abbrev PackageDecl := TSyntax ``packageDecl
+
+instance : Coe PackageDecl Command where
+  coe x := ⟨x.raw⟩
+
 
 /--
 Declare a post-`lake update` hook for the package.
diff --git a/src/lake/Lake/DSL/Require.lean b/src/lake/Lake/DSL/Require.lean
index c4a6921566..0db58f28c5 100644
--- a/src/lake/Lake/DSL/Require.lean
+++ b/src/lake/Lake/DSL/Require.lean
@@ -55,3 +55,8 @@ required to disambiguate the syntax).
 -/
 scoped macro (name := requireDecl) "require " spec:depSpec : command =>
   expandDepSpec spec
+
+@[inherit_doc requireDecl] abbrev RequireDecl := TSyntax ``requireDecl
+
+instance : Coe RequireDecl Command where
+  coe x := ⟨x.raw⟩
diff --git a/src/lake/Lake/DSL/Targets.lean b/src/lake/Lake/DSL/Targets.lean
index dc00363f54..fa81a62bf7 100644
--- a/src/lake/Lake/DSL/Targets.lean
+++ b/src/lake/Lake/DSL/Targets.lean
@@ -163,6 +163,11 @@ doc?:optional(docComment) attrs?:optional(Term.attributes)
   let attrs := #[attr] ++ expandAttrs attrs?
   mkConfigDecl none doc? attrs ty sig
 
+@[inherit_doc leanLibDecl] abbrev LeanLibDecl := TSyntax ``leanLibDecl
+
+instance : Coe LeanLibDecl Command where
+  coe x := ⟨x.raw⟩
+
 /--
 Define a new Lean binary executable target for the package.
 Can optionally be provided with a configuration of type `LeanExeConfig`.
@@ -182,6 +187,10 @@ doc?:optional(docComment) attrs?:optional(Term.attributes)
   let attrs := #[attr] ++ expandAttrs attrs?
   mkConfigDecl none doc? attrs ty sig
 
+@[inherit_doc leanExeDecl] abbrev LeanExeDecl := TSyntax ``leanExeDecl
+
+instance : Coe LeanExeDecl Command where
+  coe x := ⟨x.raw⟩
 
 --------------------------------------------------------------------------------
 /-! ## External Library Target Declaration                                    -/
diff --git a/src/lake/Lake/Load/Config.lean b/src/lake/Lake/Load/Config.lean
index c6ad9cd4c9..2de9c24661 100644
--- a/src/lake/Lake/Load/Config.lean
+++ b/src/lake/Lake/Load/Config.lean
@@ -15,14 +15,30 @@ open System Lean
 /-- Context for loading a Lake configuration. -/
 structure LoadConfig where
   /-- The Lake environment of the load process. -/
-  env : Lake.Env
-  /-- The root directory of the loaded package (and its workspace). -/
-  rootDir : FilePath
-  /-- The Lean file with the package's Lake configuration (e.g., `lakefile.lean`) -/
-  configFile : FilePath := rootDir / defaultConfigFile
+  lakeEnv : Lake.Env
+  /-- The root directory of the Lake workspace. -/
+  wsDir : FilePath
+  /-- The directory of the loaded package (relative to the root). -/
+  relPkgDir : FilePath := "."
+  /-- The package's Lake configuration file (relative to the package directory). -/
+  relConfigFile : FilePath := defaultConfigFile
   /-- A set of key-value Lake configuration options (i.e., `-K` settings). -/
-  configOpts : NameMap String := {}
+  lakeOpts : NameMap String := {}
   /-- The Lean options with which to elaborate the configuration file. -/
   leanOpts : Options := {}
-  /-- If true, Lake will elaborate configuration files instead of using OLeans. -/
+  /-- If `true`, Lake will elaborate configuration files instead of using OLeans. -/
   reconfigure : Bool := false
+  /-- The URL to this package's Git remote (if any). -/
+  remoteUrl? : Option String := none
+
+/-- The full path to loaded package's directory. -/
+@[inline] def LoadConfig.pkgDir (cfg : LoadConfig) : FilePath :=
+  cfg.wsDir / cfg.relPkgDir
+
+/-- The full path to loaded package's configuration file. -/
+@[inline] def LoadConfig.configFile (cfg : LoadConfig) : FilePath :=
+  cfg.pkgDir / cfg.relConfigFile
+
+/-- The package's Lake directory (for Lake temporary files). -/
+@[inline] def LoadConfig.lakeDir (cfg : LoadConfig) : FilePath :=
+  cfg.pkgDir / defaultLakeDir
diff --git a/src/lake/Lake/Load/Elab.lean b/src/lake/Lake/Load/Elab.lean
index c3f64016d1..c1ba7e5467 100644
--- a/src/lake/Lake/Load/Elab.lean
+++ b/src/lake/Lake/Load/Elab.lean
@@ -42,7 +42,7 @@ def configModuleName : Name := `lakefile
 
 /-- Elaborate `configFile` with the given package directory and options. -/
 def elabConfigFile (pkgDir : FilePath) (lakeOpts : NameMap String)
-(leanOpts := Options.empty) (configFile := pkgDir / defaultConfigFile) : LogIO Environment := do
+(leanOpts := Options.empty) (configFile := pkgDir / defaultLeanConfigFile) : LogIO Environment := do
 
   -- Read file and initialize environment
   let input ← IO.FS.readFile configFile
@@ -156,13 +156,12 @@ Import the `.olean` for the configuration file if `reconfigure` is not set and
 an up-to-date one exists (i.e., one with matching configuration and on the same
 toolchain). Otherwise, elaborate the configuration and save it to the `.olean`.
 -/
-def importConfigFile (pkgDir lakeDir : FilePath) (lakeEnv : Lake.Env) (lakeOpts : NameMap String)
-(leanOpts := Options.empty) (configFile := pkgDir / defaultConfigFile) (reconfigure := true) : LogIO Environment := do
-  let some configName := FilePath.mk <$> configFile.fileName
+def importConfigFile (cfg : LoadConfig) : LogIO Environment := do
+  let some configName := FilePath.mk <$> cfg.configFile.fileName
     | error "invalid configuration file name"
-  let olean := lakeDir / configName.withExtension "olean"
-  let traceFile := lakeDir / configName.withExtension "olean.trace"
-  let lockFile := lakeDir / configName.withExtension "olean.lock"
+  let olean := cfg.lakeDir / configName.withExtension "olean"
+  let traceFile := cfg.lakeDir / configName.withExtension "olean.trace"
+  let lockFile := cfg.lakeDir / configName.withExtension "olean.lock"
   /-
   Remark:
   To prevent race conditions between the `.olean` and its trace file
@@ -206,7 +205,7 @@ def importConfigFile (pkgDir lakeDir : FilePath) (lakeEnv : Lake.Env) (lakeOpts
       h.unlock
       error <| s!"could not acquire an exclusive configuration lock; " ++
         "another process may already be reconfiguring the package"
-  let configHash ← computeTextFileHash configFile
+  let configHash ← computeTextFileHash cfg.configFile
   let elabConfig h (lakeOpts : NameMap String) : LogIO Environment := id do
     /-
     Remark:
@@ -222,10 +221,10 @@ def importConfigFile (pkgDir lakeDir : FilePath) (lakeEnv : Lake.Env) (lakeOpts
     match (← IO.FS.removeFile olean |>.toBaseIO) with
     | .ok _ | .error (.noFileOrDirectory ..) =>
       h.putStrLn <| Json.pretty <| toJson
-        {platform := System.Platform.target, leanHash := lakeEnv.leanGithash,
+        {platform := System.Platform.target, leanHash := cfg.lakeEnv.leanGithash,
           configHash, options := lakeOpts : ConfigTrace}
       h.truncate
-      let env ← elabConfigFile pkgDir lakeOpts leanOpts configFile
+      let env ← elabConfigFile cfg.pkgDir lakeOpts cfg.leanOpts cfg.configFile
       Lean.writeModule env olean
       h.unlock
       return env
@@ -235,8 +234,8 @@ def importConfigFile (pkgDir lakeDir : FilePath) (lakeEnv : Lake.Env) (lakeOpts
       IO.FS.removeFile traceFile
       failure
   let validateTrace h : LogIO Environment := id do
-    if reconfigure then
-      elabConfig (← acquireTrace h) lakeOpts
+    if cfg.reconfigure then
+      elabConfig (← acquireTrace h) cfg.lakeOpts
     else
       h.lock (exclusive := false)
       let contents ← h.readToEnd
@@ -244,9 +243,9 @@ def importConfigFile (pkgDir lakeDir : FilePath) (lakeEnv : Lake.Env) (lakeOpts
         | error "compiled configuration is invalid; run with '-R' to reconfigure"
       let upToDate :=
         (← olean.pathExists) ∧ trace.platform = System.Platform.target ∧
-        trace.leanHash = lakeEnv.leanGithash ∧ trace.configHash = configHash
+        trace.leanHash = cfg.lakeEnv.leanGithash ∧ trace.configHash = configHash
       if upToDate then
-        let env ← importConfigFileCore olean leanOpts
+        let env ← importConfigFileCore olean cfg.leanOpts
         h.unlock
         return env
       else
@@ -254,10 +253,10 @@ def importConfigFile (pkgDir lakeDir : FilePath) (lakeEnv : Lake.Env) (lakeOpts
   if (← traceFile.pathExists) then
     validateTrace <| ← IO.FS.Handle.mk traceFile .read
   else
-    IO.FS.createDirAll lakeDir
+    IO.FS.createDirAll cfg.lakeDir
     match (← IO.FS.Handle.mk traceFile .writeNew |>.toBaseIO) with
     | .ok h =>
-      h.lock; elabConfig h lakeOpts
+      h.lock; elabConfig h cfg.lakeOpts
     | .error (.alreadyExists ..) =>
       validateTrace <| ← IO.FS.Handle.mk traceFile .read
     | .error e => error e.toString
diff --git a/src/lake/Lake/Load/Main.lean b/src/lake/Lake/Load/Main.lean
index 658a99aea6..a467ecd7fb 100644
--- a/src/lake/Lake/Load/Main.lean
+++ b/src/lake/Lake/Load/Main.lean
@@ -13,6 +13,7 @@ import Lake.Build.Library
 import Lake.Load.Materialize
 import Lake.Load.Package
 import Lake.Load.Elab
+import Lake.Load.Toml
 
 open System Lean
 
@@ -22,76 +23,115 @@ The main definitions for loading a workspace and resolving dependencies.
 
 namespace Lake
 
-/-- Load the tagged `Dependency` definitions from a package configuration environment. -/
-def loadDepsFromEnv (env : Environment) (opts : Options) : Except String (Array Dependency) := do
-  (packageDepAttr.getAllEntries env).mapM (evalConstCheck env opts Dependency ``Dependency)
-
 /--
-Elaborate a dependency's configuration file into a `Package`.
+Elaborate a dependency's Lean configuration file into a `Package`.
 The resulting package does not yet include any dependencies.
 -/
-def MaterializedDep.loadPackage (dep : MaterializedDep)
-(wsDir : FilePath) (lakeEnv : Lake.Env) (leanOpts : Options) (reconfigure : Bool) : LogIO Package := do
-  let dir := wsDir / dep.relPkgDir
-  let lakeDir := dir / defaultLakeDir
-  let configEnv ← importConfigFile dir lakeDir lakeEnv dep.configOpts leanOpts (dir / dep.configFile) reconfigure
-  let config ← IO.ofExcept <| PackageConfig.loadFromEnv configEnv leanOpts
-  return {
-    dir
-    relDir := dep.relPkgDir
-    config, configEnv, leanOpts
-    configFile := dep.configFile
+def loadLeanConfig (cfg : LoadConfig)
+: LogIO (Package × Environment) := do
+  let configEnv ← importConfigFile cfg
+  let pkgConfig ← IO.ofExcept <| PackageConfig.loadFromEnv configEnv cfg.leanOpts
+  let pkg : Package := {
+    dir := cfg.pkgDir
+    relDir := cfg.relPkgDir
+    config := pkgConfig
+    relConfigFile := cfg.relConfigFile
+    remoteUrl? := cfg.remoteUrl?
+  }
+  return (← pkg.loadFromEnv configEnv cfg.leanOpts, configEnv)
+
+/--
+Return whether a configuration file with the given name
+and/or a supported extension exists.
+-/
+def configFileExists (cfgFile : FilePath) : BaseIO Bool :=
+  if cfgFile.extension.isSome then
+    cfgFile.pathExists
+  else
+    let leanFile := cfgFile.addExtension "lean"
+    let tomlFile := cfgFile.addExtension "toml"
+    leanFile.pathExists <||> tomlFile.pathExists
+
+/-- Loads a Lake package configuration (either Lean or TOML). -/
+def loadPackage
+  (name : String) (cfg : LoadConfig)
+: LogIO (Package × Option Environment) := do
+  if let some ext := cfg.relConfigFile.extension then
+    unless (← cfg.configFile.pathExists) do
+      error s!"{name}: configuration file not found: {cfg.configFile}"
+    match ext with
+    | "lean" => (·.map id some) <$> loadLeanConfig cfg
+    | "toml" => ((·,none)) <$> loadTomlConfig cfg.pkgDir cfg.relPkgDir cfg.relConfigFile
+    | _ => error s!"{name}: configuration has unsupported file extension: {cfg.configFile}"
+  else
+    let relLeanFile := cfg.relConfigFile.addExtension "lean"
+    let relTomlFile := cfg.relConfigFile.addExtension "toml"
+    let leanFile := cfg.pkgDir / relLeanFile
+    let tomlFile := cfg.pkgDir / relTomlFile
+    let leanExists ← leanFile.pathExists
+    let tomlExists ← tomlFile.pathExists
+    if leanExists then
+      if tomlExists then
+        logInfo s!"{name}: {relLeanFile} and {relTomlFile} are both present; using {relLeanFile}"
+      (·.map id some) <$> loadLeanConfig {cfg with relConfigFile := relLeanFile}
+    else
+      if tomlExists then
+        ((·,none)) <$> loadTomlConfig cfg.pkgDir cfg.relPkgDir relTomlFile
+      else
+        error s!"{name}: no configuration file with a supported extension:\n{leanFile}\n{tomlFile}"
+
+/--
+Loads the package configuration of a materialized dependency.
+Adds the facets defined in the package to the `Workspace`.
+-/
+def loadDepPackage
+  (dep : MaterializedDep) (leanOpts : Options) (reconfigure : Bool)
+: StateT Workspace LogIO Package := fun ws => do
+  let name := dep.name.toString (escape := false)
+  let (pkg, env?) ← loadPackage name {
+    lakeEnv := ws.lakeEnv
+    wsDir := ws.dir
+    relPkgDir := dep.relPkgDir
+    relConfigFile := dep.configFile
+    lakeOpts := dep.configOpts
+    leanOpts
+    reconfigure
     remoteUrl? := dep.remoteUrl?
   }
+  if let some env := env? then
+    let ws ← IO.ofExcept <| ws.addFacetsFromEnv env leanOpts
+    return (pkg, ws)
+  else
+    return (pkg, ws)
 
 /--
 Load a `Workspace` for a Lake package by elaborating its configuration file.
 Does not resolve dependencies.
 -/
 def loadWorkspaceRoot (config : LoadConfig) : LogIO Workspace := do
-  Lean.searchPathRef.set config.env.leanSearchPath
-  let configEnv ← importConfigFile
-    config.rootDir (config.rootDir / defaultLakeDir) config.env
-    config.configOpts config.leanOpts config.configFile config.reconfigure
-  let pkgConfig ← IO.ofExcept <| PackageConfig.loadFromEnv configEnv config.leanOpts
-  let root := {
-    dir := config.rootDir
-    relDir := "."
-    config := pkgConfig
-    configEnv
-    leanOpts := config.leanOpts
-    configFile := config.configFile
-  }
-  return {
-    root, lakeEnv := config.env
+  Lean.searchPathRef.set config.lakeEnv.leanSearchPath
+  let (root, env?) ← loadPackage "[root]" config
+  let ws : Workspace := {
+    root, lakeEnv := config.lakeEnv
     moduleFacetConfigs := initModuleFacetConfigs
     packageFacetConfigs := initPackageFacetConfigs
     libraryFacetConfigs := initLibraryFacetConfigs
   }
+  if let some env := env? then
+    IO.ofExcept <| ws.addFacetsFromEnv env config.leanOpts
+  else
+    return ws
 
-/--
-Finalize the workspace's root and its transitive dependencies
-and add them to the workspace.
--/
-def Workspace.finalize (ws : Workspace) : LogIO Workspace := do
-  have : MonadStore Name Package (StateT Workspace LogIO) := {
-    fetch? := fun name => return (← get).findPackage? name
-    store := fun _ pkg => modify (·.addPackage pkg)
-  }
-  let (res, ws) ← EStateT.run ws do
-    buildTop (·.name) ws.root fun pkg load => do
-      let depPkgs ← pkg.deps.mapM load
-      set <| ← IO.ofExcept <| (← get).addFacetsFromEnv pkg.configEnv pkg.leanOpts
-      let pkg ← pkg.finalize depPkgs
-      return pkg
-  match res with
-  | Except.ok root =>
-    return {ws with root}
-  | Except.error cycle => do
+/-- Recursively visits a package dependency graph, avoiding cycles. -/
+private def resolveDepsAcyclic
+  [Monad m] [MonadError m]
+  (root : Package) (f : RecFetchFn Package α (CycleT Name m))
+: m α := do
+  match (← ExceptT.run <| recFetchAcyclic (·.name) f root []) with
+  | .ok s => pure s
+  | .error cycle =>
     let cycle := cycle.map (s!"  {·}")
-    error <|
-      s!"oops! dependency load cycle detected (this likely indicates a bug in Lake):\n" ++
-      "\n".intercalate cycle
+    error s!"dependency cycle detected:\n{"\n".intercalate cycle}"
 
 /--
 Rebuild the workspace's Lake manifest and materialize missing dependencies.
@@ -103,11 +143,15 @@ root dependencies. Otherwise, only update the root dependencies specified.
 
 If `reconfigure`, elaborate configuration files while updating, do not use OLeans.
 -/
-def Workspace.updateAndMaterialize (ws : Workspace)
-(toUpdate : NameSet := {}) (reconfigure := true) : LogIO Workspace := do
-  let res ← StateT.run (s := mkNameMap MaterializedDep) <|
-    StateT.run' (s := mkNameMap PackageEntry) <| EStateT.run' (mkNameMap Package) do
+def Workspace.updateAndMaterialize
+  (ws : Workspace) (leanOpts : Options := {})
+  (toUpdate : NameSet := {}) (reconfigure := true)
+: LogIO Workspace := do
+  let ((root, deps), ws) ←
+    StateT.run (s := ws) <| StateT.run (s := mkNameMap MaterializedDep) <|
+    StateT.run' (s := mkNameMap PackageEntry) <| StateT.run' (s := mkNameMap Package) do
     -- Use manifest versions of root packages that should not be updated
+    let rootName := ws.root.name.toString (escape := false)
     match (← Manifest.load ws.manifestFile |>.toBaseIO) with
     | .ok manifest =>
       unless toUpdate.isEmpty do
@@ -122,19 +166,18 @@ def Workspace.updateAndMaterialize (ws : Workspace)
             IO.FS.rename oldPkgsDir ws.pkgsDir
           if let .error e ← doRename.toBaseIO then
             error <|
-              s!"{ws.root.name}: could not rename packages directory " ++
+              s!"{rootName}: could not rename packages directory " ++
               s!"({oldPkgsDir} -> {ws.pkgsDir}): {e}"
     | .error (.noFileOrDirectory ..) =>
-      logInfo s!"{ws.root.name}: no previous manifest, creating one from scratch"
+      logInfo s!"{rootName}: no previous manifest, creating one from scratch"
     | .error e =>
       unless toUpdate.isEmpty do
         liftM (m := IO) <| throw e -- only ignore manifest on a bare `lake update`
-      logWarning s!"{ws.root.name}: ignoring previous manifest because it failed to load: {e}"
-    buildAcyclic (·.name) ws.root fun pkg resolve => do
+      logWarning s!"{rootName}: ignoring previous manifest because it failed to load: {e}"
+    resolveDepsAcyclic ws.root fun pkg resolve => do
       let inherited := pkg.name != ws.root.name
       -- Materialize this package's dependencies first
-      let deps ← IO.ofExcept <| loadDepsFromEnv pkg.configEnv pkg.leanOpts
-      let deps ← deps.mapM fun dep => fetchOrCreate dep.name do
+      let deps ← pkg.depConfigs.mapM fun dep => fetchOrCreate dep.name do
         if let some entry := (← getThe (NameMap PackageEntry)).find? dep.name then
           entry.materialize dep ws.dir ws.relPkgsDir ws.lakeEnv.pkgUrlMap
         else
@@ -145,7 +188,7 @@ def Workspace.updateAndMaterialize (ws : Workspace)
           return pkg
         else
           -- Load the package
-          let depPkg ← dep.loadPackage ws.dir ws.lakeEnv pkg.leanOpts reconfigure
+          let depPkg ← liftM <| loadDepPackage dep leanOpts reconfigure
           if depPkg.name ≠ dep.name then
             logWarning s!"{pkg.name}: package '{depPkg.name}' was required as '{dep.name}'"
           -- Materialize locked dependencies
@@ -162,46 +205,47 @@ def Workspace.updateAndMaterialize (ws : Workspace)
           modifyThe (NameMap Package) (·.insert dep.name depPkg)
           return depPkg
       -- Resolve dependencies's dependencies recursively
-      return {pkg with opaqueDeps := ← deps.mapM (.mk <$> resolve ·)}
-  match res with
-  | (.ok root, deps) =>
-    let ws : Workspace ← {ws with root}.finalize
-    let manifest : Manifest := {
-      name := ws.root.name
-      lakeDir := ws.relLakeDir
-      packagesDir? := ws.relPkgsDir
-    }
-    let manifest := ws.packages.foldl (init := manifest) fun manifest pkg =>
-      match deps.find? pkg.name with
-      | some dep => manifest.addPackage <|
-        dep.manifestEntry.setManifestFile pkg.relManifestFile
-      | none => manifest -- should only be the case for the root
-    manifest.saveToFile ws.manifestFile
-    LakeT.run ⟨ws⟩ <| ws.packages.forM fun pkg => do
-      unless pkg.postUpdateHooks.isEmpty do
-        logInfo s!"{pkg.name}: running post-update hooks"
-        pkg.postUpdateHooks.forM fun hook => hook.get.fn pkg
-    return ws
-  | (.error cycle, _) =>
-    let cycle := cycle.map (s!"  {·}")
-    error s!"dependency cycle detected:\n{"\n".intercalate cycle}"
+      let pkg := {pkg with opaqueDeps := ← deps.mapM (.mk <$> resolve ·)}
+      modifyThe Workspace (·.addPackage pkg)
+      return pkg
+  let ws : Workspace := {ws with root}
+  let manifest : Manifest := {
+    name := ws.root.name
+    lakeDir := ws.relLakeDir
+    packagesDir? := ws.relPkgsDir
+  }
+  let manifest := ws.packages.foldl (init := manifest) fun manifest pkg =>
+    match deps.find? pkg.name with
+    | some dep => manifest.addPackage <|
+      dep.manifestEntry.setManifestFile pkg.relManifestFile |>.setConfigFile pkg.relConfigFile
+    | none => manifest -- should only be the case for the root
+  manifest.saveToFile ws.manifestFile
+  LakeT.run ⟨ws⟩ <| ws.packages.forM fun pkg => do
+    unless pkg.postUpdateHooks.isEmpty do
+      logInfo s!"{pkg.name}: running post-update hooks"
+      pkg.postUpdateHooks.forM fun hook => hook.get.fn pkg
+  return ws
 
 /--
 Resolving a workspace's dependencies using a manifest,
 downloading and/or updating them as necessary.
 -/
-def Workspace.materializeDeps (ws : Workspace) (manifest : Manifest) (reconfigure := false) : LogIO Workspace := do
-  if !manifest.packages.isEmpty && manifest.packagesDir? != some (normalizePath ws.relPkgsDir) then
+def Workspace.materializeDeps
+  (ws : Workspace) (manifest : Manifest)
+  (leanOpts : Options := {}) (reconfigure := false)
+: LogIO Workspace := do
+  if !manifest.packages.isEmpty && manifest.packagesDir? != some (mkRelPathString ws.relPkgsDir) then
     logWarning <|
       "manifest out of date: packages directory changed; " ++
       "use `lake update` to rebuild the manifest (warning: this will update ALL workspace dependencies)"
   let relPkgsDir := manifest.packagesDir?.getD ws.relPkgsDir
   let pkgEntries := manifest.packages.foldl (init := mkNameMap PackageEntry)
     fun map entry => map.insert entry.name entry
-  let res ← EStateT.run' (mkNameMap Package) do
-    buildAcyclic (·.name) ws.root fun pkg resolve => do
-      let topLevel := pkg.name = ws.root.name
-      let deps ← IO.ofExcept <| loadDepsFromEnv pkg.configEnv pkg.leanOpts
+  let rootPkg := ws.root
+  let (root, ws) ← StateT.run (s := ws) <| StateT.run' (s := mkNameMap Package) do
+    resolveDepsAcyclic rootPkg fun pkg resolve => do
+      let topLevel := pkg.name = rootPkg.name
+      let deps := pkg.depConfigs
       if topLevel then
         if manifest.packages.isEmpty && !deps.isEmpty then
           error "missing manifest; use `lake update` to generate one"
@@ -219,8 +263,9 @@ def Workspace.materializeDeps (ws : Workspace) (manifest : Manifest) (reconfigur
           | _, _ => warnOutOfDate "source kind (git/path)"
       let depPkgs ← deps.mapM fun dep => fetchOrCreate dep.name do
         if let some entry := pkgEntries.find? dep.name then
+          let ws ← getThe Workspace
           let result ← entry.materialize dep ws.dir relPkgsDir ws.lakeEnv.pkgUrlMap
-          result.loadPackage ws.dir ws.lakeEnv pkg.leanOpts reconfigure
+          liftM <| loadDepPackage result leanOpts reconfigure
         else if topLevel then
           error <|
             s!"dependency '{dep.name}' not in manifest; " ++
@@ -230,13 +275,10 @@ def Workspace.materializeDeps (ws : Workspace) (manifest : Manifest) (reconfigur
             s!"dependency '{dep.name}' of '{pkg.name}' not in manifest; " ++
             "this suggests that the manifest is corrupt;" ++
             "use `lake update` to generate a new, complete file (warning: this will update ALL workspace dependencies)"
-      return {pkg with opaqueDeps := ← depPkgs.mapM (.mk <$> resolve ·)}
-  match res with
-  | Except.ok root =>
-    ({ws with root}).finalize
-  | Except.error cycle =>
-    let cycle := cycle.map (s!"  {·}")
-    error s!"dependency cycle detected:\n{"\n".intercalate cycle}"
+      let pkg := {pkg with opaqueDeps := ← depPkgs.mapM (.mk <$> resolve ·)}
+      modifyThe Workspace (·.addPackage pkg)
+      return pkg
+  return {ws with root}
 
 /--
 Load a `Workspace` for a Lake package by
@@ -245,16 +287,18 @@ If `updateDeps` is true, updates the manifest before resolving dependencies.
 -/
 def loadWorkspace (config : LoadConfig) (updateDeps := false) : LogIO Workspace := do
   let rc := config.reconfigure
+  let leanOpts := config.leanOpts
   let ws ← loadWorkspaceRoot config
   if updateDeps then
-    ws.updateAndMaterialize {} rc
+    ws.updateAndMaterialize leanOpts {} rc
   else if let some manifest ← Manifest.load? ws.manifestFile then
-    ws.materializeDeps manifest rc
+    ws.materializeDeps manifest leanOpts rc
   else
-    ws.updateAndMaterialize {} rc
+    ws.updateAndMaterialize leanOpts {} rc
 
 /-- Updates the manifest for the loaded Lake workspace (see `updateAndMaterialize`). -/
 def updateManifest (config : LoadConfig) (toUpdate : NameSet := {}) : LogIO Unit := do
   let rc := config.reconfigure
+  let leanOpts := config.leanOpts
   let ws ← loadWorkspaceRoot config
-  discard <| ws.updateAndMaterialize toUpdate rc
+  discard <| ws.updateAndMaterialize leanOpts toUpdate rc
diff --git a/src/lake/Lake/Load/Manifest.lean b/src/lake/Lake/Load/Manifest.lean
index ab077fef29..fa8cce314c 100644
--- a/src/lake/Lake/Load/Manifest.lean
+++ b/src/lake/Lake/Load/Manifest.lean
@@ -5,6 +5,7 @@ Authors: Mac Malone, Gabriel Ebner
 -/
 import Lake.Util.Log
 import Lake.Util.Name
+import Lake.Util.FilePath
 import Lake.Load.Config
 import Lake.Config.Workspace
 
@@ -27,20 +28,6 @@ inductive PackageEntryV6
     (inputRev? : Option String) (subDir? : Option FilePath)
 deriving FromJson, ToJson, Inhabited
 
-/-- Set `/` as the path separator, even on Windows. -/
-def normalizePath (path : FilePath) : FilePath :=
-  if System.Platform.isWindows then
-    path.toString.map fun c => if c = '\\' then '/' else c
-  else
-    path.toString
-
-/--
-Use `/` and instead of `\\` in file paths
-when serializing the manifest on Windows.
--/
-local instance : ToJson FilePath where
-  toJson path := toJson <| normalizePath path
-
 /-- An entry for a package stored in the manifest. -/
 inductive PackageEntry
   /--
@@ -142,6 +129,12 @@ def setInherited : PackageEntry → PackageEntry
 @[inline] protected def manifestFile? : PackageEntry →  Option FilePath
 | .path (manifestFile? := manifestFile?) .. | .git (manifestFile? := manifestFile?) .. => manifestFile?
 
+def setConfigFile (path : FilePath) : PackageEntry → PackageEntry
+| .path name inherited _ manifestFile? dir =>
+  .path name inherited path manifestFile? dir
+| .git name inherited _ manifestFile? url rev inputRev? subDir? =>
+  .git name inherited path manifestFile? url rev inputRev? subDir?
+
 def setManifestFile (path? : Option FilePath) : PackageEntry → PackageEntry
 | .path name inherited configFile _ dir =>
   .path name inherited configFile path? dir
diff --git a/src/lake/Lake/Load/Package.lean b/src/lake/Lake/Load/Package.lean
index 7aa855e7fb..0a2f01647c 100644
--- a/src/lake/Lake/Load/Package.lean
+++ b/src/lake/Lake/Load/Package.lean
@@ -61,12 +61,13 @@ def PackageConfig.loadFromEnv
   evalConstCheck env opts _  ``PackageConfig declName
 
 /--
-Load the remainder of a `Package`
-from its configuration environment after resolving its dependencies.
+Load the optional elements of a `Package` from the Lean environment.
+This is done after loading its core configuration but before resolving
+its dependencies.
 -/
-def Package.finalize (self : Package) (deps : Array Package) : LogIO Package := do
-  let env := self.configEnv
-  let opts := self.leanOpts
+def Package.loadFromEnv
+  (self : Package) (env : Environment) (opts : Options)
+: LogIO Package := do
   let strName := self.name.toString (escape := false)
 
   -- Load Script, Facet, Target, and Hook Configurations
@@ -106,6 +107,8 @@ def Package.finalize (self : Package) (deps : Array Package) : LogIO Package :=
       else
         error s!"post-update hook was defined in `{decl.pkg}`, but was registered in `{self.name}`"
     | .error e => error e
+  let depConfigs ← IO.ofExcept <| packageDepAttr.getAllEntries env |>.mapM fun name =>
+    evalConstCheck env opts Dependency ``Dependency name
 
   -- Deprecation warnings
   unless self.config.manifestFile.isNone do
@@ -115,9 +118,8 @@ def Package.finalize (self : Package) (deps : Array Package) : LogIO Package :=
 
   -- Fill in the Package
   return {self with
-    opaqueDeps := deps.map (.mk ·)
-    leanLibConfigs, leanExeConfigs, externLibConfigs
-    opaqueTargetConfigs, defaultTargets, scripts, defaultScripts,
+    depConfigs, leanLibConfigs, leanExeConfigs, externLibConfigs
+    opaqueTargetConfigs, defaultTargets, scripts, defaultScripts
     postUpdateHooks
   }
 
diff --git a/src/lake/Lake/Load/Toml.lean b/src/lake/Lake/Load/Toml.lean
new file mode 100644
index 0000000000..876d941131
--- /dev/null
+++ b/src/lake/Lake/Load/Toml.lean
@@ -0,0 +1,276 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Toml.Load
+import Lake.Toml.Decode
+import Lake.Config.Package
+import Lake.Util.Log
+
+open Lean Parser
+
+/-! # TOML Loader
+
+Load a package from a TOML Lake configuration file.
+-/
+
+namespace Lake
+
+open Toml
+
+/-! ## Data Decoders -/
+
+def takeNamePart (ss : Substring) (pre : Name) : (Substring × Name) :=
+  if ss.isEmpty then
+    (ss, .anonymous)
+  else
+    let curr := ss.front
+    if isIdBeginEscape curr then
+      let ss := ss.drop 1
+      let startPos := ss.startPos
+      let ss := ss.dropWhile (!isIdEndEscape ·)
+      if isIdEndEscape ss.front then
+        let id := ss.str.extract startPos ss.startPos
+        (ss, Name.str pre id)
+      else
+        (ss, .anonymous)
+    else if isIdFirst curr then
+      let startPos := ss.startPos
+      let ss := ss.drop 1 |>.dropWhile isIdRest
+      let id := ss.str.extract startPos ss.startPos
+      (ss, Name.str pre id)
+    else if curr.isDigit then
+      let startPos := ss.startPos
+      let ss := ss.drop 1 |>.dropWhile Char.isDigit
+      let digits := ss.str.extract startPos ss.startPos
+      let n := (Syntax.decodeNatLitVal? digits).get!
+      (ss, Name.num pre n)
+    else
+      (ss, .anonymous)
+
+partial def takeName (ss : Substring) : (Substring × Name) :=
+  let rec takeRest ss pre :=
+    if ss.front == '.' then
+      let startPos := ss.startPos
+      let (ss, n) := takeNamePart (ss.drop 1) pre
+      if n.isAnonymous then ({ss with startPos}, pre) else takeRest ss n
+    else
+      (ss, pre)
+  let (ss, n) := takeNamePart ss .anonymous
+  if n.isAnonymous then (ss, .anonymous) else takeRest ss n
+
+def Glob.ofString? (v : String) : Option Glob := do
+  let (ss, n) := takeName v.toSubstring
+  if n.isAnonymous then failure
+  if h : ss.str.atEnd ss.startPos then
+    return .one n
+  else if ss.str.get' ss.startPos h == '.' then
+    match (ss.drop 1).front with
+    | '+' => return .submodules n
+    | '*' => return .andSubmodules n
+    | _ => failure
+  else
+    failure
+
+protected def Glob.decodeToml (v : Value) : Except DecodeError Glob := do
+  match inline <| Glob.ofString? (← v.decodeString) with
+  | some v => return v
+  | none => throw <| .mk v.ref "expected glob"
+
+instance : DecodeToml Glob := ⟨(Glob.decodeToml ·)⟩
+
+protected def LeanOptionValue.decodeToml : Value → Except DecodeError LeanOptionValue
+| .string _ v => return .ofString v
+| .boolean _ v => return .ofBool v
+| .integer _ (.ofNat v) => return .ofNat v
+| x => throw (.mk x.ref "expected string, boolean, or nonnegative integer")
+
+instance : DecodeToml LeanOptionValue := ⟨(LeanOptionValue.decodeToml ·)⟩
+
+protected def LeanOption.decodeToml (v : Value) : Except (Array DecodeError) LeanOption := do
+  match v with
+  | .array ref vs =>
+    if h : vs.size = 2 then ensureDecode do
+      let name : Name ← tryDecode <| decodeToml vs[0]
+      let value ← tryDecode <| decodeToml vs[1]
+      return {name, value}
+    else
+      throw #[.mk ref "expected array of size 2"]
+  | .table ref t => ensureDecode do
+    let name ← t.tryDecode `name ref
+    let value ← t.tryDecode `value ref
+    return {name, value}
+  | v =>
+    throw #[.mk v.ref "expected array or table"]
+
+instance : DecodeToml LeanOption := ⟨LeanOption.decodeToml⟩
+
+protected def BuildType.decodeToml (v : Value) : Except DecodeError BuildType := do
+  match inline <| BuildType.ofString? (← v.decodeString) with
+  | some v => return v
+  | none => throw <| .mk v.ref "expected one of 'debug', 'relWithDebInfo', 'minSizeRel', 'release'"
+
+instance : DecodeToml BuildType := ⟨(BuildType.decodeToml ·)⟩
+
+protected def Backend.decodeToml (v : Value) : Except DecodeError Backend := do
+  match inline <| Backend.ofString? (← v.decodeString) with
+  | some v => return v
+  | none => throw <| .mk v.ref "expected one of 'c', 'llvm', or 'default'"
+
+instance : DecodeToml Backend := ⟨(Backend.decodeToml ·)⟩
+
+partial def decodeLeanOptionsAux
+  (v : Value) (k : Name) (vs : Except (Array DecodeError) (Array LeanOption))
+: Except (Array DecodeError) (Array LeanOption) :=
+  match v with
+  | .table _ t => t.items.foldl (init := vs) fun vs (k',v) =>
+    decodeLeanOptionsAux v (k ++ k') vs
+  | v => mergeErrors vs (decodeToml v) fun vs v => vs.push ⟨k,v⟩
+
+def decodeLeanOptions (v : Value) : Except (Array DecodeError) (Array LeanOption) :=
+  match v with
+  | .array _ vs => decodeArray vs
+  | .table _ t => t.items.foldl (init := .ok #[]) fun vs (k,v) => decodeLeanOptionsAux v k vs
+  | v =>
+    throw #[.mk v.ref "expected array or table"]
+
+/-! ## Configuration Decoders -/
+
+protected def WorkspaceConfig.decodeToml (t : Table) : Except (Array DecodeError) WorkspaceConfig := ensureDecode do
+  let packagesDir ← t.tryDecodeD `packagesDir defaultPackagesDir
+  return {packagesDir}
+
+instance : DecodeToml WorkspaceConfig := ⟨fun v => do WorkspaceConfig.decodeToml (← v.decodeTable)⟩
+
+protected def LeanConfig.decodeToml (t : Table) : Except (Array DecodeError) LeanConfig := ensureDecode do
+  let buildType ← t.tryDecodeD `buildType .release
+  let backend ← t.tryDecodeD `backend .default
+  let platformIndependent ← t.tryDecode? `platformIndependent
+  let leanOptions ← optDecodeD #[] (t.find? `leanOptions) decodeLeanOptions
+  let moreServerOptions ← optDecodeD #[] (t.find? `moreServerOptions) decodeLeanOptions
+  let moreLeanArgs ← t.tryDecodeD `moreLeanArgs #[]
+  let weakLeanArgs ← t.tryDecodeD `weakLeanArgs #[]
+  let moreLeancArgs ← t.tryDecodeD `moreLeancArgs #[]
+  let weakLeancArgs ← t.tryDecodeD `weakLeancArgs #[]
+  let moreLinkArgs ← t.tryDecodeD `moreLinkArgs #[]
+  let weakLinkArgs ← t.tryDecodeD `weakLinkArgs #[]
+  return {
+    buildType, backend, platformIndependent, leanOptions, moreServerOptions,
+    moreLeanArgs, weakLeanArgs, moreLeancArgs, weakLeancArgs, moreLinkArgs, weakLinkArgs
+  }
+
+instance : DecodeToml LeanConfig := ⟨fun v => do LeanConfig.decodeToml (← v.decodeTable)⟩
+
+protected def PackageConfig.decodeToml (t : Table) (ref := Syntax.missing) : Except (Array DecodeError) PackageConfig := ensureDecode do
+  let name ← stringToLegalOrSimpleName <$> t.tryDecode `name ref
+  let precompileModules ← t.tryDecodeD `precompileModules false
+  let moreGlobalServerArgs ← t.tryDecodeD `moreGlobalServerArgs #[]
+  let srcDir ← t.tryDecodeD `srcDir "."
+  let buildDir ← t.tryDecodeD `buildDir defaultBuildDir
+  let leanLibDir ← t.tryDecodeD `leanLibDir defaultLeanLibDir
+  let nativeLibDir ← t.tryDecodeD `nativeLibDir defaultNativeLibDir
+  let binDir ← t.tryDecodeD `binDir defaultBinDir
+  let irDir ← t.tryDecodeD `irDir defaultIrDir
+  let releaseRepo ← t.tryDecode? `releaseRepo
+  let buildArchive? ← t.tryDecode? `buildArchive
+  let preferReleaseBuild ← t.tryDecodeD `preferReleaseBuild false
+  let toLeanConfig ← tryDecode <| LeanConfig.decodeToml t
+  let toWorkspaceConfig ← tryDecode <| WorkspaceConfig.decodeToml t
+  return {
+    name, precompileModules, moreGlobalServerArgs,
+    srcDir, buildDir, leanLibDir, nativeLibDir, binDir, irDir,
+    releaseRepo, buildArchive?, preferReleaseBuild
+    toLeanConfig, toWorkspaceConfig
+  }
+
+instance : DecodeToml PackageConfig := ⟨fun v => do PackageConfig.decodeToml (← v.decodeTable) v.ref⟩
+
+protected def LeanLibConfig.decodeToml (t : Table) (ref := Syntax.missing) : Except (Array DecodeError) LeanLibConfig := ensureDecode do
+  let name : Name ← t.tryDecode `name ref
+  let srcDir ← t.tryDecodeD `srcDir "."
+  let roots ← t.tryDecodeD `roots #[name]
+  let globs ← optDecodeD (roots.map Glob.one) (t.find? `globs) (·.decodeArrayOrSingleton)
+  let libName ← t.tryDecodeD `libName (name.toString (escape := false))
+  let precompileModules ← t.tryDecodeD `precompileModules false
+  let defaultFacets ← t.tryDecodeD `defaultFacets #[LeanLib.leanArtsFacet]
+  let toLeanConfig ← tryDecode <| LeanConfig.decodeToml t
+  return {
+    name, srcDir, roots, globs, libName,
+    precompileModules, defaultFacets, toLeanConfig
+  }
+
+instance : DecodeToml LeanLibConfig := ⟨fun v => do LeanLibConfig.decodeToml (← v.decodeTable) v.ref⟩
+
+protected def LeanExeConfig.decodeToml (t : Table) (ref := Syntax.missing) : Except (Array DecodeError) LeanExeConfig := ensureDecode do
+  let name ← stringToLegalOrSimpleName <$> t.tryDecode `name ref
+  let srcDir ← t.tryDecodeD `srcDir "."
+  let root ← t.tryDecodeD `root name
+  let exeName ← t.tryDecodeD `exeName (name.toStringWithSep "-" (escape := false))
+  let supportInterpreter ← t.tryDecodeD `supportInterpreter false
+  let toLeanConfig ← tryDecode <| LeanConfig.decodeToml t
+  return {name, srcDir, root, exeName, supportInterpreter, toLeanConfig}
+
+instance : DecodeToml LeanExeConfig := ⟨fun v => do LeanExeConfig.decodeToml (← v.decodeTable) v.ref⟩
+
+protected def Source.decodeToml (t : Table) (ref := Syntax.missing) : Except (Array DecodeError) Source := do
+  let typeVal ← t.decodeValue `type
+  match (← typeVal.decodeString) with
+  | "path" =>
+    return Source.path (← t.decode `dir)
+  | "git" => ensureDecode do
+    return Source.git (← t.tryDecode `url ref) (← t.tryDecode? `rev) (← t.tryDecode? `subDir)
+  | _ =>
+    throw #[DecodeError.mk typeVal.ref "expected one of 'path' or 'git'"]
+
+instance : DecodeToml Source := ⟨fun v => do Source.decodeToml (← v.decodeTable) v.ref⟩
+
+protected def Dependency.decodeToml (t : Table) (ref := Syntax.missing) : Except (Array DecodeError) Dependency := ensureDecode do
+  let name ← t.tryDecode `name ref
+  let src ← id do
+    if let some dir ← t.tryDecode? `path then
+      return Source.path dir
+    else if let some g := t.find? `git then
+      match g with
+      | .string _ url =>
+        return Source.git url (← t.tryDecode? `rev) (← t.tryDecode? `subDir)
+      | .table ref t =>
+        return Source.git (← t.tryDecode `url ref) (← t.tryDecode? `rev) (← t.tryDecode? `subDir)
+      | _ =>
+        modify (·.push <| .mk g.ref "expected string or table")
+        return default
+    else
+      t.tryDecode `source ref
+  let opts ← t.tryDecodeD `options {}
+  return {name, src, opts}
+
+instance : DecodeToml Dependency := ⟨fun v => do Dependency.decodeToml (← v.decodeTable) v.ref⟩
+
+/-! ## Root Loader -/
+
+def loadTomlConfig (dir relDir relConfigFile : FilePath) : LogIO Package := do
+  let configFile := dir / relConfigFile
+  let input ← IO.FS.readFile configFile
+  let ictx := mkInputContext input relConfigFile.toString
+  match (← loadToml ictx |>.toBaseIO) with
+  | .ok table =>
+    let (pkg, errs) := Id.run <| StateT.run (s := (#[] : Array DecodeError)) do
+      let config ← tryDecode <| PackageConfig.decodeToml table
+      let leanLibConfigs ← mkRBArray (·.name) <$> table.tryDecodeD `lean_lib #[]
+      let leanExeConfigs ← mkRBArray (·.name) <$> table.tryDecodeD `lean_exe #[]
+      let defaultTargets ← table.tryDecodeD `defaultTargets #[]
+      let depConfigs ← table.tryDecodeD `require #[]
+      return {
+        dir, relDir, relConfigFile,
+        config, depConfigs, leanLibConfigs, leanExeConfigs, defaultTargets
+      }
+    if errs.isEmpty then
+      return pkg
+    else
+      errs.forM fun {ref, msg} =>
+        let pos := ictx.fileMap.toPosition <| ref.getPos?.getD 0
+        logError <| mkErrorStringWithPos ictx.fileName pos msg
+      failure
+  | .error log =>
+    log.forM fun msg => do logError (← msg.toString)
+    failure
diff --git a/src/lake/Lake/Toml.lean b/src/lake/Lake/Toml.lean
new file mode 100644
index 0000000000..df3e653e59
--- /dev/null
+++ b/src/lake/Lake/Toml.lean
@@ -0,0 +1,6 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Toml.Load
diff --git a/src/lake/Lake/Toml/Data.lean b/src/lake/Lake/Toml/Data.lean
new file mode 100644
index 0000000000..04ef0bc181
--- /dev/null
+++ b/src/lake/Lake/Toml/Data.lean
@@ -0,0 +1,10 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Toml.Data.Value
+
+/-!
+# TOML Data Types
+-/
diff --git a/src/lake/Lake/Toml/Data/DateTime.lean b/src/lake/Lake/Toml/Data/DateTime.lean
new file mode 100644
index 0000000000..d201f3ce45
--- /dev/null
+++ b/src/lake/Lake/Toml/Data/DateTime.lean
@@ -0,0 +1,184 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+
+/-!
+# TOML Date-Time
+
+Defines data types for representing a TOML [date-time][1].
+TOML date-times are based on [IETF RFC 3339][2] with some components
+optionally left out, creating four distinct variants.
+
+* **Offset Date-Time**: A full RFC 3339 date-time.
+* **Local Date-Time**: An RFC 3339 date-time without the time zone.
+* **Local Date**: The date portion of an RFC 3339 date-time (year-month-day).
+* **Local Time**: The time portion of an RFC 3339 date-time (without time zone).
+
+[1]: https://toml.io/en/v1.0.0#offset-date-time
+[2]: https://datatracker.ietf.org/doc/html/rfc3339
+-/
+
+namespace Lake.Toml
+
+def lpad (s : String) (c : Char) (len : Nat) : String :=
+  "".pushn c (len - s.length) ++ s
+
+def rpad (s : String) (c : Char) (len : Nat) : String :=
+  s.pushn c (len - s.length)
+
+def zpad (n : Nat) (len : Nat) : String :=
+  lpad (toString n) '0' len
+
+/-- A TOML date (year-month-day). -/
+structure Date where
+  year : Nat
+  month : Nat
+  day : Nat
+  deriving Inhabited, DecidableEq, Ord
+
+namespace Date
+
+abbrev IsLeapYear (y : Nat) : Prop :=
+  y % 4 = 0 ∧ (y % 100 ≠ 0 ∨ y % 400 = 0)
+
+abbrev IsValidMonth (m : Nat) : Prop :=
+  m ≥ 1 ∧ m ≤ 12
+
+def maxDay (y m : Nat) :  Nat :=
+  if m = 2 then
+    if IsLeapYear y then 29 else 28
+  else if m ≤ 7 then
+    30 + (m % 2)
+  else
+    31 - (m % 2)
+
+abbrev IsValidDay (y m d : Nat) : Prop :=
+  d ≥ 1 ∧ d ≤ maxDay y m
+
+def ofValid? (year month day : Nat) : Option Date := do
+  guard (IsValidMonth month ∧ IsValidDay year month day)
+  return {year, month, day}
+
+def ofString? (t : String) : Option Date := do
+  match t.split (· == '-') with
+  | [y,m,d] =>
+    ofValid? (← y.toNat?) (← m.toNat?) (← d.toNat?)
+  | _ => none
+
+protected def toString (d : Date) : String :=
+  s!"{zpad d.year 4}-{zpad d.month 2}-{zpad d.day 2}"
+
+instance : ToString Date := ⟨Date.toString⟩
+
+end Date
+
+/--
+A TOML time (hour:minute:second.fraction).
+
+We do not represent whole time as seconds to due to the possibility
+of leap seconds in RFC 3339 times.
+-/
+structure Time where
+  hour : Nat
+  minute : Nat
+  second : Nat
+  fracExponent : Nat := 0
+  fracMantissa : Nat := 0
+  deriving Inhabited, DecidableEq
+
+namespace Time
+
+abbrev IsValidHour (h : Nat) : Prop :=
+  h ≤ 23
+
+abbrev IsValidMinute (m : Nat) : Prop :=
+  m ≤ 59
+
+abbrev IsValidSecond (s : Nat) : Prop :=
+  s ≤ 60
+
+def zero : Time :=
+  {hour := 0, minute := 0, second := 0}
+
+instance : OfNat Time (nat_lit 0) := ⟨Time.zero⟩
+
+def ofValid? (hour minute second : Nat) : Option Time := do
+  guard (IsValidHour hour ∧ IsValidMinute minute ∧ IsValidSecond second)
+  return {hour, minute, second}
+
+def ofString? (t : String) : Option Time := do
+  match t.split (· == ':') with
+  | [h,m,s] =>
+    match s.split (· == '.') with
+    | [s,f] =>
+      let time ← ofValid? (← h.toNat?) (← m.toNat?) (← s.toNat?)
+      return {time with fracExponent := f.length-1, fracMantissa := ← f.toNat?}
+    | [s] =>
+      ofValid? (← h.toNat?) (← m.toNat?) (← s.toNat?)
+    | _ => none
+  | [h,m] =>
+    ofValid? (← h.toNat?) (← m.toNat?) 0
+  | _ => none
+
+protected def toString (t : Time) : String :=
+  let s := s!"{zpad t.hour 2}:{zpad t.minute 2}:{zpad t.second 2}"
+  if t.fracMantissa = 0 then
+    s
+  else
+    s!"{s}.{rpad (zpad t.fracMantissa t.fracExponent) '0' 3}"
+
+instance : ToString Time := ⟨Time.toString⟩
+
+end Time
+
+/-- A TOML date-time. -/
+inductive DateTime
+| offsetDateTime (date : Date) (time : Time) (offset? : Option (Bool × Time) := none)
+| localDateTime (date : Date) (time : Time)
+| localDate (date : Date)
+| localTime (time : Time)
+deriving Inhabited, DecidableEq
+
+instance : Coe Date DateTime := ⟨DateTime.localDate⟩
+instance : Coe Time DateTime := ⟨DateTime.localTime⟩
+
+namespace DateTime
+
+def ofString? (dt : String) : Option DateTime := do
+  match dt.split (fun c => c == 'T' || c == 't' || c == ' ') with
+  | [d,t] =>
+    let d ← Date.ofString? d
+    if t.back == 'Z' || t.back == 'z' then
+      return offsetDateTime d (← Time.ofString? <| t.dropRight 1)
+    else if let [t,o] := t.split (· == '+') then
+      return offsetDateTime d (← Time.ofString? t) (false, ← Time.ofString? o)
+    else if let [t,o] := t.split (· == '-') then
+      return offsetDateTime d (← Time.ofString? t) (true, ← Time.ofString? o)
+    else
+      return localDateTime d (← Time.ofString? t)
+  | [x] =>
+    if x.any (· == ':') then
+      return localTime (← Time.ofString? x)
+    else
+      return localDate (← Date.ofString? x)
+  | _ => none
+
+protected def toString (dt : DateTime) : String :=
+  match dt with
+  | .offsetDateTime d t o? =>
+    if let some (s,o) := o? then
+      if s then
+        s!"{d}T{t}-{zpad o.hour 2}:{zpad o.minute 2}"
+      else
+        s!"{d}T{t}+{zpad o.hour 2}:{zpad o.minute 2}"
+    else
+      s!"{d}T{t}Z"
+  | .localDateTime d t => s!"{d}T{t}"
+  | .localDate d => d.toString
+  | .localTime t => t.toString
+
+instance : ToString DateTime := ⟨DateTime.toString⟩
+
+end DateTime
diff --git a/src/lake/Lake/Toml/Data/Dict.lean b/src/lake/Lake/Toml/Data/Dict.lean
new file mode 100644
index 0000000000..e6db14668b
--- /dev/null
+++ b/src/lake/Lake/Toml/Data/Dict.lean
@@ -0,0 +1,118 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lean.Data.NameMap
+
+/-! # Red-Black Dictionary
+
+Defines an **insertion-ordered** key-value mapping backed by an red-black tree.
+Implemented via a key-index `RBMap` into an `Array` of key-value pairs.
+-/
+
+open Lean
+
+namespace Lake.Toml
+
+/- An insertion-ordered key-value mapping backed by a red-black tree. -/
+structure RBDict (α : Type u) (β : Type v) (cmp : α → α → Ordering)  where
+  items : Array (α × β)
+  indices : RBMap α Nat cmp
+  deriving Inhabited
+
+abbrev NameDict (α : Type u) := RBDict Name α Name.quickCmp
+
+namespace RBDict
+
+def empty : RBDict α β cmp :=
+  {items := #[], indices := {}}
+
+instance : EmptyCollection (RBDict α β cmp) := ⟨RBDict.empty⟩
+
+def mkEmpty (capacity : Nat) : RBDict α β cmp :=
+  {items := .mkEmpty capacity, indices := {}}
+
+def ofArray (items : Array (α × β)) : RBDict α β cmp := Id.run do
+  let mut indices := mkRBMap α Nat cmp
+  for h : i in [0:items.size] do
+    indices := indices.insert (items[i]'h.upper).1 i
+  return {items, indices}
+
+protected def beq [BEq (α × β)] (self other : RBDict α β cmp) : Bool :=
+  self.items == other.items
+
+instance [BEq (α × β)] : BEq (RBDict α β cmp) := ⟨RBDict.beq⟩
+
+abbrev size (t : RBDict α β cmp) : Nat :=
+  t.items.size
+
+abbrev isEmpty (t : RBDict α β cmp) : Bool :=
+  t.items.isEmpty
+
+def keys (t : RBDict α β cmp) : Array α :=
+  t.items.map (·.1)
+
+def values (t : RBDict α β cmp) : Array β :=
+  t.items.map (·.2)
+
+def contains (k : α) (t : RBDict α β cmp) : Bool :=
+  t.indices.contains k
+
+def findIdx? (k : α) (t : RBDict α β cmp) : Option (Fin t.size) := do
+  let i ← t.indices.find? k; if h : i < t.items.size then some ⟨i, h⟩ else none
+
+def findEntry? (k : α) (t : RBDict α β cmp) : Option (α × β) := do
+  return t.items[← t.findIdx? k]
+
+@[inline] def find? (k : α) (t : RBDict α β cmp) : Option β := do
+  return (← t.findEntry? k).2
+
+def push (k : α) (v : β) (t : RBDict α β cmp) : RBDict α β cmp :=
+  {items := t.items.push ⟨k,v⟩, indices := t.indices.insert k t.items.size}
+
+@[specialize] def alter (k : α) (f : Option β → β) (t : RBDict α β cmp) : RBDict α β cmp :=
+   if let some i := t.findIdx? k then
+    {t with items := t.items.modify i fun (k, v) => (k, f (some v))}
+  else
+    t.push k (f none)
+
+def insert (k : α) (v : β) (t : RBDict α β cmp) : RBDict α β cmp :=
+  if let some i := t.findIdx? k then
+    if h : i < t.items.size then
+      {t with items := t.items.set ⟨i,h⟩ (k,v)}
+    else
+      t.push k v
+  else
+    t.push k v
+
+/-- Inserts the value into the dictionary if `p` is `true`. -/
+@[macro_inline] def insertIf (p : Bool) (k : α) (v : β) (t : RBDict α β cmp) : RBDict α β cmp :=
+  if p then t.insert k v else t
+
+/-- Inserts the value into the dictionary if `p` is `false`. -/
+@[macro_inline] def insertUnless (p : Bool) (k : α) (v : β) (t : RBDict α β cmp) : RBDict α β cmp :=
+  if p then t else t.insert k v
+
+/-- Insert the value into the dictionary if it is not `none`. -/
+@[macro_inline] def insertSome (k : α) (v? : Option β) (t : RBDict α β cmp) : RBDict α β cmp :=
+  if let some v := v? then t.insert k v else t
+
+def appendArray (self : RBDict α β cmp) (other : Array (α × β)): RBDict α β cmp :=
+  other.foldl (fun t (k,v) => t.insert k v) self
+
+instance : HAppend (RBDict α β cmp) (Array (α × β)) (RBDict α β cmp) := ⟨RBDict.appendArray⟩
+
+@[inline] def append (self other : RBDict α β cmp) : RBDict α β cmp :=
+  self.appendArray other.items
+
+instance : Append (RBDict α β cmp) := ⟨RBDict.append⟩
+
+@[inline] def map (f : α → β → γ) (t : RBDict α β cmp) : RBDict α γ cmp :=
+  {t with items := t.items.map fun ⟨k, v⟩ => ⟨k, f k v⟩}
+
+@[inline] def filter (p : α → β → Bool) (t : RBDict α β cmp) : RBDict α β cmp :=
+  t.items.foldl (init := {}) fun t (k, v) => if p k v then t.push k v else t
+
+@[inline] def filterMap (f : α → β → Option γ) (t : RBDict α β cmp) : RBDict α γ cmp :=
+  t.items.foldl (init := {}) fun t ⟨k, v⟩ => if let some v := f k v then t.push k v else t
diff --git a/src/lake/Lake/Toml/Data/Value.lean b/src/lake/Lake/Toml/Data/Value.lean
new file mode 100644
index 0000000000..beb973d690
--- /dev/null
+++ b/src/lake/Lake/Toml/Data/Value.lean
@@ -0,0 +1,125 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Toml.Data.Dict
+import Lake.Toml.Data.DateTime
+
+/-!
+# TOML Value
+-/
+
+open Lean
+
+namespace Lake.Toml
+
+/-- A TOML value with optional source info. -/
+inductive Value
+| string (ref : Syntax) (s : String)
+| integer (ref : Syntax) (n : Int)
+| float (ref : Syntax) (n : Float)
+| boolean (ref : Syntax) (b : Bool)
+| dateTime (ref : Syntax) (dt : DateTime)
+| array (ref : Syntax) (xs : Array Value)
+| private table' (ref : Syntax) (xs : RBDict Name Value Name.quickCmp)
+deriving Inhabited, BEq
+
+/-- A TOML table, an ordered key-value map of TOML values (`Lake.Toml.Value`). -/
+abbrev Table := NameDict Value
+
+@[inline] def Table.empty : Table := RBDict.empty
+@[inline] def Table.mkEmpty (capacity : Nat) : Table := RBDict.mkEmpty capacity
+
+@[match_pattern] abbrev Value.table (ref : Syntax) (t : Table) :=
+  Value.table' ref t
+
+@[inline] def Value.ref : Value → Syntax
+| .string (ref := ref) .. => ref
+| .integer (ref := ref) .. => ref
+| .float (ref := ref) .. => ref
+| .boolean (ref := ref) .. => ref
+| .dateTime (ref := ref) .. => ref
+| .array (ref := ref) .. => ref
+| .table (ref := ref) .. => ref
+
+--------------------------------------------------------------------------------
+/-! ## Pretty Printing -/
+--------------------------------------------------------------------------------
+
+def ppString (s : String) : String :=
+  let s := s.foldl (init := "\"") fun s c =>
+    match c with
+    | '\x08' => s ++ "\\b"
+    | '\t' => s ++ "\\t"
+    | '\n' => s ++ "\\n"
+    | '\x0C' => s ++ "\\f"
+    | '\r' => s ++ "\\r"
+    | '\"' => s ++ "\\\""
+    | '\\' => s ++ "\\\\"
+    | _ =>
+      if c.val < 0x20 || c.val == 0x7F then
+        s ++ "\\u" ++ lpad (String.mk <| Nat.toDigits 16 c.val.toNat) '0' 4
+      else
+        s.push c
+  s.push '\"'
+
+def ppSimpleKey (k : String) : String :=
+  if k.all (fun c => c.isAlphanum || c == '_' || c == '-') then
+    k
+  else
+    ppString k
+
+partial def ppKey (k : Name) : String :=
+  match k with
+  | .str p s =>
+    if p.isAnonymous then
+      ppSimpleKey s
+    else
+      s!"{ppKey p}.{ppSimpleKey s}"
+  | _ => ""
+
+mutual
+
+partial def ppInlineTable (t : Table) : String :=
+  let xs := t.items.map fun (k,v) => s!"{ppKey k} = {Value.toString v}"
+  "{" ++ ", ".intercalate xs.toList ++ "}"
+
+partial def ppInlineArray (vs : Array Value) : String :=
+  let xs := vs.map Value.toString
+  "[" ++ ", ".intercalate xs.toList ++ "]"
+
+partial def Value.toString (v : Value) : String :=
+  match v with
+  | .string _ s => ppString s
+  | .integer _ n => toString n
+  | .float _ n => toString n
+  | .boolean _ b => toString b
+  | .dateTime _ dt => toString dt
+  | .array _ vs => ppInlineArray vs
+  | .table _ t => ppInlineTable t
+
+end
+
+instance : ToString Value := ⟨Value.toString⟩
+
+def ppTable (t : Table) : String :=
+  String.trimLeft <| t.items.foldl (init := "") fun s (k,v) =>
+    match v with
+    | .array _ vs =>
+      if vs.all (· matches .table ..) then
+        vs.foldl (init := s) fun s v =>
+          match v with
+          | .table _ t =>
+            let s := s ++ s!"\n[[{ppKey k}]]\n"
+            t.items.foldl (fun s (k,v) => appendKeyval s k v) s
+          | _ => unreachable!
+      else
+        s.append s!"{ppKey k} = {ppInlineArray vs}\n"
+    | .table _ t =>
+      let s := s ++ s!"\n[{ppKey k}]\n"
+      t.items.foldl (fun s (k,v) => appendKeyval s k v) s
+    | _ => appendKeyval s k v
+where
+  appendKeyval s k v :=
+    s.append s!"{ppKey k} = {v}\n"
diff --git a/src/lake/Lake/Toml/Decode.lean b/src/lake/Lake/Toml/Decode.lean
new file mode 100644
index 0000000000..9a38374825
--- /dev/null
+++ b/src/lake/Lake/Toml/Decode.lean
@@ -0,0 +1,188 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Toml.Data
+
+/-!
+# TOML Decoders
+
+This module contains definitions to assist in decoding TOML data values
+into concrete user types.
+-/
+
+namespace Lake
+open Lean Toml
+
+/-!
+## Generic Decode Helpers
+-/
+
+instance : MonadLift (Except ε) (Except (Array ε)) where
+  monadLift x := x.mapError Array.singleton
+
+/-- Run the decode action. If there were errors, throw. Otherwise, return the result. -/
+@[inline] def ensureDecode (x : StateM (Array ε) α) : Except (Array ε) α :=
+  let (a, es) := x.run Array.empty; if es.isEmpty then pure a else throw es
+
+/-- Run the decode action. If it fails, add the errors to the state and return `default`. -/
+@[inline] def tryDecodeD (default : α) (x : Except (Array ε) α) : StateM (Array ε) α :=
+  match x with
+  | .ok a => pure a
+  | .error es => modify (· ++ es) *> pure default
+
+/-- Run the decode action. If it fails, add the errors to the state and return `Inhabited.default`. -/
+@[inline] def tryDecode [Inhabited α] (x : Except (Array ε) α) : StateM (Array ε) α :=
+  tryDecodeD default x
+
+/--
+If the value is not `none`, run the decode action.
+If it fails, add the errors to the state and return `default`.
+-/
+@[inline] def optDecodeD (default : β)  (a? : Option α) (f : α → Except (Array ε) β) : StateM (Array ε) β :=
+  match a? with
+  | some a => tryDecodeD default (f a)
+  | none => pure default
+
+/--
+If the value is not `none`, run the decode action.
+If it fails, add the errors to the state and return `Inhabited.default`.
+-/
+@[inline] def optDecode [Inhabited β] (a? : Option α) (f : α → Except (Array ε) β) : StateM (Array ε) β :=
+  optDecodeD default a? f
+
+
+/--
+If the value is not `none`, run the decode action.
+If it fails, add the errors to the state and return `none`.
+Otherwise, return the the result in `some`.
+-/
+@[inline] def optDecode? (a? : Option α)  (f : α → Except (Array ε) β) : StateM (Array ε) (Option β) :=
+  optDecodeD none a? fun a  => some <$> f a
+
+/--
+If either action errors, throw the concatenated errors.
+Otherwise, if no errors, combine the results with `f`.
+-/
+def mergeErrors (x₁ : Except (Array ε) α) (x₂ : Except (Array ε) β) (f : α → β → γ) : Except (Array ε) γ :=
+  match x₁, x₂ with
+  | .ok a, .ok b => .ok (f a b)
+  | .ok _, .error es => .error es
+  | .error es, .ok _ => .error es
+  | .error es', .error es => .error (es ++ es')
+
+structure Toml.DecodeError where
+  ref : Syntax
+  msg : String
+
+class DecodeToml (α : Type u) where
+  decode (v : Value) : Except (Array DecodeError) α
+
+abbrev decodeToml [DecodeToml α] (v : Value) : Except (Array DecodeError) α :=
+  DecodeToml.decode v
+
+namespace Toml
+
+/-- Decode an array of TOML values, merging any errors from the elements into a single array. -/
+def decodeArray [dec : DecodeToml α] (vs : Array Value) : Except (Array DecodeError) (Array α) :=
+  vs.foldl (init := Except.ok (.mkEmpty vs.size)) fun vs v =>
+    mergeErrors vs (dec.decode v) Array.push
+
+instance : DecodeToml Value := ⟨pure⟩
+
+namespace Value
+
+@[inline] def decodeString : Value → Except DecodeError String
+| .string _ v => .ok v
+| x => .error (.mk x.ref "expected string")
+
+instance : DecodeToml String := ⟨(·.decodeString)⟩
+instance : DecodeToml System.FilePath := ⟨(.mk <$> decodeToml ·)⟩
+
+@[inline] def decodeName (v : Value) : Except DecodeError Name := do
+  match (← v.decodeString).toName with
+  | .anonymous => throw (.mk v.ref "expected name")
+  | n => pure n
+
+instance : DecodeToml Lean.Name := ⟨(·.decodeName)⟩
+
+@[inline] def decodeInt : Value → Except DecodeError Int
+| .integer _ v => .ok v
+| x => .error (.mk x.ref "expected integer")
+
+instance : DecodeToml Int := ⟨(·.decodeInt)⟩
+
+@[inline] def decodeNat : Value → Except DecodeError Nat
+| .integer _ (.ofNat v) => .ok v
+| x => .error (.mk x.ref "expected nonnegative integer")
+
+instance : DecodeToml Nat := ⟨(·.decodeNat)⟩
+
+@[inline] def decodeFloat : Value → Except DecodeError Float
+| .float _ v => .ok v
+| x => .error (.mk x.ref "expected float")
+
+instance : DecodeToml Float := ⟨(·.decodeFloat)⟩
+
+@[inline] def decodeBool : Value → Except DecodeError Bool
+| .boolean _ v => .ok v
+| x => .error (.mk x.ref "expected boolean")
+
+instance : DecodeToml Bool := ⟨(·.decodeBool)⟩
+
+@[inline] def decodeDateTime : Value → Except DecodeError DateTime
+| .dateTime _ v => .ok v
+| x => .error (.mk x.ref "expected date-time")
+
+instance : DecodeToml DateTime := ⟨(·.decodeDateTime)⟩
+
+@[inline] def decodeValueArray : Value → Except DecodeError (Array Value)
+| .array _ vs => .ok vs
+| x => .error (.mk x.ref "expected array")
+
+@[inline] protected def decodeArray [dec : DecodeToml α] (v : Value) : Except (Array DecodeError) (Array α) := do
+  decodeArray (dec := dec) (← v.decodeValueArray)
+
+instance [DecodeToml α] : DecodeToml (Array α) := ⟨Value.decodeArray⟩
+
+@[inline] def decodeArrayOrSingleton [dec : DecodeToml α] : Value → Except (Array DecodeError) (Array α)
+| .array _ vs => decodeArray (dec := dec) vs
+| v => Array.singleton <$> dec.decode v
+
+@[inline] def decodeTable : Value → Except DecodeError Table
+| .table _ t => .ok t
+| x => .error (.mk x.ref "expected table")
+
+instance : DecodeToml Table := ⟨(·.decodeTable)⟩
+
+end Value
+
+namespace Table
+
+@[inline] def decodeValue (t : Table) (k : Name) (ref := Syntax.missing) : Except DecodeError Value := do
+  let some a := t.find? k
+    | throw (.mk ref s!"missing required key: {ppKey k}")
+  return a
+
+def decode [dec : DecodeToml α] (t : Table) (k : Name) (ref := Syntax.missing) : Except (Array DecodeError) α := do
+  let a ← t.decodeValue k ref
+  dec.decode a |>.mapError fun xs => xs.map fun x =>
+    {x with msg := s!"key {ppKey k}: " ++ x.msg}
+
+def decodeNameMap [dec : DecodeToml α] (t : Toml.Table) : Except (Array DecodeError) (NameMap α) := do
+  t.items.foldl (init := Except.ok {}) fun m (k,v) =>
+    mergeErrors m (dec.decode v) fun m v => m.insert k v
+
+instance [DecodeToml α] : DecodeToml (NameMap α) := ⟨(do decodeNameMap <| ← ·.decodeTable)⟩
+
+@[inline] protected def tryDecode [Inhabited α] [dec : DecodeToml α] (t : Table) (k : Name) (ref := Syntax.missing) : StateM (Array DecodeError) α := do
+  tryDecode <| t.decode (dec := dec) k ref
+
+@[inline] protected def tryDecode? [dec : DecodeToml α] (t : Table) (k : Name) : StateM (Array DecodeError) (Option α) :=
+  optDecode? (t.find? k) dec.decode
+
+@[inline] protected def tryDecodeD [dec : DecodeToml α] (k : Name) (default : α) (t : Table) : StateM (Array DecodeError) α :=
+  optDecodeD default (t.find? k) dec.decode
+
+end Table
diff --git a/src/lake/Lake/Toml/Elab.lean b/src/lake/Lake/Toml/Elab.lean
new file mode 100644
index 0000000000..7403d606e1
--- /dev/null
+++ b/src/lake/Lake/Toml/Elab.lean
@@ -0,0 +1,13 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Toml.Elab.Expression
+
+/-!
+# TOML Elaboration
+
+Elaborates TOML syntax into Lean data types.
+At top-level, elaborates a whole TOML file into a `Toml.Table`.
+-/
diff --git a/src/lake/Lake/Toml/Elab/Expression.lean b/src/lake/Lake/Toml/Elab/Expression.lean
new file mode 100644
index 0000000000..f44c516de0
--- /dev/null
+++ b/src/lake/Lake/Toml/Elab/Expression.lean
@@ -0,0 +1,241 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Toml.Elab.Value
+
+/-!
+# TOML Expression Elaboration
+
+Elaborates top-level TOML syntax into a Lean `Toml.Table`.
+-/
+
+open Lean
+
+namespace Lake.Toml
+
+/-- The manner in which a TOML key was declared. -/
+inductive KeyTy
+/-- A key declared via `key = v`. -/
+| value
+/-- A key declared via `[key]`. -/
+| stdTable
+/-- A key declared via `[[key]]`. -/
+| array
+/-- A key declared via `key.foo`. -/
+| dottedPrefix
+/-- A key declared via `[key.foo]` or `[[key.foo]]`. -/
+| headerPrefix
+deriving Inhabited
+
+protected def KeyTy.toString (ty : KeyTy) :=
+  match ty with
+  | .value => "value"
+  | .stdTable => "table"
+  | .array => "array"
+  | .dottedPrefix => "dotted"
+  | .headerPrefix => "dotted"
+
+instance : ToString KeyTy := ⟨KeyTy.toString⟩
+
+def KeyTy.isValidPrefix (ty : KeyTy) :=
+  match ty with
+  | .stdTable | .headerPrefix | .dottedPrefix  => true
+  | _ => false
+
+structure Keyval where
+  ref : Syntax
+  key : Name
+  val : Value
+
+structure ElabState where
+  keyTys : NameMap KeyTy := {}
+  arrKeyTys : NameMap (NameMap KeyTy) := {}
+  arrParents : NameMap Name := {}
+  currArrKey : Name := .anonymous
+  currKey : Name := .anonymous
+  items : Array Keyval := {}
+  deriving Inhabited
+
+abbrev TomlElabM := StateT ElabState CoreM
+
+def elabSubKeys (ks : Array (TSyntax ``simpleKey)) : TomlElabM Name := do
+  ks.foldlM (init := (← get).currKey) fun k kStx => do
+    let k := k.str <| ← elabSimpleKey kStx
+    if let some ty := (← get).keyTys.find? k then
+      unless ty matches .dottedPrefix do
+        throwErrorAt kStx "cannot redefine {ty} key '{k}'"
+    else
+      modify fun s => {s with keyTys := s.keyTys.insert k .dottedPrefix}
+    return k
+
+def elabKeyval (kv : TSyntax ``keyval) : TomlElabM Unit := do
+  let `(keyval|$kStx = $v) := kv
+    | throwErrorAt kv "ill-formed key-value pair syntax"
+  let `(key|$[$ks:simpleKey].*) := kStx
+    | throwErrorAt kStx "ill-formed key syntax"
+  let tailKeyStx := ks.back
+  let k ← elabSubKeys ks.pop
+  let k := k.str <| ← elabSimpleKey tailKeyStx
+  if let some ty := (← get).keyTys.find? k then
+    throwErrorAt tailKeyStx "cannot redefine {ty} key '{k}'"
+  else
+    let v ← elabVal v
+    modify fun s => {
+      s with
+      items := s.items.push ⟨kStx, k, v⟩
+      keyTys := s.keyTys.insert k .value
+  }
+
+def elabHeaderKeys (ks : Array (TSyntax ``simpleKey)) : TomlElabM Name := do
+  modify fun s =>
+    let arrKeyTys := s.arrKeyTys.insert s.currArrKey s.keyTys
+    {
+      s with
+      arrKeyTys
+      currArrKey := .anonymous
+      keyTys := arrKeyTys.find? .anonymous |>.getD {}
+    }
+  ks.foldlM (init := Name.anonymous) fun k kStx => do
+    let k ← k.str <$> elabSimpleKey kStx
+    if let some ty := (← get).keyTys.find? k then
+      match ty with
+      | .array =>
+        let some keyTys := (← get).arrKeyTys.find? k
+          | throwError "(internal) bad array key '{k}'"
+        modify fun s => {s with keyTys, currArrKey := k}
+      | .stdTable | .headerPrefix | .dottedPrefix  => pure ()
+      | _ => throwErrorAt kStx m!"cannot redefine {ty} key '{k}'"
+    else
+      modify fun s => {s with keyTys := s.keyTys.insert k .headerPrefix}
+    return k
+
+def elabStdTable (x : TSyntax ``stdTable) : TomlElabM Unit := withRef x do
+  let `(stdTable|[$kStx]) := x
+    | throwErrorAt x "ill-formed table syntax"
+  let `(key|$[$ks:simpleKey].*) := kStx
+    | throwErrorAt kStx "ill-formed key syntax"
+  let tailKey := ks.back
+  let k ← elabHeaderKeys ks.pop
+  let k ← k.str <$> elabSimpleKey tailKey
+  if let some ty := (← get).keyTys.find? k then
+    unless ty matches .headerPrefix do
+      throwErrorAt tailKey m!"cannot redefine {ty} key '{k}'"
+  modify fun s => {
+    s with
+    currKey := k
+    keyTys := s.keyTys.insert k .stdTable
+    items := s.items.push ⟨x, k, .table x {}⟩
+  }
+
+def elabArrayTable (x : TSyntax ``arrayTable) : TomlElabM Unit := withRef x do
+  let `(arrayTable|[[$k]]) := x
+    | throwErrorAt x "ill-formed array table syntax"
+  let `(key|$[$ks:simpleKey].*) := k
+    | throwErrorAt x "ill-formed key syntax"
+  let tailKey := ks.back
+  let k ← elabHeaderKeys ks.pop
+  let k := k.str (← elabSimpleKey tailKey)
+  if let some ty := (← get).keyTys.find? k then
+    if ty matches .array then
+      let s ← get
+      let some keyTys := s.arrParents.find? k >>= s.arrKeyTys.find?
+        | throwError "(internal) bad array key '{k}'"
+      modify fun s => {
+        s with
+        keyTys, currKey := k, currArrKey := k
+        items := s.items.push ⟨x, k, .array x #[.table x {}]⟩
+      }
+    else
+      throwErrorAt tailKey s!"cannot redefine {ty} key '{k}'"
+  else
+    modify fun s =>
+      let keyTys := s.keyTys.insert k .array
+      {
+        s with
+        keyTys
+        currKey := k
+        currArrKey := k
+        arrKeyTys := s.arrKeyTys.insert s.currArrKey keyTys
+        arrParents := s.arrParents.insert k s.currArrKey
+        items := s.items.push ⟨x, k, .array x #[.table x {}]⟩
+      }
+
+def elabExpression (x : TSyntax ``expression) : TomlElabM Unit := do
+  match x with
+  | `(expression|$x:keyval) => elabKeyval x
+  | `(expression|$x:stdTable) => elabStdTable x
+  | `(expression|$x:arrayTable) => elabArrayTable x
+  | _ => throwErrorAt x "ill-formed expression syntax"
+
+/--
+Construct a table of simple key-value pairs from arbitrary key-value pairs.
+
+For example:
+
+`{a.b := [c.d := 0]}, {a.b := [c.e := 1]}`
+
+becomes
+
+`{a := {b := [{c := {d := 0, e := 1}}]}}`
+-/
+partial def mkSimpleTable (items : Array Keyval) : Table :=
+  items.foldl (init := {}) fun t ⟨kRef,k,v⟩ =>
+    match k.components with
+    | .nil => t
+    | .cons k ks => insert t kRef k ks v
+where
+  simpVal : Value → Value
+    | .table ref t => .table ref <| t.items.foldl (init := {}) fun t ⟨k,v⟩ =>
+      match k.components with
+      | .nil => t
+      | .cons k ks => insert t ref k ks v
+    | .array ref vs => .array ref <| vs.map simpVal
+    | v => v
+  insert t kRef k ks newV :=
+    match ks with
+    | .nil => t.alter k fun v? =>
+      match v?, simpVal newV with
+      | some (.table ref vt), .table _ newT => .table ref (vt ++ newT)
+      | some (.array ref vs), .array _ newVs => .array ref (vs ++ newVs)
+      | some (.array ref vs), newV => .array ref (vs.push newV)
+      | _, newV => newV
+    | k' :: ks => t.alter k fun v? =>
+      if let some v := v? then
+        match v with
+        | .array ref vs =>
+          .array ref <| vs.modify (vs.size-1) fun
+          | .table ref t' => .table ref <| insert t' kRef k' ks newV
+          | _ => .table kRef {}
+        | .table ref t' => .table ref <| insert t' kRef k' ks newV
+        | _ => .table kRef <| insert {} kRef k' ks newV
+      else
+        .table kRef <| insert {} kRef k' ks newV
+
+nonrec def TomlElabM.run (x : TomlElabM Unit) : CoreM Table := do
+  let (_,s) ← x.run {}
+  return mkSimpleTable s.items
+
+def elabToml (x : TSyntax ``toml) : CoreM Table := do
+  let `(toml|$xs*) := x
+    | throwErrorAt x "ill-formed TOML syntax"
+  TomlElabM.run do
+  let mut recovering := false
+  for x in xs.getElems do
+    try
+      match x with
+      | `(expression|$x:keyval) =>
+        unless recovering do
+          elabKeyval x
+      | `(expression|$x:stdTable) =>
+        elabStdTable x
+        recovering := false
+      | `(expression|$x:arrayTable) =>
+        elabArrayTable x
+        recovering := false
+      | _ =>
+        logErrorAt x "ill-formed expression syntax"
+    catch e : Exception =>
+      recovering := true
+      logErrorAt e.getRef e.toMessageData
diff --git a/src/lake/Lake/Toml/Elab/Value.lean b/src/lake/Lake/Toml/Elab/Value.lean
new file mode 100644
index 0000000000..8288533880
--- /dev/null
+++ b/src/lake/Lake/Toml/Elab/Value.lean
@@ -0,0 +1,243 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lean.CoreM
+import Lake.Toml.Data.Value
+import Lake.Toml.Grammar
+
+/-!
+# TOML Value Elaboration
+
+Elaborates TOML values into Lean data types.
+-/
+
+open Lean
+
+namespace Lake.Toml
+
+@[inline] def elabLit {k : SyntaxNodeKind} (x : TSyntax k) (name : String) : CoreM String := do
+  let some spelling := x.raw.isLit? k
+    | throwErrorAt x s!"ill-formed {name} syntax"
+  return spelling
+
+def elabBoolean (x : TSyntax ``boolean) : CoreM Bool := do
+  match x with
+  | `(boolean|true)=> return true
+  | `(boolean|false) => return false
+  | _ => throwErrorAt x "invalid boolean"
+
+--------------------------------------------------------------------------------
+/-! ## Numerals -/
+--------------------------------------------------------------------------------
+
+def decodeDecNum (s : String) : Nat :=
+  s.foldl (init := 0) fun n c =>
+    if c == '_' then n else n*10 + (c.val - '0'.val).toNat
+
+def decodeSign (s : String) : Bool × String :=
+  if s.front == '-' then
+    (true, s.drop 1)
+  else if s.front == '+' then
+    (false, s.drop 1)
+  else
+    (false, s)
+
+def decodeDecInt (s : String) : Int :=
+  let (sign, s) := decodeSign s
+  if sign then
+    .negOfNat <| decodeDecNum s
+  else
+    .ofNat <| decodeDecNum s
+
+def elabDecInt (x : TSyntax ``decInt) : CoreM Int := do
+  return decodeDecInt <| ← elabLit x "decimal integer"
+
+def decodeMantissa (s : String) : Nat × Nat :=
+  let (m,e) := s.foldl (init := (0,s.length)) fun (m,e) c =>
+    match c with
+    | '_' => (m,e)
+    | '.' => (m,0)
+    | c => (m*10 + (c.val - '0'.val).toNat, e+1)
+  (m, if e ≥ s.length then 0 else e)
+
+def decodeFrExp (s : String) : Nat × Int :=
+  match s.split (fun c => c == 'E' || c == 'e') with
+  | [m,exp] =>
+    let exp := decodeDecInt exp
+    let (m,dotExp) := decodeMantissa m
+    (m, Int.negOfNat dotExp + exp)
+  | [m] =>
+    let (m, e) := decodeMantissa m
+    (m, Int.negOfNat e)
+  | _ => (0,0)
+
+def decodeFloat (s : String) : Float :=
+  let (sign, s) := decodeSign s
+  if s = "inf" then
+    if sign then -1.0/0 else 1.0/0
+  else if s = "nan" then
+    if sign then -(0.0/0) else 0.0/0
+  else
+    let (m,e) := decodeFrExp s
+    let flt := Float.ofScientific m (e < 0) e.natAbs
+    if sign then -flt else flt
+
+def elabFloat (x : TSyntax ``float) : CoreM Float := do
+  return decodeFloat <| ← elabLit x "float"
+
+def elabBinNum (x : TSyntax ``binNum) : CoreM Nat := do
+  let spelling ← elabLit x "binary number"
+  return spelling.drop 2 |>.foldl (init := 0) fun n c =>
+    if c == '_' then n else n*2 + (c.val - '0'.val).toNat
+
+def elabOctNum (x : TSyntax ``octNum) : CoreM Nat := do
+  let spelling ← elabLit x "octal number"
+  return spelling.drop 2 |>.foldl (init := 0) fun n c =>
+    if c == '_' then n else n*8 + (c.val - '0'.val).toNat
+
+def decodeHexDigit (c : Char) : Nat :=
+  if c  ≤ '9' then (c.val - '0'.val).toNat
+  else if c  ≤ 'F' then 10 + (c.val - 'A'.val).toNat
+  else 10 + (c.val - 'a'.val).toNat
+
+def elabHexNum (x : TSyntax ``hexNum) : CoreM Nat := do
+  let spelling ← elabLit x "hexadecimal number"
+  return spelling.drop 2 |>.foldl (init := 0) fun n c =>
+    if c == '_' then n else n*16 + decodeHexDigit c
+
+def elabDateTime (x : TSyntax ``dateTime) : CoreM DateTime := do
+  let spelling ← elabLit x "date-time"
+  let some dt := DateTime.ofString? spelling
+    | throwErrorAt x "invalid date-time"
+  return dt
+
+--------------------------------------------------------------------------------
+/-! ## Strings & Simple Keys -/
+--------------------------------------------------------------------------------
+
+def elabLiteralString (x : TSyntax ``literalString) : CoreM String := do
+  return (← elabLit x "literalString").drop 1 |>.dropRight 1
+
+def decodeHexDigits (s : Substring) : Nat :=
+  s.foldl (init := 0) fun n c => n*16 + decodeHexDigit c
+
+partial def elabBasicStringCore (lit : String) (i : String.Pos := 0) (out := "") : CoreM String := do
+  if h : lit.atEnd i then
+    return out
+  else
+    let curr := lit.get' i h
+    let i := lit.next' i h
+    if curr == '\\' then
+      if h : lit.atEnd i then
+        return out
+      else
+        let curr := lit.get' i h
+        let elabUnicodeEscape escape :=
+          let val := decodeHexDigits escape
+          if h : val.isValidChar then
+            let ch := Char.ofNatAux val h
+            elabBasicStringCore lit escape.stopPos (out.push ch)
+          else
+            throwError "invalid unicode escape '{escape}'"
+        match curr with
+        | 'b'  => elabBasicStringCore lit (lit.next' i h) (out.push '\x08')
+        | 't'  => elabBasicStringCore lit (lit.next' i h) (out.push '\t')
+        | 'n'  => elabBasicStringCore lit (lit.next' i h) (out.push '\n')
+        | 'f'  => elabBasicStringCore lit (lit.next' i h) (out.push '\x0C')
+        | 'r'  => elabBasicStringCore lit (lit.next' i h) (out.push '\r')
+        | '\"' => elabBasicStringCore lit (lit.next' i h) (out.push '"')
+        | '\\' => elabBasicStringCore lit (lit.next' i h) (out.push '\\')
+        | 'u'  => elabUnicodeEscape (Substring.mk lit (lit.next' i h) lit.endPos |>.take 4)
+        | 'U'  => elabUnicodeEscape (Substring.mk lit (lit.next' i h) lit.endPos |>.take 8)
+        | _ =>
+          let i := Substring.mk lit i lit.endPos |>.trimLeft |>.startPos
+          elabBasicStringCore lit i out
+    else
+      elabBasicStringCore lit i (out.push curr)
+
+def elabBasicString (x : TSyntax ``basicString) : CoreM String := do
+  let spelling ← elabLit x "basic string"
+  withRef x <| elabBasicStringCore (spelling.drop 1 |>.dropRight 1)
+
+def dropInitialNewline (s : String) : String :=
+  if s.front == '\r' then
+    s.drop 2
+  else if s.front == '\n' then
+    s.drop 1
+  else
+    s
+
+def elabMlLiteralString (x : TSyntax ``mlLiteralString) : CoreM String := do
+  let spelling ← elabLit x "multi-line literal string"
+  return dropInitialNewline (spelling.drop 3 |>.dropRight 3)
+
+def elabMlBasicString (x : TSyntax ``mlBasicString) : CoreM String := do
+  let spelling ← elabLit x "multi-line basic string"
+  withRef x <| elabBasicStringCore (dropInitialNewline (spelling.drop 3 |>.dropRight 3))
+
+def elabString (x : TSyntax ``string) : CoreM String := do
+  match x with
+  | `(val|$x:literalString) => elabLiteralString x
+  | `(val|$x:basicString) => elabBasicString x
+  | `(val|$x:mlLiteralString) => elabMlLiteralString x
+  | `(val|$x:mlBasicString) => elabMlBasicString x
+  | _ => throwErrorAt x "ill-formed string syntax"
+
+@[inline] def elabUnquotedKey (x : TSyntax ``unquotedKey) : CoreM String := do
+  elabLit x "unquoted key"
+
+def elabSimpleKey (x : TSyntax ``simpleKey) : CoreM String := do
+  match x with
+  | `(simpleKey|$x:unquotedKey) => elabUnquotedKey x
+  | `(simpleKey|$x:literalString) => elabLiteralString x
+  | `(simpleKey|$x:basicString) => elabBasicString x
+  | _ => throwErrorAt x "ill-formed simple key syntax"
+
+--------------------------------------------------------------------------------
+/-! ## Complex Values -/
+--------------------------------------------------------------------------------
+
+def elabArray (x : TSyntax ``array) (elabVal : TSyntax ``val → CoreM α) : CoreM (Array α) := do
+  let `(val|[$xs,*]) := x
+    | throwErrorAt x "ill-formed array syntax"
+  xs.getElems.mapM elabVal
+
+def elabInlineTable (x : TSyntax ``inlineTable) (elabVal : TSyntax ``val → CoreM Value) : CoreM Table := do
+  let `(val|{$kvs,*}) := x
+    | throwErrorAt x "ill-formed inline table syntax"
+  let t : NameDict (Option Value) := {}  -- some: static value, none: partial table
+  let t ← kvs.getElems.foldlM (init := t) fun t kv => do
+    let `(keyval|$k = $v) := kv
+      | throwErrorAt kv "ill-formed key-value pair syntax"
+    let `(key|$[$ks].*) := k
+      | throwErrorAt k "ill-formed key syntax"
+    let tailKey := ks.back
+    let (k, t) ← StateT.run (s := t) <| ks.pop.foldlM (init := Name.anonymous) fun k p => do
+      let k ← k.str <$> elabSimpleKey p
+      if let some v := t.find? k then
+        unless v.isNone do throwErrorAt p m!"cannot redefine key '{k}'"
+      else
+        modify fun t => t.push k none
+      return k
+    let k ← k.str <$> elabSimpleKey tailKey
+    if t.contains k then
+      throwErrorAt tailKey m!"cannot redefine key '{k}'"
+    else
+      return t.push k (← elabVal v)
+  return t.filterMap fun _ v => v
+
+partial def elabVal (x : TSyntax ``val) : CoreM Value := do
+  match x with
+  | `(val|$x:float) => .float x <$> elabFloat x
+  | `(val|$x:decInt) => .integer x <$> elabDecInt x
+  | `(val|$x:binNum) => .integer x <$> .ofNat <$> elabBinNum x
+  | `(val|$x:octNum) => .integer x <$> .ofNat <$> elabOctNum x
+  | `(val|$x:hexNum) => .integer x <$> .ofNat <$> elabHexNum x
+  | `(val|$x:dateTime) => .dateTime x <$> elabDateTime x
+  | `(val|$x:string) => .string x <$> elabString x
+  | `(val|$x:boolean) => .boolean x <$> elabBoolean x
+  | `(val|$x:array) => .array x <$> elabArray x elabVal
+  | `(val|$x:inlineTable) => .table x <$> elabInlineTable x elabVal
+  | _ => throwErrorAt x "ill-formed value syntax"
diff --git a/src/lake/Lake/Toml/Encode.lean b/src/lake/Lake/Toml/Encode.lean
new file mode 100644
index 0000000000..c304ec37ba
--- /dev/null
+++ b/src/lake/Lake/Toml/Encode.lean
@@ -0,0 +1,74 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Toml.Data
+import Lake.Util.FilePath
+
+/-!
+# TOML Encoders
+
+This module contains definitions to assist in encoding Lean types
+into TOML data values.
+-/
+
+namespace Lake
+
+open System Lean Toml
+
+class ToToml (α : Type u) where
+  toToml : α → Value
+
+export ToToml (toToml)
+
+instance : ToToml Value := ⟨id⟩
+instance : ToToml String := ⟨.string .missing⟩
+instance : ToToml FilePath := ⟨(toToml <| mkRelPathString ·)⟩
+instance : ToToml Name := ⟨(toToml ·.toString)⟩
+instance : ToToml Int := ⟨.integer .missing⟩
+instance : ToToml Nat := ⟨fun n => .integer .missing (.ofNat n)⟩
+instance : ToToml Float := ⟨.float .missing⟩
+instance : ToToml Bool := ⟨.boolean .missing⟩
+instance [ToToml α] : ToToml (Array α) := ⟨(.array .missing <| ·.map toToml)⟩
+instance : ToToml Table := ⟨.table .missing⟩
+
+/-- Insert a value into a table unless it represents a nullish value. -/
+class SmartInsert (α : Type u) where
+  smartInsert (k : Name) : α → Table → Table
+
+namespace Toml.Table
+
+/-- Inserts the encoded value into the table. -/
+@[inline] nonrec def insert [enc : ToToml α] (k : Name) (v : α) (t : Table) : Table :=
+  t.insert k (enc.toToml v)
+
+instance (priority := low) [ToToml α] : SmartInsert α := ⟨Table.insert⟩
+
+/-- If the value is not `none`, inserts the encoded value into the table. -/
+@[inline] nonrec def insertSome [enc : ToToml α] (k : Name) (v? : Option α) (t : Table) : Table :=
+  t.insertSome k (v?.map enc.toToml)
+
+instance [ToToml α] : SmartInsert (Option α) := ⟨Table.insertSome⟩
+
+/-- Insert a value into the table unless it represents a nullish value. -/
+@[inline] nonrec def smartInsert [SmartInsert α] (k : Name) (v : α) (t : Table) : Table :=
+  SmartInsert.smartInsert k v t
+
+instance : SmartInsert Table where
+  smartInsert k v t := t.insertUnless v.isEmpty k (toToml v)
+
+instance [ToToml (Array α)] : SmartInsert (Array α) where
+  smartInsert k v t := t.insertUnless v.isEmpty k (toToml v)
+
+/-- Insert a value into the table if `p` is `true`. -/
+@[inline] nonrec def insertIf [enc : ToToml α] (p : Bool) (k : Name) (v : α) (t : Table) : Table :=
+  t.insertIf p k (enc.toToml v)
+
+/-- Insert a value into the table if `p` is `false`. -/
+@[inline] nonrec def insertUnless [enc : ToToml α] (p : Bool) (k : Name) (v : α) (t : Table) : Table :=
+  t.insertUnless p k (enc.toToml v)
+
+/-- Inserts the value into the table if it is not equal to `default`. -/
+@[inline] def insertD [enc : ToToml α] [BEq α] (k : Name) (v : α) (default : α) (t : Table) : Table :=
+  t.insertUnless (v == default) k (enc.toToml v)
diff --git a/src/lake/Lake/Toml/Grammar.lean b/src/lake/Lake/Toml/Grammar.lean
new file mode 100644
index 0000000000..349d985bb2
--- /dev/null
+++ b/src/lake/Lake/Toml/Grammar.lean
@@ -0,0 +1,647 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Toml.ParserUtil
+
+/-!
+# TOML Grammar
+
+A Lean encoding of the v1.0.0 TOML grammar ([en][1], [abnf]][2])
+using `Lean.Parser` objects. The current encoding elides the use of
+tokens entirely, relying purely on custom parser functions.
+
+[1]: https://toml.io/en/v1.0.0
+[2]: https://github.com/toml-lang/toml/blob/1.0.0/toml.abnf
+-/
+
+namespace Lake.Toml
+
+open Lean Parser
+
+/-- Is it a TOML control character? (excludes tabs and spaces) -/
+def isControlChar (c : Char) :=
+  c = '\x7F' || (c < '\x20' && c != '\t')
+
+--------------------------------------------------------------------------------
+/-! ## Trailing Functions -/
+--------------------------------------------------------------------------------
+
+/-- Consume optional horizontal whitespace (i.e., tab or space). -/
+def wsFn : ParserFn :=
+  takeWhileFn fun c => c = ' ' || c = '\t'
+
+/-- Consumes the LF following a CR in a CRLF newline. -/
+def crlfAuxFn : ParserFn := fun c s =>
+  let input := c.input
+  let errMsg := "invalid newline; no LF after CR"
+  if h : input.atEnd s.pos then
+    s.mkUnexpectedError errMsg
+  else
+    let curr := input.get' s.pos h
+    if curr == '\n' then
+      s.next' input s.pos h
+    else
+      s.mkUnexpectedError errMsg
+
+/-- Consume a newline. -/
+def newlineFn : ParserFn := fun c s =>
+  let input := c.input
+  if h : input.atEnd s.pos then
+    s.mkEOIError ["newline"]
+  else
+    let curr := input.get' s.pos h
+    if curr == '\n' then
+      s.next' input s.pos h
+    else if curr == '\r' then
+      crlfAuxFn c (s.next' input s.pos h)
+    else
+      mkUnexpectedCharError s curr ["newline"]
+
+/-- Consumes the body of a comment. -/
+def commentBodyFn : ParserFn :=
+  -- While the v1.0.0 TOML ABNF grammar permits a `DEL`, the test suite does not.
+  -- We forbid it because it the omission seems likely to be an error
+  takeUntilFn isControlChar
+
+/-- Consumes a line comment. -/
+def commentFn : ParserFn :=
+  chFn '#' ["comment"] >> commentBodyFn
+
+/-- Consume optional whitespace (space, tab, or newline). -/
+partial def wsNewlineFn : ParserFn := fun c s =>
+  let input := c.input
+  if h : input.atEnd s.pos then
+    s
+  else
+    let curr := input.get' s.pos h
+    if curr = ' ' || curr = '\t' || curr == '\n' then
+      wsNewlineFn c (s.next' input s.pos  h)
+    else if curr == '\r' then
+      (crlfAuxFn >> wsNewlineFn) c (s.next' input s.pos  h)
+    else
+      s
+
+/-- Consume optional sequence of whitespace / newline(s) / comment (s). -/
+partial def trailingFn : ParserFn := fun c s =>
+  let input := c.input
+  if h : input.atEnd s.pos then
+    s
+  else
+    let curr := input.get' s.pos h
+    if curr = ' ' || curr = '\t' || curr == '\n' then
+      trailingFn c (s.next' input s.pos h)
+    else if curr == '\r' then
+      (crlfAuxFn >> trailingFn) c (s.next' input s.pos h)
+    else if curr == '#' then
+      (commentBodyFn >> trailingFn) c (s.next' input s.pos h)
+    else
+      s
+
+--------------------------------------------------------------------------------
+/-! ## Strings -/
+--------------------------------------------------------------------------------
+
+/-- A TOML character escape. -/
+def isEscapeChar (c : Char) : Bool :=
+  c == 'b' || c == 't' || c == 'n' || c == 'f' || c == 'r' || c == '\"' || c == '\\'
+
+/-- Consumes a TOML string escape sequence after a `\`. -/
+def escapeSeqFn (stringGap : Bool) : ParserFn := fun c s =>
+  let input := c.input
+  let expected := ["escape sequence"]
+  if h : input.atEnd s.pos then
+    s.mkEOIError expected
+  else
+    let curr := input.get' s.pos h
+    let ifStringGap (p : ParserFn) :=
+      if stringGap then
+        p c (s.next' input s.pos h)
+      else
+        s.mkUnexpectedError "string gap is forbidden here" expected
+    if isEscapeChar curr then
+      s.next' input s.pos h
+    else if curr == 'u' then
+      repeatFn 4 hexDigitFn c (s.next' input s.pos h)
+    else if curr == 'U' then
+      repeatFn 8 hexDigitFn c (s.next' input s.pos h)
+    else if curr == ' ' || curr == '\t' then
+      ifStringGap (wsFn >> newlineFn >> wsNewlineFn)
+    else if curr == '\n' then
+      ifStringGap wsNewlineFn
+    else if curr == '\r' then
+      ifStringGap (crlfAuxFn >> wsNewlineFn)
+    else
+      s.mkUnexpectedError "invalid escape sequence"
+
+partial def basicStringAuxFn (startPos : String.Pos) : ParserFn := fun c s =>
+  let input := c.input
+  if h : input.atEnd s.pos then
+    s.mkUnexpectedErrorAt "unterminated basic string" startPos
+  else
+    let curr := input.get' s.pos h
+    if curr == '\"' then
+      s.next' input s.pos h
+    else if curr == '\\' then
+      (escapeSeqFn false >> basicStringAuxFn startPos) c (s.next' input s.pos h)
+    else if isControlChar curr then
+      mkUnexpectedCharError s curr
+    else
+      basicStringAuxFn startPos c (s.next' input s.pos h)
+
+def basicStringFn : ParserFn := usePosFn fun startPos =>
+  chFn '\"' ["basic string"] >> basicStringAuxFn startPos
+
+partial def literalStringAuxFn (startPos : String.Pos) : ParserFn := fun c s =>
+  let input := c.input
+  if h : input.atEnd s.pos then
+    s.mkUnexpectedErrorAt "unterminated literal string" startPos
+  else
+    let curr := input.get' s.pos h
+    if curr == '\'' then
+      s.next' input s.pos h
+    else if isControlChar curr then
+      mkUnexpectedCharError s curr
+    else
+      literalStringAuxFn startPos c (s.next' input s.pos h)
+
+def literalStringFn : ParserFn := usePosFn fun startPos =>
+  chFn '\'' ["literal string"] >> literalStringAuxFn startPos
+
+partial def mlLiteralStringAuxFn (startPos : String.Pos) (quoteDepth : Nat)  : ParserFn := fun c s =>
+  let input := c.input
+  if h : input.atEnd s.pos then
+    if quoteDepth ≥ 3 then
+      s
+    else
+      s.mkUnexpectedErrorAt "unterminated multi-line literal string" startPos
+  else
+    let curr := input.get' s.pos h
+    if curr == '\'' then
+      let s := s.next' input s.pos h
+      if quoteDepth ≥ 5 then
+        s.mkUnexpectedError "too many quotes"
+      else
+        mlLiteralStringAuxFn startPos (quoteDepth+1) c s
+    else if quoteDepth ≥ 3 then
+      s
+    else if curr == '\n' then
+      mlLiteralStringAuxFn startPos 0 c (s.next' input s.pos h)
+    else if curr == '\r' then
+      (crlfAuxFn >> mlLiteralStringAuxFn startPos 0) c (s.next' input s.pos h)
+    else if isControlChar curr then
+      mkUnexpectedCharError s curr
+    else
+      mlLiteralStringAuxFn startPos 0 c (s.next' input s.pos h)
+
+def mlLiteralStringFn : ParserFn := usePosFn fun startPos =>
+  atomicFn (repeatFn 3 (chFn '\'' ["multi-line literal string"])) >>
+  mlLiteralStringAuxFn startPos 0
+
+partial def mlBasicStringAuxFn (startPos : String.Pos) (quoteDepth : Nat)  : ParserFn := fun c s =>
+  let input := c.input
+  if h : input.atEnd s.pos then
+    if quoteDepth ≥ 3 then
+      s
+    else
+      s.mkUnexpectedErrorAt "unterminated multi-line basic string" startPos
+  else
+    let curr := input.get' s.pos h
+    if curr == '\"' then
+      let s := s.next' input s.pos h
+      if quoteDepth ≥ 5 then
+        s.mkUnexpectedError "too many quotes"
+      else
+        mlBasicStringAuxFn startPos (quoteDepth+1) c s
+    else if quoteDepth ≥ 3 then
+      s
+    else if curr == '\n' then
+      mlBasicStringAuxFn startPos 0 c (s.next' input s.pos h)
+    else if curr == '\r' then
+      (crlfAuxFn >> mlBasicStringAuxFn startPos 0) c (s.next' input s.pos h)
+    else if curr == '\\' then
+      (escapeSeqFn true >> mlBasicStringAuxFn startPos 0) c (s.next' input s.pos h)
+    else if isControlChar curr then
+      mkUnexpectedCharError s curr
+    else
+      mlBasicStringAuxFn startPos 0 c (s.next' input s.pos h)
+
+def mlBasicStringFn : ParserFn := usePosFn fun startPos =>
+  atomicFn (repeatFn 3 (chFn '\"' ["multi-line basic string"])) >>
+  mlBasicStringAuxFn startPos 0
+
+--------------------------------------------------------------------------------
+/-! ## Numerals (Date-Times, Floats, and Integers) -/
+--------------------------------------------------------------------------------
+
+def hourMinFn : ParserFn :=
+  digitPairFn ["hour digit"] >> chFn ':' >> digitPairFn ["minute digit"]
+
+def timeTailFn (allowOffset : Bool) : ParserFn := fun c s =>
+  let input := c.input
+  if h : input.atEnd s.pos then
+    s
+  else
+    let curr := input.get' s.pos h
+    if curr = '.' then
+      let s := s.next' input s.pos h
+      let s := takeWhile1Fn (·.isDigit) ["millisecond"] c s
+      if s.hasError then s else
+      if h : input.atEnd s.pos then s else
+      timeOffsetFn (input.get' s.pos h) (input.next' s.pos h) c s
+    else
+      timeOffsetFn curr (input.next' s.pos h) c s
+where
+  @[inline] timeOffsetFn curr nextPos c s :=
+    if curr == 'Z' || curr == 'z' then
+      if allowOffset then s.setPos nextPos else
+      s.mkUnexpectedError "time offset is forbidden here"
+    else if curr = '+' || curr = '-' then
+      if allowOffset then hourMinFn c (s.setPos nextPos) else
+      s.mkUnexpectedError "time offset is forbidden here"
+    else
+      s
+
+def timeAuxFn (allowOffset : Bool) : ParserFn :=
+  digitPairFn ["minute digit"] >> chFn ':' >>
+  digitPairFn ["second digit"] >> timeTailFn allowOffset
+
+def timeFn (allowOffset := false) : ParserFn :=
+  digitPairFn ["hour"] >> chFn ':' >> timeAuxFn allowOffset
+
+def optTimeFn : ParserFn := fun c s =>
+  let i := s.pos
+  let input := c.input
+  if h : input.atEnd i then
+    s
+  else
+    let curr := input.get' i h
+    if curr = 'T' || curr = 't' then
+      timeFn true c (s.next' input i h)
+    else if curr = ' ' then
+      let tPos := input.next' i h
+      let s := timeFn true c (s.setPos tPos)
+      if s.hasError && s.pos == tPos then s.restore (s.stackSize-1) i else s
+    else
+      s
+
+def dateTimeAuxFn : ParserFn :=
+  digitPairFn ["month digit"] >> chFn '-' >>
+  digitPairFn ["day digit"] >> optTimeFn
+
+def dateTimeFn : ParserFn :=
+  repeatFn 4 (digitFn ["year digit"]) >> chFn '-' >> dateTimeAuxFn
+
+def dateTimeLitFn : ParserFn :=
+  litFn `Lake.Toml.dateTime dateTimeFn
+
+def decExpFn : ParserFn := fun c s =>
+  let input := c.input
+  let expected := ["decimal exponent"]
+  if h : input.atEnd s.pos then
+    s.mkEOIError expected
+  else
+    let curr := input.get' s.pos h
+    if curr = '-' || curr == '+' then
+      let s := s.next' input s.pos h
+      sepByChar1Fn (·.isDigit) '_' expected c s
+    else if curr.isDigit then
+      let s := s.next' input s.pos h
+      sepByChar1AuxFn (·.isDigit) '_' expected c s
+    else
+      mkUnexpectedCharError s curr expected
+
+def optDecExpFn : ParserFn :=  fun c s =>
+  let input := c.input
+  if h : input.atEnd s.pos then
+    s
+  else
+    let curr := input.get' s.pos h
+    if curr == 'e' || curr == 'E' then
+      decExpFn c (s.next' input s.pos h)
+    else
+      s
+
+def decNumberTailAuxFn (startPos : String.Pos) (curr : Char) (nextPos : String.Pos) : ParserFn := fun c s =>
+  if curr == '.' then
+    let s := s.setPos nextPos
+    let s := sepByChar1Fn (·.isDigit) '_' ["decimal fraction"] c s
+    if s.hasError then s else
+    let s := optDecExpFn c s
+    if s.hasError then s else
+    pushLit `Lake.Toml.float startPos skipFn c s
+  else if curr == 'e' || curr == 'E' then
+    let s := s.setPos nextPos
+    let s := decExpFn c s
+    if s.hasError then s else
+    pushLit `Lake.Toml.float startPos skipFn c s
+  else
+    pushLit `Lake.Toml.decInt startPos skipFn c s
+
+def decNumberTailFn (startPos : String.Pos)  : ParserFn := fun c s =>
+  let input := c.input
+  if h : input.atEnd s.pos then
+    pushLit `Lake.Toml.decInt startPos skipFn c s
+  else
+    decNumberTailAuxFn startPos (input.get' s.pos h) (input.next' s.pos h) c s
+
+mutual
+
+partial def decNumberSepFn (startPos : String.Pos) (curr : Char) (nextPos : String.Pos) : ParserFn := fun c s =>
+  if curr == '_' then
+    let s := s.setPos nextPos
+    decNumberFn startPos c s
+  else
+    decNumberTailAuxFn startPos curr nextPos c s
+
+partial def decNumberAuxFn (startPos : String.Pos) : ParserFn := fun c s =>
+  let input := c.input
+  if h : input.atEnd s.pos then
+    pushLit `Lake.Toml.decInt startPos skipFn c s
+  else
+    let curr := input.get' s.pos h
+    if curr.isDigit then
+      let s := s.next' input s.pos h
+      decNumberAuxFn startPos c s
+    else
+      decNumberSepFn startPos curr (input.next' s.pos h) c s
+
+partial def decNumberFn (startPos : String.Pos) : ParserFn := fun c s =>
+  let i := s.pos
+  let input := c.input
+  let expected := ["decimal integer", "float"]
+  if h : input.atEnd i then
+    s.mkEOIError expected
+  else
+    let curr := input.get' i h
+    if curr.isDigit then
+      let s := s.next' input i h
+      decNumberAuxFn startPos c s
+    else
+      mkUnexpectedCharError s curr expected
+
+end
+
+def infAuxFn (startPos : String.Pos) : ParserFn :=
+  strFn "nf" ["'inf'"] >> pushLit `Lake.Toml.float startPos
+
+def nanAuxFn (startPos : String.Pos) : ParserFn :=
+  strFn "an" ["'nan'"] >> pushLit `Lake.Toml.float startPos
+
+def decimalFn (startPos : String.Pos) : ParserFn := fun c s =>
+  let input := c.input
+  let expected := ["decimal integer", "float"]
+  if h : input.atEnd s.pos then
+    s.mkEOIError expected
+  else
+    let curr := input.get' s.pos h
+    if curr == '0' then
+      decNumberTailFn startPos c (s.next' input s.pos h)
+    else if curr.isDigit then
+      decNumberAuxFn startPos c (s.next' input s.pos h)
+    else if curr == 'i' then
+      infAuxFn startPos c (s.next' input s.pos h)
+    else if curr == 'n' then
+      nanAuxFn startPos c (s.next' input s.pos h)
+    else
+      mkUnexpectedCharError s curr expected
+
+def decNumeralAuxFn (startPos : String.Pos) : ParserFn := fun c s =>
+  let input := c.input
+  if h : input.atEnd s.pos then
+    s.mkEOIError ["decimal integer", "float", "date-time"]
+  else -- `NN`
+    let curr := input.get' s.pos h
+    let nextPos := input.next' s.pos h
+    if curr.isDigit then
+      let s := s.setPos nextPos
+      if h : input.atEnd s.pos then
+        pushLit `Lake.Toml.decInt startPos skipFn c s
+      else
+        let curr := input.get' s.pos h
+        let nextPos := input.next' s.pos h
+        if curr == ':' then -- `HH:`
+          let s := s.setPos nextPos
+          let s := timeAuxFn false c s
+          if s.hasError then s else
+          pushLit `Lake.Toml.dateTime startPos skipFn c s
+        else if curr.isDigit then -- `NNN`
+          let s := s.setPos nextPos
+          if h : input.atEnd s.pos then
+            pushLit `Lake.Toml.decInt startPos skipFn c s
+          else
+            let curr := input.get' s.pos h
+            let nextPos := input.next' s.pos h
+            if curr.isDigit then -- `NNNN`
+              let s := s.setPos nextPos
+              if h : input.atEnd nextPos then
+                pushLit `Lake.Toml.decInt startPos skipFn c s
+              else
+                let curr := input.get' s.pos h
+                let nextPos := input.next' s.pos h
+                if curr == '-' then -- `YYYY-`
+                  let s := s.setPos nextPos
+                  let s := dateTimeAuxFn c s
+                  if s.hasError then s else
+                  pushLit `Lake.Toml.dateTime startPos skipFn c s
+                else if curr.isDigit then
+                  let s := s.setPos nextPos
+                  decNumberAuxFn startPos c s
+                else
+                  decNumberSepFn startPos curr nextPos c s
+            else
+              decNumberSepFn startPos curr nextPos c s
+        else
+          decNumberSepFn startPos curr nextPos c s
+    else
+      decNumberSepFn startPos curr nextPos c s
+
+def numeralFn : ParserFn := atomicFn fun c s =>
+  let input := c.input
+  let startPos := s.pos
+  let expected := ["integer", "float", "date-time"]
+  if h : input.atEnd s.pos then
+    s.mkEOIError expected
+  else
+    let curr := input.get' s.pos h
+    if curr == '0' then
+      let s := s.next' input startPos h
+      if h : input.atEnd s.pos then
+        pushLit `Lake.Toml.decInt startPos skipFn c s
+      else
+        let curr := input.get' s.pos h
+        if curr == 'b' then
+          let s := s.next' input s.pos h
+          let s := sepByChar1Fn isBinDigit '_' ["binary integer"] c s
+          if s.hasError then s else
+          pushLit `Lake.Toml.binNum startPos skipFn c s
+        else if curr == 'o' then
+          let s := s.next' input s.pos h
+          let s := sepByChar1Fn isOctDigit '_' ["octal integer"] c s
+          if s.hasError then s else
+          pushLit `Lake.Toml.octNum startPos skipFn c s
+        else if curr == 'x' then
+          let s := s.next' input s.pos h
+          let s := sepByChar1Fn isHexDigit '_' ["hexadecimal integer"] c s
+          if s.hasError then s else
+          pushLit `Lake.Toml.hexNum startPos skipFn c s
+        else if curr.isDigit then
+          let s := s.next' input s.pos h
+          let s := (chFn ':' >> timeAuxFn false) c s
+          if s.hasError then s else
+          pushLit `Lake.Toml.dateTime startPos skipFn c s
+        else
+          decNumberTailAuxFn startPos curr (input.next' s.pos h) c s
+    else if curr.isDigit then
+      decNumeralAuxFn startPos c (s.next' input s.pos h)
+    else if curr == '+' || curr == '-' then
+      decimalFn startPos c (s.next' input s.pos h)
+    else if curr == 'i' then
+      infAuxFn startPos c (s.next' input s.pos h)
+    else if curr == 'n' then
+      nanAuxFn startPos c (s.next' input s.pos h)
+    else
+      s.mkUnexpectedError s!"unexpected '{curr}'" expected
+
+--------------------------------------------------------------------------------
+/-! ## Parsers -/
+--------------------------------------------------------------------------------
+
+def trailingWs : Parser :=
+  trailing wsFn
+
+def trailingSep : Parser :=
+  trailing trailingFn
+
+def unquotedKeyFn : ParserFn :=
+  takeWhile1Fn (fun c => c.isAlphanum || c == '_' || c == '-') ["unquoted key"]
+
+def unquotedKey : Parser :=
+  litWithAntiquot "unquotedKey" `Lake.Toml.unquotedKey unquotedKeyFn
+
+def basicString : Parser :=
+  litWithAntiquot "basicString" `Lake.Toml.basicString basicStringFn
+
+def literalString : Parser :=
+  litWithAntiquot "literalString" `Lake.Toml.literalString literalStringFn
+
+def mlBasicString : Parser :=
+  litWithAntiquot "mlBasicString" `Lake.Toml.mlBasicString mlBasicStringFn
+
+def mlLiteralString : Parser :=
+  litWithAntiquot "mlLiteralString" `Lake.Toml.mlLiteralString mlLiteralStringFn
+
+def quotedKey : Parser :=
+  basicString <|> literalString
+
+def simpleKey : Parser := nodeWithAntiquot "simpleKey" `Lake.Toml.simpleKey (anonymous := true) $
+  unquotedKey <|> quotedKey
+
+def key : Parser := nodeWithAntiquot "key" `Lake.Toml.key (anonymous := true)  $ setExpected ["key"]  $
+  sepBy1 simpleKey "." (trailingWs >> chAtom '.' >> trailingWs)
+
+def stdTable : Parser := nodeWithAntiquot "stdTable" `Lake.Toml.stdTable $
+  atomic (chAtom '[' ["table"] >> notFollowedBy (chAtom '[') "'['") >>
+  trailingWs >> key >> trailingWs >> chAtom ']'
+
+def arrayTable : Parser := nodeWithAntiquot "arrayTable" `Lake.Toml.arrayTable $
+  atomic (chAtom '[' ["table"] >> chAtom '[' ) >>
+  trailingWs >> key >> trailingWs >> chAtom ']' >> chAtom ']'
+
+def table :=
+  stdTable <|> arrayTable
+
+def keyvalCore (val : Parser) : Parser := nodeWithAntiquot "keyval" `Lake.Toml.keyval (anonymous := true) $
+  key >> trailingWs >> chAtom '=' >> trailingWs >> val
+
+def expressionCore (val : Parser) : Parser :=
+  withAntiquot (mkAntiquot "expression" `Lake.Toml.expression (isPseudoKind := true)) $
+  keyvalCore val <|> table
+
+def header : Parser :=
+  litWithAntiquot "header" `Lake.Toml.header skipFn trailingFn
+
+def tomlCore (val : Parser) : Parser :=
+  nodeWithAntiquot "toml" `Lake.Toml.toml (anonymous := true) $
+  header >> sepByLinebreak (expressionCore val >> trailingSep)
+
+def inlineTableCore (val : Parser) : Parser := nodeWithAntiquot "inlineTable" `Lake.Toml.inlineTable $
+  chAtom '{' ["inline-table"] (trailingFn := trailingFn) >>
+  sepBy (keyvalCore val >> trailingWs) "," (chAtom ',' (trailingFn := wsFn)) false >>
+  chAtom '}'
+
+def arrayCore (val : Parser) : Parser := nodeWithAntiquot "array" `Lake.Toml.array $
+  chAtom '[' ["array"] (trailingFn := trailingFn) >>
+  sepBy (val >> trailingSep) "," (chAtom ',' (trailingFn := trailingFn)) true >>
+  chAtom ']'
+
+def string : Parser :=
+  nodeWithAntiquot "string" `Lake.Toml.string $ setExpected ["string"] $
+  mlBasicString <|> basicString <|> mlLiteralString <|> literalString
+
+protected def true : Parser :=
+  lit `Lake.Toml.true $ strFn "true"
+
+protected def false : Parser :=
+  lit `Lake.Toml.false $ strFn "false"
+
+def boolean : Parser :=
+  nodeWithAntiquot "boolean" `Lake.Toml.boolean $
+  Toml.true <|> Toml.false
+
+def numeralAntiquot :=
+  mkAntiquot "float" `Lake.Toml.float (anonymous := false) <|>
+  mkAntiquot "decInt" `Lake.Toml.decInt (anonymous := false) <|>
+  mkAntiquot "binNum" `Lake.Toml.binNum (anonymous := false) <|>
+  mkAntiquot "octNum" `Lake.Toml.octNum (anonymous := false) <|>
+  mkAntiquot "hexNum" `Lake.Toml.hexNum (anonymous := false) <|>
+  mkAntiquot "dateTime" `Lake.Toml.dateTime (anonymous := false) <|>
+  mkAntiquot "numeral" `Lake.Toml.numeral (isPseudoKind := true)
+
+/- A value starting with a numeral. Either a TOML date-time, float, or integer. -/
+def numeral : Parser :=
+  withAntiquot numeralAntiquot $ dynamicNode numeralFn
+
+def numeralOfKind (name : String) (kind : SyntaxNodeKind) : Parser :=
+  numeral >> setExpected [name] (checkStackTop (·.isOfKind kind) "illegal numeral kind")
+
+def float : Parser :=
+  numeralOfKind "float" `Lake.Toml.float
+
+def decInt : Parser :=
+  numeralOfKind "decimal integer" `Lake.Toml.decInt
+
+def binNum : Parser :=
+  numeralOfKind "binary number" `Lake.Toml.binNum
+
+def octNum : Parser :=
+  numeralOfKind "octal number" `Lake.Toml.octNum
+
+def hexNum : Parser :=
+  numeralOfKind "hexadecimal number" `Lake.Toml.hexNum
+
+def dateTime : Parser :=
+  numeralOfKind "date-time" `Lake.Toml.dateTime
+
+def valCore (val : Parser) : Parser :=
+  string <|> boolean <|> numeral <|>
+  arrayCore val <|> inlineTableCore val
+
+def val : Parser :=
+  recNodeWithAntiquot "val" `Lake.Toml.val valCore (anonymous := true)
+
+def array : Parser :=
+  arrayCore val
+
+def inlineTable : Parser :=
+  inlineTableCore val
+
+def keyval : Parser :=
+  keyvalCore val
+
+def expression : Parser :=
+  expressionCore val
+
+@[run_parser_attribute_hooks] def toml : Parser :=
+  withCache `Lake.Toml.toml $ tomlCore val
diff --git a/src/lake/Lake/Toml/Load.lean b/src/lake/Lake/Toml/Load.lean
new file mode 100644
index 0000000000..919ff4e694
--- /dev/null
+++ b/src/lake/Lake/Toml/Load.lean
@@ -0,0 +1,34 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Toml.Elab
+import Lake.Util.Message
+
+open Lean Parser
+
+namespace Lake.Toml
+
+/-- Load a TOML table from some input. -/
+def loadToml (ictx : InputContext) : EIO MessageLog Table := do
+  let env ←
+    match (← mkEmptyEnvironment.toBaseIO) with
+    | .ok env => pure env
+    | .error e => throw <| MessageLog.empty.add <| mkMessageNoPos ictx <|
+      m!"failed to initialize TOML environment: {e}"
+  let s := toml.fn.run ictx { env, options := {} } {} (mkParserState ictx.input)
+  if let some errorMsg := s.errorMsg then
+    throw <|  MessageLog.empty.add <| mkParserErrorMessage ictx s errorMsg
+  else if ictx.input.atEnd s.pos then
+    let act := elabToml ⟨s.stxStack.back⟩
+    match (← act.run {fileName := ictx.fileName, fileMap := ictx.fileMap} {env} |>.toBaseIO) with
+    | .ok (t, s) =>
+      if s.messages.hasErrors then
+        throw s.messages
+      else
+        return t
+    | .error e =>
+      throw <| MessageLog.empty.add <| mkExceptionMessage ictx e
+  else
+    throw <| MessageLog.empty.add <| mkParserErrorMessage ictx s {expected := ["end of input"]}
diff --git a/src/lake/Lake/Toml/ParserUtil.lean b/src/lake/Lake/Toml/ParserUtil.lean
new file mode 100644
index 0000000000..43e3d2070e
--- /dev/null
+++ b/src/lake/Lake/Toml/ParserUtil.lean
@@ -0,0 +1,301 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lean.Parser
+import Lean.PrettyPrinter.Formatter
+
+/-!
+# TOML Parser Utilities
+
+Generic parser utilities used by Lake's TOML parser.
+-/
+
+namespace Lake.Toml
+
+open Lean Parser PrettyPrinter Formatter
+
+def isBinDigit (c : Char) : Bool :=
+  c == '0' || c == '1'
+
+def isOctDigit (c : Char) : Bool :=
+  '0' ≤ c && c ≤ '7'
+
+def isHexDigit (c : Char) : Bool :=
+  ('0' ≤ c && c ≤ '9') || ('a' ≤ c && c ≤ 'f') || ('A' ≤ c && c ≤ 'F')
+
+def skipFn : ParserFn := fun _ s => s
+
+scoped instance : AndThen ParserFn where
+  andThen p q := fun c s => let s := p c s; if s.hasError then s else q () c s
+
+/-- `ParserFn` combinator that runs `f` with the current position. -/
+@[always_inline, inline] def usePosFn (f : String.Pos → ParserFn) : ParserFn :=
+  fun c s => f s.pos c s
+
+/-- Match an arbitrary parser or do nothing. -/
+def optFn (p : ParserFn) : ParserFn := fun c s =>
+  let iniSz  := s.stackSize
+  let iniPos := s.pos
+  let s := p c s
+  if s.hasError && s.pos == iniPos then s.restore iniSz iniPos else  s
+
+/-- A sequence of `n` repetitions of a parser function. -/
+@[inline] def repeatFn (n : Nat) (p : ParserFn) : ParserFn := fun c s =>
+  let rec @[specialize] loop
+    | 0, s => s
+    | n+1, s =>
+      let s := p c s
+      if s.hasError then s else loop n s
+  loop n s
+
+def mkUnexpectedCharError (s : ParserState) (c : Char)  (expected : List String := []) (pushMissing := true) : ParserState :=
+  s.mkUnexpectedError s!"unexpected '{c}'" expected pushMissing
+
+@[inline] def satisfyFn (p : Char → Bool) (expected : List String := [])  : ParserFn := fun c s =>
+  let i := s.pos
+  if h : c.input.atEnd i then
+    s.mkEOIError expected
+  else
+    let curr := c.input.get' i h
+    if p curr then
+      s.next' c.input i h
+    else
+      mkUnexpectedCharError s curr expected
+
+def takeWhile1Fn (p : Char → Bool) (expected : List String := []) : ParserFn :=
+  satisfyFn p expected >> takeWhileFn p
+
+/-- Consume a single digit (i.e., `Char.isDigit`). -/
+def digitFn (expected : List String := ["digit"]) : ParserFn :=
+  satisfyFn Char.isDigit expected
+
+/-- Consume a two digits (i.e., `Char.isDigit`). -/
+def digitPairFn (expected := ["digit"]) : ParserFn :=
+  digitFn expected >> digitFn expected
+
+/-- Consume a single matching character. -/
+def chFn (c : Char) (expected : List String := [s!"'{c}'"]) : ParserFn :=
+  satisfyFn (fun d => d == c) expected
+
+partial def strAuxFn (str : String) (expected : List String) (strPos : String.Pos) : ParserFn := fun c s =>
+  if h₁ : str.atEnd strPos then
+    s
+  else
+    let s := chFn (str.get' strPos h₁) expected c s
+    if s.hasError then s else strAuxFn str expected (str.next' strPos h₁) c s
+
+/-- Consume a matching string atomically. -/
+def strFn (str : String) (expected : List String := [s!"'{str}'"]) : ParserFn :=
+  atomicFn <| strAuxFn str expected 0
+
+mutual
+
+partial def sepByChar1AuxFn (p : Char → Bool) (sep : Char) (expected : List String := []) : ParserFn := fun c s =>
+  let i := s.pos
+  let input := c.input
+  if h : input.atEnd i then
+    s
+  else
+    let curr := input.get' i h
+    if p curr then
+      sepByChar1AuxFn p sep expected c (s.next' input i h)
+    else if curr == sep then
+      sepByChar1Fn p sep expected c (s.next' input i h)
+    else
+      s
+
+partial def sepByChar1Fn (p : Char → Bool) (sep : Char) (expected : List String := []) : ParserFn := fun c s =>
+  let i := s.pos
+  let input := c.input
+  if h : input.atEnd i then
+    s
+  else
+    let curr := input.get' i h
+    let s := s.next' input i h
+    if p curr then
+      sepByChar1AuxFn p sep expected c s
+    else if curr == sep then
+      s.mkUnexpectedError s!"unexpected separator '{curr}'" expected
+    else
+      mkUnexpectedCharError s curr expected
+
+end
+
+/-- Push a new atom onto the syntax stack. -/
+def pushAtom (startPos : String.Pos) (trailingFn := skipFn) : ParserFn := fun c s =>
+  let input    := c.input
+  let stopPos  := s.pos
+  let leading  := mkEmptySubstringAt input startPos
+  let val      := input.extract startPos stopPos
+  let s        := trailingFn c s
+  let stopPos' := s.pos
+  let trailing := { str := input, startPos := stopPos, stopPos := stopPos' : Substring }
+  let atom     := mkAtom (SourceInfo.original leading startPos trailing (startPos + val)) val
+  s.pushSyntax atom
+
+/-- Match an arbitrary `ParserFn` and return the consumed String in a `Syntax.atom`. -/
+def atomFn (p : ParserFn) (trailingFn := skipFn) : ParserFn := fun c s =>
+  let startPos := s.pos
+  let s := p c s
+  if s.hasError then s else
+  pushAtom startPos trailingFn c s
+
+def atom (p : ParserFn) (trailingFn := skipFn) : Parser where
+  fn := atomFn p trailingFn
+
+def getInfoExprPos? : SourceInfo → Option String.Pos
+  | SourceInfo.synthetic (pos := pos) .. => pos
+  | _ => none
+
+def getSyntaxExprPos? : Syntax → Option String.Pos
+  | .node info _ _ => getInfoExprPos? info
+  | .atom info _ => getInfoExprPos? info
+  | .ident info _ _ _ => getInfoExprPos? info
+  | .missing => none
+
+open Formatter Syntax.MonadTraverser in
+@[combinator_formatter atom] def atom.formatter (_ _ : ParserFn) : Formatter := do
+  let stx ← getCur
+  let .atom info val := stx
+    | trace[PrettyPrinter.format.backtrack] "unexpected syntax '{format stx}', expected atom"
+      throwBacktrack
+  withMaybeTag (getSyntaxExprPos? stx) (pushToken info val)
+  goLeft
+
+@[combinator_parenthesizer atom]
+def atom.parenthesizer (_  _ : ParserFn) : Parenthesizer :=
+  Parenthesizer.visitToken
+
+/-- Parse a single character as an atom. -/
+def chAtom (c : Char) (expected := [s!"'{c}'"]) (trailingFn := skipFn) : Parser :=
+  atom (chFn c expected) trailingFn
+
+@[combinator_formatter chAtom]
+def chAtom.formatter (c : Char) (_ : List String) (_ : ParserFn) : Formatter :=
+  rawCh.formatter c
+
+@[combinator_parenthesizer chAtom]
+def chAtom.parenthesizer (_ : Char) (_  : List String) (_ : ParserFn) : Parenthesizer :=
+  Parenthesizer.visitToken
+
+/-- Parse the trimmed string as an atom (but use the full string for formatting). -/
+def strAtom (s : String) (expected := [s!"'{s}'"]) (trailingFn := skipFn) : Parser :=
+  atom (strFn s.trim expected) trailingFn
+
+@[combinator_formatter strAtom]
+def strAtom.formatter (s : String) (_ : List String) (_ : ParserFn) : Formatter :=
+  symbolNoAntiquot.formatter s
+
+@[combinator_parenthesizer strAtom]
+def strAtom.parenthesizer (_ : String) (_  : List String) (_ : ParserFn) : Parenthesizer :=
+  Parenthesizer.visitToken
+
+/-- Push `(Syntax.node kind <new-atom>)` onto the syntax stack. -/
+def pushLit (kind : SyntaxNodeKind) (startPos : String.Pos) (trailingFn := skipFn) : ParserFn := fun c s =>
+  let input     := c.input
+  let stopPos   := s.pos
+  let leading   := mkEmptySubstringAt input startPos
+  let val       := input.extract startPos stopPos
+  let s         := trailingFn c s
+  let wsStopPos := s.pos
+  let trailing  := { str := input, startPos := stopPos, stopPos := wsStopPos : Substring }
+  let info      := SourceInfo.original leading startPos trailing stopPos
+  s.pushSyntax (Syntax.mkLit kind val info)
+
+def litFn (kind : SyntaxNodeKind) (p : ParserFn) (trailingFn := skipFn) : ParserFn := fun c s =>
+  let iniPos := s.pos
+  let s := p c s
+  if s.hasError then s else
+  pushLit kind iniPos trailingFn c s
+
+def lit (kind : SyntaxNodeKind) (p : ParserFn) (trailingFn := skipFn) : Parser where
+  fn := litFn kind p trailingFn
+
+@[combinator_formatter lit]
+def lit.formatter (kind : SyntaxNodeKind) (_ _ : ParserFn) : Formatter :=
+  visitAtom kind
+
+@[combinator_parenthesizer lit]
+def lit.parenthesizer (_ : SyntaxNodeKind) (_ _ : ParserFn) : Parenthesizer :=
+  Parenthesizer.visitToken
+
+def litWithAntiquot (name : String) (kind : SyntaxNodeKind) (p : ParserFn) (trailingFn := skipFn) (anonymous := false) : Parser :=
+  withAntiquot (mkAntiquot name kind anonymous) $ lit kind p trailingFn
+
+@[inline] def epsilon (fn : ParserFn) : Parser :=
+  {fn := fn, info := epsilonInfo}
+
+@[combinator_formatter epsilon]
+def epsilon.formatter (_ : ParserFn) : Formatter := pure ()
+
+@[combinator_parenthesizer epsilon]
+def epsilon.parenthesizer (_ : ParserFn) : Parenthesizer := pure ()
+
+def SourceInfo.updateTrailing (trailing : Substring) : SourceInfo → SourceInfo
+  | SourceInfo.original leading pos _ endPos => SourceInfo.original leading pos trailing endPos
+  | info                                     => info
+
+partial def modifyTailInfo (f : SourceInfo → SourceInfo) : (stx : Syntax) → Syntax
+  | .atom info val => .atom (f info) val
+  | .ident info rawVal val pre => .ident (f info) rawVal val pre
+  | .node info k args =>
+    .node info k <| args.modify (args.size - 1) (modifyTailInfo f)
+  | s => s
+
+def extendTrailingFn (p : ParserFn) : ParserFn := fun c s =>
+  let s := p c s
+  let stopPos := s.pos
+  let tail := s.stxStack.back
+  let s := s.popSyntax -- try for linearity
+  let tail := modifyTailInfo (stx := tail) fun
+    | .original leading pos trailing endPos =>
+      .original leading pos {trailing with stopPos} endPos
+    | info => info
+  s.pushSyntax tail
+
+def trailing (p : ParserFn) : Parser :=
+  epsilon (extendTrailingFn p)
+
+def dynamicNode (p : ParserFn) : Parser where
+  fn := p
+
+@[combinator_formatter dynamicNode]
+def dynamicNode.formatter (_ : ParserFn) : Formatter := do
+  formatterForKind (← Syntax.MonadTraverser.getCur).getKind
+
+@[combinator_parenthesizer dynamicNode]
+def dynamicNode.parenthesizer (_ : ParserFn) : Parenthesizer := do
+  Parenthesizer.parenthesizerForKind (← Syntax.MonadTraverser.getCur).getKind
+
+partial def recNodeFn (f : Parser → Parser) : ParserFn :=
+  f (dynamicNode (recNodeFn f)) |>.fn
+
+/--
+`Parser → Parser` hidden by an `abbrev`.
+Prevents the formatter/parenthesizer generator from transforming it.
+-/
+abbrev ParserMapFn := Parser → Parser
+
+def recNode (f : ParserMapFn) : Parser :=
+  dynamicNode (recNodeFn f)
+
+def recNodeWithAntiquot (name : String) (kind : SyntaxNodeKind) (f : ParserMapFn) (anonymous := false) : Parser :=
+  withCache kind $ withAntiquot (mkAntiquot name kind anonymous true) $ recNode go
+where
+  go p := withCache kind $ withAntiquot (mkAntiquot name kind anonymous true) $ f p
+
+@[inline] def sepByLinebreak (p : Parser) (allowTrailingLinebreak := true) : Parser :=
+  let p := withAntiquotSpliceAndSuffix `sepBy p (symbol "*")
+  sepByNoAntiquot p (checkLinebreakBefore >> pushNone) allowTrailingLinebreak
+
+@[inline] def sepBy1Linebreak (p : Parser) (allowTrailingLinebreak := true) : Parser :=
+  let p := withAntiquotSpliceAndSuffix `sepBy p (symbol "*")
+  sepBy1NoAntiquot p (checkLinebreakBefore >> pushNone) allowTrailingLinebreak
+
+def skipInsideQuotFn (p : ParserFn) : ParserFn := fun c s =>
+  if c.quotDepth > 0 then s else p c s
+
+@[run_parser_attribute_hooks] def skipInsideQuot (p : Parser) : Parser :=
+  withFn skipInsideQuotFn p
diff --git a/src/lake/Lake/Util/FilePath.lean b/src/lake/Lake/Util/FilePath.lean
new file mode 100644
index 0000000000..c614a32c8b
--- /dev/null
+++ b/src/lake/Lake/Util/FilePath.lean
@@ -0,0 +1,28 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lean.ToExpr
+import Lean.Data.Json
+
+open System Lean
+
+namespace Lake
+
+/--
+Convert a relative file path to a platform-independent string.
+Uses `/` as the path separator, even on Windows.
+-/
+def mkRelPathString (path : FilePath) : String :=
+  if System.Platform.isWindows then
+    path.toString.map fun c => if c = '\\' then '/' else c
+  else
+    path.toString
+
+scoped instance : ToJson FilePath where
+  toJson path := toJson <| mkRelPathString path
+
+scoped instance : ToExpr FilePath where
+  toExpr p := mkApp (mkConst ``System.FilePath.mk) (toExpr p.toString)
+  toTypeExpr := mkConst ``System.FilePath
diff --git a/src/lake/Lake/Util/Message.lean b/src/lake/Lake/Util/Message.lean
new file mode 100644
index 0000000000..0d7847fa6c
--- /dev/null
+++ b/src/lake/Lake/Util/Message.lean
@@ -0,0 +1,65 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lean.Message
+import Lean.Exception
+import Lean.Parser.Basic
+
+open Lean Parser
+
+namespace Lake
+
+def mkParserErrorMessage (ictx : InputContext) (s : ParserState) (e : Parser.Error) : Message where
+  fileName := ictx.fileName
+  pos := ictx.fileMap.toPosition s.pos
+  endPos := none
+  keepFullRange := true
+  data := toString e
+
+def mkExceptionMessage (ictx : InputContext) (e : Exception) : Message where
+  fileName := ictx.fileName
+  pos := ictx.fileMap.toPosition <| e.getRef.getPos?.getD 0
+  endPos := ictx.fileMap.toPosition <$> e.getRef.getTailPos?
+  data := e.toMessageData
+
+def mkMessageNoPos (ictx : InputContext) (data : MessageData) (severity := MessageSeverity.error) : Message where
+  fileName := ictx.fileName
+  pos := ictx.fileMap.toPosition 0
+  endPos := none
+  severity := severity
+  data := data
+
+def mkMessageStringCore
+  (severity : MessageSeverity)
+  (fileName caption body : String)
+  (pos : Position) (endPos? : Option Position := none)
+  (infoWithPos := false)
+: String := Id.run do
+  let mut str := body
+  unless caption == "" do
+    str := caption ++ ":\n" ++ str
+  match severity with
+  | .information =>
+    if infoWithPos then
+      str := mkErrorStringWithPos fileName pos (endPos := endPos?) "info: " ++ str
+  | .warning =>
+    str := mkErrorStringWithPos fileName pos (endPos := endPos?) "warning: " ++ str
+  | .error =>
+    str := mkErrorStringWithPos fileName pos (endPos := endPos?) "error: " ++ str
+  if str.isEmpty || str.back != '\n' then
+    str := str ++ "\n"
+  return str
+
+def mkMessageString (msg : Message) (includeEndPos := false) (infoWithPos := false) : BaseIO String := do
+  let endPos? := if includeEndPos then msg.endPos else none
+  match (← msg.data.toString.toBaseIO) with
+  | .ok s =>
+    return mkMessageStringCore msg.severity msg.fileName msg.caption s msg.pos endPos? infoWithPos
+  | .error e =>
+    return mkMessageStringCore .error msg.fileName msg.caption (toString e) msg.pos endPos? infoWithPos
+
+def mkMessageLogString (log : MessageLog) : BaseIO String :=
+  log.toList.foldlM (init := "") fun s m => do
+    return s ++ (← mkMessageString m (infoWithPos := true))
diff --git a/src/lake/Lake/Util/Newline.lean b/src/lake/Lake/Util/Newline.lean
new file mode 100644
index 0000000000..fa0cb415f9
--- /dev/null
+++ b/src/lake/Lake/Util/Newline.lean
@@ -0,0 +1,24 @@
+/-
+Copyright (c) 2023 Mario Carneiro. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mario Carneiro
+-/
+
+namespace Lake
+
+/-- This is the same as `String.replace text "\r\n" "\n"`, but more efficient. -/
+@[inline] partial def crlf2lf (text : String) : String :=
+  go "" 0 0
+where
+  go (acc : String) (accStop pos : String.Pos) : String :=
+    if h : text.atEnd pos then
+      -- note: if accStop = 0 then acc is empty
+      if accStop = 0 then text else acc ++ text.extract accStop pos
+    else
+      let c := text.get' pos h
+      let pos' := text.next' pos h
+      if c == '\r' && text.get pos' == '\n' then
+        let acc := acc ++ text.extract accStop pos
+        go acc pos' (text.next pos')
+      else
+        go acc accStop pos'
diff --git a/src/lake/Lake/Util/RBArray.lean b/src/lake/Lake/Util/RBArray.lean
index e6e6832703..a0a18640dd 100644
--- a/src/lake/Lake/Util/RBArray.lean
+++ b/src/lake/Lake/Util/RBArray.lean
@@ -66,3 +66,8 @@ def insert (self : RBArray α β cmp) (a : α) (b : β) : RBArray α β cmp :=
   self.toArray.forIn init f
 
 instance : ForIn m (RBArray α β cmp) β := ⟨RBArray.forIn⟩
+
+end RBArray
+
+@[inline] def mkRBArray  (f : β → α) (vs : Array β) : RBArray α β cmp :=
+  vs.foldl (init := RBArray.mkEmpty vs.size) fun m v => m.insert (f v) v
diff --git a/src/lake/README.md b/src/lake/README.md
index b4f8988bd1..e342de5c2b 100644
--- a/src/lake/README.md
+++ b/src/lake/README.md
@@ -36,7 +36,7 @@ Lake is part of the [lean4](https://github.com/leanprover/lean4) repository and
 
 ## Creating and Building a Package
 
-To create a new package, either run `lake init <package-name> [<template>]` to setup the package in the current directory or `lake new <package-name> [<template>]` to create it in a new directory. For example, we could create the package `hello` like so:
+To create a new package, either run `lake init` to setup the package in the current directory or `lake new` to create it in a new directory. For example, we could create the package `hello` like so:
 
 ```
 $ mkdir hello
@@ -115,7 +115,22 @@ $ ./.lake/build/bin/hello
 Hello, world!
 ```
 
-Examples of different package configurations can be found in the [`examples`](examples) folder of this repository. You can also specified a particular configuration file template when using `lake init` or `lake new` to control what files Lake creates. See `lake help init` or `lake help new` for details.
+Examples of different package configurations can be found in the [`examples`](examples) folder of this repository. You can also pass a package template tp `lake init` or `lake new` to control what files Lake creates. For example, instead of using a Lean configuration file for this package, one could produce a TOML version via `lake new hello .toml`.
+
+**lakefile.toml**
+```toml
+name = "hello"
+defaultTargets = ["hello"]
+
+[[lean_lib]]
+name = "Hello"
+
+[[lean_exe]]
+name = "hello"
+root = "Main"
+```
+
+See `lake help init` or `lake help new` for more details on other template options.
 
 ## Glossary of Terms
 
@@ -195,6 +210,12 @@ lean_lib «target-name» where
   -- configuration options go here
 ```
 
+```toml
+[[lean_lib]]
+name = "«target-name»"
+# more configuration options go here
+```
+
 **Configuration Options**
 
 * `srcDir`: The subdirectory of the package's source directory containing the library's source files. Defaults to the package's `srcDir`. (This will be passed to `lean` as the `-R` option.)
@@ -217,6 +238,12 @@ lean_exe «target-name» where
   -- configuration options go here
 ```
 
+```toml
+[[lean_exe]]
+name = "«target-name»"
+# more configuration options go here
+```
+
 **Configuration Options**
 
 * `srcDir`: The subdirectory of the package's source directory containing the executable's source file. Defaults to the package's `srcDir`. (This will be passed to `lean` as the `-R` option.)
@@ -304,6 +331,19 @@ The first form adds a local dependency and the second form adds a Git dependency
 
 Both forms also support an optional `with` clause to specify arguments to pass to the dependency's package configuration (i.e., same as `args` in a `lake build -- <args...>` invocation). The elements of both the `from` and `with` clauses are proper terms so normal computation is supported within them (though parentheses made be required to disambiguate the syntax).
 
+To `require` a package in a TOML configuration, the equivalent syntax is:
+
+```toml
+[[require]]
+path = "path/to/local/package"
+options = {}
+
+[[require]]
+git = "url.git"
+rev = "rev"
+subDir = "optional/path-to/dir-with-pkg"
+```
+
 ## GitHub Release Builds
 
 Lake supports uploading and downloading build artifacts (i.e., the archived build directory) to/from the GitHub releases of packages. This enables end users to fetch pre-built artifacts from the cloud without needed to rebuild the package from the source themselves.
diff --git a/src/lake/examples/bootstrap/lakefile.toml b/src/lake/examples/bootstrap/lakefile.toml
new file mode 100644
index 0000000000..b13a6e8ccf
--- /dev/null
+++ b/src/lake/examples/bootstrap/lakefile.toml
@@ -0,0 +1,11 @@
+name = "lake"
+srcDir = "../.."
+defaultTargets = ["lake"]
+
+[[lean_lib]]
+name = "Lake"
+
+[[lean_exe]]
+name = "lake"
+root = "Lake.Main"
+supportInterpreter = true
diff --git a/src/lake/examples/deps/bar/lakefile.toml b/src/lake/examples/deps/bar/lakefile.toml
new file mode 100644
index 0000000000..61c7236012
--- /dev/null
+++ b/src/lake/examples/deps/bar/lakefile.toml
@@ -0,0 +1,13 @@
+name = "bar"
+defaultTargets = ["bar"]
+
+[[require]]
+name = "foo"
+path = "../foo"
+
+[[lean_lib]]
+name = "Bar"
+
+[[lean_exe]]
+name = "bar"
+root = "Main"
diff --git a/src/lake/examples/deps/foo/lakefile.toml b/src/lake/examples/deps/foo/lakefile.toml
new file mode 100644
index 0000000000..a8d47f9819
--- /dev/null
+++ b/src/lake/examples/deps/foo/lakefile.toml
@@ -0,0 +1,17 @@
+name = "foo"
+defaultTargets = ["foo"]
+
+[[require]]
+name = "a"
+path  = "../a"
+
+[[require]]
+name = "b"
+path = "../b"
+
+[[lean_lib]]
+name = "Foo"
+
+[[lean_exe]]
+name = "foo"
+root = "Main"
diff --git a/src/lake/examples/deps/test.sh b/src/lake/examples/deps/test.sh
index 5117a6bb8a..46b469384b 100755
--- a/src/lake/examples/deps/test.sh
+++ b/src/lake/examples/deps/test.sh
@@ -25,3 +25,11 @@ test -d foo/.lake/build
 $LAKE -d foo clean
 test ! -d root/.lake/build
 test ! -d foo/.lake/build
+
+./clean.sh
+
+$LAKE -d bar -f lakefile.toml build --update
+$LAKE -d foo -f lakefile.toml build --update
+
+./foo/.lake/build/bin/foo
+./bar/.lake/build/bin/bar
diff --git a/src/lake/examples/hello/lakefile.toml b/src/lake/examples/hello/lakefile.toml
new file mode 100644
index 0000000000..a696c7aed6
--- /dev/null
+++ b/src/lake/examples/hello/lakefile.toml
@@ -0,0 +1,9 @@
+name = "hello"
+defaultTargets = ["hello"]
+
+[[lean_lib]]
+name = "Hello"
+
+[[lean_exe]]
+name = "hello"
+root = "Main"
diff --git a/src/lake/examples/hello/test.sh b/src/lake/examples/hello/test.sh
index a7cfa1484f..b75faaa375 100755
--- a/src/lake/examples/hello/test.sh
+++ b/src/lake/examples/hello/test.sh
@@ -11,3 +11,9 @@ $LAKE exe hello Bob Bill
 # Tests that build produces a manifest if there is none.
 # Related: https://github.com/leanprover/lean4/issues/2549
 test -f lake-manifest.json
+
+./clean.sh
+
+$LAKE -f lakefile.toml exe hello
+$LAKE -f lakefile.toml exe hello Bob Bill
+.lake/build/bin/hello
diff --git a/src/lake/examples/precompile/bar/lakefile.lean b/src/lake/examples/precompile/bar/lakefile.lean
index be265d5d01..e174f1c497 100644
--- a/src/lake/examples/precompile/bar/lakefile.lean
+++ b/src/lake/examples/precompile/bar/lakefile.lean
@@ -1,9 +1,8 @@
 import Lake
 open Lake DSL
 
-package bar {
+package bar where
   precompileModules := false
-}
 
 require foo from "../foo"
 
diff --git a/src/lake/examples/precompile/bar/lakefile.toml b/src/lake/examples/precompile/bar/lakefile.toml
new file mode 100644
index 0000000000..b34c216148
--- /dev/null
+++ b/src/lake/examples/precompile/bar/lakefile.toml
@@ -0,0 +1,10 @@
+name = "bar"
+precompileModules = false
+defaultTargets = ["Bar"]
+
+[[require]]
+name = "foo"
+path = "../foo"
+
+[[lean_lib]]
+name = "Bar"
diff --git a/src/lake/examples/precompile/foo/lakefile.lean b/src/lake/examples/precompile/foo/lakefile.lean
index a7642b102b..ed9a62ac1d 100644
--- a/src/lake/examples/precompile/foo/lakefile.lean
+++ b/src/lake/examples/precompile/foo/lakefile.lean
@@ -1,9 +1,8 @@
 import Lake
 open Lake DSL
 
-package foo {
+package foo where
   precompileModules := true
-}
 
 @[default_target]
 lean_lib Foo
diff --git a/src/lake/examples/precompile/foo/lakefile.toml b/src/lake/examples/precompile/foo/lakefile.toml
new file mode 100644
index 0000000000..4bbdcb1f1b
--- /dev/null
+++ b/src/lake/examples/precompile/foo/lakefile.toml
@@ -0,0 +1,6 @@
+name = "foo"
+precompileModules = true
+defaultTargets = ["Foo"]
+
+[[lean_lib]]
+name = "Foo"
diff --git a/src/lake/examples/precompile/test.sh b/src/lake/examples/precompile/test.sh
index 4dafdb64e2..a9ee14b9b0 100755
--- a/src/lake/examples/precompile/test.sh
+++ b/src/lake/examples/precompile/test.sh
@@ -4,5 +4,10 @@ LAKE=${LAKE:-../../.lake/build/bin/lake}
 
 ./clean.sh
 $LAKE -d bar update
-$LAKE -d bar build # tests #83
+$LAKE -d bar build # tests lake#83
 $LAKE -d foo build
+
+./clean.sh
+$LAKE -d bar -f lakefile.toml update
+$LAKE -d bar -f lakefile.toml build
+$LAKE -d foo -f lakefile.toml build
diff --git a/src/lake/tests/globs/lakefile.lean b/src/lake/tests/globs/lakefile.lean
index e68d9f79bc..fb8c61a9d1 100644
--- a/src/lake/tests/globs/lakefile.lean
+++ b/src/lake/tests/globs/lakefile.lean
@@ -4,10 +4,8 @@ open Lake DSL
 
 package test
 
-@[default_target]
 lean_lib TBA where
-  globs := #[.andSubmodules `TBA]
+  globs := `TBA.*
 
-@[default_target]
 lean_lib Test where
-  globs := #[.submodules `Test]
+  globs := #[`Test.+]
diff --git a/src/lake/tests/globs/lakefile.toml b/src/lake/tests/globs/lakefile.toml
new file mode 100644
index 0000000000..17d9d78b0c
--- /dev/null
+++ b/src/lake/tests/globs/lakefile.toml
@@ -0,0 +1,9 @@
+name = 'test'
+
+[[lean_lib]]
+name = 'TBA'
+globs = 'TBA.*'
+
+[[lean_lib]]
+name = 'Test'
+globs = ['Test.+']
diff --git a/src/lake/tests/globs/test.sh b/src/lake/tests/globs/test.sh
index a228ddc811..f86c7920df 100755
--- a/src/lake/tests/globs/test.sh
+++ b/src/lake/tests/globs/test.sh
@@ -12,6 +12,11 @@ $LAKE build TBA
 test -f .lake/build/lib/TBA.olean
 test -f .lake/build/lib/TBA/Eulerian.olean
 test -f .lake/build/lib/TBA/Eulerian/A.olean
+rm -rf .lake
+$LAKE -f lakefile.toml build TBA
+test -f .lake/build/lib/TBA.olean
+test -f .lake/build/lib/TBA/Eulerian.olean
+test -f .lake/build/lib/TBA/Eulerian/A.olean
 
 # test that globs capture modules with non-Lean names
 # see https://github.com/leanprover/lake/issues/174
@@ -22,4 +27,7 @@ test -f .lake/build/lib/TBA/Eulerian/A.olean
 $LAKE build Test
 test -f .lake/build/lib/Test/1.olean
 test -f .lake/build/lib/Test/Subtest/1.olean
-
+rm -rf .lake
+$LAKE -f lakefile.toml build Test
+test -f .lake/build/lib/Test/1.olean
+test -f .lake/build/lib/Test/Subtest/1.olean
diff --git a/src/lake/tests/init/test.sh b/src/lake/tests/init/test.sh
index b9d747de7a..b729b1ec9b 100755
--- a/src/lake/tests/init/test.sh
+++ b/src/lake/tests/init/test.sh
@@ -13,10 +13,12 @@ fi
 LAKE1=${LAKE:-../../../.lake/build/bin/lake}
 LAKE=${LAKE:-../../.lake/build/bin/lake}
 
-# Test `new` and `init` with bad template (should error)
+# Test `new` and `init` with bad template/langauge (should error)
 
-($LAKE new  foo bar 2>&1 && false || true) | grep "unknown package template"
+($LAKE new foo bar 2>&1 && false || true) | grep "unknown package template"
+($LAKE new foo .baz 2>&1 && false || true) | grep "unknown configuration language"
 ($LAKE init foo bar 2>&1 && false || true) | grep "unknown package template"
+($LAKE init foo std.baz 2>&1 && false || true) | grep "unknown configuration language"
 
 # Test package name validation (should error)
 # https://github.com/leanprover/lean4/issues/2637
@@ -34,13 +36,36 @@ for cmd in new init; do
 ($LAKE $cmd main 2>&1 && false || true) | grep "reserved package name"
 done
 
-# Test `init .`
+# Test default (std) template
 
-mkdir hello
-pushd hello
-$LAKE1 init .
-$LAKE1 exe hello
-popd
+$LAKE new hello
+$LAKE -d hello exe hello
+test -f hello/.lake/build/lib/Hello.olean
+rm -rf hello
+$LAKE new hello .toml
+$LAKE -d hello exe hello
+test -f hello/.lake/build/lib/Hello.olean
+rm -rf hello
+
+# Test exe template
+
+$LAKE new hello exe
+$LAKE -d hello exe hello
+rm -rf hello
+$LAKE new hello exe.toml
+$LAKE -d hello exe hello
+rm -rf hello
+
+# Test lib template
+
+$LAKE new hello lib
+$LAKE -d hello build Hello
+test -f hello/.lake/build/lib/Hello.olean
+rm -rf hello
+$LAKE new hello lib.toml
+$LAKE -d hello build Hello
+test -f hello/.lake/build/lib/Hello.olean
+rm -rf hello
 
 # Test math template
 
@@ -49,6 +74,20 @@ $LAKE new qed math
 sed_i '/^require.*/{N;d;}' qed/lakefile.lean
 $LAKE -d qed build Qed
 test -f qed/.lake/build/lib/Qed.olean
+rm -rf qed
+$LAKE new qed math.toml
+# Remove the require, since we do not wish to download mathlib during tests
+sed_i '/^\[\[require\]\]/{N;N;N;d;}' qed/lakefile.toml
+$LAKE -d qed build Qed
+test -f qed/.lake/build/lib/Qed.olean
+
+# Test `init .`
+
+mkdir hello
+pushd hello
+$LAKE1 init .
+$LAKE1 exe hello
+popd
 
 # Test creating packages with uppercase names
 # https://github.com/leanprover/lean4/issues/2540
diff --git a/src/lake/tests/toml/README.md b/src/lake/tests/toml/README.md
new file mode 100644
index 0000000000..915ba85a51
--- /dev/null
+++ b/src/lake/tests/toml/README.md
@@ -0,0 +1,26 @@
+Test cases are taken from https://github.com/toml-lang/toml-test, which
+is licensed under the MIT license. The license is copied below.
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2018 TOML authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+```
diff --git a/src/lake/tests/toml/Test.lean b/src/lake/tests/toml/Test.lean
new file mode 100644
index 0000000000..dea7b1e134
--- /dev/null
+++ b/src/lake/tests/toml/Test.lean
@@ -0,0 +1,217 @@
+/-
+Copyright (c) 2024 Mac Malone. All rights reserved.
+Released under Apache 2.0 license as described in the file LICENSE.
+Authors: Mac Malone
+-/
+import Lake.Toml
+import Lake.Util.Message
+import Lake.Util.Newline
+
+/-!
+## TOML Test Runner
+
+Tests Lake's TOML implementation against the version of the [toml-test][1]
+compliance suite stored in `tests` (currently, suite v1.4.0 for TOML v1.0.0).
+
+[1]: https://github.com/toml-lang/toml-test
+-/
+
+open Lake Toml
+open Lean Parser System
+
+inductive TomlOutcome where
+| pass (t : Table)
+| fail (log : MessageLog)
+| error (e : IO.Error)
+
+@[inline] def Fin.allM [Monad m] (n) (f : Fin n → m Bool) : m Bool :=
+  loop 0
+where
+  loop (i : Nat) : m Bool := do
+    if h : i < n then
+      if (← f ⟨i, h⟩) then loop (i+1) else pure false
+    else
+      pure true
+  termination_by n - i
+
+@[inline] def Fin.all (n) (f : Fin n → Bool) : Bool :=
+  Id.run <| allM n f
+
+def bytesBEq (a b : ByteArray) : Bool :=
+  if h_size : a.size = b.size then
+    Fin.all a.size fun i => a[i] = b[i]'(h_size ▸ i.isLt)
+  else
+    false
+
+def String.fromUTF8 (bytes : ByteArray) : String :=
+  String.fromUTF8Unchecked bytes |>.map id
+
+@[inline] def String.fromUTF8? (bytes : ByteArray) : Option String :=
+  let s := String.fromUTF8 bytes
+  if bytesBEq s.toUTF8 bytes then some s else none
+
+nonrec def loadToml (tomlFile : FilePath) : BaseIO TomlOutcome := do
+  let fileName := tomlFile.fileName.getD tomlFile.toString
+  let input ←
+    match (← IO.FS.readBinFile tomlFile |>.toBaseIO) with
+    | .ok bytes =>
+      if let some input := String.fromUTF8? bytes then
+        pure (crlf2lf input)
+      else
+        return .fail <| MessageLog.empty.add
+          {fileName, pos := ⟨1,0⟩, data := m!"file contains invalid characters"}
+    | .error e => return .error e
+  let ictx := mkInputContext input fileName
+  match (← loadToml ictx |>.toBaseIO) with
+  | .ok table => return .pass table
+  | .error log => return .fail log
+
+inductive TestOutcome
+| skip
+| pass (s : String)
+| fail (s : String)
+| error (e : String)
+
+def testInvalid (tomlFile : FilePath) : BaseIO TestOutcome := do
+  match (← loadToml tomlFile) with
+  | .pass t => return .fail (ppTable t)
+  | .fail l => return .pass (← mkMessageLogString l)
+  | .error e => return .error (toString e)
+
+@[inline] def Fin.forM [Monad m] (n) (f : Fin n → m Unit) : m Unit :=
+  loop 0
+where
+  loop (i : Nat) : m Unit := do
+    if h : i < n then let a ← f ⟨i, h⟩; loop (i+1) else pure ()
+  termination_by n - i
+
+local instance [Monad m] : ForIn m (RBNode α β) ((a : α) × β a) where
+  forIn t init f := t.forIn init (fun a b acc => f ⟨a, b⟩ acc)
+
+def expectBEq [BEq α] [ToString α] (actual expected : α) : Except String Unit := do
+  unless actual == expected do
+    throw s!"expected '{expected}', got '{actual}'"
+
+def expectPrimitive (actualTy : String) (expected : Json) : Except String String := do
+  let .ok expected := expected.getObj?
+    | throw s!"expected non-primitive, got '{actualTy}'"
+  let some ty := expected.find compare "type"
+    | throw s!"expected non-primitive, got '{actualTy}'"
+  let some val := expected.find compare "value"
+    | throw s!"expected non-primitive, got '{actualTy}'"
+  let .ok val := val.getStr?
+    | throw s!"expected non-primitive, got '{actualTy}'"
+  unless actualTy == ty do
+    throw s!"expected value of type '{ty}', got '{actualTy}'"
+  return val
+
+mutual
+
+partial def expectValue (actual : Value) (expected : Json) : Except String Unit := do
+  match actual with
+  | .boolean _ b => expectBEq (toString b) (← expectPrimitive "bool" expected)
+  | .string _ s => expectBEq s (← expectPrimitive "string" expected)
+  | .integer _ n => expectBEq (toString n) (← expectPrimitive "integer" expected)
+  | .float _ actN =>
+    let expected ← expectPrimitive "float" expected
+    if expected.toLower == "nan" then
+      unless actN.isNaN do
+        throw s!"expected '{expected}', got '{actN}'"
+    else
+      let (sign, e) := decodeSign expected
+      if e.toLower == "inf" then
+        unless actN.isInf && sign == (actN < 0) do
+          throw s!"expected '{e}', got '{actN}'"
+      else
+          let some flt :=
+            (Nat.toFloat <$> e.toNat?) <|>
+            (Syntax.decodeScientificLitVal? e |>.map fun (m,s,e) => .ofScientific m s e)
+            | throw s!"failed to parse expected float value: {e}"
+          expectBEq actN <| if sign then -flt else flt
+  | .dateTime _ dt =>
+    match dt with
+    | .offsetDateTime _ _ _ => expectBEq (toString dt) (← expectPrimitive "datetime" expected)
+    | .localDateTime .. =>  expectBEq (toString dt) (← expectPrimitive "datetime-local" expected)
+    | .localDate d => expectBEq (toString d) (← expectPrimitive "date-local" expected)
+    | .localTime t => expectBEq (toString t) (← expectPrimitive "time-local" expected)
+  | .array _ actVs =>
+    let .ok expVs := expected.getArr?
+      | throw "expected non-array, got array"
+    if h_size : actVs.size = expVs.size then
+      Fin.forM actVs.size fun i => expectValue actVs[i] (expVs[i]'(h_size ▸ i.isLt))
+    else
+      throw s!"expected array of size {expVs.size}, got {actVs.size}:\n{actual}"
+  | .table _ t => expectTable t expected
+
+partial def expectTable (actual : Table) (expected : Json) : Except String Unit := do
+  let .ok expected := expected.getObj?
+    | throw "expected non-table, got table"
+  if actual.size != expected.size then
+    throw s!"expected table of size {expected.size}, got {actual.size}:\n{ppTable actual}"
+  for ⟨k,expV⟩ in expected do
+    let some actV := actual.find? (Name.mkSimple k)
+      | throw s!"expected key '{k}'"
+    try expectValue actV expV catch e => throw s!"{k}: {e}"
+
+end
+
+def expectJson (actual expected : Json) : TestOutcome :=
+  let s := actual.pretty ++ "\n"
+  if actual == expected then .pass s else .fail s
+
+def testValid (tomlFile : FilePath) : BaseIO TestOutcome := do
+  -- Tests skipped due to bugs in Lean's JSON parser
+  -- TODO: Fix JSON parser (high-low unicode escape pairs)
+  let normPath := tomlFile.toString.map fun c => if c = '\\' then '/' else c
+  for testPath in ["string/quoted-unicode.toml", "key/quoted-unicode.toml"] do
+    if normPath.endsWith testPath then return .skip
+  match (← loadToml tomlFile) with
+  | .pass t =>
+    match (← IO.FS.readFile (tomlFile.withExtension "json") |>.toBaseIO) with
+    | .ok contents =>
+      match Json.parse contents with
+      | .ok j =>
+        match expectTable t j with
+        | .ok _ => return .pass <| ppTable t
+        | .error e => return .fail <| e.trimRight ++ "\n"
+      | .error e => return .error s!"invalid JSON: {e}"
+    | .error e => return .error (toString e)
+  | .fail l => return .fail (← mkMessageLogString l)
+  | .error e => return .error (toString e)
+
+def walkDir (root : FilePath) (ext : String := "toml") : IO (Array FilePath) := do
+  (← root.walkDir).filterM fun path => do
+    return path.extension == some ext && !(← path.isDir)
+
+def main : IO UInt32 := do
+  -- Detect Tests
+  let invalidTestFiles ← walkDir <| FilePath.mk "tests" / "invalid"
+  let validTestFiles ← walkDir <| FilePath.mk "tests" / "valid"
+  let numTests := invalidTestFiles.size + validTestFiles.size
+  let outcomes := Array.mkEmpty numTests
+  -- Run Tests
+  let outcomes ← invalidTestFiles.foldlM (init := outcomes) fun outcomes path => do
+    return outcomes.push (← IO.FS.realPath path, ← testInvalid path)
+  let outcomes ← validTestFiles.foldlM (init := outcomes) fun outcomes path => do
+    return outcomes.push (← IO.FS.realPath path, ← testValid path)
+  -- Print Results
+  let showPassedTests := false
+  let showOutputOnFail := true
+  let mut skipped := 0; let mut failed := 0; let mut errored := 0
+  for (testName, outcome) in outcomes do
+    match outcome with
+    | .skip =>
+      skipped := skipped + 1
+    | .pass s =>
+      if showPassedTests then
+        IO.print s!"{testName} passed:\n{s}"
+    | .fail s =>
+      failed := failed + 1
+      if showOutputOnFail && !s.isEmpty then
+        IO.print s!"{testName} failed:\n{s}"
+      else
+        IO.print s!"{testName} failed\n"
+    | .error s => errored := errored + 1; IO.print s!"{testName} errored:\n{s}\n"
+  let percent := (numTests - skipped - failed - errored) * 100 / numTests
+  IO.println s!"{percent}% of tests passed, {failed} failed, {errored} errored, {skipped} skipped out of {numTests}"
+  return if failed > 0 || errored > 0 then 1 else 0
diff --git a/src/lake/tests/toml/fetch-tests.sh b/src/lake/tests/toml/fetch-tests.sh
new file mode 100755
index 0000000000..4bc68414ca
--- /dev/null
+++ b/src/lake/tests/toml/fetch-tests.sh
@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+git clone https://github.com/toml-lang/toml-test toml-test --depth 1 --branch v1.4.0
+TOML_VER=${1:-1.0.0}
+echo "Copying tests for TOML v$TOML_VER..."
+while read t; do
+    echo "$t"
+    mkdir -p tests/"$(dirname "$t")"
+    cp -r "toml-test/tests/$t" tests/"$t"
+done < "toml-test/tests/files-toml-$TOML_VER"
+rm -rf toml-test
diff --git a/src/lake/tests/toml/test.sh b/src/lake/tests/toml/test.sh
new file mode 100755
index 0000000000..e37facb26a
--- /dev/null
+++ b/src/lake/tests/toml/test.sh
@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+set -euo pipefail
+LAKE=${LAKE:-../../.lake/build/bin/lake}
+$LAKE -d ../.. build Lake.Toml
+$LAKE env lean --run Test.lean
diff --git a/src/lake/tests/toml/tests/invalid/array/double-comma-1.toml b/src/lake/tests/toml/tests/invalid/array/double-comma-1.toml
new file mode 100644
index 0000000000..339aad2ca1
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/double-comma-1.toml
@@ -0,0 +1 @@
+array = [1,,2]
diff --git a/src/lake/tests/toml/tests/invalid/array/double-comma-2.toml b/src/lake/tests/toml/tests/invalid/array/double-comma-2.toml
new file mode 100644
index 0000000000..ce3565c249
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/double-comma-2.toml
@@ -0,0 +1,2 @@
+array = [1,2,,]
+
diff --git a/src/lake/tests/toml/tests/invalid/array/extend-defined-aot.toml b/src/lake/tests/toml/tests/invalid/array/extend-defined-aot.toml
new file mode 100644
index 0000000000..1c3c34b857
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/extend-defined-aot.toml
@@ -0,0 +1,3 @@
+[[tab.arr]]
+[tab]
+arr.val1=1
diff --git a/src/lake/tests/toml/tests/invalid/array/extending-table.toml b/src/lake/tests/toml/tests/invalid/array/extending-table.toml
new file mode 100644
index 0000000000..a6b7ce4b05
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/extending-table.toml
@@ -0,0 +1,6 @@
+a = [{ b = 1 }]
+
+# Cannot extend tables within static arrays
+# https://github.com/toml-lang/toml/issues/908
+[a.c]
+foo = 1
diff --git a/src/lake/tests/toml/tests/invalid/array/missing-separator-1.toml b/src/lake/tests/toml/tests/invalid/array/missing-separator-1.toml
new file mode 100644
index 0000000000..9431d90799
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/missing-separator-1.toml
@@ -0,0 +1 @@
+arrr = [true false]
diff --git a/src/lake/tests/toml/tests/invalid/array/missing-separator-2.toml b/src/lake/tests/toml/tests/invalid/array/missing-separator-2.toml
new file mode 100644
index 0000000000..ab3791afa6
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/missing-separator-2.toml
@@ -0,0 +1 @@
+wrong = [ 1 2 3 ]
diff --git a/src/lake/tests/toml/tests/invalid/array/missing-separator.toml b/src/lake/tests/toml/tests/invalid/array/missing-separator.toml
new file mode 100644
index 0000000000..ab3791afa6
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/missing-separator.toml
@@ -0,0 +1 @@
+wrong = [ 1 2 3 ]
diff --git a/src/lake/tests/toml/tests/invalid/array/no-close-1.toml b/src/lake/tests/toml/tests/invalid/array/no-close-1.toml
new file mode 100644
index 0000000000..fa72e49b27
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-close-1.toml
@@ -0,0 +1 @@
+no-close-1 = [ 1, 2, 3
diff --git a/src/lake/tests/toml/tests/invalid/array/no-close-2.toml b/src/lake/tests/toml/tests/invalid/array/no-close-2.toml
new file mode 100644
index 0000000000..2f46123f5b
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-close-2.toml
@@ -0,0 +1 @@
+x = [42 #
diff --git a/src/lake/tests/toml/tests/invalid/array/no-close-3.toml b/src/lake/tests/toml/tests/invalid/array/no-close-3.toml
new file mode 100644
index 0000000000..7edcc4397b
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-close-3.toml
@@ -0,0 +1 @@
+no-close-3 = [42 #]
diff --git a/src/lake/tests/toml/tests/invalid/array/no-close-4.toml b/src/lake/tests/toml/tests/invalid/array/no-close-4.toml
new file mode 100644
index 0000000000..8c64b5e22c
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-close-4.toml
@@ -0,0 +1 @@
+no-close-4 = [{ key = 42
diff --git a/src/lake/tests/toml/tests/invalid/array/no-close-5.toml b/src/lake/tests/toml/tests/invalid/array/no-close-5.toml
new file mode 100644
index 0000000000..fba61097f0
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-close-5.toml
@@ -0,0 +1 @@
+no-close-5 = [{ key = 42}
diff --git a/src/lake/tests/toml/tests/invalid/array/no-close-6.toml b/src/lake/tests/toml/tests/invalid/array/no-close-6.toml
new file mode 100644
index 0000000000..551e7114fc
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-close-6.toml
@@ -0,0 +1 @@
+no-close-6 = [{ key = 42 #}]
diff --git a/src/lake/tests/toml/tests/invalid/array/no-close-7.toml b/src/lake/tests/toml/tests/invalid/array/no-close-7.toml
new file mode 100644
index 0000000000..fe8c8fdd1a
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-close-7.toml
@@ -0,0 +1 @@
+no-close-7 = [{ key = 42} #]
diff --git a/src/lake/tests/toml/tests/invalid/array/no-close-8.toml b/src/lake/tests/toml/tests/invalid/array/no-close-8.toml
new file mode 100644
index 0000000000..3378bf3dc7
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-close-8.toml
@@ -0,0 +1 @@
+no-close-8 = [
diff --git a/src/lake/tests/toml/tests/invalid/array/no-close-table-1.toml b/src/lake/tests/toml/tests/invalid/array/no-close-table-1.toml
new file mode 100644
index 0000000000..7b077beb29
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-close-table-1.toml
@@ -0,0 +1 @@
+x = [{ key = 42
diff --git a/src/lake/tests/toml/tests/invalid/array/no-close-table-2.toml b/src/lake/tests/toml/tests/invalid/array/no-close-table-2.toml
new file mode 100644
index 0000000000..827c128429
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-close-table-2.toml
@@ -0,0 +1 @@
+x = [{ key = 42 #
diff --git a/src/lake/tests/toml/tests/invalid/array/no-close-table.toml b/src/lake/tests/toml/tests/invalid/array/no-close-table.toml
new file mode 100644
index 0000000000..7b077beb29
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-close-table.toml
@@ -0,0 +1 @@
+x = [{ key = 42
diff --git a/src/lake/tests/toml/tests/invalid/array/no-close.toml b/src/lake/tests/toml/tests/invalid/array/no-close.toml
new file mode 100644
index 0000000000..032ebcc247
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-close.toml
@@ -0,0 +1 @@
+long_array = [ 1, 2, 3
diff --git a/src/lake/tests/toml/tests/invalid/array/no-comma-1.toml b/src/lake/tests/toml/tests/invalid/array/no-comma-1.toml
new file mode 100644
index 0000000000..ae7ab2495d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-comma-1.toml
@@ -0,0 +1 @@
+no-comma-1 = [true false]
diff --git a/src/lake/tests/toml/tests/invalid/array/no-comma-2.toml b/src/lake/tests/toml/tests/invalid/array/no-comma-2.toml
new file mode 100644
index 0000000000..a8bc60710b
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-comma-2.toml
@@ -0,0 +1 @@
+no-comma-2 = [ 1 2 3 ]
diff --git a/src/lake/tests/toml/tests/invalid/array/no-comma-3.toml b/src/lake/tests/toml/tests/invalid/array/no-comma-3.toml
new file mode 100644
index 0000000000..1a636d6d0e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/no-comma-3.toml
@@ -0,0 +1 @@
+no-comma-3 = [ 1 #,]
diff --git a/src/lake/tests/toml/tests/invalid/array/only-comma-1.toml b/src/lake/tests/toml/tests/invalid/array/only-comma-1.toml
new file mode 100644
index 0000000000..dca0f1b4b2
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/only-comma-1.toml
@@ -0,0 +1 @@
+only-comma-1 = [,]
diff --git a/src/lake/tests/toml/tests/invalid/array/only-comma-2.toml b/src/lake/tests/toml/tests/invalid/array/only-comma-2.toml
new file mode 100644
index 0000000000..3e46ca62f2
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/only-comma-2.toml
@@ -0,0 +1 @@
+only-comma-2 = [,,]
diff --git a/src/lake/tests/toml/tests/invalid/array/tables-1.toml b/src/lake/tests/toml/tests/invalid/array/tables-1.toml
new file mode 100644
index 0000000000..01d4d1381c
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/tables-1.toml
@@ -0,0 +1,4 @@
+# INVALID TOML DOC
+fruit = []
+
+[[fruit]] # Not allowed
diff --git a/src/lake/tests/toml/tests/invalid/array/tables-2.toml b/src/lake/tests/toml/tests/invalid/array/tables-2.toml
new file mode 100644
index 0000000000..a77b0e4d3e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/tables-2.toml
@@ -0,0 +1,10 @@
+# INVALID TOML DOC
+[[fruit]]
+  name = "apple"
+
+  [[fruit.variety]]
+    name = "red delicious"
+
+  # This table conflicts with the previous table
+  [fruit.variety]
+    name = "granny smith"
diff --git a/src/lake/tests/toml/tests/invalid/array/text-after-array-entries.toml b/src/lake/tests/toml/tests/invalid/array/text-after-array-entries.toml
new file mode 100644
index 0000000000..1a7289074e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/text-after-array-entries.toml
@@ -0,0 +1,4 @@
+array = [
+  "Is there life after an array separator?", No
+  "Entry"
+]
diff --git a/src/lake/tests/toml/tests/invalid/array/text-before-array-separator.toml b/src/lake/tests/toml/tests/invalid/array/text-before-array-separator.toml
new file mode 100644
index 0000000000..9b06a39241
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/text-before-array-separator.toml
@@ -0,0 +1,4 @@
+array = [
+  "Is there life before an array separator?" No,
+  "Entry"
+]
diff --git a/src/lake/tests/toml/tests/invalid/array/text-in-array.toml b/src/lake/tests/toml/tests/invalid/array/text-in-array.toml
new file mode 100644
index 0000000000..a6a6c42075
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/array/text-in-array.toml
@@ -0,0 +1,5 @@
+array = [
+  "Entry 1",
+  I don't belong,
+  "Entry 2",
+]
diff --git a/src/lake/tests/toml/tests/invalid/bool/almost-false-with-extra.toml b/src/lake/tests/toml/tests/invalid/bool/almost-false-with-extra.toml
new file mode 100644
index 0000000000..047911e187
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/almost-false-with-extra.toml
@@ -0,0 +1 @@
+a = falsify
diff --git a/src/lake/tests/toml/tests/invalid/bool/almost-false.toml b/src/lake/tests/toml/tests/invalid/bool/almost-false.toml
new file mode 100644
index 0000000000..90d612dd87
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/almost-false.toml
@@ -0,0 +1 @@
+a = fals
diff --git a/src/lake/tests/toml/tests/invalid/bool/almost-true-with-extra.toml b/src/lake/tests/toml/tests/invalid/bool/almost-true-with-extra.toml
new file mode 100644
index 0000000000..b8946f320f
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/almost-true-with-extra.toml
@@ -0,0 +1 @@
+a = truthy
diff --git a/src/lake/tests/toml/tests/invalid/bool/almost-true.toml b/src/lake/tests/toml/tests/invalid/bool/almost-true.toml
new file mode 100644
index 0000000000..e9a6145960
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/almost-true.toml
@@ -0,0 +1 @@
+a = tru
diff --git a/src/lake/tests/toml/tests/invalid/bool/capitalized-false.toml b/src/lake/tests/toml/tests/invalid/bool/capitalized-false.toml
new file mode 100644
index 0000000000..a8217fa77a
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/capitalized-false.toml
@@ -0,0 +1 @@
+capitalized-false        = False
diff --git a/src/lake/tests/toml/tests/invalid/bool/capitalized-true.toml b/src/lake/tests/toml/tests/invalid/bool/capitalized-true.toml
new file mode 100644
index 0000000000..99cbcbc781
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/capitalized-true.toml
@@ -0,0 +1 @@
+capitalized-true         = True
diff --git a/src/lake/tests/toml/tests/invalid/bool/just-f.toml b/src/lake/tests/toml/tests/invalid/bool/just-f.toml
new file mode 100644
index 0000000000..b7dfb900da
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/just-f.toml
@@ -0,0 +1 @@
+a = f
diff --git a/src/lake/tests/toml/tests/invalid/bool/just-t.toml b/src/lake/tests/toml/tests/invalid/bool/just-t.toml
new file mode 100644
index 0000000000..26e457a913
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/just-t.toml
@@ -0,0 +1 @@
+a = t
diff --git a/src/lake/tests/toml/tests/invalid/bool/mixed-case-false.toml b/src/lake/tests/toml/tests/invalid/bool/mixed-case-false.toml
new file mode 100644
index 0000000000..1dceaa6317
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/mixed-case-false.toml
@@ -0,0 +1 @@
+mixed-case-false        = falsE
diff --git a/src/lake/tests/toml/tests/invalid/bool/mixed-case-true.toml b/src/lake/tests/toml/tests/invalid/bool/mixed-case-true.toml
new file mode 100644
index 0000000000..d26a0840fe
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/mixed-case-true.toml
@@ -0,0 +1 @@
+mixed-case-true         = trUe
diff --git a/src/lake/tests/toml/tests/invalid/bool/mixed-case.toml b/src/lake/tests/toml/tests/invalid/bool/mixed-case.toml
new file mode 100644
index 0000000000..41d995a2d3
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/mixed-case.toml
@@ -0,0 +1 @@
+valid = False
diff --git a/src/lake/tests/toml/tests/invalid/bool/starting-same-false.toml b/src/lake/tests/toml/tests/invalid/bool/starting-same-false.toml
new file mode 100644
index 0000000000..19dfb8d041
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/starting-same-false.toml
@@ -0,0 +1 @@
+a = falsey
diff --git a/src/lake/tests/toml/tests/invalid/bool/starting-same-true.toml b/src/lake/tests/toml/tests/invalid/bool/starting-same-true.toml
new file mode 100644
index 0000000000..bf2f784271
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/starting-same-true.toml
@@ -0,0 +1 @@
+a = truer
diff --git a/src/lake/tests/toml/tests/invalid/bool/wrong-case-false.toml b/src/lake/tests/toml/tests/invalid/bool/wrong-case-false.toml
new file mode 100644
index 0000000000..398222098f
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/wrong-case-false.toml
@@ -0,0 +1 @@
+b = FALSE
diff --git a/src/lake/tests/toml/tests/invalid/bool/wrong-case-true.toml b/src/lake/tests/toml/tests/invalid/bool/wrong-case-true.toml
new file mode 100644
index 0000000000..85e34c5eb6
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/bool/wrong-case-true.toml
@@ -0,0 +1 @@
+a = TRUE
diff --git a/src/lake/tests/toml/tests/invalid/control/bare-cr.toml b/src/lake/tests/toml/tests/invalid/control/bare-cr.toml
new file mode 100644
index 0000000000..37f4ce4c22
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/bare-cr.toml
@@ -0,0 +1,2 @@
+# The following line contains a single carriage return control character
+
\ No newline at end of file
diff --git a/src/lake/tests/toml/tests/invalid/control/bare-formfeed.toml b/src/lake/tests/toml/tests/invalid/control/bare-formfeed.toml
new file mode 100644
index 0000000000..508a650806
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/bare-formfeed.toml
@@ -0,0 +1 @@
+bare-formfeed = 
diff --git a/src/lake/tests/toml/tests/invalid/control/bare-null.toml b/src/lake/tests/toml/tests/invalid/control/bare-null.toml
new file mode 100644
index 0000000000..cf15002ae4
Binary files /dev/null and b/src/lake/tests/toml/tests/invalid/control/bare-null.toml differ
diff --git a/src/lake/tests/toml/tests/invalid/control/bare-vertical-tab.toml b/src/lake/tests/toml/tests/invalid/control/bare-vertical-tab.toml
new file mode 100644
index 0000000000..abacefd2d9
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/bare-vertical-tab.toml
@@ -0,0 +1 @@
+bare-vertical-tab = 
diff --git a/src/lake/tests/toml/tests/invalid/control/comment-cr.toml b/src/lake/tests/toml/tests/invalid/control/comment-cr.toml
new file mode 100644
index 0000000000..3ce1cb45f6
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/comment-cr.toml
@@ -0,0 +1 @@
+comment-cr = "Carriage return in comment" # 
a=1
diff --git a/src/lake/tests/toml/tests/invalid/control/comment-del.toml b/src/lake/tests/toml/tests/invalid/control/comment-del.toml
new file mode 100644
index 0000000000..fb904007cc
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/comment-del.toml
@@ -0,0 +1 @@
+comment-del = "0x7f" # 
diff --git a/src/lake/tests/toml/tests/invalid/control/comment-ff.toml b/src/lake/tests/toml/tests/invalid/control/comment-ff.toml
new file mode 100644
index 0000000000..1dcc2c84b9
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/comment-ff.toml
@@ -0,0 +1 @@
+comment-ff   = "0x7f"   # 
diff --git a/src/lake/tests/toml/tests/invalid/control/comment-lf.toml b/src/lake/tests/toml/tests/invalid/control/comment-lf.toml
new file mode 100644
index 0000000000..f6e963e026
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/comment-lf.toml
@@ -0,0 +1 @@
+comment-lf = "ctrl-P" # 
diff --git a/src/lake/tests/toml/tests/invalid/control/comment-null.toml b/src/lake/tests/toml/tests/invalid/control/comment-null.toml
new file mode 100644
index 0000000000..2c903729b9
Binary files /dev/null and b/src/lake/tests/toml/tests/invalid/control/comment-null.toml differ
diff --git a/src/lake/tests/toml/tests/invalid/control/comment-us.toml b/src/lake/tests/toml/tests/invalid/control/comment-us.toml
new file mode 100644
index 0000000000..c685b798f6
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/comment-us.toml
@@ -0,0 +1 @@
+comment-us = "ctrl-_" # 
diff --git a/src/lake/tests/toml/tests/invalid/control/multi-cr.toml b/src/lake/tests/toml/tests/invalid/control/multi-cr.toml
new file mode 100644
index 0000000000..7814ce57a2
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/multi-cr.toml
@@ -0,0 +1 @@
+multi-cr   = """null
"""
diff --git a/src/lake/tests/toml/tests/invalid/control/multi-del.toml b/src/lake/tests/toml/tests/invalid/control/multi-del.toml
new file mode 100644
index 0000000000..6629ae3b0e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/multi-del.toml
@@ -0,0 +1 @@
+multi-del = """null"""
diff --git a/src/lake/tests/toml/tests/invalid/control/multi-lf.toml b/src/lake/tests/toml/tests/invalid/control/multi-lf.toml
new file mode 100644
index 0000000000..f207d33f19
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/multi-lf.toml
@@ -0,0 +1 @@
+multi-lf = """null"""
diff --git a/src/lake/tests/toml/tests/invalid/control/multi-null.toml b/src/lake/tests/toml/tests/invalid/control/multi-null.toml
new file mode 100644
index 0000000000..ac6cb46c00
Binary files /dev/null and b/src/lake/tests/toml/tests/invalid/control/multi-null.toml differ
diff --git a/src/lake/tests/toml/tests/invalid/control/multi-us.toml b/src/lake/tests/toml/tests/invalid/control/multi-us.toml
new file mode 100644
index 0000000000..b923ca9e6f
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/multi-us.toml
@@ -0,0 +1 @@
+multi-us = """null"""
diff --git a/src/lake/tests/toml/tests/invalid/control/rawmulti-cd.toml b/src/lake/tests/toml/tests/invalid/control/rawmulti-cd.toml
new file mode 100644
index 0000000000..c6f32d0734
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/rawmulti-cd.toml
@@ -0,0 +1 @@
+rawmulti-cd   = '''null
'''
diff --git a/src/lake/tests/toml/tests/invalid/control/rawmulti-del.toml b/src/lake/tests/toml/tests/invalid/control/rawmulti-del.toml
new file mode 100644
index 0000000000..17cde07785
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/rawmulti-del.toml
@@ -0,0 +1 @@
+rawmulti-del = '''null'''
diff --git a/src/lake/tests/toml/tests/invalid/control/rawmulti-lf.toml b/src/lake/tests/toml/tests/invalid/control/rawmulti-lf.toml
new file mode 100644
index 0000000000..360d48987f
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/rawmulti-lf.toml
@@ -0,0 +1 @@
+rawmulti-lf = '''null'''
diff --git a/src/lake/tests/toml/tests/invalid/control/rawmulti-null.toml b/src/lake/tests/toml/tests/invalid/control/rawmulti-null.toml
new file mode 100644
index 0000000000..1b5bd092c5
Binary files /dev/null and b/src/lake/tests/toml/tests/invalid/control/rawmulti-null.toml differ
diff --git a/src/lake/tests/toml/tests/invalid/control/rawmulti-us.toml b/src/lake/tests/toml/tests/invalid/control/rawmulti-us.toml
new file mode 100644
index 0000000000..0251420715
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/rawmulti-us.toml
@@ -0,0 +1 @@
+rawmulti-us = '''null'''
diff --git a/src/lake/tests/toml/tests/invalid/control/rawstring-cr.toml b/src/lake/tests/toml/tests/invalid/control/rawstring-cr.toml
new file mode 100644
index 0000000000..fe3cf70e61
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/rawstring-cr.toml
@@ -0,0 +1 @@
+rawstring-cr   = 'null
'
diff --git a/src/lake/tests/toml/tests/invalid/control/rawstring-del.toml b/src/lake/tests/toml/tests/invalid/control/rawstring-del.toml
new file mode 100644
index 0000000000..8d83ba8e47
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/rawstring-del.toml
@@ -0,0 +1 @@
+rawstring-del = 'null'
diff --git a/src/lake/tests/toml/tests/invalid/control/rawstring-lf.toml b/src/lake/tests/toml/tests/invalid/control/rawstring-lf.toml
new file mode 100644
index 0000000000..237470ae6a
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/rawstring-lf.toml
@@ -0,0 +1 @@
+rawstring-lf = 'null'
diff --git a/src/lake/tests/toml/tests/invalid/control/rawstring-null.toml b/src/lake/tests/toml/tests/invalid/control/rawstring-null.toml
new file mode 100644
index 0000000000..2d8d0b4cb8
Binary files /dev/null and b/src/lake/tests/toml/tests/invalid/control/rawstring-null.toml differ
diff --git a/src/lake/tests/toml/tests/invalid/control/rawstring-us.toml b/src/lake/tests/toml/tests/invalid/control/rawstring-us.toml
new file mode 100644
index 0000000000..76cb08c0b1
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/rawstring-us.toml
@@ -0,0 +1 @@
+rawstring-us = 'null'
diff --git a/src/lake/tests/toml/tests/invalid/control/string-bs.toml b/src/lake/tests/toml/tests/invalid/control/string-bs.toml
new file mode 100644
index 0000000000..0061c48542
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/string-bs.toml
@@ -0,0 +1 @@
+string-bs = "backspace"
diff --git a/src/lake/tests/toml/tests/invalid/control/string-cr.toml b/src/lake/tests/toml/tests/invalid/control/string-cr.toml
new file mode 100644
index 0000000000..8ae063443b
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/string-cr.toml
@@ -0,0 +1 @@
+string-cr   = "null
"
diff --git a/src/lake/tests/toml/tests/invalid/control/string-del.toml b/src/lake/tests/toml/tests/invalid/control/string-del.toml
new file mode 100644
index 0000000000..bc0ec7fb80
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/string-del.toml
@@ -0,0 +1 @@
+string-del = "null"
diff --git a/src/lake/tests/toml/tests/invalid/control/string-lf.toml b/src/lake/tests/toml/tests/invalid/control/string-lf.toml
new file mode 100644
index 0000000000..0cf9218d7b
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/string-lf.toml
@@ -0,0 +1 @@
+string-lf = "null"
diff --git a/src/lake/tests/toml/tests/invalid/control/string-null.toml b/src/lake/tests/toml/tests/invalid/control/string-null.toml
new file mode 100644
index 0000000000..821c72c32c
Binary files /dev/null and b/src/lake/tests/toml/tests/invalid/control/string-null.toml differ
diff --git a/src/lake/tests/toml/tests/invalid/control/string-us.toml b/src/lake/tests/toml/tests/invalid/control/string-us.toml
new file mode 100644
index 0000000000..af31f57b95
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/control/string-us.toml
@@ -0,0 +1 @@
+string-us = "null"
diff --git a/src/lake/tests/toml/tests/invalid/datetime/feb-29.toml b/src/lake/tests/toml/tests/invalid/datetime/feb-29.toml
new file mode 100644
index 0000000000..bf30c99fd6
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/feb-29.toml
@@ -0,0 +1 @@
+"not a leap year" = 2100-02-29T15:15:15Z
diff --git a/src/lake/tests/toml/tests/invalid/datetime/feb-30.toml b/src/lake/tests/toml/tests/invalid/datetime/feb-30.toml
new file mode 100644
index 0000000000..ecd75a7fd9
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/feb-30.toml
@@ -0,0 +1 @@
+"only 28 or 29 days in february" = 1988-02-30T15:15:15Z
diff --git a/src/lake/tests/toml/tests/invalid/datetime/hour-over.toml b/src/lake/tests/toml/tests/invalid/datetime/hour-over.toml
new file mode 100644
index 0000000000..d4b89b6a9c
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/hour-over.toml
@@ -0,0 +1,2 @@
+# time-hour       = 2DIGIT  ; 00-23
+d = 2006-01-01T24:00:00-00:00
diff --git a/src/lake/tests/toml/tests/invalid/datetime/mday-over.toml b/src/lake/tests/toml/tests/invalid/datetime/mday-over.toml
new file mode 100644
index 0000000000..600a4095f7
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/mday-over.toml
@@ -0,0 +1,3 @@
+# date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on
+#                           ; month/year
+d = 2006-01-32T00:00:00-00:00
diff --git a/src/lake/tests/toml/tests/invalid/datetime/mday-under.toml b/src/lake/tests/toml/tests/invalid/datetime/mday-under.toml
new file mode 100644
index 0000000000..689fc98f81
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/mday-under.toml
@@ -0,0 +1,3 @@
+# date-mday       = 2DIGIT  ; 01-28, 01-29, 01-30, 01-31 based on
+#                           ; month/year
+d = 2006-01-00T00:00:00-00:00
diff --git a/src/lake/tests/toml/tests/invalid/datetime/minute-over.toml b/src/lake/tests/toml/tests/invalid/datetime/minute-over.toml
new file mode 100644
index 0000000000..1532d79a59
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/minute-over.toml
@@ -0,0 +1,2 @@
+# time-minute     = 2DIGIT  ; 00-59
+d = 2006-01-01T00:60:00-00:00
diff --git a/src/lake/tests/toml/tests/invalid/datetime/month-over.toml b/src/lake/tests/toml/tests/invalid/datetime/month-over.toml
new file mode 100644
index 0000000000..c7d40c928d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/month-over.toml
@@ -0,0 +1,2 @@
+# date-month      = 2DIGIT  ; 01-12
+d = 2006-13-01T00:00:00-00:00
diff --git a/src/lake/tests/toml/tests/invalid/datetime/month-under.toml b/src/lake/tests/toml/tests/invalid/datetime/month-under.toml
new file mode 100644
index 0000000000..503f60a1fb
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/month-under.toml
@@ -0,0 +1,2 @@
+# date-month      = 2DIGIT  ; 01-12
+d = 2007-00-01T00:00:00-00:00
diff --git a/src/lake/tests/toml/tests/invalid/datetime/no-leads-month.toml b/src/lake/tests/toml/tests/invalid/datetime/no-leads-month.toml
new file mode 100644
index 0000000000..6700d1cdca
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/no-leads-month.toml
@@ -0,0 +1,2 @@
+# Month "7" instead of "07"; the leading zero is required.
+no-leads = 1987-7-05T17:45:00Z
diff --git a/src/lake/tests/toml/tests/invalid/datetime/no-leads-with-milli.toml b/src/lake/tests/toml/tests/invalid/datetime/no-leads-with-milli.toml
new file mode 100644
index 0000000000..6e3d2e3b77
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/no-leads-with-milli.toml
@@ -0,0 +1,2 @@
+# Day "5" instead of "05"; the leading zero is required.
+with-milli = 1987-07-5T17:45:00.12Z
diff --git a/src/lake/tests/toml/tests/invalid/datetime/no-leads.toml b/src/lake/tests/toml/tests/invalid/datetime/no-leads.toml
new file mode 100644
index 0000000000..6700d1cdca
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/no-leads.toml
@@ -0,0 +1,2 @@
+# Month "7" instead of "07"; the leading zero is required.
+no-leads = 1987-7-05T17:45:00Z
diff --git a/src/lake/tests/toml/tests/invalid/datetime/no-secs.toml b/src/lake/tests/toml/tests/invalid/datetime/no-secs.toml
new file mode 100644
index 0000000000..bbd196afe2
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/no-secs.toml
@@ -0,0 +1,2 @@
+# No seconds in time.
+no-secs = 1987-07-05T17:45Z
diff --git a/src/lake/tests/toml/tests/invalid/datetime/no-t.toml b/src/lake/tests/toml/tests/invalid/datetime/no-t.toml
new file mode 100644
index 0000000000..8d87260107
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/no-t.toml
@@ -0,0 +1,2 @@
+# No "t" or "T" between the date and time.
+no-t = 1987-07-0517:45:00Z
diff --git a/src/lake/tests/toml/tests/invalid/datetime/second-over.toml b/src/lake/tests/toml/tests/invalid/datetime/second-over.toml
new file mode 100644
index 0000000000..4921704854
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/second-over.toml
@@ -0,0 +1,3 @@
+# time-second     = 2DIGIT  ; 00-58, 00-59, 00-60 based on leap second
+#                           ; rules
+d = 2006-01-01T00:00:61-00:00
diff --git a/src/lake/tests/toml/tests/invalid/datetime/time-no-leads-2.toml b/src/lake/tests/toml/tests/invalid/datetime/time-no-leads-2.toml
new file mode 100644
index 0000000000..d7b845947e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/time-no-leads-2.toml
@@ -0,0 +1,2 @@
+# Leading 0 is always required.
+d = 01:32:0
diff --git a/src/lake/tests/toml/tests/invalid/datetime/time-no-leads.toml b/src/lake/tests/toml/tests/invalid/datetime/time-no-leads.toml
new file mode 100644
index 0000000000..8ad722ab61
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/time-no-leads.toml
@@ -0,0 +1,2 @@
+# Leading 0 is always required.
+d = 1:32:00
diff --git a/src/lake/tests/toml/tests/invalid/datetime/trailing-t.toml b/src/lake/tests/toml/tests/invalid/datetime/trailing-t.toml
new file mode 100644
index 0000000000..38ee1dbfa3
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/trailing-t.toml
@@ -0,0 +1,2 @@
+# Date cannot end with trailing T
+d = 2006-01-30T
diff --git a/src/lake/tests/toml/tests/invalid/datetime/y10k.toml b/src/lake/tests/toml/tests/invalid/datetime/y10k.toml
new file mode 100644
index 0000000000..db9b1d7dbd
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/datetime/y10k.toml
@@ -0,0 +1,2 @@
+# Maximum RFC3399 year is 9999.
+d = 10000-01-01 00:00:00z
diff --git a/src/lake/tests/toml/tests/invalid/encoding/bad-codepoint.toml b/src/lake/tests/toml/tests/invalid/encoding/bad-codepoint.toml
new file mode 100644
index 0000000000..b5b819a25e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/encoding/bad-codepoint.toml
@@ -0,0 +1 @@
+# Invalid codepoint U+D800 : ���
diff --git a/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-at-end.toml b/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-at-end.toml
new file mode 100644
index 0000000000..df5f0b0664
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-at-end.toml
@@ -0,0 +1,5 @@
+# There is a 0xda at after the quotes, and no EOL at the end of the file.
+#
+# This is a bit of an edge case: This indicates there should be two bytes
+# (0b1101_1010) but there is no byte to follow because it's the end of the file.
+x = """"""�
\ No newline at end of file
diff --git a/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-comment.toml b/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-comment.toml
new file mode 100644
index 0000000000..816fa46981
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-comment.toml
@@ -0,0 +1 @@
+# �
diff --git a/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-multiline-literal.toml b/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-multiline-literal.toml
new file mode 100644
index 0000000000..296cf9d68f
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-multiline-literal.toml
@@ -0,0 +1,2 @@
+# The following line contains an invalid UTF-8 sequence.
+bad = '''�'''
diff --git a/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-multiline.toml b/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-multiline.toml
new file mode 100644
index 0000000000..9371cb1121
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-multiline.toml
@@ -0,0 +1,2 @@
+# The following line contains an invalid UTF-8 sequence.
+bad = """�"""
diff --git a/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-string-literal.toml b/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-string-literal.toml
new file mode 100644
index 0000000000..3f8948b4a6
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-string-literal.toml
@@ -0,0 +1,2 @@
+# The following line contains an invalid UTF-8 sequence.
+bad = '�'
diff --git a/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-string.toml b/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-string.toml
new file mode 100644
index 0000000000..6d376fb17b
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/encoding/bad-utf8-in-string.toml
@@ -0,0 +1,2 @@
+# The following line contains an invalid UTF-8 sequence.
+bad = "�"
diff --git a/src/lake/tests/toml/tests/invalid/encoding/bom-not-at-start-1.toml b/src/lake/tests/toml/tests/invalid/encoding/bom-not-at-start-1.toml
new file mode 100644
index 0000000000..effe1f2359
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/encoding/bom-not-at-start-1.toml
@@ -0,0 +1 @@
+bom-not-at-start ��
diff --git a/src/lake/tests/toml/tests/invalid/encoding/bom-not-at-start-2.toml b/src/lake/tests/toml/tests/invalid/encoding/bom-not-at-start-2.toml
new file mode 100644
index 0000000000..71e52b41ed
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/encoding/bom-not-at-start-2.toml
@@ -0,0 +1 @@
+bom-not-at-start= ��
diff --git a/src/lake/tests/toml/tests/invalid/encoding/utf16-bom.toml b/src/lake/tests/toml/tests/invalid/encoding/utf16-bom.toml
new file mode 100644
index 0000000000..95b5f9608c
Binary files /dev/null and b/src/lake/tests/toml/tests/invalid/encoding/utf16-bom.toml differ
diff --git a/src/lake/tests/toml/tests/invalid/encoding/utf16-comment.toml b/src/lake/tests/toml/tests/invalid/encoding/utf16-comment.toml
new file mode 100644
index 0000000000..de3cbb2cb2
Binary files /dev/null and b/src/lake/tests/toml/tests/invalid/encoding/utf16-comment.toml differ
diff --git a/src/lake/tests/toml/tests/invalid/encoding/utf16-key.toml b/src/lake/tests/toml/tests/invalid/encoding/utf16-key.toml
new file mode 100644
index 0000000000..7ddf55d2dc
Binary files /dev/null and b/src/lake/tests/toml/tests/invalid/encoding/utf16-key.toml differ
diff --git a/src/lake/tests/toml/tests/invalid/encoding/utf16.toml b/src/lake/tests/toml/tests/invalid/encoding/utf16.toml
new file mode 100644
index 0000000000..de3cbb2cb2
Binary files /dev/null and b/src/lake/tests/toml/tests/invalid/encoding/utf16.toml differ
diff --git a/src/lake/tests/toml/tests/invalid/float/double-point-1.toml b/src/lake/tests/toml/tests/invalid/float/double-point-1.toml
new file mode 100644
index 0000000000..2105fa9beb
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/double-point-1.toml
@@ -0,0 +1 @@
+double-point-1 = 0..1
diff --git a/src/lake/tests/toml/tests/invalid/float/double-point-2.toml b/src/lake/tests/toml/tests/invalid/float/double-point-2.toml
new file mode 100644
index 0000000000..1ef3d0b736
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/double-point-2.toml
@@ -0,0 +1 @@
+double-point-2 = 0.1.2
diff --git a/src/lake/tests/toml/tests/invalid/float/exp-double-e-1.toml b/src/lake/tests/toml/tests/invalid/float/exp-double-e-1.toml
new file mode 100644
index 0000000000..ee568ce869
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/exp-double-e-1.toml
@@ -0,0 +1 @@
+exp-double-e-1 = 1ee2
diff --git a/src/lake/tests/toml/tests/invalid/float/exp-double-e-2.toml b/src/lake/tests/toml/tests/invalid/float/exp-double-e-2.toml
new file mode 100644
index 0000000000..8fb0158548
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/exp-double-e-2.toml
@@ -0,0 +1 @@
+exp-double-e-2 = 1e2e3
diff --git a/src/lake/tests/toml/tests/invalid/float/exp-double-us.toml b/src/lake/tests/toml/tests/invalid/float/exp-double-us.toml
new file mode 100644
index 0000000000..63f94e6c52
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/exp-double-us.toml
@@ -0,0 +1 @@
+exp-double-us = 1e__23
diff --git a/src/lake/tests/toml/tests/invalid/float/exp-leading-us.toml b/src/lake/tests/toml/tests/invalid/float/exp-leading-us.toml
new file mode 100644
index 0000000000..1426f36af3
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/exp-leading-us.toml
@@ -0,0 +1 @@
+exp-leading-us = 1e_23
diff --git a/src/lake/tests/toml/tests/invalid/float/exp-point-1.toml b/src/lake/tests/toml/tests/invalid/float/exp-point-1.toml
new file mode 100644
index 0000000000..569590bb8e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/exp-point-1.toml
@@ -0,0 +1 @@
+exp-point-1 = 1e2.3
diff --git a/src/lake/tests/toml/tests/invalid/float/exp-point-2.toml b/src/lake/tests/toml/tests/invalid/float/exp-point-2.toml
new file mode 100644
index 0000000000..4a5e1d4dda
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/exp-point-2.toml
@@ -0,0 +1 @@
+exp-point-2 = 1.e2
diff --git a/src/lake/tests/toml/tests/invalid/float/exp-point-3.toml b/src/lake/tests/toml/tests/invalid/float/exp-point-3.toml
new file mode 100644
index 0000000000..dd53e98a42
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/exp-point-3.toml
@@ -0,0 +1 @@
+exp-point-3 = 3.e+20
diff --git a/src/lake/tests/toml/tests/invalid/float/exp-trailing-us-1.toml b/src/lake/tests/toml/tests/invalid/float/exp-trailing-us-1.toml
new file mode 100644
index 0000000000..b0fb70e26f
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/exp-trailing-us-1.toml
@@ -0,0 +1 @@
+exp-trailing-us-1 = 1_e2
diff --git a/src/lake/tests/toml/tests/invalid/float/exp-trailing-us-2.toml b/src/lake/tests/toml/tests/invalid/float/exp-trailing-us-2.toml
new file mode 100644
index 0000000000..e35f3e3f66
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/exp-trailing-us-2.toml
@@ -0,0 +1 @@
+exp-trailing-us-2 = 1.2_e2
diff --git a/src/lake/tests/toml/tests/invalid/float/exp-trailing-us.toml b/src/lake/tests/toml/tests/invalid/float/exp-trailing-us.toml
new file mode 100644
index 0000000000..4d31fcd7e0
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/exp-trailing-us.toml
@@ -0,0 +1 @@
+exp-trailing-us = 1e23_
diff --git a/src/lake/tests/toml/tests/invalid/float/inf-capital.toml b/src/lake/tests/toml/tests/invalid/float/inf-capital.toml
new file mode 100644
index 0000000000..2c0cb4efb3
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/inf-capital.toml
@@ -0,0 +1 @@
+v = Inf
diff --git a/src/lake/tests/toml/tests/invalid/float/inf-incomplete-1.toml b/src/lake/tests/toml/tests/invalid/float/inf-incomplete-1.toml
new file mode 100644
index 0000000000..2c9ef598e6
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/inf-incomplete-1.toml
@@ -0,0 +1 @@
+inf-incomplete-1 = in
diff --git a/src/lake/tests/toml/tests/invalid/float/inf-incomplete-2.toml b/src/lake/tests/toml/tests/invalid/float/inf-incomplete-2.toml
new file mode 100644
index 0000000000..afda7123dc
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/inf-incomplete-2.toml
@@ -0,0 +1 @@
+inf-incomplete-2 = +in
diff --git a/src/lake/tests/toml/tests/invalid/float/inf-incomplete-3.toml b/src/lake/tests/toml/tests/invalid/float/inf-incomplete-3.toml
new file mode 100644
index 0000000000..bd8273866d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/inf-incomplete-3.toml
@@ -0,0 +1 @@
+inf-incomplete-3 = -in
diff --git a/src/lake/tests/toml/tests/invalid/float/inf_underscore.toml b/src/lake/tests/toml/tests/invalid/float/inf_underscore.toml
new file mode 100644
index 0000000000..8e6ab17093
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/inf_underscore.toml
@@ -0,0 +1 @@
+inf_underscore = in_f
diff --git a/src/lake/tests/toml/tests/invalid/float/leading-point-neg.toml b/src/lake/tests/toml/tests/invalid/float/leading-point-neg.toml
new file mode 100644
index 0000000000..74c526fc2b
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/leading-point-neg.toml
@@ -0,0 +1 @@
+leading-point-neg = -.12345
diff --git a/src/lake/tests/toml/tests/invalid/float/leading-point-plus.toml b/src/lake/tests/toml/tests/invalid/float/leading-point-plus.toml
new file mode 100644
index 0000000000..85e23a2824
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/leading-point-plus.toml
@@ -0,0 +1 @@
+leading-point-plus = +.12345
diff --git a/src/lake/tests/toml/tests/invalid/float/leading-point.toml b/src/lake/tests/toml/tests/invalid/float/leading-point.toml
new file mode 100644
index 0000000000..a3c29b972c
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/leading-point.toml
@@ -0,0 +1 @@
+leading-point = .12345
diff --git a/src/lake/tests/toml/tests/invalid/float/leading-us.toml b/src/lake/tests/toml/tests/invalid/float/leading-us.toml
new file mode 100644
index 0000000000..fa94fd0f51
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/leading-us.toml
@@ -0,0 +1 @@
+leading-us = _1.2
diff --git a/src/lake/tests/toml/tests/invalid/float/leading-zero-neg.toml b/src/lake/tests/toml/tests/invalid/float/leading-zero-neg.toml
new file mode 100644
index 0000000000..94a4e70aa7
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/leading-zero-neg.toml
@@ -0,0 +1 @@
+leading-zero-neg = -03.14
diff --git a/src/lake/tests/toml/tests/invalid/float/leading-zero-plus.toml b/src/lake/tests/toml/tests/invalid/float/leading-zero-plus.toml
new file mode 100644
index 0000000000..12bfd60037
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/leading-zero-plus.toml
@@ -0,0 +1 @@
+leading-zero-plus = +03.14
diff --git a/src/lake/tests/toml/tests/invalid/float/leading-zero.toml b/src/lake/tests/toml/tests/invalid/float/leading-zero.toml
new file mode 100644
index 0000000000..551fb25510
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/leading-zero.toml
@@ -0,0 +1 @@
+leading-zero = 03.14
diff --git a/src/lake/tests/toml/tests/invalid/float/nan-capital.toml b/src/lake/tests/toml/tests/invalid/float/nan-capital.toml
new file mode 100644
index 0000000000..f6f926e996
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/nan-capital.toml
@@ -0,0 +1 @@
+v = NaN
diff --git a/src/lake/tests/toml/tests/invalid/float/nan-incomplete-1.toml b/src/lake/tests/toml/tests/invalid/float/nan-incomplete-1.toml
new file mode 100644
index 0000000000..df2e261352
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/nan-incomplete-1.toml
@@ -0,0 +1 @@
+nan-incomplete-1 = na
diff --git a/src/lake/tests/toml/tests/invalid/float/nan-incomplete-2.toml b/src/lake/tests/toml/tests/invalid/float/nan-incomplete-2.toml
new file mode 100644
index 0000000000..6d2e8fb762
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/nan-incomplete-2.toml
@@ -0,0 +1 @@
+nan-incomplete-2 = +na
diff --git a/src/lake/tests/toml/tests/invalid/float/nan-incomplete-3.toml b/src/lake/tests/toml/tests/invalid/float/nan-incomplete-3.toml
new file mode 100644
index 0000000000..9d365acf9e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/nan-incomplete-3.toml
@@ -0,0 +1 @@
+nan-incomplete-3 = -na
diff --git a/src/lake/tests/toml/tests/invalid/float/nan_underscore.toml b/src/lake/tests/toml/tests/invalid/float/nan_underscore.toml
new file mode 100644
index 0000000000..44c8bf16f2
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/nan_underscore.toml
@@ -0,0 +1 @@
+nan_underscore = na_n
diff --git a/src/lake/tests/toml/tests/invalid/float/trailing-point-min.toml b/src/lake/tests/toml/tests/invalid/float/trailing-point-min.toml
new file mode 100644
index 0000000000..48741e3b18
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/trailing-point-min.toml
@@ -0,0 +1 @@
+trailing-point-min = -1.
diff --git a/src/lake/tests/toml/tests/invalid/float/trailing-point-plus.toml b/src/lake/tests/toml/tests/invalid/float/trailing-point-plus.toml
new file mode 100644
index 0000000000..99260390f7
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/trailing-point-plus.toml
@@ -0,0 +1 @@
+trailing-point-plus = +1.
diff --git a/src/lake/tests/toml/tests/invalid/float/trailing-point.toml b/src/lake/tests/toml/tests/invalid/float/trailing-point.toml
new file mode 100644
index 0000000000..76c95d916d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/trailing-point.toml
@@ -0,0 +1 @@
+trailing-point = 1.
diff --git a/src/lake/tests/toml/tests/invalid/float/trailing-us-exp-1.toml b/src/lake/tests/toml/tests/invalid/float/trailing-us-exp-1.toml
new file mode 100644
index 0000000000..7d4d3ccef6
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/trailing-us-exp-1.toml
@@ -0,0 +1 @@
+trailing-us-exp-1 = 1_e2
diff --git a/src/lake/tests/toml/tests/invalid/float/trailing-us-exp-2.toml b/src/lake/tests/toml/tests/invalid/float/trailing-us-exp-2.toml
new file mode 100644
index 0000000000..f869025fe6
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/trailing-us-exp-2.toml
@@ -0,0 +1 @@
+trailing-us-exp-2 = 1.2_e2
diff --git a/src/lake/tests/toml/tests/invalid/float/trailing-us.toml b/src/lake/tests/toml/tests/invalid/float/trailing-us.toml
new file mode 100644
index 0000000000..ddfb7ba005
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/trailing-us.toml
@@ -0,0 +1 @@
+trailing-us = 1.2_
diff --git a/src/lake/tests/toml/tests/invalid/float/us-after-point.toml b/src/lake/tests/toml/tests/invalid/float/us-after-point.toml
new file mode 100644
index 0000000000..7f15f57091
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/us-after-point.toml
@@ -0,0 +1 @@
+us-after-point = 1._2
diff --git a/src/lake/tests/toml/tests/invalid/float/us-before-point.toml b/src/lake/tests/toml/tests/invalid/float/us-before-point.toml
new file mode 100644
index 0000000000..c8edcbf0ce
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/float/us-before-point.toml
@@ -0,0 +1 @@
+us-before-point = 1_.2
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/add.toml b/src/lake/tests/toml/tests/invalid/inline-table/add.toml
new file mode 100644
index 0000000000..bb8b3e8c4b
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/add.toml
@@ -0,0 +1,3 @@
+a={}
+# Inline tables are immutable and can't be extended
+[a.b]
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/bad-key-syntax.toml b/src/lake/tests/toml/tests/invalid/inline-table/bad-key-syntax.toml
new file mode 100644
index 0000000000..bf71827ce8
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/bad-key-syntax.toml
@@ -0,0 +1 @@
+tbl = { a = 1, [b] }
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/dotted-key-conflict.toml b/src/lake/tests/toml/tests/invalid/inline-table/dotted-key-conflict.toml
new file mode 100644
index 0000000000..58fa3b2ae0
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/dotted-key-conflict.toml
@@ -0,0 +1 @@
+tbl = { a.b = "a_b", a.b.c = "a_b_c" }
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/double-comma.toml b/src/lake/tests/toml/tests/invalid/inline-table/double-comma.toml
new file mode 100644
index 0000000000..2d2913a395
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/double-comma.toml
@@ -0,0 +1 @@
+t = {x=3,,y=4}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key-1.toml b/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key-1.toml
new file mode 100644
index 0000000000..0789e146df
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key-1.toml
@@ -0,0 +1,2 @@
+# Duplicate keys within an inline table are invalid
+a={b=1, b=2}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key-2.toml b/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key-2.toml
new file mode 100644
index 0000000000..a942679836
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key-2.toml
@@ -0,0 +1 @@
+table1 = { table2.dupe = 1, table2.dupe = 2 }
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key-3.toml b/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key-3.toml
new file mode 100644
index 0000000000..c567c3f5e4
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key-3.toml
@@ -0,0 +1,2 @@
+tbl = { fruit = { apple.color = "red" }, fruit.apple.texture = { smooth = true } }
+
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key-4.toml b/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key-4.toml
new file mode 100644
index 0000000000..58fa3b2ae0
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key-4.toml
@@ -0,0 +1 @@
+tbl = { a.b = "a_b", a.b.c = "a_b_c" }
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key.toml b/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key.toml
new file mode 100644
index 0000000000..0789e146df
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/duplicate-key.toml
@@ -0,0 +1,2 @@
+# Duplicate keys within an inline table are invalid
+a={b=1, b=2}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/empty-1.toml b/src/lake/tests/toml/tests/invalid/inline-table/empty-1.toml
new file mode 100644
index 0000000000..ebbb06664d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/empty-1.toml
@@ -0,0 +1 @@
+t = {,}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/empty-2.toml b/src/lake/tests/toml/tests/invalid/inline-table/empty-2.toml
new file mode 100644
index 0000000000..646a8970f1
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/empty-2.toml
@@ -0,0 +1,2 @@
+t = {,
+}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/empty-3.toml b/src/lake/tests/toml/tests/invalid/inline-table/empty-3.toml
new file mode 100644
index 0000000000..f69a0709a8
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/empty-3.toml
@@ -0,0 +1,3 @@
+t = {
+,
+}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/empty.toml b/src/lake/tests/toml/tests/invalid/inline-table/empty.toml
new file mode 100644
index 0000000000..ebbb06664d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/empty.toml
@@ -0,0 +1 @@
+t = {,}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/linebreak-1.toml b/src/lake/tests/toml/tests/invalid/inline-table/linebreak-1.toml
new file mode 100644
index 0000000000..0ae44b63ce
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/linebreak-1.toml
@@ -0,0 +1,4 @@
+# No newlines are allowed between the curly braces unless they are valid within
+# a value.
+simple = { a = 1 
+}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/linebreak-2.toml b/src/lake/tests/toml/tests/invalid/inline-table/linebreak-2.toml
new file mode 100644
index 0000000000..5ea4eaf5fb
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/linebreak-2.toml
@@ -0,0 +1,2 @@
+t = {a=1,
+b=2}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/linebreak-3.toml b/src/lake/tests/toml/tests/invalid/inline-table/linebreak-3.toml
new file mode 100644
index 0000000000..7f6e892494
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/linebreak-3.toml
@@ -0,0 +1,2 @@
+t = {a=1
+,b=2}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/linebreak-4.toml b/src/lake/tests/toml/tests/invalid/inline-table/linebreak-4.toml
new file mode 100644
index 0000000000..3f34e15c07
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/linebreak-4.toml
@@ -0,0 +1,4 @@
+json_like = {
+          first = "Tom",
+          last = "Preston-Werner"
+}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/nested_key_conflict.toml b/src/lake/tests/toml/tests/invalid/inline-table/nested_key_conflict.toml
new file mode 100644
index 0000000000..c567c3f5e4
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/nested_key_conflict.toml
@@ -0,0 +1,2 @@
+tbl = { fruit = { apple.color = "red" }, fruit.apple.texture = { smooth = true } }
+
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/no-close-1.toml b/src/lake/tests/toml/tests/invalid/inline-table/no-close-1.toml
new file mode 100644
index 0000000000..e269d228cf
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/no-close-1.toml
@@ -0,0 +1 @@
+a={
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/no-close-2.toml b/src/lake/tests/toml/tests/invalid/inline-table/no-close-2.toml
new file mode 100644
index 0000000000..64a9e7dd64
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/no-close-2.toml
@@ -0,0 +1 @@
+a={b=1
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/no-comma-1.toml b/src/lake/tests/toml/tests/invalid/inline-table/no-comma-1.toml
new file mode 100644
index 0000000000..0a4083de55
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/no-comma-1.toml
@@ -0,0 +1 @@
+t = {x = 3 y = 4}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/no-comma-2.toml b/src/lake/tests/toml/tests/invalid/inline-table/no-comma-2.toml
new file mode 100644
index 0000000000..d98b41dd03
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/no-comma-2.toml
@@ -0,0 +1 @@
+arrr = { comma-missing = true valid-toml = false }
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/no-comma.toml b/src/lake/tests/toml/tests/invalid/inline-table/no-comma.toml
new file mode 100644
index 0000000000..0a4083de55
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/no-comma.toml
@@ -0,0 +1 @@
+t = {x = 3 y = 4}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/overwrite.toml b/src/lake/tests/toml/tests/invalid/inline-table/overwrite.toml
new file mode 100644
index 0000000000..4da0a8580e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/overwrite.toml
@@ -0,0 +1,3 @@
+a.b=0
+# Since table "a" is already defined, it can't be replaced by an inline table.
+a={}
diff --git a/src/lake/tests/toml/tests/invalid/inline-table/trailing-comma.toml b/src/lake/tests/toml/tests/invalid/inline-table/trailing-comma.toml
new file mode 100644
index 0000000000..6b67e02096
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/inline-table/trailing-comma.toml
@@ -0,0 +1,3 @@
+# A terminating comma (also called trailing comma) is not permitted after the
+# last key/value pair in an inline table
+abc = { abc = 123, }
diff --git a/src/lake/tests/toml/tests/invalid/integer/capital-bin.toml b/src/lake/tests/toml/tests/invalid/integer/capital-bin.toml
new file mode 100644
index 0000000000..bea4e5e270
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/capital-bin.toml
@@ -0,0 +1 @@
+capital-bin = 0B0
diff --git a/src/lake/tests/toml/tests/invalid/integer/capital-hex.toml b/src/lake/tests/toml/tests/invalid/integer/capital-hex.toml
new file mode 100644
index 0000000000..bc064bb630
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/capital-hex.toml
@@ -0,0 +1 @@
+capital-hex = 0X1
diff --git a/src/lake/tests/toml/tests/invalid/integer/capital-oct.toml b/src/lake/tests/toml/tests/invalid/integer/capital-oct.toml
new file mode 100644
index 0000000000..ea08a4da91
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/capital-oct.toml
@@ -0,0 +1 @@
+capital-oct = 0O0
diff --git a/src/lake/tests/toml/tests/invalid/integer/double-sign-nex.toml b/src/lake/tests/toml/tests/invalid/integer/double-sign-nex.toml
new file mode 100644
index 0000000000..ff014cf051
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/double-sign-nex.toml
@@ -0,0 +1 @@
+double-sign-nex = --99
diff --git a/src/lake/tests/toml/tests/invalid/integer/double-sign-plus.toml b/src/lake/tests/toml/tests/invalid/integer/double-sign-plus.toml
new file mode 100644
index 0000000000..845ebb599a
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/double-sign-plus.toml
@@ -0,0 +1 @@
+double-sign-plus = ++99
diff --git a/src/lake/tests/toml/tests/invalid/integer/double-us.toml b/src/lake/tests/toml/tests/invalid/integer/double-us.toml
new file mode 100644
index 0000000000..cd00561f6d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/double-us.toml
@@ -0,0 +1 @@
+double-us = 1__23
diff --git a/src/lake/tests/toml/tests/invalid/integer/incomplete-bin.toml b/src/lake/tests/toml/tests/invalid/integer/incomplete-bin.toml
new file mode 100644
index 0000000000..2d80143d88
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/incomplete-bin.toml
@@ -0,0 +1 @@
+incomplete-bin = 0b
diff --git a/src/lake/tests/toml/tests/invalid/integer/incomplete-hex.toml b/src/lake/tests/toml/tests/invalid/integer/incomplete-hex.toml
new file mode 100644
index 0000000000..691b09c78d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/incomplete-hex.toml
@@ -0,0 +1 @@
+incomplete-hex = 0x
diff --git a/src/lake/tests/toml/tests/invalid/integer/incomplete-oct.toml b/src/lake/tests/toml/tests/invalid/integer/incomplete-oct.toml
new file mode 100644
index 0000000000..a248b7186e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/incomplete-oct.toml
@@ -0,0 +1 @@
+incomplete-oct = 0o
diff --git a/src/lake/tests/toml/tests/invalid/integer/invalid-bin.toml b/src/lake/tests/toml/tests/invalid/integer/invalid-bin.toml
new file mode 100644
index 0000000000..d0182581bc
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/invalid-bin.toml
@@ -0,0 +1 @@
+invalid-bin = 0b0012
diff --git a/src/lake/tests/toml/tests/invalid/integer/invalid-hex.toml b/src/lake/tests/toml/tests/invalid/integer/invalid-hex.toml
new file mode 100644
index 0000000000..7cc0e855e5
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/invalid-hex.toml
@@ -0,0 +1 @@
+invalid-hex = 0xaafz
diff --git a/src/lake/tests/toml/tests/invalid/integer/invalid-oct.toml b/src/lake/tests/toml/tests/invalid/integer/invalid-oct.toml
new file mode 100644
index 0000000000..03181b1a45
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/invalid-oct.toml
@@ -0,0 +1 @@
+invalid-oct = 0o778
diff --git a/src/lake/tests/toml/tests/invalid/integer/leading-us-bin.toml b/src/lake/tests/toml/tests/invalid/integer/leading-us-bin.toml
new file mode 100644
index 0000000000..8885c031a8
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/leading-us-bin.toml
@@ -0,0 +1 @@
+leading-us-bin = _0o1
diff --git a/src/lake/tests/toml/tests/invalid/integer/leading-us-hex.toml b/src/lake/tests/toml/tests/invalid/integer/leading-us-hex.toml
new file mode 100644
index 0000000000..9f193f80e9
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/leading-us-hex.toml
@@ -0,0 +1 @@
+leading-us-hex = _0o1
diff --git a/src/lake/tests/toml/tests/invalid/integer/leading-us-oct.toml b/src/lake/tests/toml/tests/invalid/integer/leading-us-oct.toml
new file mode 100644
index 0000000000..a717f1c814
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/leading-us-oct.toml
@@ -0,0 +1 @@
+leading-us-oct = _0o1
diff --git a/src/lake/tests/toml/tests/invalid/integer/leading-us.toml b/src/lake/tests/toml/tests/invalid/integer/leading-us.toml
new file mode 100644
index 0000000000..d059f50a87
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/leading-us.toml
@@ -0,0 +1 @@
+leading-us = _123
diff --git a/src/lake/tests/toml/tests/invalid/integer/leading-zero-1.toml b/src/lake/tests/toml/tests/invalid/integer/leading-zero-1.toml
new file mode 100644
index 0000000000..eba6bda313
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/leading-zero-1.toml
@@ -0,0 +1 @@
+leading-zero-1 = 01
diff --git a/src/lake/tests/toml/tests/invalid/integer/leading-zero-2.toml b/src/lake/tests/toml/tests/invalid/integer/leading-zero-2.toml
new file mode 100644
index 0000000000..436af56527
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/leading-zero-2.toml
@@ -0,0 +1 @@
+leading-zero-2 = 00
diff --git a/src/lake/tests/toml/tests/invalid/integer/leading-zero-3.toml b/src/lake/tests/toml/tests/invalid/integer/leading-zero-3.toml
new file mode 100644
index 0000000000..5404fc8adc
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/leading-zero-3.toml
@@ -0,0 +1 @@
+leading-zero-3 = 0_0
diff --git a/src/lake/tests/toml/tests/invalid/integer/leading-zero-sign-1.toml b/src/lake/tests/toml/tests/invalid/integer/leading-zero-sign-1.toml
new file mode 100644
index 0000000000..1f15a9da54
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/leading-zero-sign-1.toml
@@ -0,0 +1 @@
+leading-zero-sign-1 = -01
diff --git a/src/lake/tests/toml/tests/invalid/integer/leading-zero-sign-2.toml b/src/lake/tests/toml/tests/invalid/integer/leading-zero-sign-2.toml
new file mode 100644
index 0000000000..fa259c3cd3
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/leading-zero-sign-2.toml
@@ -0,0 +1 @@
+leading-zero-sign-2 = +01
diff --git a/src/lake/tests/toml/tests/invalid/integer/leading-zero-sign-3.toml b/src/lake/tests/toml/tests/invalid/integer/leading-zero-sign-3.toml
new file mode 100644
index 0000000000..3ac64a5c3b
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/leading-zero-sign-3.toml
@@ -0,0 +1 @@
+leading-zero-sign-3 = +0_1
diff --git a/src/lake/tests/toml/tests/invalid/integer/negative-bin.toml b/src/lake/tests/toml/tests/invalid/integer/negative-bin.toml
new file mode 100644
index 0000000000..948b23678a
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/negative-bin.toml
@@ -0,0 +1 @@
+negative-bin = -0b11010110
diff --git a/src/lake/tests/toml/tests/invalid/integer/negative-hex.toml b/src/lake/tests/toml/tests/invalid/integer/negative-hex.toml
new file mode 100644
index 0000000000..67c31ea436
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/negative-hex.toml
@@ -0,0 +1 @@
+negative-hex = -0xff
diff --git a/src/lake/tests/toml/tests/invalid/integer/negative-oct.toml b/src/lake/tests/toml/tests/invalid/integer/negative-oct.toml
new file mode 100644
index 0000000000..b0c5ab0da3
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/negative-oct.toml
@@ -0,0 +1 @@
+negative-oct = -0o99
diff --git a/src/lake/tests/toml/tests/invalid/integer/positive-bin.toml b/src/lake/tests/toml/tests/invalid/integer/positive-bin.toml
new file mode 100644
index 0000000000..7d6de65172
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/positive-bin.toml
@@ -0,0 +1 @@
+positive-bin = +0b11010110
diff --git a/src/lake/tests/toml/tests/invalid/integer/positive-hex.toml b/src/lake/tests/toml/tests/invalid/integer/positive-hex.toml
new file mode 100644
index 0000000000..bd503aad41
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/positive-hex.toml
@@ -0,0 +1 @@
+positive-hex = +0xff
diff --git a/src/lake/tests/toml/tests/invalid/integer/positive-oct.toml b/src/lake/tests/toml/tests/invalid/integer/positive-oct.toml
new file mode 100644
index 0000000000..d77aa5213e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/positive-oct.toml
@@ -0,0 +1 @@
+positive-oct = +0o99
diff --git a/src/lake/tests/toml/tests/invalid/integer/text-after-integer.toml b/src/lake/tests/toml/tests/invalid/integer/text-after-integer.toml
new file mode 100644
index 0000000000..42de7aff4d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/text-after-integer.toml
@@ -0,0 +1 @@
+answer = 42 the ultimate answer?
diff --git a/src/lake/tests/toml/tests/invalid/integer/trailing-us-bin.toml b/src/lake/tests/toml/tests/invalid/integer/trailing-us-bin.toml
new file mode 100644
index 0000000000..9a0b57419c
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/trailing-us-bin.toml
@@ -0,0 +1 @@
+trailing-us-bin = 0b1_
diff --git a/src/lake/tests/toml/tests/invalid/integer/trailing-us-hex.toml b/src/lake/tests/toml/tests/invalid/integer/trailing-us-hex.toml
new file mode 100644
index 0000000000..2a9645509a
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/trailing-us-hex.toml
@@ -0,0 +1 @@
+trailing-us-hex = 0x1_
diff --git a/src/lake/tests/toml/tests/invalid/integer/trailing-us-oct.toml b/src/lake/tests/toml/tests/invalid/integer/trailing-us-oct.toml
new file mode 100644
index 0000000000..d28e8bca90
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/trailing-us-oct.toml
@@ -0,0 +1 @@
+trailing-us-oct = 0o1_
diff --git a/src/lake/tests/toml/tests/invalid/integer/trailing-us.toml b/src/lake/tests/toml/tests/invalid/integer/trailing-us.toml
new file mode 100644
index 0000000000..e11e8ff6b0
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/trailing-us.toml
@@ -0,0 +1 @@
+trailing-us = 123_
diff --git a/src/lake/tests/toml/tests/invalid/integer/us-after-bin.toml b/src/lake/tests/toml/tests/invalid/integer/us-after-bin.toml
new file mode 100644
index 0000000000..61dd895dea
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/us-after-bin.toml
@@ -0,0 +1 @@
+us-after-bin = 0b_1
diff --git a/src/lake/tests/toml/tests/invalid/integer/us-after-hex.toml b/src/lake/tests/toml/tests/invalid/integer/us-after-hex.toml
new file mode 100644
index 0000000000..200220ad93
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/us-after-hex.toml
@@ -0,0 +1 @@
+us-after-hex = 0x_1
diff --git a/src/lake/tests/toml/tests/invalid/integer/us-after-oct.toml b/src/lake/tests/toml/tests/invalid/integer/us-after-oct.toml
new file mode 100644
index 0000000000..23f530030d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/integer/us-after-oct.toml
@@ -0,0 +1 @@
+us-after-oct = 0o_1
diff --git a/src/lake/tests/toml/tests/invalid/key/after-array.toml b/src/lake/tests/toml/tests/invalid/key/after-array.toml
new file mode 100644
index 0000000000..5c1a1b0a9b
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/after-array.toml
@@ -0,0 +1 @@
+[[agencies]] owner = "S Cjelli"
diff --git a/src/lake/tests/toml/tests/invalid/key/after-table.toml b/src/lake/tests/toml/tests/invalid/key/after-table.toml
new file mode 100644
index 0000000000..68867842cb
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/after-table.toml
@@ -0,0 +1 @@
+[error] this = "should not be here"
diff --git a/src/lake/tests/toml/tests/invalid/key/after-value.toml b/src/lake/tests/toml/tests/invalid/key/after-value.toml
new file mode 100644
index 0000000000..e05c47c231
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/after-value.toml
@@ -0,0 +1 @@
+first = "Tom" last = "Preston-Werner" # INVALID
diff --git a/src/lake/tests/toml/tests/invalid/key/bare-invalid-character.toml b/src/lake/tests/toml/tests/invalid/key/bare-invalid-character.toml
new file mode 100644
index 0000000000..e50dbe3889
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/bare-invalid-character.toml
@@ -0,0 +1 @@
+bare!key = 123
diff --git a/src/lake/tests/toml/tests/invalid/key/dotted-redefine-table.toml b/src/lake/tests/toml/tests/invalid/key/dotted-redefine-table.toml
new file mode 100644
index 0000000000..55e25ac083
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/dotted-redefine-table.toml
@@ -0,0 +1,4 @@
+# Defined a.b as int
+a.b = 1
+# Tries to access it as table: error
+a.b.c = 2
diff --git a/src/lake/tests/toml/tests/invalid/key/duplicate-keys.toml b/src/lake/tests/toml/tests/invalid/key/duplicate-keys.toml
new file mode 100644
index 0000000000..9b5aee0e59
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/duplicate-keys.toml
@@ -0,0 +1,2 @@
+dupe = false
+dupe = true
diff --git a/src/lake/tests/toml/tests/invalid/key/duplicate.toml b/src/lake/tests/toml/tests/invalid/key/duplicate.toml
new file mode 100644
index 0000000000..7847bd401d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/duplicate.toml
@@ -0,0 +1,3 @@
+# DO NOT DO THIS
+name = "Tom"
+name = "Pradyun"
diff --git a/src/lake/tests/toml/tests/invalid/key/empty.toml b/src/lake/tests/toml/tests/invalid/key/empty.toml
new file mode 100644
index 0000000000..09f998f416
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/empty.toml
@@ -0,0 +1 @@
+ = 1
diff --git a/src/lake/tests/toml/tests/invalid/key/escape.toml b/src/lake/tests/toml/tests/invalid/key/escape.toml
new file mode 100644
index 0000000000..cdb8f4d68e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/escape.toml
@@ -0,0 +1 @@
+\u00c0 = "latin capital letter A with grave"
diff --git a/src/lake/tests/toml/tests/invalid/key/hash.toml b/src/lake/tests/toml/tests/invalid/key/hash.toml
new file mode 100644
index 0000000000..e321b1fbd0
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/hash.toml
@@ -0,0 +1 @@
+a# = 1
diff --git a/src/lake/tests/toml/tests/invalid/key/multiline.toml b/src/lake/tests/toml/tests/invalid/key/multiline.toml
new file mode 100644
index 0000000000..31ff67e423
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/multiline.toml
@@ -0,0 +1,2 @@
+"""long
+key""" = 1
diff --git a/src/lake/tests/toml/tests/invalid/key/newline.toml b/src/lake/tests/toml/tests/invalid/key/newline.toml
new file mode 100644
index 0000000000..24acaa1b1f
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/newline.toml
@@ -0,0 +1,2 @@
+barekey
+   = 123
diff --git a/src/lake/tests/toml/tests/invalid/key/no-eol.toml b/src/lake/tests/toml/tests/invalid/key/no-eol.toml
new file mode 100644
index 0000000000..3c58eee182
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/no-eol.toml
@@ -0,0 +1 @@
+a = 1 b = 2
diff --git a/src/lake/tests/toml/tests/invalid/key/open-bracket.toml b/src/lake/tests/toml/tests/invalid/key/open-bracket.toml
new file mode 100644
index 0000000000..f0aeb16e50
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/open-bracket.toml
@@ -0,0 +1 @@
+[abc = 1
diff --git a/src/lake/tests/toml/tests/invalid/key/partial-quoted.toml b/src/lake/tests/toml/tests/invalid/key/partial-quoted.toml
new file mode 100644
index 0000000000..e491a2f11f
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/partial-quoted.toml
@@ -0,0 +1 @@
+partial"quoted" = 5
diff --git a/src/lake/tests/toml/tests/invalid/key/quoted-unclosed-1.toml b/src/lake/tests/toml/tests/invalid/key/quoted-unclosed-1.toml
new file mode 100644
index 0000000000..4ea331aa60
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/quoted-unclosed-1.toml
@@ -0,0 +1 @@
+"key = x
diff --git a/src/lake/tests/toml/tests/invalid/key/quoted-unclosed-2.toml b/src/lake/tests/toml/tests/invalid/key/quoted-unclosed-2.toml
new file mode 100644
index 0000000000..d341d80111
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/quoted-unclosed-2.toml
@@ -0,0 +1 @@
+"key
diff --git a/src/lake/tests/toml/tests/invalid/key/single-open-bracket.toml b/src/lake/tests/toml/tests/invalid/key/single-open-bracket.toml
new file mode 100644
index 0000000000..558ed37d93
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/single-open-bracket.toml
@@ -0,0 +1 @@
+[
diff --git a/src/lake/tests/toml/tests/invalid/key/space.toml b/src/lake/tests/toml/tests/invalid/key/space.toml
new file mode 100644
index 0000000000..7c22703e88
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/space.toml
@@ -0,0 +1 @@
+a b = 1
diff --git a/src/lake/tests/toml/tests/invalid/key/special-character.toml b/src/lake/tests/toml/tests/invalid/key/special-character.toml
new file mode 100644
index 0000000000..bc181a5cc9
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/special-character.toml
@@ -0,0 +1 @@
+μ = "greek small letter mu"
diff --git a/src/lake/tests/toml/tests/invalid/key/start-bracket.toml b/src/lake/tests/toml/tests/invalid/key/start-bracket.toml
new file mode 100644
index 0000000000..e0597ae1c6
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/start-bracket.toml
@@ -0,0 +1,3 @@
+[a]
+[xyz = 5
+[b]
diff --git a/src/lake/tests/toml/tests/invalid/key/start-dot.toml b/src/lake/tests/toml/tests/invalid/key/start-dot.toml
new file mode 100644
index 0000000000..9967c7ddbf
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/start-dot.toml
@@ -0,0 +1 @@
+.key = 1
diff --git a/src/lake/tests/toml/tests/invalid/key/two-equals.toml b/src/lake/tests/toml/tests/invalid/key/two-equals.toml
new file mode 100644
index 0000000000..25a037894e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/two-equals.toml
@@ -0,0 +1 @@
+key= = 1
diff --git a/src/lake/tests/toml/tests/invalid/key/two-equals2.toml b/src/lake/tests/toml/tests/invalid/key/two-equals2.toml
new file mode 100644
index 0000000000..c5f2de8b69
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/two-equals2.toml
@@ -0,0 +1 @@
+a==1
diff --git a/src/lake/tests/toml/tests/invalid/key/two-equals3.toml b/src/lake/tests/toml/tests/invalid/key/two-equals3.toml
new file mode 100644
index 0000000000..eb203729a8
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/two-equals3.toml
@@ -0,0 +1 @@
+a=b=1
diff --git a/src/lake/tests/toml/tests/invalid/key/without-value-1.toml b/src/lake/tests/toml/tests/invalid/key/without-value-1.toml
new file mode 100644
index 0000000000..06bfde4933
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/without-value-1.toml
@@ -0,0 +1 @@
+key
diff --git a/src/lake/tests/toml/tests/invalid/key/without-value-2.toml b/src/lake/tests/toml/tests/invalid/key/without-value-2.toml
new file mode 100644
index 0000000000..ca6d7eba67
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/without-value-2.toml
@@ -0,0 +1 @@
+key = 
diff --git a/src/lake/tests/toml/tests/invalid/key/without-value-3.toml b/src/lake/tests/toml/tests/invalid/key/without-value-3.toml
new file mode 100644
index 0000000000..a9c06effde
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/without-value-3.toml
@@ -0,0 +1 @@
+"key"
diff --git a/src/lake/tests/toml/tests/invalid/key/without-value-4.toml b/src/lake/tests/toml/tests/invalid/key/without-value-4.toml
new file mode 100644
index 0000000000..adf9d62593
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/key/without-value-4.toml
@@ -0,0 +1 @@
+"key" = 
diff --git a/src/lake/tests/toml/tests/invalid/spec/inline-table-2-0.toml b/src/lake/tests/toml/tests/invalid/spec/inline-table-2-0.toml
new file mode 100644
index 0000000000..7689e14fb7
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/spec/inline-table-2-0.toml
@@ -0,0 +1,3 @@
+[product]
+type = { name = "Nail" }
+type.edible = false  # INVALID
diff --git a/src/lake/tests/toml/tests/invalid/spec/inline-table-3-0.toml b/src/lake/tests/toml/tests/invalid/spec/inline-table-3-0.toml
new file mode 100644
index 0000000000..d6937eb8b8
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/spec/inline-table-3-0.toml
@@ -0,0 +1,3 @@
+[product]
+type.name = "Nail"
+type = { edible = false }  # INVALID
diff --git a/src/lake/tests/toml/tests/invalid/spec/key-value-pair-1.toml b/src/lake/tests/toml/tests/invalid/spec/key-value-pair-1.toml
new file mode 100644
index 0000000000..56f085a5b0
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/spec/key-value-pair-1.toml
@@ -0,0 +1 @@
+key = # INVALID
diff --git a/src/lake/tests/toml/tests/invalid/spec/keys-2.toml b/src/lake/tests/toml/tests/invalid/spec/keys-2.toml
new file mode 100644
index 0000000000..1547a5c767
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/spec/keys-2.toml
@@ -0,0 +1,3 @@
+= "no key name"  # INVALID
+"" = "blank"     # VALID but discouraged
+'' = 'blank'     # VALID but discouraged
diff --git a/src/lake/tests/toml/tests/invalid/spec/string-4-0.toml b/src/lake/tests/toml/tests/invalid/spec/string-4-0.toml
new file mode 100644
index 0000000000..72071ea98a
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/spec/string-4-0.toml
@@ -0,0 +1,7 @@
+str4 = """Here are two quotation marks: "". Simple enough."""
+str5 = """Here are three quotation marks: """."""  # INVALID
+str5 = """Here are three quotation marks: ""\"."""
+str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\"."""
+
+# "This," she said, "is just a pointless statement."
+str7 = """"This," she said, "is just a pointless statement.""""
diff --git a/src/lake/tests/toml/tests/invalid/spec/string-7-0.toml b/src/lake/tests/toml/tests/invalid/spec/string-7-0.toml
new file mode 100644
index 0000000000..7b20aeca04
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/spec/string-7-0.toml
@@ -0,0 +1,7 @@
+quot15 = '''Here are fifteen quotation marks: """""""""""""""'''
+
+apos15 = '''Here are fifteen apostrophes: ''''''''''''''''''  # INVALID
+apos15 = "Here are fifteen apostrophes: '''''''''''''''"
+
+# 'That,' she said, 'is still pointless.'
+str = ''''That,' she said, 'is still pointless.''''
diff --git a/src/lake/tests/toml/tests/invalid/spec/table-9-0.toml b/src/lake/tests/toml/tests/invalid/spec/table-9-0.toml
new file mode 100644
index 0000000000..adc384101d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/spec/table-9-0.toml
@@ -0,0 +1,9 @@
+[fruit]
+apple.color = "red"
+apple.taste.sweet = true
+
+[fruit.apple]  # INVALID
+# [fruit.apple.taste]  # INVALID
+
+[fruit.apple.texture]  # you can add sub-tables
+smooth = true
diff --git a/src/lake/tests/toml/tests/invalid/spec/table-9-1.toml b/src/lake/tests/toml/tests/invalid/spec/table-9-1.toml
new file mode 100644
index 0000000000..3b5644ea08
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/spec/table-9-1.toml
@@ -0,0 +1,9 @@
+[fruit]
+apple.color = "red"
+apple.taste.sweet = true
+
+# [fruit.apple]  # INVALID
+[fruit.apple.taste]  # INVALID
+
+[fruit.apple.texture]  # you can add sub-tables
+smooth = true
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-byte-escape.toml b/src/lake/tests/toml/tests/invalid/string/bad-byte-escape.toml
new file mode 100644
index 0000000000..4c7be59f4b
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-byte-escape.toml
@@ -0,0 +1 @@
+naughty = "\xAg"
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-codepoint.toml b/src/lake/tests/toml/tests/invalid/string/bad-codepoint.toml
new file mode 100644
index 0000000000..592db75bb0
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-codepoint.toml
@@ -0,0 +1 @@
+invalid-codepoint = "This string contains a non scalar unicode codepoint \uD801"
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-concat.toml b/src/lake/tests/toml/tests/invalid/string/bad-concat.toml
new file mode 100644
index 0000000000..fc6d3c9cf0
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-concat.toml
@@ -0,0 +1 @@
+no_concat = "first" "second"
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-escape-1.toml b/src/lake/tests/toml/tests/invalid/string/bad-escape-1.toml
new file mode 100644
index 0000000000..60acb0ccc5
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-escape-1.toml
@@ -0,0 +1 @@
+invalid-escape = "This string has a bad \a escape character."
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-escape-2.toml b/src/lake/tests/toml/tests/invalid/string/bad-escape-2.toml
new file mode 100644
index 0000000000..2a20d8c905
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-escape-2.toml
@@ -0,0 +1,2 @@
+invalid-escape = "This string has a bad \  escape character."
+
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-1.toml b/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-1.toml
new file mode 100644
index 0000000000..199c961522
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-1.toml
@@ -0,0 +1 @@
+bad-hex-esc-1 = "\x0g"
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-2.toml b/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-2.toml
new file mode 100644
index 0000000000..3ff0765348
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-2.toml
@@ -0,0 +1 @@
+bad-hex-esc-2 = "\xG0"
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-3.toml b/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-3.toml
new file mode 100644
index 0000000000..5a1df546c7
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-3.toml
@@ -0,0 +1 @@
+bad-hex-esc-3 = "\x"
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-4.toml b/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-4.toml
new file mode 100644
index 0000000000..4df871b6a2
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-4.toml
@@ -0,0 +1 @@
+bad-hex-esc-4 = "\x 50"
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-5.toml b/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-5.toml
new file mode 100644
index 0000000000..379922fda9
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-hex-esc-5.toml
@@ -0,0 +1 @@
+bad-hex-esc-5 = "\x 50"
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-multiline.toml b/src/lake/tests/toml/tests/invalid/string/bad-multiline.toml
new file mode 100644
index 0000000000..786046b55a
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-multiline.toml
@@ -0,0 +1,2 @@
+multi = "first line
+second line"
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-slash-escape.toml b/src/lake/tests/toml/tests/invalid/string/bad-slash-escape.toml
new file mode 100644
index 0000000000..154abadd5c
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-slash-escape.toml
@@ -0,0 +1 @@
+invalid-escape = "This string has a bad \/ escape character."
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-1.toml b/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-1.toml
new file mode 100644
index 0000000000..9eae4ab96e
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-1.toml
@@ -0,0 +1 @@
+str = "val\ue"
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-2.toml b/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-2.toml
new file mode 100644
index 0000000000..dce8b08918
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-2.toml
@@ -0,0 +1 @@
+str = "val\Ux"
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-3.toml b/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-3.toml
new file mode 100644
index 0000000000..95ea098282
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-3.toml
@@ -0,0 +1,2 @@
+str = "val\U0000000"
+
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-4.toml b/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-4.toml
new file mode 100644
index 0000000000..b90d0fb3f6
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-4.toml
@@ -0,0 +1 @@
+str = "val\U0000"
diff --git a/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-5.toml b/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-5.toml
new file mode 100644
index 0000000000..448d3c6d8c
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/bad-uni-esc-5.toml
@@ -0,0 +1 @@
+str = "val\Ugggggggg"
diff --git a/src/lake/tests/toml/tests/invalid/string/basic-byte-escapes.toml b/src/lake/tests/toml/tests/invalid/string/basic-byte-escapes.toml
new file mode 100644
index 0000000000..e94452a8df
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/basic-byte-escapes.toml
@@ -0,0 +1 @@
+answer = "\x33"
diff --git a/src/lake/tests/toml/tests/invalid/string/basic-multiline-out-of-range-unicode-escape-1.toml b/src/lake/tests/toml/tests/invalid/string/basic-multiline-out-of-range-unicode-escape-1.toml
new file mode 100644
index 0000000000..b27e203c74
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/basic-multiline-out-of-range-unicode-escape-1.toml
@@ -0,0 +1 @@
+a = """\UFFFFFFFF"""
diff --git a/src/lake/tests/toml/tests/invalid/string/basic-multiline-out-of-range-unicode-escape-2.toml b/src/lake/tests/toml/tests/invalid/string/basic-multiline-out-of-range-unicode-escape-2.toml
new file mode 100644
index 0000000000..17a9361b3f
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/basic-multiline-out-of-range-unicode-escape-2.toml
@@ -0,0 +1 @@
+a = """\U00D80000"""
diff --git a/src/lake/tests/toml/tests/invalid/string/basic-multiline-quotes.toml b/src/lake/tests/toml/tests/invalid/string/basic-multiline-quotes.toml
new file mode 100644
index 0000000000..02ebf13a0c
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/basic-multiline-quotes.toml
@@ -0,0 +1 @@
+str5 = """Here are three quotation marks: """."""
diff --git a/src/lake/tests/toml/tests/invalid/string/basic-multiline-unknown-escape.toml b/src/lake/tests/toml/tests/invalid/string/basic-multiline-unknown-escape.toml
new file mode 100644
index 0000000000..35c5cc5ea7
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/basic-multiline-unknown-escape.toml
@@ -0,0 +1 @@
+a = """\@"""
diff --git a/src/lake/tests/toml/tests/invalid/string/basic-out-of-range-unicode-escape-1.toml b/src/lake/tests/toml/tests/invalid/string/basic-out-of-range-unicode-escape-1.toml
new file mode 100644
index 0000000000..ada1f557ff
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/basic-out-of-range-unicode-escape-1.toml
@@ -0,0 +1 @@
+a = "\UFFFFFFFF"
diff --git a/src/lake/tests/toml/tests/invalid/string/basic-out-of-range-unicode-escape-2.toml b/src/lake/tests/toml/tests/invalid/string/basic-out-of-range-unicode-escape-2.toml
new file mode 100644
index 0000000000..d4833b3dbb
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/basic-out-of-range-unicode-escape-2.toml
@@ -0,0 +1 @@
+a = "\U00D80000"
diff --git a/src/lake/tests/toml/tests/invalid/string/basic-unknown-escape.toml b/src/lake/tests/toml/tests/invalid/string/basic-unknown-escape.toml
new file mode 100644
index 0000000000..381dd858c1
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/basic-unknown-escape.toml
@@ -0,0 +1 @@
+a = "\@"
diff --git a/src/lake/tests/toml/tests/invalid/string/literal-multiline-quotes-1.toml b/src/lake/tests/toml/tests/invalid/string/literal-multiline-quotes-1.toml
new file mode 100644
index 0000000000..9cfb763560
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/literal-multiline-quotes-1.toml
@@ -0,0 +1,2 @@
+a = '''6 apostrophes: ''''''
+
diff --git a/src/lake/tests/toml/tests/invalid/string/literal-multiline-quotes-2.toml b/src/lake/tests/toml/tests/invalid/string/literal-multiline-quotes-2.toml
new file mode 100644
index 0000000000..9924236e96
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/literal-multiline-quotes-2.toml
@@ -0,0 +1 @@
+a = '''15 apostrophes: ''''''''''''''''''
diff --git a/src/lake/tests/toml/tests/invalid/string/missing-quotes.toml b/src/lake/tests/toml/tests/invalid/string/missing-quotes.toml
new file mode 100644
index 0000000000..22927931ae
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/missing-quotes.toml
@@ -0,0 +1 @@
+name = value
diff --git a/src/lake/tests/toml/tests/invalid/string/multiline-bad-escape-1.toml b/src/lake/tests/toml/tests/invalid/string/multiline-bad-escape-1.toml
new file mode 100644
index 0000000000..5de9e15bf5
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/multiline-bad-escape-1.toml
@@ -0,0 +1,2 @@
+k = """t\a"""
+
diff --git a/src/lake/tests/toml/tests/invalid/string/multiline-bad-escape-2.toml b/src/lake/tests/toml/tests/invalid/string/multiline-bad-escape-2.toml
new file mode 100644
index 0000000000..3d1ac103b7
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/multiline-bad-escape-2.toml
@@ -0,0 +1,2 @@
+# \<Space> is not a valid escape.
+k = """t\ t"""
diff --git a/src/lake/tests/toml/tests/invalid/string/multiline-bad-escape-3.toml b/src/lake/tests/toml/tests/invalid/string/multiline-bad-escape-3.toml
new file mode 100644
index 0000000000..95621eb5ec
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/multiline-bad-escape-3.toml
@@ -0,0 +1,3 @@
+# \<Space> is not a valid escape.
+k = """t\ """
+
diff --git a/src/lake/tests/toml/tests/invalid/string/multiline-escape-space.toml b/src/lake/tests/toml/tests/invalid/string/multiline-escape-space.toml
new file mode 100644
index 0000000000..13570d3b6a
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/multiline-escape-space.toml
@@ -0,0 +1,3 @@
+a = """
+  foo \ \n
+  bar"""
diff --git a/src/lake/tests/toml/tests/invalid/string/multiline-no-close-2.toml b/src/lake/tests/toml/tests/invalid/string/multiline-no-close-2.toml
new file mode 100644
index 0000000000..f46940206c
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/multiline-no-close-2.toml
@@ -0,0 +1 @@
+x="""
diff --git a/src/lake/tests/toml/tests/invalid/string/multiline-no-close.toml b/src/lake/tests/toml/tests/invalid/string/multiline-no-close.toml
new file mode 100644
index 0000000000..4ca959715a
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/multiline-no-close.toml
@@ -0,0 +1,2 @@
+invalid = """
+    this will fail
diff --git a/src/lake/tests/toml/tests/invalid/string/multiline-quotes-1.toml b/src/lake/tests/toml/tests/invalid/string/multiline-quotes-1.toml
new file mode 100644
index 0000000000..9f7a42b777
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/multiline-quotes-1.toml
@@ -0,0 +1 @@
+a = """6 quotes: """"""
diff --git a/src/lake/tests/toml/tests/invalid/string/no-close.toml b/src/lake/tests/toml/tests/invalid/string/no-close.toml
new file mode 100644
index 0000000000..0c292fcab7
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/no-close.toml
@@ -0,0 +1 @@
+no-ending-quote = "One time, at band camp
diff --git a/src/lake/tests/toml/tests/invalid/string/text-after-string.toml b/src/lake/tests/toml/tests/invalid/string/text-after-string.toml
new file mode 100644
index 0000000000..c92a6f11d8
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/text-after-string.toml
@@ -0,0 +1 @@
+string = "Is there life after strings?" No.
diff --git a/src/lake/tests/toml/tests/invalid/string/wrong-close.toml b/src/lake/tests/toml/tests/invalid/string/wrong-close.toml
new file mode 100644
index 0000000000..0f5c8011ea
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/string/wrong-close.toml
@@ -0,0 +1 @@
+bad-ending-quote = "double and single'
diff --git a/src/lake/tests/toml/tests/invalid/table/append-to-array-with-dotted-keys.toml b/src/lake/tests/toml/tests/invalid/table/append-to-array-with-dotted-keys.toml
new file mode 100644
index 0000000000..1cae3a9b18
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/append-to-array-with-dotted-keys.toml
@@ -0,0 +1,4 @@
+[[a.b]]
+
+[a]
+b.y = 2
diff --git a/src/lake/tests/toml/tests/invalid/table/append-with-dotted-keys-1.toml b/src/lake/tests/toml/tests/invalid/table/append-with-dotted-keys-1.toml
new file mode 100644
index 0000000000..0b5b4bbfdb
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/append-with-dotted-keys-1.toml
@@ -0,0 +1,17 @@
+# First a.b.c defines a table: a.b.c = {z=9}
+#
+# Then we define a.b.c.t = "str" to add a str to the above table, making it:
+#
+#   a.b.c = {z=9, t="..."}
+#
+# While this makes sense, logically, it was decided this is not valid TOML as
+# it's too confusing/convoluted.
+# 
+# See: https://github.com/toml-lang/toml/issues/846
+#      https://github.com/toml-lang/toml/pull/859
+
+[a.b.c]
+  z = 9
+
+[a]
+  b.c.t = "Using dotted keys to add to [a.b.c] after explicitly defining it above is not allowed"
diff --git a/src/lake/tests/toml/tests/invalid/table/append-with-dotted-keys-2.toml b/src/lake/tests/toml/tests/invalid/table/append-with-dotted-keys-2.toml
new file mode 100644
index 0000000000..3f0a011f93
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/append-with-dotted-keys-2.toml
@@ -0,0 +1,8 @@
+# This is the same issue as in injection-1.toml, except that nests one level
+# deeper. See that file for a more complete description.
+
+[a.b.c.d]
+  z = 9
+
+[a]
+  b.c.d.k.t = "Using dotted keys to add to [a.b.c.d] after explicitly defining it above is not allowed"
diff --git a/src/lake/tests/toml/tests/invalid/table/array-empty.toml b/src/lake/tests/toml/tests/invalid/table/array-empty.toml
new file mode 100644
index 0000000000..a470ca332f
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/array-empty.toml
@@ -0,0 +1,2 @@
+[[]]
+name = "Born to Run"
diff --git a/src/lake/tests/toml/tests/invalid/table/array-implicit.toml b/src/lake/tests/toml/tests/invalid/table/array-implicit.toml
new file mode 100644
index 0000000000..05f2507ecb
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/array-implicit.toml
@@ -0,0 +1,14 @@
+# This test is a bit tricky. It should fail because the first use of
+# `[[albums.songs]]` without first declaring `albums` implies that `albums`
+# must be a table. The alternative would be quite weird. Namely, it wouldn't
+# comply with the TOML spec: "Each double-bracketed sub-table will belong to 
+# the most *recently* defined table element *above* it."
+#
+# This is in contrast to the *valid* test, table-array-implicit where
+# `[[albums.songs]]` works by itself, so long as `[[albums]]` isn't declared
+# later. (Although, `[albums]` could be.)
+[[albums.songs]]
+name = "Glory Days"
+
+[[albums]]
+name = "Born in the USA"
diff --git a/src/lake/tests/toml/tests/invalid/table/array-missing-bracket.toml b/src/lake/tests/toml/tests/invalid/table/array-missing-bracket.toml
new file mode 100644
index 0000000000..39c73b05c4
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/array-missing-bracket.toml
@@ -0,0 +1,2 @@
+[[albums]
+name = "Born to Run"
diff --git a/src/lake/tests/toml/tests/invalid/table/duplicate-key-dotted-array.toml b/src/lake/tests/toml/tests/invalid/table/duplicate-key-dotted-array.toml
new file mode 100644
index 0000000000..b75c2bc6f9
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/duplicate-key-dotted-array.toml
@@ -0,0 +1,4 @@
+[fruit]
+apple.color = "red"
+
+[[fruit.apple]]
diff --git a/src/lake/tests/toml/tests/invalid/table/duplicate-key-dotted-table.toml b/src/lake/tests/toml/tests/invalid/table/duplicate-key-dotted-table.toml
new file mode 100644
index 0000000000..ade637bff8
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/duplicate-key-dotted-table.toml
@@ -0,0 +1,4 @@
+[fruit]
+apple.color = "red"
+
+[fruit.apple] # INVALID
diff --git a/src/lake/tests/toml/tests/invalid/table/duplicate-key-dotted-table2.toml b/src/lake/tests/toml/tests/invalid/table/duplicate-key-dotted-table2.toml
new file mode 100644
index 0000000000..609b660f0c
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/duplicate-key-dotted-table2.toml
@@ -0,0 +1,4 @@
+[fruit]
+apple.taste.sweet = true
+
+[fruit.apple.taste] # INVALID
diff --git a/src/lake/tests/toml/tests/invalid/table/duplicate-key-table.toml b/src/lake/tests/toml/tests/invalid/table/duplicate-key-table.toml
new file mode 100644
index 0000000000..cedf05fc53
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/duplicate-key-table.toml
@@ -0,0 +1,5 @@
+[fruit]
+type = "apple"
+
+[fruit.type]
+apple = "yes"
diff --git a/src/lake/tests/toml/tests/invalid/table/duplicate-table-array.toml b/src/lake/tests/toml/tests/invalid/table/duplicate-table-array.toml
new file mode 100644
index 0000000000..a1d87059eb
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/duplicate-table-array.toml
@@ -0,0 +1,2 @@
+[tbl]
+[[tbl]]
diff --git a/src/lake/tests/toml/tests/invalid/table/duplicate-table-array2.toml b/src/lake/tests/toml/tests/invalid/table/duplicate-table-array2.toml
new file mode 100644
index 0000000000..72eacbd10b
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/duplicate-table-array2.toml
@@ -0,0 +1,2 @@
+[[tbl]]
+[tbl]
diff --git a/src/lake/tests/toml/tests/invalid/table/duplicate.toml b/src/lake/tests/toml/tests/invalid/table/duplicate.toml
new file mode 100644
index 0000000000..73ef1cc7c7
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/duplicate.toml
@@ -0,0 +1,5 @@
+[a]
+b = 1
+
+[a]
+c = 2
diff --git a/src/lake/tests/toml/tests/invalid/table/empty-implicit-table.toml b/src/lake/tests/toml/tests/invalid/table/empty-implicit-table.toml
new file mode 100644
index 0000000000..0cc36d0d28
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/empty-implicit-table.toml
@@ -0,0 +1 @@
+[naughty..naughty]
diff --git a/src/lake/tests/toml/tests/invalid/table/empty.toml b/src/lake/tests/toml/tests/invalid/table/empty.toml
new file mode 100644
index 0000000000..fe51488c70
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/empty.toml
@@ -0,0 +1 @@
+[]
diff --git a/src/lake/tests/toml/tests/invalid/table/equals-sign.toml b/src/lake/tests/toml/tests/invalid/table/equals-sign.toml
new file mode 100644
index 0000000000..eb5e742f76
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/equals-sign.toml
@@ -0,0 +1 @@
+[name=bad]
diff --git a/src/lake/tests/toml/tests/invalid/table/llbrace.toml b/src/lake/tests/toml/tests/invalid/table/llbrace.toml
new file mode 100644
index 0000000000..047978e5bc
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/llbrace.toml
@@ -0,0 +1 @@
+[ [table]]
diff --git a/src/lake/tests/toml/tests/invalid/table/nested-brackets-close.toml b/src/lake/tests/toml/tests/invalid/table/nested-brackets-close.toml
new file mode 100644
index 0000000000..c8b5a67858
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/nested-brackets-close.toml
@@ -0,0 +1,2 @@
+[a]b]
+zyx = 42
diff --git a/src/lake/tests/toml/tests/invalid/table/nested-brackets-open.toml b/src/lake/tests/toml/tests/invalid/table/nested-brackets-open.toml
new file mode 100644
index 0000000000..246d7e91fe
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/nested-brackets-open.toml
@@ -0,0 +1,2 @@
+[a[b]
+zyx = 42
diff --git a/src/lake/tests/toml/tests/invalid/table/quoted-no-close.toml b/src/lake/tests/toml/tests/invalid/table/quoted-no-close.toml
new file mode 100644
index 0000000000..6e7c1a1ed3
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/quoted-no-close.toml
@@ -0,0 +1,2 @@
+["where will it end]
+name = value
diff --git a/src/lake/tests/toml/tests/invalid/table/redefine.toml b/src/lake/tests/toml/tests/invalid/table/redefine.toml
new file mode 100644
index 0000000000..fc23bf7d61
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/redefine.toml
@@ -0,0 +1,6 @@
+# Define b as int, and try to use it as a table: error
+[a]
+b = 1
+
+[a.b]
+c = 2
diff --git a/src/lake/tests/toml/tests/invalid/table/rrbrace.toml b/src/lake/tests/toml/tests/invalid/table/rrbrace.toml
new file mode 100644
index 0000000000..3a4dee4712
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/rrbrace.toml
@@ -0,0 +1 @@
+[[table] ]
diff --git a/src/lake/tests/toml/tests/invalid/table/text-after-table.toml b/src/lake/tests/toml/tests/invalid/table/text-after-table.toml
new file mode 100644
index 0000000000..87da9db26d
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/text-after-table.toml
@@ -0,0 +1 @@
+[error] this shouldn't be here
diff --git a/src/lake/tests/toml/tests/invalid/table/whitespace.toml b/src/lake/tests/toml/tests/invalid/table/whitespace.toml
new file mode 100644
index 0000000000..0a6a6a6972
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/whitespace.toml
@@ -0,0 +1 @@
+[invalid key]
diff --git a/src/lake/tests/toml/tests/invalid/table/with-pound.toml b/src/lake/tests/toml/tests/invalid/table/with-pound.toml
new file mode 100644
index 0000000000..e7b777ecfb
--- /dev/null
+++ b/src/lake/tests/toml/tests/invalid/table/with-pound.toml
@@ -0,0 +1,2 @@
+[key#group]
+answer = 42
diff --git a/src/lake/tests/toml/tests/valid/array/array.json b/src/lake/tests/toml/tests/valid/array/array.json
new file mode 100644
index 0000000000..4e9d45b86f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/array.json
@@ -0,0 +1,68 @@
+{
+  "comments": [
+    {
+      "type": "integer",
+      "value": "1"
+    },
+    {
+      "type": "integer",
+      "value": "2"
+    }
+  ],
+  "dates": [
+    {
+      "type": "datetime",
+      "value": "1987-07-05T17:45:00Z"
+    },
+    {
+      "type": "datetime",
+      "value": "1979-05-27T07:32:00Z"
+    },
+    {
+      "type": "datetime",
+      "value": "2006-06-01T11:00:00Z"
+    }
+  ],
+  "floats": [
+    {
+      "type": "float",
+      "value": "1.1"
+    },
+    {
+      "type": "float",
+      "value": "2.1"
+    },
+    {
+      "type": "float",
+      "value": "3.1"
+    }
+  ],
+  "ints": [
+    {
+      "type": "integer",
+      "value": "1"
+    },
+    {
+      "type": "integer",
+      "value": "2"
+    },
+    {
+      "type": "integer",
+      "value": "3"
+    }
+  ],
+  "strings": [
+    {
+      "type": "string",
+      "value": "a"
+    },
+    {
+      "type": "string",
+      "value": "b"
+    },
+    {
+      "type": "string",
+      "value": "c"
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/array.toml b/src/lake/tests/toml/tests/valid/array/array.toml
new file mode 100644
index 0000000000..ab884652bc
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/array.toml
@@ -0,0 +1,12 @@
+ints = [1, 2, 3, ]
+floats = [1.1, 2.1, 3.1]
+strings = ["a", "b", "c"]
+dates = [
+  1987-07-05T17:45:00Z,
+  1979-05-27T07:32:00Z,
+  2006-06-01T11:00:00Z,
+]
+comments = [
+         1,
+         2, #this is ok
+]
diff --git a/src/lake/tests/toml/tests/valid/array/bool.json b/src/lake/tests/toml/tests/valid/array/bool.json
new file mode 100644
index 0000000000..7cede3fc5d
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/bool.json
@@ -0,0 +1,12 @@
+{
+  "a": [
+    {
+      "type": "bool",
+      "value": "true"
+    },
+    {
+      "type": "bool",
+      "value": "false"
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/bool.toml b/src/lake/tests/toml/tests/valid/array/bool.toml
new file mode 100644
index 0000000000..d2010c5870
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/bool.toml
@@ -0,0 +1 @@
+a = [true, false]
diff --git a/src/lake/tests/toml/tests/valid/array/empty.json b/src/lake/tests/toml/tests/valid/array/empty.json
new file mode 100644
index 0000000000..7b1ca0cfa2
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/empty.json
@@ -0,0 +1,11 @@
+{
+  "thevoid": [
+    [
+      [
+        [
+          []
+        ]
+      ]
+    ]
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/empty.toml b/src/lake/tests/toml/tests/valid/array/empty.toml
new file mode 100644
index 0000000000..fa58dc63d4
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/empty.toml
@@ -0,0 +1 @@
+thevoid = [[[[[]]]]]
diff --git a/src/lake/tests/toml/tests/valid/array/hetergeneous.json b/src/lake/tests/toml/tests/valid/array/hetergeneous.json
new file mode 100644
index 0000000000..751b6244b8
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/hetergeneous.json
@@ -0,0 +1,34 @@
+{
+  "mixed": [
+    [
+      {
+        "type": "integer",
+        "value": "1"
+      },
+      {
+        "type": "integer",
+        "value": "2"
+      }
+    ],
+    [
+      {
+        "type": "string",
+        "value": "a"
+      },
+      {
+        "type": "string",
+        "value": "b"
+      }
+    ],
+    [
+      {
+        "type": "float",
+        "value": "1.1"
+      },
+      {
+        "type": "float",
+        "value": "2.1"
+      }
+    ]
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/hetergeneous.toml b/src/lake/tests/toml/tests/valid/array/hetergeneous.toml
new file mode 100644
index 0000000000..a246fcf1de
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/hetergeneous.toml
@@ -0,0 +1 @@
+mixed = [[1, 2], ["a", "b"], [1.1, 2.1]]
diff --git a/src/lake/tests/toml/tests/valid/array/mixed-int-array.json b/src/lake/tests/toml/tests/valid/array/mixed-int-array.json
new file mode 100644
index 0000000000..2f3ac5ee67
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/mixed-int-array.json
@@ -0,0 +1,14 @@
+{
+  "arrays-and-ints": [
+    {
+      "type": "integer",
+      "value": "1"
+    },
+    [
+      {
+        "type": "string",
+        "value": "Arrays are not integers."
+      }
+    ]
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/mixed-int-array.toml b/src/lake/tests/toml/tests/valid/array/mixed-int-array.toml
new file mode 100644
index 0000000000..051ec73136
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/mixed-int-array.toml
@@ -0,0 +1 @@
+arrays-and-ints =  [1, ["Arrays are not integers."]]
diff --git a/src/lake/tests/toml/tests/valid/array/mixed-int-float.json b/src/lake/tests/toml/tests/valid/array/mixed-int-float.json
new file mode 100644
index 0000000000..e73059b807
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/mixed-int-float.json
@@ -0,0 +1,12 @@
+{
+  "ints-and-floats": [
+    {
+      "type": "integer",
+      "value": "1"
+    },
+    {
+      "type": "float",
+      "value": "1.1"
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/mixed-int-float.toml b/src/lake/tests/toml/tests/valid/array/mixed-int-float.toml
new file mode 100644
index 0000000000..a5aa9b7a03
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/mixed-int-float.toml
@@ -0,0 +1 @@
+ints-and-floats = [1, 1.1]
diff --git a/src/lake/tests/toml/tests/valid/array/mixed-int-string.json b/src/lake/tests/toml/tests/valid/array/mixed-int-string.json
new file mode 100644
index 0000000000..c6acc76337
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/mixed-int-string.json
@@ -0,0 +1,12 @@
+{
+  "strings-and-ints": [
+    {
+      "type": "string",
+      "value": "hi"
+    },
+    {
+      "type": "integer",
+      "value": "42"
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/mixed-int-string.toml b/src/lake/tests/toml/tests/valid/array/mixed-int-string.toml
new file mode 100644
index 0000000000..f348308053
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/mixed-int-string.toml
@@ -0,0 +1 @@
+strings-and-ints = ["hi", 42]
diff --git a/src/lake/tests/toml/tests/valid/array/mixed-string-table.json b/src/lake/tests/toml/tests/valid/array/mixed-string-table.json
new file mode 100644
index 0000000000..0de6a6e603
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/mixed-string-table.json
@@ -0,0 +1,38 @@
+{
+  "contributors": [
+    {
+      "type": "string",
+      "value": "Foo Bar \u003cfoo@example.com\u003e"
+    },
+    {
+      "email": {
+        "type": "string",
+        "value": "bazqux@example.com"
+      },
+      "name": {
+        "type": "string",
+        "value": "Baz Qux"
+      },
+      "url": {
+        "type": "string",
+        "value": "https://example.com/bazqux"
+      }
+    }
+  ],
+  "mixed": [
+    {
+      "k": {
+        "type": "string",
+        "value": "a"
+      }
+    },
+    {
+      "type": "string",
+      "value": "b"
+    },
+    {
+      "type": "integer",
+      "value": "1"
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/mixed-string-table.toml b/src/lake/tests/toml/tests/valid/array/mixed-string-table.toml
new file mode 100644
index 0000000000..f0ede9ccb2
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/mixed-string-table.toml
@@ -0,0 +1,11 @@
+contributors = [
+  "Foo Bar <foo@example.com>",
+  { name = "Baz Qux", email = "bazqux@example.com", url = "https://example.com/bazqux" }
+]
+
+# Start with a table as the first element. This tests a case that some libraries
+# might have where they will check if the first entry is a table/map/hash/assoc
+# array and then encode it as a table array. This was a reasonable thing to do
+# before TOML 1.0 since arrays could only contain one type, but now it's no
+# longer.
+mixed = [{k="a"}, "b", 1]
diff --git a/src/lake/tests/toml/tests/valid/array/nested-double.json b/src/lake/tests/toml/tests/valid/array/nested-double.json
new file mode 100644
index 0000000000..c89a8c9b72
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/nested-double.json
@@ -0,0 +1,28 @@
+{
+  "nest": [
+    [
+      [
+        {
+          "type": "string",
+          "value": "a"
+        }
+      ],
+      [
+        {
+          "type": "integer",
+          "value": "1"
+        },
+        {
+          "type": "integer",
+          "value": "2"
+        },
+        [
+          {
+            "type": "integer",
+            "value": "3"
+          }
+        ]
+      ]
+    ]
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/nested-double.toml b/src/lake/tests/toml/tests/valid/array/nested-double.toml
new file mode 100644
index 0000000000..c1de7477fe
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/nested-double.toml
@@ -0,0 +1,6 @@
+nest = [
+	[
+		["a"],
+		[1, 2, [3]]
+	]
+]
diff --git a/src/lake/tests/toml/tests/valid/array/nested-inline-table.json b/src/lake/tests/toml/tests/valid/array/nested-inline-table.json
new file mode 100644
index 0000000000..2ae5fa70c4
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/nested-inline-table.json
@@ -0,0 +1,7 @@
+{
+  "a": [
+    {
+      "b": {}
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/nested-inline-table.toml b/src/lake/tests/toml/tests/valid/array/nested-inline-table.toml
new file mode 100644
index 0000000000..e1e24f6c38
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/nested-inline-table.toml
@@ -0,0 +1 @@
+a = [ { b = {} } ]
diff --git a/src/lake/tests/toml/tests/valid/array/nested.json b/src/lake/tests/toml/tests/valid/array/nested.json
new file mode 100644
index 0000000000..72c75897f6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/nested.json
@@ -0,0 +1,16 @@
+{
+  "nest": [
+    [
+      {
+        "type": "string",
+        "value": "a"
+      }
+    ],
+    [
+      {
+        "type": "string",
+        "value": "b"
+      }
+    ]
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/nested.toml b/src/lake/tests/toml/tests/valid/array/nested.toml
new file mode 100644
index 0000000000..ce3302249b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/nested.toml
@@ -0,0 +1 @@
+nest = [["a"], ["b"]]
diff --git a/src/lake/tests/toml/tests/valid/array/nospaces.json b/src/lake/tests/toml/tests/valid/array/nospaces.json
new file mode 100644
index 0000000000..6c89fced19
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/nospaces.json
@@ -0,0 +1,16 @@
+{
+  "ints": [
+    {
+      "type": "integer",
+      "value": "1"
+    },
+    {
+      "type": "integer",
+      "value": "2"
+    },
+    {
+      "type": "integer",
+      "value": "3"
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/nospaces.toml b/src/lake/tests/toml/tests/valid/array/nospaces.toml
new file mode 100644
index 0000000000..66189367fe
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/nospaces.toml
@@ -0,0 +1 @@
+ints = [1,2,3]
diff --git a/src/lake/tests/toml/tests/valid/array/string-quote-comma-2.json b/src/lake/tests/toml/tests/valid/array/string-quote-comma-2.json
new file mode 100644
index 0000000000..7cd54063a6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/string-quote-comma-2.json
@@ -0,0 +1,8 @@
+{
+  "title": [
+    {
+      "type": "string",
+      "value": " \", "
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/string-quote-comma-2.toml b/src/lake/tests/toml/tests/valid/array/string-quote-comma-2.toml
new file mode 100644
index 0000000000..4758ddcade
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/string-quote-comma-2.toml
@@ -0,0 +1 @@
+title = [ " \", ",]
diff --git a/src/lake/tests/toml/tests/valid/array/string-quote-comma.json b/src/lake/tests/toml/tests/valid/array/string-quote-comma.json
new file mode 100644
index 0000000000..b78db423e5
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/string-quote-comma.json
@@ -0,0 +1,12 @@
+{
+  "title": [
+    {
+      "type": "string",
+      "value": "Client: \"XXXX\", Job: XXXX"
+    },
+    {
+      "type": "string",
+      "value": "Code: XXXX"
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/string-quote-comma.toml b/src/lake/tests/toml/tests/valid/array/string-quote-comma.toml
new file mode 100644
index 0000000000..6b458e1e8b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/string-quote-comma.toml
@@ -0,0 +1,4 @@
+title = [
+"Client: \"XXXX\", Job: XXXX",
+"Code: XXXX"
+]
diff --git a/src/lake/tests/toml/tests/valid/array/string-with-comma-2.json b/src/lake/tests/toml/tests/valid/array/string-with-comma-2.json
new file mode 100644
index 0000000000..8b591d52c9
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/string-with-comma-2.json
@@ -0,0 +1,12 @@
+{
+  "title": [
+    {
+      "type": "string",
+      "value": "Client: XXXX,\nJob: XXXX"
+    },
+    {
+      "type": "string",
+      "value": "Code: XXXX"
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/string-with-comma-2.toml b/src/lake/tests/toml/tests/valid/array/string-with-comma-2.toml
new file mode 100644
index 0000000000..2997c91cfa
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/string-with-comma-2.toml
@@ -0,0 +1,5 @@
+title = [
+"""Client: XXXX,
+Job: XXXX""",
+"Code: XXXX"
+]
diff --git a/src/lake/tests/toml/tests/valid/array/string-with-comma.json b/src/lake/tests/toml/tests/valid/array/string-with-comma.json
new file mode 100644
index 0000000000..42b77ef725
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/string-with-comma.json
@@ -0,0 +1,12 @@
+{
+  "title": [
+    {
+      "type": "string",
+      "value": "Client: XXXX, Job: XXXX"
+    },
+    {
+      "type": "string",
+      "value": "Code: XXXX"
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/string-with-comma.toml b/src/lake/tests/toml/tests/valid/array/string-with-comma.toml
new file mode 100644
index 0000000000..655c40e27e
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/string-with-comma.toml
@@ -0,0 +1,4 @@
+title = [
+"Client: XXXX, Job: XXXX",
+"Code: XXXX"
+]
diff --git a/src/lake/tests/toml/tests/valid/array/strings.json b/src/lake/tests/toml/tests/valid/array/strings.json
new file mode 100644
index 0000000000..27617b4d0e
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/strings.json
@@ -0,0 +1,20 @@
+{
+  "string_array": [
+    {
+      "type": "string",
+      "value": "all"
+    },
+    {
+      "type": "string",
+      "value": "strings"
+    },
+    {
+      "type": "string",
+      "value": "are the same"
+    },
+    {
+      "type": "string",
+      "value": "type"
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/strings.toml b/src/lake/tests/toml/tests/valid/array/strings.toml
new file mode 100644
index 0000000000..51894ce100
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/strings.toml
@@ -0,0 +1 @@
+string_array = [ "all", 'strings', """are the same""", '''type''']
diff --git a/src/lake/tests/toml/tests/valid/array/table-array-string-backslash.json b/src/lake/tests/toml/tests/valid/array/table-array-string-backslash.json
new file mode 100644
index 0000000000..2c0feb13d7
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/table-array-string-backslash.json
@@ -0,0 +1,10 @@
+{
+  "foo": [
+    {
+      "bar": {
+        "type": "string",
+        "value": "\"{{baz}}\""
+      }
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/array/table-array-string-backslash.toml b/src/lake/tests/toml/tests/valid/array/table-array-string-backslash.toml
new file mode 100644
index 0000000000..f0de81e0d6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/array/table-array-string-backslash.toml
@@ -0,0 +1 @@
+foo = [ { bar="\"{{baz}}\""} ]
diff --git a/src/lake/tests/toml/tests/valid/bool/bool.json b/src/lake/tests/toml/tests/valid/bool/bool.json
new file mode 100644
index 0000000000..be47d6d046
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/bool/bool.json
@@ -0,0 +1,10 @@
+{
+  "f": {
+    "type": "bool",
+    "value": "false"
+  },
+  "t": {
+    "type": "bool",
+    "value": "true"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/bool/bool.toml b/src/lake/tests/toml/tests/valid/bool/bool.toml
new file mode 100644
index 0000000000..a8a829b34d
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/bool/bool.toml
@@ -0,0 +1,2 @@
+t = true
+f = false
diff --git a/src/lake/tests/toml/tests/valid/comment/at-eof.json b/src/lake/tests/toml/tests/valid/comment/at-eof.json
new file mode 100644
index 0000000000..af3154ab4c
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/comment/at-eof.json
@@ -0,0 +1,6 @@
+{
+  "key": {
+    "type": "string",
+    "value": "value"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/comment/at-eof.toml b/src/lake/tests/toml/tests/valid/comment/at-eof.toml
new file mode 100644
index 0000000000..090b474834
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/comment/at-eof.toml
@@ -0,0 +1,2 @@
+# This is a full-line comment
+key = "value" # This is a comment at the end of a line
diff --git a/src/lake/tests/toml/tests/valid/comment/at-eof2.json b/src/lake/tests/toml/tests/valid/comment/at-eof2.json
new file mode 100644
index 0000000000..af3154ab4c
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/comment/at-eof2.json
@@ -0,0 +1,6 @@
+{
+  "key": {
+    "type": "string",
+    "value": "value"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/comment/at-eof2.toml b/src/lake/tests/toml/tests/valid/comment/at-eof2.toml
new file mode 100644
index 0000000000..090b474834
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/comment/at-eof2.toml
@@ -0,0 +1,2 @@
+# This is a full-line comment
+key = "value" # This is a comment at the end of a line
diff --git a/src/lake/tests/toml/tests/valid/comment/everywhere.json b/src/lake/tests/toml/tests/valid/comment/everywhere.json
new file mode 100644
index 0000000000..6e714d1cba
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/comment/everywhere.json
@@ -0,0 +1,26 @@
+{
+  "group": {
+    "answer": {
+      "type": "integer",
+      "value": "42"
+    },
+    "dt": {
+      "type": "datetime",
+      "value": "1979-05-27T07:32:12-07:00"
+    },
+    "d": {
+      "type": "date-local",
+      "value": "1979-05-27"
+    },
+    "more": [
+      {
+        "type": "integer",
+        "value": "42"
+      },
+      {
+        "type": "integer",
+        "value": "42"
+      }
+    ]
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/comment/everywhere.toml b/src/lake/tests/toml/tests/valid/comment/everywhere.toml
new file mode 100644
index 0000000000..a5da1d77c1
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/comment/everywhere.toml
@@ -0,0 +1,28 @@
+# Top comment.
+  # Top comment.
+# Top comment.
+
+# [no-extraneous-groups-please]
+
+[group] # Comment
+answer = 42 # Comment
+# no-extraneous-keys-please = 999
+# Inbetween comment.
+more = [ # Comment
+  # What about multiple # comments?
+  # Can you handle it?
+  #
+          # Evil.
+# Evil.
+  42, 42, # Comments within arrays are fun.
+  # What about multiple # comments?
+  # Can you handle it?
+  #
+          # Evil.
+# Evil.
+# ] Did I fool you?
+] # Hopefully not.
+
+# Make sure the space between the datetime and "#" isn't lexed.
+dt = 1979-05-27T07:32:12-07:00  # c
+d = 1979-05-27 # Comment
diff --git a/src/lake/tests/toml/tests/valid/comment/noeol.json b/src/lake/tests/toml/tests/valid/comment/noeol.json
new file mode 100644
index 0000000000..0967ef424b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/comment/noeol.json
@@ -0,0 +1 @@
+{}
diff --git a/src/lake/tests/toml/tests/valid/comment/noeol.toml b/src/lake/tests/toml/tests/valid/comment/noeol.toml
new file mode 100644
index 0000000000..7662df8a47
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/comment/noeol.toml
@@ -0,0 +1 @@
+# single comment without any eol characters
\ No newline at end of file
diff --git a/src/lake/tests/toml/tests/valid/comment/nonascii.json b/src/lake/tests/toml/tests/valid/comment/nonascii.json
new file mode 100644
index 0000000000..0967ef424b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/comment/nonascii.json
@@ -0,0 +1 @@
+{}
diff --git a/src/lake/tests/toml/tests/valid/comment/nonascii.toml b/src/lake/tests/toml/tests/valid/comment/nonascii.toml
new file mode 100644
index 0000000000..2fdde6b526
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/comment/nonascii.toml
@@ -0,0 +1 @@
+# ~ € ÿ ퟿  ￿ 𐀀 􏿿
diff --git a/src/lake/tests/toml/tests/valid/comment/tricky.json b/src/lake/tests/toml/tests/valid/comment/tricky.json
new file mode 100644
index 0000000000..09948647ca
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/comment/tricky.json
@@ -0,0 +1,98 @@
+{
+  "hash#tag": {
+    "#!": {
+      "type": "string",
+      "value": "hash bang"
+    },
+    "arr3": [
+      {
+        "type": "string",
+        "value": "#"
+      },
+      {
+        "type": "string",
+        "value": "#"
+      },
+      {
+        "type": "string",
+        "value": "###"
+      }
+    ],
+    "arr4": [
+      {
+        "type": "integer",
+        "value": "1"
+      },
+      {
+        "type": "integer",
+        "value": "2"
+      },
+      {
+        "type": "integer",
+        "value": "3"
+      },
+      {
+        "type": "integer",
+        "value": "4"
+      }
+    ],
+    "arr5": [
+      [
+        [
+          [
+            [
+              {
+                "type": "string",
+                "value": "#"
+              }
+            ]
+          ]
+        ]
+      ]
+    ],
+    "tbl1": {
+      "#": {
+        "type": "string",
+        "value": "}#"
+      }
+    }
+  },
+  "section": {
+    "8": {
+      "type": "string",
+      "value": "eight"
+    },
+    "eleven": {
+      "type": "float",
+      "value": "11.1"
+    },
+    "five": {
+      "type": "float",
+      "value": "5.5"
+    },
+    "four": {
+      "type": "string",
+      "value": "# no comment\n# nor this\n#also not comment"
+    },
+    "one": {
+      "type": "string",
+      "value": "11"
+    },
+    "six": {
+      "type": "integer",
+      "value": "6"
+    },
+    "ten": {
+      "type": "float",
+      "value": "1000.0"
+    },
+    "three": {
+      "type": "string",
+      "value": "#"
+    },
+    "two": {
+      "type": "string",
+      "value": "22#"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/comment/tricky.toml b/src/lake/tests/toml/tests/valid/comment/tricky.toml
new file mode 100644
index 0000000000..c95f94d0d9
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/comment/tricky.toml
@@ -0,0 +1,31 @@
+[section]#attached comment
+#[notsection]
+one = "11"#cmt
+two = "22#"
+three = '#'
+
+four = """# no comment
+# nor this
+#also not comment"""#is_comment
+
+five = 5.5#66
+six = 6#7
+8 = "eight"
+#nine = 99
+ten = 10e2#1
+eleven = 1.11e1#23
+
+["hash#tag"]
+"#!" = "hash bang"
+arr3 = [ "#", '#', """###""" ]
+arr4 = [ 1,# 9, 9,
+2#,9
+,#9
+3#]
+,4]
+arr5 = [[[[#["#"],
+["#"]]]]#]
+]
+tbl1 = { "#" = '}#'}#}}
+
+
diff --git a/src/lake/tests/toml/tests/valid/datetime/datetime.json b/src/lake/tests/toml/tests/valid/datetime/datetime.json
new file mode 100644
index 0000000000..514633596f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/datetime/datetime.json
@@ -0,0 +1,10 @@
+{
+  "lower": {
+    "type": "datetime",
+    "value": "1987-07-05T17:45:00Z"
+  },
+  "space": {
+    "type": "datetime",
+    "value": "1987-07-05T17:45:00Z"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/datetime/datetime.toml b/src/lake/tests/toml/tests/valid/datetime/datetime.toml
new file mode 100644
index 0000000000..653d521fd9
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/datetime/datetime.toml
@@ -0,0 +1,2 @@
+space = 1987-07-05 17:45:00Z
+lower = 1987-07-05t17:45:00z
diff --git a/src/lake/tests/toml/tests/valid/datetime/local-date.json b/src/lake/tests/toml/tests/valid/datetime/local-date.json
new file mode 100644
index 0000000000..8fea2fe06a
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/datetime/local-date.json
@@ -0,0 +1,6 @@
+{
+  "bestdayever": {
+    "type": "date-local",
+    "value": "1987-07-05"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/datetime/local-date.toml b/src/lake/tests/toml/tests/valid/datetime/local-date.toml
new file mode 100644
index 0000000000..1be4a5f8eb
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/datetime/local-date.toml
@@ -0,0 +1 @@
+bestdayever = 1987-07-05
diff --git a/src/lake/tests/toml/tests/valid/datetime/local-time.json b/src/lake/tests/toml/tests/valid/datetime/local-time.json
new file mode 100644
index 0000000000..5e527e97b6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/datetime/local-time.json
@@ -0,0 +1,10 @@
+{
+  "besttimeever": {
+    "type": "time-local",
+    "value": "17:45:00"
+  },
+  "milliseconds": {
+    "type": "time-local",
+    "value": "10:32:00.555"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/datetime/local-time.toml b/src/lake/tests/toml/tests/valid/datetime/local-time.toml
new file mode 100644
index 0000000000..6b07f6ffee
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/datetime/local-time.toml
@@ -0,0 +1,2 @@
+besttimeever = 17:45:00
+milliseconds = 10:32:00.555
diff --git a/src/lake/tests/toml/tests/valid/datetime/local.json b/src/lake/tests/toml/tests/valid/datetime/local.json
new file mode 100644
index 0000000000..12f8df5d56
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/datetime/local.json
@@ -0,0 +1,14 @@
+{
+  "local": {
+    "type": "datetime-local",
+    "value": "1987-07-05T17:45:00"
+  },
+  "milli": {
+    "type": "datetime-local",
+    "value": "1977-12-21T10:32:00.555"
+  },
+  "space": {
+    "type": "datetime-local",
+    "value": "1987-07-05T17:45:00"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/datetime/local.toml b/src/lake/tests/toml/tests/valid/datetime/local.toml
new file mode 100644
index 0000000000..ab425ecacf
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/datetime/local.toml
@@ -0,0 +1,3 @@
+local = 1987-07-05T17:45:00
+milli = 1977-12-21T10:32:00.555
+space = 1987-07-05 17:45:00
diff --git a/src/lake/tests/toml/tests/valid/datetime/milliseconds.json b/src/lake/tests/toml/tests/valid/datetime/milliseconds.json
new file mode 100644
index 0000000000..543ae73bee
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/datetime/milliseconds.json
@@ -0,0 +1,18 @@
+{
+  "utc1": {
+    "type": "datetime",
+    "value": "1987-07-05T17:45:56.123Z"
+  },
+  "utc2": {
+    "type": "datetime",
+    "value": "1987-07-05T17:45:56.600Z"
+  },
+  "wita1": {
+    "type": "datetime",
+    "value": "1987-07-05T17:45:56.123+08:00"
+  },
+  "wita2": {
+    "type": "datetime",
+    "value": "1987-07-05T17:45:56.600+08:00"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/datetime/milliseconds.toml b/src/lake/tests/toml/tests/valid/datetime/milliseconds.toml
new file mode 100644
index 0000000000..b608b577b2
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/datetime/milliseconds.toml
@@ -0,0 +1,4 @@
+utc1  = 1987-07-05T17:45:56.123Z
+utc2  = 1987-07-05T17:45:56.6Z
+wita1 = 1987-07-05T17:45:56.123+08:00
+wita2 = 1987-07-05T17:45:56.6+08:00
diff --git a/src/lake/tests/toml/tests/valid/datetime/timezone.json b/src/lake/tests/toml/tests/valid/datetime/timezone.json
new file mode 100644
index 0000000000..8dc83281b2
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/datetime/timezone.json
@@ -0,0 +1,18 @@
+{
+  "nzdt": {
+    "type": "datetime",
+    "value": "1987-07-05T17:45:56+13:00"
+  },
+  "nzst": {
+    "type": "datetime",
+    "value": "1987-07-05T17:45:56+12:00"
+  },
+  "pdt": {
+    "type": "datetime",
+    "value": "1987-07-05T17:45:56-05:00"
+  },
+  "utc": {
+    "type": "datetime",
+    "value": "1987-07-05T17:45:56Z"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/datetime/timezone.toml b/src/lake/tests/toml/tests/valid/datetime/timezone.toml
new file mode 100644
index 0000000000..20f3835b70
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/datetime/timezone.toml
@@ -0,0 +1,4 @@
+utc  = 1987-07-05T17:45:56Z
+pdt  = 1987-07-05T17:45:56-05:00
+nzst = 1987-07-05T17:45:56+12:00
+nzdt = 1987-07-05T17:45:56+13:00  # DST
diff --git a/src/lake/tests/toml/tests/valid/empty-file.json b/src/lake/tests/toml/tests/valid/empty-file.json
new file mode 100644
index 0000000000..0967ef424b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/empty-file.json
@@ -0,0 +1 @@
+{}
diff --git a/src/lake/tests/toml/tests/valid/empty-file.toml b/src/lake/tests/toml/tests/valid/empty-file.toml
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/src/lake/tests/toml/tests/valid/example.json b/src/lake/tests/toml/tests/valid/example.json
new file mode 100644
index 0000000000..2ea95a20d2
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/example.json
@@ -0,0 +1,26 @@
+{
+  "best-day-ever": {
+    "type": "datetime",
+    "value": "1987-07-05T17:45:00Z"
+  },
+  "numtheory": {
+    "boring": {
+      "type": "bool",
+      "value": "false"
+    },
+    "perfection": [
+      {
+        "type": "integer",
+        "value": "6"
+      },
+      {
+        "type": "integer",
+        "value": "28"
+      },
+      {
+        "type": "integer",
+        "value": "496"
+      }
+    ]
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/example.toml b/src/lake/tests/toml/tests/valid/example.toml
new file mode 100644
index 0000000000..8cb02e01b0
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/example.toml
@@ -0,0 +1,5 @@
+best-day-ever = 1987-07-05T17:45:00Z
+
+[numtheory]
+boring = false
+perfection = [6, 28, 496]
diff --git a/src/lake/tests/toml/tests/valid/float/exponent.json b/src/lake/tests/toml/tests/valid/float/exponent.json
new file mode 100644
index 0000000000..e79a6e13d3
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/float/exponent.json
@@ -0,0 +1,34 @@
+{
+  "lower": {
+    "type": "float",
+    "value": "300.0"
+  },
+  "minustenth": {
+    "type": "float",
+    "value": "-0.1"
+  },
+  "neg": {
+    "type": "float",
+    "value": "0.03"
+  },
+  "pointlower": {
+    "type": "float",
+    "value": "310.0"
+  },
+  "pointupper": {
+    "type": "float",
+    "value": "310.0"
+  },
+  "pos": {
+    "type": "float",
+    "value": "300.0"
+  },
+  "upper": {
+    "type": "float",
+    "value": "300.0"
+  },
+  "zero": {
+    "type": "float",
+    "value": "3.0"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/float/exponent.toml b/src/lake/tests/toml/tests/valid/float/exponent.toml
new file mode 100644
index 0000000000..573e0a85aa
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/float/exponent.toml
@@ -0,0 +1,8 @@
+lower = 3e2
+upper = 3E2
+neg = 3e-2
+pos = 3E+2
+zero = 3e0
+pointlower = 3.1e2
+pointupper = 3.1E2
+minustenth = -1E-1
diff --git a/src/lake/tests/toml/tests/valid/float/float.json b/src/lake/tests/toml/tests/valid/float/float.json
new file mode 100644
index 0000000000..f92d8d8792
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/float/float.json
@@ -0,0 +1,18 @@
+{
+  "negpi": {
+    "type": "float",
+    "value": "-3.14"
+  },
+  "pi": {
+    "type": "float",
+    "value": "3.14"
+  },
+  "pospi": {
+    "type": "float",
+    "value": "3.14"
+  },
+  "zero-intpart": {
+    "type": "float",
+    "value": "0.123"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/float/float.toml b/src/lake/tests/toml/tests/valid/float/float.toml
new file mode 100644
index 0000000000..5f02322948
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/float/float.toml
@@ -0,0 +1,4 @@
+pi = 3.14
+pospi = +3.14
+negpi = -3.14
+zero-intpart = 0.123
diff --git a/src/lake/tests/toml/tests/valid/float/inf-and-nan.json b/src/lake/tests/toml/tests/valid/float/inf-and-nan.json
new file mode 100644
index 0000000000..e3f1ba3c7f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/float/inf-and-nan.json
@@ -0,0 +1,26 @@
+{
+  "infinity": {
+    "type": "float",
+    "value": "inf"
+  },
+  "infinity_neg": {
+    "type": "float",
+    "value": "-inf"
+  },
+  "infinity_plus": {
+    "type": "float",
+    "value": "+inf"
+  },
+  "nan": {
+    "type": "float",
+    "value": "nan"
+  },
+  "nan_neg": {
+    "type": "float",
+    "value": "nan"
+  },
+  "nan_plus": {
+    "type": "float",
+    "value": "nan"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/float/inf-and-nan.toml b/src/lake/tests/toml/tests/valid/float/inf-and-nan.toml
new file mode 100644
index 0000000000..c8f8459c69
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/float/inf-and-nan.toml
@@ -0,0 +1,8 @@
+# We don't encode +nan and -nan back with the signs; many languages don't
+# support a sign on NaN (it doesn't really make much sense).
+nan = nan
+nan_neg = -nan
+nan_plus = +nan
+infinity = inf
+infinity_neg = -inf
+infinity_plus = +inf
diff --git a/src/lake/tests/toml/tests/valid/float/long.json b/src/lake/tests/toml/tests/valid/float/long.json
new file mode 100644
index 0000000000..73d7505277
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/float/long.json
@@ -0,0 +1,10 @@
+{
+  "longpi": {
+    "type": "float",
+    "value": "3.141592653589793"
+  },
+  "neglongpi": {
+    "type": "float",
+    "value": "-3.141592653589793"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/float/long.toml b/src/lake/tests/toml/tests/valid/float/long.toml
new file mode 100644
index 0000000000..9558ae47c0
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/float/long.toml
@@ -0,0 +1,2 @@
+longpi = 3.141592653589793
+neglongpi = -3.141592653589793
diff --git a/src/lake/tests/toml/tests/valid/float/underscore.json b/src/lake/tests/toml/tests/valid/float/underscore.json
new file mode 100644
index 0000000000..f54f7b5022
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/float/underscore.json
@@ -0,0 +1,14 @@
+{
+  "after": {
+    "type": "float",
+    "value": "3141.5927"
+  },
+  "before": {
+    "type": "float",
+    "value": "3141.5927"
+  },
+  "exponent": {
+    "type": "float",
+    "value": "3.0e14"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/float/underscore.toml b/src/lake/tests/toml/tests/valid/float/underscore.toml
new file mode 100644
index 0000000000..343353a89e
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/float/underscore.toml
@@ -0,0 +1,3 @@
+before = 3_141.5927
+after = 3141.592_7
+exponent = 3e1_4
diff --git a/src/lake/tests/toml/tests/valid/float/zero.json b/src/lake/tests/toml/tests/valid/float/zero.json
new file mode 100644
index 0000000000..61551e8a15
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/float/zero.json
@@ -0,0 +1,30 @@
+{
+  "zero": {
+    "type": "float",
+    "value": "0"
+  },
+  "signed-pos": {
+    "type": "float",
+    "value": "0"
+  },
+  "signed-neg": {
+    "type": "float",
+    "value": "0"
+  },
+  "exponent": {
+    "type": "float",
+    "value": "0"
+  },
+  "exponent-two-0": {
+    "type": "float",
+    "value": "0"
+  },
+  "exponent-signed-pos": {
+    "type": "float",
+    "value": "0"
+  },
+  "exponent-signed-neg": {
+    "type": "float",
+    "value": "0"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/float/zero.toml b/src/lake/tests/toml/tests/valid/float/zero.toml
new file mode 100644
index 0000000000..e7efb1f843
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/float/zero.toml
@@ -0,0 +1,7 @@
+zero = 0.0
+signed-pos = +0.0
+signed-neg = -0.0
+exponent = 0e0
+exponent-two-0 = 0e00
+exponent-signed-pos = +0e0
+exponent-signed-neg = -0e0
diff --git a/src/lake/tests/toml/tests/valid/implicit-and-explicit-after.json b/src/lake/tests/toml/tests/valid/implicit-and-explicit-after.json
new file mode 100644
index 0000000000..663a34e8e8
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/implicit-and-explicit-after.json
@@ -0,0 +1,16 @@
+{
+  "a": {
+    "b": {
+      "c": {
+        "answer": {
+          "type": "integer",
+          "value": "42"
+        }
+      }
+    },
+    "better": {
+      "type": "integer",
+      "value": "43"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/implicit-and-explicit-after.toml b/src/lake/tests/toml/tests/valid/implicit-and-explicit-after.toml
new file mode 100644
index 0000000000..c0e8865b39
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/implicit-and-explicit-after.toml
@@ -0,0 +1,5 @@
+[a.b.c]
+answer = 42
+
+[a]
+better = 43
diff --git a/src/lake/tests/toml/tests/valid/implicit-and-explicit-before.json b/src/lake/tests/toml/tests/valid/implicit-and-explicit-before.json
new file mode 100644
index 0000000000..663a34e8e8
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/implicit-and-explicit-before.json
@@ -0,0 +1,16 @@
+{
+  "a": {
+    "b": {
+      "c": {
+        "answer": {
+          "type": "integer",
+          "value": "42"
+        }
+      }
+    },
+    "better": {
+      "type": "integer",
+      "value": "43"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/implicit-and-explicit-before.toml b/src/lake/tests/toml/tests/valid/implicit-and-explicit-before.toml
new file mode 100644
index 0000000000..eee68ff514
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/implicit-and-explicit-before.toml
@@ -0,0 +1,5 @@
+[a]
+better = 43
+
+[a.b.c]
+answer = 42
diff --git a/src/lake/tests/toml/tests/valid/implicit-groups.json b/src/lake/tests/toml/tests/valid/implicit-groups.json
new file mode 100644
index 0000000000..347c693cf6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/implicit-groups.json
@@ -0,0 +1,12 @@
+{
+  "a": {
+    "b": {
+      "c": {
+        "answer": {
+          "type": "integer",
+          "value": "42"
+        }
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/implicit-groups.toml b/src/lake/tests/toml/tests/valid/implicit-groups.toml
new file mode 100644
index 0000000000..b6333e49d5
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/implicit-groups.toml
@@ -0,0 +1,2 @@
+[a.b.c]
+answer = 42
diff --git a/src/lake/tests/toml/tests/valid/inline-table/array.json b/src/lake/tests/toml/tests/valid/inline-table/array.json
new file mode 100644
index 0000000000..fe78bf6b5b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/array.json
@@ -0,0 +1,34 @@
+{
+  "people": [
+    {
+      "first_name": {
+        "type": "string",
+        "value": "Bruce"
+      },
+      "last_name": {
+        "type": "string",
+        "value": "Springsteen"
+      }
+    },
+    {
+      "first_name": {
+        "type": "string",
+        "value": "Eric"
+      },
+      "last_name": {
+        "type": "string",
+        "value": "Clapton"
+      }
+    },
+    {
+      "first_name": {
+        "type": "string",
+        "value": "Bob"
+      },
+      "last_name": {
+        "type": "string",
+        "value": "Seger"
+      }
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/inline-table/array.toml b/src/lake/tests/toml/tests/valid/inline-table/array.toml
new file mode 100644
index 0000000000..3fa60d6695
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/array.toml
@@ -0,0 +1,3 @@
+people = [{first_name = "Bruce", last_name = "Springsteen"},
+          {first_name = "Eric", last_name = "Clapton"},
+          {first_name = "Bob", last_name = "Seger"}]
diff --git a/src/lake/tests/toml/tests/valid/inline-table/bool.json b/src/lake/tests/toml/tests/valid/inline-table/bool.json
new file mode 100644
index 0000000000..717952fabf
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/bool.json
@@ -0,0 +1,12 @@
+{
+  "a": {
+    "a": {
+      "type": "bool",
+      "value": "true"
+    },
+    "b": {
+      "type": "bool",
+      "value": "false"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/inline-table/bool.toml b/src/lake/tests/toml/tests/valid/inline-table/bool.toml
new file mode 100644
index 0000000000..d228fc2641
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/bool.toml
@@ -0,0 +1 @@
+a = {a = true, b = false}
diff --git a/src/lake/tests/toml/tests/valid/inline-table/empty.json b/src/lake/tests/toml/tests/valid/inline-table/empty.json
new file mode 100644
index 0000000000..28beacf88b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/empty.json
@@ -0,0 +1,30 @@
+{
+  "empty1": {},
+  "empty2": {},
+  "empty_in_array": [
+    {
+      "not_empty": {
+        "type": "integer",
+        "value": "1"
+      }
+    },
+    {}
+  ],
+  "empty_in_array2": [
+    {},
+    {
+      "not_empty": {
+        "type": "integer",
+        "value": "1"
+      }
+    }
+  ],
+  "many_empty": [
+    {},
+    {},
+    {}
+  ],
+  "nested_empty": {
+    "empty": {}
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/inline-table/empty.toml b/src/lake/tests/toml/tests/valid/inline-table/empty.toml
new file mode 100644
index 0000000000..910d458f19
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/empty.toml
@@ -0,0 +1,6 @@
+empty1 = {}
+empty2 = { }
+empty_in_array = [ { not_empty = 1 }, {} ]
+empty_in_array2 = [{},{not_empty=1}]
+many_empty = [{},{},{}]
+nested_empty = {"empty"={}}
diff --git a/src/lake/tests/toml/tests/valid/inline-table/end-in-bool.json b/src/lake/tests/toml/tests/valid/inline-table/end-in-bool.json
new file mode 100644
index 0000000000..90e700abaa
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/end-in-bool.json
@@ -0,0 +1,16 @@
+{
+  "black": {
+    "allow_prereleases": {
+      "type": "bool",
+      "value": "true"
+    },
+    "python": {
+      "type": "string",
+      "value": "\u003e3.6"
+    },
+    "version": {
+      "type": "string",
+      "value": "\u003e=18.9b0"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/inline-table/end-in-bool.toml b/src/lake/tests/toml/tests/valid/inline-table/end-in-bool.toml
new file mode 100644
index 0000000000..94e5651d58
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/end-in-bool.toml
@@ -0,0 +1 @@
+black = { python=">3.6", version=">=18.9b0", allow_prereleases=true }
diff --git a/src/lake/tests/toml/tests/valid/inline-table/inline-table.json b/src/lake/tests/toml/tests/valid/inline-table/inline-table.json
new file mode 100644
index 0000000000..2468f62c07
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/inline-table.json
@@ -0,0 +1,48 @@
+{
+  "name": {
+    "first": {
+      "type": "string",
+      "value": "Tom"
+    },
+    "last": {
+      "type": "string",
+      "value": "Preston-Werner"
+    }
+  },
+  "point": {
+    "x": {
+      "type": "integer",
+      "value": "1"
+    },
+    "y": {
+      "type": "integer",
+      "value": "2"
+    }
+  },
+  "simple": {
+    "a": {
+      "type": "integer",
+      "value": "1"
+    }
+  },
+  "str-key": {
+    "a": {
+      "type": "integer",
+      "value": "1"
+    }
+  },
+  "table-array": [
+    {
+      "a": {
+        "type": "integer",
+        "value": "1"
+      }
+    },
+    {
+      "b": {
+        "type": "integer",
+        "value": "2"
+      }
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/inline-table/inline-table.toml b/src/lake/tests/toml/tests/valid/inline-table/inline-table.toml
new file mode 100644
index 0000000000..257047eebc
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/inline-table.toml
@@ -0,0 +1,5 @@
+name = { first = "Tom", last = "Preston-Werner" }
+point = { x = 1, y = 2 }
+simple = { a = 1 }
+str-key = { "a" = 1 }
+table-array = [{ "a" = 1 }, { "b" = 2 }]
diff --git a/src/lake/tests/toml/tests/valid/inline-table/key-dotted.json b/src/lake/tests/toml/tests/valid/inline-table/key-dotted.json
new file mode 100644
index 0000000000..38868032ae
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/key-dotted.json
@@ -0,0 +1,140 @@
+{
+  "a": {
+    "a": {
+      "b": {
+        "type": "integer",
+        "value": "1"
+      }
+    }
+  },
+  "arr": [
+    {
+      "T": {
+        "a": {
+          "b": {
+            "type": "integer",
+            "value": "1"
+          }
+        }
+      },
+      "t": {
+        "a": {
+          "b": {
+            "type": "integer",
+            "value": "1"
+          }
+        }
+      }
+    },
+    {
+      "T": {
+        "a": {
+          "b": {
+            "type": "integer",
+            "value": "2"
+          }
+        }
+      },
+      "t": {
+        "a": {
+          "b": {
+            "type": "integer",
+            "value": "2"
+          }
+        }
+      }
+    }
+  ],
+  "b": {
+    "a": {
+      "b": {
+        "type": "integer",
+        "value": "1"
+      }
+    }
+  },
+  "c": {
+    "a": {
+      "b": {
+        "type": "integer",
+        "value": "1"
+      }
+    }
+  },
+  "d": {
+    "a": {
+      "b": {
+        "type": "integer",
+        "value": "1"
+      }
+    }
+  },
+  "e": {
+    "a": {
+      "b": {
+        "type": "integer",
+        "value": "1"
+      }
+    }
+  },
+  "inline": {
+    "a": {
+      "b": {
+        "type": "integer",
+        "value": "42"
+      }
+    }
+  },
+  "many": {
+    "dots": {
+      "here": {
+        "dot": {
+          "dot": {
+            "dot": {
+              "a": {
+                "b": {
+                  "c": {
+                    "type": "integer",
+                    "value": "1"
+                  },
+                  "d": {
+                    "type": "integer",
+                    "value": "2"
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  },
+  "tbl": {
+    "a": {
+      "b": {
+        "c": {
+          "d": {
+            "e": {
+              "type": "integer",
+              "value": "1"
+            }
+          }
+        }
+      }
+    },
+    "x": {
+      "a": {
+        "b": {
+          "c": {
+            "d": {
+              "e": {
+                "type": "integer",
+                "value": "1"
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/inline-table/key-dotted.toml b/src/lake/tests/toml/tests/valid/inline-table/key-dotted.toml
new file mode 100644
index 0000000000..e812943a93
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/key-dotted.toml
@@ -0,0 +1,23 @@
+inline = {a.b = 42}
+
+many.dots.here.dot.dot.dot = {a.b.c = 1, a.b.d = 2}
+
+a = {   a.b  =  1   }
+b = {   "a"."b"  =  1   }
+c = {   a   .   b  =  1   }
+d = {   'a'   .   "b"  =  1   }
+e = {a.b=1}
+
+[tbl]
+a.b.c = {d.e=1}
+
+[tbl.x]
+a.b.c = {d.e=1}
+
+[[arr]]
+t = {a.b=1}
+T = {a.b=1}
+
+[[arr]]
+t = {a.b=2}
+T = {a.b=2}
diff --git a/src/lake/tests/toml/tests/valid/inline-table/multiline.json b/src/lake/tests/toml/tests/valid/inline-table/multiline.json
new file mode 100644
index 0000000000..f946d819e6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/multiline.json
@@ -0,0 +1,20 @@
+{
+  "tbl_multiline": {
+    "a": {
+      "type": "integer",
+      "value": "1"
+    },
+    "b": {
+      "type": "string",
+      "value": "multiline\n"
+    },
+    "c": {
+      "type": "string",
+      "value": "and yet\nanother line"
+    },
+    "d": {
+      "type": "integer",
+      "value": "4"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/inline-table/multiline.toml b/src/lake/tests/toml/tests/valid/inline-table/multiline.toml
new file mode 100644
index 0000000000..a653b18f4a
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/multiline.toml
@@ -0,0 +1,4 @@
+tbl_multiline = { a = 1, b = """
+multiline
+""", c = """and yet
+another line""", d = 4 }
diff --git a/src/lake/tests/toml/tests/valid/inline-table/nest.json b/src/lake/tests/toml/tests/valid/inline-table/nest.json
new file mode 100644
index 0000000000..70aebb3f96
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/nest.json
@@ -0,0 +1,64 @@
+{
+  "arr_arr_tbl_empty": [
+    [
+      {}
+    ]
+  ],
+  "arr_arr_tbl_val": [
+    [
+      {
+        "one": {
+          "type": "integer",
+          "value": "1"
+        }
+      }
+    ]
+  ],
+  "arr_arr_tbls": [
+    [
+      {
+        "one": {
+          "type": "integer",
+          "value": "1"
+        }
+      },
+      {
+        "two": {
+          "type": "integer",
+          "value": "2"
+        }
+      }
+    ]
+  ],
+  "arr_tbl_tbl": [
+    {
+      "tbl": {
+        "one": {
+          "type": "integer",
+          "value": "1"
+        }
+      }
+    }
+  ],
+  "tbl_arr_tbl": {
+    "arr_tbl": [
+      {
+        "one": {
+          "type": "integer",
+          "value": "1"
+        }
+      }
+    ]
+  },
+  "tbl_tbl_empty": {
+    "tbl_0": {}
+  },
+  "tbl_tbl_val": {
+    "tbl_1": {
+      "one": {
+        "type": "integer",
+        "value": "1"
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/inline-table/nest.toml b/src/lake/tests/toml/tests/valid/inline-table/nest.toml
new file mode 100644
index 0000000000..2624c1d545
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/inline-table/nest.toml
@@ -0,0 +1,10 @@
+tbl_tbl_empty = { tbl_0 = {} }
+tbl_tbl_val   = { tbl_1 = { one = 1 } }
+tbl_arr_tbl   = { arr_tbl = [ { one = 1 } ] }
+arr_tbl_tbl   = [ { tbl = { one = 1 } } ]
+
+# Array-of-array-of-table is interesting because it can only
+# be represented in inline form.
+arr_arr_tbl_empty = [ [ {} ] ]
+arr_arr_tbl_val = [ [ { one = 1 } ] ]
+arr_arr_tbls  = [ [ { one = 1 }, { two = 2 } ] ]
diff --git a/src/lake/tests/toml/tests/valid/integer/integer.json b/src/lake/tests/toml/tests/valid/integer/integer.json
new file mode 100644
index 0000000000..eee9758068
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/integer/integer.json
@@ -0,0 +1,18 @@
+{
+  "answer": {
+    "type": "integer",
+    "value": "42"
+  },
+  "neganswer": {
+    "type": "integer",
+    "value": "-42"
+  },
+  "posanswer": {
+    "type": "integer",
+    "value": "42"
+  },
+  "zero": {
+    "type": "integer",
+    "value": "0"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/integer/integer.toml b/src/lake/tests/toml/tests/valid/integer/integer.toml
new file mode 100644
index 0000000000..b62de30aee
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/integer/integer.toml
@@ -0,0 +1,4 @@
+answer = 42
+posanswer = +42
+neganswer = -42
+zero = 0
diff --git a/src/lake/tests/toml/tests/valid/integer/literals.json b/src/lake/tests/toml/tests/valid/integer/literals.json
new file mode 100644
index 0000000000..1a8555bddd
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/integer/literals.json
@@ -0,0 +1,38 @@
+{
+  "bin1": {
+    "type": "integer",
+    "value": "214"
+  },
+  "bin2": {
+    "type": "integer",
+    "value": "5"
+  },
+  "hex1": {
+    "type": "integer",
+    "value": "3735928559"
+  },
+  "hex2": {
+    "type": "integer",
+    "value": "3735928559"
+  },
+  "hex3": {
+    "type": "integer",
+    "value": "3735928559"
+  },
+  "hex4": {
+    "type": "integer",
+    "value": "2439"
+  },
+  "oct1": {
+    "type": "integer",
+    "value": "342391"
+  },
+  "oct2": {
+    "type": "integer",
+    "value": "493"
+  },
+  "oct3": {
+    "type": "integer",
+    "value": "501"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/integer/literals.toml b/src/lake/tests/toml/tests/valid/integer/literals.toml
new file mode 100644
index 0000000000..a07859047f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/integer/literals.toml
@@ -0,0 +1,11 @@
+bin1 = 0b11010110
+bin2 = 0b1_0_1
+
+oct1 = 0o01234567
+oct2 = 0o755
+oct3 = 0o7_6_5
+
+hex1 = 0xDEADBEEF
+hex2 = 0xdeadbeef
+hex3 = 0xdead_beef
+hex4 = 0x00987
diff --git a/src/lake/tests/toml/tests/valid/integer/long.json b/src/lake/tests/toml/tests/valid/integer/long.json
new file mode 100644
index 0000000000..6f4f0a7cbe
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/integer/long.json
@@ -0,0 +1,10 @@
+{
+  "int64-max": {
+    "type": "integer",
+    "value": "9223372036854775807"
+  },
+  "int64-max-neg": {
+    "type": "integer",
+    "value": "-9223372036854775808"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/integer/long.toml b/src/lake/tests/toml/tests/valid/integer/long.toml
new file mode 100644
index 0000000000..5db5ed79e3
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/integer/long.toml
@@ -0,0 +1,2 @@
+int64-max = 9223372036854775807
+int64-max-neg = -9223372036854775808
diff --git a/src/lake/tests/toml/tests/valid/integer/underscore.json b/src/lake/tests/toml/tests/valid/integer/underscore.json
new file mode 100644
index 0000000000..10b9b591dc
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/integer/underscore.json
@@ -0,0 +1,10 @@
+{
+  "kilo": {
+    "type": "integer",
+    "value": "1000"
+  },
+  "x": {
+    "type": "integer",
+    "value": "1111"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/integer/underscore.toml b/src/lake/tests/toml/tests/valid/integer/underscore.toml
new file mode 100644
index 0000000000..7c2da5fec7
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/integer/underscore.toml
@@ -0,0 +1,2 @@
+kilo = 1_000
+x = 1_1_1_1
diff --git a/src/lake/tests/toml/tests/valid/integer/zero.json b/src/lake/tests/toml/tests/valid/integer/zero.json
new file mode 100644
index 0000000000..9d5c707717
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/integer/zero.json
@@ -0,0 +1,50 @@
+{
+  "a2": {
+    "type": "integer",
+    "value": "0"
+  },
+  "a3": {
+    "type": "integer",
+    "value": "0"
+  },
+  "b1": {
+    "type": "integer",
+    "value": "0"
+  },
+  "b2": {
+    "type": "integer",
+    "value": "0"
+  },
+  "b3": {
+    "type": "integer",
+    "value": "0"
+  },
+  "d1": {
+    "type": "integer",
+    "value": "0"
+  },
+  "d2": {
+    "type": "integer",
+    "value": "0"
+  },
+  "d3": {
+    "type": "integer",
+    "value": "0"
+  },
+  "h1": {
+    "type": "integer",
+    "value": "0"
+  },
+  "h2": {
+    "type": "integer",
+    "value": "0"
+  },
+  "h3": {
+    "type": "integer",
+    "value": "0"
+  },
+  "o1": {
+    "type": "integer",
+    "value": "0"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/integer/zero.toml b/src/lake/tests/toml/tests/valid/integer/zero.toml
new file mode 100644
index 0000000000..4687c28102
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/integer/zero.toml
@@ -0,0 +1,15 @@
+d1 = 0
+d2 = +0
+d3 = -0
+
+h1 = 0x0
+h2 = 0x00
+h3 = 0x00000
+
+o1 = 0o0
+a2 = 0o00
+a3 = 0o00000
+
+b1 = 0b0
+b2 = 0b00
+b3 = 0b00000
diff --git a/src/lake/tests/toml/tests/valid/key/alphanum.json b/src/lake/tests/toml/tests/valid/key/alphanum.json
new file mode 100644
index 0000000000..a54e1d3515
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/alphanum.json
@@ -0,0 +1,46 @@
+{
+  "000111": {
+    "type": "string",
+    "value": "leading"
+  },
+  "10e3": {
+    "type": "string",
+    "value": "false float"
+  },
+  "123": {
+    "type": "string",
+    "value": "num"
+  },
+  "2018_10": {
+    "001": {
+      "type": "integer",
+      "value": "1"
+    }
+  },
+  "34-11": {
+    "type": "integer",
+    "value": "23"
+  },
+  "a-a-a": {
+    "_": {
+      "type": "bool",
+      "value": "false"
+    }
+  },
+  "alpha": {
+    "type": "string",
+    "value": "a"
+  },
+  "one1two2": {
+    "type": "string",
+    "value": "mixed"
+  },
+  "under_score": {
+    "type": "string",
+    "value": "___"
+  },
+  "with-dash": {
+    "type": "string",
+    "value": "dashed"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/alphanum.toml b/src/lake/tests/toml/tests/valid/key/alphanum.toml
new file mode 100644
index 0000000000..0632e9ccde
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/alphanum.toml
@@ -0,0 +1,14 @@
+alpha = "a"
+123 = "num"
+000111 = "leading"
+10e3 = "false float"
+one1two2 = "mixed"
+with-dash = "dashed"
+under_score = "___"
+34-11 = 23
+
+[2018_10]
+001 = 1
+
+[a-a-a]
+_ = false
diff --git a/src/lake/tests/toml/tests/valid/key/case-sensitive.json b/src/lake/tests/toml/tests/valid/key/case-sensitive.json
new file mode 100644
index 0000000000..1f205d20cd
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/case-sensitive.json
@@ -0,0 +1,38 @@
+{
+  "Section": {
+    "M": {
+      "type": "string",
+      "value": "latin letter M"
+    },
+    "name": {
+      "type": "string",
+      "value": "different section!!"
+    },
+    "Μ": {
+      "type": "string",
+      "value": "greek capital letter MU"
+    },
+    "μ": {
+      "type": "string",
+      "value": "greek small letter mu"
+    }
+  },
+  "sectioN": {
+    "type": "string",
+    "value": "NN"
+  },
+  "section": {
+    "NAME": {
+      "type": "string",
+      "value": "upper"
+    },
+    "Name": {
+      "type": "string",
+      "value": "capitalized"
+    },
+    "name": {
+      "type": "string",
+      "value": "lower"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/case-sensitive.toml b/src/lake/tests/toml/tests/valid/key/case-sensitive.toml
new file mode 100644
index 0000000000..e02b3a51ad
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/case-sensitive.toml
@@ -0,0 +1,13 @@
+sectioN = "NN"
+
+[section]
+name = "lower"
+NAME = "upper"
+Name = "capitalized"
+
+[Section]
+name = "different section!!"
+"μ" = "greek small letter mu"
+"Μ" = "greek capital letter MU"
+M = "latin letter M"
+
diff --git a/src/lake/tests/toml/tests/valid/key/dotted-empty.json b/src/lake/tests/toml/tests/valid/key/dotted-empty.json
new file mode 100644
index 0000000000..4ca4b5075f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/dotted-empty.json
@@ -0,0 +1,22 @@
+{
+  "": {
+    "x": {
+      "type": "string",
+      "value": "empty.x"
+    }
+  },
+  "x": {
+    "": {
+      "type": "string",
+      "value": "x.empty"
+    }
+  },
+  "a": {
+    "": {
+      "": {
+        "type": "string",
+        "value": "empty.empty"
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/dotted-empty.toml b/src/lake/tests/toml/tests/valid/key/dotted-empty.toml
new file mode 100644
index 0000000000..45ef4c7e00
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/dotted-empty.toml
@@ -0,0 +1,4 @@
+''.x = "empty.x"
+x."" = "x.empty"
+[a]
+"".'' = "empty.empty"
diff --git a/src/lake/tests/toml/tests/valid/key/dotted.json b/src/lake/tests/toml/tests/valid/key/dotted.json
new file mode 100644
index 0000000000..a527a72c2d
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/dotted.json
@@ -0,0 +1,132 @@
+{
+  "a": {
+    "few": {
+      "dots": {
+        "polka": {
+          "dance-with": {
+            "type": "string",
+            "value": "Dot"
+          },
+          "dot": {
+            "type": "string",
+            "value": "again?"
+          }
+        }
+      }
+    }
+  },
+  "arr": [
+    {
+      "a": {
+        "b": {
+          "c": {
+            "type": "integer",
+            "value": "1"
+          },
+          "d": {
+            "type": "integer",
+            "value": "2"
+          }
+        }
+      }
+    },
+    {
+      "a": {
+        "b": {
+          "c": {
+            "type": "integer",
+            "value": "3"
+          },
+          "d": {
+            "type": "integer",
+            "value": "4"
+          }
+        }
+      }
+    }
+  ],
+  "count": {
+    "a": {
+      "type": "integer",
+      "value": "1"
+    },
+    "b": {
+      "type": "integer",
+      "value": "2"
+    },
+    "c": {
+      "type": "integer",
+      "value": "3"
+    },
+    "d": {
+      "type": "integer",
+      "value": "4"
+    },
+    "e": {
+      "type": "integer",
+      "value": "5"
+    },
+    "f": {
+      "type": "integer",
+      "value": "6"
+    },
+    "g": {
+      "type": "integer",
+      "value": "7"
+    },
+    "h": {
+      "type": "integer",
+      "value": "8"
+    },
+    "i": {
+      "type": "integer",
+      "value": "9"
+    },
+    "j": {
+      "type": "integer",
+      "value": "10"
+    },
+    "k": {
+      "type": "integer",
+      "value": "11"
+    },
+    "l": {
+      "type": "integer",
+      "value": "12"
+    }
+  },
+  "many": {
+    "dots": {
+      "here": {
+        "dot": {
+          "dot": {
+            "dot": {
+              "type": "integer",
+              "value": "42"
+            }
+          }
+        }
+      }
+    }
+  },
+  "name": {
+    "first": {
+      "type": "string",
+      "value": "Arthur"
+    },
+    "last": {
+      "type": "string",
+      "value": "Dent"
+    }
+  },
+  "tbl": {
+    "a": {
+      "b": {
+        "c": {
+          "type": "float",
+          "value": "42.666"
+        }
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/dotted.toml b/src/lake/tests/toml/tests/valid/key/dotted.toml
new file mode 100644
index 0000000000..52d62d72f2
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/dotted.toml
@@ -0,0 +1,35 @@
+# Note: this file contains literal tab characters.
+
+name.first = "Arthur"
+"name".'last' = "Dent"
+
+many.dots.here.dot.dot.dot = 42
+
+# Space are ignored, and key parts can be quoted.
+count.a       = 1
+count . b     = 2
+"count"."c"   = 3
+"count" . "d" = 4
+'count'.'e'   = 5
+'count' . 'f' = 6
+"count".'g'   = 7
+"count" . 'h' = 8
+count.'i'     = 9
+count 	.	 'j'	   = 10
+"count".k     = 11
+"count" . l   = 12
+
+[tbl]
+a.b.c = 42.666
+
+[a.few.dots]
+polka.dot = "again?"
+polka.dance-with = "Dot"
+
+[[arr]]
+a.b.c=1
+a.b.d=2
+
+[[arr]]
+a.b.c=3
+a.b.d=4
diff --git a/src/lake/tests/toml/tests/valid/key/empty.json b/src/lake/tests/toml/tests/valid/key/empty.json
new file mode 100644
index 0000000000..44948a9e76
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/empty.json
@@ -0,0 +1,6 @@
+{
+  "": {
+    "type": "string",
+    "value": "blank"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/empty.toml b/src/lake/tests/toml/tests/valid/key/empty.toml
new file mode 100644
index 0000000000..0a1640dc2b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/empty.toml
@@ -0,0 +1 @@
+"" = "blank"
diff --git a/src/lake/tests/toml/tests/valid/key/equals-nospace.json b/src/lake/tests/toml/tests/valid/key/equals-nospace.json
new file mode 100644
index 0000000000..9394e562be
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/equals-nospace.json
@@ -0,0 +1,6 @@
+{
+  "answer": {
+    "type": "integer",
+    "value": "42"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/equals-nospace.toml b/src/lake/tests/toml/tests/valid/key/equals-nospace.toml
new file mode 100644
index 0000000000..560901c5a4
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/equals-nospace.toml
@@ -0,0 +1 @@
+answer=42
diff --git a/src/lake/tests/toml/tests/valid/key/escapes.json b/src/lake/tests/toml/tests/valid/key/escapes.json
new file mode 100644
index 0000000000..e62b3a14e9
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/escapes.json
@@ -0,0 +1,24 @@
+{
+  "\n": {
+    "type": "string",
+    "value": "newline"
+  },
+  "\"": {
+    "type": "string",
+    "value": "just a quote"
+  },
+  "\"quoted\"": {
+    "quote": {
+      "type": "bool",
+      "value": "true"
+    }
+  },
+  "a.b": {
+    "À": {}
+  },
+  "backsp\u0008\u0008": {},
+  "À": {
+    "type": "string",
+    "value": "latin capital letter A with grave"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/escapes.toml b/src/lake/tests/toml/tests/valid/key/escapes.toml
new file mode 100644
index 0000000000..aac3c0a511
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/escapes.toml
@@ -0,0 +1,10 @@
+"\n" = "newline"
+"\u00c0" = "latin capital letter A with grave"
+"\"" = "just a quote"
+
+["backsp\b\b"]
+
+["\"quoted\""]
+quote = true
+
+["a.b"."\u00c0"]
diff --git a/src/lake/tests/toml/tests/valid/key/numeric-dotted.json b/src/lake/tests/toml/tests/valid/key/numeric-dotted.json
new file mode 100644
index 0000000000..43dd4d1f2b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/numeric-dotted.json
@@ -0,0 +1,8 @@
+{
+  "1": {
+    "2": {
+      "type": "integer",
+      "value": "3"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/numeric-dotted.toml b/src/lake/tests/toml/tests/valid/key/numeric-dotted.toml
new file mode 100644
index 0000000000..538204c681
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/numeric-dotted.toml
@@ -0,0 +1 @@
+1.2 = 3
diff --git a/src/lake/tests/toml/tests/valid/key/numeric.json b/src/lake/tests/toml/tests/valid/key/numeric.json
new file mode 100644
index 0000000000..eddb88be19
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/numeric.json
@@ -0,0 +1,6 @@
+{
+  "1": {
+    "type": "integer",
+    "value": "1"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/numeric.toml b/src/lake/tests/toml/tests/valid/key/numeric.toml
new file mode 100644
index 0000000000..532356f49b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/numeric.toml
@@ -0,0 +1 @@
+1 = 1
diff --git a/src/lake/tests/toml/tests/valid/key/quoted-dots.json b/src/lake/tests/toml/tests/valid/key/quoted-dots.json
new file mode 100644
index 0000000000..1582c5b88f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/quoted-dots.json
@@ -0,0 +1,32 @@
+{
+  "plain": {
+    "type": "integer",
+    "value": "1"
+  },
+  "plain_table": {
+    "plain": {
+      "type": "integer",
+      "value": "3"
+    },
+    "with.dot": {
+      "type": "integer",
+      "value": "4"
+    }
+  },
+  "table": {
+    "withdot": {
+      "key.with.dots": {
+        "type": "integer",
+        "value": "6"
+      },
+      "plain": {
+        "type": "integer",
+        "value": "5"
+      }
+    }
+  },
+  "with.dot": {
+    "type": "integer",
+    "value": "2"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/quoted-dots.toml b/src/lake/tests/toml/tests/valid/key/quoted-dots.toml
new file mode 100644
index 0000000000..65fcddf96a
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/quoted-dots.toml
@@ -0,0 +1,10 @@
+plain = 1
+"with.dot" = 2
+
+[plain_table]
+plain = 3
+"with.dot" = 4
+
+[table.withdot]
+plain = 5
+"key.with.dots" = 6
diff --git a/src/lake/tests/toml/tests/valid/key/quoted-unicode.json b/src/lake/tests/toml/tests/valid/key/quoted-unicode.json
new file mode 100644
index 0000000000..a51cc01f95
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/quoted-unicode.json
@@ -0,0 +1,22 @@
+{
+  "\u0000": {
+    "type": "string",
+    "value": "null"
+  },
+  "\\u0000": {
+    "type": "string",
+    "value": "different key"
+  },
+  "\b \f A \u007f \u0080 \u00ff \ud7ff \ue000 \uffff \ud800\udc00 \udbff\udfff": {
+    "type": "string",
+    "value": "escaped key"
+  },
+  "~ \u0080 \u00ff \ud7ff \ue000 \uffff \ud800\udc00 \udbff\udfff": {
+    "type": "string",
+    "value": "basic key"
+  },
+  "l ~ \u0080 \u00ff \ud7ff \ue000 \uffff \ud800\udc00 \udbff\udfff": {
+    "type": "string",
+    "value": "literal key"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/quoted-unicode.toml b/src/lake/tests/toml/tests/valid/key/quoted-unicode.toml
new file mode 100644
index 0000000000..bc31b729ae
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/quoted-unicode.toml
@@ -0,0 +1,7 @@
+
+"\u0000" = "null"
+'\u0000' = "different key"
+"\u0008 \u000c \U00000041 \u007f \u0080 \u00ff \ud7ff \ue000 \uffff \U00010000 \U0010ffff" = "escaped key"
+
+"~ € ÿ ퟿  ￿ 𐀀 􏿿" = "basic key"
+'l ~ € ÿ ퟿  ￿ 𐀀 􏿿' = "literal key"
diff --git a/src/lake/tests/toml/tests/valid/key/space.json b/src/lake/tests/toml/tests/valid/key/space.json
new file mode 100644
index 0000000000..670d16a1c6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/space.json
@@ -0,0 +1,16 @@
+{
+  " c d ": {
+    "type": "integer",
+    "value": "2"
+  },
+  " tbl ": {
+    "\ttab\ttab\t": {
+      "type": "string",
+      "value": "tab"
+    }
+  },
+  "a b": {
+    "type": "integer",
+    "value": "1"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/space.toml b/src/lake/tests/toml/tests/valid/key/space.toml
new file mode 100644
index 0000000000..4234f88ac1
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/space.toml
@@ -0,0 +1,6 @@
+# Keep whitespace inside quotes keys at all positions.
+"a b"   = 1
+" c d " = 2
+
+[ " tbl " ]
+"\ttab\ttab\t" = "tab"
diff --git a/src/lake/tests/toml/tests/valid/key/special-chars.json b/src/lake/tests/toml/tests/valid/key/special-chars.json
new file mode 100644
index 0000000000..fa64c7d217
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/special-chars.json
@@ -0,0 +1,6 @@
+{
+  "=~!@$^\u0026*()_+-`1234567890[]|/?\u003e\u003c.,;:'=": {
+    "type": "integer",
+    "value": "1"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/special-chars.toml b/src/lake/tests/toml/tests/valid/key/special-chars.toml
new file mode 100644
index 0000000000..0ba7168479
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/special-chars.toml
@@ -0,0 +1 @@
+"=~!@$^&*()_+-`1234567890[]|/?><.,;:'=" = 1
diff --git a/src/lake/tests/toml/tests/valid/key/special-word.json b/src/lake/tests/toml/tests/valid/key/special-word.json
new file mode 100644
index 0000000000..59ce693a6f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/special-word.json
@@ -0,0 +1,18 @@
+{
+  "false": {
+    "type": "bool",
+    "value": "false"
+  },
+  "inf": {
+    "type": "integer",
+    "value": "100000000"
+  },
+  "nan": {
+    "type": "string",
+    "value": "ceci n'est pas un nombre"
+  },
+  "true": {
+    "type": "integer",
+    "value": "1"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/key/special-word.toml b/src/lake/tests/toml/tests/valid/key/special-word.toml
new file mode 100644
index 0000000000..0b836f17dc
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/key/special-word.toml
@@ -0,0 +1,5 @@
+false = false
+true = 1
+inf = 100000000
+nan = "ceci n'est pas un nombre"
+
diff --git a/src/lake/tests/toml/tests/valid/newline-crlf.json b/src/lake/tests/toml/tests/valid/newline-crlf.json
new file mode 100644
index 0000000000..acf617e32f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/newline-crlf.json
@@ -0,0 +1,10 @@
+{
+  "newline": {
+    "type": "string",
+    "value": "crlf"
+  },
+  "os": {
+    "type": "string",
+    "value": "DOS"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/newline-crlf.toml b/src/lake/tests/toml/tests/valid/newline-crlf.toml
new file mode 100644
index 0000000000..0030024428
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/newline-crlf.toml
@@ -0,0 +1,2 @@
+os = "DOS"
+newline = "crlf"
diff --git a/src/lake/tests/toml/tests/valid/newline-lf.json b/src/lake/tests/toml/tests/valid/newline-lf.json
new file mode 100644
index 0000000000..66cf871f39
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/newline-lf.json
@@ -0,0 +1,10 @@
+{
+  "newline": {
+    "type": "string",
+    "value": "lf"
+  },
+  "os": {
+    "type": "string",
+    "value": "unix"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/newline-lf.toml b/src/lake/tests/toml/tests/valid/newline-lf.toml
new file mode 100644
index 0000000000..0f3377cd99
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/newline-lf.toml
@@ -0,0 +1,2 @@
+os = "unix"
+newline = "lf"
diff --git a/src/lake/tests/toml/tests/valid/spec-example-1-compact.json b/src/lake/tests/toml/tests/valid/spec-example-1-compact.json
new file mode 100644
index 0000000000..9f4078aa78
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec-example-1-compact.json
@@ -0,0 +1,100 @@
+{
+  "clients": {
+    "data": [
+      [
+        {
+          "type": "string",
+          "value": "gamma"
+        },
+        {
+          "type": "string",
+          "value": "delta"
+        }
+      ],
+      [
+        {
+          "type": "integer",
+          "value": "1"
+        },
+        {
+          "type": "integer",
+          "value": "2"
+        }
+      ]
+    ],
+    "hosts": [
+      {
+        "type": "string",
+        "value": "alpha"
+      },
+      {
+        "type": "string",
+        "value": "omega"
+      }
+    ]
+  },
+  "database": {
+    "connection_max": {
+      "type": "integer",
+      "value": "5000"
+    },
+    "enabled": {
+      "type": "bool",
+      "value": "true"
+    },
+    "ports": [
+      {
+        "type": "integer",
+        "value": "8001"
+      },
+      {
+        "type": "integer",
+        "value": "8001"
+      },
+      {
+        "type": "integer",
+        "value": "8002"
+      }
+    ],
+    "server": {
+      "type": "string",
+      "value": "192.168.1.1"
+    }
+  },
+  "owner": {
+    "dob": {
+      "type": "datetime",
+      "value": "1979-05-27T07:32:00-08:00"
+    },
+    "name": {
+      "type": "string",
+      "value": "Lance Uppercut"
+    }
+  },
+  "servers": {
+    "alpha": {
+      "dc": {
+        "type": "string",
+        "value": "eqdc10"
+      },
+      "ip": {
+        "type": "string",
+        "value": "10.0.0.1"
+      }
+    },
+    "beta": {
+      "dc": {
+        "type": "string",
+        "value": "eqdc10"
+      },
+      "ip": {
+        "type": "string",
+        "value": "10.0.0.2"
+      }
+    }
+  },
+  "title": {
+    "type": "string",
+    "value": "TOML Example"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec-example-1-compact.toml b/src/lake/tests/toml/tests/valid/spec-example-1-compact.toml
new file mode 100644
index 0000000000..15e2b84b86
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec-example-1-compact.toml
@@ -0,0 +1,23 @@
+#Useless spaces eliminated.
+title="TOML Example"
+[owner]
+name="Lance Uppercut"
+dob=1979-05-27T07:32:00-08:00#First class dates
+[database]
+server="192.168.1.1"
+ports=[8001,8001,8002]
+connection_max=5000
+enabled=true
+[servers]
+[servers.alpha]
+ip="10.0.0.1"
+dc="eqdc10"
+[servers.beta]
+ip="10.0.0.2"
+dc="eqdc10"
+[clients]
+data=[["gamma","delta"],[1,2]]
+hosts=[
+"alpha",
+"omega"
+]
diff --git a/src/lake/tests/toml/tests/valid/spec-example-1.json b/src/lake/tests/toml/tests/valid/spec-example-1.json
new file mode 100644
index 0000000000..9f4078aa78
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec-example-1.json
@@ -0,0 +1,100 @@
+{
+  "clients": {
+    "data": [
+      [
+        {
+          "type": "string",
+          "value": "gamma"
+        },
+        {
+          "type": "string",
+          "value": "delta"
+        }
+      ],
+      [
+        {
+          "type": "integer",
+          "value": "1"
+        },
+        {
+          "type": "integer",
+          "value": "2"
+        }
+      ]
+    ],
+    "hosts": [
+      {
+        "type": "string",
+        "value": "alpha"
+      },
+      {
+        "type": "string",
+        "value": "omega"
+      }
+    ]
+  },
+  "database": {
+    "connection_max": {
+      "type": "integer",
+      "value": "5000"
+    },
+    "enabled": {
+      "type": "bool",
+      "value": "true"
+    },
+    "ports": [
+      {
+        "type": "integer",
+        "value": "8001"
+      },
+      {
+        "type": "integer",
+        "value": "8001"
+      },
+      {
+        "type": "integer",
+        "value": "8002"
+      }
+    ],
+    "server": {
+      "type": "string",
+      "value": "192.168.1.1"
+    }
+  },
+  "owner": {
+    "dob": {
+      "type": "datetime",
+      "value": "1979-05-27T07:32:00-08:00"
+    },
+    "name": {
+      "type": "string",
+      "value": "Lance Uppercut"
+    }
+  },
+  "servers": {
+    "alpha": {
+      "dc": {
+        "type": "string",
+        "value": "eqdc10"
+      },
+      "ip": {
+        "type": "string",
+        "value": "10.0.0.1"
+      }
+    },
+    "beta": {
+      "dc": {
+        "type": "string",
+        "value": "eqdc10"
+      },
+      "ip": {
+        "type": "string",
+        "value": "10.0.0.2"
+      }
+    }
+  },
+  "title": {
+    "type": "string",
+    "value": "TOML Example"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec-example-1.toml b/src/lake/tests/toml/tests/valid/spec-example-1.toml
new file mode 100644
index 0000000000..52fd1e89c1
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec-example-1.toml
@@ -0,0 +1,33 @@
+# This is a TOML document. Boom.
+
+title = "TOML Example"
+
+[owner]
+name = "Lance Uppercut"
+dob = 1979-05-27T07:32:00-08:00 # First class dates? Why not?
+
+[database]
+server = "192.168.1.1"
+ports = [ 8001, 8001, 8002 ]
+connection_max = 5000
+enabled = true
+
+[servers]
+
+  # You can indent as you please. Tabs or spaces. TOML don't care.
+  [servers.alpha]
+  ip = "10.0.0.1"
+  dc = "eqdc10"
+
+  [servers.beta]
+  ip = "10.0.0.2"
+  dc = "eqdc10"
+
+[clients]
+data = [ ["gamma", "delta"], [1, 2] ]
+
+# Line breaks are OK when inside arrays
+hosts = [
+  "alpha",
+  "omega"
+]
diff --git a/src/lake/tests/toml/tests/valid/spec/array-0.json b/src/lake/tests/toml/tests/valid/spec/array-0.json
new file mode 100644
index 0000000000..f150e9db0d
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/array-0.json
@@ -0,0 +1,146 @@
+{
+  "colors": [
+    {
+      "type": "string",
+      "value": "red"
+    },
+    {
+      "type": "string",
+      "value": "yellow"
+    },
+    {
+      "type": "string",
+      "value": "green"
+    }
+  ],
+  "contributors": [
+    {
+      "type": "string",
+      "value": "Foo Bar \u003cfoo@example.com\u003e"
+    },
+    {
+      "email": {
+        "type": "string",
+        "value": "bazqux@example.com"
+      },
+      "name": {
+        "type": "string",
+        "value": "Baz Qux"
+      },
+      "url": {
+        "type": "string",
+        "value": "https://example.com/bazqux"
+      }
+    }
+  ],
+  "integers": [
+    {
+      "type": "integer",
+      "value": "1"
+    },
+    {
+      "type": "integer",
+      "value": "2"
+    },
+    {
+      "type": "integer",
+      "value": "3"
+    }
+  ],
+  "nested_arrays_of_ints": [
+    [
+      {
+        "type": "integer",
+        "value": "1"
+      },
+      {
+        "type": "integer",
+        "value": "2"
+      }
+    ],
+    [
+      {
+        "type": "integer",
+        "value": "3"
+      },
+      {
+        "type": "integer",
+        "value": "4"
+      },
+      {
+        "type": "integer",
+        "value": "5"
+      }
+    ]
+  ],
+  "nested_mixed_array": [
+    [
+      {
+        "type": "integer",
+        "value": "1"
+      },
+      {
+        "type": "integer",
+        "value": "2"
+      }
+    ],
+    [
+      {
+        "type": "string",
+        "value": "a"
+      },
+      {
+        "type": "string",
+        "value": "b"
+      },
+      {
+        "type": "string",
+        "value": "c"
+      }
+    ]
+  ],
+  "numbers": [
+    {
+      "type": "float",
+      "value": "0.1"
+    },
+    {
+      "type": "float",
+      "value": "0.2"
+    },
+    {
+      "type": "float",
+      "value": "0.5"
+    },
+    {
+      "type": "integer",
+      "value": "1"
+    },
+    {
+      "type": "integer",
+      "value": "2"
+    },
+    {
+      "type": "integer",
+      "value": "5"
+    }
+  ],
+  "string_array": [
+    {
+      "type": "string",
+      "value": "all"
+    },
+    {
+      "type": "string",
+      "value": "strings"
+    },
+    {
+      "type": "string",
+      "value": "are the same"
+    },
+    {
+      "type": "string",
+      "value": "type"
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/array-0.toml b/src/lake/tests/toml/tests/valid/spec/array-0.toml
new file mode 100644
index 0000000000..467a8bc010
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/array-0.toml
@@ -0,0 +1,12 @@
+integers = [ 1, 2, 3 ]
+colors = [ "red", "yellow", "green" ]
+nested_arrays_of_ints = [ [ 1, 2 ], [3, 4, 5] ]
+nested_mixed_array = [ [ 1, 2 ], ["a", "b", "c"] ]
+string_array = [ "all", 'strings', """are the same""", '''type''' ]
+
+# Mixed-type arrays are allowed
+numbers = [ 0.1, 0.2, 0.5, 1, 2, 5 ]
+contributors = [
+  "Foo Bar <foo@example.com>",
+  { name = "Baz Qux", email = "bazqux@example.com", url = "https://example.com/bazqux" }
+]
diff --git a/src/lake/tests/toml/tests/valid/spec/array-1.json b/src/lake/tests/toml/tests/valid/spec/array-1.json
new file mode 100644
index 0000000000..334c333145
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/array-1.json
@@ -0,0 +1,26 @@
+{
+  "integers2": [
+    {
+      "type": "integer",
+      "value": "1"
+    },
+    {
+      "type": "integer",
+      "value": "2"
+    },
+    {
+      "type": "integer",
+      "value": "3"
+    }
+  ],
+  "integers3": [
+    {
+      "type": "integer",
+      "value": "1"
+    },
+    {
+      "type": "integer",
+      "value": "2"
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/array-1.toml b/src/lake/tests/toml/tests/valid/spec/array-1.toml
new file mode 100644
index 0000000000..6acd9ca261
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/array-1.toml
@@ -0,0 +1,8 @@
+integers2 = [
+  1, 2, 3
+]
+
+integers3 = [
+  1,
+  2, # this is ok
+]
diff --git a/src/lake/tests/toml/tests/valid/spec/array-of-tables-0.json b/src/lake/tests/toml/tests/valid/spec/array-of-tables-0.json
new file mode 100644
index 0000000000..23287571cb
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/array-of-tables-0.json
@@ -0,0 +1,29 @@
+{
+  "products": [
+    {
+      "name": {
+        "type": "string",
+        "value": "Hammer"
+      },
+      "sku": {
+        "type": "integer",
+        "value": "738594937"
+      }
+    },
+    {},
+    {
+      "color": {
+        "type": "string",
+        "value": "gray"
+      },
+      "name": {
+        "type": "string",
+        "value": "Nail"
+      },
+      "sku": {
+        "type": "integer",
+        "value": "284758393"
+      }
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/array-of-tables-0.toml b/src/lake/tests/toml/tests/valid/spec/array-of-tables-0.toml
new file mode 100644
index 0000000000..544d142d4a
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/array-of-tables-0.toml
@@ -0,0 +1,11 @@
+[[products]]
+name = "Hammer"
+sku = 738594937
+
+[[products]]  # empty table within the array
+
+[[products]]
+name = "Nail"
+sku = 284758393
+
+color = "gray"
diff --git a/src/lake/tests/toml/tests/valid/spec/array-of-tables-1.json b/src/lake/tests/toml/tests/valid/spec/array-of-tables-1.json
new file mode 100644
index 0000000000..17d491870e
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/array-of-tables-1.json
@@ -0,0 +1,48 @@
+{
+  "fruits": [
+    {
+      "name": {
+        "type": "string",
+        "value": "apple"
+      },
+      "physical": {
+        "color": {
+          "type": "string",
+          "value": "red"
+        },
+        "shape": {
+          "type": "string",
+          "value": "round"
+        }
+      },
+      "varieties": [
+        {
+          "name": {
+            "type": "string",
+            "value": "red delicious"
+          }
+        },
+        {
+          "name": {
+            "type": "string",
+            "value": "granny smith"
+          }
+        }
+      ]
+    },
+    {
+      "name": {
+        "type": "string",
+        "value": "banana"
+      },
+      "varieties": [
+        {
+          "name": {
+            "type": "string",
+            "value": "plantain"
+          }
+        }
+      ]
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/array-of-tables-1.toml b/src/lake/tests/toml/tests/valid/spec/array-of-tables-1.toml
new file mode 100644
index 0000000000..7a3971f3f5
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/array-of-tables-1.toml
@@ -0,0 +1,19 @@
+[[fruits]]
+name = "apple"
+
+[fruits.physical]  # subtable
+color = "red"
+shape = "round"
+
+[[fruits.varieties]]  # nested array of tables
+name = "red delicious"
+
+[[fruits.varieties]]
+name = "granny smith"
+
+
+[[fruits]]
+name = "banana"
+
+[[fruits.varieties]]
+name = "plantain"
diff --git a/src/lake/tests/toml/tests/valid/spec/array-of-tables-2.json b/src/lake/tests/toml/tests/valid/spec/array-of-tables-2.json
new file mode 100644
index 0000000000..f2e3f36786
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/array-of-tables-2.json
@@ -0,0 +1,46 @@
+{
+  "points": [
+    {
+      "x": {
+        "type": "integer",
+        "value": "1"
+      },
+      "y": {
+        "type": "integer",
+        "value": "2"
+      },
+      "z": {
+        "type": "integer",
+        "value": "3"
+      }
+    },
+    {
+      "x": {
+        "type": "integer",
+        "value": "7"
+      },
+      "y": {
+        "type": "integer",
+        "value": "8"
+      },
+      "z": {
+        "type": "integer",
+        "value": "9"
+      }
+    },
+    {
+      "x": {
+        "type": "integer",
+        "value": "2"
+      },
+      "y": {
+        "type": "integer",
+        "value": "4"
+      },
+      "z": {
+        "type": "integer",
+        "value": "8"
+      }
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/array-of-tables-2.toml b/src/lake/tests/toml/tests/valid/spec/array-of-tables-2.toml
new file mode 100644
index 0000000000..ba5584af5e
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/array-of-tables-2.toml
@@ -0,0 +1,3 @@
+points = [ { x = 1, y = 2, z = 3 },
+           { x = 7, y = 8, z = 9 },
+           { x = 2, y = 4, z = 8 } ]
diff --git a/src/lake/tests/toml/tests/valid/spec/boolean-0.json b/src/lake/tests/toml/tests/valid/spec/boolean-0.json
new file mode 100644
index 0000000000..f956ec02d8
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/boolean-0.json
@@ -0,0 +1,10 @@
+{
+  "bool1": {
+    "type": "bool",
+    "value": "true"
+  },
+  "bool2": {
+    "type": "bool",
+    "value": "false"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/boolean-0.toml b/src/lake/tests/toml/tests/valid/spec/boolean-0.toml
new file mode 100644
index 0000000000..1f80fbd1df
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/boolean-0.toml
@@ -0,0 +1,2 @@
+bool1 = true
+bool2 = false
diff --git a/src/lake/tests/toml/tests/valid/spec/comment-0.json b/src/lake/tests/toml/tests/valid/spec/comment-0.json
new file mode 100644
index 0000000000..d97960796e
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/comment-0.json
@@ -0,0 +1,10 @@
+{
+  "another": {
+    "type": "string",
+    "value": "# This is not a comment"
+  },
+  "key": {
+    "type": "string",
+    "value": "value"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/comment-0.toml b/src/lake/tests/toml/tests/valid/spec/comment-0.toml
new file mode 100644
index 0000000000..fae57c6019
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/comment-0.toml
@@ -0,0 +1,3 @@
+# This is a full-line comment
+key = "value"  # This is a comment at the end of a line
+another = "# This is not a comment"
diff --git a/src/lake/tests/toml/tests/valid/spec/float-0.json b/src/lake/tests/toml/tests/valid/spec/float-0.json
new file mode 100644
index 0000000000..ae7d5a5c84
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/float-0.json
@@ -0,0 +1,30 @@
+{
+  "flt1": {
+    "type": "float",
+    "value": "1"
+  },
+  "flt2": {
+    "type": "float",
+    "value": "3.1415"
+  },
+  "flt3": {
+    "type": "float",
+    "value": "-0.01"
+  },
+  "flt4": {
+    "type": "float",
+    "value": "5e+22"
+  },
+  "flt5": {
+    "type": "float",
+    "value": "1e+06"
+  },
+  "flt6": {
+    "type": "float",
+    "value": "-0.02"
+  },
+  "flt7": {
+    "type": "float",
+    "value": "6.626e-34"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/float-0.toml b/src/lake/tests/toml/tests/valid/spec/float-0.toml
new file mode 100644
index 0000000000..7b29c6558c
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/float-0.toml
@@ -0,0 +1,12 @@
+# fractional
+flt1 = +1.0
+flt2 = 3.1415
+flt3 = -0.01
+
+# exponent
+flt4 = 5e+22
+flt5 = 1e06
+flt6 = -2E-2
+
+# both
+flt7 = 6.626e-34
diff --git a/src/lake/tests/toml/tests/valid/spec/float-1.json b/src/lake/tests/toml/tests/valid/spec/float-1.json
new file mode 100644
index 0000000000..592a4d2ef0
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/float-1.json
@@ -0,0 +1,6 @@
+{
+  "flt8": {
+    "type": "float",
+    "value": "224617.445991228"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/float-1.toml b/src/lake/tests/toml/tests/valid/spec/float-1.toml
new file mode 100644
index 0000000000..3c8f0aa554
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/float-1.toml
@@ -0,0 +1 @@
+flt8 = 224_617.445_991_228
diff --git a/src/lake/tests/toml/tests/valid/spec/float-2.json b/src/lake/tests/toml/tests/valid/spec/float-2.json
new file mode 100644
index 0000000000..95077204b6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/float-2.json
@@ -0,0 +1,26 @@
+{
+  "sf1": {
+    "type": "float",
+    "value": "+Inf"
+  },
+  "sf2": {
+    "type": "float",
+    "value": "+Inf"
+  },
+  "sf3": {
+    "type": "float",
+    "value": "-Inf"
+  },
+  "sf4": {
+    "type": "float",
+    "value": "nan"
+  },
+  "sf5": {
+    "type": "float",
+    "value": "nan"
+  },
+  "sf6": {
+    "type": "float",
+    "value": "nan"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/float-2.toml b/src/lake/tests/toml/tests/valid/spec/float-2.toml
new file mode 100644
index 0000000000..4cede55d8a
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/float-2.toml
@@ -0,0 +1,9 @@
+# infinity
+sf1 = inf  # positive infinity
+sf2 = +inf # positive infinity
+sf3 = -inf # negative infinity
+
+# not a number
+sf4 = nan  # actual sNaN/qNaN encoding is implementation-specific
+sf5 = +nan # same as `nan`
+sf6 = -nan # valid, actual encoding is implementation-specific
diff --git a/src/lake/tests/toml/tests/valid/spec/inline-table-0.json b/src/lake/tests/toml/tests/valid/spec/inline-table-0.json
new file mode 100644
index 0000000000..8c0d315086
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/inline-table-0.json
@@ -0,0 +1,30 @@
+{
+  "animal": {
+    "type": {
+      "name": {
+        "type": "string",
+        "value": "pug"
+      }
+    }
+  },
+  "name": {
+    "first": {
+      "type": "string",
+      "value": "Tom"
+    },
+    "last": {
+      "type": "string",
+      "value": "Preston-Werner"
+    }
+  },
+  "point": {
+    "x": {
+      "type": "integer",
+      "value": "1"
+    },
+    "y": {
+      "type": "integer",
+      "value": "2"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/inline-table-0.toml b/src/lake/tests/toml/tests/valid/spec/inline-table-0.toml
new file mode 100644
index 0000000000..26062b5173
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/inline-table-0.toml
@@ -0,0 +1,3 @@
+name = { first = "Tom", last = "Preston-Werner" }
+point = { x = 1, y = 2 }
+animal = { type.name = "pug" }
diff --git a/src/lake/tests/toml/tests/valid/spec/inline-table-1.json b/src/lake/tests/toml/tests/valid/spec/inline-table-1.json
new file mode 100644
index 0000000000..8c0d315086
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/inline-table-1.json
@@ -0,0 +1,30 @@
+{
+  "animal": {
+    "type": {
+      "name": {
+        "type": "string",
+        "value": "pug"
+      }
+    }
+  },
+  "name": {
+    "first": {
+      "type": "string",
+      "value": "Tom"
+    },
+    "last": {
+      "type": "string",
+      "value": "Preston-Werner"
+    }
+  },
+  "point": {
+    "x": {
+      "type": "integer",
+      "value": "1"
+    },
+    "y": {
+      "type": "integer",
+      "value": "2"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/inline-table-1.toml b/src/lake/tests/toml/tests/valid/spec/inline-table-1.toml
new file mode 100644
index 0000000000..6f72155fa4
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/inline-table-1.toml
@@ -0,0 +1,10 @@
+[name]
+first = "Tom"
+last = "Preston-Werner"
+
+[point]
+x = 1
+y = 2
+
+[animal]
+type.name = "pug"
diff --git a/src/lake/tests/toml/tests/valid/spec/inline-table-2.json b/src/lake/tests/toml/tests/valid/spec/inline-table-2.json
new file mode 100644
index 0000000000..406691d126
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/inline-table-2.json
@@ -0,0 +1,10 @@
+{
+  "product": {
+    "type": {
+      "name": {
+        "type": "string",
+        "value": "Nail"
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/inline-table-2.toml b/src/lake/tests/toml/tests/valid/spec/inline-table-2.toml
new file mode 100644
index 0000000000..aabb500567
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/inline-table-2.toml
@@ -0,0 +1,3 @@
+[product]
+type = { name = "Nail" }
+# type.edible = false  # INVALID
diff --git a/src/lake/tests/toml/tests/valid/spec/inline-table-3.json b/src/lake/tests/toml/tests/valid/spec/inline-table-3.json
new file mode 100644
index 0000000000..406691d126
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/inline-table-3.json
@@ -0,0 +1,10 @@
+{
+  "product": {
+    "type": {
+      "name": {
+        "type": "string",
+        "value": "Nail"
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/inline-table-3.toml b/src/lake/tests/toml/tests/valid/spec/inline-table-3.toml
new file mode 100644
index 0000000000..970949c392
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/inline-table-3.toml
@@ -0,0 +1,3 @@
+[product]
+type.name = "Nail"
+# type = { edible = false }  # INVALID
diff --git a/src/lake/tests/toml/tests/valid/spec/integer-0.json b/src/lake/tests/toml/tests/valid/spec/integer-0.json
new file mode 100644
index 0000000000..72cbbbbfed
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/integer-0.json
@@ -0,0 +1,18 @@
+{
+  "int1": {
+    "type": "integer",
+    "value": "99"
+  },
+  "int2": {
+    "type": "integer",
+    "value": "42"
+  },
+  "int3": {
+    "type": "integer",
+    "value": "0"
+  },
+  "int4": {
+    "type": "integer",
+    "value": "-17"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/integer-0.toml b/src/lake/tests/toml/tests/valid/spec/integer-0.toml
new file mode 100644
index 0000000000..da14ea2afe
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/integer-0.toml
@@ -0,0 +1,4 @@
+int1 = +99
+int2 = 42
+int3 = 0
+int4 = -17
diff --git a/src/lake/tests/toml/tests/valid/spec/integer-1.json b/src/lake/tests/toml/tests/valid/spec/integer-1.json
new file mode 100644
index 0000000000..f431f47d82
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/integer-1.json
@@ -0,0 +1,18 @@
+{
+  "int5": {
+    "type": "integer",
+    "value": "1000"
+  },
+  "int6": {
+    "type": "integer",
+    "value": "5349221"
+  },
+  "int7": {
+    "type": "integer",
+    "value": "5349221"
+  },
+  "int8": {
+    "type": "integer",
+    "value": "12345"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/integer-1.toml b/src/lake/tests/toml/tests/valid/spec/integer-1.toml
new file mode 100644
index 0000000000..0c4b619096
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/integer-1.toml
@@ -0,0 +1,4 @@
+int5 = 1_000
+int6 = 5_349_221
+int7 = 53_49_221  # Indian number system grouping
+int8 = 1_2_3_4_5  # VALID but discouraged
diff --git a/src/lake/tests/toml/tests/valid/spec/integer-2.json b/src/lake/tests/toml/tests/valid/spec/integer-2.json
new file mode 100644
index 0000000000..b937b2b8fd
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/integer-2.json
@@ -0,0 +1,26 @@
+{
+  "bin1": {
+    "type": "integer",
+    "value": "214"
+  },
+  "hex1": {
+    "type": "integer",
+    "value": "3735928559"
+  },
+  "hex2": {
+    "type": "integer",
+    "value": "3735928559"
+  },
+  "hex3": {
+    "type": "integer",
+    "value": "3735928559"
+  },
+  "oct1": {
+    "type": "integer",
+    "value": "342391"
+  },
+  "oct2": {
+    "type": "integer",
+    "value": "493"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/integer-2.toml b/src/lake/tests/toml/tests/valid/spec/integer-2.toml
new file mode 100644
index 0000000000..ecffca634a
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/integer-2.toml
@@ -0,0 +1,11 @@
+# hexadecimal with prefix `0x`
+hex1 = 0xDEADBEEF
+hex2 = 0xdeadbeef
+hex3 = 0xdead_beef
+
+# octal with prefix `0o`
+oct1 = 0o01234567
+oct2 = 0o755 # useful for Unix file permissions
+
+# binary with prefix `0b`
+bin1 = 0b11010110
diff --git a/src/lake/tests/toml/tests/valid/spec/key-value-pair-0.json b/src/lake/tests/toml/tests/valid/spec/key-value-pair-0.json
new file mode 100644
index 0000000000..af3154ab4c
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/key-value-pair-0.json
@@ -0,0 +1,6 @@
+{
+  "key": {
+    "type": "string",
+    "value": "value"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/key-value-pair-0.toml b/src/lake/tests/toml/tests/valid/spec/key-value-pair-0.toml
new file mode 100644
index 0000000000..e5b34ebccc
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/key-value-pair-0.toml
@@ -0,0 +1 @@
+key = "value"
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-0.json b/src/lake/tests/toml/tests/valid/spec/keys-0.json
new file mode 100644
index 0000000000..6130c71d9d
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-0.json
@@ -0,0 +1,18 @@
+{
+  "1234": {
+    "type": "string",
+    "value": "value"
+  },
+  "bare-key": {
+    "type": "string",
+    "value": "value"
+  },
+  "bare_key": {
+    "type": "string",
+    "value": "value"
+  },
+  "key": {
+    "type": "string",
+    "value": "value"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-0.toml b/src/lake/tests/toml/tests/valid/spec/keys-0.toml
new file mode 100644
index 0000000000..657ff2415c
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-0.toml
@@ -0,0 +1,4 @@
+key = "value"
+bare_key = "value"
+bare-key = "value"
+1234 = "value"
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-1.json b/src/lake/tests/toml/tests/valid/spec/keys-1.json
new file mode 100644
index 0000000000..fb756032f3
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-1.json
@@ -0,0 +1,22 @@
+{
+  "127.0.0.1": {
+    "type": "string",
+    "value": "value"
+  },
+  "character encoding": {
+    "type": "string",
+    "value": "value"
+  },
+  "key2": {
+    "type": "string",
+    "value": "value"
+  },
+  "quoted \"value\"": {
+    "type": "string",
+    "value": "value"
+  },
+  "ʎǝʞ": {
+    "type": "string",
+    "value": "value"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-1.toml b/src/lake/tests/toml/tests/valid/spec/keys-1.toml
new file mode 100644
index 0000000000..cc2d1d006d
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-1.toml
@@ -0,0 +1,5 @@
+"127.0.0.1" = "value"
+"character encoding" = "value"
+"ʎǝʞ" = "value"
+'key2' = "value"
+'quoted "value"' = "value"
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-3.json b/src/lake/tests/toml/tests/valid/spec/keys-3.json
new file mode 100644
index 0000000000..b8ee719311
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-3.json
@@ -0,0 +1,22 @@
+{
+  "name": {
+    "type": "string",
+    "value": "Orange"
+  },
+  "physical": {
+    "color": {
+      "type": "string",
+      "value": "orange"
+    },
+    "shape": {
+      "type": "string",
+      "value": "round"
+    }
+  },
+  "site": {
+    "google.com": {
+      "type": "bool",
+      "value": "true"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-3.toml b/src/lake/tests/toml/tests/valid/spec/keys-3.toml
new file mode 100644
index 0000000000..8f83571347
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-3.toml
@@ -0,0 +1,4 @@
+name = "Orange"
+physical.color = "orange"
+physical.shape = "round"
+site."google.com" = true
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-4.json b/src/lake/tests/toml/tests/valid/spec/keys-4.json
new file mode 100644
index 0000000000..c33966a597
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-4.json
@@ -0,0 +1,16 @@
+{
+  "fruit": {
+    "color": {
+      "type": "string",
+      "value": "yellow"
+    },
+    "flavor": {
+      "type": "string",
+      "value": "banana"
+    },
+    "name": {
+      "type": "string",
+      "value": "banana"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-4.toml b/src/lake/tests/toml/tests/valid/spec/keys-4.toml
new file mode 100644
index 0000000000..75bf90b568
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-4.toml
@@ -0,0 +1,3 @@
+fruit.name = "banana"     # this is best practice
+fruit. color = "yellow"    # same as fruit.color
+fruit . flavor = "banana"   # same as fruit.flavor
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-5.json b/src/lake/tests/toml/tests/valid/spec/keys-5.json
new file mode 100644
index 0000000000..482b362d0b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-5.json
@@ -0,0 +1,30 @@
+{
+  "apple": {
+    "color": {
+      "type": "string",
+      "value": "red"
+    },
+    "skin": {
+      "type": "string",
+      "value": "thin"
+    },
+    "type": {
+      "type": "string",
+      "value": "fruit"
+    }
+  },
+  "orange": {
+    "color": {
+      "type": "string",
+      "value": "orange"
+    },
+    "skin": {
+      "type": "string",
+      "value": "thick"
+    },
+    "type": {
+      "type": "string",
+      "value": "fruit"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-5.toml b/src/lake/tests/toml/tests/valid/spec/keys-5.toml
new file mode 100644
index 0000000000..dc94a8c941
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-5.toml
@@ -0,0 +1,10 @@
+# VALID BUT DISCOURAGED
+
+apple.type = "fruit"
+orange.type = "fruit"
+
+apple.skin = "thin"
+orange.skin = "thick"
+
+apple.color = "red"
+orange.color = "orange"
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-6.json b/src/lake/tests/toml/tests/valid/spec/keys-6.json
new file mode 100644
index 0000000000..482b362d0b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-6.json
@@ -0,0 +1,30 @@
+{
+  "apple": {
+    "color": {
+      "type": "string",
+      "value": "red"
+    },
+    "skin": {
+      "type": "string",
+      "value": "thin"
+    },
+    "type": {
+      "type": "string",
+      "value": "fruit"
+    }
+  },
+  "orange": {
+    "color": {
+      "type": "string",
+      "value": "orange"
+    },
+    "skin": {
+      "type": "string",
+      "value": "thick"
+    },
+    "type": {
+      "type": "string",
+      "value": "fruit"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-6.toml b/src/lake/tests/toml/tests/valid/spec/keys-6.toml
new file mode 100644
index 0000000000..705686c94f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-6.toml
@@ -0,0 +1,9 @@
+# RECOMMENDED
+
+apple.type = "fruit"
+apple.skin = "thin"
+apple.color = "red"
+
+orange.type = "fruit"
+orange.skin = "thick"
+orange.color = "orange"
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-7.json b/src/lake/tests/toml/tests/valid/spec/keys-7.json
new file mode 100644
index 0000000000..5ab0e06601
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-7.json
@@ -0,0 +1,8 @@
+{
+  "3": {
+    "14159": {
+      "type": "string",
+      "value": "pi"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/keys-7.toml b/src/lake/tests/toml/tests/valid/spec/keys-7.toml
new file mode 100644
index 0000000000..2efd659b8d
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/keys-7.toml
@@ -0,0 +1 @@
+3.14159 = "pi"
diff --git a/src/lake/tests/toml/tests/valid/spec/local-date-0.json b/src/lake/tests/toml/tests/valid/spec/local-date-0.json
new file mode 100644
index 0000000000..9e281f54d7
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/local-date-0.json
@@ -0,0 +1,6 @@
+{
+  "ld1": {
+    "type": "date-local",
+    "value": "1979-05-27"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/local-date-0.toml b/src/lake/tests/toml/tests/valid/spec/local-date-0.toml
new file mode 100644
index 0000000000..6670e5dd99
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/local-date-0.toml
@@ -0,0 +1 @@
+ld1 = 1979-05-27
diff --git a/src/lake/tests/toml/tests/valid/spec/local-date-time-0.json b/src/lake/tests/toml/tests/valid/spec/local-date-time-0.json
new file mode 100644
index 0000000000..d42d49d6f8
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/local-date-time-0.json
@@ -0,0 +1,10 @@
+{
+  "ldt1": {
+    "type": "datetime-local",
+    "value": "1979-05-27T07:32:00"
+  },
+  "ldt2": {
+    "type": "datetime-local",
+    "value": "1979-05-27T00:32:00.999999"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/local-date-time-0.toml b/src/lake/tests/toml/tests/valid/spec/local-date-time-0.toml
new file mode 100644
index 0000000000..38700d210f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/local-date-time-0.toml
@@ -0,0 +1,2 @@
+ldt1 = 1979-05-27T07:32:00
+ldt2 = 1979-05-27T00:32:00.999999
diff --git a/src/lake/tests/toml/tests/valid/spec/local-time-0.json b/src/lake/tests/toml/tests/valid/spec/local-time-0.json
new file mode 100644
index 0000000000..93803fc3c4
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/local-time-0.json
@@ -0,0 +1,10 @@
+{
+  "lt1": {
+    "type": "time-local",
+    "value": "07:32:00"
+  },
+  "lt2": {
+    "type": "time-local",
+    "value": "00:32:00.999999"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/local-time-0.toml b/src/lake/tests/toml/tests/valid/spec/local-time-0.toml
new file mode 100644
index 0000000000..dbd058a687
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/local-time-0.toml
@@ -0,0 +1,2 @@
+lt1 = 07:32:00
+lt2 = 00:32:00.999999
diff --git a/src/lake/tests/toml/tests/valid/spec/offset-date-time-0.json b/src/lake/tests/toml/tests/valid/spec/offset-date-time-0.json
new file mode 100644
index 0000000000..26d59a8cec
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/offset-date-time-0.json
@@ -0,0 +1,14 @@
+{
+  "odt1": {
+    "type": "datetime",
+    "value": "1979-05-27T07:32:00Z"
+  },
+  "odt2": {
+    "type": "datetime",
+    "value": "1979-05-27T00:32:00-07:00"
+  },
+  "odt3": {
+    "type": "datetime",
+    "value": "1979-05-27T00:32:00.999999-07:00"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/offset-date-time-0.toml b/src/lake/tests/toml/tests/valid/spec/offset-date-time-0.toml
new file mode 100644
index 0000000000..52eaff2f25
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/offset-date-time-0.toml
@@ -0,0 +1,3 @@
+odt1 = 1979-05-27T07:32:00Z
+odt2 = 1979-05-27T00:32:00-07:00
+odt3 = 1979-05-27T00:32:00.999999-07:00
diff --git a/src/lake/tests/toml/tests/valid/spec/offset-date-time-1.json b/src/lake/tests/toml/tests/valid/spec/offset-date-time-1.json
new file mode 100644
index 0000000000..fa17a4ea44
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/offset-date-time-1.json
@@ -0,0 +1,6 @@
+{
+  "odt4": {
+    "type": "datetime",
+    "value": "1979-05-27T07:32:00Z"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/offset-date-time-1.toml b/src/lake/tests/toml/tests/valid/spec/offset-date-time-1.toml
new file mode 100644
index 0000000000..da9bd3bc58
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/offset-date-time-1.toml
@@ -0,0 +1 @@
+odt4 = 1979-05-27 07:32:00Z
diff --git a/src/lake/tests/toml/tests/valid/spec/string-0.json b/src/lake/tests/toml/tests/valid/spec/string-0.json
new file mode 100644
index 0000000000..3c26fa1783
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-0.json
@@ -0,0 +1,6 @@
+{
+  "str": {
+    "type": "string",
+    "value": "I'm a string. \"You can quote me\". Name\tJosé\nLocation\tSF."
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/string-0.toml b/src/lake/tests/toml/tests/valid/spec/string-0.toml
new file mode 100644
index 0000000000..b611549024
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-0.toml
@@ -0,0 +1 @@
+str = "I'm a string. \"You can quote me\". Name\tJos\u00E9\nLocation\tSF."
diff --git a/src/lake/tests/toml/tests/valid/spec/string-1.json b/src/lake/tests/toml/tests/valid/spec/string-1.json
new file mode 100644
index 0000000000..316d0f4e32
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-1.json
@@ -0,0 +1,6 @@
+{
+  "str1": {
+    "type": "string",
+    "value": "Roses are red\nViolets are blue"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/string-1.toml b/src/lake/tests/toml/tests/valid/spec/string-1.toml
new file mode 100644
index 0000000000..337ad080be
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-1.toml
@@ -0,0 +1,3 @@
+str1 = """
+Roses are red
+Violets are blue"""
diff --git a/src/lake/tests/toml/tests/valid/spec/string-2.json b/src/lake/tests/toml/tests/valid/spec/string-2.json
new file mode 100644
index 0000000000..09faeb6bc1
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-2.json
@@ -0,0 +1,10 @@
+{
+  "str2": {
+    "type": "string",
+    "value": "Roses are red\nViolets are blue"
+  },
+  "str3": {
+    "type": "string",
+    "value": "Roses are red\r\nViolets are blue"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/string-2.toml b/src/lake/tests/toml/tests/valid/spec/string-2.toml
new file mode 100644
index 0000000000..ce5a73be94
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-2.toml
@@ -0,0 +1,5 @@
+# On a Unix system, the above multi-line string will most likely be the same as:
+str2 = "Roses are red\nViolets are blue"
+
+# On a Windows system, it will most likely be equivalent to:
+str3 = "Roses are red\r\nViolets are blue"
diff --git a/src/lake/tests/toml/tests/valid/spec/string-3.json b/src/lake/tests/toml/tests/valid/spec/string-3.json
new file mode 100644
index 0000000000..c55424f71e
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-3.json
@@ -0,0 +1,14 @@
+{
+  "str1": {
+    "type": "string",
+    "value": "The quick brown fox jumps over the lazy dog."
+  },
+  "str2": {
+    "type": "string",
+    "value": "The quick brown fox jumps over the lazy dog."
+  },
+  "str3": {
+    "type": "string",
+    "value": "The quick brown fox jumps over the lazy dog."
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/string-3.toml b/src/lake/tests/toml/tests/valid/spec/string-3.toml
new file mode 100644
index 0000000000..20b4aa7c98
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-3.toml
@@ -0,0 +1,15 @@
+# The following strings are byte-for-byte equivalent:
+str1 = "The quick brown fox jumps over the lazy dog."
+
+str2 = """
+The quick brown \
+
+
+  fox jumps over \
+    the lazy dog."""
+
+str3 = """\
+       The quick brown \
+       fox jumps over \
+       the lazy dog.\
+       """
diff --git a/src/lake/tests/toml/tests/valid/spec/string-4.json b/src/lake/tests/toml/tests/valid/spec/string-4.json
new file mode 100644
index 0000000000..52ddb1972b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-4.json
@@ -0,0 +1,18 @@
+{
+  "str4": {
+    "type": "string",
+    "value": "Here are two quotation marks: \"\". Simple enough."
+  },
+  "str5": {
+    "type": "string",
+    "value": "Here are three quotation marks: \"\"\"."
+  },
+  "str6": {
+    "type": "string",
+    "value": "Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\"."
+  },
+  "str7": {
+    "type": "string",
+    "value": "\"This,\" she said, \"is just a pointless statement.\""
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/string-4.toml b/src/lake/tests/toml/tests/valid/spec/string-4.toml
new file mode 100644
index 0000000000..8f51b11799
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-4.toml
@@ -0,0 +1,7 @@
+str4 = """Here are two quotation marks: "". Simple enough."""
+# str5 = """Here are three quotation marks: """."""  # INVALID
+str5 = """Here are three quotation marks: ""\"."""
+str6 = """Here are fifteen quotation marks: ""\"""\"""\"""\"""\"."""
+
+# "This," she said, "is just a pointless statement."
+str7 = """"This," she said, "is just a pointless statement.""""
diff --git a/src/lake/tests/toml/tests/valid/spec/string-5.json b/src/lake/tests/toml/tests/valid/spec/string-5.json
new file mode 100644
index 0000000000..bce72d900c
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-5.json
@@ -0,0 +1,18 @@
+{
+  "quoted": {
+    "type": "string",
+    "value": "Tom \"Dubs\" Preston-Werner"
+  },
+  "regex": {
+    "type": "string",
+    "value": "\u003c\\i\\c*\\s*\u003e"
+  },
+  "winpath": {
+    "type": "string",
+    "value": "C:\\Users\\nodejs\\templates"
+  },
+  "winpath2": {
+    "type": "string",
+    "value": "\\\\ServerX\\admin$\\system32\\"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/string-5.toml b/src/lake/tests/toml/tests/valid/spec/string-5.toml
new file mode 100644
index 0000000000..36772bb6e7
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-5.toml
@@ -0,0 +1,5 @@
+# What you see is what you get.
+winpath  = 'C:\Users\nodejs\templates'
+winpath2 = '\\ServerX\admin$\system32\'
+quoted   = 'Tom "Dubs" Preston-Werner'
+regex    = '<\i\c*\s*>'
diff --git a/src/lake/tests/toml/tests/valid/spec/string-6.json b/src/lake/tests/toml/tests/valid/spec/string-6.json
new file mode 100644
index 0000000000..aa7663e09b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-6.json
@@ -0,0 +1,10 @@
+{
+  "lines": {
+    "type": "string",
+    "value": "The first newline is\ntrimmed in raw strings.\n   All other whitespace\n   is preserved.\n"
+  },
+  "regex2": {
+    "type": "string",
+    "value": "I [dw]on't need \\d{2} apples"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/string-6.toml b/src/lake/tests/toml/tests/valid/spec/string-6.toml
new file mode 100644
index 0000000000..bc88494c4d
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-6.toml
@@ -0,0 +1,7 @@
+regex2 = '''I [dw]on't need \d{2} apples'''
+lines  = '''
+The first newline is
+trimmed in raw strings.
+   All other whitespace
+   is preserved.
+'''
diff --git a/src/lake/tests/toml/tests/valid/spec/string-7.json b/src/lake/tests/toml/tests/valid/spec/string-7.json
new file mode 100644
index 0000000000..ad0fff21c9
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-7.json
@@ -0,0 +1,14 @@
+{
+  "apos15": {
+    "type": "string",
+    "value": "Here are fifteen apostrophes: '''''''''''''''"
+  },
+  "quot15": {
+    "type": "string",
+    "value": "Here are fifteen quotation marks: \"\"\"\"\"\"\"\"\"\"\"\"\"\"\""
+  },
+  "str": {
+    "type": "string",
+    "value": "'That,' she said, 'is still pointless.'"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/string-7.toml b/src/lake/tests/toml/tests/valid/spec/string-7.toml
new file mode 100644
index 0000000000..82890b08a1
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/string-7.toml
@@ -0,0 +1,7 @@
+quot15 = '''Here are fifteen quotation marks: """""""""""""""'''
+
+# apos15 = '''Here are fifteen apostrophes: ''''''''''''''''''  # INVALID
+apos15 = "Here are fifteen apostrophes: '''''''''''''''"
+
+# 'That,' she said, 'is still pointless.'
+str = ''''That,' she said, 'is still pointless.''''
diff --git a/src/lake/tests/toml/tests/valid/spec/table-0.json b/src/lake/tests/toml/tests/valid/spec/table-0.json
new file mode 100644
index 0000000000..b6e7fb5020
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-0.json
@@ -0,0 +1,3 @@
+{
+  "table": {}
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/table-0.toml b/src/lake/tests/toml/tests/valid/spec/table-0.toml
new file mode 100644
index 0000000000..f1098fdaca
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-0.toml
@@ -0,0 +1 @@
+[table]
diff --git a/src/lake/tests/toml/tests/valid/spec/table-1.json b/src/lake/tests/toml/tests/valid/spec/table-1.json
new file mode 100644
index 0000000000..f8521e0fd2
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-1.json
@@ -0,0 +1,22 @@
+{
+  "table-1": {
+    "key1": {
+      "type": "string",
+      "value": "some string"
+    },
+    "key2": {
+      "type": "integer",
+      "value": "123"
+    }
+  },
+  "table-2": {
+    "key1": {
+      "type": "string",
+      "value": "another string"
+    },
+    "key2": {
+      "type": "integer",
+      "value": "456"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/table-1.toml b/src/lake/tests/toml/tests/valid/spec/table-1.toml
new file mode 100644
index 0000000000..6b4884c2c6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-1.toml
@@ -0,0 +1,7 @@
+[table-1]
+key1 = "some string"
+key2 = 123
+
+[table-2]
+key1 = "another string"
+key2 = 456
diff --git a/src/lake/tests/toml/tests/valid/spec/table-2.json b/src/lake/tests/toml/tests/valid/spec/table-2.json
new file mode 100644
index 0000000000..afb74d593b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-2.json
@@ -0,0 +1,12 @@
+{
+  "dog": {
+    "tater.man": {
+      "type": {
+        "name": {
+          "type": "string",
+          "value": "pug"
+        }
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/table-2.toml b/src/lake/tests/toml/tests/valid/spec/table-2.toml
new file mode 100644
index 0000000000..32cbe7924b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-2.toml
@@ -0,0 +1,2 @@
+[dog."tater.man"]
+type.name = "pug"
diff --git a/src/lake/tests/toml/tests/valid/spec/table-3.json b/src/lake/tests/toml/tests/valid/spec/table-3.json
new file mode 100644
index 0000000000..0e40e3fd1b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-3.json
@@ -0,0 +1,22 @@
+{
+  "a": {
+    "b": {
+      "c": {}
+    }
+  },
+  "d": {
+    "e": {
+      "f": {}
+    }
+  },
+  "g": {
+    "h": {
+      "i": {}
+    }
+  },
+  "j": {
+    "ʞ": {
+      "l": {}
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/table-3.toml b/src/lake/tests/toml/tests/valid/spec/table-3.toml
new file mode 100644
index 0000000000..0b10db3a70
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-3.toml
@@ -0,0 +1,4 @@
+[a.b.c]            # this is best practice
+[ d.e.f ]          # same as [d.e.f]
+[ g .  h  . i ]    # same as [g.h.i]
+[ j . "ʞ" . 'l' ]  # same as [j."ʞ".'l']
diff --git a/src/lake/tests/toml/tests/valid/spec/table-4.json b/src/lake/tests/toml/tests/valid/spec/table-4.json
new file mode 100644
index 0000000000..3c390c682c
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-4.json
@@ -0,0 +1,9 @@
+{
+  "x": {
+    "y": {
+      "z": {
+        "w": {}
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/table-4.toml b/src/lake/tests/toml/tests/valid/spec/table-4.toml
new file mode 100644
index 0000000000..256e6c08d5
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-4.toml
@@ -0,0 +1,6 @@
+# [x] you
+# [x.y] don't
+# [x.y.z] need these
+[x.y.z.w] # for this to work
+
+[x] # defining a super-table afterward is ok
diff --git a/src/lake/tests/toml/tests/valid/spec/table-5.json b/src/lake/tests/toml/tests/valid/spec/table-5.json
new file mode 100644
index 0000000000..2ec8407154
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-5.json
@@ -0,0 +1,7 @@
+{
+  "animal": {},
+  "fruit": {
+    "apple": {},
+    "orange": {}
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/table-5.toml b/src/lake/tests/toml/tests/valid/spec/table-5.toml
new file mode 100644
index 0000000000..03fe3a3e4f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-5.toml
@@ -0,0 +1,4 @@
+# VALID BUT DISCOURAGED
+[fruit.apple]
+[animal]
+[fruit.orange]
diff --git a/src/lake/tests/toml/tests/valid/spec/table-6.json b/src/lake/tests/toml/tests/valid/spec/table-6.json
new file mode 100644
index 0000000000..2ec8407154
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-6.json
@@ -0,0 +1,7 @@
+{
+  "animal": {},
+  "fruit": {
+    "apple": {},
+    "orange": {}
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/table-6.toml b/src/lake/tests/toml/tests/valid/spec/table-6.toml
new file mode 100644
index 0000000000..ef330e40aa
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-6.toml
@@ -0,0 +1,4 @@
+# RECOMMENDED
+[fruit.apple]
+[fruit.orange]
+[animal]
diff --git a/src/lake/tests/toml/tests/valid/spec/table-7.json b/src/lake/tests/toml/tests/valid/spec/table-7.json
new file mode 100644
index 0000000000..3bdfe953e0
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-7.json
@@ -0,0 +1,20 @@
+{
+  "breed": {
+    "type": "string",
+    "value": "pug"
+  },
+  "name": {
+    "type": "string",
+    "value": "Fido"
+  },
+  "owner": {
+    "member_since": {
+      "type": "date-local",
+      "value": "1999-08-04"
+    },
+    "name": {
+      "type": "string",
+      "value": "Regina Dogman"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/table-7.toml b/src/lake/tests/toml/tests/valid/spec/table-7.toml
new file mode 100644
index 0000000000..c57a2294b2
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-7.toml
@@ -0,0 +1,8 @@
+# Top-level table begins.
+name = "Fido"
+breed = "pug"
+
+# Top-level table ends.
+[owner]
+name = "Regina Dogman"
+member_since = 1999-08-04
diff --git a/src/lake/tests/toml/tests/valid/spec/table-8.json b/src/lake/tests/toml/tests/valid/spec/table-8.json
new file mode 100644
index 0000000000..dd59a5182e
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-8.json
@@ -0,0 +1,16 @@
+{
+  "fruit": {
+    "apple": {
+      "color": {
+        "type": "string",
+        "value": "red"
+      },
+      "taste": {
+        "sweet": {
+          "type": "bool",
+          "value": "true"
+        }
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/table-8.toml b/src/lake/tests/toml/tests/valid/spec/table-8.toml
new file mode 100644
index 0000000000..d5a2c11fad
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-8.toml
@@ -0,0 +1,7 @@
+fruit.apple.color = "red"
+# Defines a table named fruit
+# Defines a table named fruit.apple
+
+fruit.apple.taste.sweet = true
+# Defines a table named fruit.apple.taste
+# fruit and fruit.apple were already created
diff --git a/src/lake/tests/toml/tests/valid/spec/table-9.json b/src/lake/tests/toml/tests/valid/spec/table-9.json
new file mode 100644
index 0000000000..89e8d5e5f4
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-9.json
@@ -0,0 +1,22 @@
+{
+  "fruit": {
+    "apple": {
+      "color": {
+        "type": "string",
+        "value": "red"
+      },
+      "taste": {
+        "sweet": {
+          "type": "bool",
+          "value": "true"
+        }
+      },
+      "texture": {
+        "smooth": {
+          "type": "bool",
+          "value": "true"
+        }
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/spec/table-9.toml b/src/lake/tests/toml/tests/valid/spec/table-9.toml
new file mode 100644
index 0000000000..ae2d65bb32
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/spec/table-9.toml
@@ -0,0 +1,9 @@
+[fruit]
+apple.color = "red"
+apple.taste.sweet = true
+
+# [fruit.apple]  # INVALID
+# [fruit.apple.taste]  # INVALID
+
+[fruit.apple.texture]  # you can add sub-tables
+smooth = true
diff --git a/src/lake/tests/toml/tests/valid/string/double-quote-escape.json b/src/lake/tests/toml/tests/valid/string/double-quote-escape.json
new file mode 100644
index 0000000000..0c4ac37e0a
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/double-quote-escape.json
@@ -0,0 +1,6 @@
+{
+  "test": {
+    "type": "string",
+    "value": "\"one\""
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/double-quote-escape.toml b/src/lake/tests/toml/tests/valid/string/double-quote-escape.toml
new file mode 100644
index 0000000000..78e7e72927
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/double-quote-escape.toml
@@ -0,0 +1 @@
+test = "\"one\""
diff --git a/src/lake/tests/toml/tests/valid/string/empty.json b/src/lake/tests/toml/tests/valid/string/empty.json
new file mode 100644
index 0000000000..efe96c3633
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/empty.json
@@ -0,0 +1,6 @@
+{
+  "answer": {
+    "type": "string",
+    "value": ""
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/empty.toml b/src/lake/tests/toml/tests/valid/string/empty.toml
new file mode 100644
index 0000000000..e37e6815bc
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/empty.toml
@@ -0,0 +1 @@
+answer = ""
diff --git a/src/lake/tests/toml/tests/valid/string/escape-tricky.json b/src/lake/tests/toml/tests/valid/string/escape-tricky.json
new file mode 100644
index 0000000000..572e0a569d
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/escape-tricky.json
@@ -0,0 +1,30 @@
+{
+  "end_esc": {
+    "type": "string",
+    "value": "String does not end here\" but ends here\\"
+  },
+  "lit_end_esc": {
+    "type": "string",
+    "value": "String ends here\\"
+  },
+  "lit_multiline_end": {
+    "type": "string",
+    "value": "There is no escape\\"
+  },
+  "lit_multiline_not_unicode": {
+    "type": "string",
+    "value": "\\u007f"
+  },
+  "multiline_end_esc": {
+    "type": "string",
+    "value": "When will it end? \"\"\"...\"\"\" should be here\""
+  },
+  "multiline_not_unicode": {
+    "type": "string",
+    "value": "\\u0041"
+  },
+  "multiline_unicode": {
+    "type": "string",
+    "value": " "
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/escape-tricky.toml b/src/lake/tests/toml/tests/valid/string/escape-tricky.toml
new file mode 100644
index 0000000000..dc204cb3fa
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/escape-tricky.toml
@@ -0,0 +1,15 @@
+end_esc = "String does not end here\" but ends here\\"
+lit_end_esc = 'String ends here\'
+
+multiline_unicode = """
+\u00a0"""
+
+multiline_not_unicode = """
+\\u0041"""
+
+multiline_end_esc = """When will it end? \"""...""\" should be here\""""
+
+lit_multiline_not_unicode = '''
+\u007f'''
+
+lit_multiline_end = '''There is no escape\'''
diff --git a/src/lake/tests/toml/tests/valid/string/escaped-escape.json b/src/lake/tests/toml/tests/valid/string/escaped-escape.json
new file mode 100644
index 0000000000..112c0c9772
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/escaped-escape.json
@@ -0,0 +1,6 @@
+{
+  "answer": {
+    "type": "string",
+    "value": "\\x64"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/escaped-escape.toml b/src/lake/tests/toml/tests/valid/string/escaped-escape.toml
new file mode 100644
index 0000000000..d575876145
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/escaped-escape.toml
@@ -0,0 +1 @@
+answer = "\\x64"
diff --git a/src/lake/tests/toml/tests/valid/string/escapes.json b/src/lake/tests/toml/tests/valid/string/escapes.json
new file mode 100644
index 0000000000..d849574ac3
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/escapes.json
@@ -0,0 +1,54 @@
+{
+  "backslash": {
+    "type": "string",
+    "value": "This string has a \\ backslash character."
+  },
+  "backspace": {
+    "type": "string",
+    "value": "This string has a \u0008 backspace character."
+  },
+  "carriage": {
+    "type": "string",
+    "value": "This string has a \r carriage return character."
+  },
+  "delete": {
+    "type": "string",
+    "value": "This string has a  delete control code."
+  },
+  "formfeed": {
+    "type": "string",
+    "value": "This string has a \u000c form feed character."
+  },
+  "newline": {
+    "type": "string",
+    "value": "This string has a \n new line character."
+  },
+  "notunicode1": {
+    "type": "string",
+    "value": "This string does not have a unicode \\u escape."
+  },
+  "notunicode2": {
+    "type": "string",
+    "value": "This string does not have a unicode \\u escape."
+  },
+  "notunicode3": {
+    "type": "string",
+    "value": "This string does not have a unicode \\u0075 escape."
+  },
+  "notunicode4": {
+    "type": "string",
+    "value": "This string does not have a unicode \\u escape."
+  },
+  "quote": {
+    "type": "string",
+    "value": "This string has a \" quote character."
+  },
+  "tab": {
+    "type": "string",
+    "value": "This string has a \t tab character."
+  },
+  "unitseparator": {
+    "type": "string",
+    "value": "This string has a \u001f unit separator control code."
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/escapes.toml b/src/lake/tests/toml/tests/valid/string/escapes.toml
new file mode 100644
index 0000000000..78f7ebdf43
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/escapes.toml
@@ -0,0 +1,13 @@
+backspace = "This string has a \b backspace character."
+tab = "This string has a \t tab character."
+newline = "This string has a \n new line character."
+formfeed = "This string has a \f form feed character."
+carriage = "This string has a \r carriage return character."
+quote = "This string has a \" quote character."
+backslash = "This string has a \\ backslash character."
+notunicode1 = "This string does not have a unicode \\u escape."
+notunicode2 = "This string does not have a unicode \u005Cu escape."
+notunicode3 = "This string does not have a unicode \\u0075 escape."
+notunicode4 = "This string does not have a unicode \\\u0075 escape."
+delete = "This string has a \u007F delete control code."
+unitseparator = "This string has a \u001F unit separator control code."
diff --git a/src/lake/tests/toml/tests/valid/string/multiline-escaped-crlf.json b/src/lake/tests/toml/tests/valid/string/multiline-escaped-crlf.json
new file mode 100644
index 0000000000..aa5e3eed4a
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/multiline-escaped-crlf.json
@@ -0,0 +1,6 @@
+{
+  "0": {
+    "type": "string",
+    "value": ""
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/multiline-escaped-crlf.toml b/src/lake/tests/toml/tests/valid/string/multiline-escaped-crlf.toml
new file mode 100644
index 0000000000..97d697de37
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/multiline-escaped-crlf.toml
@@ -0,0 +1,4 @@
+# The following line should be an unescaped backslash followed by a Windows
+# newline sequence ("\r\n")
+0="""\
+"""
diff --git a/src/lake/tests/toml/tests/valid/string/multiline-quotes.json b/src/lake/tests/toml/tests/valid/string/multiline-quotes.json
new file mode 100644
index 0000000000..af9c4c80f6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/multiline-quotes.json
@@ -0,0 +1,46 @@
+{
+  "escaped": {
+    "type": "string",
+    "value": "lol\"\"\""
+  },
+  "lit_one": {
+    "type": "string",
+    "value": "'one quote'"
+  },
+  "lit_one_space": {
+    "type": "string",
+    "value": " 'one quote' "
+  },
+  "lit_two": {
+    "type": "string",
+    "value": "''two quotes''"
+  },
+  "lit_two_space": {
+    "type": "string",
+    "value": " ''two quotes'' "
+  },
+  "mismatch1": {
+    "type": "string",
+    "value": "aaa'''bbb"
+  },
+  "mismatch2": {
+    "type": "string",
+    "value": "aaa\"\"\"bbb"
+  },
+  "one": {
+    "type": "string",
+    "value": "\"one quote\""
+  },
+  "one_space": {
+    "type": "string",
+    "value": " \"one quote\" "
+  },
+  "two": {
+    "type": "string",
+    "value": "\"\"two quotes\"\""
+  },
+  "two_space": {
+    "type": "string",
+    "value": " \"\"two quotes\"\" "
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/multiline-quotes.toml b/src/lake/tests/toml/tests/valid/string/multiline-quotes.toml
new file mode 100644
index 0000000000..085e127f2e
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/multiline-quotes.toml
@@ -0,0 +1,19 @@
+# Make sure that quotes inside multiline strings are allowed, including right
+# after the opening '''/""" and before the closing '''/"""
+
+lit_one = ''''one quote''''
+lit_two = '''''two quotes'''''
+lit_one_space = ''' 'one quote' '''
+lit_two_space = ''' ''two quotes'' '''
+
+one = """"one quote""""
+two = """""two quotes"""""
+one_space = """ "one quote" """
+two_space = """ ""two quotes"" """
+
+mismatch1 = """aaa'''bbb"""
+mismatch2 = '''aaa"""bbb'''
+
+# Three opening """, then one escaped ", then two "" (allowed), and then three
+# closing """
+escaped = """lol\""""""
diff --git a/src/lake/tests/toml/tests/valid/string/multiline.json b/src/lake/tests/toml/tests/valid/string/multiline.json
new file mode 100644
index 0000000000..66e572bd46
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/multiline.json
@@ -0,0 +1,54 @@
+{
+  "equivalent_one": {
+    "type": "string",
+    "value": "The quick brown fox jumps over the lazy dog."
+  },
+  "equivalent_three": {
+    "type": "string",
+    "value": "The quick brown fox jumps over the lazy dog."
+  },
+  "equivalent_two": {
+    "type": "string",
+    "value": "The quick brown fox jumps over the lazy dog."
+  },
+  "escape-bs-1": {
+    "type": "string",
+    "value": "a \\\nb"
+  },
+  "escape-bs-2": {
+    "type": "string",
+    "value": "a \\b"
+  },
+  "escape-bs-3": {
+    "type": "string",
+    "value": "a \\\\\n  b"
+  },
+  "keep-ws-before": {
+    "type": "string",
+    "value": "a   \tb"
+  },
+  "multiline_empty_four": {
+    "type": "string",
+    "value": ""
+  },
+  "multiline_empty_one": {
+    "type": "string",
+    "value": ""
+  },
+  "multiline_empty_three": {
+    "type": "string",
+    "value": ""
+  },
+  "multiline_empty_two": {
+    "type": "string",
+    "value": ""
+  },
+  "no-space": {
+    "type": "string",
+    "value": "ab"
+  },
+  "whitespace-after-bs": {
+    "type": "string",
+    "value": "The quick brown fox jumps over the lazy dog."
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/multiline.toml b/src/lake/tests/toml/tests/valid/string/multiline.toml
new file mode 100644
index 0000000000..f3b3c2ed3f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/multiline.toml
@@ -0,0 +1,52 @@
+# NOTE: this file includes some literal tab characters.
+
+multiline_empty_one = """"""
+
+# A newline immediately following the opening delimiter will be trimmed.
+multiline_empty_two = """
+"""
+
+# \ at the end of line trims newlines as well; note that last \ is followed by
+# two spaces, which are ignored.
+multiline_empty_three = """\
+    """
+multiline_empty_four = """\
+   \
+   \  
+   """
+
+equivalent_one = "The quick brown fox jumps over the lazy dog."
+equivalent_two = """
+The quick brown \
+
+
+  fox jumps over \
+    the lazy dog."""
+
+equivalent_three = """\
+       The quick brown \
+       fox jumps over \
+       the lazy dog.\
+       """
+
+whitespace-after-bs = """\
+       The quick brown \
+       fox jumps over \   
+       the lazy dog.\	
+       """
+
+no-space = """a\
+    b"""
+
+# Has tab character.
+keep-ws-before = """a   	\
+   b"""
+
+escape-bs-1 = """a \\
+b"""
+
+escape-bs-2 = """a \\\
+b"""
+
+escape-bs-3 = """a \\\\
+  b"""
diff --git a/src/lake/tests/toml/tests/valid/string/nl.json b/src/lake/tests/toml/tests/valid/string/nl.json
new file mode 100644
index 0000000000..8eae09a02a
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/nl.json
@@ -0,0 +1,22 @@
+{
+  "lit_nl_end": {
+    "type": "string",
+    "value": "value\\n"
+  },
+  "lit_nl_mid": {
+    "type": "string",
+    "value": "val\\nue"
+  },
+  "lit_nl_uni": {
+    "type": "string",
+    "value": "val\\ue"
+  },
+  "nl_end": {
+    "type": "string",
+    "value": "value\n"
+  },
+  "nl_mid": {
+    "type": "string",
+    "value": "val\nue"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/nl.toml b/src/lake/tests/toml/tests/valid/string/nl.toml
new file mode 100644
index 0000000000..1e09a8bf78
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/nl.toml
@@ -0,0 +1,6 @@
+nl_mid = "val\nue"
+nl_end = """value\n"""
+
+lit_nl_end = '''value\n'''
+lit_nl_mid = 'val\nue'
+lit_nl_uni = 'val\ue'
diff --git a/src/lake/tests/toml/tests/valid/string/quoted-unicode.json b/src/lake/tests/toml/tests/valid/string/quoted-unicode.json
new file mode 100644
index 0000000000..9c6cc955ce
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/quoted-unicode.json
@@ -0,0 +1,18 @@
+{
+  "escaped_string": {
+    "type": "string",
+    "value": "\u0000 \b \f A \u007f \u0080 \u00ff \ud7ff \ue000 \uffff \ud800\udc00 \udbff\udfff"
+  },
+  "not_escaped_string": {
+    "type": "string",
+    "value": "\\u0000 \\u0008 \\u000c \\U00000041 \\u007f \\u0080 \\u00ff \\ud7ff \\ue000 \\uffff \\U00010000 \\U0010ffff"
+  },
+  "basic_string": {
+    "type": "string",
+    "value": "~ \u0080 \u00ff \ud7ff \ue000 \uffff \ud800\udc00 \udbff\udfff"
+  },
+  "literal_string": {
+    "type": "string",
+    "value": "~ \u0080 \u00ff \ud7ff \ue000 \uffff \ud800\udc00 \udbff\udfff"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/quoted-unicode.toml b/src/lake/tests/toml/tests/valid/string/quoted-unicode.toml
new file mode 100644
index 0000000000..3dfb147319
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/quoted-unicode.toml
@@ -0,0 +1,6 @@
+
+escaped_string = "\u0000 \u0008 \u000c \U00000041 \u007f \u0080 \u00ff \ud7ff \ue000 \uffff \U00010000 \U0010ffff"
+not_escaped_string = '\u0000 \u0008 \u000c \U00000041 \u007f \u0080 \u00ff \ud7ff \ue000 \uffff \U00010000 \U0010ffff'
+
+basic_string = "~ € ÿ ퟿  ￿ 𐀀 􏿿"
+literal_string = '~ € ÿ ퟿  ￿ 𐀀 􏿿'
diff --git a/src/lake/tests/toml/tests/valid/string/raw-multiline.json b/src/lake/tests/toml/tests/valid/string/raw-multiline.json
new file mode 100644
index 0000000000..4159eb010a
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/raw-multiline.json
@@ -0,0 +1,18 @@
+{
+  "firstnl": {
+    "type": "string",
+    "value": "This string has a ' quote character."
+  },
+  "multiline": {
+    "type": "string",
+    "value": "This string\nhas ' a quote character\nand more than\none newline\nin it."
+  },
+  "oneline": {
+    "type": "string",
+    "value": "This string has a ' quote character."
+  },
+  "multiline_with_tab": {
+    "type": "string",
+    "value": "First line\n\t Followed by a tab"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/raw-multiline.toml b/src/lake/tests/toml/tests/valid/string/raw-multiline.toml
new file mode 100644
index 0000000000..fff00d9c2f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/raw-multiline.toml
@@ -0,0 +1,18 @@
+# Single ' should be allowed.
+oneline = '''This string has a ' quote character.'''
+
+# A newline immediately following the opening delimiter will be trimmed.
+firstnl = '''
+This string has a ' quote character.'''
+
+# All other whitespace and newline characters remain intact.
+multiline = '''
+This string
+has ' a quote character
+and more than
+one newline
+in it.'''
+
+# Tab character in literal string does not need to be escaped
+multiline_with_tab = '''First line
+	 Followed by a tab'''
diff --git a/src/lake/tests/toml/tests/valid/string/raw.json b/src/lake/tests/toml/tests/valid/string/raw.json
new file mode 100644
index 0000000000..3e1cfd1dbf
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/raw.json
@@ -0,0 +1,34 @@
+{
+  "backslash": {
+    "type": "string",
+    "value": "This string has a \\\\ backslash character."
+  },
+  "backspace": {
+    "type": "string",
+    "value": "This string has a \\b backspace character."
+  },
+  "carriage": {
+    "type": "string",
+    "value": "This string has a \\r carriage return character."
+  },
+  "formfeed": {
+    "type": "string",
+    "value": "This string has a \\f form feed character."
+  },
+  "newline": {
+    "type": "string",
+    "value": "This string has a \\n new line character."
+  },
+  "slash": {
+    "type": "string",
+    "value": "This string has a \\/ slash character."
+  },
+  "tab": {
+    "type": "string",
+    "value": "This string has a \\t tab character."
+  },
+  "unescaped_tab": {
+    "type": "string",
+    "value": "This string has an \t unescaped tab character."
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/raw.toml b/src/lake/tests/toml/tests/valid/string/raw.toml
new file mode 100644
index 0000000000..993307f176
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/raw.toml
@@ -0,0 +1,8 @@
+backspace = 'This string has a \b backspace character.'
+tab = 'This string has a \t tab character.'
+unescaped_tab = 'This string has an 	 unescaped tab character.'
+newline = 'This string has a \n new line character.'
+formfeed = 'This string has a \f form feed character.'
+carriage = 'This string has a \r carriage return character.'
+slash = 'This string has a \/ slash character.'
+backslash = 'This string has a \\ backslash character.'
diff --git a/src/lake/tests/toml/tests/valid/string/simple.json b/src/lake/tests/toml/tests/valid/string/simple.json
new file mode 100644
index 0000000000..2561cda38b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/simple.json
@@ -0,0 +1,6 @@
+{
+  "answer": {
+    "type": "string",
+    "value": "You are not drinking enough whisky."
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/simple.toml b/src/lake/tests/toml/tests/valid/string/simple.toml
new file mode 100644
index 0000000000..e17ade6237
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/simple.toml
@@ -0,0 +1 @@
+answer = "You are not drinking enough whisky."
diff --git a/src/lake/tests/toml/tests/valid/string/unicode-escape.json b/src/lake/tests/toml/tests/valid/string/unicode-escape.json
new file mode 100644
index 0000000000..9ae728bad6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/unicode-escape.json
@@ -0,0 +1,10 @@
+{
+  "answer4": {
+    "type": "string",
+    "value": "δ"
+  },
+  "answer8": {
+    "type": "string",
+    "value": "δ"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/unicode-escape.toml b/src/lake/tests/toml/tests/valid/string/unicode-escape.toml
new file mode 100644
index 0000000000..82faecbfa5
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/unicode-escape.toml
@@ -0,0 +1,2 @@
+answer4 = "\u03B4"
+answer8 = "\U000003B4"
diff --git a/src/lake/tests/toml/tests/valid/string/unicode-literal.json b/src/lake/tests/toml/tests/valid/string/unicode-literal.json
new file mode 100644
index 0000000000..7f15df4229
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/unicode-literal.json
@@ -0,0 +1,6 @@
+{
+  "answer": {
+    "type": "string",
+    "value": "δ"
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/unicode-literal.toml b/src/lake/tests/toml/tests/valid/string/unicode-literal.toml
new file mode 100644
index 0000000000..c65723ca1d
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/unicode-literal.toml
@@ -0,0 +1 @@
+answer = "δ"
diff --git a/src/lake/tests/toml/tests/valid/string/with-pound.json b/src/lake/tests/toml/tests/valid/string/with-pound.json
new file mode 100644
index 0000000000..2cb8beb906
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/with-pound.json
@@ -0,0 +1,10 @@
+{
+  "pound": {
+    "type": "string",
+    "value": "We see no # comments here."
+  },
+  "poundcomment": {
+    "type": "string",
+    "value": "But there are # some comments here."
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/string/with-pound.toml b/src/lake/tests/toml/tests/valid/string/with-pound.toml
new file mode 100644
index 0000000000..5fd87466df
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/string/with-pound.toml
@@ -0,0 +1,2 @@
+pound = "We see no # comments here."
+poundcomment = "But there are # some comments here." # Did I # mess you up?
diff --git a/src/lake/tests/toml/tests/valid/table/array-implicit-and-explicit-after.json b/src/lake/tests/toml/tests/valid/table/array-implicit-and-explicit-after.json
new file mode 100644
index 0000000000..de156c5b52
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-implicit-and-explicit-after.json
@@ -0,0 +1,16 @@
+{
+  "a": {
+    "b": [
+      {
+        "x": {
+          "type": "integer",
+          "value": "1"
+        }
+      }
+    ],
+    "y": {
+      "type": "integer",
+      "value": "2"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/table/array-implicit-and-explicit-after.toml b/src/lake/tests/toml/tests/valid/table/array-implicit-and-explicit-after.toml
new file mode 100644
index 0000000000..bab8d61957
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-implicit-and-explicit-after.toml
@@ -0,0 +1,5 @@
+[[a.b]]
+x = 1
+
+[a]
+y = 2
diff --git a/src/lake/tests/toml/tests/valid/table/array-implicit.json b/src/lake/tests/toml/tests/valid/table/array-implicit.json
new file mode 100644
index 0000000000..ee164c5f3b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-implicit.json
@@ -0,0 +1,12 @@
+{
+  "albums": {
+    "songs": [
+      {
+        "name": {
+          "type": "string",
+          "value": "Glory Days"
+        }
+      }
+    ]
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/table/array-implicit.toml b/src/lake/tests/toml/tests/valid/table/array-implicit.toml
new file mode 100644
index 0000000000..3157ac981d
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-implicit.toml
@@ -0,0 +1,2 @@
+[[albums.songs]]
+name = "Glory Days"
diff --git a/src/lake/tests/toml/tests/valid/table/array-many.json b/src/lake/tests/toml/tests/valid/table/array-many.json
new file mode 100644
index 0000000000..fe78bf6b5b
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-many.json
@@ -0,0 +1,34 @@
+{
+  "people": [
+    {
+      "first_name": {
+        "type": "string",
+        "value": "Bruce"
+      },
+      "last_name": {
+        "type": "string",
+        "value": "Springsteen"
+      }
+    },
+    {
+      "first_name": {
+        "type": "string",
+        "value": "Eric"
+      },
+      "last_name": {
+        "type": "string",
+        "value": "Clapton"
+      }
+    },
+    {
+      "first_name": {
+        "type": "string",
+        "value": "Bob"
+      },
+      "last_name": {
+        "type": "string",
+        "value": "Seger"
+      }
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/table/array-many.toml b/src/lake/tests/toml/tests/valid/table/array-many.toml
new file mode 100644
index 0000000000..46062beb8e
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-many.toml
@@ -0,0 +1,11 @@
+[[people]]
+first_name = "Bruce"
+last_name = "Springsteen"
+
+[[people]]
+first_name = "Eric"
+last_name = "Clapton"
+
+[[people]]
+first_name = "Bob"
+last_name = "Seger"
diff --git a/src/lake/tests/toml/tests/valid/table/array-nest.json b/src/lake/tests/toml/tests/valid/table/array-nest.json
new file mode 100644
index 0000000000..97f55c81ef
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-nest.json
@@ -0,0 +1,44 @@
+{
+  "albums": [
+    {
+      "name": {
+        "type": "string",
+        "value": "Born to Run"
+      },
+      "songs": [
+        {
+          "name": {
+            "type": "string",
+            "value": "Jungleland"
+          }
+        },
+        {
+          "name": {
+            "type": "string",
+            "value": "Meeting Across the River"
+          }
+        }
+      ]
+    },
+    {
+      "name": {
+        "type": "string",
+        "value": "Born in the USA"
+      },
+      "songs": [
+        {
+          "name": {
+            "type": "string",
+            "value": "Glory Days"
+          }
+        },
+        {
+          "name": {
+            "type": "string",
+            "value": "Dancing in the Dark"
+          }
+        }
+      ]
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/table/array-nest.toml b/src/lake/tests/toml/tests/valid/table/array-nest.toml
new file mode 100644
index 0000000000..d659a3d947
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-nest.toml
@@ -0,0 +1,17 @@
+[[albums]]
+name = "Born to Run"
+
+  [[albums.songs]]
+  name = "Jungleland"
+
+  [[albums.songs]]
+  name = "Meeting Across the River"
+
+[[albums]]
+name = "Born in the USA"
+  
+  [[albums.songs]]
+  name = "Glory Days"
+
+  [[albums.songs]]
+  name = "Dancing in the Dark"
diff --git a/src/lake/tests/toml/tests/valid/table/array-one.json b/src/lake/tests/toml/tests/valid/table/array-one.json
new file mode 100644
index 0000000000..5cd67de1fb
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-one.json
@@ -0,0 +1,14 @@
+{
+  "people": [
+    {
+      "first_name": {
+        "type": "string",
+        "value": "Bruce"
+      },
+      "last_name": {
+        "type": "string",
+        "value": "Springsteen"
+      }
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/table/array-one.toml b/src/lake/tests/toml/tests/valid/table/array-one.toml
new file mode 100644
index 0000000000..cd7e1b6907
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-one.toml
@@ -0,0 +1,3 @@
+[[people]]
+first_name = "Bruce"
+last_name = "Springsteen"
diff --git a/src/lake/tests/toml/tests/valid/table/array-table-array.json b/src/lake/tests/toml/tests/valid/table/array-table-array.json
new file mode 100644
index 0000000000..5c3d6495d2
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-table-array.json
@@ -0,0 +1,24 @@
+{
+  "a": [
+    {
+      "b": [
+        {
+          "c": {
+            "d": {
+              "type": "string",
+              "value": "val0"
+            }
+          }
+        },
+        {
+          "c": {
+            "d": {
+              "type": "string",
+              "value": "val1"
+            }
+          }
+        }
+      ]
+    }
+  ]
+}
diff --git a/src/lake/tests/toml/tests/valid/table/array-table-array.toml b/src/lake/tests/toml/tests/valid/table/array-table-array.toml
new file mode 100644
index 0000000000..a07b0c7fe3
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-table-array.toml
@@ -0,0 +1,7 @@
+[[a]]
+    [[a.b]]
+        [a.b.c]
+            d = "val0"
+    [[a.b]]
+        [a.b.c]
+            d = "val1"
diff --git a/src/lake/tests/toml/tests/valid/table/array-within-dotted.json b/src/lake/tests/toml/tests/valid/table/array-within-dotted.json
new file mode 100644
index 0000000000..30b151732f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-within-dotted.json
@@ -0,0 +1,18 @@
+{
+  "fruit": {
+    "apple": {
+      "color": {
+        "type": "string",
+        "value": "red"
+      },
+      "seeds": [
+        {
+          "size": {
+            "type": "integer",
+            "value": "2"
+          }
+        }
+      ]
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/table/array-within-dotted.toml b/src/lake/tests/toml/tests/valid/table/array-within-dotted.toml
new file mode 100644
index 0000000000..3ecbeb7029
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/array-within-dotted.toml
@@ -0,0 +1,5 @@
+[fruit]
+apple.color = "red"
+
+[[fruit.apple.seeds]]
+size = 2
diff --git a/src/lake/tests/toml/tests/valid/table/empty-name.json b/src/lake/tests/toml/tests/valid/table/empty-name.json
new file mode 100644
index 0000000000..fc58e386d6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/empty-name.json
@@ -0,0 +1,22 @@
+{
+  "": {
+    "x": {
+      "type": "integer",
+      "value": "1"
+    },
+    "a": {
+      "x": {
+        "type": "integer",
+        "value": "2"
+      }
+    }
+  },
+  "a": {
+    "": {
+      "x": {
+        "type": "integer",
+        "value": "3"
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/table/empty-name.toml b/src/lake/tests/toml/tests/valid/table/empty-name.toml
new file mode 100644
index 0000000000..3c98faac95
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/empty-name.toml
@@ -0,0 +1,8 @@
+['']
+x = 1
+
+["".a]
+x = 2
+
+[a.'']
+x = 3
diff --git a/src/lake/tests/toml/tests/valid/table/empty.json b/src/lake/tests/toml/tests/valid/table/empty.json
new file mode 100644
index 0000000000..3e82cdad50
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/empty.json
@@ -0,0 +1,3 @@
+{
+  "a": {}
+}
diff --git a/src/lake/tests/toml/tests/valid/table/empty.toml b/src/lake/tests/toml/tests/valid/table/empty.toml
new file mode 100644
index 0000000000..8bb6a0aa07
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/empty.toml
@@ -0,0 +1 @@
+[a]
diff --git a/src/lake/tests/toml/tests/valid/table/keyword.json b/src/lake/tests/toml/tests/valid/table/keyword.json
new file mode 100644
index 0000000000..a15dfae0a8
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/keyword.json
@@ -0,0 +1,6 @@
+{
+  "true": {},
+  "false": {},
+  "inf": {},
+  "nan": {}
+}
diff --git a/src/lake/tests/toml/tests/valid/table/keyword.toml b/src/lake/tests/toml/tests/valid/table/keyword.toml
new file mode 100644
index 0000000000..bc3d52a7dd
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/keyword.toml
@@ -0,0 +1,9 @@
+[true]
+
+[false]
+
+[inf]
+
+[nan]
+
+
diff --git a/src/lake/tests/toml/tests/valid/table/names.json b/src/lake/tests/toml/tests/valid/table/names.json
new file mode 100644
index 0000000000..66d8ea5b7e
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/names.json
@@ -0,0 +1,30 @@
+{
+  "a": {
+    " x ": {},
+    "b": {
+      "c": {}
+    },
+    "b.c": {},
+    "d.e": {}
+  },
+  "d": {
+    "e": {
+      "f": {}
+    }
+  },
+  "g": {
+    "h": {
+      "i": {}
+    }
+  },
+  "j": {
+    "ʞ": {
+      "l": {}
+    }
+  },
+  "x": {
+    "1": {
+      "2": {}
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/table/names.toml b/src/lake/tests/toml/tests/valid/table/names.toml
new file mode 100644
index 0000000000..092da2ff9e
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/names.toml
@@ -0,0 +1,9 @@
+[a.b.c]
+[a."b.c"]
+[a.'d.e']
+[a.' x ']
+[ d.e.f ]
+[ g . h . i ]
+[ j . "ʞ" . 'l' ]
+
+[x.1.2]
diff --git a/src/lake/tests/toml/tests/valid/table/no-eol.json b/src/lake/tests/toml/tests/valid/table/no-eol.json
new file mode 100644
index 0000000000..b6e7fb5020
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/no-eol.json
@@ -0,0 +1,3 @@
+{
+  "table": {}
+}
diff --git a/src/lake/tests/toml/tests/valid/table/no-eol.toml b/src/lake/tests/toml/tests/valid/table/no-eol.toml
new file mode 100644
index 0000000000..f1098fdaca
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/no-eol.toml
@@ -0,0 +1 @@
+[table]
diff --git a/src/lake/tests/toml/tests/valid/table/sub-empty.json b/src/lake/tests/toml/tests/valid/table/sub-empty.json
new file mode 100644
index 0000000000..ed10cd236d
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/sub-empty.json
@@ -0,0 +1,5 @@
+{
+  "a": {
+    "b": {}
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/table/sub-empty.toml b/src/lake/tests/toml/tests/valid/table/sub-empty.toml
new file mode 100644
index 0000000000..70b7fe11c3
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/sub-empty.toml
@@ -0,0 +1,2 @@
+[a]
+[a.b]
diff --git a/src/lake/tests/toml/tests/valid/table/sub.json b/src/lake/tests/toml/tests/valid/table/sub.json
new file mode 100644
index 0000000000..cb81a3f1ad
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/sub.json
@@ -0,0 +1,20 @@
+{
+  "a": {
+    "extend": {
+      "key": {
+        "type": "integer",
+        "value": "2"
+      },
+      "more": {
+        "key": {
+          "type": "integer",
+          "value": "3"
+        }
+      }
+    },
+    "key": {
+      "type": "integer",
+      "value": "1"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/table/sub.toml b/src/lake/tests/toml/tests/valid/table/sub.toml
new file mode 100644
index 0000000000..e8299c257f
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/sub.toml
@@ -0,0 +1,9 @@
+[a]
+key = 1
+
+# a.extend is a key inside the "a" table.
+[a.extend]
+key = 2
+
+[a.extend.more]
+key = 3
diff --git a/src/lake/tests/toml/tests/valid/table/whitespace.json b/src/lake/tests/toml/tests/valid/table/whitespace.json
new file mode 100644
index 0000000000..c770470302
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/whitespace.json
@@ -0,0 +1,3 @@
+{
+  "valid key": {}
+}
diff --git a/src/lake/tests/toml/tests/valid/table/whitespace.toml b/src/lake/tests/toml/tests/valid/table/whitespace.toml
new file mode 100644
index 0000000000..daf881d13a
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/whitespace.toml
@@ -0,0 +1 @@
+["valid key"]
diff --git a/src/lake/tests/toml/tests/valid/table/with-literal-string.json b/src/lake/tests/toml/tests/valid/table/with-literal-string.json
new file mode 100644
index 0000000000..7784695c99
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/with-literal-string.json
@@ -0,0 +1,12 @@
+{
+  "a": {
+    "\"b\"": {
+      "c": {
+        "answer": {
+          "type": "integer",
+          "value": "42"
+        }
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/table/with-literal-string.toml b/src/lake/tests/toml/tests/valid/table/with-literal-string.toml
new file mode 100644
index 0000000000..b81643daa0
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/with-literal-string.toml
@@ -0,0 +1,4 @@
+['a']
+[a.'"b"']
+[a.'"b"'.c]
+answer = 42 
diff --git a/src/lake/tests/toml/tests/valid/table/with-pound.json b/src/lake/tests/toml/tests/valid/table/with-pound.json
new file mode 100644
index 0000000000..f32d2f2ebd
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/with-pound.json
@@ -0,0 +1,8 @@
+{
+  "key#group": {
+    "answer": {
+      "type": "integer",
+      "value": "42"
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/table/with-pound.toml b/src/lake/tests/toml/tests/valid/table/with-pound.toml
new file mode 100644
index 0000000000..33f2c4fd6c
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/with-pound.toml
@@ -0,0 +1,2 @@
+["key#group"]
+answer = 42
diff --git a/src/lake/tests/toml/tests/valid/table/with-single-quotes.json b/src/lake/tests/toml/tests/valid/table/with-single-quotes.json
new file mode 100644
index 0000000000..347c693cf6
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/with-single-quotes.json
@@ -0,0 +1,12 @@
+{
+  "a": {
+    "b": {
+      "c": {
+        "answer": {
+          "type": "integer",
+          "value": "42"
+        }
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/table/with-single-quotes.toml b/src/lake/tests/toml/tests/valid/table/with-single-quotes.toml
new file mode 100644
index 0000000000..56e52cc990
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/with-single-quotes.toml
@@ -0,0 +1,4 @@
+['a']
+[a.'b']
+[a.'b'.c]
+answer = 42 
diff --git a/src/lake/tests/toml/tests/valid/table/without-super.json b/src/lake/tests/toml/tests/valid/table/without-super.json
new file mode 100644
index 0000000000..3c390c682c
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/without-super.json
@@ -0,0 +1,9 @@
+{
+  "x": {
+    "y": {
+      "z": {
+        "w": {}
+      }
+    }
+  }
+}
diff --git a/src/lake/tests/toml/tests/valid/table/without-super.toml b/src/lake/tests/toml/tests/valid/table/without-super.toml
new file mode 100644
index 0000000000..73ed68b2c1
--- /dev/null
+++ b/src/lake/tests/toml/tests/valid/table/without-super.toml
@@ -0,0 +1,5 @@
+# [x] you
+# [x.y] don't
+# [x.y.z] need these
+[x.y.z.w] # for this to work
+[x] # defining a super-table afterwards is ok
diff --git a/src/lake/tests/translateConfig/.gitignore b/src/lake/tests/translateConfig/.gitignore
new file mode 100644
index 0000000000..09ccfec591
--- /dev/null
+++ b/src/lake/tests/translateConfig/.gitignore
@@ -0,0 +1 @@
+lakefile.*
diff --git a/src/lake/tests/translateConfig/clean.sh b/src/lake/tests/translateConfig/clean.sh
new file mode 100755
index 0000000000..99f0127ded
--- /dev/null
+++ b/src/lake/tests/translateConfig/clean.sh
@@ -0,0 +1,3 @@
+rm -rf .lake
+rm -f *.produced.*
+rm -f lakefile.*
diff --git a/src/lake/tests/translateConfig/out.expected.lean b/src/lake/tests/translateConfig/out.expected.lean
new file mode 100644
index 0000000000..9e8159ea7f
--- /dev/null
+++ b/src/lake/tests/translateConfig/out.expected.lean
@@ -0,0 +1,16 @@
+import Lake
+
+open System Lake DSL
+
+package test where
+  releaseRepo := ""
+  buildArchive := ""
+  platformIndependent := true
+
+require foo from "-" with Lake.NameMap.empty |>.insert `foo "bar"
+
+require bar from git "https://example.com"@"abc"/"sub/dir"
+
+lean_lib A
+
+@[default_target] lean_exe b
diff --git a/src/lake/tests/translateConfig/out.expected.toml b/src/lake/tests/translateConfig/out.expected.toml
new file mode 100644
index 0000000000..8706c1391c
--- /dev/null
+++ b/src/lake/tests/translateConfig/out.expected.toml
@@ -0,0 +1,19 @@
+name = "test"
+defaultTargets = ["b"]
+
+[[require]]
+name = "foo"
+path = "dir"
+options = {foo = "bar"}
+
+[[require]]
+name = "bar"
+git = "https://example.com"
+rev = "abc"
+subDir = "sub/dir"
+
+[[lean_lib]]
+name = "A"
+
+[[lean_exe]]
+name = "b"
diff --git a/src/lake/tests/translateConfig/source.lean b/src/lake/tests/translateConfig/source.lean
new file mode 100644
index 0000000000..6ede4aae71
--- /dev/null
+++ b/src/lake/tests/translateConfig/source.lean
@@ -0,0 +1,55 @@
+import Lake
+open Lake DSL
+
+def testLeanConfig : LeanConfig where
+  buildType := .release
+  leanOptions := #[]
+  moreServerOptions := #[]
+  moreLeanArgs := #[]
+  weakLeanArgs := #[]
+  moreLeancArgs := #[]
+  weakLeancArgs := #[]
+  moreLinkArgs := #[]
+  weakLinkArgs := #[]
+  backend := .default
+  platformIndependent := none
+
+package test where
+  extraDepTargets := #[]
+  precompileModules := false
+  moreGlobalServerArgs := #[]
+  srcDir := "."
+  buildDir := defaultBuildDir
+  leanLibDir := defaultLeanLibDir
+  nativeLibDir := defaultNativeLibDir
+  binDir := defaultBinDir
+  irDir := defaultIrDir
+  releaseRepo := none
+  releaseRepo? := none
+  buildArchive? := none
+  preferReleaseBuild := false
+  packagesDir := defaultPackagesDir
+  toLeanConfig := testLeanConfig
+
+require foo from "dir" with NameMap.empty.insert `foo "bar"
+require bar from git "https://example.com" @ "abc" / "sub" / "dir"
+
+lean_lib A where
+  srcDir := "."
+  roots := #[`A]
+  globs := #[`A]
+  extraDepTargets := #[]
+  precompileModules := false
+  defaultFacets := #[LeanLib.leanArtsFacet]
+  nativeFacets := fun _ => #[]
+  toLeanConfig := testLeanConfig
+
+@[default_target]
+lean_exe b where
+  srcDir := "."
+  root := `b
+  exeName := "b"
+  extraDepTargets := #[]
+  supportInterpreter := false
+  nativeFacets := fun _ => #[]
+  toLeanConfig := testLeanConfig
diff --git a/src/lake/tests/translateConfig/source.toml b/src/lake/tests/translateConfig/source.toml
new file mode 100644
index 0000000000..07d1cefeb6
--- /dev/null
+++ b/src/lake/tests/translateConfig/source.toml
@@ -0,0 +1,57 @@
+defaultTargets = ['b']
+
+name = "test"
+extraDepTargets = []
+precompileModules = false
+moreGlobalServerArgs = []
+srcDir = "."
+buildDir = ".lake/build"
+leanLibDir = "lib"
+nativeLibDir = "lib"
+binDir = "bin"
+irDir = "ir"
+releaseRepo = ""
+buildArchive = ""
+preferReleaseBuild = false
+packagesDir = ".lake/packages"
+buildType = "release"
+leanOptions = []
+moreServerOptions = []
+moreLeanArgs = []
+weakLeanArgs = []
+moreLeancArgs = []
+weakLeancArgs = []
+moreLinkArgs = []
+weakLinkArgs = []
+backend = "default"
+platformIndependent = true
+
+[[lean_lib]]
+name = "A"
+srcDir = "."
+roots = ["A"]
+globs = ["A"]
+extraDepTargets = []
+precompileModules = false
+defaultFacets = ["leanArts"]
+
+[[lean_exe]]
+name = "b"
+srcDir = "."
+root = "b"
+exeName = "b"
+extraDepTargets = []
+supportInterpreter = false
+
+[[require]]
+name = "foo"
+path = "-"
+
+[require.options]
+foo = "bar"
+
+[[require]]
+name = "bar"
+git = "https://example.com"
+rev = "abc"
+subDir = "sub/dir"
diff --git a/src/lake/tests/translateConfig/test.sh b/src/lake/tests/translateConfig/test.sh
new file mode 100755
index 0000000000..3acbe2780a
--- /dev/null
+++ b/src/lake/tests/translateConfig/test.sh
@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+set -euxo pipefail
+
+LAKE=${LAKE:-../../.lake/build/bin/lake}
+
+./clean.sh
+
+# Test Lean to TOML translation
+$LAKE translate-config -f source.lean toml out.produced.toml
+diff --strip-trailing-cr out.expected.toml out.produced.toml
+rm out.produced.toml
+
+# Test idempotency of TOML translation
+$LAKE translate-config -f out.expected.toml toml out.produced.toml
+diff --strip-trailing-cr out.expected.toml out.produced.toml
+
+# Test TOML to Lean translation
+$LAKE translate-config -f source.toml lean out.produced.lean
+diff --strip-trailing-cr out.expected.lean out.produced.lean
+rm out.produced.lean
+
+# Test idempotency of Lean translation
+$LAKE translate-config -f out.expected.lean lean out.produced.lean
+diff --strip-trailing-cr out.expected.lean out.produced.lean
+
+# Test produced TOML round-trips
+$LAKE translate-config -f out.produced.toml lean bridge.produced.lean
+$LAKE translate-config -f bridge.produced.lean toml roundtrip.produced.toml
+diff --strip-trailing-cr out.produced.toml roundtrip.produced.toml
+
+# Test produced Lean round-trips
+$LAKE translate-config -f out.produced.lean toml bridge.produced.toml
+$LAKE translate-config -f bridge.produced.toml lean roundtrip.produced.lean
+diff --strip-trailing-cr out.produced.lean roundtrip.produced.lean
+
+# Test source rename
+cp source.lean lakefile.lean
+$LAKE translate-config toml
+test -f lakefile.lean.bak
+test -f lakefile.toml
diff --git a/tests/pkg/test_extern/expected.txt b/tests/pkg/test_extern/expected.txt
index 9a02d14070..7fbc63dcb0 100644
--- a/tests/pkg/test_extern/expected.txt
+++ b/tests/pkg/test_extern/expected.txt
@@ -1,5 +1,5 @@
 error: stdout:
-./././TestExtern.lean:5:0: error: native implementation did not agree with reference implementation!
+././././TestExtern.lean:5:0: error: native implementation did not agree with reference implementation!
 Compare the outputs of:
 #eval Nat.not_add 4 5
  and