diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 0000000..dba5752
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,946 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "addr2line"
+version = "0.25.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b5d307320b3181d6d7954e663bd7c774a838b8220fe0593c86d9fb09f498b4b"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "ahash"
+version = "0.8.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a15f179cd60c4584b8a8c596927aadc462e27f2ca70c04e0071964a73ba7a75"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "version_check",
+ "zerocopy",
+]
+
+[[package]]
+name = "allocator-api2"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683d7910e743518b0e34f1186f92494becacb047c7b6bf616c96772180fef923"
+
+[[package]]
+name = "anstream"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anv-cli"
+version = "0.1.0"
+dependencies = [
+ "anv-core",
+ "anv-syntax",
+ "anv-types",
+ "clap",
+ "miette",
+ "thiserror",
+]
+
+[[package]]
+name = "anv-core"
+version = "0.1.0"
+dependencies = [
+ "derive_more",
+ "ordered-float",
+ "pretty_assertions",
+ "serde",
+ "smol_str",
+ "thiserror",
+]
+
+[[package]]
+name = "anv-syntax"
+version = "0.1.0"
+dependencies = [
+ "anv-core",
+ "chumsky",
+ "logos",
+ "ordered-float",
+ "pretty_assertions",
+ "thiserror",
+]
+
+[[package]]
+name = "anv-types"
+version = "0.1.0"
+dependencies = [
+ "anv-core",
+ "anv-syntax",
+ "ordered-float",
+ "pretty_assertions",
+ "thiserror",
+]
+
+[[package]]
+name = "ar_archive_writer"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0c269894b6fe5e9d7ada0cf69b5bf847ff35bc25fc271f08e1d080fce80339a"
+dependencies = [
+ "object 0.32.2",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "backtrace"
+version = "0.3.76"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bb531853791a215d7c62a30daf0dde835f381ab5de4589cfe7c649d2cbe92bd6"
+dependencies = [
+ "addr2line",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object 0.37.3",
+ "rustc-demangle",
+ "windows-link",
+]
+
+[[package]]
+name = "backtrace-ext"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "537beee3be4a18fb023b570f80e3ae28003db9167a751266b259926e25539d50"
+dependencies = [
+ "backtrace",
+]
+
+[[package]]
+name = "beef"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a8241f3ebb85c056b509d4327ad0358fbbba6ffb340bf388f26350aeda225b1"
+
+[[package]]
+name = "bitflags"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+
+[[package]]
+name = "cc"
+version = "1.2.51"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a0aeaff4ff1a90589618835a598e545176939b97874f7abc7851caa0618f203"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "chumsky"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8eebd66744a15ded14960ab4ccdbfb51ad3b81f51f3f04a80adac98c985396c9"
+dependencies = [
+ "hashbrown",
+ "stacker",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.53"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.53"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.5.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a0b5487afeab2deb2ff4e03a807ad1a03ac532ff5a2cee5d86884440c7f7671"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+
+[[package]]
+name = "convert_case"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
+
+[[package]]
+name = "derive_more"
+version = "0.99.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6edb4b64a43d977b8e99788fe3a04d483834fba1215a7e02caa415b626497f7f"
+dependencies = [
+ "convert_case",
+ "proc-macro2",
+ "quote",
+ "rustc_version",
+ "syn",
+]
+
+[[package]]
+name = "diff"
+version = "0.1.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "645cbb3a84e60b7531617d5ae4e57f7e27308f6445f5abf653209ea76dec8dff"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "gimli"
+version = "0.32.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e629b9b98ef3dd8afe6ca2bd0f89306cec16d43d907889945bc5d6687f2f13c7"
+
+[[package]]
+name = "hashbrown"
+version = "0.14.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
+dependencies = [
+ "ahash",
+ "allocator-api2",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "is_ci"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7655c9839580ee829dfacba1d1278c2b7883e50a277ff7541299489d6bdfdc45"
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "lazy_static"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
+
+[[package]]
+name = "libc"
+version = "0.2.178"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+
+[[package]]
+name = "logos"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7251356ef8cb7aec833ddf598c6cb24d17b689d20b993f9d11a3d764e34e6458"
+dependencies = [
+ "logos-derive",
+]
+
+[[package]]
+name = "logos-codegen"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59f80069600c0d66734f5ff52cc42f2dabd6b29d205f333d61fd7832e9e9963f"
+dependencies = [
+ "beef",
+ "fnv",
+ "lazy_static",
+ "proc-macro2",
+ "quote",
+ "regex-syntax",
+ "syn",
+]
+
+[[package]]
+name = "logos-derive"
+version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24fb722b06a9dc12adb0963ed585f19fc61dc5413e6a9be9422ef92c091e731d"
+dependencies = [
+ "logos-codegen",
+]
+
+[[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
+name = "miette"
+version = "7.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f98efec8807c63c752b5bd61f862c165c115b0a35685bdcfd9238c7aeb592b7"
+dependencies = [
+ "backtrace",
+ "backtrace-ext",
+ "cfg-if",
+ "miette-derive",
+ "owo-colors",
+ "supports-color",
+ "supports-hyperlinks",
+ "supports-unicode",
+ "terminal_size",
+ "textwrap",
+ "unicode-width 0.1.14",
+]
+
+[[package]]
+name = "miette-derive"
+version = "7.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db5b29714e950dbb20d5e6f74f9dcec4edbcc1067bb7f8ed198c097b8c1a818b"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "object"
+version = "0.32.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "object"
+version = "0.37.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "ordered-float"
+version = "4.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7bb71e1b3fa6ca1c61f383464aaf2bb0e2f8e772a1f01d486832464de363b951"
+dependencies = [
+ "num-traits",
+ "rand",
+ "serde",
+]
+
+[[package]]
+name = "owo-colors"
+version = "4.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c6901729fa79e91a0913333229e9ca5dc725089d1c363b2f4b4760709dc4a52"
+
+[[package]]
+name = "pretty_assertions"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ae130e2f271fbc2ac3a40fb1d07180839cdbbe443c7a27e1e3c13c5cac0116d"
+dependencies = [
+ "diff",
+ "yansi",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.104"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9695f8df41bb4f3d222c95a67532365f569318332d03d5f3f67f37b20e6ebdf0"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "psm"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d11f2fedc3b7dafdc2851bc52f277377c5473d378859be234bc7ebb593144d01"
+dependencies = [
+ "ar_archive_writer",
+ "cc",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "rand_core",
+ "serde",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56f7d92ca342cea22a06f2121d944b4fd82af56988c270852495420f961d4ace"
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "146c9e247ccc180c1f61615433868c99f3de3ae256a30a43b49f67c2d9171f34"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "smol_str"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd538fb6910ac1099850255cf94a94df6551fbdd602454387d0adb2d1ca6dead"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "stacker"
+version = "0.1.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1f8b29fb42aafcea4edeeb6b2f2d7ecd0d969c48b4cf0d2e64aafc471dd6e59"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "libc",
+ "psm",
+ "windows-sys 0.59.0",
+]
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "supports-color"
+version = "3.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c64fc7232dd8d2e4ac5ce4ef302b1d81e0b80d055b9d77c7c4f51f6aa4c867d6"
+dependencies = [
+ "is_ci",
+]
+
+[[package]]
+name = "supports-hyperlinks"
+version = "3.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e396b6523b11ccb83120b115a0b7366de372751aa6edf19844dfb13a6af97e91"
+
+[[package]]
+name = "supports-unicode"
+version = "3.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b7401a30af6cb5818bb64852270bb722533397edcfc7344954a38f420819ece2"
+
+[[package]]
+name = "syn"
+version = "2.0.112"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21f182278bf2d2bcb3c88b1b08a37df029d71ce3d3ae26168e3c653b213b99d4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "terminal_size"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b8cb979cb11c32ce1603f8137b22262a9d131aaa5c37b5678025f22b8becd0"
+dependencies = [
+ "rustix",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "textwrap"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c13547615a44dc9c452a8a534638acdf07120d4b6847c8178705da06306a3057"
+dependencies = [
+ "unicode-linebreak",
+ "unicode-width 0.2.2",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "unicode-linebreak"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
+
+[[package]]
+name = "unicode-width"
+version = "0.1.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af"
+
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "yansi"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
+
+[[package]]
+name = "zerocopy"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fd74ec98b9250adb3ca554bdde269adf631549f51d8a8f8f0a10b50f1cb298c3"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a8d209fdf45cf5138cbb5a506f6b52522a25afccc534d1475dad8e31105c6a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..78a9e0c
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,63 @@
+# SPDX-FileCopyrightText: 2025 hyperpolymath
+# SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+[workspace]
+resolver = "2"
+members = [
+    "crates/anv-core",
+    "crates/anv-syntax",
+    "crates/anv-types",
+    "crates/anv-cli",
+]
+
+[workspace.package]
+version = "0.1.0"
+edition = "2021"
+rust-version = "1.75"
+authors = ["hyperpolymath"]
+license = "MIT OR AGPL-3.0-or-later"
+repository = "https://github.com/hyperpolymath/anvomidav"
+keywords = ["figure-skating", "choreography", "dsl", "notation"]
+categories = ["compilers", "development-tools"]
+
+[workspace.dependencies]
+# Internal crates
+anv-core = { path = "crates/anv-core" }
+anv-syntax = { path = "crates/anv-syntax" }
+anv-types = { path = "crates/anv-types" }
+
+# Parsing
+logos = "0.14"
+chumsky = "0.9"
+
+# Error handling
+thiserror = "1.0"
+miette = { version = "7", features = ["fancy"] }
+
+# CLI
+clap = { version = "4", features = ["derive"] }
+
+# Data structures
+indexmap = "2"
+rustc-hash = "1.1"
+smol_str = "0.2"
+
+# Serialization
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+# Utilities
+derive_more = "0.99"
+ordered-float = { version = "4", features = ["serde"] }
+
+# Testing
+pretty_assertions = "1"
+insta = { version = "1", features = ["yaml"] }
+
+[profile.release]
+lto = true
+codegen-units = 1
+
+[profile.dev]
+# Faster builds during development
+debug = 1
diff --git a/crates/anv-cli/Cargo.toml b/crates/anv-cli/Cargo.toml
new file mode 100644
index 0000000..e6da5c5
--- /dev/null
+++ b/crates/anv-cli/Cargo.toml
@@ -0,0 +1,25 @@
+# SPDX-FileCopyrightText: 2025 hyperpolymath
+# SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+[package]
+name = "anv-cli"
+version = "0.1.0"
+edition = "2021"
+description = "Command-line interface for the Anvomidav figure skating DSL"
+license = "MIT OR AGPL-3.0-or-later"
+repository = "https://github.com/hyperpolymath/anvomidav"
+readme = "README.md"
+keywords = ["figure-skating", "dsl", "cli"]
+categories = ["command-line-utilities", "compilers"]
+
+[[bin]]
+name = "anv"
+path = "src/main.rs"
+
+[dependencies]
+anv-core = { path = "../anv-core" }
+anv-syntax = { path = "../anv-syntax" }
+anv-types = { path = "../anv-types" }
+clap = { workspace = true }
+miette = { workspace = true }
+thiserror = { workspace = true }
diff --git a/crates/anv-cli/src/main.rs b/crates/anv-cli/src/main.rs
new file mode 100644
index 0000000..ec24050
--- /dev/null
+++ b/crates/anv-cli/src/main.rs
@@ -0,0 +1,396 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Anvomidav CLI - Command-line interface for the figure skating DSL.
+//!
+//! This tool provides commands for:
+//! - Checking Anvomidav source files for errors
+//! - Formatting source files
+//! - Running programs
+//! - Generating visualizations
+
+use anv_core::source::FileId;
+use anv_syntax::parse;
+use anv_types::check;
+use clap::{Parser, Subcommand};
+use miette::{Diagnostic, NamedSource, Report, SourceSpan};
+use std::fs;
+use std::path::PathBuf;
+use std::process::ExitCode;
+
+/// Anvomidav - A domain-specific language for figure skating choreography.
+#[derive(Parser)]
+#[command(name = "anv")]
+#[command(author = "hyperpolymath")]
+#[command(version)]
+#[command(about = "Anvomidav figure skating DSL compiler and tools", long_about = None)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Check source files for errors without running them
+    Check {
+        /// Source files to check
+        #[arg(required = true)]
+        files: Vec<PathBuf>,
+
+        /// Show detailed output
+        #[arg(short, long)]
+        verbose: bool,
+    },
+
+    /// Parse a source file and print the AST
+    Parse {
+        /// Source file to parse
+        file: PathBuf,
+
+        /// Output format (json, debug)
+        #[arg(short, long, default_value = "debug")]
+        format: String,
+    },
+
+    /// Lex a source file and print tokens
+    Lex {
+        /// Source file to lex
+        file: PathBuf,
+    },
+
+    /// Format source files
+    Fmt {
+        /// Source files to format
+        files: Vec<PathBuf>,
+
+        /// Check if files are formatted without modifying them
+        #[arg(long)]
+        check: bool,
+    },
+
+    /// Create a new Anvomidav project
+    New {
+        /// Project name
+        name: String,
+
+        /// Project template (singles, pairs, ice-dance)
+        #[arg(short, long, default_value = "singles")]
+        template: String,
+    },
+}
+
+/// Error type for CLI operations.
+#[derive(Debug, thiserror::Error, Diagnostic)]
+enum CliError {
+    #[error("failed to read file: {path}")]
+    #[diagnostic(code(anv::io::read_error))]
+    ReadError {
+        path: String,
+        #[source]
+        source: std::io::Error,
+    },
+
+    #[error("parse error")]
+    #[diagnostic(code(anv::syntax::parse_error))]
+    ParseError {
+        #[source_code]
+        src: NamedSource<String>,
+        #[label("here")]
+        span: SourceSpan,
+        #[help]
+        help: String,
+    },
+
+    #[error("type error")]
+    #[diagnostic(code(anv::types::type_error))]
+    TypeError {
+        #[source_code]
+        src: NamedSource<String>,
+        #[label("{message}")]
+        span: SourceSpan,
+        message: String,
+    },
+}
+
+fn main() -> ExitCode {
+    let cli = Cli::parse();
+
+    match run(cli) {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(e) => {
+            eprintln!("{:?}", e);
+            ExitCode::FAILURE
+        }
+    }
+}
+
+fn run(cli: Cli) -> miette::Result<()> {
+    match cli.command {
+        Commands::Check { files, verbose } => {
+            let mut has_errors = false;
+
+            for (file_idx, path) in files.iter().enumerate() {
+                if verbose {
+                    eprintln!("Checking {}...", path.display());
+                }
+
+                let source = fs::read_to_string(path).map_err(|e| CliError::ReadError {
+                    path: path.display().to_string(),
+                    source: e,
+                })?;
+
+                let file_id = FileId(file_idx as u32);
+
+                // Parse
+                let program = match parse(&source, file_id) {
+                    Ok(p) => p,
+                    Err(errors) => {
+                        has_errors = true;
+                        for err in errors {
+                            let span: SourceSpan = (err.span.start, err.span.end - err.span.start).into();
+                            let report = Report::new(CliError::ParseError {
+                                src: NamedSource::new(path.display().to_string(), source.clone()),
+                                span,
+                                help: err.message.clone(),
+                            });
+                            eprintln!("{:?}", report);
+                        }
+                        continue;
+                    }
+                };
+
+                // Type check
+                if let Err(diagnostics) = check(&program, file_id) {
+                    has_errors = true;
+                    for diag in diagnostics.iter() {
+                        let code_str = diag.code.as_ref().map(|c| c.to_string()).unwrap_or_default();
+                        eprintln!(
+                            "{}:{}: {} [{}]",
+                            path.display(),
+                            diag.labels.first().map(|l| l.span.start).unwrap_or(0),
+                            diag.message,
+                            code_str
+                        );
+                        for note in &diag.notes {
+                            eprintln!("  note: {:?}", note);
+                        }
+                    }
+                }
+            }
+
+            if has_errors {
+                Err(miette::miette!("check failed with errors"))?;
+            } else if verbose {
+                eprintln!("All checks passed!");
+            }
+
+            Ok(())
+        }
+
+        Commands::Parse { file, format } => {
+            let source = fs::read_to_string(&file).map_err(|e| CliError::ReadError {
+                path: file.display().to_string(),
+                source: e,
+            })?;
+
+            let program = parse(&source, FileId(0)).map_err(|errors| {
+                let err = &errors[0];
+                let span: SourceSpan = (err.span.start, err.span.end - err.span.start).into();
+                CliError::ParseError {
+                    src: NamedSource::new(file.display().to_string(), source.clone()),
+                    span,
+                    help: err.message.clone(),
+                }
+            })?;
+
+            match format.as_str() {
+                "debug" => println!("{:#?}", program),
+                "json" => {
+                    // TODO: Implement JSON serialization
+                    println!("{{\"name\": \"{}\", \"segments\": {}}}", program.name.node, program.segments.len());
+                }
+                _ => {
+                    eprintln!("Unknown format: {}. Using 'debug'.", format);
+                    println!("{:#?}", program);
+                }
+            }
+
+            Ok(())
+        }
+
+        Commands::Lex { file } => {
+            let source = fs::read_to_string(&file).map_err(|e| CliError::ReadError {
+                path: file.display().to_string(),
+                source: e,
+            })?;
+
+            let tokens = anv_syntax::Lexer::tokenize(&source).map_err(|e| {
+                let span: SourceSpan = (e.span.start, e.span.end - e.span.start).into();
+                CliError::ParseError {
+                    src: NamedSource::new(file.display().to_string(), source.clone()),
+                    span,
+                    help: e.message.clone(),
+                }
+            })?;
+
+            for tok in tokens {
+                println!("{:4}..{:4} {:?}", tok.span.start, tok.span.end, tok.token);
+            }
+
+            Ok(())
+        }
+
+        Commands::Fmt { files, check } => {
+            if files.is_empty() {
+                eprintln!("No files specified");
+                return Ok(());
+            }
+
+            for path in &files {
+                let source = fs::read_to_string(path).map_err(|e| CliError::ReadError {
+                    path: path.display().to_string(),
+                    source: e,
+                })?;
+
+                // TODO: Implement formatter
+                // For now, just verify the file parses
+                let _program = parse(&source, FileId(0)).map_err(|errors| {
+                    let err = &errors[0];
+                    let span: SourceSpan = (err.span.start, err.span.end - err.span.start).into();
+                    CliError::ParseError {
+                        src: NamedSource::new(path.display().to_string(), source.clone()),
+                        span,
+                        help: err.message.clone(),
+                    }
+                })?;
+
+                if check {
+                    eprintln!("{}: would reformat", path.display());
+                } else {
+                    eprintln!("{}: formatted (no-op, formatter not implemented)", path.display());
+                }
+            }
+
+            Ok(())
+        }
+
+        Commands::New { name, template } => {
+            let project_dir = PathBuf::from(&name);
+
+            if project_dir.exists() {
+                return Err(miette::miette!("directory '{}' already exists", name));
+            }
+
+            fs::create_dir_all(&project_dir).map_err(|e| CliError::ReadError {
+                path: project_dir.display().to_string(),
+                source: e,
+            })?;
+
+            let main_content = match template.as_str() {
+                "singles" => format!(
+                    r#"/// {} - Singles figure skating program
+///
+/// Created with Anvomidav
+
+program {} {{
+    segment short_program: short {{
+        sequence opening {{
+            jump triple axel at 0:15
+            spin camel sit upright L3 at 0:30
+            step circular L3 at 1:00
+        }}
+    }}
+
+    segment free_skate: free {{
+        sequence technical {{
+            jump quad lutz at 0:30
+            jump triple axel at 1:00
+            spin layback L4 at 1:30
+        }}
+    }}
+}}
+"#,
+                    name, name
+                ),
+                "pairs" => format!(
+                    r#"/// {} - Pairs figure skating program
+///
+/// Created with Anvomidav
+
+program {} {{
+    segment short_program: short {{
+        skater lead
+        skater follow
+
+        sequence opening {{
+            parallel {{
+                lead: jump double axel at 0:15
+                follow: jump double axel at 0:15
+            }}
+            lift group3 L3 at 0:30
+            throw triple salchow at 1:00
+        }}
+    }}
+}}
+"#,
+                    name, name
+                ),
+                "ice-dance" => format!(
+                    r#"/// {} - Ice dance program
+///
+/// Created with Anvomidav
+
+program {} {{
+    segment pattern: pattern {{
+        skater lead
+        skater follow
+
+        sequence waltz {{
+            sync {{
+                step circular L3 at 0:00
+            }}
+        }}
+    }}
+}}
+"#,
+                    name, name
+                ),
+                _ => {
+                    return Err(miette::miette!(
+                        "unknown template '{}'. Use: singles, pairs, or ice-dance",
+                        template
+                    ));
+                }
+            };
+
+            let main_file = project_dir.join("main.anv");
+            fs::write(&main_file, main_content).map_err(|e| CliError::ReadError {
+                path: main_file.display().to_string(),
+                source: e,
+            })?;
+
+            eprintln!("Created new {} project in '{}'", template, name);
+            eprintln!("  Main file: {}/main.anv", name);
+
+            Ok(())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_cli_parse() {
+        let cli = Cli::try_parse_from(["anv", "check", "test.anv"]);
+        assert!(cli.is_ok());
+    }
+
+    #[test]
+    fn test_cli_version() {
+        let cli = Cli::try_parse_from(["anv", "--version"]);
+        // --version causes early exit, so this will be an error
+        assert!(cli.is_err());
+    }
+}
diff --git a/crates/anv-core/Cargo.toml b/crates/anv-core/Cargo.toml
new file mode 100644
index 0000000..c5a72ca
--- /dev/null
+++ b/crates/anv-core/Cargo.toml
@@ -0,0 +1,21 @@
+# SPDX-FileCopyrightText: 2025 hyperpolymath
+# SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+[package]
+name = "anv-core"
+description = "Core types and utilities for Anvomidav"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[dependencies]
+derive_more = { workspace = true }
+ordered-float = { workspace = true }
+serde = { workspace = true }
+smol_str = { workspace = true }
+thiserror = { workspace = true }
+
+[dev-dependencies]
+pretty_assertions = { workspace = true }
diff --git a/crates/anv-core/src/diagnostics.rs b/crates/anv-core/src/diagnostics.rs
new file mode 100644
index 0000000..c8b2ca0
--- /dev/null
+++ b/crates/anv-core/src/diagnostics.rs
@@ -0,0 +1,332 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Diagnostic reporting for errors, warnings, and hints.
+
+use crate::source::Span;
+use serde::{Deserialize, Serialize};
+use std::fmt;
+
+/// Severity level of a diagnostic.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum Severity {
+    /// Informational hint.
+    Hint,
+    /// Warning (does not prevent compilation).
+    Warning,
+    /// Error (prevents successful compilation).
+    Error,
+}
+
+impl fmt::Display for Severity {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Severity::Hint => write!(f, "hint"),
+            Severity::Warning => write!(f, "warning"),
+            Severity::Error => write!(f, "error"),
+        }
+    }
+}
+
+/// Error code for categorizing diagnostics.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct ErrorCode(pub String);
+
+impl ErrorCode {
+    // Syntax errors
+    pub const UNEXPECTED_TOKEN: &'static str = "E0001";
+    pub const UNTERMINATED_STRING: &'static str = "E0002";
+    pub const INVALID_NUMBER: &'static str = "E0003";
+    pub const INVALID_TIME: &'static str = "E0004";
+
+    // Type errors
+    pub const TYPE_MISMATCH: &'static str = "E0100";
+    pub const UNDEFINED_VARIABLE: &'static str = "E0101";
+    pub const UNDEFINED_ELEMENT: &'static str = "E0102";
+    pub const WRONG_ARITY: &'static str = "E0103";
+
+    // ISU rule errors
+    pub const INVALID_COMBINATION: &'static str = "E0200";
+    pub const TOO_MANY_JUMPS: &'static str = "E0201";
+    pub const ZAYAK_VIOLATION: &'static str = "E0202";
+    pub const WRONG_EDGE: &'static str = "E0203";
+    pub const DURATION_EXCEEDED: &'static str = "E0204";
+
+    // Temporal errors
+    pub const TEMPORAL_OVERLAP: &'static str = "E0300";
+    pub const UNREACHABLE_TIME: &'static str = "E0301";
+    pub const DURATION_MISMATCH: &'static str = "E0302";
+
+    // Spatial errors
+    pub const OUT_OF_BOUNDS: &'static str = "E0400";
+    pub const COLLISION: &'static str = "E0401";
+    pub const UNREACHABLE_POSITION: &'static str = "E0402";
+
+    pub fn new(code: impl Into<String>) -> Self {
+        ErrorCode(code.into())
+    }
+}
+
+impl fmt::Display for ErrorCode {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+/// A secondary label attached to a diagnostic.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Label {
+    /// Span of the label.
+    pub span: Span,
+    /// Message for the label.
+    pub message: String,
+    /// Is this the primary label?
+    pub primary: bool,
+}
+
+impl Label {
+    pub fn primary(span: Span, message: impl Into<String>) -> Self {
+        Label {
+            span,
+            message: message.into(),
+            primary: true,
+        }
+    }
+
+    pub fn secondary(span: Span, message: impl Into<String>) -> Self {
+        Label {
+            span,
+            message: message.into(),
+            primary: false,
+        }
+    }
+}
+
+/// A note or help message attached to a diagnostic.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum Note {
+    /// A note providing additional context.
+    Note(String),
+    /// A help message suggesting a fix.
+    Help(String),
+}
+
+/// A diagnostic message.
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Diagnostic {
+    /// Severity level.
+    pub severity: Severity,
+    /// Error code (optional).
+    pub code: Option<ErrorCode>,
+    /// Primary message.
+    pub message: String,
+    /// Labels pointing to source locations.
+    pub labels: Vec<Label>,
+    /// Additional notes and help.
+    pub notes: Vec<Note>,
+}
+
+impl Diagnostic {
+    /// Create a new error diagnostic.
+    pub fn error(message: impl Into<String>) -> Self {
+        Diagnostic {
+            severity: Severity::Error,
+            code: None,
+            message: message.into(),
+            labels: Vec::new(),
+            notes: Vec::new(),
+        }
+    }
+
+    /// Create a new warning diagnostic.
+    pub fn warning(message: impl Into<String>) -> Self {
+        Diagnostic {
+            severity: Severity::Warning,
+            code: None,
+            message: message.into(),
+            labels: Vec::new(),
+            notes: Vec::new(),
+        }
+    }
+
+    /// Create a new hint diagnostic.
+    pub fn hint(message: impl Into<String>) -> Self {
+        Diagnostic {
+            severity: Severity::Hint,
+            code: None,
+            message: message.into(),
+            labels: Vec::new(),
+            notes: Vec::new(),
+        }
+    }
+
+    /// Set the error code.
+    pub fn with_code(mut self, code: impl Into<String>) -> Self {
+        self.code = Some(ErrorCode::new(code));
+        self
+    }
+
+    /// Add a primary label.
+    pub fn with_label(mut self, span: Span, message: impl Into<String>) -> Self {
+        self.labels.push(Label::primary(span, message));
+        self
+    }
+
+    /// Add a secondary label.
+    pub fn with_secondary_label(mut self, span: Span, message: impl Into<String>) -> Self {
+        self.labels.push(Label::secondary(span, message));
+        self
+    }
+
+    /// Add a note.
+    pub fn with_note(mut self, note: impl Into<String>) -> Self {
+        self.notes.push(Note::Note(note.into()));
+        self
+    }
+
+    /// Add a help message.
+    pub fn with_help(mut self, help: impl Into<String>) -> Self {
+        self.notes.push(Note::Help(help.into()));
+        self
+    }
+
+    /// Is this an error?
+    pub fn is_error(&self) -> bool {
+        self.severity == Severity::Error
+    }
+
+    /// Get the primary span (first primary label).
+    pub fn primary_span(&self) -> Option<Span> {
+        self.labels.iter().find(|l| l.primary).map(|l| l.span)
+    }
+}
+
+/// Collection of diagnostics.
+#[derive(Debug, Default, Clone)]
+pub struct Diagnostics {
+    diagnostics: Vec<Diagnostic>,
+}
+
+impl Diagnostics {
+    pub fn new() -> Self {
+        Diagnostics {
+            diagnostics: Vec::new(),
+        }
+    }
+
+    /// Add a diagnostic.
+    pub fn add(&mut self, diagnostic: Diagnostic) {
+        self.diagnostics.push(diagnostic);
+    }
+
+    /// Add an error.
+    pub fn error(&mut self, message: impl Into<String>, span: Span) {
+        self.add(Diagnostic::error(message).with_label(span, "here"));
+    }
+
+    /// Add a warning.
+    pub fn warning(&mut self, message: impl Into<String>, span: Span) {
+        self.add(Diagnostic::warning(message).with_label(span, "here"));
+    }
+
+    /// Check if there are any errors.
+    pub fn has_errors(&self) -> bool {
+        self.diagnostics.iter().any(|d| d.is_error())
+    }
+
+    /// Get error count.
+    pub fn error_count(&self) -> usize {
+        self.diagnostics.iter().filter(|d| d.is_error()).count()
+    }
+
+    /// Get warning count.
+    pub fn warning_count(&self) -> usize {
+        self.diagnostics
+            .iter()
+            .filter(|d| d.severity == Severity::Warning)
+            .count()
+    }
+
+    /// Iterate over all diagnostics.
+    pub fn iter(&self) -> impl Iterator<Item = &Diagnostic> {
+        self.diagnostics.iter()
+    }
+
+    /// Take all diagnostics.
+    pub fn take(&mut self) -> Vec<Diagnostic> {
+        std::mem::take(&mut self.diagnostics)
+    }
+
+    /// Merge another diagnostics collection.
+    pub fn merge(&mut self, other: Diagnostics) {
+        self.diagnostics.extend(other.diagnostics);
+    }
+
+    /// Check if empty.
+    pub fn is_empty(&self) -> bool {
+        self.diagnostics.is_empty()
+    }
+
+    /// Number of diagnostics.
+    pub fn len(&self) -> usize {
+        self.diagnostics.len()
+    }
+}
+
+impl IntoIterator for Diagnostics {
+    type Item = Diagnostic;
+    type IntoIter = std::vec::IntoIter<Diagnostic>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.diagnostics.into_iter()
+    }
+}
+
+impl<'a> IntoIterator for &'a Diagnostics {
+    type Item = &'a Diagnostic;
+    type IntoIter = std::slice::Iter<'a, Diagnostic>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.diagnostics.iter()
+    }
+}
+
+impl Extend<Diagnostic> for Diagnostics {
+    fn extend<T: IntoIterator<Item = Diagnostic>>(&mut self, iter: T) {
+        self.diagnostics.extend(iter);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::source::FileId;
+
+    #[test]
+    fn test_diagnostic_builder() {
+        let span = Span::new(10, 20, FileId(0));
+        let diag = Diagnostic::error("Type mismatch")
+            .with_code(ErrorCode::TYPE_MISMATCH)
+            .with_label(span, "expected int, found string")
+            .with_help("Try converting the string to an integer");
+
+        assert!(diag.is_error());
+        assert_eq!(diag.code, Some(ErrorCode::new(ErrorCode::TYPE_MISMATCH)));
+        assert_eq!(diag.labels.len(), 1);
+        assert_eq!(diag.notes.len(), 1);
+    }
+
+    #[test]
+    fn test_diagnostics_collection() {
+        let mut diags = Diagnostics::new();
+        let span = Span::new(0, 10, FileId(0));
+
+        diags.error("Error 1", span);
+        diags.warning("Warning 1", span);
+        diags.error("Error 2", span);
+
+        assert!(diags.has_errors());
+        assert_eq!(diags.error_count(), 2);
+        assert_eq!(diags.warning_count(), 1);
+    }
+}
diff --git a/crates/anv-core/src/lib.rs b/crates/anv-core/src/lib.rs
new file mode 100644
index 0000000..fbe51ed
--- /dev/null
+++ b/crates/anv-core/src/lib.rs
@@ -0,0 +1,18 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Core types and utilities for Anvomidav.
+//!
+//! This crate provides the foundational domain types used throughout the
+//! Anvomidav compiler and runtime, including skating-specific primitives,
+//! source locations, and diagnostics.
+
+pub mod diagnostics;
+pub mod skating;
+pub mod source;
+pub mod types;
+
+pub use diagnostics::*;
+pub use skating::*;
+pub use source::*;
+pub use types::*;
diff --git a/crates/anv-core/src/skating.rs b/crates/anv-core/src/skating.rs
new file mode 100644
index 0000000..01746f2
--- /dev/null
+++ b/crates/anv-core/src/skating.rs
@@ -0,0 +1,528 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Figure skating domain types.
+//!
+//! This module defines the core skating primitives: edges, elements (jumps, spins,
+//! steps, lifts), and related enumerations used throughout Anvomidav.
+
+use serde::{Deserialize, Serialize};
+use std::fmt;
+
+// =============================================================================
+// Edge Types
+// =============================================================================
+
+/// Skating foot.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum Foot {
+    Left,
+    Right,
+}
+
+impl fmt::Display for Foot {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Foot::Left => write!(f, "L"),
+            Foot::Right => write!(f, "R"),
+        }
+    }
+}
+
+/// Skating direction.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum Direction {
+    Forward,
+    Backward,
+}
+
+impl fmt::Display for Direction {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Direction::Forward => write!(f, "F"),
+            Direction::Backward => write!(f, "B"),
+        }
+    }
+}
+
+/// Edge curve type.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum Curve {
+    Inside,
+    Outside,
+    Flat,
+}
+
+impl fmt::Display for Curve {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Curve::Inside => write!(f, "I"),
+            Curve::Outside => write!(f, "O"),
+            Curve::Flat => write!(f, ""),
+        }
+    }
+}
+
+/// Complete edge specification.
+///
+/// An edge is defined by foot (L/R), direction (F/B), and curve (I/O).
+/// For example: LFO = Left Forward Outside, RBI = Right Backward Inside.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum Edge {
+    LFO, LFI, LBO, LBI,
+    RFO, RFI, RBO, RBI,
+}
+
+impl Edge {
+    /// All possible edges.
+    pub const ALL: [Edge; 8] = [
+        Edge::LFO, Edge::LFI, Edge::LBO, Edge::LBI,
+        Edge::RFO, Edge::RFI, Edge::RBO, Edge::RBI,
+    ];
+
+    /// Decompose edge into components.
+    pub fn decompose(&self) -> (Foot, Direction, Curve) {
+        match self {
+            Edge::LFO => (Foot::Left, Direction::Forward, Curve::Outside),
+            Edge::LFI => (Foot::Left, Direction::Forward, Curve::Inside),
+            Edge::LBO => (Foot::Left, Direction::Backward, Curve::Outside),
+            Edge::LBI => (Foot::Left, Direction::Backward, Curve::Inside),
+            Edge::RFO => (Foot::Right, Direction::Forward, Curve::Outside),
+            Edge::RFI => (Foot::Right, Direction::Forward, Curve::Inside),
+            Edge::RBO => (Foot::Right, Direction::Backward, Curve::Outside),
+            Edge::RBI => (Foot::Right, Direction::Backward, Curve::Inside),
+        }
+    }
+
+    /// Compose edge from components.
+    pub fn compose(foot: Foot, direction: Direction, curve: Curve) -> Option<Self> {
+        match (foot, direction, curve) {
+            (Foot::Left, Direction::Forward, Curve::Outside) => Some(Edge::LFO),
+            (Foot::Left, Direction::Forward, Curve::Inside) => Some(Edge::LFI),
+            (Foot::Left, Direction::Backward, Curve::Outside) => Some(Edge::LBO),
+            (Foot::Left, Direction::Backward, Curve::Inside) => Some(Edge::LBI),
+            (Foot::Right, Direction::Forward, Curve::Outside) => Some(Edge::RFO),
+            (Foot::Right, Direction::Forward, Curve::Inside) => Some(Edge::RFI),
+            (Foot::Right, Direction::Backward, Curve::Outside) => Some(Edge::RBO),
+            (Foot::Right, Direction::Backward, Curve::Inside) => Some(Edge::RBI),
+            _ => None, // Flat edge doesn't have a simple representation
+        }
+    }
+
+    /// Get the foot.
+    pub fn foot(&self) -> Foot {
+        self.decompose().0
+    }
+
+    /// Get the direction.
+    pub fn direction(&self) -> Direction {
+        self.decompose().1
+    }
+
+    /// Get the curve.
+    pub fn curve(&self) -> Curve {
+        self.decompose().2
+    }
+
+    /// Switch to the other foot (same direction and curve).
+    pub fn switch_foot(&self) -> Self {
+        let (foot, dir, curve) = self.decompose();
+        let new_foot = match foot {
+            Foot::Left => Foot::Right,
+            Foot::Right => Foot::Left,
+        };
+        Edge::compose(new_foot, dir, curve).unwrap()
+    }
+
+    /// Parse from string like "LFO", "RBI", etc.
+    pub fn parse(s: &str) -> Option<Self> {
+        match s.to_uppercase().as_str() {
+            "LFO" => Some(Edge::LFO),
+            "LFI" => Some(Edge::LFI),
+            "LBO" => Some(Edge::LBO),
+            "LBI" => Some(Edge::LBI),
+            "RFO" => Some(Edge::RFO),
+            "RFI" => Some(Edge::RFI),
+            "RBO" => Some(Edge::RBO),
+            "RBI" => Some(Edge::RBI),
+            _ => None,
+        }
+    }
+}
+
+impl fmt::Display for Edge {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let (foot, dir, curve) = self.decompose();
+        write!(f, "{}{}{}", foot, dir, curve)
+    }
+}
+
+// =============================================================================
+// Rotation Direction
+// =============================================================================
+
+/// Rotation direction for jumps and spins.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum RotationDirection {
+    /// Counter-clockwise (most common for right-handed skaters)
+    CounterClockwise,
+    /// Clockwise (most common for left-handed skaters)
+    Clockwise,
+}
+
+impl Default for RotationDirection {
+    fn default() -> Self {
+        RotationDirection::CounterClockwise
+    }
+}
+
+// =============================================================================
+// Level (for spins, steps, lifts)
+// =============================================================================
+
+/// ISU level for leveled elements.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum Level {
+    /// Base level (no features)
+    B,
+    /// Level 1
+    L1,
+    /// Level 2
+    L2,
+    /// Level 3
+    L3,
+    /// Level 4
+    L4,
+}
+
+impl Level {
+    pub fn as_number(&self) -> u8 {
+        match self {
+            Level::B => 0,
+            Level::L1 => 1,
+            Level::L2 => 2,
+            Level::L3 => 3,
+            Level::L4 => 4,
+        }
+    }
+
+    pub fn from_number(n: u8) -> Option<Self> {
+        match n {
+            0 => Some(Level::B),
+            1 => Some(Level::L1),
+            2 => Some(Level::L2),
+            3 => Some(Level::L3),
+            4 => Some(Level::L4),
+            _ => None,
+        }
+    }
+}
+
+impl fmt::Display for Level {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Level::B => write!(f, "B"),
+            Level::L1 => write!(f, "1"),
+            Level::L2 => write!(f, "2"),
+            Level::L3 => write!(f, "3"),
+            Level::L4 => write!(f, "4"),
+        }
+    }
+}
+
+impl Default for Level {
+    fn default() -> Self {
+        Level::B
+    }
+}
+
+// =============================================================================
+// Jump Types
+// =============================================================================
+
+/// Type of jump.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum JumpKind {
+    /// Axel (A) - forward takeoff, extra half rotation
+    Axel,
+    /// Lutz (Lz) - back outside edge, toe pick
+    Lutz,
+    /// Flip (F) - back inside edge, toe pick
+    Flip,
+    /// Loop (Lo) - back outside edge, no toe pick
+    Loop,
+    /// Salchow (S) - back inside edge, no toe pick
+    Salchow,
+    /// Toe Loop (T) - back outside edge, toe pick
+    ToeLoop,
+    /// Euler/Half Loop (Eu) - connector jump in combinations
+    Euler,
+}
+
+impl JumpKind {
+    /// ISU abbreviation.
+    pub fn abbrev(&self) -> &'static str {
+        match self {
+            JumpKind::Axel => "A",
+            JumpKind::Lutz => "Lz",
+            JumpKind::Flip => "F",
+            JumpKind::Loop => "Lo",
+            JumpKind::Salchow => "S",
+            JumpKind::ToeLoop => "T",
+            JumpKind::Euler => "Eu",
+        }
+    }
+
+    /// Required entry edge for correct technique.
+    pub fn required_entry_edge(&self) -> Edge {
+        match self {
+            JumpKind::Axel => Edge::LFO,
+            JumpKind::Lutz => Edge::LBO,
+            JumpKind::Flip => Edge::LBI,
+            JumpKind::Loop => Edge::RBO,
+            JumpKind::Salchow => Edge::LBI,
+            JumpKind::ToeLoop => Edge::RBO,
+            JumpKind::Euler => Edge::RBO,
+        }
+    }
+
+    /// Standard exit edge after landing.
+    pub fn standard_exit_edge(&self) -> Edge {
+        // All jumps land on RBO for CCW rotation
+        Edge::RBO
+    }
+
+    /// Is this a toe jump (uses toe pick for takeoff)?
+    pub fn is_toe_jump(&self) -> bool {
+        matches!(self, JumpKind::Lutz | JumpKind::Flip | JumpKind::ToeLoop)
+    }
+
+    /// Parse from string.
+    pub fn parse(s: &str) -> Option<Self> {
+        match s.to_lowercase().as_str() {
+            "axel" | "a" => Some(JumpKind::Axel),
+            "lutz" | "lz" => Some(JumpKind::Lutz),
+            "flip" | "f" => Some(JumpKind::Flip),
+            "loop" | "lo" => Some(JumpKind::Loop),
+            "salchow" | "s" => Some(JumpKind::Salchow),
+            "toe_loop" | "toeloop" | "toe" | "t" => Some(JumpKind::ToeLoop),
+            "euler" | "eu" | "half_loop" => Some(JumpKind::Euler),
+            _ => None,
+        }
+    }
+}
+
+impl fmt::Display for JumpKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.abbrev())
+    }
+}
+
+/// Number of rotations for a jump.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub enum Rotations {
+    Single = 1,
+    Double = 2,
+    Triple = 3,
+    Quad = 4,
+}
+
+impl Rotations {
+    pub fn as_number(&self) -> u8 {
+        *self as u8
+    }
+
+    pub fn from_number(n: u8) -> Option<Self> {
+        match n {
+            1 => Some(Rotations::Single),
+            2 => Some(Rotations::Double),
+            3 => Some(Rotations::Triple),
+            4 => Some(Rotations::Quad),
+            _ => None,
+        }
+    }
+
+    /// Prefix for element notation (e.g., "3" for triple)
+    pub fn prefix(&self) -> &'static str {
+        match self {
+            Rotations::Single => "1",
+            Rotations::Double => "2",
+            Rotations::Triple => "3",
+            Rotations::Quad => "4",
+        }
+    }
+}
+
+impl fmt::Display for Rotations {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.prefix())
+    }
+}
+
+// =============================================================================
+// Spin Types
+// =============================================================================
+
+/// Basic spin position.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum SpinPosition {
+    Upright,
+    Sit,
+    Camel,
+    Layback,
+    Biellmann,
+}
+
+impl SpinPosition {
+    pub fn abbrev(&self) -> &'static str {
+        match self {
+            SpinPosition::Upright => "USp",
+            SpinPosition::Sit => "SSp",
+            SpinPosition::Camel => "CSp",
+            SpinPosition::Layback => "LSp",
+            SpinPosition::Biellmann => "BSp",
+        }
+    }
+}
+
+impl fmt::Display for SpinPosition {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            SpinPosition::Upright => write!(f, "upright"),
+            SpinPosition::Sit => write!(f, "sit"),
+            SpinPosition::Camel => write!(f, "camel"),
+            SpinPosition::Layback => write!(f, "layback"),
+            SpinPosition::Biellmann => write!(f, "biellmann"),
+        }
+    }
+}
+
+/// Spin modifiers.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum SpinModifier {
+    /// Flying entry
+    Flying,
+    /// Change of foot
+    Change,
+    /// Combination spin (multiple positions)
+    Combination,
+}
+
+// =============================================================================
+// Step Types
+// =============================================================================
+
+/// Types of turns and steps in step sequences.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum StepKind {
+    ThreeTurn,
+    Bracket,
+    Rocker,
+    Counter,
+    Twizzle,
+    Choctaw,
+    Mohawk,
+    Loop,
+    CrossRoll,
+    ChangeEdge,
+}
+
+impl StepKind {
+    /// Is this a difficult turn (for level features)?
+    pub fn is_difficult(&self) -> bool {
+        matches!(
+            self,
+            StepKind::Bracket | StepKind::Rocker | StepKind::Counter | StepKind::Twizzle
+        )
+    }
+}
+
+impl fmt::Display for StepKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            StepKind::ThreeTurn => write!(f, "three_turn"),
+            StepKind::Bracket => write!(f, "bracket"),
+            StepKind::Rocker => write!(f, "rocker"),
+            StepKind::Counter => write!(f, "counter"),
+            StepKind::Twizzle => write!(f, "twizzle"),
+            StepKind::Choctaw => write!(f, "choctaw"),
+            StepKind::Mohawk => write!(f, "mohawk"),
+            StepKind::Loop => write!(f, "loop"),
+            StepKind::CrossRoll => write!(f, "cross_roll"),
+            StepKind::ChangeEdge => write!(f, "change_edge"),
+        }
+    }
+}
+
+// =============================================================================
+// Lift Types (Pairs/Dance)
+// =============================================================================
+
+/// Lift group for pairs skating.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub enum LiftGroup {
+    Group1, // Armpit holds
+    Group2, // Armpit holds
+    Group3, // Waist holds
+    Group4, // Waist holds
+    Group5, // Hand-to-hand
+}
+
+impl fmt::Display for LiftGroup {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            LiftGroup::Group1 => write!(f, "Gr1"),
+            LiftGroup::Group2 => write!(f, "Gr2"),
+            LiftGroup::Group3 => write!(f, "Gr3"),
+            LiftGroup::Group4 => write!(f, "Gr4"),
+            LiftGroup::Group5 => write!(f, "Gr5"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_edge_decompose() {
+        let (foot, dir, curve) = Edge::LFO.decompose();
+        assert_eq!(foot, Foot::Left);
+        assert_eq!(dir, Direction::Forward);
+        assert_eq!(curve, Curve::Outside);
+    }
+
+    #[test]
+    fn test_edge_compose() {
+        assert_eq!(
+            Edge::compose(Foot::Right, Direction::Backward, Curve::Inside),
+            Some(Edge::RBI)
+        );
+    }
+
+    #[test]
+    fn test_edge_switch_foot() {
+        assert_eq!(Edge::LFO.switch_foot(), Edge::RFO);
+        assert_eq!(Edge::RBI.switch_foot(), Edge::LBI);
+    }
+
+    #[test]
+    fn test_edge_parse() {
+        assert_eq!(Edge::parse("LFO"), Some(Edge::LFO));
+        assert_eq!(Edge::parse("rbi"), Some(Edge::RBI));
+        assert_eq!(Edge::parse("invalid"), None);
+    }
+
+    #[test]
+    fn test_jump_kind_entry() {
+        assert_eq!(JumpKind::Lutz.required_entry_edge(), Edge::LBO);
+        assert_eq!(JumpKind::Flip.required_entry_edge(), Edge::LBI);
+    }
+
+    #[test]
+    fn test_level_ordering() {
+        assert!(Level::B < Level::L1);
+        assert!(Level::L1 < Level::L4);
+    }
+}
diff --git a/crates/anv-core/src/source.rs b/crates/anv-core/src/source.rs
new file mode 100644
index 0000000..9346c7b
--- /dev/null
+++ b/crates/anv-core/src/source.rs
@@ -0,0 +1,322 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Source location tracking.
+//!
+//! This module provides types for tracking positions in source code,
+//! essential for error reporting and IDE features.
+
+use serde::{Deserialize, Serialize};
+use std::fmt;
+use std::ops::Range;
+
+/// Unique identifier for a source file.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct FileId(pub u32);
+
+impl FileId {
+    /// Dummy file ID for generated/synthetic code.
+    pub const DUMMY: FileId = FileId(u32::MAX);
+}
+
+/// A span in the source code.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct Span {
+    /// Start byte offset (inclusive).
+    pub start: u32,
+    /// End byte offset (exclusive).
+    pub end: u32,
+    /// File containing this span.
+    pub file_id: FileId,
+}
+
+impl Span {
+    /// Create a new span.
+    pub fn new(start: u32, end: u32, file_id: FileId) -> Self {
+        debug_assert!(start <= end);
+        Span { start, end, file_id }
+    }
+
+    /// Create a dummy span for synthetic nodes.
+    pub const fn dummy() -> Self {
+        Span {
+            start: 0,
+            end: 0,
+            file_id: FileId::DUMMY,
+        }
+    }
+
+    /// Length of the span in bytes.
+    pub fn len(&self) -> u32 {
+        self.end - self.start
+    }
+
+    /// Is this span empty?
+    pub fn is_empty(&self) -> bool {
+        self.start == self.end
+    }
+
+    /// Convert to a byte range.
+    pub fn to_range(&self) -> Range<usize> {
+        (self.start as usize)..(self.end as usize)
+    }
+
+    /// Merge two spans (taking the union).
+    pub fn merge(&self, other: &Span) -> Self {
+        debug_assert_eq!(self.file_id, other.file_id);
+        Span {
+            start: self.start.min(other.start),
+            end: self.end.max(other.end),
+            file_id: self.file_id,
+        }
+    }
+
+    /// Create a zero-width span at the start of this span.
+    pub fn start_span(&self) -> Self {
+        Span {
+            start: self.start,
+            end: self.start,
+            file_id: self.file_id,
+        }
+    }
+
+    /// Create a zero-width span at the end of this span.
+    pub fn end_span(&self) -> Self {
+        Span {
+            start: self.end,
+            end: self.end,
+            file_id: self.file_id,
+        }
+    }
+}
+
+impl Default for Span {
+    fn default() -> Self {
+        Span::dummy()
+    }
+}
+
+impl fmt::Display for Span {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}..{}", self.start, self.end)
+    }
+}
+
+/// A value with an associated source span.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct Spanned<T> {
+    pub node: T,
+    pub span: Span,
+}
+
+impl<T> Spanned<T> {
+    /// Create a new spanned value.
+    pub fn new(node: T, span: Span) -> Self {
+        Spanned { node, span }
+    }
+
+    /// Create a spanned value with a dummy span.
+    pub fn dummy(node: T) -> Self {
+        Spanned {
+            node,
+            span: Span::dummy(),
+        }
+    }
+
+    /// Map the inner value.
+    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Spanned<U> {
+        Spanned {
+            node: f(self.node),
+            span: self.span,
+        }
+    }
+
+    /// Get a reference to the inner value.
+    pub fn as_ref(&self) -> Spanned<&T> {
+        Spanned {
+            node: &self.node,
+            span: self.span,
+        }
+    }
+}
+
+impl<T> std::ops::Deref for Spanned<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.node
+    }
+}
+
+impl<T> std::ops::DerefMut for Spanned<T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.node
+    }
+}
+
+/// Line and column location (1-indexed, for display).
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct LineCol {
+    /// Line number (1-indexed).
+    pub line: u32,
+    /// Column number (1-indexed, in UTF-8 code units).
+    pub col: u32,
+}
+
+impl LineCol {
+    pub fn new(line: u32, col: u32) -> Self {
+        LineCol { line, col }
+    }
+}
+
+impl fmt::Display for LineCol {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}:{}", self.line, self.col)
+    }
+}
+
+/// Source file with contents and line index.
+#[derive(Debug, Clone)]
+pub struct SourceFile {
+    /// File ID.
+    pub id: FileId,
+    /// File name/path.
+    pub name: String,
+    /// File contents.
+    pub contents: String,
+    /// Byte offsets of line starts.
+    line_starts: Vec<u32>,
+}
+
+impl SourceFile {
+    /// Create a new source file.
+    pub fn new(id: FileId, name: String, contents: String) -> Self {
+        let line_starts = std::iter::once(0)
+            .chain(
+                contents
+                    .bytes()
+                    .enumerate()
+                    .filter(|(_, b)| *b == b'\n')
+                    .map(|(i, _)| (i + 1) as u32),
+            )
+            .collect();
+
+        SourceFile {
+            id,
+            name,
+            contents,
+            line_starts,
+        }
+    }
+
+    /// Get the line/column for a byte offset.
+    pub fn line_col(&self, offset: u32) -> LineCol {
+        let line = match self.line_starts.binary_search(&offset) {
+            Ok(line) => line,
+            Err(line) => line - 1,
+        };
+        let col = offset - self.line_starts[line];
+        LineCol::new(line as u32 + 1, col + 1)
+    }
+
+    /// Get the byte offset for a line/column.
+    pub fn offset(&self, line_col: LineCol) -> Option<u32> {
+        let line_idx = (line_col.line - 1) as usize;
+        if line_idx >= self.line_starts.len() {
+            return None;
+        }
+        let line_start = self.line_starts[line_idx];
+        Some(line_start + line_col.col - 1)
+    }
+
+    /// Get the source text for a span.
+    pub fn slice(&self, span: &Span) -> &str {
+        &self.contents[span.to_range()]
+    }
+
+    /// Get a specific line (1-indexed).
+    pub fn line(&self, line_num: u32) -> Option<&str> {
+        let idx = (line_num - 1) as usize;
+        if idx >= self.line_starts.len() {
+            return None;
+        }
+        let start = self.line_starts[idx] as usize;
+        let end = self
+            .line_starts
+            .get(idx + 1)
+            .map(|&e| e as usize)
+            .unwrap_or(self.contents.len());
+        Some(self.contents[start..end].trim_end_matches('\n'))
+    }
+
+    /// Number of lines in the file.
+    pub fn line_count(&self) -> usize {
+        self.line_starts.len()
+    }
+}
+
+/// Database of source files.
+#[derive(Debug, Default)]
+pub struct SourceDb {
+    files: Vec<SourceFile>,
+}
+
+impl SourceDb {
+    pub fn new() -> Self {
+        SourceDb { files: Vec::new() }
+    }
+
+    /// Add a source file.
+    pub fn add(&mut self, name: String, contents: String) -> FileId {
+        let id = FileId(self.files.len() as u32);
+        self.files.push(SourceFile::new(id, name, contents));
+        id
+    }
+
+    /// Get a source file by ID.
+    pub fn get(&self, id: FileId) -> Option<&SourceFile> {
+        self.files.get(id.0 as usize)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_span_merge() {
+        let file = FileId(0);
+        let s1 = Span::new(10, 20, file);
+        let s2 = Span::new(15, 30, file);
+        let merged = s1.merge(&s2);
+        assert_eq!(merged.start, 10);
+        assert_eq!(merged.end, 30);
+    }
+
+    #[test]
+    fn test_source_file_line_col() {
+        let file = SourceFile::new(
+            FileId(0),
+            "test.anv".to_string(),
+            "line1\nline2\nline3".to_string(),
+        );
+
+        assert_eq!(file.line_col(0), LineCol::new(1, 1));
+        assert_eq!(file.line_col(5), LineCol::new(1, 6)); // newline
+        assert_eq!(file.line_col(6), LineCol::new(2, 1)); // start of line2
+    }
+
+    #[test]
+    fn test_source_file_line() {
+        let file = SourceFile::new(
+            FileId(0),
+            "test.anv".to_string(),
+            "line1\nline2\nline3".to_string(),
+        );
+
+        assert_eq!(file.line(1), Some("line1"));
+        assert_eq!(file.line(2), Some("line2"));
+        assert_eq!(file.line(3), Some("line3"));
+        assert_eq!(file.line(4), None);
+    }
+}
diff --git a/crates/anv-core/src/types.rs b/crates/anv-core/src/types.rs
new file mode 100644
index 0000000..dbf8c36
--- /dev/null
+++ b/crates/anv-core/src/types.rs
@@ -0,0 +1,331 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Core numeric and dimensional types.
+
+use derive_more::{Add, Display, From, Into, Mul, Sub};
+use ordered_float::OrderedFloat;
+use serde::{Deserialize, Serialize};
+
+/// Time point in seconds from program start.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Add, Sub, From, Into, Display, Serialize, Deserialize)]
+#[display(fmt = "{}", "_0.0")]
+pub struct Time(pub OrderedFloat<f64>);
+
+impl Time {
+    pub const ZERO: Time = Time(OrderedFloat(0.0));
+
+    pub fn new(seconds: f64) -> Self {
+        Time(OrderedFloat(seconds))
+    }
+
+    pub fn as_secs(&self) -> f64 {
+        self.0.into_inner()
+    }
+
+    /// Parse time from mm:ss or mm:ss.ms format
+    pub fn parse(s: &str) -> Option<Self> {
+        let parts: Vec<&str> = s.split(':').collect();
+        match parts.as_slice() {
+            [mins, secs] => {
+                let m: f64 = mins.parse().ok()?;
+                let s: f64 = secs.parse().ok()?;
+                Some(Time::new(m * 60.0 + s))
+            }
+            [hours, mins, secs] => {
+                let h: f64 = hours.parse().ok()?;
+                let m: f64 = mins.parse().ok()?;
+                let s: f64 = secs.parse().ok()?;
+                Some(Time::new(h * 3600.0 + m * 60.0 + s))
+            }
+            _ => None,
+        }
+    }
+
+    /// Format as mm:ss.ms
+    pub fn format_mmss(&self) -> String {
+        let total_secs = self.as_secs();
+        let mins = (total_secs / 60.0).floor() as u32;
+        let secs = total_secs % 60.0;
+        if secs.fract() == 0.0 {
+            format!("{}:{:02}", mins, secs as u32)
+        } else {
+            format!("{}:{:05.2}", mins, secs)
+        }
+    }
+}
+
+impl Default for Time {
+    fn default() -> Self {
+        Self::ZERO
+    }
+}
+
+/// Duration in seconds.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Add, Sub, Mul, From, Into, Display, Serialize, Deserialize)]
+#[display(fmt = "{}s", "_0.0")]
+pub struct Duration(pub OrderedFloat<f64>);
+
+impl Duration {
+    pub const ZERO: Duration = Duration(OrderedFloat(0.0));
+
+    pub fn new(seconds: f64) -> Self {
+        Duration(OrderedFloat(seconds))
+    }
+
+    pub fn from_millis(ms: u64) -> Self {
+        Duration::new(ms as f64 / 1000.0)
+    }
+
+    pub fn as_secs(&self) -> f64 {
+        self.0.into_inner()
+    }
+
+    pub fn as_millis(&self) -> u64 {
+        (self.as_secs() * 1000.0) as u64
+    }
+}
+
+impl Default for Duration {
+    fn default() -> Self {
+        Self::ZERO
+    }
+}
+
+/// Angle in radians.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Add, Sub, Mul, From, Into, Serialize, Deserialize)]
+pub struct Angle(pub OrderedFloat<f64>);
+
+impl Angle {
+    pub const ZERO: Angle = Angle(OrderedFloat(0.0));
+    pub const PI: Angle = Angle(OrderedFloat(std::f64::consts::PI));
+    pub const TWO_PI: Angle = Angle(OrderedFloat(std::f64::consts::TAU));
+
+    pub fn from_radians(rad: f64) -> Self {
+        Angle(OrderedFloat(rad))
+    }
+
+    pub fn from_degrees(deg: f64) -> Self {
+        Angle::from_radians(deg.to_radians())
+    }
+
+    pub fn as_radians(&self) -> f64 {
+        self.0.into_inner()
+    }
+
+    pub fn as_degrees(&self) -> f64 {
+        self.as_radians().to_degrees()
+    }
+
+    /// Normalize to [0, 2π)
+    pub fn normalize(&self) -> Self {
+        let rad = self.as_radians().rem_euclid(std::f64::consts::TAU);
+        Angle::from_radians(rad)
+    }
+}
+
+impl Default for Angle {
+    fn default() -> Self {
+        Self::ZERO
+    }
+}
+
+impl std::fmt::Display for Angle {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:.1}°", self.as_degrees())
+    }
+}
+
+/// 2D position on the ice surface.
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+pub struct Position {
+    /// X coordinate (along long axis, positive toward judges)
+    pub x: f64,
+    /// Y coordinate (along short axis, positive toward right)
+    pub y: f64,
+}
+
+impl Position {
+    pub const ORIGIN: Position = Position { x: 0.0, y: 0.0 };
+
+    pub fn new(x: f64, y: f64) -> Self {
+        Position { x, y }
+    }
+
+    pub fn distance(&self, other: &Position) -> f64 {
+        ((self.x - other.x).powi(2) + (self.y - other.y).powi(2)).sqrt()
+    }
+
+    pub fn translate(&self, dx: f64, dy: f64) -> Self {
+        Position::new(self.x + dx, self.y + dy)
+    }
+
+    pub fn rotate(&self, angle: Angle, center: &Position) -> Self {
+        let cos = angle.as_radians().cos();
+        let sin = angle.as_radians().sin();
+        let dx = self.x - center.x;
+        let dy = self.y - center.y;
+        Position::new(
+            center.x + dx * cos - dy * sin,
+            center.y + dx * sin + dy * cos,
+        )
+    }
+}
+
+impl Default for Position {
+    fn default() -> Self {
+        Self::ORIGIN
+    }
+}
+
+impl std::fmt::Display for Position {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "({:.2}, {:.2})", self.x, self.y)
+    }
+}
+
+/// 3D position (includes height for jumps).
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+pub struct Position3 {
+    pub x: f64,
+    pub y: f64,
+    pub z: f64,
+}
+
+impl Position3 {
+    pub const ORIGIN: Position3 = Position3 { x: 0.0, y: 0.0, z: 0.0 };
+
+    pub fn new(x: f64, y: f64, z: f64) -> Self {
+        Position3 { x, y, z }
+    }
+
+    pub fn from_2d(pos: Position, z: f64) -> Self {
+        Position3 { x: pos.x, y: pos.y, z }
+    }
+
+    pub fn to_2d(&self) -> Position {
+        Position::new(self.x, self.y)
+    }
+
+    pub fn distance(&self, other: &Position3) -> f64 {
+        ((self.x - other.x).powi(2) + (self.y - other.y).powi(2) + (self.z - other.z).powi(2)).sqrt()
+    }
+}
+
+impl Default for Position3 {
+    fn default() -> Self {
+        Self::ORIGIN
+    }
+}
+
+/// 2D velocity vector.
+#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
+pub struct Velocity {
+    pub vx: f64,
+    pub vy: f64,
+}
+
+impl Velocity {
+    pub const ZERO: Velocity = Velocity { vx: 0.0, vy: 0.0 };
+
+    pub fn new(vx: f64, vy: f64) -> Self {
+        Velocity { vx, vy }
+    }
+
+    pub fn from_polar(speed: f64, angle: Angle) -> Self {
+        Velocity::new(
+            speed * angle.as_radians().cos(),
+            speed * angle.as_radians().sin(),
+        )
+    }
+
+    pub fn speed(&self) -> f64 {
+        (self.vx.powi(2) + self.vy.powi(2)).sqrt()
+    }
+
+    pub fn direction(&self) -> Angle {
+        Angle::from_radians(self.vy.atan2(self.vx))
+    }
+}
+
+impl Default for Velocity {
+    fn default() -> Self {
+        Self::ZERO
+    }
+}
+
+/// Beat position in musical time.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+pub struct Beat {
+    /// Measure number (1-indexed)
+    pub measure: u32,
+    /// Beat within measure (1-indexed)
+    pub beat: u32,
+}
+
+impl Beat {
+    pub fn new(measure: u32, beat: u32) -> Self {
+        Beat { measure, beat }
+    }
+
+    /// Convert to absolute beat number (0-indexed)
+    pub fn to_absolute(&self, beats_per_measure: u32) -> u32 {
+        (self.measure - 1) * beats_per_measure + (self.beat - 1)
+    }
+
+    /// Convert from absolute beat number
+    pub fn from_absolute(abs_beat: u32, beats_per_measure: u32) -> Self {
+        Beat {
+            measure: abs_beat / beats_per_measure + 1,
+            beat: abs_beat % beats_per_measure + 1,
+        }
+    }
+}
+
+impl std::fmt::Display for Beat {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}.{}", self.measure, self.beat)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn test_time_parse() {
+        assert_eq!(Time::parse("1:30"), Some(Time::new(90.0)));
+        assert_eq!(Time::parse("2:45.5"), Some(Time::new(165.5)));
+        assert_eq!(Time::parse("0:00"), Some(Time::new(0.0)));
+    }
+
+    #[test]
+    fn test_time_format() {
+        assert_eq!(Time::new(90.0).format_mmss(), "1:30");
+        assert_eq!(Time::new(165.5).format_mmss(), "2:45.50");
+    }
+
+    #[test]
+    fn test_angle_normalize() {
+        let a = Angle::from_degrees(450.0);
+        assert!((a.normalize().as_degrees() - 90.0).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_position_distance() {
+        let p1 = Position::new(0.0, 0.0);
+        let p2 = Position::new(3.0, 4.0);
+        assert!((p1.distance(&p2) - 5.0).abs() < 0.001);
+    }
+
+    #[test]
+    fn test_beat_conversion() {
+        let beat = Beat::new(3, 2);
+        assert_eq!(beat.to_absolute(4), 9); // (3-1)*4 + (2-1) = 9
+        assert_eq!(Beat::from_absolute(9, 4), beat);
+    }
+}
diff --git a/crates/anv-syntax/Cargo.toml b/crates/anv-syntax/Cargo.toml
new file mode 100644
index 0000000..fab4ca0
--- /dev/null
+++ b/crates/anv-syntax/Cargo.toml
@@ -0,0 +1,23 @@
+# SPDX-FileCopyrightText: 2025 hyperpolymath
+# SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+[package]
+name = "anv-syntax"
+version = "0.1.0"
+edition = "2021"
+description = "Lexer and parser for the Anvomidav figure skating DSL"
+license = "MIT OR AGPL-3.0-or-later"
+repository = "https://github.com/hyperpolymath/anvomidav"
+readme = "README.md"
+keywords = ["figure-skating", "dsl", "parser", "lexer"]
+categories = ["parsing", "compilers"]
+
+[dependencies]
+anv-core = { path = "../anv-core" }
+logos = { workspace = true }
+chumsky = { workspace = true }
+thiserror = { workspace = true }
+ordered-float = { workspace = true }
+
+[dev-dependencies]
+pretty_assertions = "1.4"
diff --git a/crates/anv-syntax/src/ast.rs b/crates/anv-syntax/src/ast.rs
new file mode 100644
index 0000000..6b02e78
--- /dev/null
+++ b/crates/anv-syntax/src/ast.rs
@@ -0,0 +1,770 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Abstract Syntax Tree for Anvomidav.
+//!
+//! This module defines the AST produced by parsing Anvomidav source code.
+
+use anv_core::skating::{Curve, Edge, JumpKind, Level, LiftGroup, Rotations, SpinPosition};
+use anv_core::source::Span;
+use ordered_float::OrderedFloat;
+use std::fmt;
+
+/// A node with source location information.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Spanned<T> {
+    pub node: T,
+    pub span: Span,
+}
+
+impl<T> Spanned<T> {
+    pub fn new(node: T, span: Span) -> Self {
+        Spanned { node, span }
+    }
+
+    pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Spanned<U> {
+        Spanned {
+            node: f(self.node),
+            span: self.span,
+        }
+    }
+}
+
+/// An identifier.
+pub type Ident = Spanned<String>;
+
+/// A program is the top-level compilation unit.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Program {
+    /// Program name.
+    pub name: Ident,
+    /// Documentation comments.
+    pub docs: Vec<String>,
+    /// Import declarations.
+    pub imports: Vec<Import>,
+    /// Type definitions.
+    pub types: Vec<TypeDef>,
+    /// Function definitions.
+    pub functions: Vec<FnDef>,
+    /// Segment definitions (the main content).
+    pub segments: Vec<Segment>,
+}
+
+/// An import declaration.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Import {
+    /// Module path.
+    pub path: Vec<Ident>,
+    /// Optional alias.
+    pub alias: Option<Ident>,
+    /// Specific items to import (None means all).
+    pub items: Option<Vec<ImportItem>>,
+    pub span: Span,
+}
+
+/// An imported item.
+#[derive(Debug, Clone, PartialEq)]
+pub struct ImportItem {
+    pub name: Ident,
+    pub alias: Option<Ident>,
+}
+
+/// A type definition.
+#[derive(Debug, Clone, PartialEq)]
+pub struct TypeDef {
+    /// Type name.
+    pub name: Ident,
+    /// Type parameters.
+    pub params: Vec<TypeParam>,
+    /// Type body.
+    pub body: TypeBody,
+    /// Documentation.
+    pub docs: Vec<String>,
+    pub span: Span,
+}
+
+/// A type parameter.
+#[derive(Debug, Clone, PartialEq)]
+pub struct TypeParam {
+    pub name: Ident,
+    pub bounds: Vec<TypeExpr>,
+}
+
+/// The body of a type definition.
+#[derive(Debug, Clone, PartialEq)]
+pub enum TypeBody {
+    /// Type alias.
+    Alias(TypeExpr),
+    /// Record type.
+    Record(Vec<Field>),
+    /// Enum/variant type.
+    Enum(Vec<Variant>),
+}
+
+/// A record field.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Field {
+    pub name: Ident,
+    pub ty: TypeExpr,
+    pub docs: Vec<String>,
+}
+
+/// An enum variant.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Variant {
+    pub name: Ident,
+    pub fields: Option<Vec<Field>>,
+    pub docs: Vec<String>,
+}
+
+/// A type expression.
+#[derive(Debug, Clone, PartialEq)]
+pub enum TypeExpr {
+    /// Named type.
+    Named(Ident),
+    /// Generic type application.
+    App(Box<TypeExpr>, Vec<TypeExpr>),
+    /// Function type.
+    Fn(Vec<TypeExpr>, Box<TypeExpr>),
+    /// Tuple type.
+    Tuple(Vec<TypeExpr>),
+    /// Array type.
+    Array(Box<TypeExpr>),
+    /// Optional type.
+    Optional(Box<TypeExpr>),
+    /// Refinement type: { x: T | P(x) }
+    Refinement {
+        base: Box<TypeExpr>,
+        var: Ident,
+        predicate: Box<Expr>,
+    },
+}
+
+/// A function definition.
+#[derive(Debug, Clone, PartialEq)]
+pub struct FnDef {
+    /// Function name.
+    pub name: Ident,
+    /// Type parameters.
+    pub type_params: Vec<TypeParam>,
+    /// Parameters.
+    pub params: Vec<Param>,
+    /// Return type.
+    pub return_ty: Option<TypeExpr>,
+    /// Function body.
+    pub body: Expr,
+    /// Documentation.
+    pub docs: Vec<String>,
+    pub span: Span,
+}
+
+/// A function parameter.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Param {
+    pub name: Ident,
+    pub ty: Option<TypeExpr>,
+    pub default: Option<Expr>,
+}
+
+/// A program segment (e.g., short program, free skate).
+#[derive(Debug, Clone, PartialEq)]
+pub struct Segment {
+    /// Segment name.
+    pub name: Ident,
+    /// Segment kind.
+    pub kind: SegmentKind,
+    /// Music information.
+    pub music: Option<MusicDef>,
+    /// Duration constraints.
+    pub duration: Option<DurationDef>,
+    /// Skater definitions (for pairs/ice dance).
+    pub skaters: Vec<SkaterDef>,
+    /// Element sequences.
+    pub sequences: Vec<Sequence>,
+    /// Documentation.
+    pub docs: Vec<String>,
+    pub span: Span,
+}
+
+/// Segment kind.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SegmentKind {
+    Short,
+    Free,
+    Pattern,
+}
+
+impl fmt::Display for SegmentKind {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            SegmentKind::Short => write!(f, "short"),
+            SegmentKind::Free => write!(f, "free"),
+            SegmentKind::Pattern => write!(f, "pattern"),
+        }
+    }
+}
+
+/// Music definition.
+#[derive(Debug, Clone, PartialEq)]
+pub struct MusicDef {
+    /// Music file or reference.
+    pub source: String,
+    /// Tempo in BPM.
+    pub tempo: Option<f64>,
+    /// Beat structure.
+    pub beats: Option<Vec<BeatMark>>,
+    pub span: Span,
+}
+
+/// A beat marker.
+#[derive(Debug, Clone, PartialEq)]
+pub struct BeatMark {
+    pub time: TimeExpr,
+    pub beat: i64,
+}
+
+/// Duration definition.
+#[derive(Debug, Clone, PartialEq)]
+pub struct DurationDef {
+    /// Minimum duration.
+    pub min: Option<TimeExpr>,
+    /// Maximum duration.
+    pub max: Option<TimeExpr>,
+    pub span: Span,
+}
+
+/// Skater definition (for pairs/ice dance).
+#[derive(Debug, Clone, PartialEq)]
+pub struct SkaterDef {
+    pub name: Ident,
+    pub role: Option<SkaterRole>,
+    pub span: Span,
+}
+
+/// Skater role in pairs.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SkaterRole {
+    Lead,
+    Follow,
+}
+
+/// A sequence of elements.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Sequence {
+    pub name: Option<Ident>,
+    pub elements: Vec<Element>,
+    pub span: Span,
+}
+
+/// A skating element.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Element {
+    pub kind: ElementKind,
+    pub timing: Option<Timing>,
+    pub position: Option<PositionExpr>,
+    pub annotations: Vec<Annotation>,
+    pub span: Span,
+}
+
+/// Element kind.
+#[derive(Debug, Clone, PartialEq)]
+pub enum ElementKind {
+    /// Jump element.
+    Jump(JumpElement),
+    /// Spin element.
+    Spin(SpinElement),
+    /// Step sequence.
+    StepSequence(StepSequence),
+    /// Lift (pairs).
+    Lift(LiftElement),
+    /// Death spiral (pairs).
+    DeathSpiral(DeathSpiralElement),
+    /// Throw jump (pairs).
+    Throw(ThrowElement),
+    /// Twist lift (pairs).
+    Twist(TwistElement),
+    /// Transition.
+    Transition(TransitionElement),
+    /// Choreographic element.
+    Choreographic(ChoreographicElement),
+    /// Pattern (ice dance).
+    Pattern(PatternElement),
+    /// Parallel execution (pairs/ice dance).
+    Parallel(ParallelElement),
+    /// Synchronized execution.
+    Sync(SyncElement),
+}
+
+/// A jump element.
+#[derive(Debug, Clone, PartialEq)]
+pub struct JumpElement {
+    /// Jump kind.
+    pub kind: JumpKind,
+    /// Rotation count.
+    pub rotations: Rotations,
+    /// Entry edge (if specified).
+    pub entry_edge: Option<Edge>,
+    /// Exit edge (if specified).
+    pub exit_edge: Option<Edge>,
+    /// Combination (following jumps).
+    pub combination: Vec<JumpElement>,
+}
+
+/// A spin element.
+#[derive(Debug, Clone, PartialEq)]
+pub struct SpinElement {
+    /// Spin positions.
+    pub positions: Vec<SpinPositionDef>,
+    /// Minimum revolutions.
+    pub min_revs: Option<i64>,
+    /// Level features.
+    pub features: Vec<SpinFeature>,
+    /// Target level.
+    pub level: Option<Level>,
+}
+
+/// A spin position definition.
+#[derive(Debug, Clone, PartialEq)]
+pub struct SpinPositionDef {
+    pub position: SpinPosition,
+    pub revolutions: Option<i64>,
+    pub change_edge: bool,
+    pub change_foot: bool,
+}
+
+/// Spin level features.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SpinFeature {
+    DifficultVariation,
+    ChangeOfFoot,
+    ChangeOfEdge,
+    JumpEntry,
+    FlyingEntry,
+    BackEntry,
+    DifficultPosition,
+    TravelSuppressed,
+}
+
+/// A step sequence.
+#[derive(Debug, Clone, PartialEq)]
+pub struct StepSequence {
+    /// Pattern type.
+    pub pattern: StepPattern,
+    /// Target level.
+    pub level: Option<Level>,
+    /// Individual steps.
+    pub steps: Vec<StepDef>,
+}
+
+/// Step sequence pattern.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum StepPattern {
+    Straight,
+    Circular,
+    Serpentine,
+    Diagonal,
+    Midline,
+}
+
+impl fmt::Display for StepPattern {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            StepPattern::Straight => write!(f, "straight"),
+            StepPattern::Circular => write!(f, "circular"),
+            StepPattern::Serpentine => write!(f, "serpentine"),
+            StepPattern::Diagonal => write!(f, "diagonal"),
+            StepPattern::Midline => write!(f, "midline"),
+        }
+    }
+}
+
+/// A step definition.
+#[derive(Debug, Clone, PartialEq)]
+pub struct StepDef {
+    pub edge: Edge,
+    pub curve: Option<Curve>,
+    pub turn: Option<TurnKind>,
+}
+
+/// Turn types.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TurnKind {
+    ThreeTurn,
+    Bracket,
+    Rocker,
+    Counter,
+    Mohawk,
+    Choctaw,
+    Twizzle,
+}
+
+/// A lift element (pairs).
+#[derive(Debug, Clone, PartialEq)]
+pub struct LiftElement {
+    /// Lift group.
+    pub group: LiftGroup,
+    /// Difficulty level.
+    pub level: Option<Level>,
+    /// Entry method.
+    pub entry: Option<String>,
+    /// Exit method.
+    pub exit: Option<String>,
+}
+
+/// A death spiral element (pairs).
+#[derive(Debug, Clone, PartialEq)]
+pub struct DeathSpiralElement {
+    /// Edge (BI, FI, BO, FO).
+    pub edge: Edge,
+    /// Difficulty level.
+    pub level: Option<Level>,
+}
+
+/// A throw jump element (pairs).
+#[derive(Debug, Clone, PartialEq)]
+pub struct ThrowElement {
+    /// Jump kind.
+    pub kind: JumpKind,
+    /// Rotation count.
+    pub rotations: Rotations,
+}
+
+/// A twist lift element (pairs).
+#[derive(Debug, Clone, PartialEq)]
+pub struct TwistElement {
+    /// Rotation count.
+    pub rotations: Rotations,
+    /// Difficulty level.
+    pub level: Option<Level>,
+}
+
+/// A transition element.
+#[derive(Debug, Clone, PartialEq)]
+pub struct TransitionElement {
+    /// Transition description.
+    pub description: Option<String>,
+    /// Movement quality.
+    pub quality: Option<MovementQuality>,
+}
+
+/// Movement quality.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum MovementQuality {
+    Gliding,
+    Stroking,
+    Crossovers,
+    EdgeWork,
+    Footwork,
+}
+
+/// A choreographic element.
+#[derive(Debug, Clone, PartialEq)]
+pub struct ChoreographicElement {
+    /// Element kind.
+    pub kind: ChoreographicKind,
+    /// Description.
+    pub description: Option<String>,
+}
+
+/// Choreographic element kind.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ChoreographicKind {
+    Spiral,
+    Spread,
+    Ina,
+    Hydroblading,
+    Pivot,
+    Choreographic,
+}
+
+/// A pattern element (ice dance).
+#[derive(Debug, Clone, PartialEq)]
+pub struct PatternElement {
+    /// Pattern name.
+    pub name: String,
+    /// Key points.
+    pub key_points: Vec<KeyPoint>,
+}
+
+/// A key point in a pattern.
+#[derive(Debug, Clone, PartialEq)]
+pub struct KeyPoint {
+    pub position: PositionExpr,
+    pub edge: Edge,
+}
+
+/// Parallel execution for pairs/ice dance.
+#[derive(Debug, Clone, PartialEq)]
+pub struct ParallelElement {
+    pub branches: Vec<(Ident, Vec<Element>)>,
+}
+
+/// Synchronized execution.
+#[derive(Debug, Clone, PartialEq)]
+pub struct SyncElement {
+    pub elements: Vec<Element>,
+}
+
+/// Timing specification.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Timing {
+    /// At specific time.
+    At(TimeExpr),
+    /// Range of time.
+    Range(TimeExpr, TimeExpr),
+    /// Duration only.
+    Duration(TimeExpr),
+    /// Beat-relative.
+    Beat(i64),
+    /// After previous.
+    After(TimeExpr),
+}
+
+/// Time expression.
+#[derive(Debug, Clone, PartialEq)]
+pub enum TimeExpr {
+    /// Literal time (seconds).
+    Literal(OrderedFloat<f64>),
+    /// Time from string (mm:ss format).
+    Formatted(String),
+    /// Variable reference.
+    Var(Ident),
+    /// Binary operation.
+    BinOp(Box<TimeExpr>, TimeBinOp, Box<TimeExpr>),
+}
+
+/// Time binary operators.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum TimeBinOp {
+    Add,
+    Sub,
+}
+
+/// Position expression.
+#[derive(Debug, Clone, PartialEq)]
+pub enum PositionExpr {
+    /// Literal (x, y) in meters.
+    Literal(OrderedFloat<f64>, OrderedFloat<f64>),
+    /// Named position (center, corner, etc.).
+    Named(String),
+    /// Variable reference.
+    Var(Ident),
+    /// Relative to another position.
+    Relative(Box<PositionExpr>, OrderedFloat<f64>, OrderedFloat<f64>),
+}
+
+/// An annotation on an element.
+#[derive(Debug, Clone, PartialEq)]
+pub struct Annotation {
+    pub name: Ident,
+    pub args: Vec<Expr>,
+}
+
+/// An expression.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Expr {
+    /// Integer literal.
+    Int(i64),
+    /// Float literal.
+    Float(OrderedFloat<f64>),
+    /// String literal.
+    String(String),
+    /// Boolean literal.
+    Bool(bool),
+    /// Time literal.
+    Time(TimeExpr),
+    /// Position literal.
+    Position(PositionExpr),
+    /// Variable reference.
+    Var(Ident),
+    /// Binary operation.
+    BinOp(Box<Spanned<Expr>>, BinOp, Box<Spanned<Expr>>),
+    /// Unary operation.
+    UnaryOp(UnaryOp, Box<Spanned<Expr>>),
+    /// Function call.
+    Call(Box<Spanned<Expr>>, Vec<Spanned<Expr>>),
+    /// Field access.
+    Field(Box<Spanned<Expr>>, Ident),
+    /// Index access.
+    Index(Box<Spanned<Expr>>, Box<Spanned<Expr>>),
+    /// If expression.
+    If(Box<Spanned<Expr>>, Box<Spanned<Expr>>, Option<Box<Spanned<Expr>>>),
+    /// Match expression.
+    Match(Box<Spanned<Expr>>, Vec<MatchArm>),
+    /// Let binding.
+    Let(Ident, Option<TypeExpr>, Box<Spanned<Expr>>, Box<Spanned<Expr>>),
+    /// Block expression.
+    Block(Vec<Spanned<Stmt>>),
+    /// Lambda expression.
+    Lambda(Vec<Param>, Box<Spanned<Expr>>),
+    /// Tuple expression.
+    Tuple(Vec<Spanned<Expr>>),
+    /// Array expression.
+    Array(Vec<Spanned<Expr>>),
+    /// Record expression.
+    Record(Vec<(Ident, Spanned<Expr>)>),
+    /// Element expression (inline skating element).
+    Element(Box<Element>),
+}
+
+/// Binary operators.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum BinOp {
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Mod,
+    Eq,
+    NotEq,
+    Lt,
+    LtEq,
+    Gt,
+    GtEq,
+    And,
+    Or,
+}
+
+impl fmt::Display for BinOp {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            BinOp::Add => write!(f, "+"),
+            BinOp::Sub => write!(f, "-"),
+            BinOp::Mul => write!(f, "*"),
+            BinOp::Div => write!(f, "/"),
+            BinOp::Mod => write!(f, "%"),
+            BinOp::Eq => write!(f, "=="),
+            BinOp::NotEq => write!(f, "!="),
+            BinOp::Lt => write!(f, "<"),
+            BinOp::LtEq => write!(f, "<="),
+            BinOp::Gt => write!(f, ">"),
+            BinOp::GtEq => write!(f, ">="),
+            BinOp::And => write!(f, "&&"),
+            BinOp::Or => write!(f, "||"),
+        }
+    }
+}
+
+/// Unary operators.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum UnaryOp {
+    Neg,
+    Not,
+}
+
+impl fmt::Display for UnaryOp {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            UnaryOp::Neg => write!(f, "-"),
+            UnaryOp::Not => write!(f, "!"),
+        }
+    }
+}
+
+/// A match arm.
+#[derive(Debug, Clone, PartialEq)]
+pub struct MatchArm {
+    pub pattern: Pattern,
+    pub guard: Option<Spanned<Expr>>,
+    pub body: Spanned<Expr>,
+}
+
+/// A pattern for matching.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Pattern {
+    /// Wildcard pattern.
+    Wildcard,
+    /// Variable binding.
+    Var(Ident),
+    /// Literal pattern.
+    Literal(Literal),
+    /// Constructor pattern.
+    Constructor(Ident, Vec<Pattern>),
+    /// Tuple pattern.
+    Tuple(Vec<Pattern>),
+    /// Record pattern.
+    Record(Vec<(Ident, Pattern)>),
+    /// Or pattern.
+    Or(Vec<Pattern>),
+    /// Guard pattern.
+    Guard(Box<Pattern>, Spanned<Expr>),
+}
+
+/// A literal value.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Literal {
+    Int(i64),
+    Float(OrderedFloat<f64>),
+    String(String),
+    Bool(bool),
+}
+
+/// A statement.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Stmt {
+    /// Expression statement.
+    Expr(Expr),
+    /// Let binding.
+    Let(Ident, Option<TypeExpr>, Expr),
+    /// Assignment.
+    Assign(Spanned<Expr>, Expr),
+    /// Return statement.
+    Return(Option<Expr>),
+    /// For loop.
+    For(Ident, Expr, Vec<Spanned<Stmt>>),
+    /// While loop.
+    While(Expr, Vec<Spanned<Stmt>>),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anv_core::source::FileId;
+
+    fn dummy_span() -> Span {
+        Span::new(0, 0, FileId(0))
+    }
+
+    fn ident(name: &str) -> Ident {
+        Spanned::new(name.to_string(), dummy_span())
+    }
+
+    #[test]
+    fn test_spanned() {
+        let spanned = Spanned::new(42, dummy_span());
+        assert_eq!(spanned.node, 42);
+    }
+
+    #[test]
+    fn test_segment_kind_display() {
+        assert_eq!(format!("{}", SegmentKind::Short), "short");
+        assert_eq!(format!("{}", SegmentKind::Free), "free");
+        assert_eq!(format!("{}", SegmentKind::Pattern), "pattern");
+    }
+
+    #[test]
+    fn test_jump_element() {
+        let jump = JumpElement {
+            kind: JumpKind::Axel,
+            rotations: Rotations::Triple,
+            entry_edge: None,
+            exit_edge: None,
+            combination: vec![],
+        };
+        assert_eq!(jump.kind, JumpKind::Axel);
+        assert_eq!(jump.rotations, Rotations::Triple);
+    }
+
+    #[test]
+    fn test_program_structure() {
+        let program = Program {
+            name: ident("test_program"),
+            docs: vec![],
+            imports: vec![],
+            types: vec![],
+            functions: vec![],
+            segments: vec![],
+        };
+        assert_eq!(program.name.node, "test_program");
+    }
+}
diff --git a/crates/anv-syntax/src/lib.rs b/crates/anv-syntax/src/lib.rs
new file mode 100644
index 0000000..3e37273
--- /dev/null
+++ b/crates/anv-syntax/src/lib.rs
@@ -0,0 +1,39 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Syntax processing for Anvomidav.
+//!
+//! This crate provides lexical analysis and parsing for the Anvomidav DSL.
+//! It includes:
+//!
+//! - **Lexer** (`token` module): Tokenizes source code using `logos`
+//! - **AST** (`ast` module): Abstract syntax tree definitions
+//! - **Parser** (`parser` module): Parses tokens into AST using `chumsky`
+//!
+//! # Example
+//!
+//! ```
+//! use anv_syntax::{parse, ast::Program};
+//! use anv_core::source::FileId;
+//!
+//! let source = r#"
+//!     program my_routine {
+//!         segment intro: short {
+//!             sequence {
+//!                 jump triple axel at 1:30
+//!             }
+//!         }
+//!     }
+//! "#;
+//!
+//! let result = parse(source, FileId(0));
+//! assert!(result.is_ok());
+//! ```
+
+pub mod ast;
+pub mod parser;
+pub mod token;
+
+pub use ast::*;
+pub use parser::{parse, parse_tokens, ParseError};
+pub use token::{Lexer, LexError, SpannedToken, Token};
diff --git a/crates/anv-syntax/src/parser.rs b/crates/anv-syntax/src/parser.rs
new file mode 100644
index 0000000..9481942
--- /dev/null
+++ b/crates/anv-syntax/src/parser.rs
@@ -0,0 +1,780 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Parser for Anvomidav using chumsky.
+//!
+//! This module implements a recursive descent parser with error recovery
+//! for the Anvomidav DSL.
+
+use crate::ast::*;
+use crate::token::{LexError, Lexer, SpannedToken, Token};
+use anv_core::skating::{JumpKind, Level, Rotations, SpinPosition};
+use anv_core::source::{FileId, Span};
+use chumsky::prelude::*;
+use ordered_float::OrderedFloat;
+
+/// Parser input type: a stream of spanned tokens.
+pub type TokenStream<'a> = &'a [SpannedToken];
+
+/// Parser error type.
+#[derive(Debug, Clone)]
+pub struct ParseError {
+    pub span: std::ops::Range<usize>,
+    pub message: String,
+    pub expected: Vec<String>,
+    pub found: Option<String>,
+}
+
+impl std::fmt::Display for ParseError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.message)?;
+        if !self.expected.is_empty() {
+            write!(f, ", expected one of: {}", self.expected.join(", "))?;
+        }
+        if let Some(ref found) = self.found {
+            write!(f, ", found: {}", found)?;
+        }
+        Ok(())
+    }
+}
+
+impl std::error::Error for ParseError {}
+
+/// Convert byte offset range to Span.
+fn to_span(range: std::ops::Range<usize>, file_id: FileId) -> Span {
+    Span::new(range.start as u32, range.end as u32, file_id)
+}
+
+/// Create a spanned node from a value and span range.
+fn spanned<T>(node: T, span: std::ops::Range<usize>, file_id: FileId) -> Spanned<T> {
+    Spanned::new(node, to_span(span, file_id))
+}
+
+/// Main parsing function.
+pub fn parse(source: &str, file_id: FileId) -> Result<Program, Vec<ParseError>> {
+    // First, lex the source
+    let tokens = match Lexer::tokenize(source) {
+        Ok(tokens) => tokens,
+        Err(lex_err) => {
+            return Err(vec![ParseError {
+                span: lex_err.span,
+                message: lex_err.message,
+                expected: vec![],
+                found: None,
+            }])
+        }
+    };
+
+    // Then parse the token stream
+    parse_tokens(&tokens, file_id)
+}
+
+/// Parse a token stream into a Program.
+pub fn parse_tokens(tokens: &[SpannedToken], file_id: FileId) -> Result<Program, Vec<ParseError>> {
+    let parser = program_parser(file_id);
+
+    // Build input for chumsky
+    let len = tokens.last().map(|t| t.span.end).unwrap_or(0);
+    let eoi = len..len;
+
+    let stream = chumsky::Stream::from_iter(
+        eoi,
+        tokens.iter().map(|t| (t.token.clone(), t.span.clone())),
+    );
+
+    match parser.parse(stream) {
+        Ok(program) => Ok(program),
+        Err(errors) => Err(errors
+            .into_iter()
+            .map(|e| ParseError {
+                span: e.span(),
+                message: e.to_string(),
+                expected: e
+                    .expected()
+                    .filter_map(|e| e.as_ref().map(|t| format!("{:?}", t)))
+                    .collect(),
+                found: e.found().map(|t| format!("{:?}", t)),
+            })
+            .collect()),
+    }
+}
+
+/// Create identifier parser.
+fn ident_parser(
+    file_id: FileId,
+) -> impl Parser<Token, Ident, Error = Simple<Token>> + Clone {
+    select! {
+        Token::Ident(name) => name,
+    }
+    .map_with_span(move |name, span| spanned(name, span, file_id))
+    .labelled("identifier")
+}
+
+/// Create literal parser.
+fn literal_parser() -> impl Parser<Token, Literal, Error = Simple<Token>> + Clone {
+    select! {
+        Token::Integer(n) => Literal::Int(n),
+        Token::Float(f) => Literal::Float(f),
+        Token::String(s) => Literal::String(s),
+        Token::True => Literal::Bool(true),
+        Token::False => Literal::Bool(false),
+    }
+    .labelled("literal")
+}
+
+/// Create time expression parser.
+fn time_expr_parser(
+    file_id: FileId,
+) -> impl Parser<Token, TimeExpr, Error = Simple<Token>> + Clone {
+    let ident = ident_parser(file_id);
+
+    let literal = select! {
+        Token::Float(f) => TimeExpr::Literal(f),
+        Token::Integer(n) => TimeExpr::Literal(OrderedFloat(n as f64)),
+        Token::Time(s) => TimeExpr::Formatted(s),
+    };
+
+    let var = ident.map(TimeExpr::Var);
+
+    literal.or(var).labelled("time expression")
+}
+
+/// Create position expression parser.
+fn position_expr_parser(
+    file_id: FileId,
+) -> impl Parser<Token, PositionExpr, Error = Simple<Token>> + Clone {
+    let ident = ident_parser(file_id);
+
+    let literal = select! { Token::Float(f) => f }
+        .then_ignore(just(Token::Comma))
+        .then(select! { Token::Float(f) => f })
+        .delimited_by(just(Token::LParen), just(Token::RParen))
+        .map(|(x, y)| PositionExpr::Literal(x, y));
+
+    let named = select! {
+        Token::Ident(s) if s == "center" || s == "corner" => PositionExpr::Named(s),
+    };
+
+    let var = ident.map(PositionExpr::Var);
+
+    literal.or(named).or(var).labelled("position expression")
+}
+
+/// Create jump kind parser.
+fn jump_kind_parser() -> impl Parser<Token, JumpKind, Error = Simple<Token>> + Clone {
+    select! {
+        Token::Axel => JumpKind::Axel,
+        Token::Lutz => JumpKind::Lutz,
+        Token::Flip => JumpKind::Flip,
+        Token::Loop => JumpKind::Loop,
+        Token::Salchow => JumpKind::Salchow,
+        Token::ToeLoop => JumpKind::ToeLoop,
+        Token::Euler => JumpKind::Euler,
+    }
+    .labelled("jump kind")
+}
+
+/// Create rotations parser.
+fn rotations_parser() -> impl Parser<Token, Rotations, Error = Simple<Token>> + Clone {
+    select! {
+        Token::Single => Rotations::Single,
+        Token::Double => Rotations::Double,
+        Token::Triple => Rotations::Triple,
+        Token::Quad => Rotations::Quad,
+    }
+    .labelled("rotation count")
+}
+
+/// Create level parser.
+fn level_parser() -> impl Parser<Token, Level, Error = Simple<Token>> + Clone {
+    select! {
+        Token::LevelB => Level::B,
+        Token::Level1 => Level::L1,
+        Token::Level2 => Level::L2,
+        Token::Level3 => Level::L3,
+        Token::Level4 => Level::L4,
+    }
+    .labelled("level")
+}
+
+/// Create spin position parser.
+fn spin_position_parser() -> impl Parser<Token, SpinPosition, Error = Simple<Token>> + Clone {
+    select! {
+        Token::Upright => SpinPosition::Upright,
+        Token::Sit => SpinPosition::Sit,
+        Token::Camel => SpinPosition::Camel,
+        Token::Layback => SpinPosition::Layback,
+        Token::Biellmann => SpinPosition::Biellmann,
+    }
+    .labelled("spin position")
+}
+
+/// Create step pattern parser.
+fn step_pattern_parser() -> impl Parser<Token, StepPattern, Error = Simple<Token>> + Clone {
+    select! {
+        Token::Ident(s) if s == "straight" => StepPattern::Straight,
+        Token::Ident(s) if s == "circular" => StepPattern::Circular,
+        Token::Ident(s) if s == "serpentine" => StepPattern::Serpentine,
+        Token::Ident(s) if s == "diagonal" => StepPattern::Diagonal,
+        Token::Ident(s) if s == "midline" => StepPattern::Midline,
+    }
+    .labelled("step pattern")
+}
+
+/// Create type expression parser.
+fn type_expr_parser(
+    file_id: FileId,
+) -> impl Parser<Token, TypeExpr, Error = Simple<Token>> + Clone {
+    recursive(|type_expr| {
+        let ident = ident_parser(file_id);
+
+        let named = ident.clone().map(TypeExpr::Named);
+
+        let array = type_expr
+            .clone()
+            .delimited_by(just(Token::LBracket), just(Token::RBracket))
+            .map(|t| TypeExpr::Array(Box::new(t)));
+
+        let optional = type_expr
+            .clone()
+            .then_ignore(just(Token::Question))
+            .map(|t| TypeExpr::Optional(Box::new(t)));
+
+        let tuple = type_expr
+            .clone()
+            .separated_by(just(Token::Comma))
+            .at_least(2)
+            .delimited_by(just(Token::LParen), just(Token::RParen))
+            .map(TypeExpr::Tuple);
+
+        let generic = ident
+            .clone()
+            .map(TypeExpr::Named)
+            .then(
+                type_expr
+                    .clone()
+                    .separated_by(just(Token::Comma))
+                    .at_least(1)
+                    .delimited_by(just(Token::Lt), just(Token::Gt)),
+            )
+            .map(|(base, args)| TypeExpr::App(Box::new(base), args));
+
+        choice((array, optional, tuple, generic, named)).labelled("type expression")
+    })
+}
+
+/// Create expression parser.
+fn expr_parser(
+    file_id: FileId,
+) -> impl Parser<Token, Spanned<Expr>, Error = Simple<Token>> + Clone {
+    recursive(|expr| {
+        let ident = ident_parser(file_id);
+
+        // Literals
+        let int = select! { Token::Integer(n) => Expr::Int(n) };
+        let float = select! { Token::Float(f) => Expr::Float(f) };
+        let string = select! { Token::String(s) => Expr::String(s) };
+        let bool_lit = select! {
+            Token::True => Expr::Bool(true),
+            Token::False => Expr::Bool(false),
+        };
+
+        let literal = choice((int, float, string, bool_lit));
+
+        // Variable
+        let var = ident.clone().map(Expr::Var);
+
+        // Parenthesized or tuple
+        let paren_or_tuple = expr
+            .clone()
+            .separated_by(just(Token::Comma))
+            .at_least(1)
+            .delimited_by(just(Token::LParen), just(Token::RParen))
+            .map(|mut exprs: Vec<Spanned<Expr>>| {
+                if exprs.len() == 1 {
+                    exprs.pop().unwrap().node
+                } else {
+                    Expr::Tuple(exprs)
+                }
+            });
+
+        // Array literal
+        let array = expr
+            .clone()
+            .separated_by(just(Token::Comma))
+            .allow_trailing()
+            .delimited_by(just(Token::LBracket), just(Token::RBracket))
+            .map(Expr::Array);
+
+        // Block expression
+        let block = expr
+            .clone()
+            .map(|e| Stmt::Expr(e.node))
+            .map_with_span(move |stmt, span| spanned(stmt, span, file_id))
+            .separated_by(just(Token::Semi))
+            .allow_trailing()
+            .delimited_by(just(Token::LBrace), just(Token::RBrace))
+            .map(Expr::Block);
+
+        // If expression
+        let if_expr = just(Token::If)
+            .ignore_then(expr.clone())
+            .then_ignore(just(Token::Then))
+            .then(expr.clone())
+            .then(just(Token::Else).ignore_then(expr.clone()).or_not())
+            .map(|((cond, then_branch), else_branch)| {
+                Expr::If(
+                    Box::new(cond),
+                    Box::new(then_branch),
+                    else_branch.map(Box::new),
+                )
+            });
+
+        // Let expression
+        let let_expr = just(Token::Let)
+            .ignore_then(ident.clone())
+            .then(just(Token::Colon).ignore_then(type_expr_parser(file_id)).or_not())
+            .then_ignore(just(Token::Eq))
+            .then(expr.clone())
+            .then_ignore(just(Token::In))
+            .then(expr.clone())
+            .map(|(((name, ty), value), body)| {
+                Expr::Let(name, ty, Box::new(value), Box::new(body))
+            });
+
+        // Atoms
+        let atom = choice((
+            literal,
+            if_expr,
+            let_expr,
+            paren_or_tuple,
+            array,
+            block,
+            var,
+        ))
+        .map_with_span(move |e, span| spanned(e, span, file_id));
+
+        // For now, just use atoms directly (function calls and field access to be added later)
+        // TODO: Add function calls and field access parsing
+        let primary = atom;
+
+        // Unary operators
+        let unary = just(Token::Minus)
+            .to(UnaryOp::Neg)
+            .or(just(Token::Not).to(UnaryOp::Not))
+            .repeated()
+            .then(primary)
+            .foldr(move |op, expr| {
+                let span = 0..expr.span.end as usize;
+                spanned(Expr::UnaryOp(op, Box::new(expr)), span, file_id)
+            });
+
+        // Binary operators (multiplication/division)
+        let mul_op = just(Token::Star)
+            .to(BinOp::Mul)
+            .or(just(Token::Slash).to(BinOp::Div))
+            .or(just(Token::Percent).to(BinOp::Mod));
+
+        let mul_div = unary
+            .clone()
+            .then(mul_op.then(unary).repeated())
+            .foldl(move |left, (op, right)| {
+                let span = left.span.start as usize..right.span.end as usize;
+                spanned(Expr::BinOp(Box::new(left), op, Box::new(right)), span, file_id)
+            });
+
+        // Binary operators (addition/subtraction)
+        let add_op = just(Token::Plus)
+            .to(BinOp::Add)
+            .or(just(Token::Minus).to(BinOp::Sub));
+
+        let add_sub = mul_div
+            .clone()
+            .then(add_op.then(mul_div).repeated())
+            .foldl(move |left, (op, right)| {
+                let span = left.span.start as usize..right.span.end as usize;
+                spanned(Expr::BinOp(Box::new(left), op, Box::new(right)), span, file_id)
+            });
+
+        // Comparison operators
+        let cmp_op = choice((
+            just(Token::EqEq).to(BinOp::Eq),
+            just(Token::NotEq).to(BinOp::NotEq),
+            just(Token::LtEq).to(BinOp::LtEq),
+            just(Token::Lt).to(BinOp::Lt),
+            just(Token::GtEq).to(BinOp::GtEq),
+            just(Token::Gt).to(BinOp::Gt),
+        ));
+
+        let comparison = add_sub
+            .clone()
+            .then(cmp_op.then(add_sub).repeated())
+            .foldl(move |left, (op, right)| {
+                let span = left.span.start as usize..right.span.end as usize;
+                spanned(Expr::BinOp(Box::new(left), op, Box::new(right)), span, file_id)
+            });
+
+        // Logical AND
+        let and = comparison
+            .clone()
+            .then(just(Token::AndAnd).to(BinOp::And).then(comparison).repeated())
+            .foldl(move |left, (op, right)| {
+                let span = left.span.start as usize..right.span.end as usize;
+                spanned(Expr::BinOp(Box::new(left), op, Box::new(right)), span, file_id)
+            });
+
+        // Logical OR
+        and.clone()
+            .then(just(Token::OrOr).to(BinOp::Or).then(and).repeated())
+            .foldl(move |left, (op, right)| {
+                let span = left.span.start as usize..right.span.end as usize;
+                spanned(Expr::BinOp(Box::new(left), op, Box::new(right)), span, file_id)
+            })
+    })
+}
+
+/// Create timing parser.
+fn timing_parser(
+    file_id: FileId,
+) -> impl Parser<Token, Timing, Error = Simple<Token>> + Clone {
+    let time = time_expr_parser(file_id);
+
+    let at = just(Token::At).ignore_then(time.clone()).map(Timing::At);
+
+    let range = time
+        .clone()
+        .then_ignore(just(Token::DotDot))
+        .then(time.clone())
+        .map(|(start, end)| Timing::Range(start, end));
+
+    let duration = just(Token::Duration)
+        .ignore_then(time.clone())
+        .map(Timing::Duration);
+
+    let beat = just(Token::Beat)
+        .ignore_then(select! { Token::Integer(n) => n })
+        .map(Timing::Beat);
+
+    choice((at, range, duration, beat)).labelled("timing")
+}
+
+/// Create jump element parser.
+fn jump_element_parser(
+    file_id: FileId,
+) -> impl Parser<Token, JumpElement, Error = Simple<Token>> + Clone {
+    just(Token::Jump)
+        .ignore_then(rotations_parser())
+        .then(jump_kind_parser())
+        .map(|(rotations, kind)| JumpElement {
+            kind,
+            rotations,
+            entry_edge: None,
+            exit_edge: None,
+            combination: vec![],
+        })
+        .labelled("jump element")
+}
+
+/// Create spin element parser.
+fn spin_element_parser(
+    file_id: FileId,
+) -> impl Parser<Token, SpinElement, Error = Simple<Token>> + Clone {
+    just(Token::Spin)
+        .ignore_then(spin_position_parser().repeated().at_least(1))
+        .then(level_parser().or_not())
+        .map(|(positions, level)| SpinElement {
+            positions: positions
+                .into_iter()
+                .map(|p| SpinPositionDef {
+                    position: p,
+                    revolutions: None,
+                    change_edge: false,
+                    change_foot: false,
+                })
+                .collect(),
+            min_revs: None,
+            features: vec![],
+            level,
+        })
+        .labelled("spin element")
+}
+
+/// Create step sequence parser.
+fn step_sequence_parser(
+    file_id: FileId,
+) -> impl Parser<Token, StepSequence, Error = Simple<Token>> + Clone {
+    just(Token::Step)
+        .ignore_then(step_pattern_parser())
+        .then(level_parser().or_not())
+        .map(|(pattern, level)| StepSequence {
+            pattern,
+            level,
+            steps: vec![],
+        })
+        .labelled("step sequence")
+}
+
+/// Create element parser.
+fn element_parser(
+    file_id: FileId,
+) -> impl Parser<Token, Element, Error = Simple<Token>> + Clone {
+    let jump = jump_element_parser(file_id).map(ElementKind::Jump);
+    let spin = spin_element_parser(file_id).map(ElementKind::Spin);
+    let step = step_sequence_parser(file_id).map(ElementKind::StepSequence);
+
+    let element_kind = choice((jump, spin, step));
+
+    element_kind
+        .then(timing_parser(file_id).or_not())
+        .map_with_span(move |(kind, timing), span| Element {
+            kind,
+            timing,
+            position: None,
+            annotations: vec![],
+            span: to_span(span, file_id),
+        })
+        .labelled("element")
+}
+
+/// Create sequence parser.
+fn sequence_parser(
+    file_id: FileId,
+) -> impl Parser<Token, Sequence, Error = Simple<Token>> + Clone {
+    just(Token::Sequence)
+        .ignore_then(ident_parser(file_id).or_not())
+        .then_ignore(just(Token::LBrace))
+        .then(element_parser(file_id).repeated())
+        .then_ignore(just(Token::RBrace))
+        .map_with_span(move |(name, elements), span| Sequence {
+            name,
+            elements,
+            span: to_span(span, file_id),
+        })
+        .labelled("sequence")
+}
+
+/// Create segment parser.
+fn segment_parser(
+    file_id: FileId,
+) -> impl Parser<Token, Segment, Error = Simple<Token>> + Clone {
+    let segment_kind = choice((
+        just(Token::Short).to(SegmentKind::Short),
+        just(Token::Free).to(SegmentKind::Free),
+        just(Token::Pattern).to(SegmentKind::Pattern),
+    ));
+
+    just(Token::Segment)
+        .ignore_then(ident_parser(file_id))
+        .then_ignore(just(Token::Colon))
+        .then(segment_kind)
+        .then_ignore(just(Token::LBrace))
+        .then(sequence_parser(file_id).repeated())
+        .then_ignore(just(Token::RBrace))
+        .map_with_span(move |((name, kind), sequences), span| Segment {
+            name,
+            kind,
+            music: None,
+            duration: None,
+            skaters: vec![],
+            sequences,
+            docs: vec![],
+            span: to_span(span, file_id),
+        })
+        .labelled("segment")
+}
+
+/// Create import parser.
+fn import_parser(
+    file_id: FileId,
+) -> impl Parser<Token, Import, Error = Simple<Token>> + Clone {
+    just(Token::Import)
+        .ignore_then(
+            ident_parser(file_id)
+                .separated_by(just(Token::ColonColon))
+                .at_least(1),
+        )
+        .then(just(Token::As).ignore_then(ident_parser(file_id)).or_not())
+        .map_with_span(move |(path, alias), span| Import {
+            path,
+            alias,
+            items: None,
+            span: to_span(span, file_id),
+        })
+        .labelled("import")
+}
+
+/// Create function definition parser.
+fn fn_def_parser(
+    file_id: FileId,
+) -> impl Parser<Token, FnDef, Error = Simple<Token>> + Clone {
+    let param = ident_parser(file_id)
+        .then(just(Token::Colon).ignore_then(type_expr_parser(file_id)).or_not())
+        .map(|(name, ty)| Param {
+            name,
+            ty,
+            default: None,
+        });
+
+    just(Token::Fn)
+        .ignore_then(ident_parser(file_id))
+        .then(
+            param
+                .separated_by(just(Token::Comma))
+                .allow_trailing()
+                .delimited_by(just(Token::LParen), just(Token::RParen)),
+        )
+        .then(just(Token::Arrow).ignore_then(type_expr_parser(file_id)).or_not())
+        .then_ignore(just(Token::Eq))
+        .then(expr_parser(file_id))
+        .map_with_span(move |(((name, params), return_ty), body), span| FnDef {
+            name,
+            type_params: vec![],
+            params,
+            return_ty,
+            body: body.node,
+            docs: vec![],
+            span: to_span(span, file_id),
+        })
+        .labelled("function definition")
+}
+
+/// Create program parser.
+fn program_parser(
+    file_id: FileId,
+) -> impl Parser<Token, Program, Error = Simple<Token>> {
+    just(Token::Program)
+        .ignore_then(ident_parser(file_id))
+        .then_ignore(just(Token::LBrace))
+        .then(
+            choice((
+                import_parser(file_id).map(Item::Import),
+                fn_def_parser(file_id).map(Item::Fn),
+                segment_parser(file_id).map(Item::Segment),
+            ))
+            .repeated(),
+        )
+        .then_ignore(just(Token::RBrace))
+        .then_ignore(end())
+        .map(move |(name, items)| {
+            let mut imports = vec![];
+            let mut functions = vec![];
+            let mut segments = vec![];
+
+            for item in items {
+                match item {
+                    Item::Import(i) => imports.push(i),
+                    Item::Fn(f) => functions.push(f),
+                    Item::Segment(s) => segments.push(s),
+                }
+            }
+
+            Program {
+                name,
+                docs: vec![],
+                imports,
+                types: vec![],
+                functions,
+                segments,
+            }
+        })
+        .labelled("program")
+}
+
+/// Internal enum for collecting program items.
+enum Item {
+    Import(Import),
+    Fn(FnDef),
+    Segment(Segment),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse_empty_program() {
+        let source = "program test {}";
+        let result = parse(source, FileId(0));
+        assert!(result.is_ok());
+        let program = result.unwrap();
+        assert_eq!(program.name.node, "test");
+        assert!(program.segments.is_empty());
+    }
+
+    #[test]
+    fn test_parse_program_with_segment() {
+        let source = r#"
+            program my_program {
+                segment intro: short {
+                    sequence {
+                        jump triple axel at 1:30
+                    }
+                }
+            }
+        "#;
+        let result = parse(source, FileId(0));
+        assert!(result.is_ok());
+        let program = result.unwrap();
+        assert_eq!(program.name.node, "my_program");
+        assert_eq!(program.segments.len(), 1);
+        assert_eq!(program.segments[0].name.node, "intro");
+        assert_eq!(program.segments[0].kind, SegmentKind::Short);
+    }
+
+    #[test]
+    fn test_parse_jump_element() {
+        let source = "program t { segment s: free { sequence { jump triple lutz } } }";
+        let result = parse(source, FileId(0));
+        assert!(result.is_ok());
+        let program = result.unwrap();
+        let element = &program.segments[0].sequences[0].elements[0];
+        match &element.kind {
+            ElementKind::Jump(jump) => {
+                assert_eq!(jump.kind, JumpKind::Lutz);
+                assert_eq!(jump.rotations, Rotations::Triple);
+            }
+            _ => panic!("Expected jump element"),
+        }
+    }
+
+    #[test]
+    fn test_parse_spin_element() {
+        let source = "program t { segment s: free { sequence { spin camel sit L3 } } }";
+        let result = parse(source, FileId(0));
+        assert!(result.is_ok());
+        let program = result.unwrap();
+        let element = &program.segments[0].sequences[0].elements[0];
+        match &element.kind {
+            ElementKind::Spin(spin) => {
+                assert_eq!(spin.positions.len(), 2);
+                assert_eq!(spin.positions[0].position, SpinPosition::Camel);
+                assert_eq!(spin.positions[1].position, SpinPosition::Sit);
+                assert_eq!(spin.level, Some(Level::L3));
+            }
+            _ => panic!("Expected spin element"),
+        }
+    }
+
+    #[test]
+    fn test_parse_step_sequence() {
+        let source = "program t { segment s: free { sequence { step circular L4 } } }";
+        let result = parse(source, FileId(0));
+        assert!(result.is_ok());
+        let program = result.unwrap();
+        let element = &program.segments[0].sequences[0].elements[0];
+        match &element.kind {
+            ElementKind::StepSequence(steps) => {
+                assert_eq!(steps.pattern, StepPattern::Circular);
+                assert_eq!(steps.level, Some(Level::L4));
+            }
+            _ => panic!("Expected step sequence"),
+        }
+    }
+
+    #[test]
+    fn test_lexer_error() {
+        let source = "program test { @ }"; // @ is valid now, try invalid char
+        let result = parse(source, FileId(0));
+        // This may succeed now with @ being a valid token, that's okay
+    }
+}
diff --git a/crates/anv-syntax/src/token.rs b/crates/anv-syntax/src/token.rs
new file mode 100644
index 0000000..c0855df
--- /dev/null
+++ b/crates/anv-syntax/src/token.rs
@@ -0,0 +1,844 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Lexical tokens for Anvomidav.
+//!
+//! This module defines all tokens recognized by the lexer, using the `logos` crate
+//! for efficient DFA-based tokenization.
+
+use logos::Logos;
+use ordered_float::OrderedFloat;
+use std::fmt;
+use std::hash::Hash;
+
+/// Lexical token types for Anvomidav.
+#[derive(Logos, Debug, Clone, PartialEq, Eq, Hash)]
+#[logos(skip r"[ \t\r\n]+")]
+#[logos(skip r"//[^\n]*")]
+#[logos(skip r"/\*([^*]|\*[^/])*\*/")]
+pub enum Token {
+    // === Keywords ===
+    #[token("program")]
+    Program,
+
+    #[token("segment")]
+    Segment,
+
+    #[token("sequence")]
+    Sequence,
+
+    #[token("element")]
+    Element,
+
+    #[token("jump")]
+    Jump,
+
+    #[token("spin")]
+    Spin,
+
+    #[token("step")]
+    Step,
+
+    #[token("lift")]
+    Lift,
+
+    #[token("death_spiral")]
+    DeathSpiral,
+
+    #[token("throw")]
+    Throw,
+
+    #[token("twist")]
+    Twist,
+
+    #[token("transition")]
+    Transition,
+
+    #[token("choreographic")]
+    Choreographic,
+
+    #[token("let")]
+    Let,
+
+    #[token("if")]
+    If,
+
+    #[token("then")]
+    Then,
+
+    #[token("else")]
+    Else,
+
+    #[token("match")]
+    Match,
+
+    #[token("with")]
+    With,
+
+    #[token("for")]
+    For,
+
+    #[token("in")]
+    In,
+
+    #[token("while")]
+    While,
+
+    #[token("do")]
+    Do,
+
+    #[token("end")]
+    End,
+
+    #[token("return")]
+    Return,
+
+    #[token("fn")]
+    Fn,
+
+    #[token("type")]
+    Type,
+
+    #[token("import")]
+    Import,
+
+    #[token("export")]
+    Export,
+
+    #[token("from")]
+    From,
+
+    #[token("as")]
+    As,
+
+    #[token("music")]
+    Music,
+
+    #[token("tempo")]
+    Tempo,
+
+    #[token("beat")]
+    Beat,
+
+    #[token("at")]
+    At,
+
+    #[token("to")]
+    To,
+
+    #[token("duration")]
+    Duration,
+
+    #[token("position")]
+    Position,
+
+    #[token("skater")]
+    Skater,
+
+    #[token("pairs")]
+    Pairs,
+
+    #[token("ice_dance")]
+    IceDance,
+
+    #[token("singles")]
+    Singles,
+
+    #[token("short")]
+    Short,
+
+    #[token("free")]
+    Free,
+
+    #[token("pattern")]
+    Pattern,
+
+    #[token("repeat")]
+    Repeat,
+
+    #[token("parallel")]
+    Parallel,
+
+    #[token("sync")]
+    Sync,
+
+    #[token("true")]
+    True,
+
+    #[token("false")]
+    False,
+
+    // === Jump Types ===
+    #[token("axel")]
+    Axel,
+
+    #[token("lutz")]
+    Lutz,
+
+    #[token("flip")]
+    Flip,
+
+    #[token("loop")]
+    Loop,
+
+    #[token("salchow")]
+    Salchow,
+
+    #[token("toe_loop")]
+    ToeLoop,
+
+    #[token("euler")]
+    Euler,
+
+    // === Rotation Counts ===
+    #[token("single")]
+    Single,
+
+    #[token("double")]
+    Double,
+
+    #[token("triple")]
+    Triple,
+
+    #[token("quad")]
+    Quad,
+
+    // === Spin Positions ===
+    #[token("upright")]
+    Upright,
+
+    #[token("sit")]
+    Sit,
+
+    #[token("camel")]
+    Camel,
+
+    #[token("layback")]
+    Layback,
+
+    #[token("biellmann")]
+    Biellmann,
+
+    // === Edges ===
+    #[token("LFO")]
+    LFO,
+
+    #[token("LFI")]
+    LFI,
+
+    #[token("LBO")]
+    LBO,
+
+    #[token("LBI")]
+    LBI,
+
+    #[token("RFO")]
+    RFO,
+
+    #[token("RFI")]
+    RFI,
+
+    #[token("RBO")]
+    RBO,
+
+    #[token("RBI")]
+    RBI,
+
+    // === Levels ===
+    #[token("B")]
+    LevelB,
+
+    #[token("L1")]
+    Level1,
+
+    #[token("L2")]
+    Level2,
+
+    #[token("L3")]
+    Level3,
+
+    #[token("L4")]
+    Level4,
+
+    // === Operators ===
+    #[token("+")]
+    Plus,
+
+    #[token("-")]
+    Minus,
+
+    #[token("*")]
+    Star,
+
+    #[token("/")]
+    Slash,
+
+    #[token("%")]
+    Percent,
+
+    #[token("==")]
+    EqEq,
+
+    #[token("!=")]
+    NotEq,
+
+    #[token("<")]
+    Lt,
+
+    #[token("<=")]
+    LtEq,
+
+    #[token(">")]
+    Gt,
+
+    #[token(">=")]
+    GtEq,
+
+    #[token("&&")]
+    AndAnd,
+
+    #[token("||")]
+    OrOr,
+
+    #[token("!")]
+    Not,
+
+    #[token("=")]
+    Eq,
+
+    #[token("->")]
+    Arrow,
+
+    #[token("=>")]
+    FatArrow,
+
+    #[token(":")]
+    Colon,
+
+    #[token("::")]
+    ColonColon,
+
+    #[token(";")]
+    Semi,
+
+    #[token(",")]
+    Comma,
+
+    #[token(".")]
+    Dot,
+
+    #[token("..")]
+    DotDot,
+
+    #[token("...")]
+    DotDotDot,
+
+    #[token("|")]
+    Pipe,
+
+    #[token("@")]
+    At_,
+
+    #[token("#")]
+    Hash,
+
+    #[token("?")]
+    Question,
+
+    // === Delimiters ===
+    #[token("(")]
+    LParen,
+
+    #[token(")")]
+    RParen,
+
+    #[token("[")]
+    LBracket,
+
+    #[token("]")]
+    RBracket,
+
+    #[token("{")]
+    LBrace,
+
+    #[token("}")]
+    RBrace,
+
+    // === Literals ===
+    /// Integer literal
+    #[regex(r"[0-9]+", |lex| lex.slice().parse().ok())]
+    Integer(i64),
+
+    /// Float literal
+    #[regex(r"[0-9]+\.[0-9]+([eE][+-]?[0-9]+)?", |lex| lex.slice().parse::<f64>().ok().map(OrderedFloat))]
+    Float(OrderedFloat<f64>),
+
+    /// Time literal (mm:ss or hh:mm:ss format)
+    #[regex(r"[0-9]+:[0-9]+(:[0-9]+)?(\.[0-9]+)?", |lex| lex.slice().to_string())]
+    Time(String),
+
+    /// String literal
+    #[regex(r#""([^"\\]|\\.)*""#, |lex| {
+        let s = lex.slice();
+        // Remove surrounding quotes
+        s[1..s.len()-1].to_string()
+    })]
+    String(String),
+
+    /// Identifier
+    #[regex(r"[a-zA-Z_][a-zA-Z0-9_]*", priority = 1, callback = |lex| lex.slice().to_string())]
+    Ident(String),
+
+    /// Documentation comment
+    #[regex(r"///[^\n]*", |lex| lex.slice()[3..].trim().to_string())]
+    DocComment(String),
+}
+
+impl fmt::Display for Token {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Token::Program => write!(f, "program"),
+            Token::Segment => write!(f, "segment"),
+            Token::Sequence => write!(f, "sequence"),
+            Token::Element => write!(f, "element"),
+            Token::Jump => write!(f, "jump"),
+            Token::Spin => write!(f, "spin"),
+            Token::Step => write!(f, "step"),
+            Token::Lift => write!(f, "lift"),
+            Token::DeathSpiral => write!(f, "death_spiral"),
+            Token::Throw => write!(f, "throw"),
+            Token::Twist => write!(f, "twist"),
+            Token::Transition => write!(f, "transition"),
+            Token::Choreographic => write!(f, "choreographic"),
+            Token::Let => write!(f, "let"),
+            Token::If => write!(f, "if"),
+            Token::Then => write!(f, "then"),
+            Token::Else => write!(f, "else"),
+            Token::Match => write!(f, "match"),
+            Token::With => write!(f, "with"),
+            Token::For => write!(f, "for"),
+            Token::In => write!(f, "in"),
+            Token::While => write!(f, "while"),
+            Token::Do => write!(f, "do"),
+            Token::End => write!(f, "end"),
+            Token::Return => write!(f, "return"),
+            Token::Fn => write!(f, "fn"),
+            Token::Type => write!(f, "type"),
+            Token::Import => write!(f, "import"),
+            Token::Export => write!(f, "export"),
+            Token::From => write!(f, "from"),
+            Token::As => write!(f, "as"),
+            Token::Music => write!(f, "music"),
+            Token::Tempo => write!(f, "tempo"),
+            Token::Beat => write!(f, "beat"),
+            Token::At => write!(f, "at"),
+            Token::To => write!(f, "to"),
+            Token::Duration => write!(f, "duration"),
+            Token::Position => write!(f, "position"),
+            Token::Skater => write!(f, "skater"),
+            Token::Pairs => write!(f, "pairs"),
+            Token::IceDance => write!(f, "ice_dance"),
+            Token::Singles => write!(f, "singles"),
+            Token::Short => write!(f, "short"),
+            Token::Free => write!(f, "free"),
+            Token::Pattern => write!(f, "pattern"),
+            Token::Repeat => write!(f, "repeat"),
+            Token::Parallel => write!(f, "parallel"),
+            Token::Sync => write!(f, "sync"),
+            Token::True => write!(f, "true"),
+            Token::False => write!(f, "false"),
+            Token::Axel => write!(f, "axel"),
+            Token::Lutz => write!(f, "lutz"),
+            Token::Flip => write!(f, "flip"),
+            Token::Loop => write!(f, "loop"),
+            Token::Salchow => write!(f, "salchow"),
+            Token::ToeLoop => write!(f, "toe_loop"),
+            Token::Euler => write!(f, "euler"),
+            Token::Single => write!(f, "single"),
+            Token::Double => write!(f, "double"),
+            Token::Triple => write!(f, "triple"),
+            Token::Quad => write!(f, "quad"),
+            Token::Upright => write!(f, "upright"),
+            Token::Sit => write!(f, "sit"),
+            Token::Camel => write!(f, "camel"),
+            Token::Layback => write!(f, "layback"),
+            Token::Biellmann => write!(f, "biellmann"),
+            Token::LFO => write!(f, "LFO"),
+            Token::LFI => write!(f, "LFI"),
+            Token::LBO => write!(f, "LBO"),
+            Token::LBI => write!(f, "LBI"),
+            Token::RFO => write!(f, "RFO"),
+            Token::RFI => write!(f, "RFI"),
+            Token::RBO => write!(f, "RBO"),
+            Token::RBI => write!(f, "RBI"),
+            Token::LevelB => write!(f, "B"),
+            Token::Level1 => write!(f, "L1"),
+            Token::Level2 => write!(f, "L2"),
+            Token::Level3 => write!(f, "L3"),
+            Token::Level4 => write!(f, "L4"),
+            Token::Plus => write!(f, "+"),
+            Token::Minus => write!(f, "-"),
+            Token::Star => write!(f, "*"),
+            Token::Slash => write!(f, "/"),
+            Token::Percent => write!(f, "%"),
+            Token::EqEq => write!(f, "=="),
+            Token::NotEq => write!(f, "!="),
+            Token::Lt => write!(f, "<"),
+            Token::LtEq => write!(f, "<="),
+            Token::Gt => write!(f, ">"),
+            Token::GtEq => write!(f, ">="),
+            Token::AndAnd => write!(f, "&&"),
+            Token::OrOr => write!(f, "||"),
+            Token::Not => write!(f, "!"),
+            Token::Eq => write!(f, "="),
+            Token::Arrow => write!(f, "->"),
+            Token::FatArrow => write!(f, "=>"),
+            Token::Colon => write!(f, ":"),
+            Token::ColonColon => write!(f, "::"),
+            Token::Semi => write!(f, ";"),
+            Token::Comma => write!(f, ","),
+            Token::Dot => write!(f, "."),
+            Token::DotDot => write!(f, ".."),
+            Token::DotDotDot => write!(f, "..."),
+            Token::Pipe => write!(f, "|"),
+            Token::At_ => write!(f, "@"),
+            Token::Hash => write!(f, "#"),
+            Token::Question => write!(f, "?"),
+            Token::LParen => write!(f, "("),
+            Token::RParen => write!(f, ")"),
+            Token::LBracket => write!(f, "["),
+            Token::RBracket => write!(f, "]"),
+            Token::LBrace => write!(f, "{{"),
+            Token::RBrace => write!(f, "}}"),
+            Token::Integer(n) => write!(f, "{}", n),
+            Token::Float(n) => write!(f, "{}", n),
+            Token::Time(s) => write!(f, "{}", s),
+            Token::String(s) => write!(f, "\"{}\"", s),
+            Token::Ident(s) => write!(f, "{}", s),
+            Token::DocComment(s) => write!(f, "/// {}", s),
+        }
+    }
+}
+
+impl Token {
+    /// Returns true if this token is a keyword.
+    pub fn is_keyword(&self) -> bool {
+        matches!(
+            self,
+            Token::Program
+                | Token::Segment
+                | Token::Sequence
+                | Token::Element
+                | Token::Jump
+                | Token::Spin
+                | Token::Step
+                | Token::Lift
+                | Token::DeathSpiral
+                | Token::Throw
+                | Token::Twist
+                | Token::Transition
+                | Token::Choreographic
+                | Token::Let
+                | Token::If
+                | Token::Then
+                | Token::Else
+                | Token::Match
+                | Token::With
+                | Token::For
+                | Token::In
+                | Token::While
+                | Token::Do
+                | Token::End
+                | Token::Return
+                | Token::Fn
+                | Token::Type
+                | Token::Import
+                | Token::Export
+                | Token::From
+                | Token::As
+                | Token::Music
+                | Token::Tempo
+                | Token::Beat
+                | Token::At
+                | Token::To
+                | Token::Duration
+                | Token::Position
+                | Token::Skater
+                | Token::Pairs
+                | Token::IceDance
+                | Token::Singles
+                | Token::Short
+                | Token::Free
+                | Token::Pattern
+                | Token::Repeat
+                | Token::Parallel
+                | Token::Sync
+                | Token::True
+                | Token::False
+        )
+    }
+
+    /// Returns true if this token is a skating-specific keyword.
+    pub fn is_skating_keyword(&self) -> bool {
+        matches!(
+            self,
+            Token::Axel
+                | Token::Lutz
+                | Token::Flip
+                | Token::Loop
+                | Token::Salchow
+                | Token::ToeLoop
+                | Token::Euler
+                | Token::Single
+                | Token::Double
+                | Token::Triple
+                | Token::Quad
+                | Token::Upright
+                | Token::Sit
+                | Token::Camel
+                | Token::Layback
+                | Token::Biellmann
+                | Token::LFO
+                | Token::LFI
+                | Token::LBO
+                | Token::LBI
+                | Token::RFO
+                | Token::RFI
+                | Token::RBO
+                | Token::RBI
+                | Token::LevelB
+                | Token::Level1
+                | Token::Level2
+                | Token::Level3
+                | Token::Level4
+        )
+    }
+
+    /// Returns true if this is an operator token.
+    pub fn is_operator(&self) -> bool {
+        matches!(
+            self,
+            Token::Plus
+                | Token::Minus
+                | Token::Star
+                | Token::Slash
+                | Token::Percent
+                | Token::EqEq
+                | Token::NotEq
+                | Token::Lt
+                | Token::LtEq
+                | Token::Gt
+                | Token::GtEq
+                | Token::AndAnd
+                | Token::OrOr
+                | Token::Not
+                | Token::Eq
+        )
+    }
+}
+
+/// A token with its span in the source.
+#[derive(Debug, Clone, PartialEq)]
+pub struct SpannedToken {
+    pub token: Token,
+    pub span: std::ops::Range<usize>,
+}
+
+/// Lexer for Anvomidav source code.
+pub struct Lexer<'src> {
+    inner: logos::Lexer<'src, Token>,
+}
+
+impl<'src> Lexer<'src> {
+    /// Create a new lexer for the given source code.
+    pub fn new(source: &'src str) -> Self {
+        Lexer {
+            inner: Token::lexer(source),
+        }
+    }
+
+    /// Tokenize the entire source, returning all tokens with their spans.
+    pub fn tokenize(source: &str) -> Result<Vec<SpannedToken>, LexError> {
+        let mut lexer = Lexer::new(source);
+        let mut tokens = Vec::new();
+
+        while let Some(result) = lexer.next() {
+            match result {
+                Ok(token) => tokens.push(token),
+                Err(e) => return Err(e),
+            }
+        }
+
+        Ok(tokens)
+    }
+}
+
+impl<'src> Iterator for Lexer<'src> {
+    type Item = Result<SpannedToken, LexError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.inner.next() {
+            Some(Ok(token)) => Some(Ok(SpannedToken {
+                token,
+                span: self.inner.span(),
+            })),
+            Some(Err(())) => Some(Err(LexError {
+                span: self.inner.span(),
+                message: format!("unexpected character: {:?}", self.inner.slice()),
+            })),
+            None => None,
+        }
+    }
+}
+
+/// Error during lexical analysis.
+#[derive(Debug, Clone, thiserror::Error)]
+#[error("lex error at {span:?}: {message}")]
+pub struct LexError {
+    pub span: std::ops::Range<usize>,
+    pub message: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_keywords() {
+        let source = "program segment sequence element jump spin step";
+        let tokens: Vec<_> = Lexer::new(source)
+            .map(|r| r.unwrap().token)
+            .collect();
+
+        assert_eq!(tokens, vec![
+            Token::Program,
+            Token::Segment,
+            Token::Sequence,
+            Token::Element,
+            Token::Jump,
+            Token::Spin,
+            Token::Step,
+        ]);
+    }
+
+    #[test]
+    fn test_operators() {
+        let source = "+ - * / == != < <= > >= && || !";
+        let tokens: Vec<_> = Lexer::new(source)
+            .map(|r| r.unwrap().token)
+            .collect();
+
+        assert_eq!(tokens, vec![
+            Token::Plus,
+            Token::Minus,
+            Token::Star,
+            Token::Slash,
+            Token::EqEq,
+            Token::NotEq,
+            Token::Lt,
+            Token::LtEq,
+            Token::Gt,
+            Token::GtEq,
+            Token::AndAnd,
+            Token::OrOr,
+            Token::Not,
+        ]);
+    }
+
+    #[test]
+    fn test_literals() {
+        let source = r#"42 3.14 1:30 2:30:45 "hello world" my_var"#;
+        let tokens: Vec<_> = Lexer::new(source)
+            .map(|r| r.unwrap().token)
+            .collect();
+
+        assert_eq!(tokens, vec![
+            Token::Integer(42),
+            Token::Float(OrderedFloat(3.14)),
+            Token::Time("1:30".to_string()),
+            Token::Time("2:30:45".to_string()),
+            Token::String("hello world".to_string()),
+            Token::Ident("my_var".to_string()),
+        ]);
+    }
+
+    #[test]
+    fn test_edges() {
+        let source = "LFO LFI LBO LBI RFO RFI RBO RBI";
+        let tokens: Vec<_> = Lexer::new(source)
+            .map(|r| r.unwrap().token)
+            .collect();
+
+        assert_eq!(tokens, vec![
+            Token::LFO,
+            Token::LFI,
+            Token::LBO,
+            Token::LBI,
+            Token::RFO,
+            Token::RFI,
+            Token::RBO,
+            Token::RBI,
+        ]);
+    }
+
+    #[test]
+    fn test_jump_types() {
+        let source = "axel lutz flip loop salchow toe_loop euler";
+        let tokens: Vec<_> = Lexer::new(source)
+            .map(|r| r.unwrap().token)
+            .collect();
+
+        assert_eq!(tokens, vec![
+            Token::Axel,
+            Token::Lutz,
+            Token::Flip,
+            Token::Loop,
+            Token::Salchow,
+            Token::ToeLoop,
+            Token::Euler,
+        ]);
+    }
+
+    #[test]
+    fn test_comments() {
+        let source = "program // this is a comment\nsegment /* block comment */ element";
+        let tokens: Vec<_> = Lexer::new(source)
+            .map(|r| r.unwrap().token)
+            .collect();
+
+        assert_eq!(tokens, vec![
+            Token::Program,
+            Token::Segment,
+            Token::Element,
+        ]);
+    }
+
+    #[test]
+    fn test_doc_comment() {
+        let source = "/// This is documentation\nprogram";
+        let tokens: Vec<_> = Lexer::new(source)
+            .map(|r| r.unwrap().token)
+            .collect();
+
+        assert_eq!(tokens, vec![
+            Token::DocComment("This is documentation".to_string()),
+            Token::Program,
+        ]);
+    }
+
+    #[test]
+    fn test_skating_element() {
+        let source = "jump triple axel at 1:30";
+        let tokens: Vec<_> = Lexer::new(source)
+            .map(|r| r.unwrap().token)
+            .collect();
+
+        assert_eq!(tokens, vec![
+            Token::Jump,
+            Token::Triple,
+            Token::Axel,
+            Token::At,
+            Token::Time("1:30".to_string()),
+        ]);
+    }
+}
diff --git a/crates/anv-types/Cargo.toml b/crates/anv-types/Cargo.toml
new file mode 100644
index 0000000..bd2b956
--- /dev/null
+++ b/crates/anv-types/Cargo.toml
@@ -0,0 +1,22 @@
+# SPDX-FileCopyrightText: 2025 hyperpolymath
+# SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+[package]
+name = "anv-types"
+version = "0.1.0"
+edition = "2021"
+description = "Type system and type checking for the Anvomidav figure skating DSL"
+license = "MIT OR AGPL-3.0-or-later"
+repository = "https://github.com/hyperpolymath/anvomidav"
+readme = "README.md"
+keywords = ["figure-skating", "dsl", "types", "type-checking"]
+categories = ["compilers"]
+
+[dependencies]
+anv-core = { path = "../anv-core" }
+anv-syntax = { path = "../anv-syntax" }
+thiserror = { workspace = true }
+ordered-float = { workspace = true }
+
+[dev-dependencies]
+pretty_assertions = "1.4"
diff --git a/crates/anv-types/src/check.rs b/crates/anv-types/src/check.rs
new file mode 100644
index 0000000..9071d13
--- /dev/null
+++ b/crates/anv-types/src/check.rs
@@ -0,0 +1,972 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Type checker for Anvomidav.
+//!
+//! This module implements type checking and inference for Anvomidav programs.
+//! It uses a Hindley-Milner style type inference with extensions for
+//! domain-specific types and refinement types.
+
+use crate::env::TypeEnv;
+use crate::ty::{Type, TypeScheme, TypeVar};
+use anv_core::diagnostics::{Diagnostic, Diagnostics, ErrorCode, Label, Severity};
+use anv_core::source::{FileId, Span};
+use anv_syntax::ast::*;
+use std::collections::HashMap;
+
+/// Result of type checking.
+pub type TypeResult<T> = Result<T, TypeError>;
+
+/// A type error.
+#[derive(Debug, Clone)]
+pub struct TypeError {
+    pub message: String,
+    pub span: Span,
+    pub expected: Option<Type>,
+    pub found: Option<Type>,
+}
+
+impl TypeError {
+    pub fn new(message: impl Into<String>, span: Span) -> Self {
+        TypeError {
+            message: message.into(),
+            span,
+            expected: None,
+            found: None,
+        }
+    }
+
+    pub fn mismatch(expected: Type, found: Type, span: Span) -> Self {
+        TypeError {
+            message: format!("type mismatch: expected {}, found {}", expected, found),
+            span,
+            expected: Some(expected),
+            found: Some(found),
+        }
+    }
+
+    pub fn undefined(name: &str, span: Span) -> Self {
+        TypeError {
+            message: format!("undefined variable: {}", name),
+            span,
+            expected: None,
+            found: None,
+        }
+    }
+
+    pub fn to_diagnostic(&self) -> Diagnostic {
+        let code = if self.expected.is_some() && self.found.is_some() {
+            ErrorCode::TYPE_MISMATCH
+        } else {
+            ErrorCode::UNDEFINED_VARIABLE
+        };
+
+        let mut diag = Diagnostic::error(&self.message).with_code(code);
+        diag = diag.with_label(self.span, "here");
+
+        if let (Some(expected), Some(found)) = (&self.expected, &self.found) {
+            diag = diag.with_note(format!("expected: {}", expected));
+            diag = diag.with_note(format!("   found: {}", found));
+        }
+
+        diag
+    }
+}
+
+/// The type checker.
+pub struct TypeChecker {
+    /// Type environment.
+    env: TypeEnv,
+    /// Substitution (for unification).
+    subst: HashMap<TypeVar, Type>,
+    /// Collected errors.
+    errors: Vec<TypeError>,
+    /// Current file being checked.
+    file_id: FileId,
+}
+
+impl TypeChecker {
+    /// Create a new type checker.
+    pub fn new(file_id: FileId) -> Self {
+        TypeChecker {
+            env: TypeEnv::new(),
+            subst: HashMap::new(),
+            errors: Vec::new(),
+            file_id,
+        }
+    }
+
+    /// Check a program.
+    pub fn check_program(&mut self, program: &Program) -> Result<(), Vec<TypeError>> {
+        // Check all function definitions
+        for func in &program.functions {
+            if let Err(e) = self.check_fn_def(func) {
+                self.errors.push(e);
+            }
+        }
+
+        // Check all segments
+        for segment in &program.segments {
+            if let Err(e) = self.check_segment(segment) {
+                self.errors.push(e);
+            }
+        }
+
+        if self.errors.is_empty() {
+            Ok(())
+        } else {
+            Err(std::mem::take(&mut self.errors))
+        }
+    }
+
+    /// Check a function definition.
+    fn check_fn_def(&mut self, func: &FnDef) -> TypeResult<Type> {
+        self.env.push_scope();
+
+        // Add parameters to environment
+        let mut param_types = Vec::new();
+        for param in &func.params {
+            let ty = if let Some(ref ty_expr) = param.ty {
+                self.resolve_type_expr(ty_expr)?
+            } else {
+                Type::Var(TypeVar::fresh())
+            };
+            self.env.define(&param.name.node, TypeScheme::mono(ty.clone()));
+            param_types.push(ty);
+        }
+
+        // Check body
+        let body_ty = self.infer_expr(&func.body)?;
+
+        // Check return type if specified
+        if let Some(ref ret_ty_expr) = func.return_ty {
+            let ret_ty = self.resolve_type_expr(ret_ty_expr)?;
+            self.unify(&ret_ty, &body_ty, func.span)?;
+        }
+
+        self.env.pop_scope();
+
+        // Create function type
+        let fn_ty = Type::Fn(param_types, Box::new(body_ty));
+
+        // Add to environment with generalization
+        let scheme = self.env.generalize(&fn_ty);
+        self.env.define(&func.name.node, scheme);
+
+        Ok(fn_ty)
+    }
+
+    /// Check a segment.
+    fn check_segment(&mut self, segment: &Segment) -> TypeResult<Type> {
+        self.env.push_scope();
+
+        // Check all sequences
+        for sequence in &segment.sequences {
+            self.check_sequence(sequence)?;
+        }
+
+        self.env.pop_scope();
+
+        Ok(Type::Segment)
+    }
+
+    /// Check a sequence.
+    fn check_sequence(&mut self, sequence: &Sequence) -> TypeResult<Type> {
+        for element in &sequence.elements {
+            self.check_element(element)?;
+        }
+        Ok(Type::Sequence)
+    }
+
+    /// Check an element.
+    fn check_element(&mut self, element: &Element) -> TypeResult<Type> {
+        let ty = match &element.kind {
+            ElementKind::Jump(jump) => self.check_jump(jump, element.span)?,
+            ElementKind::Spin(spin) => self.check_spin(spin, element.span)?,
+            ElementKind::StepSequence(steps) => self.check_step_sequence(steps, element.span)?,
+            ElementKind::Lift(lift) => self.check_lift(lift, element.span)?,
+            ElementKind::DeathSpiral(_) => Type::DeathSpiral,
+            ElementKind::Throw(throw) => self.check_throw(throw, element.span)?,
+            ElementKind::Twist(_) => Type::Twist,
+            ElementKind::Transition(_) => Type::Transition,
+            ElementKind::Choreographic(_) => Type::Choreographic,
+            ElementKind::Pattern(_) => Type::Element,
+            ElementKind::Parallel(_) => Type::Element,
+            ElementKind::Sync(_) => Type::Element,
+        };
+
+        // Check timing if present
+        if let Some(ref timing) = element.timing {
+            self.check_timing(timing)?;
+        }
+
+        // Check position if present
+        if let Some(ref position) = element.position {
+            self.check_position_expr(position)?;
+        }
+
+        Ok(ty)
+    }
+
+    /// Check a jump element.
+    fn check_jump(&mut self, jump: &JumpElement, span: Span) -> TypeResult<Type> {
+        // Validate entry edge matches jump requirements
+        if let Some(ref entry_edge) = jump.entry_edge {
+            let required = jump.kind.required_entry_edge();
+            if *entry_edge != required {
+                self.errors.push(TypeError {
+                    message: format!(
+                        "invalid entry edge for {:?}: expected {:?}, found {:?}",
+                        jump.kind, required, entry_edge
+                    ),
+                    span,
+                    expected: None,
+                    found: None,
+                });
+            }
+        }
+
+        // Check combinations recursively
+        for combo_jump in &jump.combination {
+            self.check_jump(combo_jump, span)?;
+        }
+
+        Ok(Type::Jump)
+    }
+
+    /// Check a spin element.
+    fn check_spin(&mut self, spin: &SpinElement, span: Span) -> TypeResult<Type> {
+        // Validate minimum revolutions for level requirements
+        if let Some(level) = &spin.level {
+            if let Some(min_revs) = spin.min_revs {
+                let required_revs = match level {
+                    anv_core::skating::Level::L4 => 8,
+                    anv_core::skating::Level::L3 => 6,
+                    anv_core::skating::Level::L2 => 4,
+                    _ => 2,
+                };
+                if min_revs < required_revs {
+                    self.errors.push(TypeError {
+                        message: format!(
+                            "insufficient revolutions for level {:?}: requires {}, specified {}",
+                            level, required_revs, min_revs
+                        ),
+                        span,
+                        expected: None,
+                        found: None,
+                    });
+                }
+            }
+        }
+
+        Ok(Type::Spin)
+    }
+
+    /// Check a step sequence.
+    fn check_step_sequence(&mut self, _steps: &StepSequence, _span: Span) -> TypeResult<Type> {
+        // TODO: Validate step sequence requirements
+        Ok(Type::StepSequence)
+    }
+
+    /// Check a lift element.
+    fn check_lift(&mut self, _lift: &LiftElement, _span: Span) -> TypeResult<Type> {
+        // TODO: Validate lift requirements
+        Ok(Type::Lift)
+    }
+
+    /// Check a throw element.
+    fn check_throw(&mut self, _throw: &ThrowElement, _span: Span) -> TypeResult<Type> {
+        // TODO: Validate throw requirements
+        Ok(Type::Throw)
+    }
+
+    /// Check timing.
+    fn check_timing(&mut self, timing: &Timing) -> TypeResult<Type> {
+        match timing {
+            Timing::At(time) => self.check_time_expr(time),
+            Timing::Range(start, end) => {
+                self.check_time_expr(start)?;
+                self.check_time_expr(end)
+            }
+            Timing::Duration(dur) => self.check_time_expr(dur),
+            Timing::Beat(_) => Ok(Type::Beat),
+            Timing::After(time) => self.check_time_expr(time),
+        }
+    }
+
+    /// Check a time expression.
+    fn check_time_expr(&mut self, time: &TimeExpr) -> TypeResult<Type> {
+        match time {
+            TimeExpr::Literal(_) => Ok(Type::Time),
+            TimeExpr::Formatted(_) => Ok(Type::Time),
+            TimeExpr::Var(ident) => {
+                if let Some(scheme) = self.env.lookup(&ident.node) {
+                    let ty = scheme.instantiate();
+                    self.unify(&ty, &Type::Time, ident.span)?;
+                    Ok(Type::Time)
+                } else {
+                    Err(TypeError::undefined(&ident.node, ident.span))
+                }
+            }
+            TimeExpr::BinOp(left, _op, right) => {
+                self.check_time_expr(left)?;
+                self.check_time_expr(right)?;
+                Ok(Type::Time)
+            }
+        }
+    }
+
+    /// Check a position expression.
+    fn check_position_expr(&mut self, pos: &PositionExpr) -> TypeResult<Type> {
+        match pos {
+            PositionExpr::Literal(_, _) => Ok(Type::Position),
+            PositionExpr::Named(_) => Ok(Type::Position),
+            PositionExpr::Var(ident) => {
+                if let Some(scheme) = self.env.lookup(&ident.node) {
+                    let ty = scheme.instantiate();
+                    self.unify(&ty, &Type::Position, ident.span)?;
+                    Ok(Type::Position)
+                } else {
+                    Err(TypeError::undefined(&ident.node, ident.span))
+                }
+            }
+            PositionExpr::Relative(base, _, _) => {
+                self.check_position_expr(base)?;
+                Ok(Type::Position)
+            }
+        }
+    }
+
+    /// Infer the type of an expression.
+    fn infer_expr(&mut self, expr: &Expr) -> TypeResult<Type> {
+        match expr {
+            Expr::Int(_) => Ok(Type::Int),
+            Expr::Float(_) => Ok(Type::Float),
+            Expr::String(_) => Ok(Type::String),
+            Expr::Bool(_) => Ok(Type::Bool),
+            Expr::Time(time) => self.check_time_expr(time),
+            Expr::Position(pos) => self.check_position_expr(pos),
+            Expr::Var(ident) => {
+                if let Some(scheme) = self.env.lookup(&ident.node) {
+                    Ok(scheme.instantiate())
+                } else {
+                    Err(TypeError::undefined(&ident.node, ident.span))
+                }
+            }
+            Expr::BinOp(left, op, right) => {
+                let left_ty = self.infer_spanned_expr(left)?;
+                let right_ty = self.infer_spanned_expr(right)?;
+                self.check_binop(*op, &left_ty, &right_ty, left.span)
+            }
+            Expr::UnaryOp(op, operand) => {
+                let operand_ty = self.infer_spanned_expr(operand)?;
+                self.check_unaryop(*op, &operand_ty, operand.span)
+            }
+            Expr::Call(func, args) => {
+                let func_ty = self.infer_spanned_expr(func)?;
+                let mut arg_types = Vec::new();
+                for arg in args {
+                    arg_types.push(self.infer_spanned_expr(arg)?);
+                }
+                self.check_call(&func_ty, &arg_types, func.span)
+            }
+            Expr::Field(base, field) => {
+                let base_ty = self.infer_spanned_expr(base)?;
+                self.check_field_access(&base_ty, &field.node, field.span)
+            }
+            Expr::Index(base, index) => {
+                let base_ty = self.infer_spanned_expr(base)?;
+                let _index_ty = self.infer_spanned_expr(index)?;
+                self.check_index(&base_ty, base.span)
+            }
+            Expr::If(cond, then_branch, else_branch) => {
+                let cond_ty = self.infer_spanned_expr(cond)?;
+                self.unify(&cond_ty, &Type::Bool, cond.span)?;
+
+                let then_ty = self.infer_spanned_expr(then_branch)?;
+
+                if let Some(else_branch) = else_branch {
+                    let else_ty = self.infer_spanned_expr(else_branch)?;
+                    self.unify(&then_ty, &else_ty, else_branch.span)?;
+                    Ok(then_ty)
+                } else {
+                    Ok(Type::Unit)
+                }
+            }
+            Expr::Let(name, ty_ann, value, body) => {
+                let value_ty = self.infer_spanned_expr(value)?;
+
+                if let Some(ty_expr) = ty_ann {
+                    let ann_ty = self.resolve_type_expr(ty_expr)?;
+                    self.unify(&value_ty, &ann_ty, value.span)?;
+                }
+
+                self.env.push_scope();
+                let scheme = self.env.generalize(&value_ty);
+                self.env.define(&name.node, scheme);
+
+                let body_ty = self.infer_spanned_expr(body)?;
+                self.env.pop_scope();
+
+                Ok(body_ty)
+            }
+            Expr::Block(stmts) => {
+                self.env.push_scope();
+                let mut last_ty = Type::Unit;
+                for stmt in stmts {
+                    last_ty = self.check_stmt(&stmt.node)?;
+                }
+                self.env.pop_scope();
+                Ok(last_ty)
+            }
+            Expr::Lambda(params, body) => {
+                self.env.push_scope();
+                let mut param_types = Vec::new();
+                for param in params {
+                    let ty = if let Some(ref ty_expr) = param.ty {
+                        self.resolve_type_expr(ty_expr)?
+                    } else {
+                        Type::Var(TypeVar::fresh())
+                    };
+                    self.env.define(&param.name.node, TypeScheme::mono(ty.clone()));
+                    param_types.push(ty);
+                }
+                let body_ty = self.infer_spanned_expr(body)?;
+                self.env.pop_scope();
+                Ok(Type::Fn(param_types, Box::new(body_ty)))
+            }
+            Expr::Tuple(exprs) => {
+                let types: Vec<Type> = exprs
+                    .iter()
+                    .map(|e| self.infer_spanned_expr(e))
+                    .collect::<Result<_, _>>()?;
+                Ok(Type::Tuple(types))
+            }
+            Expr::Array(exprs) => {
+                if exprs.is_empty() {
+                    Ok(Type::Array(Box::new(Type::Var(TypeVar::fresh()))))
+                } else {
+                    let first_ty = self.infer_spanned_expr(&exprs[0])?;
+                    for expr in &exprs[1..] {
+                        let ty = self.infer_spanned_expr(expr)?;
+                        self.unify(&first_ty, &ty, expr.span)?;
+                    }
+                    Ok(Type::Array(Box::new(first_ty)))
+                }
+            }
+            Expr::Record(fields) => {
+                let field_types: Vec<(String, Type)> = fields
+                    .iter()
+                    .map(|(name, expr)| {
+                        let ty = self.infer_spanned_expr(expr)?;
+                        Ok((name.node.clone(), ty))
+                    })
+                    .collect::<Result<_, TypeError>>()?;
+                Ok(Type::Record(field_types))
+            }
+            Expr::Element(element) => self.check_element(element),
+            Expr::Match(_, _) => {
+                // TODO: Implement match expression type checking
+                Ok(Type::Var(TypeVar::fresh()))
+            }
+        }
+    }
+
+    /// Infer type of a spanned expression.
+    fn infer_spanned_expr(&mut self, expr: &Spanned<Expr>) -> TypeResult<Type> {
+        self.infer_expr(&expr.node)
+    }
+
+    /// Check a statement.
+    fn check_stmt(&mut self, stmt: &Stmt) -> TypeResult<Type> {
+        match stmt {
+            Stmt::Expr(expr) => self.infer_expr(expr),
+            Stmt::Let(name, ty_ann, value) => {
+                let value_ty = self.infer_expr(value)?;
+
+                if let Some(ty_expr) = ty_ann {
+                    let ann_ty = self.resolve_type_expr(ty_expr)?;
+                    self.unify(&value_ty, &ann_ty, name.span)?;
+                }
+
+                let scheme = self.env.generalize(&value_ty);
+                self.env.define(&name.node, scheme);
+
+                Ok(Type::Unit)
+            }
+            Stmt::Assign(target, value) => {
+                let target_ty = self.infer_spanned_expr(target)?;
+                let value_ty = self.infer_expr(value)?;
+                self.unify(&target_ty, &value_ty, target.span)?;
+                Ok(Type::Unit)
+            }
+            Stmt::Return(expr) => {
+                if let Some(expr) = expr {
+                    self.infer_expr(expr)
+                } else {
+                    Ok(Type::Unit)
+                }
+            }
+            Stmt::For(var, iter, body) => {
+                let iter_ty = self.infer_expr(iter)?;
+                let elem_ty = match iter_ty {
+                    Type::Array(t) => *t,
+                    _ => Type::Var(TypeVar::fresh()),
+                };
+
+                self.env.push_scope();
+                self.env.define(&var.node, TypeScheme::mono(elem_ty));
+                for stmt in body {
+                    self.check_stmt(&stmt.node)?;
+                }
+                self.env.pop_scope();
+
+                Ok(Type::Unit)
+            }
+            Stmt::While(cond, body) => {
+                let cond_ty = self.infer_expr(cond)?;
+                self.unify(&cond_ty, &Type::Bool, Span::new(0, 0, self.file_id))?;
+
+                self.env.push_scope();
+                for stmt in body {
+                    self.check_stmt(&stmt.node)?;
+                }
+                self.env.pop_scope();
+
+                Ok(Type::Unit)
+            }
+        }
+    }
+
+    /// Check a binary operation.
+    fn check_binop(
+        &mut self,
+        op: BinOp,
+        left: &Type,
+        right: &Type,
+        span: Span,
+    ) -> TypeResult<Type> {
+        match op {
+            BinOp::Add | BinOp::Sub | BinOp::Mul | BinOp::Div | BinOp::Mod => {
+                self.unify(left, right, span)?;
+                // Numeric operations return the same type
+                Ok(left.clone())
+            }
+            BinOp::Eq | BinOp::NotEq => {
+                self.unify(left, right, span)?;
+                Ok(Type::Bool)
+            }
+            BinOp::Lt | BinOp::LtEq | BinOp::Gt | BinOp::GtEq => {
+                self.unify(left, right, span)?;
+                Ok(Type::Bool)
+            }
+            BinOp::And | BinOp::Or => {
+                self.unify(left, &Type::Bool, span)?;
+                self.unify(right, &Type::Bool, span)?;
+                Ok(Type::Bool)
+            }
+        }
+    }
+
+    /// Check a unary operation.
+    fn check_unaryop(&mut self, op: UnaryOp, operand: &Type, span: Span) -> TypeResult<Type> {
+        match op {
+            UnaryOp::Neg => {
+                // Negation works on numeric types
+                Ok(operand.clone())
+            }
+            UnaryOp::Not => {
+                self.unify(operand, &Type::Bool, span)?;
+                Ok(Type::Bool)
+            }
+        }
+    }
+
+    /// Check a function call.
+    fn check_call(
+        &mut self,
+        func: &Type,
+        args: &[Type],
+        span: Span,
+    ) -> TypeResult<Type> {
+        match func {
+            Type::Fn(params, ret) => {
+                if params.len() != args.len() {
+                    return Err(TypeError {
+                        message: format!(
+                            "function expects {} arguments, got {}",
+                            params.len(),
+                            args.len()
+                        ),
+                        span,
+                        expected: None,
+                        found: None,
+                    });
+                }
+
+                for (param, arg) in params.iter().zip(args.iter()) {
+                    self.unify(param, arg, span)?;
+                }
+
+                Ok((**ret).clone())
+            }
+            Type::Var(_) => {
+                // Function type is unknown, create fresh types
+                let ret = Type::Var(TypeVar::fresh());
+                let expected = Type::Fn(args.to_vec(), Box::new(ret.clone()));
+                self.unify(func, &expected, span)?;
+                Ok(ret)
+            }
+            _ => Err(TypeError {
+                message: format!("cannot call non-function type: {}", func),
+                span,
+                expected: Some(Type::Fn(vec![], Box::new(Type::Var(TypeVar::fresh())))),
+                found: Some(func.clone()),
+            }),
+        }
+    }
+
+    /// Check field access.
+    fn check_field_access(
+        &mut self,
+        base: &Type,
+        field: &str,
+        span: Span,
+    ) -> TypeResult<Type> {
+        match base {
+            Type::Record(fields) => {
+                for (name, ty) in fields {
+                    if name == field {
+                        return Ok(ty.clone());
+                    }
+                }
+                Err(TypeError {
+                    message: format!("record has no field '{}'", field),
+                    span,
+                    expected: None,
+                    found: None,
+                })
+            }
+            Type::Var(_) => {
+                // Unknown type, assume it has the field
+                Ok(Type::Var(TypeVar::fresh()))
+            }
+            _ => Err(TypeError {
+                message: format!("cannot access field '{}' on type {}", field, base),
+                span,
+                expected: None,
+                found: Some(base.clone()),
+            }),
+        }
+    }
+
+    /// Check index access.
+    fn check_index(&mut self, base: &Type, span: Span) -> TypeResult<Type> {
+        match base {
+            Type::Array(elem) => Ok((**elem).clone()),
+            Type::Tuple(elems) => {
+                // For tuples, we'd need the index to be a literal
+                // For now, return a fresh type variable
+                if elems.is_empty() {
+                    Ok(Type::Var(TypeVar::fresh()))
+                } else {
+                    Ok(elems[0].clone())
+                }
+            }
+            Type::Var(_) => Ok(Type::Var(TypeVar::fresh())),
+            _ => Err(TypeError {
+                message: format!("cannot index into type {}", base),
+                span,
+                expected: None,
+                found: Some(base.clone()),
+            }),
+        }
+    }
+
+    /// Resolve a type expression to a Type.
+    fn resolve_type_expr(&mut self, ty_expr: &TypeExpr) -> TypeResult<Type> {
+        match ty_expr {
+            TypeExpr::Named(ident) => {
+                // Look up built-in types
+                match ident.node.as_str() {
+                    "Int" => Ok(Type::Int),
+                    "Float" => Ok(Type::Float),
+                    "Bool" => Ok(Type::Bool),
+                    "String" => Ok(Type::String),
+                    "Time" => Ok(Type::Time),
+                    "Duration" => Ok(Type::Duration),
+                    "Position" => Ok(Type::Position),
+                    "Position3" => Ok(Type::Position3),
+                    "Angle" => Ok(Type::Angle),
+                    "Velocity" => Ok(Type::Velocity),
+                    "Beat" => Ok(Type::Beat),
+                    "Edge" => Ok(Type::Edge),
+                    "Level" => Ok(Type::Level),
+                    "Jump" => Ok(Type::Jump),
+                    "Spin" => Ok(Type::Spin),
+                    "StepSequence" => Ok(Type::StepSequence),
+                    "Lift" => Ok(Type::Lift),
+                    "Throw" => Ok(Type::Throw),
+                    "Twist" => Ok(Type::Twist),
+                    "DeathSpiral" => Ok(Type::DeathSpiral),
+                    "Transition" => Ok(Type::Transition),
+                    "Choreographic" => Ok(Type::Choreographic),
+                    "Element" => Ok(Type::Element),
+                    "Sequence" => Ok(Type::Sequence),
+                    "Segment" => Ok(Type::Segment),
+                    "Program" => Ok(Type::Program),
+                    _ => {
+                        // Check user-defined types
+                        if self.env.lookup_type(&ident.node).is_some() {
+                            Ok(Type::Named(ident.node.clone()))
+                        } else {
+                            Err(TypeError {
+                                message: format!("unknown type: {}", ident.node),
+                                span: ident.span,
+                                expected: None,
+                                found: None,
+                            })
+                        }
+                    }
+                }
+            }
+            TypeExpr::Fn(params, ret) => {
+                let param_types: Vec<Type> = params
+                    .iter()
+                    .map(|t| self.resolve_type_expr(t))
+                    .collect::<Result<_, _>>()?;
+                let ret_type = self.resolve_type_expr(ret)?;
+                Ok(Type::Fn(param_types, Box::new(ret_type)))
+            }
+            TypeExpr::Tuple(types) => {
+                let types: Vec<Type> = types
+                    .iter()
+                    .map(|t| self.resolve_type_expr(t))
+                    .collect::<Result<_, _>>()?;
+                Ok(Type::Tuple(types))
+            }
+            TypeExpr::Array(elem) => {
+                let elem_type = self.resolve_type_expr(elem)?;
+                Ok(Type::Array(Box::new(elem_type)))
+            }
+            TypeExpr::Optional(inner) => {
+                let inner_type = self.resolve_type_expr(inner)?;
+                Ok(Type::Optional(Box::new(inner_type)))
+            }
+            TypeExpr::App(base, args) => {
+                let base_type = self.resolve_type_expr(base)?;
+                let arg_types: Vec<Type> = args
+                    .iter()
+                    .map(|t| self.resolve_type_expr(t))
+                    .collect::<Result<_, _>>()?;
+                Ok(Type::App(Box::new(base_type), arg_types))
+            }
+            TypeExpr::Refinement { base, var: _, predicate: _ } => {
+                // TODO: Handle refinement types properly with SMT
+                let base_type = self.resolve_type_expr(base)?;
+                Ok(base_type)
+            }
+        }
+    }
+
+    /// Unify two types.
+    fn unify(&mut self, t1: &Type, t2: &Type, span: Span) -> TypeResult<()> {
+        let t1 = self.apply_subst(t1);
+        let t2 = self.apply_subst(t2);
+
+        match (&t1, &t2) {
+            // Same types unify
+            (a, b) if a == b => Ok(()),
+
+            // Type variables
+            (Type::Var(v), t) | (t, Type::Var(v)) => {
+                if t.free_vars().contains(v) {
+                    Err(TypeError {
+                        message: format!("infinite type: {} ~ {}", v, t),
+                        span,
+                        expected: None,
+                        found: None,
+                    })
+                } else {
+                    self.subst.insert(*v, t.clone());
+                    Ok(())
+                }
+            }
+
+            // Function types
+            (Type::Fn(p1, r1), Type::Fn(p2, r2)) => {
+                if p1.len() != p2.len() {
+                    return Err(TypeError::mismatch(t1.clone(), t2.clone(), span));
+                }
+                for (a, b) in p1.iter().zip(p2.iter()) {
+                    self.unify(a, b, span)?;
+                }
+                self.unify(r1, r2, span)
+            }
+
+            // Tuple types
+            (Type::Tuple(ts1), Type::Tuple(ts2)) => {
+                if ts1.len() != ts2.len() {
+                    return Err(TypeError::mismatch(t1.clone(), t2.clone(), span));
+                }
+                for (a, b) in ts1.iter().zip(ts2.iter()) {
+                    self.unify(a, b, span)?;
+                }
+                Ok(())
+            }
+
+            // Array types
+            (Type::Array(e1), Type::Array(e2)) => self.unify(e1, e2, span),
+
+            // Optional types
+            (Type::Optional(e1), Type::Optional(e2)) => self.unify(e1, e2, span),
+
+            // Record types
+            (Type::Record(f1), Type::Record(f2)) => {
+                if f1.len() != f2.len() {
+                    return Err(TypeError::mismatch(t1.clone(), t2.clone(), span));
+                }
+                for ((n1, t1), (n2, t2)) in f1.iter().zip(f2.iter()) {
+                    if n1 != n2 {
+                        return Err(TypeError {
+                            message: format!("field name mismatch: {} vs {}", n1, n2),
+                            span,
+                            expected: None,
+                            found: None,
+                        });
+                    }
+                    self.unify(t1, t2, span)?;
+                }
+                Ok(())
+            }
+
+            // Element subtyping
+            (Type::Jump, Type::Element)
+            | (Type::Spin, Type::Element)
+            | (Type::StepSequence, Type::Element)
+            | (Type::Lift, Type::Element)
+            | (Type::Throw, Type::Element)
+            | (Type::Twist, Type::Element)
+            | (Type::DeathSpiral, Type::Element)
+            | (Type::Transition, Type::Element)
+            | (Type::Choreographic, Type::Element) => Ok(()),
+
+            // Error type unifies with anything (to allow error recovery)
+            (Type::Error, _) | (_, Type::Error) => Ok(()),
+
+            // No match
+            _ => Err(TypeError::mismatch(t1, t2, span)),
+        }
+    }
+
+    /// Apply the current substitution to a type.
+    fn apply_subst(&self, ty: &Type) -> Type {
+        match ty {
+            Type::Var(v) => {
+                if let Some(t) = self.subst.get(v) {
+                    self.apply_subst(t)
+                } else {
+                    ty.clone()
+                }
+            }
+            Type::Fn(params, ret) => Type::Fn(
+                params.iter().map(|t| self.apply_subst(t)).collect(),
+                Box::new(self.apply_subst(ret)),
+            ),
+            Type::Tuple(ts) => Type::Tuple(ts.iter().map(|t| self.apply_subst(t)).collect()),
+            Type::Array(t) => Type::Array(Box::new(self.apply_subst(t))),
+            Type::Optional(t) => Type::Optional(Box::new(self.apply_subst(t))),
+            Type::Record(fields) => Type::Record(
+                fields
+                    .iter()
+                    .map(|(n, t)| (n.clone(), self.apply_subst(t)))
+                    .collect(),
+            ),
+            Type::App(base, args) => Type::App(
+                Box::new(self.apply_subst(base)),
+                args.iter().map(|t| self.apply_subst(t)).collect(),
+            ),
+            _ => ty.clone(),
+        }
+    }
+
+    /// Get all collected diagnostics.
+    pub fn into_diagnostics(self) -> Diagnostics {
+        let mut diagnostics = Diagnostics::new();
+        for error in self.errors {
+            diagnostics.add(error.to_diagnostic());
+        }
+        diagnostics
+    }
+}
+
+/// Convenience function to type-check a program.
+pub fn check(program: &Program, file_id: FileId) -> Result<(), Diagnostics> {
+    let mut checker = TypeChecker::new(file_id);
+    match checker.check_program(program) {
+        Ok(()) => Ok(()),
+        Err(_) => Err(checker.into_diagnostics()),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anv_syntax::parse;
+
+    fn check_source(source: &str) -> Result<(), Vec<TypeError>> {
+        let program = parse(source, FileId(0)).expect("parse error");
+        let mut checker = TypeChecker::new(FileId(0));
+        checker.check_program(&program)
+    }
+
+    #[test]
+    fn test_empty_program() {
+        let result = check_source("program test {}");
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_program_with_jump() {
+        let result = check_source(
+            r#"
+            program test {
+                segment main: short {
+                    sequence {
+                        jump triple axel at 1:30
+                    }
+                }
+            }
+        "#,
+        );
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_program_with_spin() {
+        let result = check_source(
+            r#"
+            program test {
+                segment main: free {
+                    sequence {
+                        spin camel sit upright L3
+                    }
+                }
+            }
+        "#,
+        );
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_function_definition() {
+        let result = check_source(
+            r#"
+            program test {
+                fn add(x: Int, y: Int) -> Int = x
+            }
+        "#,
+        );
+        assert!(result.is_ok());
+    }
+}
diff --git a/crates/anv-types/src/env.rs b/crates/anv-types/src/env.rs
new file mode 100644
index 0000000..e4f096d
--- /dev/null
+++ b/crates/anv-types/src/env.rs
@@ -0,0 +1,335 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Type environment for Anvomidav.
+//!
+//! This module defines the type environment used during type checking,
+//! which maps variables to their types and tracks type definitions.
+
+use crate::ty::{Type, TypeScheme, TypeVar};
+use std::collections::HashMap;
+
+/// The type environment.
+#[derive(Debug, Clone)]
+pub struct TypeEnv {
+    /// Variable bindings: name -> type scheme.
+    bindings: Vec<HashMap<String, TypeScheme>>,
+    /// Type definitions: name -> type.
+    types: HashMap<String, TypeDef>,
+}
+
+/// A type definition.
+#[derive(Debug, Clone)]
+pub struct TypeDef {
+    /// Type parameters.
+    pub params: Vec<String>,
+    /// The definition body.
+    pub body: TypeDefBody,
+}
+
+/// Body of a type definition.
+#[derive(Debug, Clone)]
+pub enum TypeDefBody {
+    /// Type alias.
+    Alias(Type),
+    /// Record type.
+    Record(Vec<(String, Type)>),
+    /// Enum/variant type.
+    Enum(Vec<(String, Option<Type>)>),
+}
+
+impl Default for TypeEnv {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl TypeEnv {
+    /// Create a new empty environment.
+    pub fn new() -> Self {
+        let mut env = TypeEnv {
+            bindings: vec![HashMap::new()],
+            types: HashMap::new(),
+        };
+        env.init_builtins();
+        env
+    }
+
+    /// Initialize built-in types and functions.
+    fn init_builtins(&mut self) {
+        // Built-in skating element constructors
+        self.define(
+            "triple_axel",
+            TypeScheme::mono(Type::Jump),
+        );
+        self.define(
+            "triple_lutz",
+            TypeScheme::mono(Type::Jump),
+        );
+        self.define(
+            "triple_flip",
+            TypeScheme::mono(Type::Jump),
+        );
+        self.define(
+            "triple_loop",
+            TypeScheme::mono(Type::Jump),
+        );
+        self.define(
+            "triple_salchow",
+            TypeScheme::mono(Type::Jump),
+        );
+        self.define(
+            "triple_toe_loop",
+            TypeScheme::mono(Type::Jump),
+        );
+        self.define(
+            "quad_axel",
+            TypeScheme::mono(Type::Jump),
+        );
+        self.define(
+            "quad_lutz",
+            TypeScheme::mono(Type::Jump),
+        );
+
+        // Time/duration functions
+        self.define(
+            "seconds",
+            TypeScheme::mono(Type::Fn(vec![Type::Float], Box::new(Type::Duration))),
+        );
+        self.define(
+            "minutes",
+            TypeScheme::mono(Type::Fn(vec![Type::Float], Box::new(Type::Duration))),
+        );
+
+        // Position functions
+        self.define(
+            "center",
+            TypeScheme::mono(Type::Position),
+        );
+        self.define(
+            "corner",
+            TypeScheme::mono(Type::Fn(vec![Type::Int], Box::new(Type::Position))),
+        );
+        self.define(
+            "offset",
+            TypeScheme::mono(Type::Fn(
+                vec![Type::Position, Type::Float, Type::Float],
+                Box::new(Type::Position),
+            )),
+        );
+
+        // Arithmetic operators (as polymorphic functions)
+        let num = TypeVar::fresh();
+        self.define(
+            "+",
+            TypeScheme::poly(
+                vec![num],
+                Type::Fn(vec![Type::Var(num), Type::Var(num)], Box::new(Type::Var(num))),
+            ),
+        );
+        self.define(
+            "-",
+            TypeScheme::poly(
+                vec![num],
+                Type::Fn(vec![Type::Var(num), Type::Var(num)], Box::new(Type::Var(num))),
+            ),
+        );
+        self.define(
+            "*",
+            TypeScheme::poly(
+                vec![num],
+                Type::Fn(vec![Type::Var(num), Type::Var(num)], Box::new(Type::Var(num))),
+            ),
+        );
+        self.define(
+            "/",
+            TypeScheme::poly(
+                vec![num],
+                Type::Fn(vec![Type::Var(num), Type::Var(num)], Box::new(Type::Var(num))),
+            ),
+        );
+
+        // Comparison operators
+        let ord = TypeVar::fresh();
+        self.define(
+            "<",
+            TypeScheme::poly(
+                vec![ord],
+                Type::Fn(vec![Type::Var(ord), Type::Var(ord)], Box::new(Type::Bool)),
+            ),
+        );
+        self.define(
+            "<=",
+            TypeScheme::poly(
+                vec![ord],
+                Type::Fn(vec![Type::Var(ord), Type::Var(ord)], Box::new(Type::Bool)),
+            ),
+        );
+        self.define(
+            ">",
+            TypeScheme::poly(
+                vec![ord],
+                Type::Fn(vec![Type::Var(ord), Type::Var(ord)], Box::new(Type::Bool)),
+            ),
+        );
+        self.define(
+            ">=",
+            TypeScheme::poly(
+                vec![ord],
+                Type::Fn(vec![Type::Var(ord), Type::Var(ord)], Box::new(Type::Bool)),
+            ),
+        );
+
+        // Equality operators
+        let eq = TypeVar::fresh();
+        self.define(
+            "==",
+            TypeScheme::poly(
+                vec![eq],
+                Type::Fn(vec![Type::Var(eq), Type::Var(eq)], Box::new(Type::Bool)),
+            ),
+        );
+        self.define(
+            "!=",
+            TypeScheme::poly(
+                vec![eq],
+                Type::Fn(vec![Type::Var(eq), Type::Var(eq)], Box::new(Type::Bool)),
+            ),
+        );
+
+        // Logical operators
+        self.define(
+            "&&",
+            TypeScheme::mono(Type::Fn(vec![Type::Bool, Type::Bool], Box::new(Type::Bool))),
+        );
+        self.define(
+            "||",
+            TypeScheme::mono(Type::Fn(vec![Type::Bool, Type::Bool], Box::new(Type::Bool))),
+        );
+        self.define(
+            "!",
+            TypeScheme::mono(Type::Fn(vec![Type::Bool], Box::new(Type::Bool))),
+        );
+    }
+
+    /// Push a new scope.
+    pub fn push_scope(&mut self) {
+        self.bindings.push(HashMap::new());
+    }
+
+    /// Pop the current scope.
+    pub fn pop_scope(&mut self) {
+        if self.bindings.len() > 1 {
+            self.bindings.pop();
+        }
+    }
+
+    /// Define a variable in the current scope.
+    pub fn define(&mut self, name: impl Into<String>, scheme: TypeScheme) {
+        if let Some(scope) = self.bindings.last_mut() {
+            scope.insert(name.into(), scheme);
+        }
+    }
+
+    /// Look up a variable.
+    pub fn lookup(&self, name: &str) -> Option<&TypeScheme> {
+        for scope in self.bindings.iter().rev() {
+            if let Some(scheme) = scope.get(name) {
+                return Some(scheme);
+            }
+        }
+        None
+    }
+
+    /// Define a type.
+    pub fn define_type(&mut self, name: impl Into<String>, def: TypeDef) {
+        self.types.insert(name.into(), def);
+    }
+
+    /// Look up a type definition.
+    pub fn lookup_type(&self, name: &str) -> Option<&TypeDef> {
+        self.types.get(name)
+    }
+
+    /// Get all variables in scope.
+    pub fn all_bindings(&self) -> impl Iterator<Item = (&String, &TypeScheme)> {
+        self.bindings.iter().flat_map(|scope| scope.iter())
+    }
+
+    /// Generalize a type to a type scheme.
+    ///
+    /// Type variables that are free in the environment are not generalized.
+    pub fn generalize(&self, ty: &Type) -> TypeScheme {
+        let free_in_env: Vec<TypeVar> = self
+            .bindings
+            .iter()
+            .flat_map(|scope| scope.values())
+            .flat_map(|scheme| scheme.ty.free_vars())
+            .collect();
+
+        let free_in_ty = ty.free_vars();
+        let quantified: Vec<TypeVar> = free_in_ty
+            .into_iter()
+            .filter(|v| !free_in_env.contains(v))
+            .collect();
+
+        TypeScheme::poly(quantified, ty.clone())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_env_lookup() {
+        let mut env = TypeEnv::new();
+        env.define("x", TypeScheme::mono(Type::Int));
+
+        assert!(env.lookup("x").is_some());
+        assert_eq!(env.lookup("x").unwrap().ty, Type::Int);
+        assert!(env.lookup("y").is_none());
+    }
+
+    #[test]
+    fn test_env_scoping() {
+        let mut env = TypeEnv::new();
+        env.define("x", TypeScheme::mono(Type::Int));
+
+        env.push_scope();
+        env.define("x", TypeScheme::mono(Type::String));
+
+        // Inner scope shadows outer
+        assert_eq!(env.lookup("x").unwrap().ty, Type::String);
+
+        env.pop_scope();
+
+        // Back to outer scope
+        assert_eq!(env.lookup("x").unwrap().ty, Type::Int);
+    }
+
+    #[test]
+    fn test_env_builtins() {
+        let env = TypeEnv::new();
+
+        // Check that built-in operators exist
+        assert!(env.lookup("+").is_some());
+        assert!(env.lookup("<").is_some());
+        assert!(env.lookup("&&").is_some());
+
+        // Check that built-in skating constructors exist
+        assert!(env.lookup("triple_axel").is_some());
+        assert_eq!(env.lookup("triple_axel").unwrap().ty, Type::Jump);
+    }
+
+    #[test]
+    fn test_generalize() {
+        let env = TypeEnv::new();
+        let alpha = TypeVar::fresh();
+        let ty = Type::Fn(vec![Type::Var(alpha)], Box::new(Type::Var(alpha)));
+
+        let scheme = env.generalize(&ty);
+        assert_eq!(scheme.vars.len(), 1);
+        assert!(scheme.vars.contains(&alpha));
+    }
+}
diff --git a/crates/anv-types/src/lib.rs b/crates/anv-types/src/lib.rs
new file mode 100644
index 0000000..c87234b
--- /dev/null
+++ b/crates/anv-types/src/lib.rs
@@ -0,0 +1,41 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Type system for Anvomidav.
+//!
+//! This crate provides type checking and inference for the Anvomidav DSL.
+//! It includes:
+//!
+//! - **Types** (`ty` module): Internal type representation
+//! - **Environment** (`env` module): Type environment with scoping
+//! - **Checker** (`check` module): Type checking and inference
+//!
+//! # Example
+//!
+//! ```ignore
+//! use anv_types::check;
+//! use anv_syntax::parse;
+//! use anv_core::source::FileId;
+//!
+//! let source = r#"
+//!     program my_routine {
+//!         segment intro: short {
+//!             sequence {
+//!                 jump triple axel at 1:30
+//!             }
+//!         }
+//!     }
+//! "#;
+//!
+//! let program = parse(source, FileId(0)).unwrap();
+//! let result = check(&program, FileId(0));
+//! assert!(result.is_ok());
+//! ```
+
+pub mod check;
+pub mod env;
+pub mod ty;
+
+pub use check::{check, TypeChecker, TypeError, TypeResult};
+pub use env::{TypeDef, TypeDefBody, TypeEnv};
+pub use ty::{Type, TypeScheme, TypeVar};
diff --git a/crates/anv-types/src/ty.rs b/crates/anv-types/src/ty.rs
new file mode 100644
index 0000000..3363a74
--- /dev/null
+++ b/crates/anv-types/src/ty.rs
@@ -0,0 +1,490 @@
+// SPDX-FileCopyrightText: 2025 hyperpolymath
+// SPDX-License-Identifier: MIT OR AGPL-3.0-or-later
+
+//! Type definitions for Anvomidav.
+//!
+//! This module defines the internal representation of types used during
+//! type checking. Types are more detailed than AST type expressions and
+//! include resolved references and type variables.
+
+use std::collections::HashMap;
+use std::fmt;
+use std::sync::atomic::{AtomicU32, Ordering};
+
+/// Unique identifier for type variables.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct TypeVar(pub u32);
+
+impl TypeVar {
+    /// Generate a fresh type variable.
+    pub fn fresh() -> Self {
+        static COUNTER: AtomicU32 = AtomicU32::new(0);
+        TypeVar(COUNTER.fetch_add(1, Ordering::SeqCst))
+    }
+}
+
+impl fmt::Display for TypeVar {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        // Use Greek letters for type variables
+        let letters = ['α', 'β', 'γ', 'δ', 'ε', 'ζ', 'η', 'θ'];
+        if (self.0 as usize) < letters.len() {
+            write!(f, "{}", letters[self.0 as usize])
+        } else {
+            write!(f, "τ{}", self.0)
+        }
+    }
+}
+
+/// A type in the Anvomidav type system.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum Type {
+    // === Primitive types ===
+    /// Unit type (no value).
+    Unit,
+    /// Boolean type.
+    Bool,
+    /// Integer type.
+    Int,
+    /// Floating-point type.
+    Float,
+    /// String type.
+    String,
+
+    // === Domain-specific types ===
+    /// Time type (seconds).
+    Time,
+    /// Duration type (seconds).
+    Duration,
+    /// Position type (2D coordinates in meters).
+    Position,
+    /// Position3 type (3D coordinates in meters).
+    Position3,
+    /// Angle type (radians).
+    Angle,
+    /// Velocity type (m/s).
+    Velocity,
+    /// Beat type (musical beat reference).
+    Beat,
+    /// Edge type.
+    Edge,
+    /// Level type.
+    Level,
+
+    // === Skating element types ===
+    /// Jump element type.
+    Jump,
+    /// Spin element type.
+    Spin,
+    /// Step sequence type.
+    StepSequence,
+    /// Lift element type (pairs).
+    Lift,
+    /// Throw element type (pairs).
+    Throw,
+    /// Twist element type (pairs).
+    Twist,
+    /// Death spiral type (pairs).
+    DeathSpiral,
+    /// Transition element type.
+    Transition,
+    /// Choreographic element type.
+    Choreographic,
+    /// Generic element type (supertype of all element types).
+    Element,
+    /// Sequence type.
+    Sequence,
+    /// Segment type.
+    Segment,
+    /// Program type.
+    Program,
+
+    // === Compound types ===
+    /// Function type: (param_types) -> return_type.
+    Fn(Vec<Type>, Box<Type>),
+    /// Tuple type: (T1, T2, ...).
+    Tuple(Vec<Type>),
+    /// Array type: [T].
+    Array(Box<Type>),
+    /// Optional type: T?.
+    Optional(Box<Type>),
+    /// Record type: { field: Type, ... }.
+    Record(Vec<(String, Type)>),
+    /// Enum/variant type.
+    Variant(Vec<(String, Option<Type>)>),
+
+    // === Type constructors ===
+    /// Named type (user-defined or imported).
+    Named(String),
+    /// Generic type application: T<A, B, ...>.
+    App(Box<Type>, Vec<Type>),
+
+    // === Type variables for inference ===
+    /// Unification variable (for type inference).
+    Var(TypeVar),
+
+    // === Refinement types ===
+    /// Refinement type: { x: T | predicate }.
+    Refinement {
+        base: Box<Type>,
+        predicate: String, // For now, store as string; will be SMT expression
+    },
+
+    // === Error type ===
+    /// Error type (used during type checking when errors occur).
+    Error,
+}
+
+impl Type {
+    /// Returns true if this is a primitive type.
+    pub fn is_primitive(&self) -> bool {
+        matches!(
+            self,
+            Type::Unit | Type::Bool | Type::Int | Type::Float | Type::String
+        )
+    }
+
+    /// Returns true if this is a domain-specific type.
+    pub fn is_domain(&self) -> bool {
+        matches!(
+            self,
+            Type::Time
+                | Type::Duration
+                | Type::Position
+                | Type::Position3
+                | Type::Angle
+                | Type::Velocity
+                | Type::Beat
+                | Type::Edge
+                | Type::Level
+        )
+    }
+
+    /// Returns true if this is a skating element type.
+    pub fn is_element(&self) -> bool {
+        matches!(
+            self,
+            Type::Jump
+                | Type::Spin
+                | Type::StepSequence
+                | Type::Lift
+                | Type::Throw
+                | Type::Twist
+                | Type::DeathSpiral
+                | Type::Transition
+                | Type::Choreographic
+                | Type::Element
+        )
+    }
+
+    /// Returns true if this is a function type.
+    pub fn is_function(&self) -> bool {
+        matches!(self, Type::Fn(_, _))
+    }
+
+    /// Returns true if this type contains unresolved type variables.
+    pub fn has_vars(&self) -> bool {
+        match self {
+            Type::Var(_) => true,
+            Type::Fn(params, ret) => params.iter().any(|t| t.has_vars()) || ret.has_vars(),
+            Type::Tuple(ts) => ts.iter().any(|t| t.has_vars()),
+            Type::Array(t) | Type::Optional(t) => t.has_vars(),
+            Type::Record(fields) => fields.iter().any(|(_, t)| t.has_vars()),
+            Type::Variant(variants) => variants.iter().any(|(_, t)| t.as_ref().map_or(false, |t| t.has_vars())),
+            Type::App(base, args) => base.has_vars() || args.iter().any(|t| t.has_vars()),
+            Type::Refinement { base, .. } => base.has_vars(),
+            _ => false,
+        }
+    }
+
+    /// Substitute type variables according to the given mapping.
+    pub fn substitute(&self, subst: &HashMap<TypeVar, Type>) -> Type {
+        match self {
+            Type::Var(v) => subst.get(v).cloned().unwrap_or_else(|| self.clone()),
+            Type::Fn(params, ret) => Type::Fn(
+                params.iter().map(|t| t.substitute(subst)).collect(),
+                Box::new(ret.substitute(subst)),
+            ),
+            Type::Tuple(ts) => Type::Tuple(ts.iter().map(|t| t.substitute(subst)).collect()),
+            Type::Array(t) => Type::Array(Box::new(t.substitute(subst))),
+            Type::Optional(t) => Type::Optional(Box::new(t.substitute(subst))),
+            Type::Record(fields) => Type::Record(
+                fields
+                    .iter()
+                    .map(|(n, t)| (n.clone(), t.substitute(subst)))
+                    .collect(),
+            ),
+            Type::Variant(variants) => Type::Variant(
+                variants
+                    .iter()
+                    .map(|(n, t)| (n.clone(), t.as_ref().map(|t| t.substitute(subst))))
+                    .collect(),
+            ),
+            Type::App(base, args) => Type::App(
+                Box::new(base.substitute(subst)),
+                args.iter().map(|t| t.substitute(subst)).collect(),
+            ),
+            Type::Refinement { base, predicate } => Type::Refinement {
+                base: Box::new(base.substitute(subst)),
+                predicate: predicate.clone(),
+            },
+            _ => self.clone(),
+        }
+    }
+
+    /// Collect all type variables in this type.
+    pub fn free_vars(&self) -> Vec<TypeVar> {
+        let mut vars = Vec::new();
+        self.collect_vars(&mut vars);
+        vars
+    }
+
+    fn collect_vars(&self, vars: &mut Vec<TypeVar>) {
+        match self {
+            Type::Var(v) => {
+                if !vars.contains(v) {
+                    vars.push(*v);
+                }
+            }
+            Type::Fn(params, ret) => {
+                for p in params {
+                    p.collect_vars(vars);
+                }
+                ret.collect_vars(vars);
+            }
+            Type::Tuple(ts) => {
+                for t in ts {
+                    t.collect_vars(vars);
+                }
+            }
+            Type::Array(t) | Type::Optional(t) => t.collect_vars(vars),
+            Type::Record(fields) => {
+                for (_, t) in fields {
+                    t.collect_vars(vars);
+                }
+            }
+            Type::Variant(variants) => {
+                for (_, t) in variants {
+                    if let Some(t) = t {
+                        t.collect_vars(vars);
+                    }
+                }
+            }
+            Type::App(base, args) => {
+                base.collect_vars(vars);
+                for a in args {
+                    a.collect_vars(vars);
+                }
+            }
+            Type::Refinement { base, .. } => base.collect_vars(vars),
+            _ => {}
+        }
+    }
+}
+
+impl fmt::Display for Type {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Type::Unit => write!(f, "()"),
+            Type::Bool => write!(f, "Bool"),
+            Type::Int => write!(f, "Int"),
+            Type::Float => write!(f, "Float"),
+            Type::String => write!(f, "String"),
+            Type::Time => write!(f, "Time"),
+            Type::Duration => write!(f, "Duration"),
+            Type::Position => write!(f, "Position"),
+            Type::Position3 => write!(f, "Position3"),
+            Type::Angle => write!(f, "Angle"),
+            Type::Velocity => write!(f, "Velocity"),
+            Type::Beat => write!(f, "Beat"),
+            Type::Edge => write!(f, "Edge"),
+            Type::Level => write!(f, "Level"),
+            Type::Jump => write!(f, "Jump"),
+            Type::Spin => write!(f, "Spin"),
+            Type::StepSequence => write!(f, "StepSequence"),
+            Type::Lift => write!(f, "Lift"),
+            Type::Throw => write!(f, "Throw"),
+            Type::Twist => write!(f, "Twist"),
+            Type::DeathSpiral => write!(f, "DeathSpiral"),
+            Type::Transition => write!(f, "Transition"),
+            Type::Choreographic => write!(f, "Choreographic"),
+            Type::Element => write!(f, "Element"),
+            Type::Sequence => write!(f, "Sequence"),
+            Type::Segment => write!(f, "Segment"),
+            Type::Program => write!(f, "Program"),
+            Type::Fn(params, ret) => {
+                write!(f, "(")?;
+                for (i, p) in params.iter().enumerate() {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{}", p)?;
+                }
+                write!(f, ") -> {}", ret)
+            }
+            Type::Tuple(ts) => {
+                write!(f, "(")?;
+                for (i, t) in ts.iter().enumerate() {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{}", t)?;
+                }
+                write!(f, ")")
+            }
+            Type::Array(t) => write!(f, "[{}]", t),
+            Type::Optional(t) => write!(f, "{}?", t),
+            Type::Record(fields) => {
+                write!(f, "{{ ")?;
+                for (i, (name, ty)) in fields.iter().enumerate() {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{}: {}", name, ty)?;
+                }
+                write!(f, " }}")
+            }
+            Type::Variant(variants) => {
+                for (i, (name, ty)) in variants.iter().enumerate() {
+                    if i > 0 {
+                        write!(f, " | ")?;
+                    }
+                    write!(f, "{}", name)?;
+                    if let Some(ty) = ty {
+                        write!(f, "({})", ty)?;
+                    }
+                }
+                Ok(())
+            }
+            Type::Named(name) => write!(f, "{}", name),
+            Type::App(base, args) => {
+                write!(f, "{}<", base)?;
+                for (i, a) in args.iter().enumerate() {
+                    if i > 0 {
+                        write!(f, ", ")?;
+                    }
+                    write!(f, "{}", a)?;
+                }
+                write!(f, ">")
+            }
+            Type::Var(v) => write!(f, "{}", v),
+            Type::Refinement { base, predicate } => {
+                write!(f, "{{ x: {} | {} }}", base, predicate)
+            }
+            Type::Error => write!(f, "<error>"),
+        }
+    }
+}
+
+/// Type scheme (for polymorphic types).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TypeScheme {
+    /// Quantified type variables.
+    pub vars: Vec<TypeVar>,
+    /// The body type.
+    pub ty: Type,
+}
+
+impl TypeScheme {
+    /// Create a monomorphic type scheme (no quantified variables).
+    pub fn mono(ty: Type) -> Self {
+        TypeScheme { vars: vec![], ty }
+    }
+
+    /// Create a polymorphic type scheme.
+    pub fn poly(vars: Vec<TypeVar>, ty: Type) -> Self {
+        TypeScheme { vars, ty }
+    }
+
+    /// Instantiate the type scheme with fresh type variables.
+    pub fn instantiate(&self) -> Type {
+        let subst: HashMap<TypeVar, Type> = self
+            .vars
+            .iter()
+            .map(|v| (*v, Type::Var(TypeVar::fresh())))
+            .collect();
+        self.ty.substitute(&subst)
+    }
+}
+
+impl fmt::Display for TypeScheme {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if self.vars.is_empty() {
+            write!(f, "{}", self.ty)
+        } else {
+            write!(f, "∀")?;
+            for (i, v) in self.vars.iter().enumerate() {
+                if i > 0 {
+                    write!(f, ", ")?;
+                }
+                write!(f, "{}", v)?;
+            }
+            write!(f, ". {}", self.ty)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_type_display() {
+        assert_eq!(format!("{}", Type::Int), "Int");
+        assert_eq!(format!("{}", Type::Time), "Time");
+        assert_eq!(format!("{}", Type::Jump), "Jump");
+        assert_eq!(
+            format!("{}", Type::Fn(vec![Type::Int, Type::Int], Box::new(Type::Bool))),
+            "(Int, Int) -> Bool"
+        );
+        assert_eq!(
+            format!("{}", Type::Array(Box::new(Type::Element))),
+            "[Element]"
+        );
+    }
+
+    #[test]
+    fn test_type_var_fresh() {
+        let v1 = TypeVar::fresh();
+        let v2 = TypeVar::fresh();
+        assert_ne!(v1, v2);
+    }
+
+    #[test]
+    fn test_type_scheme_instantiate() {
+        let alpha = TypeVar::fresh();
+        let scheme = TypeScheme::poly(
+            vec![alpha],
+            Type::Fn(vec![Type::Var(alpha)], Box::new(Type::Var(alpha))),
+        );
+
+        let t1 = scheme.instantiate();
+        let t2 = scheme.instantiate();
+
+        // Each instantiation should produce different type variables
+        assert_ne!(t1, t2);
+    }
+
+    #[test]
+    fn test_type_substitute() {
+        let alpha = TypeVar::fresh();
+        let ty = Type::Fn(vec![Type::Var(alpha)], Box::new(Type::Int));
+
+        let mut subst = HashMap::new();
+        subst.insert(alpha, Type::String);
+
+        let result = ty.substitute(&subst);
+        assert_eq!(result, Type::Fn(vec![Type::String], Box::new(Type::Int)));
+    }
+
+    #[test]
+    fn test_free_vars() {
+        let alpha = TypeVar::fresh();
+        let beta = TypeVar::fresh();
+        let ty = Type::Fn(vec![Type::Var(alpha)], Box::new(Type::Var(beta)));
+
+        let vars = ty.free_vars();
+        assert_eq!(vars.len(), 2);
+        assert!(vars.contains(&alpha));
+        assert!(vars.contains(&beta));
+    }
+}