diff --git a/Cargo.lock b/Cargo.lock
index d25a9e9d2d..41007b15cc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -834,6 +834,7 @@ dependencies = [
  "rayon",
  "sqlbuild-config",
  "sqlbuild-core",
+ "sqlbuild-model-config",
  "sqlbuild-sqltext",
  "tempfile",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 97a9c2b859..d142b6768f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,10 +26,10 @@ order = [
     "sqlbuild-cache",
     "sqlbuild-sqltext",
     "sqlbuild-config",
+    "sqlbuild-model-config",
     "sqlbuild-discovery",
     "sqlbuild-render",
     "sqlbuild-scopes",
-    "sqlbuild-model-config",
     "sqlbuild-attachments",
     "sqlbuild-analysis",
     "sqlbuild-rules",
diff --git a/crates/sqlbuild-core/src/text/_helpers/mod.rs b/crates/sqlbuild-core/src/text/_helpers/mod.rs
index a24bcdea58..7e429641a5 100644
--- a/crates/sqlbuild-core/src/text/_helpers/mod.rs
+++ b/crates/sqlbuild-core/src/text/_helpers/mod.rs
@@ -1,3 +1,4 @@
 pub(crate) mod cleandoc;
 pub(crate) mod decimal_digits;
 pub(crate) mod glob;
+pub(crate) mod python_tables;
diff --git a/crates/sqlbuild-core/src/text/_helpers/python_tables.rs b/crates/sqlbuild-core/src/text/_helpers/python_tables.rs
new file mode 100644
index 0000000000..451667160f
--- /dev/null
+++ b/crates/sqlbuild-core/src/text/_helpers/python_tables.rs
@@ -0,0 +1,688 @@
+//! Where Python's `str` predicates differ from Rust's `char` methods, from CPython 3.12's tables.
+
+/// Characters `char::is_alphanumeric` accepts and `str.isalnum` rejects, as inclusive ranges.
+pub(crate) const NOT_PYTHON_ALNUM: [(u32, u32); 296] = [
+    (0x0345, 0x0345),
+    (0x0363, 0x036F),
+    (0x05B0, 0x05BD),
+    (0x05BF, 0x05BF),
+    (0x05C1, 0x05C2),
+    (0x05C4, 0x05C5),
+    (0x05C7, 0x05C7),
+    (0x0610, 0x061A),
+    (0x064B, 0x0657),
+    (0x0659, 0x065F),
+    (0x0670, 0x0670),
+    (0x06D6, 0x06DC),
+    (0x06E1, 0x06E4),
+    (0x06E7, 0x06E8),
+    (0x06ED, 0x06ED),
+    (0x0711, 0x0711),
+    (0x0730, 0x073F),
+    (0x07A6, 0x07B0),
+    (0x0816, 0x0817),
+    (0x081B, 0x0823),
+    (0x0825, 0x0827),
+    (0x0829, 0x082C),
+    (0x088F, 0x088F),
+    (0x0897, 0x0897),
+    (0x08D4, 0x08DF),
+    (0x08E3, 0x08E9),
+    (0x08F0, 0x0903),
+    (0x093A, 0x093B),
+    (0x093E, 0x094C),
+    (0x094E, 0x094F),
+    (0x0955, 0x0957),
+    (0x0962, 0x0963),
+    (0x0981, 0x0983),
+    (0x09BE, 0x09C4),
+    (0x09C7, 0x09C8),
+    (0x09CB, 0x09CC),
+    (0x09D7, 0x09D7),
+    (0x09E2, 0x09E3),
+    (0x0A01, 0x0A03),
+    (0x0A3E, 0x0A42),
+    (0x0A47, 0x0A48),
+    (0x0A4B, 0x0A4C),
+    (0x0A51, 0x0A51),
+    (0x0A70, 0x0A71),
+    (0x0A75, 0x0A75),
+    (0x0A81, 0x0A83),
+    (0x0ABE, 0x0AC5),
+    (0x0AC7, 0x0AC9),
+    (0x0ACB, 0x0ACC),
+    (0x0AE2, 0x0AE3),
+    (0x0AFA, 0x0AFC),
+    (0x0B01, 0x0B03),
+    (0x0B3E, 0x0B44),
+    (0x0B47, 0x0B48),
+    (0x0B4B, 0x0B4C),
+    (0x0B56, 0x0B57),
+    (0x0B62, 0x0B63),
+    (0x0B82, 0x0B82),
+    (0x0BBE, 0x0BC2),
+    (0x0BC6, 0x0BC8),
+    (0x0BCA, 0x0BCC),
+    (0x0BD7, 0x0BD7),
+    (0x0C00, 0x0C04),
+    (0x0C3E, 0x0C44),
+    (0x0C46, 0x0C48),
+    (0x0C4A, 0x0C4C),
+    (0x0C55, 0x0C56),
+    (0x0C5C, 0x0C5C),
+    (0x0C62, 0x0C63),
+    (0x0C81, 0x0C83),
+    (0x0CBE, 0x0CC4),
+    (0x0CC6, 0x0CC8),
+    (0x0CCA, 0x0CCC),
+    (0x0CD5, 0x0CD6),
+    (0x0CDC, 0x0CDC),
+    (0x0CE2, 0x0CE3),
+    (0x0CF3, 0x0CF3),
+    (0x0D00, 0x0D03),
+    (0x0D3E, 0x0D44),
+    (0x0D46, 0x0D48),
+    (0x0D4A, 0x0D4C),
+    (0x0D57, 0x0D57),
+    (0x0D62, 0x0D63),
+    (0x0D81, 0x0D83),
+    (0x0DCF, 0x0DD4),
+    (0x0DD6, 0x0DD6),
+    (0x0DD8, 0x0DDF),
+    (0x0DF2, 0x0DF3),
+    (0x0E31, 0x0E31),
+    (0x0E34, 0x0E3A),
+    (0x0E4D, 0x0E4D),
+    (0x0EB1, 0x0EB1),
+    (0x0EB4, 0x0EB9),
+    (0x0EBB, 0x0EBC),
+    (0x0ECD, 0x0ECD),
+    (0x0F71, 0x0F83),
+    (0x0F8D, 0x0F97),
+    (0x0F99, 0x0FBC),
+    (0x102B, 0x1036),
+    (0x1038, 0x1038),
+    (0x103B, 0x103E),
+    (0x1056, 0x1059),
+    (0x105E, 0x1060),
+    (0x1062, 0x1064),
+    (0x1067, 0x106D),
+    (0x1071, 0x1074),
+    (0x1082, 0x108D),
+    (0x108F, 0x108F),
+    (0x109A, 0x109D),
+    (0x1712, 0x1713),
+    (0x1732, 0x1733),
+    (0x1752, 0x1753),
+    (0x1772, 0x1773),
+    (0x17B6, 0x17C8),
+    (0x1885, 0x1886),
+    (0x18A9, 0x18A9),
+    (0x1920, 0x192B),
+    (0x1930, 0x1938),
+    (0x1A17, 0x1A1B),
+    (0x1A55, 0x1A5E),
+    (0x1A61, 0x1A74),
+    (0x1ABF, 0x1AC0),
+    (0x1ACC, 0x1ACE),
+    (0x1B00, 0x1B04),
+    (0x1B35, 0x1B43),
+    (0x1B80, 0x1B82),
+    (0x1BA1, 0x1BA9),
+    (0x1BAC, 0x1BAD),
+    (0x1BE7, 0x1BF1),
+    (0x1C24, 0x1C36),
+    (0x1C89, 0x1C8A),
+    (0x1DD3, 0x1DF4),
+    (0x24B6, 0x24E9),
+    (0x2DE0, 0x2DFF),
+    (0xA674, 0xA67B),
+    (0xA69E, 0xA69F),
+    (0xA7CB, 0xA7CF),
+    (0xA7D2, 0xA7D2),
+    (0xA7D4, 0xA7D4),
+    (0xA7DA, 0xA7DC),
+    (0xA7F1, 0xA7F1),
+    (0xA802, 0xA802),
+    (0xA80B, 0xA80B),
+    (0xA823, 0xA827),
+    (0xA880, 0xA881),
+    (0xA8B4, 0xA8C3),
+    (0xA8C5, 0xA8C5),
+    (0xA8FF, 0xA8FF),
+    (0xA926, 0xA92A),
+    (0xA947, 0xA952),
+    (0xA980, 0xA983),
+    (0xA9B4, 0xA9BF),
+    (0xA9E5, 0xA9E5),
+    (0xAA29, 0xAA36),
+    (0xAA43, 0xAA43),
+    (0xAA4C, 0xAA4D),
+    (0xAA7B, 0xAA7D),
+    (0xAAB0, 0xAAB0),
+    (0xAAB2, 0xAAB4),
+    (0xAAB7, 0xAAB8),
+    (0xAABE, 0xAABE),
+    (0xAAEB, 0xAAEF),
+    (0xAAF5, 0xAAF5),
+    (0xABE3, 0xABEA),
+    (0xFB1E, 0xFB1E),
+    (0x10376, 0x1037A),
+    (0x105C0, 0x105F3),
+    (0x10940, 0x10959),
+    (0x10A01, 0x10A03),
+    (0x10A05, 0x10A06),
+    (0x10A0C, 0x10A0F),
+    (0x10D24, 0x10D27),
+    (0x10D40, 0x10D65),
+    (0x10D69, 0x10D69),
+    (0x10D6F, 0x10D85),
+    (0x10EAB, 0x10EAC),
+    (0x10EC2, 0x10EC7),
+    (0x10EFA, 0x10EFC),
+    (0x11000, 0x11002),
+    (0x11038, 0x11045),
+    (0x11073, 0x11074),
+    (0x11080, 0x11082),
+    (0x110B0, 0x110B8),
+    (0x110C2, 0x110C2),
+    (0x11100, 0x11102),
+    (0x11127, 0x11132),
+    (0x11145, 0x11146),
+    (0x11180, 0x11182),
+    (0x111B3, 0x111BF),
+    (0x111CE, 0x111CF),
+    (0x1122C, 0x11234),
+    (0x11237, 0x11237),
+    (0x1123E, 0x1123E),
+    (0x11241, 0x11241),
+    (0x112DF, 0x112E8),
+    (0x11300, 0x11303),
+    (0x1133E, 0x11344),
+    (0x11347, 0x11348),
+    (0x1134B, 0x1134C),
+    (0x11357, 0x11357),
+    (0x11362, 0x11363),
+    (0x11380, 0x11389),
+    (0x1138B, 0x1138B),
+    (0x1138E, 0x1138E),
+    (0x11390, 0x113B5),
+    (0x113B7, 0x113C0),
+    (0x113C2, 0x113C2),
+    (0x113C5, 0x113C5),
+    (0x113C7, 0x113CA),
+    (0x113CC, 0x113CD),
+    (0x113D1, 0x113D1),
+    (0x113D3, 0x113D3),
+    (0x11435, 0x11441),
+    (0x11443, 0x11445),
+    (0x114B0, 0x114C1),
+    (0x115AF, 0x115B5),
+    (0x115B8, 0x115BE),
+    (0x115DC, 0x115DD),
+    (0x11630, 0x1163E),
+    (0x11640, 0x11640),
+    (0x116AB, 0x116B5),
+    (0x116D0, 0x116E3),
+    (0x1171D, 0x1172A),
+    (0x1182C, 0x11838),
+    (0x11930, 0x11935),
+    (0x11937, 0x11938),
+    (0x1193B, 0x1193C),
+    (0x11940, 0x11940),
+    (0x11942, 0x11942),
+    (0x119D1, 0x119D7),
+    (0x119DA, 0x119DF),
+    (0x119E4, 0x119E4),
+    (0x11A01, 0x11A0A),
+    (0x11A35, 0x11A39),
+    (0x11A3B, 0x11A3E),
+    (0x11A51, 0x11A5B),
+    (0x11A8A, 0x11A97),
+    (0x11B60, 0x11B67),
+    (0x11BC0, 0x11BE0),
+    (0x11BF0, 0x11BF9),
+    (0x11C2F, 0x11C36),
+    (0x11C38, 0x11C3E),
+    (0x11C92, 0x11CA7),
+    (0x11CA9, 0x11CB6),
+    (0x11D31, 0x11D36),
+    (0x11D3A, 0x11D3A),
+    (0x11D3C, 0x11D3D),
+    (0x11D3F, 0x11D41),
+    (0x11D43, 0x11D43),
+    (0x11D47, 0x11D47),
+    (0x11D8A, 0x11D8E),
+    (0x11D90, 0x11D91),
+    (0x11D93, 0x11D96),
+    (0x11DB0, 0x11DDB),
+    (0x11DE0, 0x11DE9),
+    (0x11EF3, 0x11EF6),
+    (0x11F00, 0x11F01),
+    (0x11F03, 0x11F03),
+    (0x11F34, 0x11F3A),
+    (0x11F3E, 0x11F40),
+    (0x13460, 0x143FA),
+    (0x16100, 0x1612E),
+    (0x16130, 0x16139),
+    (0x16D40, 0x16D6C),
+    (0x16D70, 0x16D79),
+    (0x16EA0, 0x16EB8),
+    (0x16EBB, 0x16ED3),
+    (0x16F4F, 0x16F4F),
+    (0x16F51, 0x16F87),
+    (0x16F8F, 0x16F92),
+    (0x16FF0, 0x16FF6),
+    (0x187F8, 0x187FF),
+    (0x18CFF, 0x18CFF),
+    (0x18D09, 0x18D1E),
+    (0x18D80, 0x18DF2),
+    (0x1BC9E, 0x1BC9E),
+    (0x1CCF0, 0x1CCF9),
+    (0x1E000, 0x1E006),
+    (0x1E008, 0x1E018),
+    (0x1E01B, 0x1E021),
+    (0x1E023, 0x1E024),
+    (0x1E026, 0x1E02A),
+    (0x1E08F, 0x1E08F),
+    (0x1E5D0, 0x1E5ED),
+    (0x1E5F0, 0x1E5FA),
+    (0x1E6C0, 0x1E6DE),
+    (0x1E6E0, 0x1E6F5),
+    (0x1E6FE, 0x1E6FF),
+    (0x1E947, 0x1E947),
+    (0x1F130, 0x1F149),
+    (0x1F150, 0x1F169),
+    (0x1F170, 0x1F189),
+    (0x2B73A, 0x2B73F),
+    (0x2CEA2, 0x2CEAD),
+    (0x2EBF0, 0x2EE5D),
+    (0x323B0, 0x33479),
+];
+
+/// Characters `str.isdigit` accepts beyond the decimal digits, as inclusive ranges.
+pub(crate) const PYTHON_NON_DECIMAL_DIGITS: [(u32, u32); 20] = [
+    (0x00B2, 0x00B3),
+    (0x00B9, 0x00B9),
+    (0x1369, 0x1371),
+    (0x19DA, 0x19DA),
+    (0x2070, 0x2070),
+    (0x2074, 0x2079),
+    (0x2080, 0x2089),
+    (0x2460, 0x2468),
+    (0x2474, 0x247C),
+    (0x2488, 0x2490),
+    (0x24EA, 0x24EA),
+    (0x24F5, 0x24FD),
+    (0x24FF, 0x24FF),
+    (0x2776, 0x277E),
+    (0x2780, 0x2788),
+    (0x278A, 0x2792),
+    (0x10A40, 0x10A43),
+    (0x10E60, 0x10E68),
+    (0x11052, 0x1105A),
+    (0x1F100, 0x1F10A),
+];
+
+/// `str.casefold` of each character whose casefold differs from `char::to_lowercase`.
+pub(crate) const PYTHON_CASEFOLD: [(u32, &str); 352] = [
+    (0x00B5, "\u{3bc}"),
+    (0x00DF, "ss"),
+    (0x0149, "\u{2bc}n"),
+    (0x017F, "s"),
+    (0x01F0, "j\u{30c}"),
+    (0x0345, "\u{3b9}"),
+    (0x0390, "\u{3b9}\u{308}\u{301}"),
+    (0x03B0, "\u{3c5}\u{308}\u{301}"),
+    (0x03C2, "\u{3c3}"),
+    (0x03D0, "\u{3b2}"),
+    (0x03D1, "\u{3b8}"),
+    (0x03D5, "\u{3c6}"),
+    (0x03D6, "\u{3c0}"),
+    (0x03F0, "\u{3ba}"),
+    (0x03F1, "\u{3c1}"),
+    (0x03F5, "\u{3b5}"),
+    (0x0587, "\u{565}\u{582}"),
+    (0x13A0, "\u{13a0}"),
+    (0x13A1, "\u{13a1}"),
+    (0x13A2, "\u{13a2}"),
+    (0x13A3, "\u{13a3}"),
+    (0x13A4, "\u{13a4}"),
+    (0x13A5, "\u{13a5}"),
+    (0x13A6, "\u{13a6}"),
+    (0x13A7, "\u{13a7}"),
+    (0x13A8, "\u{13a8}"),
+    (0x13A9, "\u{13a9}"),
+    (0x13AA, "\u{13aa}"),
+    (0x13AB, "\u{13ab}"),
+    (0x13AC, "\u{13ac}"),
+    (0x13AD, "\u{13ad}"),
+    (0x13AE, "\u{13ae}"),
+    (0x13AF, "\u{13af}"),
+    (0x13B0, "\u{13b0}"),
+    (0x13B1, "\u{13b1}"),
+    (0x13B2, "\u{13b2}"),
+    (0x13B3, "\u{13b3}"),
+    (0x13B4, "\u{13b4}"),
+    (0x13B5, "\u{13b5}"),
+    (0x13B6, "\u{13b6}"),
+    (0x13B7, "\u{13b7}"),
+    (0x13B8, "\u{13b8}"),
+    (0x13B9, "\u{13b9}"),
+    (0x13BA, "\u{13ba}"),
+    (0x13BB, "\u{13bb}"),
+    (0x13BC, "\u{13bc}"),
+    (0x13BD, "\u{13bd}"),
+    (0x13BE, "\u{13be}"),
+    (0x13BF, "\u{13bf}"),
+    (0x13C0, "\u{13c0}"),
+    (0x13C1, "\u{13c1}"),
+    (0x13C2, "\u{13c2}"),
+    (0x13C3, "\u{13c3}"),
+    (0x13C4, "\u{13c4}"),
+    (0x13C5, "\u{13c5}"),
+    (0x13C6, "\u{13c6}"),
+    (0x13C7, "\u{13c7}"),
+    (0x13C8, "\u{13c8}"),
+    (0x13C9, "\u{13c9}"),
+    (0x13CA, "\u{13ca}"),
+    (0x13CB, "\u{13cb}"),
+    (0x13CC, "\u{13cc}"),
+    (0x13CD, "\u{13cd}"),
+    (0x13CE, "\u{13ce}"),
+    (0x13CF, "\u{13cf}"),
+    (0x13D0, "\u{13d0}"),
+    (0x13D1, "\u{13d1}"),
+    (0x13D2, "\u{13d2}"),
+    (0x13D3, "\u{13d3}"),
+    (0x13D4, "\u{13d4}"),
+    (0x13D5, "\u{13d5}"),
+    (0x13D6, "\u{13d6}"),
+    (0x13D7, "\u{13d7}"),
+    (0x13D8, "\u{13d8}"),
+    (0x13D9, "\u{13d9}"),
+    (0x13DA, "\u{13da}"),
+    (0x13DB, "\u{13db}"),
+    (0x13DC, "\u{13dc}"),
+    (0x13DD, "\u{13dd}"),
+    (0x13DE, "\u{13de}"),
+    (0x13DF, "\u{13df}"),
+    (0x13E0, "\u{13e0}"),
+    (0x13E1, "\u{13e1}"),
+    (0x13E2, "\u{13e2}"),
+    (0x13E3, "\u{13e3}"),
+    (0x13E4, "\u{13e4}"),
+    (0x13E5, "\u{13e5}"),
+    (0x13E6, "\u{13e6}"),
+    (0x13E7, "\u{13e7}"),
+    (0x13E8, "\u{13e8}"),
+    (0x13E9, "\u{13e9}"),
+    (0x13EA, "\u{13ea}"),
+    (0x13EB, "\u{13eb}"),
+    (0x13EC, "\u{13ec}"),
+    (0x13ED, "\u{13ed}"),
+    (0x13EE, "\u{13ee}"),
+    (0x13EF, "\u{13ef}"),
+    (0x13F0, "\u{13f0}"),
+    (0x13F1, "\u{13f1}"),
+    (0x13F2, "\u{13f2}"),
+    (0x13F3, "\u{13f3}"),
+    (0x13F4, "\u{13f4}"),
+    (0x13F5, "\u{13f5}"),
+    (0x13F8, "\u{13f0}"),
+    (0x13F9, "\u{13f1}"),
+    (0x13FA, "\u{13f2}"),
+    (0x13FB, "\u{13f3}"),
+    (0x13FC, "\u{13f4}"),
+    (0x13FD, "\u{13f5}"),
+    (0x1C80, "\u{432}"),
+    (0x1C81, "\u{434}"),
+    (0x1C82, "\u{43e}"),
+    (0x1C83, "\u{441}"),
+    (0x1C84, "\u{442}"),
+    (0x1C85, "\u{442}"),
+    (0x1C86, "\u{44a}"),
+    (0x1C87, "\u{463}"),
+    (0x1C88, "\u{a64b}"),
+    (0x1C89, "\u{1c89}"),
+    (0x1E96, "h\u{331}"),
+    (0x1E97, "t\u{308}"),
+    (0x1E98, "w\u{30a}"),
+    (0x1E99, "y\u{30a}"),
+    (0x1E9A, "a\u{2be}"),
+    (0x1E9B, "\u{1e61}"),
+    (0x1E9E, "ss"),
+    (0x1F50, "\u{3c5}\u{313}"),
+    (0x1F52, "\u{3c5}\u{313}\u{300}"),
+    (0x1F54, "\u{3c5}\u{313}\u{301}"),
+    (0x1F56, "\u{3c5}\u{313}\u{342}"),
+    (0x1F80, "\u{1f00}\u{3b9}"),
+    (0x1F81, "\u{1f01}\u{3b9}"),
+    (0x1F82, "\u{1f02}\u{3b9}"),
+    (0x1F83, "\u{1f03}\u{3b9}"),
+    (0x1F84, "\u{1f04}\u{3b9}"),
+    (0x1F85, "\u{1f05}\u{3b9}"),
+    (0x1F86, "\u{1f06}\u{3b9}"),
+    (0x1F87, "\u{1f07}\u{3b9}"),
+    (0x1F88, "\u{1f00}\u{3b9}"),
+    (0x1F89, "\u{1f01}\u{3b9}"),
+    (0x1F8A, "\u{1f02}\u{3b9}"),
+    (0x1F8B, "\u{1f03}\u{3b9}"),
+    (0x1F8C, "\u{1f04}\u{3b9}"),
+    (0x1F8D, "\u{1f05}\u{3b9}"),
+    (0x1F8E, "\u{1f06}\u{3b9}"),
+    (0x1F8F, "\u{1f07}\u{3b9}"),
+    (0x1F90, "\u{1f20}\u{3b9}"),
+    (0x1F91, "\u{1f21}\u{3b9}"),
+    (0x1F92, "\u{1f22}\u{3b9}"),
+    (0x1F93, "\u{1f23}\u{3b9}"),
+    (0x1F94, "\u{1f24}\u{3b9}"),
+    (0x1F95, "\u{1f25}\u{3b9}"),
+    (0x1F96, "\u{1f26}\u{3b9}"),
+    (0x1F97, "\u{1f27}\u{3b9}"),
+    (0x1F98, "\u{1f20}\u{3b9}"),
+    (0x1F99, "\u{1f21}\u{3b9}"),
+    (0x1F9A, "\u{1f22}\u{3b9}"),
+    (0x1F9B, "\u{1f23}\u{3b9}"),
+    (0x1F9C, "\u{1f24}\u{3b9}"),
+    (0x1F9D, "\u{1f25}\u{3b9}"),
+    (0x1F9E, "\u{1f26}\u{3b9}"),
+    (0x1F9F, "\u{1f27}\u{3b9}"),
+    (0x1FA0, "\u{1f60}\u{3b9}"),
+    (0x1FA1, "\u{1f61}\u{3b9}"),
+    (0x1FA2, "\u{1f62}\u{3b9}"),
+    (0x1FA3, "\u{1f63}\u{3b9}"),
+    (0x1FA4, "\u{1f64}\u{3b9}"),
+    (0x1FA5, "\u{1f65}\u{3b9}"),
+    (0x1FA6, "\u{1f66}\u{3b9}"),
+    (0x1FA7, "\u{1f67}\u{3b9}"),
+    (0x1FA8, "\u{1f60}\u{3b9}"),
+    (0x1FA9, "\u{1f61}\u{3b9}"),
+    (0x1FAA, "\u{1f62}\u{3b9}"),
+    (0x1FAB, "\u{1f63}\u{3b9}"),
+    (0x1FAC, "\u{1f64}\u{3b9}"),
+    (0x1FAD, "\u{1f65}\u{3b9}"),
+    (0x1FAE, "\u{1f66}\u{3b9}"),
+    (0x1FAF, "\u{1f67}\u{3b9}"),
+    (0x1FB2, "\u{1f70}\u{3b9}"),
+    (0x1FB3, "\u{3b1}\u{3b9}"),
+    (0x1FB4, "\u{3ac}\u{3b9}"),
+    (0x1FB6, "\u{3b1}\u{342}"),
+    (0x1FB7, "\u{3b1}\u{342}\u{3b9}"),
+    (0x1FBC, "\u{3b1}\u{3b9}"),
+    (0x1FBE, "\u{3b9}"),
+    (0x1FC2, "\u{1f74}\u{3b9}"),
+    (0x1FC3, "\u{3b7}\u{3b9}"),
+    (0x1FC4, "\u{3ae}\u{3b9}"),
+    (0x1FC6, "\u{3b7}\u{342}"),
+    (0x1FC7, "\u{3b7}\u{342}\u{3b9}"),
+    (0x1FCC, "\u{3b7}\u{3b9}"),
+    (0x1FD2, "\u{3b9}\u{308}\u{300}"),
+    (0x1FD3, "\u{3b9}\u{308}\u{301}"),
+    (0x1FD6, "\u{3b9}\u{342}"),
+    (0x1FD7, "\u{3b9}\u{308}\u{342}"),
+    (0x1FE2, "\u{3c5}\u{308}\u{300}"),
+    (0x1FE3, "\u{3c5}\u{308}\u{301}"),
+    (0x1FE4, "\u{3c1}\u{313}"),
+    (0x1FE6, "\u{3c5}\u{342}"),
+    (0x1FE7, "\u{3c5}\u{308}\u{342}"),
+    (0x1FF2, "\u{1f7c}\u{3b9}"),
+    (0x1FF3, "\u{3c9}\u{3b9}"),
+    (0x1FF4, "\u{3ce}\u{3b9}"),
+    (0x1FF6, "\u{3c9}\u{342}"),
+    (0x1FF7, "\u{3c9}\u{342}\u{3b9}"),
+    (0x1FFC, "\u{3c9}\u{3b9}"),
+    (0xA7CB, "\u{a7cb}"),
+    (0xA7CC, "\u{a7cc}"),
+    (0xA7CE, "\u{a7ce}"),
+    (0xA7D2, "\u{a7d2}"),
+    (0xA7D4, "\u{a7d4}"),
+    (0xA7DA, "\u{a7da}"),
+    (0xA7DC, "\u{a7dc}"),
+    (0xAB70, "\u{13a0}"),
+    (0xAB71, "\u{13a1}"),
+    (0xAB72, "\u{13a2}"),
+    (0xAB73, "\u{13a3}"),
+    (0xAB74, "\u{13a4}"),
+    (0xAB75, "\u{13a5}"),
+    (0xAB76, "\u{13a6}"),
+    (0xAB77, "\u{13a7}"),
+    (0xAB78, "\u{13a8}"),
+    (0xAB79, "\u{13a9}"),
+    (0xAB7A, "\u{13aa}"),
+    (0xAB7B, "\u{13ab}"),
+    (0xAB7C, "\u{13ac}"),
+    (0xAB7D, "\u{13ad}"),
+    (0xAB7E, "\u{13ae}"),
+    (0xAB7F, "\u{13af}"),
+    (0xAB80, "\u{13b0}"),
+    (0xAB81, "\u{13b1}"),
+    (0xAB82, "\u{13b2}"),
+    (0xAB83, "\u{13b3}"),
+    (0xAB84, "\u{13b4}"),
+    (0xAB85, "\u{13b5}"),
+    (0xAB86, "\u{13b6}"),
+    (0xAB87, "\u{13b7}"),
+    (0xAB88, "\u{13b8}"),
+    (0xAB89, "\u{13b9}"),
+    (0xAB8A, "\u{13ba}"),
+    (0xAB8B, "\u{13bb}"),
+    (0xAB8C, "\u{13bc}"),
+    (0xAB8D, "\u{13bd}"),
+    (0xAB8E, "\u{13be}"),
+    (0xAB8F, "\u{13bf}"),
+    (0xAB90, "\u{13c0}"),
+    (0xAB91, "\u{13c1}"),
+    (0xAB92, "\u{13c2}"),
+    (0xAB93, "\u{13c3}"),
+    (0xAB94, "\u{13c4}"),
+    (0xAB95, "\u{13c5}"),
+    (0xAB96, "\u{13c6}"),
+    (0xAB97, "\u{13c7}"),
+    (0xAB98, "\u{13c8}"),
+    (0xAB99, "\u{13c9}"),
+    (0xAB9A, "\u{13ca}"),
+    (0xAB9B, "\u{13cb}"),
+    (0xAB9C, "\u{13cc}"),
+    (0xAB9D, "\u{13cd}"),
+    (0xAB9E, "\u{13ce}"),
+    (0xAB9F, "\u{13cf}"),
+    (0xABA0, "\u{13d0}"),
+    (0xABA1, "\u{13d1}"),
+    (0xABA2, "\u{13d2}"),
+    (0xABA3, "\u{13d3}"),
+    (0xABA4, "\u{13d4}"),
+    (0xABA5, "\u{13d5}"),
+    (0xABA6, "\u{13d6}"),
+    (0xABA7, "\u{13d7}"),
+    (0xABA8, "\u{13d8}"),
+    (0xABA9, "\u{13d9}"),
+    (0xABAA, "\u{13da}"),
+    (0xABAB, "\u{13db}"),
+    (0xABAC, "\u{13dc}"),
+    (0xABAD, "\u{13dd}"),
+    (0xABAE, "\u{13de}"),
+    (0xABAF, "\u{13df}"),
+    (0xABB0, "\u{13e0}"),
+    (0xABB1, "\u{13e1}"),
+    (0xABB2, "\u{13e2}"),
+    (0xABB3, "\u{13e3}"),
+    (0xABB4, "\u{13e4}"),
+    (0xABB5, "\u{13e5}"),
+    (0xABB6, "\u{13e6}"),
+    (0xABB7, "\u{13e7}"),
+    (0xABB8, "\u{13e8}"),
+    (0xABB9, "\u{13e9}"),
+    (0xABBA, "\u{13ea}"),
+    (0xABBB, "\u{13eb}"),
+    (0xABBC, "\u{13ec}"),
+    (0xABBD, "\u{13ed}"),
+    (0xABBE, "\u{13ee}"),
+    (0xABBF, "\u{13ef}"),
+    (0xFB00, "ff"),
+    (0xFB01, "fi"),
+    (0xFB02, "fl"),
+    (0xFB03, "ffi"),
+    (0xFB04, "ffl"),
+    (0xFB05, "st"),
+    (0xFB06, "st"),
+    (0xFB13, "\u{574}\u{576}"),
+    (0xFB14, "\u{574}\u{565}"),
+    (0xFB15, "\u{574}\u{56b}"),
+    (0xFB16, "\u{57e}\u{576}"),
+    (0xFB17, "\u{574}\u{56d}"),
+    (0x10D50, "\u{10d50}"),
+    (0x10D51, "\u{10d51}"),
+    (0x10D52, "\u{10d52}"),
+    (0x10D53, "\u{10d53}"),
+    (0x10D54, "\u{10d54}"),
+    (0x10D55, "\u{10d55}"),
+    (0x10D56, "\u{10d56}"),
+    (0x10D57, "\u{10d57}"),
+    (0x10D58, "\u{10d58}"),
+    (0x10D59, "\u{10d59}"),
+    (0x10D5A, "\u{10d5a}"),
+    (0x10D5B, "\u{10d5b}"),
+    (0x10D5C, "\u{10d5c}"),
+    (0x10D5D, "\u{10d5d}"),
+    (0x10D5E, "\u{10d5e}"),
+    (0x10D5F, "\u{10d5f}"),
+    (0x10D60, "\u{10d60}"),
+    (0x10D61, "\u{10d61}"),
+    (0x10D62, "\u{10d62}"),
+    (0x10D63, "\u{10d63}"),
+    (0x10D64, "\u{10d64}"),
+    (0x10D65, "\u{10d65}"),
+    (0x16EA0, "\u{16ea0}"),
+    (0x16EA1, "\u{16ea1}"),
+    (0x16EA2, "\u{16ea2}"),
+    (0x16EA3, "\u{16ea3}"),
+    (0x16EA4, "\u{16ea4}"),
+    (0x16EA5, "\u{16ea5}"),
+    (0x16EA6, "\u{16ea6}"),
+    (0x16EA7, "\u{16ea7}"),
+    (0x16EA8, "\u{16ea8}"),
+    (0x16EA9, "\u{16ea9}"),
+    (0x16EAA, "\u{16eaa}"),
+    (0x16EAB, "\u{16eab}"),
+    (0x16EAC, "\u{16eac}"),
+    (0x16EAD, "\u{16ead}"),
+    (0x16EAE, "\u{16eae}"),
+    (0x16EAF, "\u{16eaf}"),
+    (0x16EB0, "\u{16eb0}"),
+    (0x16EB1, "\u{16eb1}"),
+    (0x16EB2, "\u{16eb2}"),
+    (0x16EB3, "\u{16eb3}"),
+    (0x16EB4, "\u{16eb4}"),
+    (0x16EB5, "\u{16eb5}"),
+    (0x16EB6, "\u{16eb6}"),
+    (0x16EB7, "\u{16eb7}"),
+    (0x16EB8, "\u{16eb8}"),
+];
+
+/// Whether `character` falls in one of the sorted inclusive `ranges`.
+pub(crate) fn in_ranges(ranges: &[(u32, u32)], character: char) -> bool {
+    let code: u32 = u32::from(character);
+    let index: usize = ranges.partition_point(|(_, end)| *end < code);
+    ranges.get(index).is_some_and(|(start, _)| *start <= code)
+}
diff --git a/crates/sqlbuild-core/src/text/constants.rs b/crates/sqlbuild-core/src/text/constants.rs
index f678ed5afb..4e313e1612 100644
--- a/crates/sqlbuild-core/src/text/constants.rs
+++ b/crates/sqlbuild-core/src/text/constants.rs
@@ -1,2 +1,5 @@
 /// The code points in one run of Unicode decimal digits, valued 0 to 9.
 pub(crate) const DIGITS_PER_RUN: u32 = 10;
+
+/// The information separators Python's `str.isspace` accepts and `char::is_whitespace` does not.
+pub(crate) const PYTHON_SEPARATOR_CONTROLS: std::ops::RangeInclusive<char> = '\u{1c}'..='\u{1f}';
diff --git a/crates/sqlbuild-core/src/text/main/mod.rs b/crates/sqlbuild-core/src/text/main/mod.rs
index bac686af6a..d439d53a75 100644
--- a/crates/sqlbuild-core/src/text/main/mod.rs
+++ b/crates/sqlbuild-core/src/text/main/mod.rs
@@ -7,5 +7,10 @@ pub mod ignorecase_key;
 pub mod is_decimal_digit;
 pub mod is_letter;
 pub mod is_word_char;
+pub mod python_casefold;
 pub mod python_cleandoc;
+pub mod python_isalnum;
+pub mod python_isdigit;
+pub mod python_isspace;
 pub mod python_str_repr;
+pub mod python_strip;
diff --git a/crates/sqlbuild-core/src/text/main/python_casefold.rs b/crates/sqlbuild-core/src/text/main/python_casefold.rs
new file mode 100644
index 0000000000..9039e62a20
--- /dev/null
+++ b/crates/sqlbuild-core/src/text/main/python_casefold.rs
@@ -0,0 +1,17 @@
+//! Python's `str.casefold`.
+
+use crate::text::_helpers::python_tables::PYTHON_CASEFOLD;
+
+/// Python's `text.casefold()`.
+#[must_use]
+pub fn python_casefold(text: &str) -> String {
+    let mut folded: String = String::with_capacity(text.len());
+    for character in text.chars() {
+        let code: u32 = u32::from(character);
+        match PYTHON_CASEFOLD.binary_search_by_key(&code, |(entry, _)| *entry) {
+            Ok(index) => folded.push_str(PYTHON_CASEFOLD[index].1),
+            Err(_) => folded.extend(character.to_lowercase()),
+        }
+    }
+    folded
+}
diff --git a/crates/sqlbuild-core/src/text/main/python_isalnum.rs b/crates/sqlbuild-core/src/text/main/python_isalnum.rs
new file mode 100644
index 0000000000..3c2e088c90
--- /dev/null
+++ b/crates/sqlbuild-core/src/text/main/python_isalnum.rs
@@ -0,0 +1,9 @@
+//! Python's `str.isalnum` for one character.
+
+use crate::text::_helpers::python_tables::{NOT_PYTHON_ALNUM, in_ranges};
+
+/// Whether Python's `str.isalnum` accepts `character`.
+#[must_use]
+pub fn python_isalnum(character: char) -> bool {
+    character.is_alphanumeric() && !in_ranges(&NOT_PYTHON_ALNUM, character)
+}
diff --git a/crates/sqlbuild-core/src/text/main/python_isdigit.rs b/crates/sqlbuild-core/src/text/main/python_isdigit.rs
new file mode 100644
index 0000000000..56456c76e0
--- /dev/null
+++ b/crates/sqlbuild-core/src/text/main/python_isdigit.rs
@@ -0,0 +1,10 @@
+//! Python's `str.isdigit` for one character.
+
+use crate::text::_helpers::python_tables::{PYTHON_NON_DECIMAL_DIGITS, in_ranges};
+use crate::text::main::is_decimal_digit::is_decimal_digit;
+
+/// Whether Python's `str.isdigit` accepts `character`: decimal digits and digit characters.
+#[must_use]
+pub fn python_isdigit(character: char) -> bool {
+    is_decimal_digit(character) || in_ranges(&PYTHON_NON_DECIMAL_DIGITS, character)
+}
diff --git a/crates/sqlbuild-core/src/text/main/python_isspace.rs b/crates/sqlbuild-core/src/text/main/python_isspace.rs
new file mode 100644
index 0000000000..5888db8697
--- /dev/null
+++ b/crates/sqlbuild-core/src/text/main/python_isspace.rs
@@ -0,0 +1,9 @@
+//! Python's `str.isspace` for one character.
+
+use crate::text::constants::PYTHON_SEPARATOR_CONTROLS;
+
+/// Whether Python's `str.isspace` accepts `character`.
+#[must_use]
+pub fn python_isspace(character: char) -> bool {
+    character.is_whitespace() || PYTHON_SEPARATOR_CONTROLS.contains(&character)
+}
diff --git a/crates/sqlbuild-core/src/text/main/python_strip.rs b/crates/sqlbuild-core/src/text/main/python_strip.rs
new file mode 100644
index 0000000000..73f195b728
--- /dev/null
+++ b/crates/sqlbuild-core/src/text/main/python_strip.rs
@@ -0,0 +1,9 @@
+//! Python's `str.strip()` with no arguments.
+
+use crate::text::main::python_isspace::python_isspace;
+
+/// Python's `text.strip()`.
+#[must_use]
+pub fn python_strip(text: &str) -> &str {
+    text.trim_matches(python_isspace)
+}
diff --git a/crates/sqlbuild-core/src/text/tests.rs b/crates/sqlbuild-core/src/text/tests.rs
index 98247d0665..58c350466d 100644
--- a/crates/sqlbuild-core/src/text/tests.rs
+++ b/crates/sqlbuild-core/src/text/tests.rs
@@ -1,5 +1,7 @@
 #[path = "tests/test_matching.rs"]
 mod matching;
+#[path = "tests/test_python_str.rs"]
+mod python_str;
 #[path = "tests/test_types.rs"]
 mod test_types;
 #[path = "tests/test_text.rs"]
diff --git a/crates/sqlbuild-core/src/text/tests/test_python_str.rs b/crates/sqlbuild-core/src/text/tests/test_python_str.rs
new file mode 100644
index 0000000000..cd5a678ed8
--- /dev/null
+++ b/crates/sqlbuild-core/src/text/tests/test_python_str.rs
@@ -0,0 +1,126 @@
+use crate::text::main::python_casefold::python_casefold;
+use crate::text::main::python_isalnum::python_isalnum;
+use crate::text::main::python_isdigit::python_isdigit;
+use crate::text::main::python_isspace::python_isspace;
+use crate::text::tests::test_types::{CasefoldTestCase, CharacterClassTestCase};
+
+/// Expectations recorded from CPython 3.12.
+#[test]
+fn given_text_when_casefolding_then_matches_python_casefold() {
+    let test_cases = [
+        CasefoldTestCase {
+            description: "final sigma folds to sigma",
+            text: "ΟΔΟΣ",
+            expected_folded: "οδοσ",
+        },
+        CasefoldTestCase {
+            description: "lowercase final sigma",
+            text: "οδος",
+            expected_folded: "οδοσ",
+        },
+        CasefoldTestCase {
+            description: "sharp s expands",
+            text: "Straße",
+            expected_folded: "strasse",
+        },
+        CasefoldTestCase {
+            description: "ligature expands",
+            text: "\u{fb01}le",
+            expected_folded: "file",
+        },
+        CasefoldTestCase {
+            description: "long s",
+            text: "\u{17f}",
+            expected_folded: "s",
+        },
+        CasefoldTestCase {
+            description: "micro sign",
+            text: "\u{b5}",
+            expected_folded: "\u{3bc}",
+        },
+    ];
+    for test_case in test_cases {
+        assert_eq!(
+            python_casefold(test_case.text),
+            test_case.expected_folded,
+            "{}",
+            test_case.description
+        );
+    }
+}
+
+/// Expectations recorded from CPython 3.12.
+#[test]
+fn given_characters_when_classifying_then_matches_python_str_predicates() {
+    let test_cases = [
+        CharacterClassTestCase {
+            description: "ascii letter",
+            character: 'a',
+            expected_alnum: true,
+            expected_digit: false,
+            expected_space: false,
+        },
+        CharacterClassTestCase {
+            description: "combining vowel sign",
+            character: '\u{93e}',
+            expected_alnum: false,
+            expected_digit: false,
+            expected_space: false,
+        },
+        CharacterClassTestCase {
+            description: "arabic-indic digit",
+            character: '٣',
+            expected_alnum: true,
+            expected_digit: true,
+            expected_space: false,
+        },
+        CharacterClassTestCase {
+            description: "circled digit",
+            character: '①',
+            expected_alnum: true,
+            expected_digit: true,
+            expected_space: false,
+        },
+        CharacterClassTestCase {
+            description: "subscript digit",
+            character: '₃',
+            expected_alnum: true,
+            expected_digit: true,
+            expected_space: false,
+        },
+        CharacterClassTestCase {
+            description: "vulgar fraction",
+            character: '½',
+            expected_alnum: true,
+            expected_digit: false,
+            expected_space: false,
+        },
+        CharacterClassTestCase {
+            description: "unit separator",
+            character: '\u{1f}',
+            expected_alnum: false,
+            expected_digit: false,
+            expected_space: true,
+        },
+    ];
+    for test_case in test_cases {
+        assert_eq!(
+            python_isalnum(test_case.character),
+            test_case.expected_alnum,
+            "{}",
+            test_case.description
+        );
+        assert_eq!(
+            python_isdigit(test_case.character),
+            test_case.expected_digit,
+            "{}",
+            test_case.description
+        );
+        assert_eq!(
+            python_isspace(test_case.character),
+            test_case.expected_space,
+            "{}",
+            test_case.description
+        );
+    }
+}
diff --git a/crates/sqlbuild-core/src/text/tests/test_types.rs b/crates/sqlbuild-core/src/text/tests/test_types.rs
index a7e100e90f..3eb58cfe4b 100644
--- a/crates/sqlbuild-core/src/text/tests/test_types.rs
+++ b/crates/sqlbuild-core/src/text/tests/test_types.rs
@@ -45,3 +45,17 @@ pub(super) struct GlobTestCase {
     pub(super) name: &'static str,
     pub(super) expected_match: bool,
 }
+
+pub(super) struct CasefoldTestCase {
+    pub(super) description: &'static str,
+    pub(super) text: &'static str,
+    pub(super) expected_folded: &'static str,
+}
+
+pub(super) struct CharacterClassTestCase {
+    pub(super) description: &'static str,
+    pub(super) character: char,
+    pub(super) expected_alnum: bool,
+    pub(super) expected_digit: bool,
+    pub(super) expected_space: bool,
+}
diff --git a/crates/sqlbuild-discovery/Cargo.toml b/crates/sqlbuild-discovery/Cargo.toml
index e5b3130fff..3b1132a79f 100644
--- a/crates/sqlbuild-discovery/Cargo.toml
+++ b/crates/sqlbuild-discovery/Cargo.toml
@@ -11,6 +11,7 @@ rust-version.workspace = true
 rayon.workspace = true
 sqlbuild-config.workspace = true
 sqlbuild-core.workspace = true
+sqlbuild-model-config.workspace = true
 sqlbuild-sqltext.workspace = true
 
 [target.'cfg(windows)'.dependencies]
diff --git a/crates/sqlbuild-discovery/src/_helpers/reading.rs b/crates/sqlbuild-discovery/src/_helpers/reading.rs
index bbc3dea814..36f9bc3f2f 100644
--- a/crates/sqlbuild-discovery/src/_helpers/reading.rs
+++ b/crates/sqlbuild-discovery/src/_helpers/reading.rs
@@ -114,7 +114,7 @@ pub(crate) fn windows_errno(code: i32) -> i32 {
 }
 
 /// CPython's UTF-8 decoder error: the range and reason it reports for the first bad sequence.
-fn decode_failure(bytes: Vec<u8>, error: TextDecodeError) -> ReadFailure {
+pub(crate) fn decode_failure(bytes: Vec<u8>, error: TextDecodeError) -> ReadFailure {
     let start: usize = error.valid_up_to;
     let (end, reason): (usize, &'static str) = match error.error_len {
         None => (bytes.len(), "unexpected end of data"),
diff --git a/crates/sqlbuild-discovery/src/lib.rs b/crates/sqlbuild-discovery/src/lib.rs
index c15f5b2b32..e68026dc37 100644
--- a/crates/sqlbuild-discovery/src/lib.rs
+++ b/crates/sqlbuild-discovery/src/lib.rs
@@ -9,6 +9,8 @@ pub mod declarations;
 pub mod key_checks;
 pub mod model_files;
 pub mod models;
+pub mod project_validation;
 pub mod sql_tests;
 pub mod tree;
+pub mod yaml_entries;
 pub mod yaml_files;
diff --git a/crates/sqlbuild-discovery/src/models.rs b/crates/sqlbuild-discovery/src/models.rs
index b38c79864f..f00fcbd4df 100644
--- a/crates/sqlbuild-discovery/src/models.rs
+++ b/crates/sqlbuild-discovery/src/models.rs
@@ -26,6 +26,10 @@ pub enum FailureKind {
     SqlAudit,
     /// `ResourceIdentityError` (D016).
     ResourceIdentity,
+    /// `DiscoveryConflictError` (D007).
+    Conflict,
+    /// `SeedDiscoveryError` (D008).
+    Seed,
 }
 
 impl FailureKind {
@@ -42,6 +46,8 @@ impl FailureKind {
             Self::SqlHook => "sql_hook",
             Self::SqlAudit => "sql_audit",
             Self::ResourceIdentity => "resource_identity",
+            Self::Conflict => "conflict",
+            Self::Seed => "seed",
         }
     }
 }
diff --git a/crates/sqlbuild-discovery/src/project_validation/_helpers/conflicts.rs b/crates/sqlbuild-discovery/src/project_validation/_helpers/conflicts.rs
new file mode 100644
index 0000000000..b949afbcaf
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/_helpers/conflicts.rs
@@ -0,0 +1,60 @@
+//! Shared pieces of the conflict checks: the error, name tables and the duplicate scan.
+
+use std::collections::HashMap;
+
+use crate::models::{DiscoveryFailure, FailureKind};
+use crate::project_validation::models::{NamedPath, NodeFact, ProjectFacts, ValidationFailure};
+
+/// A `DiscoveryConflictError` with this message.
+pub(crate) fn conflict(message: String) -> ValidationFailure {
+    DiscoveryFailure::new(FailureKind::Conflict, message).into()
+}
+
+/// Every schema seed declaration with the schema file that declares it.
+pub(crate) fn schema_seeds(facts: &ProjectFacts) -> Vec<NamedPath> {
+    let mut seeds: Vec<NamedPath> = Vec::new();
+    for schema in &facts.schemas {
+        for seed in &schema.seeds {
+            seeds.push(named(&seed.name, &schema.path));
+        }
+    }
+    seeds
+}
+
+/// Every source entry with the source file that declares it.
+pub(crate) fn source_entries(facts: &ProjectFacts) -> Vec<NamedPath> {
+    let mut entries: Vec<NamedPath> = Vec::new();
+    for file in &facts.sources {
+        for entry in &file.entries {
+            entries.push(named(&entry.name, &file.path));
+        }
+    }
+    entries
+}
+
+pub(crate) fn named(name: &str, path: &str) -> NamedPath {
+    NamedPath {
+        name: name.to_owned(),
+        path: path.to_owned(),
+    }
+}
+
+pub(crate) fn node_path(node: &NodeFact) -> NamedPath {
+    named(&node.name, &node.path)
+}
+
+/// Reject the second of two entries with the same name.
+pub(crate) fn unique_named(
+    entries: &[impl std::borrow::Borrow<NamedPath>],
+    message: impl Fn(&str, &str, &str) -> String,
+) -> Result<(), ValidationFailure> {
+    let mut seen: HashMap<&str, &str> = HashMap::new();
+    for entry in entries {
+        let entry: &NamedPath = entry.borrow();
+        if let Some(existing) = seen.get(entry.name.as_str()) {
+            return Err(conflict(message(&entry.name, existing, &entry.path)));
+        }
+        seen.insert(&entry.name, &entry.path);
+    }
+    Ok(())
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/_helpers/csv_header.rs b/crates/sqlbuild-discovery/src/project_validation/_helpers/csv_header.rs
new file mode 100644
index 0000000000..1859d7aa66
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/_helpers/csv_header.rs
@@ -0,0 +1,355 @@
+//! The first record Python's `csv.reader` returns for a seed file opened with `newline=""`.
+
+use crate::_helpers::reading::decode_failure;
+use crate::project_validation::errors::HeaderError;
+use crate::project_validation::models::CsvSettings;
+use sqlbuild_core::text::main::decode_text::decode_text;
+
+/// The size of the chunks `TextIOWrapper` decodes.
+const DECODE_CHUNK: usize = 8192;
+const UNQUOTED_NEWLINE: &str =
+    "new-line character seen in unquoted field - do you need to open the file with newline=''?";
+
+/// The header row, `None` for an empty file, or the error Python raises reading it.
+pub(crate) fn csv_header(
+    bytes: &[u8],
+    settings: &CsvSettings,
+    field_limit: usize,
+) -> Result<Vec<String>, HeaderError> {
+    let dialect: Dialect = Dialect::new(settings, field_limit);
+    let settings: &Dialect = &dialect;
+    let mut end: usize = bytes.len().min(DECODE_CHUNK);
+    loop {
+        let text: String = decoded_prefix(bytes, end)?;
+        let complete: bool = end == bytes.len();
+        match first_record(&text, settings, complete)? {
+            Some(record) => return Ok(record),
+            None if complete => return Ok(Vec::new()),
+            None => end = bytes.len().min(end + DECODE_CHUNK),
+        }
+    }
+}
+
+/// The reader's settings as `csv.reader` receives them; Python has already accepted them.
+pub(crate) struct Dialect {
+    delimiter: char,
+    quotechar: Option<char>,
+    escapechar: Option<char>,
+    doublequote: bool,
+    skipinitialspace: bool,
+    field_limit: usize,
+}
+
+impl Dialect {
+    fn new(settings: &CsvSettings, field_limit: usize) -> Self {
+        let single = |value: &Option<String>| -> Option<char> {
+            let mut characters = value.as_deref()?.chars();
+            match (characters.next(), characters.next()) {
+                (Some(character), None) => Some(character),
+                _ => None,
+            }
+        };
+        Self {
+            delimiter: single(&settings.delimiter).unwrap_or(','),
+            quotechar: single(&settings.quotechar),
+            escapechar: single(&settings.escapechar),
+            doublequote: settings.doublequote.unwrap_or(true),
+            skipinitialspace: settings.skipinitialspace.unwrap_or(false),
+            field_limit,
+        }
+    }
+}
+
+/// The text of `bytes[..end]`; a multi-byte character cut by `end` waits for the next chunk.
+fn decoded_prefix(bytes: &[u8], end: usize) -> Result<String, HeaderError> {
+    let prefix: &[u8] = &bytes[..end];
+    match std::str::from_utf8(prefix) {
+        Ok(text) => Ok(text.to_owned()),
+        Err(error) if error.error_len().is_none() && end < bytes.len() => {
+            Ok(String::from_utf8_lossy(&prefix[..error.valid_up_to()]).into_owned())
+        }
+        Err(_) => decode_text(prefix)
+            .map_err(|error| HeaderError::Read(decode_failure(prefix.to_vec(), error))),
+    }
+}
+
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum State {
+    StartRecord,
+    StartField,
+    EscapedChar,
+    InField,
+    InQuotedField,
+    EscapeInQuotedField,
+    QuoteInQuotedField,
+    EatCrnl,
+    AfterEscapedCrnl,
+}
+
+/// One character, or the end of a line.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum Input {
+    Char(char),
+    Eol,
+}
+
+struct Parser<'a> {
+    settings: &'a Dialect,
+    state: State,
+    field: String,
+    field_len: usize,
+    fields: Vec<String>,
+}
+
+impl Parser<'_> {
+    fn save_field(&mut self) {
+        self.fields.push(std::mem::take(&mut self.field));
+        self.field_len = 0;
+    }
+
+    fn add(&mut self, character: char) -> Result<(), HeaderError> {
+        if self.field_len >= self.settings.field_limit {
+            return Err(HeaderError::Csv(format!(
+                "field larger than field limit ({})",
+                self.settings.field_limit
+            )));
+        }
+        self.field.push(character);
+        self.field_len += 1;
+        Ok(())
+    }
+
+    fn is_quote(&self, character: char) -> bool {
+        self.settings.quotechar == Some(character)
+    }
+
+    fn is_escape(&self, character: char) -> bool {
+        self.settings.escapechar == Some(character)
+    }
+
+    fn delimiter(&self) -> char {
+        self.settings.delimiter
+    }
+
+    /// CPython's `parse_process_char`.
+    fn process(&mut self, input: Input) -> Result<(), HeaderError> {
+        let newline = |input: Input| matches!(input, Input::Char('\n' | '\r'));
+        loop {
+            match self.state {
+                State::StartRecord => {
+                    if input == Input::Eol {
+                        return Ok(());
+                    }
+                    if newline(input) {
+                        self.state = State::EatCrnl;
+                        return Ok(());
+                    }
+                    self.state = State::StartField;
+                }
+                State::StartField => {
+                    match input {
+                        Input::Eol => {
+                            self.save_field();
+                            self.state = State::StartRecord;
+                        }
+                        Input::Char('\n' | '\r') => {
+                            self.save_field();
+                            self.state = State::EatCrnl;
+                        }
+                        Input::Char(character) if self.is_quote(character) => {
+                            self.state = State::InQuotedField;
+                        }
+                        Input::Char(character) if self.is_escape(character) => {
+                            self.state = State::EscapedChar;
+                        }
+                        Input::Char(' ') if self.settings.skipinitialspace => {}
+                        Input::Char(character) if character == self.delimiter() => {
+                            self.save_field();
+                        }
+                        Input::Char(character) => {
+                            self.add(character)?;
+                            self.state = State::InField;
+                        }
+                    }
+                    return Ok(());
+                }
+                State::EscapedChar => {
+                    match input {
+                        Input::Char(character @ ('\n' | '\r')) => {
+                            self.add(character)?;
+                            self.state = State::AfterEscapedCrnl;
+                        }
+                        Input::Eol => {
+                            self.add('\n')?;
+                            self.state = State::InField;
+                        }
+                        Input::Char(character) => {
+                            self.add(character)?;
+                            self.state = State::InField;
+                        }
+                    }
+                    return Ok(());
+                }
+                State::AfterEscapedCrnl => {
+                    if input == Input::Eol {
+                        return Ok(());
+                    }
+                    self.state = State::InField;
+                }
+                State::InField => {
+                    match input {
+                        Input::Eol => {
+                            self.save_field();
+                            self.state = State::StartRecord;
+                        }
+                        Input::Char('\n' | '\r') => {
+                            self.save_field();
+                            self.state = State::EatCrnl;
+                        }
+                        Input::Char(character) if self.is_escape(character) => {
+                            self.state = State::EscapedChar;
+                        }
+                        Input::Char(character) if character == self.delimiter() => {
+                            self.save_field();
+                            self.state = State::StartField;
+                        }
+                        Input::Char(character) => self.add(character)?,
+                    }
+                    return Ok(());
+                }
+                State::InQuotedField => {
+                    match input {
+                        Input::Eol => {}
+                        Input::Char(character) if self.is_escape(character) => {
+                            self.state = State::EscapeInQuotedField;
+                        }
+                        Input::Char(character) if self.is_quote(character) => {
+                            self.state = if self.settings.doublequote {
+                                State::QuoteInQuotedField
+                            } else {
+                                State::InField
+                            };
+                        }
+                        Input::Char(character) => self.add(character)?,
+                    }
+                    return Ok(());
+                }
+                State::EscapeInQuotedField => {
+                    self.add(match input {
+                        Input::Eol => '\n',
+                        Input::Char(character) => character,
+                    })?;
+                    self.state = State::InQuotedField;
+                    return Ok(());
+                }
+                State::QuoteInQuotedField => {
+                    match input {
+                        Input::Char(character) if self.is_quote(character) => {
+                            self.add(character)?;
+                            self.state = State::InQuotedField;
+                        }
+                        Input::Char(character) if character == self.delimiter() => {
+                            self.save_field();
+                            self.state = State::StartField;
+                        }
+                        Input::Eol => {
+                            self.save_field();
+                            self.state = State::StartRecord;
+                        }
+                        Input::Char('\n' | '\r') => {
+                            self.save_field();
+                            self.state = State::EatCrnl;
+                        }
+                        Input::Char(character) => {
+                            self.add(character)?;
+                            self.state = State::InField;
+                        }
+                    }
+                    return Ok(());
+                }
+                State::EatCrnl => {
+                    return match input {
+                        Input::Char('\n' | '\r') => Ok(()),
+                        Input::Eol => {
+                            self.state = State::StartRecord;
+                            Ok(())
+                        }
+                        Input::Char(_) => Err(HeaderError::Csv(UNQUOTED_NEWLINE.to_owned())),
+                    };
+                }
+            }
+        }
+    }
+}
+
+/// The first record of `text`, or `None` when `text` ends before it (`complete` is false) or is empty.
+fn first_record(
+    text: &str,
+    settings: &Dialect,
+    complete: bool,
+) -> Result<Option<Vec<String>>, HeaderError> {
+    let mut parser: Parser<'_> = Parser {
+        settings,
+        state: State::StartRecord,
+        field: String::new(),
+        field_len: 0,
+        fields: Vec::new(),
+    };
+    let mut lines = lines(text).peekable();
+    while let Some(line) = lines.next() {
+        let terminated: bool = line.ends_with(['\n', '\r']);
+        let last: bool = lines.peek().is_none();
+        if last && !complete && !terminated_line(line, terminated, text) {
+            return Ok(None);
+        }
+        for character in line.chars() {
+            parser.process(Input::Char(character))?;
+        }
+        parser.process(Input::Eol)?;
+        if parser.state == State::StartRecord {
+            return Ok(Some(parser.fields));
+        }
+    }
+    if !complete {
+        return Ok(None);
+    }
+    if parser.field_len != 0 || parser.state == State::InQuotedField {
+        parser.save_field();
+        return Ok(Some(parser.fields));
+    }
+    Ok(None)
+}
+
+/// Whether a final line is known to be whole: it ends with `\n`, or `\r` not followed later.
+fn terminated_line(line: &str, terminated: bool, text: &str) -> bool {
+    terminated && (line.ends_with('\n') || !text.ends_with('\r'))
+}
+
+/// The lines of `text` as `newline=""` iteration yields them, terminators included.
+fn lines(text: &str) -> impl Iterator<Item = &str> {
+    let mut rest: &str = text;
+    std::iter::from_fn(move || {
+        if rest.is_empty() {
+            return None;
+        }
+        let bytes: &[u8] = rest.as_bytes();
+        let mut end: usize = bytes.len();
+        for (index, byte) in bytes.iter().enumerate() {
+            if *byte == b'\n' {
+                end = index + 1;
+                break;
+            }
+            if *byte == b'\r' {
+                end = if bytes.get(index + 1) == Some(&b'\n') {
+                    index + 2
+                } else {
+                    index + 1
+                };
+                break;
+            }
+        }
+        let (line, tail) = rest.split_at(end);
+        rest = tail;
+        Some(line)
+    })
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/_helpers/declarations.rs b/crates/sqlbuild-discovery/src/project_validation/_helpers/declarations.rs
new file mode 100644
index 0000000000..f0832fbcf4
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/_helpers/declarations.rs
@@ -0,0 +1,48 @@
+//! Duplicate schema declarations and logical relation names shared across resource kinds.
+
+use std::collections::HashMap;
+
+use crate::project_validation::_helpers::conflicts::{
+    conflict, named, schema_seeds, source_entries, unique_named,
+};
+use crate::project_validation::models::{NamedPath, ProjectFacts, ValidationFailure};
+
+/// Reject duplicate schema model and seed declarations, then shared relation names.
+pub(crate) fn validate_declarations(facts: &ProjectFacts) -> Result<(), ValidationFailure> {
+    let mut schema_models: Vec<NamedPath> = Vec::new();
+    for schema in &facts.schemas {
+        for name in &schema.model_names {
+            schema_models.push(named(name, &schema.path));
+        }
+    }
+    unique_named(&schema_models, |name, existing, path| {
+        format!(
+            "Duplicate schema.yml model declaration found for '{name}' in {existing} and {path}"
+        )
+    })?;
+    unique_named(&schema_seeds(facts), |name, existing, path| {
+        format!("Duplicate seed declaration found for '{name}' in {existing} and {path}")
+    })?;
+    unique_logical_relation_names(facts)
+}
+
+fn unique_logical_relation_names(facts: &ProjectFacts) -> Result<(), ValidationFailure> {
+    let mut seen: HashMap<String, (&'static str, String)> = HashMap::new();
+    for model in &facts.models {
+        seen.insert(model.file.name.clone(), ("model", model.file.path.clone()));
+    }
+    let sources = source_entries(facts)
+        .into_iter()
+        .map(|entry| ("source", entry));
+    let seeds = schema_seeds(facts).into_iter().map(|seed| ("seed", seed));
+    for (kind, NamedPath { name, path }) in sources.chain(seeds) {
+        if let Some((existing_kind, existing_path)) = seen.get(&name) {
+            return Err(conflict(format!(
+                "Logical relation name '{name}' is declared as both {existing_kind} in \
+                 {existing_path} and {kind} in {path}"
+            )));
+        }
+        seen.insert(name, (kind, path));
+    }
+    Ok(())
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/_helpers/file_names.rs b/crates/sqlbuild-discovery/src/project_validation/_helpers/file_names.rs
new file mode 100644
index 0000000000..c216660682
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/_helpers/file_names.rs
@@ -0,0 +1,37 @@
+//! Duplicate and reserved names among model, scenario and source files.
+
+use std::collections::HashMap;
+
+use crate::project_validation::_helpers::conflicts::{conflict, source_entries, unique_named};
+use crate::project_validation::constants::RESERVED_MODEL_NAMES;
+use crate::project_validation::models::{ModelFact, NamedPath, ProjectFacts, ValidationFailure};
+
+/// Reject reserved or duplicate model names, then duplicate scenario and source names.
+pub(crate) fn validate_file_names(facts: &ProjectFacts) -> Result<(), ValidationFailure> {
+    unique_model_file_names(&facts.models)?;
+    unique_named(&facts.scenarios, |name, existing, path| {
+        format!("Duplicate scenario file name found for '{name}' in {existing} and {path}")
+    })?;
+    unique_named(&source_entries(facts), |name, existing, path| {
+        format!("Duplicate source declaration found for '{name}' in {existing} and {path}")
+    })
+}
+
+fn unique_model_file_names(models: &[ModelFact]) -> Result<(), ValidationFailure> {
+    let mut seen: HashMap<&str, &str> = HashMap::new();
+    for model in models {
+        let NamedPath { name, path } = &model.file;
+        if RESERVED_MODEL_NAMES.contains(&name.as_str()) {
+            return Err(conflict(format!(
+                "Model name '{name}' in {path} is reserved by SQLBuild for compiled output structure"
+            )));
+        }
+        if let Some(existing) = seen.get(name.as_str()) {
+            return Err(conflict(format!(
+                "Duplicate model file name found for '{name}' in {existing} and {path}"
+            )));
+        }
+        seen.insert(name, path);
+    }
+    Ok(())
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/_helpers/identities.rs b/crates/sqlbuild-discovery/src/project_validation/_helpers/identities.rs
new file mode 100644
index 0000000000..44716a3842
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/_helpers/identities.rs
@@ -0,0 +1,155 @@
+//! Python's `validate_discovered_resource_identities`: canonical identities, in discovery order.
+
+use crate::models::{DiscoveryFailure, FailureKind};
+use crate::project_validation::models::{
+    AuditFileFact, NamedPath, NodeKind, ProjectFacts, ValidationFailure,
+};
+use sqlbuild_model_config::resource_identities::main::resource_identity_failure::resource_identity_failure;
+
+/// One identity to check: its name, the kind the error names, its path and whether it is private.
+struct Candidate<'a> {
+    name: &'a str,
+    kind: &'a str,
+    path: &'a str,
+    private: bool,
+}
+
+/// The identities to check, in the order Python's `validate_discovered_resource_identities` lists them.
+struct Candidates<'a> {
+    list: Vec<Candidate<'a>>,
+}
+
+impl<'a> Candidates<'a> {
+    fn push(&mut self, name: &'a str, kind: &'a str, path: &'a str) {
+        self.list.push(Candidate {
+            name,
+            kind,
+            path,
+            private: false,
+        });
+    }
+
+    fn push_named(&mut self, entries: &'a [NamedPath], kind: &'a str) {
+        for entry in entries {
+            self.push(&entry.name, kind, &entry.path);
+        }
+    }
+
+    /// A generic audit is named by its stem, each block naming an instance; others by the block.
+    fn push_audit(&mut self, audit: &'a AuditFileFact, block_name: Option<&'a str>) {
+        let path: &str = &audit.file.path;
+        if audit.generic {
+            self.push(&audit.file.name, "audit", path);
+            if let Some(instance) = block_name {
+                self.push(instance, "generic audit instance", path);
+            }
+        } else {
+            self.push(
+                block_or_file_name(block_name, &audit.file.name),
+                "audit",
+                path,
+            );
+        }
+    }
+
+    fn push_declarations(&mut self, declarations: &'a [NamedPath], kind: &'a str, private: bool) {
+        for declaration in declarations {
+            self.list.push(Candidate {
+                name: &declaration.name,
+                kind,
+                path: &declaration.path,
+                private,
+            });
+        }
+    }
+}
+
+/// Reject the first identity that is not canonical lowercase snake_case.
+pub(crate) fn validate_identities(facts: &ProjectFacts) -> Result<(), ValidationFailure> {
+    for candidate in candidates(facts) {
+        if let Some((corrected, help)) =
+            resource_identity_failure(candidate.name, candidate.private)
+        {
+            return Err(ValidationFailure::Discovery(DiscoveryFailure {
+                kind: FailureKind::ResourceIdentity,
+                message: format!(
+                    "Invalid {} identity '{}' in {}; use snake_case '{corrected}'",
+                    candidate.kind, candidate.name, candidate.path
+                ),
+                help: Some(help),
+            }));
+        }
+    }
+    Ok(())
+}
+
+fn candidates(facts: &ProjectFacts) -> Vec<Candidate<'_>> {
+    let mut candidates: Candidates<'_> = Candidates { list: Vec::new() };
+    for model in &facts.models {
+        candidates.push(&model.file.name, "model", &model.file.path);
+        candidates.push_declarations(&model.local_declarations, "model-local declaration", true);
+    }
+    candidates.push_named(&facts.sql_functions, "function");
+    candidates.push_named(&facts.python_functions, "function");
+    candidates.push_named(&facts.sql_hooks, "SQL hook");
+    for seed in &facts.seeds {
+        candidates.push(&seed.file.name, "seed", &seed.file.path);
+    }
+    for schema in &facts.schemas {
+        for name in &schema.model_names {
+            candidates.push(name, "schema model", &schema.path);
+        }
+        for seed in &schema.seeds {
+            candidates.push(&seed.name, "schema seed", &schema.path);
+        }
+    }
+    for file in &facts.sources {
+        for entry in &file.entries {
+            candidates.push(&entry.name, "source", &file.path);
+        }
+    }
+    for test in &facts.tests {
+        for block in &test.blocks {
+            candidates.push(
+                block_or_file_name(block.name.as_deref(), &test.file.name),
+                "SQL test",
+                &test.file.path,
+            );
+            for case in &block.cases {
+                candidates.push(case, "SQL test case", &test.file.path);
+            }
+        }
+    }
+    candidates.push_named(&facts.scenarios, "scenario");
+    for audit in &facts.audits {
+        for block_name in &audit.block_names {
+            candidates.push_audit(audit, block_name.as_deref());
+        }
+    }
+    for file in &facts.declaration_files {
+        candidates.push_declarations(&file.declarations, "declaration", file.private);
+    }
+    candidates.push_named(&facts.model_schemas, "model schema");
+    candidates.push_named(&facts.materializations, "materialization");
+    for kind in [
+        NodeKind::Loader,
+        NodeKind::Task,
+        NodeKind::Asset,
+        NodeKind::Check,
+    ] {
+        for node in facts.nodes.iter().filter(|node| node.kind == kind) {
+            candidates.push(&node.name, kind.label(), &node.path);
+        }
+    }
+    candidates.push_named(&facts.hook_functions, "Python hook");
+    candidates.push_named(&facts.event_exporters, "event exporter");
+    candidates.push_named(&facts.providers, "provider");
+    candidates.list
+}
+
+/// Python's `block.name or stem`.
+pub(crate) fn block_or_file_name<'a>(block_name: Option<&'a str>, file_name: &'a str) -> &'a str {
+    block_name
+        .filter(|name| !name.is_empty())
+        .unwrap_or(file_name)
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/_helpers/loaders.rs b/crates/sqlbuild-discovery/src/project_validation/_helpers/loaders.rs
new file mode 100644
index 0000000000..47ebf99d0a
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/_helpers/loaders.rs
@@ -0,0 +1,139 @@
+//! Loader and Python node names, dependencies, and the sources that name loaders.
+
+use std::collections::{HashMap, HashSet};
+
+use crate::project_validation::_helpers::conflicts::{conflict, node_path, unique_named};
+use crate::project_validation::_helpers::python_nodes::{
+    validate_check_dependencies, validate_loader_dependencies, validate_python_node_dependencies,
+};
+use crate::project_validation::constants::DLT_LOADER_KIND;
+use crate::project_validation::models::{
+    NamedPath, NodeFact, NodeKind, ProjectFacts, SourceFileFact, ValidationFailure,
+};
+
+/// Validate loader and node names, node dependencies, then the loaders sources name.
+pub(crate) fn validate_loaders(facts: &ProjectFacts) -> Result<(), ValidationFailure> {
+    let loaders: Vec<&NodeFact> = facts
+        .nodes
+        .iter()
+        .filter(|node| node.kind == NodeKind::Loader)
+        .collect();
+    let loader_paths: Vec<NamedPath> = loaders.iter().map(|node| node_path(node)).collect();
+    unique_named(&loader_paths, |name, existing, path| {
+        format!("Duplicate source loader found for '{name}' in {existing} and {path}")
+    })?;
+    let node_paths: Vec<NamedPath> = facts.nodes.iter().map(node_path).collect();
+    unique_named(&node_paths, |name, existing, path| {
+        format!(
+            "Duplicate Python node found for '{name}' in {existing} and {path}; loader, \
+             task, asset, and check names must be globally unique"
+        )
+    })?;
+    source_loader_name_collisions(&facts.sources, &loaders)?;
+    validate_loader_dependencies(&facts.nodes)?;
+    validate_python_node_dependencies(&facts.nodes)?;
+    validate_check_dependencies(&facts.nodes)?;
+    source_loader_references(&facts.sources, &loaders)?;
+    terminal_loader_config_ownership(&facts.sources, &loaders)
+}
+
+fn source_loader_name_collisions(
+    sources: &[SourceFileFact],
+    loaders: &[&NodeFact],
+) -> Result<(), ValidationFailure> {
+    let loader_paths: HashMap<&str, &str> = loaders
+        .iter()
+        .map(|loader| (loader.name.as_str(), loader.path.as_str()))
+        .collect();
+    for file in sources {
+        for entry in &file.entries {
+            let Some(loader_path) = loader_paths.get(entry.name.as_str()) else {
+                continue;
+            };
+            if entry.managed && entry.loader.as_deref() == Some(entry.name.as_str()) {
+                continue;
+            }
+            return Err(conflict(format!(
+                "Source '{name}' in {path} conflicts with loader '{name}' in {loader_path}; \
+                 source and loader names must be globally unique unless the source is managed",
+                name = entry.name,
+                path = file.path,
+            )));
+        }
+    }
+    Ok(())
+}
+
+/// Python's `integration_loader_name`.
+fn integration_loader_name(kind: &str, source_name: &str) -> String {
+    if kind == DLT_LOADER_KIND {
+        source_name.to_owned()
+    } else {
+        format!("{kind}__{source_name}")
+    }
+}
+
+fn source_loader_references(
+    sources: &[SourceFileFact],
+    loaders: &[&NodeFact],
+) -> Result<(), ValidationFailure> {
+    let loader_names: HashSet<&str> = loaders.iter().map(|loader| loader.name.as_str()).collect();
+    for file in sources {
+        for entry in &file.entries {
+            let expected: String = match &entry.integration_loader {
+                Some(integration) => integration_loader_name(&integration.kind, &entry.name),
+                None => entry.name.clone(),
+            };
+            if entry.managed && entry.loader.as_deref() != Some(expected.as_str()) {
+                return Err(conflict(format!(
+                    "Managed source '{}' in {} must use terminal loader '{expected}'",
+                    entry.name, file.path
+                )));
+            }
+            if entry.managed && !loader_names.contains(expected.as_str()) {
+                return Err(conflict(format!(
+                    "Managed source '{}' in {} requires loader '{expected}'",
+                    entry.name, file.path
+                )));
+            }
+            match &entry.loader {
+                Some(loader) if !loader_names.contains(loader.as_str()) => {
+                    return Err(conflict(format!(
+                        "Source '{}' in {} references unknown loader '{loader}'",
+                        entry.name, file.path
+                    )));
+                }
+                _ => {}
+            }
+        }
+    }
+    Ok(())
+}
+
+fn terminal_loader_config_ownership(
+    sources: &[SourceFileFact],
+    loaders: &[&NodeFact],
+) -> Result<(), ValidationFailure> {
+    let by_name: HashMap<&str, &NodeFact> = loaders
+        .iter()
+        .map(|loader| (loader.name.as_str(), *loader))
+        .collect();
+    for file in sources {
+        for entry in &file.entries {
+            let Some(loader) = &entry.loader else {
+                continue;
+            };
+            let configured: bool = by_name
+                .get(loader.as_str())
+                .is_some_and(|loader| loader.decorator_config);
+            if configured {
+                return Err(conflict(format!(
+                    "Source '{}' references loader '{loader}', but terminal source loader write \
+                     and schema config must be declared in source YAML, not the @loader decorator",
+                    entry.name
+                )));
+            }
+        }
+    }
+    Ok(())
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/_helpers/mod.rs b/crates/sqlbuild-discovery/src/project_validation/_helpers/mod.rs
new file mode 100644
index 0000000000..ddba252ca6
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/_helpers/mod.rs
@@ -0,0 +1,10 @@
+pub(crate) mod conflicts;
+pub(crate) mod csv_header;
+pub(crate) mod declarations;
+pub(crate) mod file_names;
+pub(crate) mod identities;
+pub(crate) mod loaders;
+pub(crate) mod path_defaults;
+pub(crate) mod python_nodes;
+pub(crate) mod resource_names;
+pub(crate) mod seeds;
diff --git a/crates/sqlbuild-discovery/src/project_validation/_helpers/path_defaults.rs b/crates/sqlbuild-discovery/src/project_validation/_helpers/path_defaults.rs
new file mode 100644
index 0000000000..0568696b6a
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/_helpers/path_defaults.rs
@@ -0,0 +1,77 @@
+//! Every `path_defaults` key must match at least one model path.
+
+use std::collections::HashSet;
+
+use sqlbuild_model_config::path_defaults::main::matched_path_default_keys::matched_path_default_keys;
+
+use crate::models::{DiscoveryFailure, FailureKind};
+use crate::project_validation::_helpers::conflicts::conflict;
+use crate::project_validation::constants::{CURRENT_DIRECTORY, KNOWN_FOLDER_LIMIT, MODELS_PREFIX};
+use crate::project_validation::models::{ProjectFacts, ValidationFailure};
+
+pub(crate) fn validate_path_defaults(facts: &ProjectFacts) -> Result<(), ValidationFailure> {
+    if facts.path_default_keys.is_empty() {
+        return Ok(());
+    }
+    let model_paths: Vec<String> = facts
+        .models
+        .iter()
+        .map(|model| {
+            let path: String = model.file.path.replace('\\', "/");
+            path.strip_prefix(MODELS_PREFIX)
+                .map_or(path.clone(), str::to_owned)
+        })
+        .collect();
+    let mut matched: HashSet<String> = HashSet::new();
+    for model_path in &model_paths {
+        let keys: Vec<String> = matched_path_default_keys(model_path, &facts.path_default_keys)
+            .map_err(|error| {
+                ValidationFailure::Discovery(DiscoveryFailure {
+                    kind: FailureKind::Conflict,
+                    message: error.message,
+                    help: error.help,
+                })
+            })?;
+        matched.extend(keys);
+    }
+    for key in &facts.path_default_keys {
+        if matched.contains(key) {
+            continue;
+        }
+        let mut folders: Vec<String> = model_paths
+            .iter()
+            .map(|path| parent_folder(path))
+            .filter(|folder| folder != CURRENT_DIRECTORY)
+            .collect::<HashSet<String>>()
+            .into_iter()
+            .collect();
+        folders.sort();
+        let known: String = if folders.is_empty() {
+            "<none>".to_owned()
+        } else {
+            folders
+                .iter()
+                .take(KNOWN_FOLDER_LIMIT)
+                .cloned()
+                .collect::<Vec<_>>()
+                .join(", ")
+        };
+        return Err(conflict(format!(
+            "path_defaults['{key}'] does not match any model paths. Known model folders include: \
+             {known}"
+        )));
+    }
+    Ok(())
+}
+
+/// `str(Path(path).parent)` for a discovered POSIX relative path.
+fn parent_folder(path: &str) -> String {
+    let parts: Vec<&str> = path
+        .split('/')
+        .filter(|part| !part.is_empty() && *part != CURRENT_DIRECTORY)
+        .collect();
+    match parts.split_last() {
+        Some((_, parents)) if !parents.is_empty() => parents.join("/"),
+        _ => CURRENT_DIRECTORY.to_owned(),
+    }
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/_helpers/python_nodes.rs b/crates/sqlbuild-discovery/src/project_validation/_helpers/python_nodes.rs
new file mode 100644
index 0000000000..5547a19d0f
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/_helpers/python_nodes.rs
@@ -0,0 +1,217 @@
+//! Python node dependency checks: known targets, no SQL inputs on loaders, no cycles.
+
+use std::collections::{HashMap, HashSet};
+
+use crate::project_validation::_helpers::conflicts::conflict;
+use crate::project_validation::models::{DependencyFact, NodeFact, NodeKind, ValidationFailure};
+
+/// `_python_node_dependency_key`: a decorated object's name, else the object itself.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum DependencyKey<'a> {
+    Name(&'a str),
+    Object(Option<usize>),
+}
+
+fn dependency_key(dependency: &DependencyFact) -> Option<DependencyKey<'_>> {
+    match dependency {
+        DependencyFact::SqlResource { .. } => None,
+        DependencyFact::Object {
+            decorated_name: Some(name),
+            ..
+        } => Some(DependencyKey::Name(name)),
+        DependencyFact::Object { owner, .. } => Some(DependencyKey::Object(*owner)),
+    }
+}
+
+/// The loaders, tasks and assets a dependency key names, as `node_by_dependency_key` maps them.
+struct ExecutableNodes<'a> {
+    nodes: &'a [NodeFact],
+    by_name: HashMap<&'a str, usize>,
+}
+
+impl<'a> ExecutableNodes<'a> {
+    fn new(nodes: &'a [NodeFact]) -> Self {
+        let mut by_name: HashMap<&'a str, usize> = HashMap::new();
+        for (index, node) in nodes.iter().enumerate() {
+            if node.kind != NodeKind::Check {
+                by_name.insert(&node.name, index);
+            }
+        }
+        Self { nodes, by_name }
+    }
+
+    fn resolve(&self, key: DependencyKey<'_>) -> Option<usize> {
+        match key {
+            DependencyKey::Name(name) => self.by_name.get(name).copied(),
+            DependencyKey::Object(Some(owner)) if self.nodes[owner].kind != NodeKind::Check => {
+                Some(owner)
+            }
+            DependencyKey::Object(_) => None,
+        }
+    }
+}
+
+/// `_validate_loader_dependencies`: no cycles through loader function dependencies.
+pub(crate) fn validate_loader_dependencies(nodes: &[NodeFact]) -> Result<(), ValidationFailure> {
+    let next = |index: usize| -> Vec<usize> {
+        nodes[index]
+            .depends_on
+            .iter()
+            .filter_map(|dependency| match dependency {
+                DependencyFact::Object {
+                    owner: Some(owner), ..
+                } if nodes[*owner].kind == NodeKind::Loader => Some(*owner),
+                _ => None,
+            })
+            .collect()
+    };
+    let roots: Vec<usize> = (0..nodes.len())
+        .filter(|index| nodes[*index].kind == NodeKind::Loader)
+        .collect();
+    find_cycle(nodes, &roots, next, "Loader dependency cycle detected")
+}
+
+/// `_validate_python_node_dependencies` over loaders, tasks and assets.
+pub(crate) fn validate_python_node_dependencies(
+    nodes: &[NodeFact],
+) -> Result<(), ValidationFailure> {
+    let executable: ExecutableNodes<'_> = ExecutableNodes::new(nodes);
+    let roots: Vec<usize> = (0..nodes.len())
+        .filter(|index| nodes[*index].kind != NodeKind::Check)
+        .collect();
+    for index in &roots {
+        let node: &NodeFact = &nodes[*index];
+        for dependency in &node.depends_on {
+            match dependency {
+                DependencyFact::SqlResource { name } => {
+                    if node.kind == NodeKind::Loader {
+                        return Err(conflict(format!(
+                            "Loader '{}' depends on SQL resource '{name}'; loaders may depend on \
+                             Python loader/task/asset functions only",
+                            node.name
+                        )));
+                    }
+                }
+                DependencyFact::Object { .. } => {
+                    let known: bool = dependency_key(dependency)
+                        .and_then(|key| executable.resolve(key))
+                        .is_some();
+                    if known {
+                        continue;
+                    }
+                    if node.kind == NodeKind::Loader {
+                        return Err(conflict(format!(
+                            "Loader '{}' depends on an unknown loader",
+                            node.name
+                        )));
+                    }
+                    return Err(conflict(format!(
+                        "Python node '{}' depends on an unknown Python node; use function \
+                         references to decorated loaders, tasks, or assets",
+                        node.name
+                    )));
+                }
+            }
+        }
+    }
+    let next = |index: usize| -> Vec<usize> {
+        nodes[index]
+            .depends_on
+            .iter()
+            .filter_map(dependency_key)
+            .filter_map(|key| executable.resolve(key))
+            .collect()
+    };
+    find_cycle(nodes, &roots, next, "Python node dependency cycle detected")
+}
+
+/// `_validate_check_dependencies`: checks depend on loaders, tasks and assets, never checks.
+pub(crate) fn validate_check_dependencies(nodes: &[NodeFact]) -> Result<(), ValidationFailure> {
+    let allowed: HashSet<&str> = nodes
+        .iter()
+        .filter(|node| node.kind != NodeKind::Check)
+        .map(|node| node.name.as_str())
+        .collect();
+    let checks: HashSet<&str> = nodes
+        .iter()
+        .filter(|node| node.kind == NodeKind::Check)
+        .map(|node| node.name.as_str())
+        .collect();
+    for check in nodes.iter().filter(|node| node.kind == NodeKind::Check) {
+        for dependency in &check.depends_on {
+            let Some(key) = dependency_key(dependency) else {
+                continue;
+            };
+            let name: Option<&str> = match key {
+                DependencyKey::Name(name) => Some(name),
+                DependencyKey::Object(_) => None,
+            };
+            if name.is_some_and(|name| checks.contains(name)) {
+                return Err(conflict(format!(
+                    "Check '{}' depends on another check; checks may depend on loaders, tasks, \
+                     assets, models, sources, and seeds only",
+                    check.name
+                )));
+            }
+            if !name.is_some_and(|name| allowed.contains(name)) {
+                return Err(conflict(format!(
+                    "Check '{}' depends on an unknown Python node; use function references to \
+                     decorated loaders, tasks, or assets",
+                    check.name
+                )));
+            }
+        }
+    }
+    Ok(())
+}
+
+/// Python's recursive `visit`: depth-first from each root, sharing visited names across roots.
+fn find_cycle(
+    nodes: &[NodeFact],
+    roots: &[usize],
+    next: impl Fn(usize) -> Vec<usize>,
+    label: &str,
+) -> Result<(), ValidationFailure> {
+    let mut search: CycleSearch<'_, _> = CycleSearch {
+        nodes,
+        next,
+        label,
+        path: Vec::new(),
+        visited: HashSet::new(),
+    };
+    for root in roots {
+        search.path.clear();
+        search.visit(*root)?;
+    }
+    Ok(())
+}
+
+/// One depth-first cycle search: the nodes on the current path and those already cleared.
+struct CycleSearch<'a, F> {
+    nodes: &'a [NodeFact],
+    next: F,
+    label: &'a str,
+    path: Vec<&'a str>,
+    visited: HashSet<&'a str>,
+}
+
+impl<'a, F: Fn(usize) -> Vec<usize>> CycleSearch<'a, F> {
+    fn visit(&mut self, index: usize) -> Result<(), ValidationFailure> {
+        let name: &'a str = &self.nodes[index].name;
+        if self.visited.contains(name) {
+            return Ok(());
+        }
+        if self.path.contains(&name) {
+            let mut cycle: Vec<&str> = self.path.clone();
+            cycle.push(name);
+            return Err(conflict(format!("{}: {}", self.label, cycle.join(" -> "))));
+        }
+        self.path.push(name);
+        for dependency in (self.next)(index) {
+            self.visit(dependency)?;
+        }
+        self.path.pop();
+        self.visited.insert(name);
+        Ok(())
+    }
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/_helpers/resource_names.rs b/crates/sqlbuild-discovery/src/project_validation/_helpers/resource_names.rs
new file mode 100644
index 0000000000..7f2032bafa
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/_helpers/resource_names.rs
@@ -0,0 +1,73 @@
+//! Python's `_validate_unique_project_resource_names`: one namespace across resource kinds.
+
+use std::collections::{HashMap, HashSet};
+
+use crate::project_validation::_helpers::conflicts::{conflict, schema_seeds};
+use crate::project_validation::_helpers::identities::block_or_file_name;
+use crate::project_validation::models::{NodeKind, ProjectFacts, ValidationFailure};
+
+/// Reject the first resource name declared twice across models, sources, seeds and the rest.
+pub(crate) fn validate_unique_project_resource_names(
+    facts: &ProjectFacts,
+) -> Result<(), ValidationFailure> {
+    let mut seen: HashMap<String, (String, String)> = HashMap::new();
+    let mut declare = |name: &str, kind: &str, path: &str| -> Result<(), ValidationFailure> {
+        if let Some((existing_kind, existing_path)) = seen.get(name) {
+            return Err(conflict(format!(
+                "Project resource name '{name}' is declared as both {existing_kind} in \
+                 {existing_path} and {kind} in {path}; model, source, seed, function, loader, \
+                 task, asset, check, provider, hook, unit test, and scenario names must be \
+                 globally unique"
+            )));
+        }
+        seen.insert(name.to_owned(), (kind.to_owned(), path.to_owned()));
+        Ok(())
+    };
+    for model in &facts.models {
+        declare(&model.file.name, "model", &model.file.path)?;
+    }
+    let mut managed_sources: HashSet<&str> = HashSet::new();
+    for file in &facts.sources {
+        for entry in &file.entries {
+            if entry.managed {
+                managed_sources.insert(&entry.name);
+            }
+            declare(&entry.name, "source", &file.path)?;
+        }
+    }
+    for seed in schema_seeds(facts) {
+        declare(&seed.name, "seed", &seed.path)?;
+    }
+    for function in facts.sql_functions.iter().chain(&facts.python_functions) {
+        declare(&function.name, "function", &function.path)?;
+    }
+    for node in &facts.nodes {
+        if node.kind == NodeKind::Loader && managed_sources.contains(node.name.as_str()) {
+            continue;
+        }
+        declare(&node.name, node.kind.label(), &node.path)?;
+    }
+    for provider in &facts.providers {
+        declare(&provider.name, "provider", &provider.path)?;
+    }
+    for hook in &facts.sql_hooks {
+        declare(&hook.name, "sql hook", &hook.path)?;
+    }
+    for hook in &facts.hook_functions {
+        declare(&hook.name, "python hook", &hook.path)?;
+    }
+    for scenario in &facts.scenarios {
+        declare(&scenario.name, "scenario", &scenario.path)?;
+    }
+    let mut test_names: HashSet<&str> = HashSet::new();
+    for test in &facts.tests {
+        for block in &test.blocks {
+            let name: &str = block_or_file_name(block.name.as_deref(), &test.file.name);
+            if !test_names.insert(name) {
+                continue;
+            }
+            declare(name, "unit test", &test.file.path)?;
+        }
+    }
+    Ok(())
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/_helpers/seeds.rs b/crates/sqlbuild-discovery/src/project_validation/_helpers/seeds.rs
new file mode 100644
index 0000000000..7f9fe73367
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/_helpers/seeds.rs
@@ -0,0 +1,133 @@
+//! Python's `_validate_declared_seed_files`: every declared seed has one CSV whose header matches.
+
+use std::collections::{HashMap, HashSet};
+
+use sqlbuild_core::text::main::python_str_repr::python_str_repr;
+
+use crate::_helpers::reading::read_failure;
+use crate::models::{DiscoveryFailure, FailureKind};
+use crate::project_validation::_helpers::csv_header::csv_header;
+use crate::project_validation::errors::HeaderError;
+use crate::project_validation::models::{
+    ProjectFacts, SeedEntryFact, SeedFileFact, ValidationFailure,
+};
+
+/// `csv.field_size_limit()` before any project changes it.
+const DEFAULT_FIELD_LIMIT: usize = 131_072;
+
+fn seed_error(message: String) -> ValidationFailure {
+    DiscoveryFailure::new(FailureKind::Seed, message).into()
+}
+
+/// Reject undeclared, duplicate or mismatched seed CSVs in Python's order.
+pub(crate) fn validate_declared_seed_files(facts: &ProjectFacts) -> Result<(), ValidationFailure> {
+    let field_limit: usize = facts.csv_field_limit.unwrap_or(DEFAULT_FIELD_LIMIT);
+    unique_seed_csv_names(&facts.seeds)?;
+    let mut by_name: HashMap<&str, Vec<&SeedFileFact>> = HashMap::new();
+    for seed in &facts.seeds {
+        by_name.entry(&seed.file.name).or_default().push(seed);
+    }
+    let mut declared: HashSet<&str> = HashSet::new();
+    for schema in &facts.schemas {
+        for entry in &schema.seeds {
+            declared.insert(&entry.name);
+            let matching: &[&SeedFileFact] =
+                by_name.get(entry.name.as_str()).map_or(&[], Vec::as_slice);
+            match matching {
+                [] => {
+                    return Err(seed_error(format!(
+                        "Seed declaration '{}' in {} has no matching CSV file under seeds/",
+                        entry.name, schema.path
+                    )));
+                }
+                [seed] => seed_csv_header(entry, seed, field_limit)?,
+                _ => {
+                    let paths: Vec<&str> = matching
+                        .iter()
+                        .map(|seed| seed.file.path.as_str())
+                        .collect();
+                    return Err(seed_error(format!(
+                        "Seed declaration '{}' matches multiple CSV files: {}",
+                        entry.name,
+                        paths.join(", ")
+                    )));
+                }
+            }
+        }
+    }
+    for seed in &facts.seeds {
+        if !declared.contains(seed.file.name.as_str()) {
+            return Err(seed_error(format!(
+                "Seed CSV {} has no matching declaration for seed '{}' under seeds/**/*.yml",
+                seed.file.path, seed.file.name
+            )));
+        }
+    }
+    Ok(())
+}
+
+fn unique_seed_csv_names(seeds: &[SeedFileFact]) -> Result<(), ValidationFailure> {
+    let mut seen: HashMap<&str, &str> = HashMap::new();
+    for seed in seeds {
+        if let Some(existing) = seen.get(seed.file.name.as_str()) {
+            return Err(seed_error(format!(
+                "Duplicate seed CSV name '{}' found: {existing}, {}. Seed CSV filenames must be \
+                 unique under seeds/.",
+                seed.file.name, seed.file.path
+            )));
+        }
+        seen.insert(&seed.file.name, &seed.file.path);
+    }
+    Ok(())
+}
+
+fn seed_csv_header(
+    entry: &SeedEntryFact,
+    seed: &SeedFileFact,
+    field_limit: usize,
+) -> Result<(), ValidationFailure> {
+    let unreadable = |failure| ValidationFailure::Unreadable {
+        absolute_path: seed.absolute_path.clone(),
+        failure,
+    };
+    let bytes: Vec<u8> =
+        std::fs::read(&seed.absolute_path).map_err(|error| unreadable(read_failure(&error)))?;
+    if let Some(error) = &entry.csv.dialect_error {
+        return Err(ValidationFailure::CsvDialect(error.clone()));
+    }
+    let header: Vec<String> = match csv_header(&bytes, &entry.csv, field_limit) {
+        Ok(header) => header,
+        Err(HeaderError::Read(failure)) => return Err(unreadable(failure)),
+        Err(HeaderError::Csv(message)) => return Err(ValidationFailure::Csv(message)),
+    };
+    let path: &str = &seed.file.path;
+    if header.is_empty() {
+        return Err(seed_error(format!("{path} must contain a CSV header row")));
+    }
+    let mut seen: HashSet<&str> = HashSet::new();
+    for column in &header {
+        if !seen.insert(column) {
+            return Err(seed_error(format!(
+                "{path} contains duplicate CSV header column '{column}'"
+            )));
+        }
+    }
+    if header != entry.columns {
+        return Err(seed_error(format!(
+            "{path} header {} does not match declared seed columns {} for '{}'",
+            python_tuple_repr(&header),
+            python_tuple_repr(&entry.columns),
+            entry.name
+        )));
+    }
+    Ok(())
+}
+
+/// Python's `repr` of a tuple of strings.
+fn python_tuple_repr(items: &[String]) -> String {
+    let parts: Vec<String> = items.iter().map(|item| python_str_repr(item)).collect();
+    match parts.as_slice() {
+        [single] => format!("({single},)"),
+        _ => format!("({})", parts.join(", ")),
+    }
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/constants.rs b/crates/sqlbuild-discovery/src/project_validation/constants.rs
new file mode 100644
index 0000000000..8ee3042fb3
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/constants.rs
@@ -0,0 +1,12 @@
+//! Names and limits cross-file discovery validation checks against.
+
+/// The loader kind whose generated loader takes the source's own name.
+pub(crate) const DLT_LOADER_KIND: &str = "dlt";
+/// The prefix discovery strips from model paths before matching path defaults.
+pub(crate) const MODELS_PREFIX: &str = "models/";
+/// `str(Path(...).parent)` of a path with no folder.
+pub(crate) const CURRENT_DIRECTORY: &str = ".";
+/// How many known model folders an unmatched path default lists.
+pub(crate) const KNOWN_FOLDER_LIMIT: usize = 5;
+/// Model names SQLBuild reserves for compiled output structure.
+pub(crate) const RESERVED_MODEL_NAMES: [&str; 1] = ["_chain_"];
diff --git a/crates/sqlbuild-discovery/src/project_validation/errors.rs b/crates/sqlbuild-discovery/src/project_validation/errors.rs
new file mode 100644
index 0000000000..1c057a217c
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/errors.rs
@@ -0,0 +1,27 @@
+//! Errors of reading seed CSV headers the way Python's `csv` module does.
+
+use crate::models::ReadFailure;
+
+/// A `TypeError` or `ValueError` Python's `csv` module raises for a reader's settings.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct CsvDialectError {
+    pub class: String,
+    pub message: String,
+}
+
+/// Why the header could not be read.
+#[derive(Debug)]
+pub(crate) enum HeaderError {
+    Read(ReadFailure),
+    /// `_csv.Error` with its message.
+    Csv(String),
+}
+
+impl std::fmt::Display for HeaderError {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Read(failure) => write!(formatter, "{failure:?}"),
+            Self::Csv(message) => formatter.write_str(message),
+        }
+    }
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/main/mod.rs b/crates/sqlbuild-discovery/src/project_validation/main/mod.rs
new file mode 100644
index 0000000000..1fc67badd8
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/main/mod.rs
@@ -0,0 +1 @@
+pub mod validate_project_inputs;
diff --git a/crates/sqlbuild-discovery/src/project_validation/main/validate_project_inputs.rs b/crates/sqlbuild-discovery/src/project_validation/main/validate_project_inputs.rs
new file mode 100644
index 0000000000..4ed360042a
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/main/validate_project_inputs.rs
@@ -0,0 +1,21 @@
+//! Python's `validate_discovered_inputs`: cross-file conflicts across discovered project inputs.
+
+use crate::project_validation::_helpers::declarations::validate_declarations;
+use crate::project_validation::_helpers::file_names::validate_file_names;
+use crate::project_validation::_helpers::identities::validate_identities;
+use crate::project_validation::_helpers::loaders::validate_loaders;
+use crate::project_validation::_helpers::path_defaults::validate_path_defaults;
+use crate::project_validation::_helpers::resource_names::validate_unique_project_resource_names;
+use crate::project_validation::_helpers::seeds::validate_declared_seed_files;
+use crate::project_validation::models::{ProjectFacts, ValidationFailure};
+
+/// Validate cross-file conflicts in Python's order; the first conflict is reported.
+pub fn validate_project_inputs(facts: &ProjectFacts) -> Result<(), ValidationFailure> {
+    validate_identities(facts)?;
+    validate_file_names(facts)?;
+    validate_loaders(facts)?;
+    validate_declarations(facts)?;
+    validate_declared_seed_files(facts)?;
+    validate_unique_project_resource_names(facts)?;
+    validate_path_defaults(facts)
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/mod.rs b/crates/sqlbuild-discovery/src/project_validation/mod.rs
new file mode 100644
index 0000000000..383898ca23
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/mod.rs
@@ -0,0 +1,8 @@
+pub(crate) mod _helpers;
+pub(crate) mod constants;
+pub mod errors;
+pub mod main;
+pub mod models;
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/sqlbuild-discovery/src/project_validation/models.rs b/crates/sqlbuild-discovery/src/project_validation/models.rs
new file mode 100644
index 0000000000..1a0f4fdb09
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/models.rs
@@ -0,0 +1,215 @@
+//! The facts cross-file discovery validation reads, in each collection's discovery order.
+
+use crate::models::{DiscoveryFailure, ReadFailure};
+use crate::project_validation::errors::CsvDialectError;
+
+/// A resource name and the project-relative path that declares it.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct NamedPath {
+    pub name: String,
+    pub path: String,
+}
+
+/// A discovered SQL model file: its stem, path and the declarations its header owns.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ModelFact {
+    pub file: NamedPath,
+    /// `(name, declaring path)` of the header's enums, then its constants.
+    pub local_declarations: Vec<NamedPath>,
+}
+
+/// One declarative integration loader a source names.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct IntegrationLoaderFact {
+    pub kind: String,
+}
+
+/// One source entry of a source YAML file.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct SourceFact {
+    pub name: String,
+    pub managed: bool,
+    pub loader: Option<String>,
+    pub integration_loader: Option<IntegrationLoaderFact>,
+}
+
+/// A source YAML file and its entries.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct SourceFileFact {
+    pub path: String,
+    pub entries: Vec<SourceFact>,
+}
+
+/// The decorated Python node kinds, in the order discovery lists them.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum NodeKind {
+    Loader,
+    Task,
+    Asset,
+    Check,
+}
+
+impl NodeKind {
+    /// The kind as resource-name conflicts word it.
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Loader => "loader",
+            Self::Task => "task",
+            Self::Asset => "asset",
+            Self::Check => "check",
+        }
+    }
+}
+
+/// One dependency a Python node declares.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum DependencyFact {
+    /// A `SqlResourceRef` to a model, source or seed.
+    SqlResource { name: String },
+    /// Any other dependency object.
+    Object {
+        /// The index of the discovered node whose function this object is.
+        owner: Option<usize>,
+        /// The name a loader, task, asset or check decorator records on the object.
+        decorated_name: Option<String>,
+    },
+}
+
+/// A decorated Python loader, task, asset or check function.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct NodeFact {
+    pub kind: NodeKind,
+    pub name: String,
+    pub path: String,
+    /// Whether a loader's decorator sets destination, write or schema config.
+    pub decorator_config: bool,
+    pub depends_on: Vec<DependencyFact>,
+}
+
+/// The CSV reader settings a seed declaration authors.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct CsvSettings {
+    pub delimiter: Option<String>,
+    pub quotechar: Option<String>,
+    pub escapechar: Option<String>,
+    pub doublequote: Option<bool>,
+    pub skipinitialspace: Option<bool>,
+    /// The error the running Python's `csv.reader` raises for these settings, if any.
+    pub dialect_error: Option<CsvDialectError>,
+}
+
+/// One seed entry of a schema YAML file.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct SeedEntryFact {
+    pub name: String,
+    pub columns: Vec<String>,
+    pub csv: CsvSettings,
+}
+
+/// A schema YAML file's model and seed entries.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct SchemaFileFact {
+    pub path: String,
+    pub model_names: Vec<String>,
+    pub seeds: Vec<SeedEntryFact>,
+}
+
+/// A seed CSV file: its stem and project-relative path, and where to read it.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct SeedFileFact {
+    pub file: NamedPath,
+    pub absolute_path: String,
+}
+
+/// One SQL test block and its case names.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct TestBlockFact {
+    pub name: Option<String>,
+    pub cases: Vec<String>,
+}
+
+/// A SQL test file: its path, stem and blocks.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct TestFileFact {
+    pub file: NamedPath,
+    pub blocks: Vec<TestBlockFact>,
+}
+
+/// An audit file: its path and stem, whether it declares a generic audit, and its block names.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct AuditFileFact {
+    pub file: NamedPath,
+    pub generic: bool,
+    pub block_names: Vec<Option<String>>,
+}
+
+/// An enum or constant declaration file's declarations and whether its scope is private.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ScopedDeclarationsFact {
+    pub private: bool,
+    pub declarations: Vec<NamedPath>,
+}
+
+/// Everything cross-file validation reads about one discovery.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ProjectFacts {
+    pub models: Vec<ModelFact>,
+    pub sql_functions: Vec<NamedPath>,
+    pub python_functions: Vec<NamedPath>,
+    pub sql_hooks: Vec<NamedPath>,
+    pub seeds: Vec<SeedFileFact>,
+    pub schemas: Vec<SchemaFileFact>,
+    pub sources: Vec<SourceFileFact>,
+    pub tests: Vec<TestFileFact>,
+    pub scenarios: Vec<NamedPath>,
+    pub audits: Vec<AuditFileFact>,
+    /// Enum declaration files, then constant declaration files.
+    pub declaration_files: Vec<ScopedDeclarationsFact>,
+    /// Every model schema declaration across the model schema files.
+    pub model_schemas: Vec<NamedPath>,
+    pub materializations: Vec<NamedPath>,
+    /// Loaders, tasks, assets, then checks.
+    pub nodes: Vec<NodeFact>,
+    pub hook_functions: Vec<NamedPath>,
+    pub event_exporters: Vec<NamedPath>,
+    pub providers: Vec<NamedPath>,
+    pub path_default_keys: Vec<String>,
+    /// Python's `csv.field_size_limit()`, or `None` for its default.
+    pub csv_field_limit: Option<usize>,
+}
+
+/// Why discovered inputs are rejected: a discovery error, or a seed CSV Python cannot read.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ValidationFailure {
+    Discovery(DiscoveryFailure),
+    Unreadable {
+        absolute_path: String,
+        failure: ReadFailure,
+    },
+    /// Python's `csv.Error` reading a seed header, with its message.
+    Csv(String),
+    /// The settings error the running Python's `csv.reader` raises.
+    CsvDialect(CsvDialectError),
+}
+
+impl From<DiscoveryFailure> for ValidationFailure {
+    fn from(failure: DiscoveryFailure) -> Self {
+        Self::Discovery(failure)
+    }
+}
+
+impl std::fmt::Display for ValidationFailure {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Discovery(failure) => {
+                write!(formatter, "{:?}: {}", failure.kind, failure.message)
+            }
+            Self::Unreadable {
+                absolute_path,
+                failure,
+            } => write!(formatter, "unreadable {absolute_path}: {failure:?}"),
+            Self::Csv(message) => write!(formatter, "csv: {message}"),
+            Self::CsvDialect(error) => write!(formatter, "{}: {}", error.class, error.message),
+        }
+    }
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/tests.rs b/crates/sqlbuild-discovery/src/project_validation/tests.rs
new file mode 100644
index 0000000000..ff3236ffdb
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/tests.rs
@@ -0,0 +1,8 @@
+#[path = "tests/test_csv_header.rs"]
+mod csv_header;
+#[path = "tests/helpers.rs"]
+mod helpers;
+#[path = "tests/test_types.rs"]
+mod test_types;
+#[path = "tests/test_validate_project_inputs.rs"]
+mod validate_project_inputs;
diff --git a/crates/sqlbuild-discovery/src/project_validation/tests/helpers.rs b/crates/sqlbuild-discovery/src/project_validation/tests/helpers.rs
new file mode 100644
index 0000000000..dc141fbc95
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/tests/helpers.rs
@@ -0,0 +1,90 @@
+use crate::project_validation::_helpers::csv_header::csv_header;
+use crate::project_validation::main::validate_project_inputs::validate_project_inputs;
+use crate::project_validation::models::{
+    CsvSettings, DependencyFact, ModelFact, NamedPath, NodeFact, NodeKind, ProjectFacts,
+    SchemaFileFact, SeedEntryFact, SeedFileFact, ValidationFailure,
+};
+
+/// The header the reader returns, or its error's message.
+pub(super) fn read_header(
+    text: &str,
+    settings: &CsvSettings,
+    field_limit: usize,
+) -> Result<Vec<String>, String> {
+    csv_header(text.as_bytes(), settings, field_limit).map_err(|error| error.to_string())
+}
+
+/// Validation's outcome, the failure shown as `Kind: message`.
+pub(super) fn validation_outcome(facts: &ProjectFacts) -> Result<(), String> {
+    validate_project_inputs(facts).map_err(|failure: ValidationFailure| failure.to_string())
+}
+
+/// Validation's outcome for one seed CSV holding `csv_text` declared with `columns`.
+pub(super) fn seed_header_outcome(csv_text: &str, columns: &[&str]) -> Result<(), String> {
+    let directory = tempfile::tempdir().expect("a temporary directory is writable");
+    let csv_path = directory.path().join("countries.csv");
+    std::fs::write(&csv_path, csv_text).expect("the seed CSV is writable");
+    let facts = ProjectFacts {
+        seeds: vec![SeedFileFact {
+            file: named("countries", "seeds/countries.csv"),
+            absolute_path: csv_path.to_string_lossy().into_owned(),
+        }],
+        schemas: vec![SchemaFileFact {
+            path: "seeds/countries.yml".to_owned(),
+            model_names: Vec::new(),
+            seeds: vec![SeedEntryFact {
+                name: "countries".to_owned(),
+                columns: columns.iter().map(|column| (*column).to_owned()).collect(),
+                ..SeedEntryFact::default()
+            }],
+        }],
+        ..ProjectFacts::default()
+    };
+    validation_outcome(&facts)
+}
+
+pub(super) fn named(name: &str, path: &str) -> NamedPath {
+    NamedPath {
+        name: name.to_owned(),
+        path: path.to_owned(),
+    }
+}
+
+/// A model file at `path` named by its stem.
+pub(super) fn model_at(name: &str, path: &str) -> ModelFact {
+    ModelFact {
+        file: named(name, path),
+        local_declarations: Vec::new(),
+    }
+}
+
+pub(super) fn model(name: &str) -> ModelFact {
+    model_at(name, &format!("models/{name}.sql"))
+}
+
+pub(super) fn node(kind: NodeKind, name: &str, depends_on: Vec<DependencyFact>) -> NodeFact {
+    NodeFact {
+        kind,
+        name: name.to_owned(),
+        path: format!("python/{name}.py"),
+        decorator_config: false,
+        depends_on,
+    }
+}
+
+/// A dependency on the decorated function of node `owner`, named `name`.
+pub(super) fn on(owner: usize, name: &str) -> DependencyFact {
+    DependencyFact::Object {
+        owner: Some(owner),
+        decorated_name: Some(name.to_owned()),
+    }
+}
+
+/// Facts for models at `paths` with the path-default `keys`.
+pub(super) fn path_default_facts(paths: &[&str], keys: &[&str]) -> ProjectFacts {
+    ProjectFacts {
+        models: paths.iter().map(|path| model_at("orders", path)).collect(),
+        path_default_keys: keys.iter().map(|key| (*key).to_owned()).collect(),
+        ..ProjectFacts::default()
+    }
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/tests/test_csv_header.rs b/crates/sqlbuild-discovery/src/project_validation/tests/test_csv_header.rs
new file mode 100644
index 0000000000..f95658ba51
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/tests/test_csv_header.rs
@@ -0,0 +1,1264 @@
+use crate::project_validation::models::CsvSettings;
+use crate::project_validation::tests::helpers::read_header;
+use crate::project_validation::tests::test_types::{CsvHeaderTestCase, LIMIT, csv_error, header};
+
+/// Expectations recorded from CPython 3.12's `next(csv.reader(...))`, identical on 3.13 and 3.14.
+#[test]
+fn given_seed_csv_text_when_reading_the_header_then_matches_python_csv_reader() {
+    let test_cases = [
+        CsvHeaderTestCase {
+            description: "bare cr",
+            text: "id,name\r1,a\r".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "no terminator",
+            text: "id,name".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "empty",
+            text: "".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&[]),
+        },
+        CsvHeaderTestCase {
+            description: "blank first line",
+            text: "\nid\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&[]),
+        },
+        CsvHeaderTestCase {
+            description: "trailing delimiter",
+            text: "a,b,\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b", ""]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\n1,a\\n' read default",
+            text: "id,name\n1,a\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\n1,a\\n' read quoted",
+            text: "id,name\n1,a\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\n1,a\\n' read quoted without doublequote",
+            text: "id,name\n1,a\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\n1,a\\n' read quoted skipping initial space",
+            text: "id,name\n1,a\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\n1,a\\n' read escaped",
+            text: "id,name\n1,a\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\n1,a\\n' read quoted and escaped",
+            text: "id,name\n1,a\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\n1,a\\n' read semicolon",
+            text: "id,name\n1,a\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["id,name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\r\\n' read default",
+            text: "id,name\r\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\r\\n' read quoted",
+            text: "id,name\r\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\r\\n' read quoted without doublequote",
+            text: "id,name\r\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\r\\n' read quoted skipping initial space",
+            text: "id,name\r\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\r\\n' read escaped",
+            text: "id,name\r\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\r\\n' read quoted and escaped",
+            text: "id,name\r\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'id,name\\r\\n' read semicolon",
+            text: "id,name\r\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["id,name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a,x\",b\\n' read default",
+            text: "\"a,x\",b\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["\"a", "x\"", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a,x\",b\\n' read quoted",
+            text: "\"a,x\",b\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a,x", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a,x\",b\\n' read quoted without doublequote",
+            text: "\"a,x\",b\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a,x", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a,x\",b\\n' read quoted skipping initial space",
+            text: "\"a,x\",b\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a,x", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a,x\",b\\n' read escaped",
+            text: "\"a,x\",b\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\"a", "x\"", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a,x\",b\\n' read quoted and escaped",
+            text: "\"a,x\",b\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a,x", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a,x\",b\\n' read semicolon",
+            text: "\"a,x\",b\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\"a,x\",b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"\"b\",c\\n' read default",
+            text: "\"a\"\"b\",c\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["\"a\"\"b\"", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"\"b\",c\\n' read quoted",
+            text: "\"a\"\"b\",c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\"b", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"\"b\",c\\n' read quoted without doublequote",
+            text: "\"a\"\"b\",c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\"b\"", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"\"b\",c\\n' read quoted skipping initial space",
+            text: "\"a\"\"b\",c\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\"b", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"\"b\",c\\n' read escaped",
+            text: "\"a\"\"b\",c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\"a\"\"b\"", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"\"b\",c\\n' read quoted and escaped",
+            text: "\"a\"\"b\",c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\"b", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"\"b\",c\\n' read semicolon",
+            text: "\"a\"\"b\",c\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\"a\"\"b\",c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"b,c\\n' read default",
+            text: "\"a\"b,c\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["\"a\"b", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"b,c\\n' read quoted",
+            text: "\"a\"b,c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["ab", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"b,c\\n' read quoted without doublequote",
+            text: "\"a\"b,c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["ab", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"b,c\\n' read quoted skipping initial space",
+            text: "\"a\"b,c\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["ab", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"b,c\\n' read escaped",
+            text: "\"a\"b,c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\"a\"b", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"b,c\\n' read quoted and escaped",
+            text: "\"a\"b,c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["ab", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"b,c\\n' read semicolon",
+            text: "\"a\"b,c\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\"a\"b,c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\\nb\",c\\n' read default",
+            text: "\"a\nb\",c\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["\"a"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\\nb\",c\\n' read quoted",
+            text: "\"a\nb\",c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\nb", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\\nb\",c\\n' read quoted without doublequote",
+            text: "\"a\nb\",c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\nb", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\\nb\",c\\n' read quoted skipping initial space",
+            text: "\"a\nb\",c\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\nb", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\\nb\",c\\n' read escaped",
+            text: "\"a\nb\",c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\"a"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\\nb\",c\\n' read quoted and escaped",
+            text: "\"a\nb\",c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\nb", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\\nb\",c\\n' read semicolon",
+            text: "\"a\nb\",c\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\"a"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a, b,  c\\n' read default",
+            text: "a, b,  c\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["a", " b", "  c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a, b,  c\\n' read quoted",
+            text: "a, b,  c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", " b", "  c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a, b,  c\\n' read quoted without doublequote",
+            text: "a, b,  c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", " b", "  c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a, b,  c\\n' read quoted skipping initial space",
+            text: "a, b,  c\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a, b,  c\\n' read escaped",
+            text: "a, b,  c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", " b", "  c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a, b,  c\\n' read quoted and escaped",
+            text: "a, b,  c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", " b", "  c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a, b,  c\\n' read semicolon",
+            text: "a, b,  c\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a, b,  c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\,b,c\\n' read default",
+            text: "a\\,b,c\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["a\\", "b", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\,b,c\\n' read quoted",
+            text: "a\\,b,c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\\", "b", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\,b,c\\n' read quoted without doublequote",
+            text: "a\\,b,c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\\", "b", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\,b,c\\n' read quoted skipping initial space",
+            text: "a\\,b,c\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\\", "b", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\,b,c\\n' read escaped",
+            text: "a\\,b,c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a,b", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\,b,c\\n' read quoted and escaped",
+            text: "a\\,b,c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a,b", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\,b,c\\n' read semicolon",
+            text: "a\\,b,c\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\\,b,c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b,\\n' read default",
+            text: "a,b,\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b", ""]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b,\\n' read quoted",
+            text: "a,b,\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b", ""]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b,\\n' read quoted without doublequote",
+            text: "a,b,\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b", ""]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b,\\n' read quoted skipping initial space",
+            text: "a,b,\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b", ""]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b,\\n' read escaped",
+            text: "a,b,\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b", ""]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b,\\n' read quoted and escaped",
+            text: "a,b,\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b", ""]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b,\\n' read semicolon",
+            text: "a,b,\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a,b,"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"abc' read default",
+            text: "\"abc".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["\"abc"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"abc' read quoted",
+            text: "\"abc".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["abc"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"abc' read quoted without doublequote",
+            text: "\"abc".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["abc"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"abc' read quoted skipping initial space",
+            text: "\"abc".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["abc"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"abc' read escaped",
+            text: "\"abc".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\"abc"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"abc' read quoted and escaped",
+            text: "\"abc".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["abc"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"abc' read semicolon",
+            text: "\"abc".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\"abc"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\ufeffid,name\\n' read default",
+            text: "\u{feff}id,name\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["\u{feff}id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\ufeffid,name\\n' read quoted",
+            text: "\u{feff}id,name\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\u{feff}id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\ufeffid,name\\n' read quoted without doublequote",
+            text: "\u{feff}id,name\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\u{feff}id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\ufeffid,name\\n' read quoted skipping initial space",
+            text: "\u{feff}id,name\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\u{feff}id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\ufeffid,name\\n' read escaped",
+            text: "\u{feff}id,name\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\u{feff}id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\ufeffid,name\\n' read quoted and escaped",
+            text: "\u{feff}id,name\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\u{feff}id", "name"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\ufeffid,name\\n' read semicolon",
+            text: "\u{feff}id,name\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\u{feff}id,name"]),
+        },
+        CsvHeaderTestCase {
+            description: "' \"a\", b\\n' read default",
+            text: " \"a\", b\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&[" \"a\"", " b"]),
+        },
+        CsvHeaderTestCase {
+            description: "' \"a\", b\\n' read quoted",
+            text: " \"a\", b\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&[" \"a\"", " b"]),
+        },
+        CsvHeaderTestCase {
+            description: "' \"a\", b\\n' read quoted without doublequote",
+            text: " \"a\", b\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&[" \"a\"", " b"]),
+        },
+        CsvHeaderTestCase {
+            description: "' \"a\", b\\n' read quoted skipping initial space",
+            text: " \"a\", b\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "' \"a\", b\\n' read escaped",
+            text: " \"a\", b\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&[" \"a\"", " b"]),
+        },
+        CsvHeaderTestCase {
+            description: "' \"a\", b\\n' read quoted and escaped",
+            text: " \"a\", b\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&[" \"a\"", " b"]),
+        },
+        CsvHeaderTestCase {
+            description: "' \"a\", b\\n' read semicolon",
+            text: " \"a\", b\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&[" \"a\", b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\\\nb,c\\n' read default",
+            text: "a\\\nb,c\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["a\\"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\\\nb,c\\n' read quoted",
+            text: "a\\\nb,c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\\"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\\\nb,c\\n' read quoted without doublequote",
+            text: "a\\\nb,c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\\"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\\\nb,c\\n' read quoted skipping initial space",
+            text: "a\\\nb,c\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\\"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\\\nb,c\\n' read escaped",
+            text: "a\\\nb,c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\nb", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\\\nb,c\\n' read quoted and escaped",
+            text: "a\\\nb,c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\nb", "c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a\\\\\\nb,c\\n' read semicolon",
+            text: "a\\\nb,c\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a\\"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"  ,b\\n' read default",
+            text: "\"a\"  ,b\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["\"a\"  ", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"  ,b\\n' read quoted",
+            text: "\"a\"  ,b\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a  ", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"  ,b\\n' read quoted without doublequote",
+            text: "\"a\"  ,b\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a  ", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"  ,b\\n' read quoted skipping initial space",
+            text: "\"a\"  ,b\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a  ", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"  ,b\\n' read escaped",
+            text: "\"a\"  ,b\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\"a\"  ", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"  ,b\\n' read quoted and escaped",
+            text: "\"a\"  ,b\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a  ", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\"a\"  ,b\\n' read semicolon",
+            text: "\"a\"  ,b\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["\"a\"  ,b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,\"b\"c\\n' read default",
+            text: "a,\"b\"c\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["a", "\"b\"c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,\"b\"c\\n' read quoted",
+            text: "a,\"b\"c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "bc"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,\"b\"c\\n' read quoted without doublequote",
+            text: "a,\"b\"c\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "bc"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,\"b\"c\\n' read quoted skipping initial space",
+            text: "a,\"b\"c\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "bc"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,\"b\"c\\n' read escaped",
+            text: "a,\"b\"c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "\"b\"c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,\"b\"c\\n' read quoted and escaped",
+            text: "a,\"b\"c\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "bc"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,\"b\"c\\n' read semicolon",
+            text: "a,\"b\"c\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a,\"b\"c"]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\n\\nid\\n' read default",
+            text: "\n\nid\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&[]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\n\\nid\\n' read quoted",
+            text: "\n\nid\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&[]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\n\\nid\\n' read quoted without doublequote",
+            text: "\n\nid\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&[]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\n\\nid\\n' read quoted skipping initial space",
+            text: "\n\nid\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&[]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\n\\nid\\n' read escaped",
+            text: "\n\nid\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&[]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\n\\nid\\n' read quoted and escaped",
+            text: "\n\nid\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&[]),
+        },
+        CsvHeaderTestCase {
+            description: "'\\n\\nid\\n' read semicolon",
+            text: "\n\nid\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&[]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b\\rc\\n' read default",
+            text: "a,b\rc\n".to_owned(),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b\\rc\\n' read quoted",
+            text: "a,b\rc\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b\\rc\\n' read quoted without doublequote",
+            text: "a,b\rc\n".to_owned(),
+            settings: CsvSettings {
+                quotechar: Some("\"".to_owned()),
+                doublequote: Some(false),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b\\rc\\n' read quoted skipping initial space",
+            text: "a,b\rc\n".to_owned(),
+            settings: CsvSettings {
+                skipinitialspace: Some(true),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b\\rc\\n' read escaped",
+            text: "a,b\rc\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b\\rc\\n' read quoted and escaped",
+            text: "a,b\rc\n".to_owned(),
+            settings: CsvSettings {
+                escapechar: Some("\\".to_owned()),
+                quotechar: Some("\"".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a", "b"]),
+        },
+        CsvHeaderTestCase {
+            description: "'a,b\\rc\\n' read semicolon",
+            text: "a,b\rc\n".to_owned(),
+            settings: CsvSettings {
+                delimiter: Some(";".to_owned()),
+                ..CsvSettings::default()
+            },
+            field_limit: LIMIT,
+            expected_header: header(&["a,b"]),
+        },
+        CsvHeaderTestCase {
+            description: "a header longer than one decode chunk",
+            text: format!("{},id\n1,2\n", "c".repeat(10_000)),
+            settings: CsvSettings::default(),
+            field_limit: LIMIT,
+            expected_header: header(&[&"c".repeat(10_000), "id"]),
+        },
+        CsvHeaderTestCase {
+            description: "a field at the limit",
+            text: format!("{},id\n", "c".repeat(10)),
+            settings: CsvSettings::default(),
+            field_limit: 10,
+            expected_header: header(&[&"c".repeat(10), "id"]),
+        },
+        CsvHeaderTestCase {
+            description: "a field over the limit",
+            text: format!("{},id\n", "c".repeat(11)),
+            settings: CsvSettings::default(),
+            field_limit: 10,
+            expected_header: csv_error("field larger than field limit (10)"),
+        },
+    ];
+    for test_case in test_cases {
+        assert_eq!(
+            read_header(&test_case.text, &test_case.settings, test_case.field_limit),
+            test_case.expected_header,
+            "{}",
+            test_case.description
+        );
+    }
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/tests/test_types.rs b/crates/sqlbuild-discovery/src/project_validation/tests/test_types.rs
new file mode 100644
index 0000000000..6881934f58
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/tests/test_types.rs
@@ -0,0 +1,44 @@
+use crate::models::FailureKind;
+use crate::project_validation::models::{CsvSettings, ProjectFacts};
+
+/// Python's default `csv.field_size_limit()`.
+pub(super) const LIMIT: usize = 131_072;
+
+/// One seed CSV text and the header Python's `csv` reader returns or the error it raises.
+pub(super) struct CsvHeaderTestCase {
+    pub(super) description: &'static str,
+    pub(super) text: String,
+    pub(super) settings: CsvSettings,
+    pub(super) field_limit: usize,
+    pub(super) expected_header: Result<Vec<String>, String>,
+}
+
+/// One project's facts and the first failure Python's validation reports, if any.
+pub(super) struct ValidationTestCase {
+    pub(super) description: &'static str,
+    pub(super) facts: ProjectFacts,
+    pub(super) expected_failure: Result<(), String>,
+}
+
+/// One seed CSV beside a declaration of `declared_columns`, and the failure validation reports.
+pub(super) struct SeedHeaderTestCase {
+    pub(super) description: &'static str,
+    pub(super) csv_text: &'static str,
+    pub(super) declared_columns: &'static [&'static str],
+    pub(super) expected_failure: Result<(), String>,
+}
+
+/// A header the reader returns.
+pub(super) fn header(columns: &[&str]) -> Result<Vec<String>, String> {
+    Ok(columns.iter().map(|column| (*column).to_owned()).collect())
+}
+
+/// The `_csv.Error` message the reader raises.
+pub(super) fn csv_error(message: &str) -> Result<Vec<String>, String> {
+    Err(message.to_owned())
+}
+
+/// The failure `Display` names for `kind` with `message`.
+pub(super) fn failure(kind: FailureKind, message: &str) -> Result<(), String> {
+    Err(format!("{kind:?}: {message}"))
+}
diff --git a/crates/sqlbuild-discovery/src/project_validation/tests/test_validate_project_inputs.rs b/crates/sqlbuild-discovery/src/project_validation/tests/test_validate_project_inputs.rs
new file mode 100644
index 0000000000..c6a9d1bd52
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/project_validation/tests/test_validate_project_inputs.rs
@@ -0,0 +1,231 @@
+use crate::models::FailureKind;
+use crate::project_validation::models::{
+    NodeKind, ProjectFacts, SeedFileFact, SourceFact, SourceFileFact,
+};
+use crate::project_validation::tests::helpers::{
+    model, model_at, named, node, on, path_default_facts, seed_header_outcome, validation_outcome,
+};
+use crate::project_validation::tests::test_types::{
+    SeedHeaderTestCase, ValidationTestCase, failure,
+};
+
+#[test]
+fn given_discovered_facts_when_validating_then_reports_python_first_conflict() {
+    let test_cases = [
+        ValidationTestCase {
+            description: "a valid project passes",
+            facts: ProjectFacts {
+                models: vec![model("orders"), model("customers")],
+                ..ProjectFacts::default()
+            },
+            expected_failure: Ok(()),
+        },
+        ValidationTestCase {
+            description: "a non-canonical model identity is rejected first",
+            facts: ProjectFacts {
+                models: vec![model("Orders"), model("_chain_")],
+                ..ProjectFacts::default()
+            },
+            expected_failure: failure(
+                FailureKind::ResourceIdentity,
+                "Invalid model identity 'Orders' in models/Orders.sql; use snake_case 'orders'",
+            ),
+        },
+        ValidationTestCase {
+            description: "a reserved model name fails its identity check first",
+            facts: ProjectFacts {
+                models: vec![model("_chain_")],
+                ..ProjectFacts::default()
+            },
+            expected_failure: failure(
+                FailureKind::ResourceIdentity,
+                "Invalid model identity '_chain_' in models/_chain_.sql; use snake_case 'chain'",
+            ),
+        },
+        ValidationTestCase {
+            description: "a source and a model share a logical relation name",
+            facts: ProjectFacts {
+                models: vec![model("orders")],
+                sources: vec![SourceFileFact {
+                    path: "sources/shop.yml".to_owned(),
+                    entries: vec![SourceFact {
+                        name: "orders".to_owned(),
+                        ..SourceFact::default()
+                    }],
+                }],
+                ..ProjectFacts::default()
+            },
+            expected_failure: failure(
+                FailureKind::Conflict,
+                "Logical relation name 'orders' is declared as both model in models/orders.sql \
+                 and source in sources/shop.yml",
+            ),
+        },
+        ValidationTestCase {
+            description: "a task cycle names its path",
+            facts: ProjectFacts {
+                nodes: vec![
+                    node(NodeKind::Task, "extract", vec![on(1, "load")]),
+                    node(NodeKind::Task, "load", vec![on(0, "extract")]),
+                ],
+                ..ProjectFacts::default()
+            },
+            expected_failure: failure(
+                FailureKind::Conflict,
+                "Python node dependency cycle detected: extract -> load -> extract",
+            ),
+        },
+        ValidationTestCase {
+            description: "a check depending on a check",
+            facts: ProjectFacts {
+                nodes: vec![
+                    node(NodeKind::Check, "first", Vec::new()),
+                    node(NodeKind::Check, "second", vec![on(0, "first")]),
+                ],
+                ..ProjectFacts::default()
+            },
+            expected_failure: failure(
+                FailureKind::Conflict,
+                "Check 'second' depends on another check; checks may depend on loaders, tasks, \
+                 assets, models, sources, and seeds only",
+            ),
+        },
+        ValidationTestCase {
+            description: "an undeclared seed CSV",
+            facts: ProjectFacts {
+                seeds: vec![SeedFileFact {
+                    file: named("countries", "seeds/countries.csv"),
+                    absolute_path: "/missing/seeds/countries.csv".to_owned(),
+                }],
+                ..ProjectFacts::default()
+            },
+            expected_failure: failure(
+                FailureKind::Seed,
+                "Seed CSV seeds/countries.csv has no matching declaration for seed 'countries' \
+                 under seeds/**/*.yml",
+            ),
+        },
+        ValidationTestCase {
+            description: "an unmatched path default lists known folders",
+            facts: ProjectFacts {
+                models: vec![model_at("orders", "models/marts/orders.sql")],
+                path_default_keys: vec!["staging".to_owned()],
+                ..ProjectFacts::default()
+            },
+            expected_failure: failure(
+                FailureKind::Conflict,
+                "path_defaults['staging'] does not match any model paths. Known model folders \
+                 include: marts",
+            ),
+        },
+        ValidationTestCase {
+            description: "accepts Windows-style model paths that match path defaults",
+            facts: path_default_facts(&["models\\staging\\orders.sql"], &["staging"]),
+            expected_failure: Ok(()),
+        },
+        ValidationTestCase {
+            description: "accepts recursive glob matching nested staging prefix",
+            facts: path_default_facts(
+                &["models/commerce/partner_feed/staging/orders.sql"],
+                &["commerce/**/staging"],
+            ),
+            expected_failure: Ok(()),
+        },
+        ValidationTestCase {
+            description: "accepts recursive glob matching zero segments",
+            facts: path_default_facts(
+                &["models/commerce/staging/orders.sql"],
+                &["commerce/**/staging"],
+            ),
+            expected_failure: Ok(()),
+        },
+        ValidationTestCase {
+            description: "counts broad glob as matched when a literal wins selection",
+            facts: path_default_facts(
+                &["models/commerce/partner_feed/staging/orders.sql"],
+                &["commerce/**/staging", "commerce/partner_feed/staging"],
+            ),
+            expected_failure: Ok(()),
+        },
+        ValidationTestCase {
+            description: "rejects recursive glob matching no model paths",
+            facts: path_default_facts(
+                &["models/commerce/partner_feed/marts/orders.sql"],
+                &["commerce/**/staging"],
+            ),
+            expected_failure: failure(
+                FailureKind::Conflict,
+                "path_defaults['commerce/**/staging'] does not match any model paths. Known \
+                 model folders include: commerce/partner_feed/marts",
+            ),
+        },
+        ValidationTestCase {
+            description: "rejects equally specific matching globs during discovery",
+            facts: path_default_facts(
+                &["models/commerce/eu/staging/orders.sql"],
+                &["commerce/*/staging", "commerce/eu/*"],
+            ),
+            expected_failure: failure(
+                FailureKind::Conflict,
+                "Model path 'commerce/eu/staging/orders.sql' matches equally specific \
+                 path_defaults keys: 'commerce/*/staging', 'commerce/eu/*'.",
+            ),
+        },
+    ];
+    for test_case in test_cases {
+        assert_eq!(
+            validation_outcome(&test_case.facts),
+            test_case.expected_failure,
+            "{}",
+            test_case.description
+        );
+    }
+}
+
+#[test]
+fn given_seed_csv_headers_when_validating_then_reports_python_tuple_reprs() {
+    let test_cases = [
+        SeedHeaderTestCase {
+            description: "a matching header passes",
+            csv_text: "code,label\nGB,United Kingdom\n",
+            declared_columns: &["code", "label"],
+            expected_failure: Ok(()),
+        },
+        SeedHeaderTestCase {
+            description: "an extra column shows both tuples",
+            csv_text: "code,label\nGB,United Kingdom\n",
+            declared_columns: &["code"],
+            expected_failure: failure(
+                FailureKind::Seed,
+                "seeds/countries.csv header ('code', 'label') does not match declared seed \
+                 columns ('code',) for 'countries'",
+            ),
+        },
+        SeedHeaderTestCase {
+            description: "a duplicate header column",
+            csv_text: "code,code\n",
+            declared_columns: &["code", "code"],
+            expected_failure: failure(
+                FailureKind::Seed,
+                "seeds/countries.csv contains duplicate CSV header column 'code'",
+            ),
+        },
+        SeedHeaderTestCase {
+            description: "an empty file has no header row",
+            csv_text: "",
+            declared_columns: &["code"],
+            expected_failure: failure(
+                FailureKind::Seed,
+                "seeds/countries.csv must contain a CSV header row",
+            ),
+        },
+    ];
+    for test_case in test_cases {
+        assert_eq!(
+            seed_header_outcome(test_case.csv_text, test_case.declared_columns),
+            test_case.expected_failure,
+            "{}",
+            test_case.description
+        );
+    }
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/_helpers/columns.rs b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/columns.rs
new file mode 100644
index 0000000000..72fc1f4a9e
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/columns.rs
@@ -0,0 +1,67 @@
+//! The `columns` list of a seed or source entry.
+
+use sqlbuild_model_config::errors::ConfigError;
+use sqlbuild_model_config::header_metadata::main::parse_audit_list::parse_audit_list;
+use sqlbuild_model_config::types::{AuthoredNode, NodeKind};
+
+use crate::yaml_entries::_helpers::fields::{
+    Site, get, optional_bool, optional_mapping, optional_text, reject_unknown_keys, required_text,
+};
+use crate::yaml_entries::models::ParsedYamlColumn;
+
+const NOT_NULL_AUDIT: &str = "not_null";
+
+/// `_parse_columns` of a seed or source entry.
+pub(crate) fn yaml_columns<N: AuthoredNode>(
+    entries: &[(N, N)],
+    site: Site<'_>,
+    allowed: Option<&[&str]>,
+) -> Result<Vec<ParsedYamlColumn<N>>, ConfigError> {
+    let Some(raw) = get(entries, "columns") else {
+        return Ok(Vec::new());
+    };
+    if raw.kind() != NodeKind::List {
+        return Err(site.error("columns must be a list"));
+    }
+    let label: String = format!("{} column", site.label);
+    let column_site: Site<'_> = Site {
+        path: site.path,
+        label: &label,
+    };
+    let mut columns: Vec<ParsedYamlColumn<N>> = Vec::new();
+    for raw_column in raw.items() {
+        if raw_column.kind() != NodeKind::Map {
+            return Err(site.error("columns must contain only mappings"));
+        }
+        let column: Vec<(N, N)> = raw_column.entries();
+        if let Some(allowed) = allowed {
+            reject_unknown_keys(&column, allowed, column_site)?;
+        }
+        let name: N = required_text(&column, "name", column_site)?;
+        let nullable: Option<N> = optional_bool(&column, "nullable", column_site)?;
+        let audits = parse_audit_list(get(&column, "audits"), site.path, &label, false)?;
+        let declares_nullable: bool = nullable
+            .as_ref()
+            .is_some_and(|value| value.kind() == NodeKind::Bool(true));
+        if declares_nullable
+            && audits
+                .iter()
+                .any(|audit| audit.definition_name.is_text(NOT_NULL_AUDIT))
+        {
+            return Err(ConfigError::compile(format!(
+                "{} column '{}' cannot set nullable = true and audit not_null",
+                site.path,
+                name.python_str()
+            )));
+        }
+        columns.push(ParsedYamlColumn {
+            name,
+            column_type: optional_text(&column, "type", column_site)?,
+            nullable,
+            description: optional_text(&column, "description", column_site)?,
+            meta: optional_mapping(&column, "meta", column_site)?,
+            audits,
+        });
+    }
+    Ok(columns)
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/_helpers/fields.rs b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/fields.rs
new file mode 100644
index 0000000000..0784da32a3
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/fields.rs
@@ -0,0 +1,175 @@
+//! Python's authored-value field readers, with the errors their YAML callers raise.
+
+use std::num::FpCategory;
+
+use sqlbuild_core::text::main::python_strip::python_strip;
+use sqlbuild_model_config::errors::ConfigError;
+use sqlbuild_model_config::types::{AuthoredNode, NodeKind};
+
+use crate::key_checks::main::unknown_mapping_keys::unknown_mapping_keys;
+
+/// Where one YAML parse reports its errors: the file path and the label the messages name.
+#[derive(Clone, Copy)]
+pub(crate) struct Site<'a> {
+    pub(crate) path: &'a str,
+    pub(crate) label: &'a str,
+}
+
+impl Site<'_> {
+    /// The error `<path> <label> <text>`.
+    pub(crate) fn error(&self, text: &str) -> ConfigError {
+        ConfigError::compile(format!("{} {} {text}", self.path, self.label))
+    }
+}
+
+/// The value of the string key `key`, the last one when a mapping repeats it.
+pub(crate) fn get<'a, N: AuthoredNode>(entries: &'a [(N, N)], key: &str) -> Option<&'a N> {
+    entries
+        .iter()
+        .rev()
+        .find(|(name, _)| name.is_text(key))
+        .map(|(_, value)| value)
+}
+
+/// `get` that reads Python's `None` as absent.
+fn present<'a, N: AuthoredNode>(entries: &'a [(N, N)], key: &str) -> Option<&'a N> {
+    get(entries, key).filter(|value| value.kind() != NodeKind::Null)
+}
+
+fn non_blank<N: AuthoredNode>(node: &N) -> bool {
+    node.with_text(|text| !python_strip(text).is_empty())
+        .unwrap_or(false)
+}
+
+/// `require_non_empty_string`.
+pub(crate) fn required_text<N: AuthoredNode>(
+    entries: &[(N, N)],
+    key: &str,
+    site: Site<'_>,
+) -> Result<N, ConfigError> {
+    match get(entries, key) {
+        Some(value) if non_blank(value) => Ok(value.clone()),
+        _ => Err(site.error(&format!("must define non-empty string '{key}'"))),
+    }
+}
+
+/// `optional_non_empty_string`.
+pub(crate) fn optional_text<N: AuthoredNode>(
+    entries: &[(N, N)],
+    key: &str,
+    site: Site<'_>,
+) -> Result<Option<N>, ConfigError> {
+    match present(entries, key) {
+        None => Ok(None),
+        Some(value) if non_blank(value) => Ok(Some(value.clone())),
+        Some(_) => Err(site.error(&format!("'{key}' must be a non-empty string"))),
+    }
+}
+
+/// `optional_bool`.
+pub(crate) fn optional_bool<N: AuthoredNode>(
+    entries: &[(N, N)],
+    key: &str,
+    site: Site<'_>,
+) -> Result<Option<N>, ConfigError> {
+    match present(entries, key) {
+        None => Ok(None),
+        Some(value) if matches!(value.kind(), NodeKind::Bool(_)) => Ok(Some(value.clone())),
+        Some(_) => Err(site.error(&format!("'{key}' must be a boolean"))),
+    }
+}
+
+/// `optional_mapping`: the authored mapping, or `None` for Python's empty default.
+pub(crate) fn optional_mapping<N: AuthoredNode>(
+    entries: &[(N, N)],
+    key: &str,
+    site: Site<'_>,
+) -> Result<Option<N>, ConfigError> {
+    match present(entries, key) {
+        None => Ok(None),
+        Some(value) if value.kind() == NodeKind::Map => Ok(Some(value.clone())),
+        Some(_) => Err(site.error(&format!("'{key}' must be a mapping"))),
+    }
+}
+
+/// `optional_string_tuple`.
+pub(crate) fn optional_texts<N: AuthoredNode>(
+    entries: &[(N, N)],
+    key: &str,
+    site: Site<'_>,
+) -> Result<Vec<N>, ConfigError> {
+    let Some(value) = present(entries, key) else {
+        return Ok(Vec::new());
+    };
+    if value.kind() != NodeKind::List {
+        return Err(site.error(&format!("'{key}' must be a list")));
+    }
+    let items: Vec<N> = value.items();
+    if items.iter().any(|item| item.kind() != NodeKind::Str) {
+        return Err(site.error(&format!("'{key}' entries must be strings")));
+    }
+    Ok(items)
+}
+
+/// `reject_unknown_mapping_keys`: the unknown keys and the nearest supported key as help.
+pub(crate) fn reject_unknown_keys<N: AuthoredNode>(
+    entries: &[(N, N)],
+    allowed: &[&str],
+    site: Site<'_>,
+) -> Result<(), ConfigError> {
+    let keys: Vec<(String, bool)> = entries
+        .iter()
+        .map(|(key, _)| (key.python_str(), key.kind() == NodeKind::Str))
+        .collect();
+    let allowed: Vec<String> = allowed.iter().map(|key| (*key).to_owned()).collect();
+    match unknown_mapping_keys(&keys, &allowed) {
+        None => Ok(()),
+        Some((message, help)) => Err(site.error(&message).with_help(help)),
+    }
+}
+
+/// Python's truth value of an authored value.
+pub(crate) fn truthy<N: AuthoredNode>(node: &N) -> bool {
+    match node.kind() {
+        NodeKind::Null => false,
+        NodeKind::Bool(value) => value,
+        NodeKind::Int { .. } => node.integer().is_none_or(|value| value != 0),
+        NodeKind::Str => node.with_text(|text| !text.is_empty()).unwrap_or(true),
+        NodeKind::List | NodeKind::Tuple => !node.items().is_empty(),
+        NodeKind::Map => !node.entries().is_empty(),
+        NodeKind::Other => node
+            .number()
+            .is_none_or(|number| number.classify() != FpCategory::Zero),
+    }
+}
+
+/// A string or list of strings, each `strip()`ped and non-empty; `error` words the failure.
+pub(crate) fn stripped_strings<N: AuthoredNode>(
+    value: &N,
+    error: impl Fn(&str) -> ConfigError,
+) -> Result<Vec<String>, ConfigError> {
+    match value.kind() {
+        NodeKind::Str => {
+            let stripped: String = python_strip(&value.text().unwrap_or_default()).to_owned();
+            if stripped.is_empty() {
+                return Err(error("must be non-empty"));
+            }
+            Ok(vec![stripped])
+        }
+        NodeKind::List => {
+            let mut strings: Vec<String> = Vec::new();
+            for item in value.items() {
+                let stripped: String = item
+                    .text()
+                    .map(|text| python_strip(&text).to_owned())
+                    .unwrap_or_default();
+                if stripped.is_empty() {
+                    return Err(error("must contain only non-empty strings"));
+                }
+                strings.push(stripped);
+            }
+            Ok(strings)
+        }
+        _ => Err(error("must be a string or list")),
+    }
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/_helpers/freshness.rs b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/freshness.rs
new file mode 100644
index 0000000000..009e129b8b
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/freshness.rs
@@ -0,0 +1,418 @@
+//! Source freshness: strategy inference, value kinds from declared types, and duration checks.
+
+use sqlbuild_core::text::main::decimal_digit_value::decimal_digit_value;
+use sqlbuild_core::text::main::is_decimal_digit::is_decimal_digit;
+use sqlbuild_core::text::main::python_casefold::python_casefold;
+use sqlbuild_core::text::main::python_isalnum::python_isalnum;
+use sqlbuild_core::text::main::python_isdigit::python_isdigit;
+use sqlbuild_core::text::main::python_isspace::python_isspace;
+use sqlbuild_core::text::main::python_strip::python_strip;
+use sqlbuild_model_config::errors::ConfigError;
+use sqlbuild_model_config::types::{AuthoredNode, NodeKind};
+
+use crate::yaml_entries::_helpers::fields::{
+    Site, get, optional_mapping, optional_text, reject_unknown_keys,
+};
+use crate::yaml_entries::models::{ParsedAgePolicy, ParsedFreshness, ParsedYamlColumn};
+
+const FRESHNESS_KEYS: [&str; 7] = [
+    "age_policy",
+    "column",
+    "filter",
+    "lag_tolerance",
+    "query",
+    "strategy",
+    "type",
+];
+const AGE_POLICY_KEYS: [&str; 2] = ["error_after", "warn_after"];
+const STRATEGIES: [&str; 3] = ["adapter", "column", "sql"];
+const VALUE_KINDS: [&str; 3] = ["integer", "string", "timestamp"];
+const TIMESTAMP: &str = "timestamp";
+const INTEGER: &str = "integer";
+const STRING: &str = "string";
+const ADAPTER: &str = "adapter";
+const COLUMN: &str = "column";
+const SQL: &str = "sql";
+const TIMESTAMP_TYPES: [&str; 9] = [
+    "DATETIME",
+    "DATETIME2",
+    "DATETIMEOFFSET",
+    "SMALLDATETIME",
+    "TIMESTAMP",
+    "TIMESTAMPTZ",
+    "TIMESTAMP_LTZ",
+    "TIMESTAMP_NTZ",
+    "TIMESTAMP_TZ",
+];
+const TIMESTAMP_ZONE_PREFIXES: [&str; 2] =
+    ["TIMESTAMP WITH TIME ZONE", "TIMESTAMP WITHOUT TIME ZONE"];
+const INTEGER_TYPES: [&str; 9] = [
+    "BIGINT", "INT", "INT2", "INT4", "INT8", "INT64", "INTEGER", "SMALLINT", "TINYINT",
+];
+const STRING_TYPES: [&str; 8] = [
+    "CHAR",
+    "CHARACTER",
+    "CHARACTER VARYING",
+    "NCHAR",
+    "NVARCHAR",
+    "STRING",
+    "TEXT",
+    "VARCHAR",
+];
+/// Duration units in `Duration._PATTERN` order, and the seconds each fixed unit spans.
+const DURATION_UNITS: [(&str, u128); 6] = [
+    ("y", 0),
+    ("mo", 0),
+    ("d", 86_400),
+    ("h", 3_600),
+    ("m", 60),
+    ("s", 1),
+];
+/// The units source freshness durations may use: minutes, hours and days.
+const FRESHNESS_UNITS: [&str; 3] = ["m", "h", "d"];
+
+fn one_of(value: &str, allowed: &[&'static str]) -> Option<&'static str> {
+    allowed.iter().copied().find(|item| *item == value)
+}
+
+/// `_optional_freshness_config`.
+pub(crate) fn freshness<N: AuthoredNode>(
+    entries: &[(N, N)],
+    columns: &[ParsedYamlColumn<N>],
+    path: &str,
+) -> Result<Option<ParsedFreshness<N>>, ConfigError> {
+    let raw: N = match get(entries, "freshness") {
+        None => return Ok(None),
+        Some(value) if value.kind() == NodeKind::Null => return Ok(None),
+        Some(value) => value.clone(),
+    };
+    if raw.kind() != NodeKind::Map {
+        return Err(ConfigError::compile(format!(
+            "{path} source 'freshness' must be a mapping"
+        )));
+    }
+    let freshness: Vec<(N, N)> = raw.entries();
+    let site: Site<'_> = Site {
+        path,
+        label: "source freshness",
+    };
+    reject_unknown_keys(&freshness, &FRESHNESS_KEYS, site)?;
+    let raw_strategy: Option<String> =
+        optional_text(&freshness, "strategy", site)?.and_then(|node| node.text());
+    let strategy: Option<&'static str> = match &raw_strategy {
+        None => None,
+        Some(text) => Some(one_of(text, &STRATEGIES).ok_or_else(|| {
+            site.error(&format!(
+                "'strategy' must be one of: {}",
+                STRATEGIES.join(", ")
+            ))
+        })?),
+    };
+    let mut value_kind: Option<&'static str> =
+        match optional_text(&freshness, "type", site)?.and_then(|node| node.text()) {
+            None => None,
+            Some(text) => Some(one_of(&text, &VALUE_KINDS).ok_or_else(|| {
+                site.error(&format!(
+                    "'type' must be one of: {}",
+                    VALUE_KINDS.join(", ")
+                ))
+            })?),
+        };
+    let column: Option<N> = optional_text(&freshness, "column", site)?;
+    let query: Option<N> = optional_text(&freshness, "query", site)?;
+    let filter: Option<N> = optional_text(&freshness, "filter", site)?;
+    let lag_tolerance: Option<N> = optional_text(&freshness, "lag_tolerance", site)?;
+    let age_policy: Option<ParsedAgePolicy<N>> = age_policy(&freshness, path)?;
+    let strategy: &'static str = match strategy {
+        Some(strategy) => strategy,
+        None => implied_strategy(
+            (column.is_some(), query.is_some()),
+            value_kind.is_some() || filter.is_some(),
+            path,
+        )?,
+    };
+    if strategy == COLUMN
+        && let Some(column_name) = column.as_ref().and_then(AuthoredNode::text)
+    {
+        value_kind = column_value_kind(&column_name, value_kind, columns, path)?;
+    }
+    let parsed: ParsedFreshness<N> = ParsedFreshness {
+        strategy,
+        value_kind,
+        column,
+        query,
+        filter,
+        lag_tolerance,
+        age_policy,
+    };
+    validate(&parsed, path)?;
+    Ok(Some(parsed))
+}
+
+fn implied_strategy(
+    (has_column, has_query): (bool, bool),
+    has_type_or_filter: bool,
+    path: &str,
+) -> Result<&'static str, ConfigError> {
+    if has_column && has_query {
+        return Err(ConfigError::compile(format!(
+            "{path} source freshness cannot set both column and query; set strategy or remove \
+             one of them"
+        )));
+    }
+    if has_column {
+        return Ok(COLUMN);
+    }
+    if has_query {
+        return Ok(SQL);
+    }
+    if has_type_or_filter {
+        return Err(ConfigError::compile(format!(
+            "{path} source freshness type and filter require column or query"
+        )));
+    }
+    Ok(ADAPTER)
+}
+
+fn age_policy<N: AuthoredNode>(
+    freshness: &[(N, N)],
+    path: &str,
+) -> Result<Option<ParsedAgePolicy<N>>, ConfigError> {
+    if get(freshness, "age_policy").is_none() {
+        return Ok(None);
+    }
+    let site: Site<'_> = Site {
+        path,
+        label: "source freshness",
+    };
+    let policy: Vec<(N, N)> = optional_mapping(freshness, "age_policy", site)?
+        .map(|node| node.entries())
+        .unwrap_or_default();
+    let site: Site<'_> = Site {
+        path,
+        label: "source freshness age_policy",
+    };
+    reject_unknown_keys(&policy, &AGE_POLICY_KEYS, site)?;
+    let warn_after: Option<N> = optional_text(&policy, "warn_after", site)?;
+    let error_after: Option<N> = optional_text(&policy, "error_after", site)?;
+    if warn_after.is_none() && error_after.is_none() {
+        return Err(site.error("requires warn_after or error_after"));
+    }
+    Ok(Some(ParsedAgePolicy {
+        warn_after,
+        error_after,
+    }))
+}
+
+/// `_resolve_column_freshness_value_kind`.
+fn column_value_kind<N: AuthoredNode>(
+    column: &str,
+    explicit: Option<&'static str>,
+    columns: &[ParsedYamlColumn<N>],
+    path: &str,
+) -> Result<Option<&'static str>, ConfigError> {
+    let declared_type: Option<String> = find_column(columns, column)
+        .and_then(|declared| declared.column_type.as_ref())
+        .and_then(AuthoredNode::text);
+    let inferred: Option<&'static str> = declared_type.as_deref().and_then(type_value_kind);
+    let Some(explicit) = explicit else {
+        if inferred.is_none()
+            && let Some(declared_type) = &declared_type
+        {
+            return Err(ConfigError::compile(format!(
+                "{path} source freshness cannot infer type from column '{column}' declared as \
+                 {declared_type}; set type to timestamp, integer, or string"
+            )));
+        }
+        return Ok(inferred);
+    };
+    if let Some(inferred) = inferred
+        && inferred != explicit
+    {
+        return Err(ConfigError::compile(format!(
+            "{path} source freshness type {explicit} contradicts column '{column}' declared as \
+             {}; remove type or set it to {inferred}",
+            declared_type.unwrap_or_default()
+        )));
+    }
+    Ok(Some(explicit))
+}
+
+/// `_find_source_column`: the exact name, else the only case-insensitive match.
+fn find_column<'a, N: AuthoredNode>(
+    columns: &'a [ParsedYamlColumn<N>],
+    name: &str,
+) -> Option<&'a ParsedYamlColumn<N>> {
+    if let Some(exact) = columns.iter().find(|column| column.name.is_text(name)) {
+        return Some(exact);
+    }
+    let folded: String = python_casefold(name);
+    let matches: Vec<&ParsedYamlColumn<N>> = columns
+        .iter()
+        .filter(|column| {
+            column
+                .name
+                .text()
+                .is_some_and(|text| python_casefold(&text) == folded)
+        })
+        .collect();
+    match matches.as_slice() {
+        [only] => Some(only),
+        _ => None,
+    }
+}
+
+/// `_freshness_value_kind_for_type`.
+fn type_value_kind(type_sql: &str) -> Option<&'static str> {
+    let upper: String = type_sql.to_uppercase();
+    let normalized: String = upper
+        .split(python_isspace)
+        .filter(|part| !part.is_empty())
+        .collect::<Vec<_>>()
+        .join(" ");
+    let base: &str = python_strip(normalized.split('(').next().unwrap_or_default());
+    if TIMESTAMP_TYPES.contains(&base)
+        || TIMESTAMP_ZONE_PREFIXES
+            .iter()
+            .any(|prefix| normalized.starts_with(prefix))
+    {
+        return Some(TIMESTAMP);
+    }
+    if INTEGER_TYPES.contains(&base) {
+        return Some(INTEGER);
+    }
+    STRING_TYPES.contains(&base).then_some(STRING)
+}
+
+/// `_validate_freshness_config`.
+fn validate<N: AuthoredNode>(config: &ParsedFreshness<N>, path: &str) -> Result<(), ConfigError> {
+    let error = |text: &str| ConfigError::compile(format!("{path} source freshness {text}"));
+    if let Some(lag_tolerance) = &config.lag_tolerance {
+        if config.value_kind != Some(TIMESTAMP) {
+            return Err(error("lag_tolerance requires type timestamp"));
+        }
+        if freshness_minutes(&lag_tolerance.text().unwrap_or_default()).is_none() {
+            return Err(error(
+                "lag_tolerance must be a positive duration like 15m, 2h, or 1d",
+            ));
+        }
+    }
+    if let Some(policy) = &config.age_policy {
+        if config.strategy != ADAPTER && config.value_kind != Some(TIMESTAMP) {
+            return Err(error("age_policy requires type timestamp"));
+        }
+        let warn: Option<String> = policy.warn_after.as_ref().and_then(AuthoredNode::text);
+        let fail: Option<String> = policy.error_after.as_ref().and_then(AuthoredNode::text);
+        for raw in [&warn, &fail].into_iter().flatten() {
+            if freshness_minutes(raw).is_none() {
+                return Err(error(
+                    "age_policy values must be positive durations like 15m, 2h, or 1d",
+                ));
+            }
+        }
+        if let (Some(warn), Some(fail)) = (&warn, &fail)
+            && freshness_minutes(warn) > freshness_minutes(fail)
+        {
+            return Err(error(
+                "age_policy warn_after must be less than or equal to error_after",
+            ));
+        }
+    }
+    match config.strategy {
+        ADAPTER => {
+            if config.value_kind.is_some()
+                || config.column.is_some()
+                || config.query.is_some()
+                || config.filter.is_some()
+            {
+                return Err(error(
+                    "strategy adapter does not support type, column, query, or filter",
+                ));
+            }
+            Ok(())
+        }
+        COLUMN => {
+            let Some(column) = config.column.as_ref().and_then(AuthoredNode::text) else {
+                return Err(error("strategy column requires column"));
+            };
+            if !plain_column_name(&column) {
+                return Err(error(
+                    "column must be a plain column name; use strategy sql for expressions",
+                ));
+            }
+            if config.value_kind.is_none() {
+                return Err(error(
+                    "strategy column requires type; set type or declare the column with a type \
+                     under columns",
+                ));
+            }
+            if config.query.is_some() {
+                return Err(error("strategy column does not support query"));
+            }
+            Ok(())
+        }
+        _ => {
+            if config.query.is_none() {
+                return Err(error("strategy sql requires query"));
+            }
+            if config.value_kind.is_none() {
+                return Err(error("strategy sql requires type"));
+            }
+            if config.column.is_some() {
+                return Err(error("strategy sql does not support column"));
+            }
+            if config.filter.is_some() {
+                return Err(error("strategy sql does not support filter"));
+            }
+            Ok(())
+        }
+    }
+}
+
+/// `column.replace("_", "").isalnum() and not column[0].isdigit()`.
+fn plain_column_name(column: &str) -> bool {
+    let rest: String = column.replace('_', "");
+    let alphanumeric: bool = !rest.is_empty() && rest.chars().all(python_isalnum);
+    let leading_digit: bool = column.chars().next().is_some_and(python_isdigit);
+    alphanumeric && !leading_digit
+}
+
+/// The whole minutes of a source freshness duration: one non-zero minute, hour or day amount.
+pub(crate) fn freshness_minutes(text: &str) -> Option<u128> {
+    let text: &str = text.strip_suffix('\n').unwrap_or(text);
+    let mut amounts: [u128; 6] = [0; 6];
+    let mut next_unit: usize = 0;
+    let mut rest: &str = text;
+    while !rest.is_empty() {
+        let digits: usize = rest
+            .char_indices()
+            .find(|(_, character)| !is_decimal_digit(*character))
+            .map_or(rest.len(), |(at, _)| at);
+        if digits == 0 {
+            return None;
+        }
+        let unit: usize = (next_unit..DURATION_UNITS.len())
+            .find(|index| rest[digits..].starts_with(DURATION_UNITS[*index].0))?;
+        amounts[unit] = decimal_value(&rest[..digits]);
+        rest = &rest[digits + DURATION_UNITS[unit].0.len()..];
+        next_unit = unit + 1;
+    }
+    let used: Vec<usize> = (0..amounts.len())
+        .filter(|index| amounts[*index] != 0)
+        .collect();
+    let [unit] = used.as_slice() else {
+        return None;
+    };
+    let (name, seconds) = DURATION_UNITS[*unit];
+    FRESHNESS_UNITS
+        .contains(&name)
+        .then(|| amounts[*unit].saturating_mul(seconds) / 60)
+}
+
+/// The value of Unicode decimal digits, saturating far beyond any real duration.
+fn decimal_value(digits: &str) -> u128 {
+    digits.chars().fold(0_u128, |value, character| {
+        let digit: u128 = decimal_digit_value(character).map_or(0, u128::from);
+        value.saturating_mul(10).saturating_add(digit)
+    })
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/_helpers/integrations.rs b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/integrations.rs
new file mode 100644
index 0000000000..337f57a5a1
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/integrations.rs
@@ -0,0 +1,388 @@
+//! Declarative integration loaders: a source's `ingestr` block and top-level `dlt_sources`.
+
+use sqlbuild_core::text::main::python_strip::python_strip;
+use sqlbuild_model_config::errors::ConfigError;
+use sqlbuild_model_config::types::{AuthoredNode, NodeKind};
+
+use crate::yaml_entries::_helpers::fields::{
+    Site, get, optional_mapping, optional_text, reject_unknown_keys, required_text,
+    stripped_strings,
+};
+use crate::yaml_entries::models::{
+    ParsedDltResource, ParsedDltSource, ParsedIngestrConfig, ParsedIntegrationLoader,
+    ParsedSourceEntry,
+};
+
+const DLT_LOADER_KIND: &str = "dlt";
+const INGESTR_KEYS: [&str; 8] = [
+    "columns",
+    "extra_args",
+    "incremental_key",
+    "primary_key",
+    "source_table",
+    "source_uri",
+    "strategy",
+    "unique_key",
+];
+const INGESTR_STRATEGIES: [&str; 5] = [
+    "append",
+    "delete+insert",
+    "merge",
+    "replace",
+    "truncate+insert",
+];
+const DLT_GROUP_KEYS: [&str; 5] = ["config", "destination", "resources", "schema", "type"];
+const DLT_RESOURCE_KEYS: [&str; 7] = [
+    "description",
+    "incremental",
+    "merge_key",
+    "name",
+    "primary_key",
+    "schema",
+    "write_disposition",
+];
+const FILESYSTEM: &str = "filesystem";
+const REST_API: &str = "rest_api";
+const SQL_DATABASE: &str = "sql_database";
+const BLOCKED_DESTINATION_KEYS: [&str; 3] = ["credentials", "dataset_name", "default_schema_name"];
+const RAW_CONFIG_EXCLUDED: [&str; 8] = [
+    "name",
+    "table",
+    "write_disposition",
+    "primary_key",
+    "merge_key",
+    "incremental",
+    "schema",
+    "description",
+];
+
+/// Python's `integration_loader_name`.
+pub(crate) fn integration_loader_name(kind: &str, source_name: &str) -> String {
+    if kind == DLT_LOADER_KIND {
+        source_name.to_owned()
+    } else {
+        format!("{kind}__{source_name}")
+    }
+}
+
+/// `parse_source_integration_loader`: the source's `ingestr` block, if any.
+pub(crate) fn source_integration_loader<N: AuthoredNode>(
+    entries: &[(N, N)],
+    path: &str,
+) -> Result<Option<ParsedIntegrationLoader<N>>, ConfigError> {
+    let Some(raw) = get(entries, "ingestr").filter(|value| value.kind() != NodeKind::Null) else {
+        return Ok(None);
+    };
+    if raw.kind() != NodeKind::Map {
+        return Err(ConfigError::compile(format!(
+            "{path} source 'ingestr' must be a mapping"
+        )));
+    }
+    let config: Vec<(N, N)> = raw.entries();
+    let site: Site<'_> = Site {
+        path,
+        label: "source ingestr",
+    };
+    reject_unknown_keys(&config, &INGESTR_KEYS, site)?;
+    let source_uri: N = required_text(&config, "source_uri", site)?;
+    let source_table: N = required_text(&config, "source_table", site)?;
+    let strategy: Option<N> = optional_text(&config, "strategy", site)?;
+    let incremental_key: Option<N> = optional_text(&config, "incremental_key", site)?;
+    let primary_key: Vec<String> = ingestr_strings(&config, "primary_key", path)?;
+    let unique_key: Vec<String> = ingestr_strings(&config, "unique_key", path)?;
+    if !primary_key.is_empty() && !unique_key.is_empty() {
+        return Err(site.error("cannot define both primary_key and unique_key"));
+    }
+    let columns: Option<N> = optional_text(&config, "columns", site)?;
+    let extra_args: Vec<String> = ingestr_strings(&config, "extra_args", path)?;
+    if let Some(text) = strategy.as_ref().and_then(AuthoredNode::text)
+        && !INGESTR_STRATEGIES.contains(&text.as_str())
+    {
+        return Err(site.error(&format!(
+            "strategy must be one of: {}",
+            INGESTR_STRATEGIES.join(", ")
+        )));
+    }
+    Ok(Some(ParsedIntegrationLoader::Ingestr(
+        ParsedIngestrConfig {
+            source_uri,
+            source_table,
+            strategy,
+            incremental_key,
+            primary_key: if primary_key.is_empty() {
+                unique_key
+            } else {
+                primary_key
+            },
+            columns,
+            extra_args,
+        },
+    )))
+}
+
+/// `_optional_ingestr_string_tuple`: one string or a list of strings, each stripped.
+fn ingestr_strings<N: AuthoredNode>(
+    config: &[(N, N)],
+    key: &str,
+    path: &str,
+) -> Result<Vec<String>, ConfigError> {
+    let error = |text: &str| ConfigError::compile(format!("{path} source ingestr '{key}' {text}"));
+    let Some(value) = get(config, key).filter(|value| value.kind() != NodeKind::Null) else {
+        return Ok(Vec::new());
+    };
+    stripped_strings(value, error)
+}
+
+/// `parse_dlt_sources`: one managed source per resource of each `dlt_sources` group.
+pub(crate) fn dlt_sources<N: AuthoredNode>(
+    payload: &[(N, N)],
+    path: &str,
+) -> Result<Vec<ParsedSourceEntry<N>>, ConfigError> {
+    let Some(raw_groups) = get(payload, "dlt_sources") else {
+        return Ok(Vec::new());
+    };
+    if raw_groups.kind() != NodeKind::List {
+        return Err(ConfigError::compile(format!(
+            "{path} dlt_sources must be a list"
+        )));
+    }
+    let mut sources: Vec<ParsedSourceEntry<N>> = Vec::new();
+    for (group_index, group) in raw_groups.items().iter().enumerate() {
+        if group.kind() != NodeKind::Map {
+            return Err(ConfigError::compile(format!(
+                "{path} dlt_sources must contain only mappings"
+            )));
+        }
+        sources.extend(dlt_group(&group.entries(), path, group_index)?);
+    }
+    Ok(sources)
+}
+
+fn dlt_group<N: AuthoredNode>(
+    group: &[(N, N)],
+    path: &str,
+    group_index: usize,
+) -> Result<Vec<ParsedSourceEntry<N>>, ConfigError> {
+    let site: Site<'_> = Site {
+        path,
+        label: "dlt source",
+    };
+    reject_unknown_keys(group, &DLT_GROUP_KEYS, site)?;
+    let source_type: N = required_text(group, "type", site)?;
+    let type_text: String = source_type.text().unwrap_or_default();
+    if ![FILESYSTEM, REST_API, SQL_DATABASE].contains(&type_text.as_str()) {
+        return Err(site.error("type must be one of: filesystem, rest_api, sql_database"));
+    }
+    let config: N = match get(group, "config") {
+        Some(config) if config.kind() == NodeKind::Map => config.clone(),
+        _ => return Err(site.error("config must be a mapping")),
+    };
+    let destination: Option<N> = optional_mapping(group, "destination", site)?;
+    if let Some(destination) = &destination {
+        let entries: Vec<(N, N)> = destination.entries();
+        for blocked in BLOCKED_DESTINATION_KEYS {
+            if get(&entries, blocked).is_some() {
+                return Err(site.error(&format!("destination cannot define '{blocked}'")));
+            }
+        }
+    }
+    let schema: Option<N> = optional_text(group, "schema", site)?;
+    validate_group_config(&type_text, &config.entries(), path)?;
+    let resources: Vec<N> = match get(group, "resources") {
+        Some(resources) if resources.kind() == NodeKind::List && !resources.items().is_empty() => {
+            resources.items()
+        }
+        _ => return Err(site.error("resources must be a non-empty list")),
+    };
+    let mut sources: Vec<ParsedSourceEntry<N>> = Vec::with_capacity(resources.len());
+    for resource in &resources {
+        if resource.kind() != NodeKind::Map {
+            return Err(site.error("resources must contain only mappings"));
+        }
+        let group: DltGroup<'_, N> = DltGroup {
+            source_type: &source_type,
+            type_text: &type_text,
+            schema: schema.as_ref(),
+            config: &config,
+            destination: destination.as_ref(),
+            index: group_index,
+        };
+        sources.push(dlt_resource(&group, &resource.entries(), path)?);
+    }
+    Ok(sources)
+}
+
+/// What every resource of one dlt source group shares.
+struct DltGroup<'a, N> {
+    source_type: &'a N,
+    type_text: &'a str,
+    schema: Option<&'a N>,
+    config: &'a N,
+    destination: Option<&'a N>,
+    index: usize,
+}
+
+fn validate_group_config<N: AuthoredNode>(
+    source_type: &str,
+    config: &[(N, N)],
+    path: &str,
+) -> Result<(), ConfigError> {
+    let error = |text: &str| ConfigError::compile(format!("{path} dlt {text}"));
+    let is_text = |value: Option<&N>| value.is_some_and(|value| value.kind() == NodeKind::Str);
+    match source_type {
+        REST_API => {
+            let base_url: bool = get(config, "client")
+                .filter(|client| client.kind() == NodeKind::Map)
+                .is_some_and(|client| is_text(get(&client.entries(), "base_url")));
+            if !base_url {
+                return Err(error("rest_api config requires client.base_url"));
+            }
+        }
+        SQL_DATABASE if !is_text(get(config, "credentials")) => {
+            return Err(error("sql_database config requires credentials"));
+        }
+        FILESYSTEM if !is_text(get(config, "bucket_url")) => {
+            return Err(error("filesystem config requires bucket_url"));
+        }
+        _ => {}
+    }
+    Ok(())
+}
+
+fn dlt_resource<N: AuthoredNode>(
+    group: &DltGroup<'_, N>,
+    resource: &[(N, N)],
+    path: &str,
+) -> Result<ParsedSourceEntry<N>, ConfigError> {
+    let name: N = required_text(
+        resource,
+        "name",
+        Site {
+            path,
+            label: "dlt resource",
+        },
+    )?;
+    let name_text: String = name.text().unwrap_or_default();
+    let error =
+        |text: &str| ConfigError::compile(format!("{path} dlt resource '{name_text}' {text}"));
+    if get(resource, "write_strategy").is_some() {
+        return Err(error("must use dlt write_disposition, not write_strategy"));
+    }
+    let type_key: &str = match group.type_text {
+        FILESYSTEM => "reader",
+        REST_API => "endpoint",
+        _ => "table",
+    };
+    let mut allowed: Vec<&str> = DLT_RESOURCE_KEYS.to_vec();
+    allowed.push(type_key);
+    let typed_label: String = format!("dlt {} resource '{name_text}'", group.type_text);
+    reject_unknown_keys(
+        resource,
+        &allowed,
+        Site {
+            path,
+            label: &typed_label,
+        },
+    )?;
+    let dlt_name: N = dlt_resource_name(group.type_text, resource, path)?;
+    let write_disposition: Option<N> = get(resource, "write_disposition").cloned();
+    let disposition: Option<String> = write_disposition.as_ref().and_then(AuthoredNode::text);
+    if disposition.as_deref() == Some("delete_insert") {
+        return Err(error("does not support delete_insert; use a Python loader"));
+    }
+    let primary_key: Option<N> = get(resource, "primary_key")
+        .filter(|value| value.kind() != NodeKind::Null)
+        .cloned();
+    if disposition.as_deref() == Some("merge") && primary_key.is_none() {
+        return Err(error("merge requires primary_key"));
+    }
+    let resource_label: String = format!("dlt resource '{name_text}'");
+    let resource_site: Site<'_> = Site {
+        path,
+        label: &resource_label,
+    };
+    let schema: Option<N> = optional_text(resource, "schema", resource_site)?
+        .filter(|value| python_truthy_text(value))
+        .or_else(|| group.schema.cloned());
+    let raw_config: Vec<(N, N)> = if group.type_text == REST_API {
+        resource
+            .iter()
+            .filter(|(key, _)| key.is_text("endpoint"))
+            .cloned()
+            .collect()
+    } else {
+        resource
+            .iter()
+            .filter(|(key, _)| !excluded_from_raw_config(key))
+            .cloned()
+            .collect()
+    };
+    let incremental: Option<N> = optional_mapping(resource, "incremental", resource_site)?;
+    let description: Option<N> = optional_text(resource, "description", resource_site)?;
+    let mut entry: ParsedSourceEntry<N> = ParsedSourceEntry::named(name.clone());
+    entry.description = description;
+    entry.schema = schema.clone();
+    entry.table = Some(name.clone());
+    entry.managed = true;
+    entry.loader = Some(integration_loader_name(DLT_LOADER_KIND, &name_text));
+    entry.integration_loader = Some(ParsedIntegrationLoader::Dlt(Box::new(ParsedDltSource {
+        source_type: group.source_type.clone(),
+        schema: schema.clone(),
+        config: group.config.clone(),
+        destination: group.destination.cloned(),
+        resource: ParsedDltResource {
+            name,
+            dlt_name,
+            schema,
+            raw_config,
+            write_disposition,
+            primary_key: get(resource, "primary_key").cloned(),
+            merge_key: get(resource, "merge_key").cloned(),
+            incremental,
+        },
+        group_index: group.index,
+    })));
+    Ok(entry)
+}
+
+/// Whether `value or other` keeps `value`: a non-empty string is always truthy.
+fn python_truthy_text<N: AuthoredNode>(value: &N) -> bool {
+    value.with_text(|text| !text.is_empty()).unwrap_or(true)
+}
+
+fn dlt_resource_name<N: AuthoredNode>(
+    source_type: &str,
+    resource: &[(N, N)],
+    path: &str,
+) -> Result<N, ConfigError> {
+    let site = |label| Site { path, label };
+    match source_type {
+        SQL_DATABASE => required_text(resource, "table", site("dlt sql_database resource")),
+        REST_API => {
+            let endpoint: Vec<(N, N)> = match get(resource, "endpoint") {
+                Some(endpoint) if endpoint.kind() == NodeKind::Map => endpoint.entries(),
+                _ => {
+                    return Err(ConfigError::compile(format!(
+                        "{path} dlt rest_api resource must define endpoint"
+                    )));
+                }
+            };
+            if let Some(name) = get(&endpoint, "name")
+                && name
+                    .with_text(|text| !python_strip(text).is_empty())
+                    .unwrap_or(false)
+            {
+                return Ok(name.clone());
+            }
+            required_text(resource, "name", site("dlt rest_api resource"))
+        }
+        _ => required_text(resource, "name", site("dlt filesystem resource")),
+    }
+}
+
+/// Whether `key` is a resource setting SQLBuild reads itself rather than passing to dlt.
+fn excluded_from_raw_config<N: AuthoredNode>(key: &N) -> bool {
+    RAW_CONFIG_EXCLUDED
+        .iter()
+        .any(|excluded| key.is_text(excluded))
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/_helpers/mod.rs b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/mod.rs
new file mode 100644
index 0000000000..4bccc8d43a
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/mod.rs
@@ -0,0 +1,6 @@
+pub(crate) mod columns;
+pub(crate) mod fields;
+pub(crate) mod freshness;
+pub(crate) mod integrations;
+pub(crate) mod seeds;
+pub(crate) mod sources;
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/_helpers/seeds.rs b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/seeds.rs
new file mode 100644
index 0000000000..f0e5e541e1
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/seeds.rs
@@ -0,0 +1,202 @@
+//! One seed declaration of a schema YAML file, and its CSV settings.
+
+use sqlbuild_model_config::errors::ConfigError;
+use sqlbuild_model_config::header_metadata::main::parse_audit_list::parse_audit_list;
+use sqlbuild_model_config::types::{AuthoredNode, NodeKind};
+
+use crate::yaml_entries::_helpers::columns::yaml_columns;
+use crate::yaml_entries::_helpers::fields::{
+    Site, get, optional_mapping, optional_text, optional_texts, reject_unknown_keys, required_text,
+};
+use crate::yaml_entries::models::{
+    ParsedCsvSettings, ParsedNaValues, ParsedSeedEntry, ParsedYamlColumn,
+};
+
+const SEED_ENTRY_KEYS: [&str; 9] = [
+    "name",
+    "description",
+    "database",
+    "schema",
+    "meta",
+    "csv_settings",
+    "columns",
+    "tags",
+    "audits",
+];
+const SEED_COLUMN_KEYS: [&str; 6] = ["name", "type", "nullable", "description", "meta", "audits"];
+const CSV_SETTING_KEYS: [&str; 9] = [
+    "delimiter",
+    "quotechar",
+    "doublequote",
+    "escapechar",
+    "skipinitialspace",
+    "lineterminator",
+    "encoding",
+    "na_values",
+    "keep_default_na",
+];
+const CSV_STRING_SETTINGS: [&str; 5] = [
+    "delimiter",
+    "quotechar",
+    "escapechar",
+    "lineterminator",
+    "encoding",
+];
+const CSV_BOOL_SETTINGS: [&str; 3] = ["doublequote", "skipinitialspace", "keep_default_na"];
+
+/// `_parse_named_mapping_list`.
+pub(crate) fn mapping_list<N: AuthoredNode>(
+    value: &N,
+    path: &str,
+    label: &str,
+) -> Result<Vec<N>, ConfigError> {
+    if value.kind() != NodeKind::List {
+        return Err(ConfigError::compile(format!(
+            "{path} {label} must be a list"
+        )));
+    }
+    let items: Vec<N> = value.items();
+    if items.iter().any(|item| item.kind() != NodeKind::Map) {
+        return Err(ConfigError::compile(format!(
+            "{path} {label} must contain only mappings"
+        )));
+    }
+    Ok(items)
+}
+
+pub(crate) fn seed_entry<N: AuthoredNode>(
+    entries: &[(N, N)],
+    path: &str,
+) -> Result<ParsedSeedEntry<N>, ConfigError> {
+    let site: Site<'_> = Site {
+        path,
+        label: "seed",
+    };
+    reject_unknown_keys(entries, &SEED_ENTRY_KEYS, site)?;
+    let columns: Vec<ParsedYamlColumn<N>> = yaml_columns(entries, site, Some(&SEED_COLUMN_KEYS))?;
+    if columns.is_empty() {
+        return Err(site.error("must declare at least one column"));
+    }
+    for column in &columns {
+        if column.column_type.is_none() {
+            return Err(site.error(&format!(
+                "column '{}' must define non-empty string 'type'",
+                column.name.python_str()
+            )));
+        }
+    }
+    Ok(ParsedSeedEntry {
+        name: required_text(entries, "name", site)?,
+        description: optional_text(entries, "description", site)?,
+        database: optional_text(entries, "database", site)?,
+        schema: optional_text(entries, "schema", site)?,
+        meta: optional_mapping(entries, "meta", site)?,
+        tags: optional_texts(entries, "tags", site)?,
+        csv_settings: csv_settings(entries, path)?,
+        columns,
+        audits: parse_audit_list(get(entries, "audits"), path, "seed", false)?,
+    })
+}
+
+fn csv_settings<N: AuthoredNode>(
+    entries: &[(N, N)],
+    path: &str,
+) -> Result<Option<ParsedCsvSettings<N>>, ConfigError> {
+    let raw: N = match get(entries, "csv_settings") {
+        None => return Ok(None),
+        Some(value) if value.kind() == NodeKind::Null => return Ok(None),
+        Some(value) => value.clone(),
+    };
+    if raw.kind() != NodeKind::Map {
+        return Err(ConfigError::compile(format!(
+            "{path} seed 'csv_settings' must be a mapping"
+        )));
+    }
+    let settings: Vec<(N, N)> = raw.entries();
+    let mut unknown: Vec<String> = settings
+        .iter()
+        .filter(|(key, _)| !csv_setting_key(key))
+        .map(|(key, _)| key.python_str())
+        .collect();
+    if !unknown.is_empty() {
+        unknown.sort();
+        return Err(ConfigError::compile(format!(
+            "{path} seed 'csv_settings' has unknown keys: {}",
+            unknown.join(", ")
+        )));
+    }
+    let set = |key: &str| get(&settings, key).filter(|value| value.kind() != NodeKind::Null);
+    for key in CSV_STRING_SETTINGS {
+        if set(key).is_some_and(|value| value.kind() != NodeKind::Str) {
+            return Err(ConfigError::compile(format!(
+                "{path} seed csv_settings '{key}' must be a string"
+            )));
+        }
+    }
+    for key in CSV_BOOL_SETTINGS {
+        if set(key).is_some_and(|value| !matches!(value.kind(), NodeKind::Bool(_))) {
+            return Err(ConfigError::compile(format!(
+                "{path} seed csv_settings '{key}' must be a boolean"
+            )));
+        }
+    }
+    Ok(Some(ParsedCsvSettings {
+        delimiter: set("delimiter").cloned(),
+        quotechar: set("quotechar").cloned(),
+        doublequote: set("doublequote").cloned(),
+        escapechar: set("escapechar").cloned(),
+        skipinitialspace: set("skipinitialspace").cloned(),
+        lineterminator: set("lineterminator").cloned(),
+        encoding: set("encoding").cloned(),
+        na_values: na_values(set("na_values"), path)?,
+        keep_default_na: set("keep_default_na").cloned(),
+    }))
+}
+
+fn na_values<N: AuthoredNode>(
+    raw: Option<&N>,
+    path: &str,
+) -> Result<Option<ParsedNaValues<N>>, ConfigError> {
+    let Some(raw) = raw else {
+        return Ok(None);
+    };
+    match raw.kind() {
+        NodeKind::List => Ok(Some(ParsedNaValues::List(na_scalars(raw, path)?))),
+        NodeKind::Map => {
+            let mut columns: Vec<(N, Vec<N>)> = Vec::new();
+            for (column, values) in raw.entries() {
+                if values.kind() != NodeKind::List {
+                    return Err(ConfigError::compile(format!(
+                        "{path} seed csv_settings 'na_values' mapping values must be lists"
+                    )));
+                }
+                columns.push((column, na_scalars(&values, path)?));
+            }
+            Ok(Some(ParsedNaValues::PerColumn(columns)))
+        }
+        _ => Err(ConfigError::compile(format!(
+            "{path} seed csv_settings 'na_values' must be a list or mapping"
+        ))),
+    }
+}
+
+fn na_scalars<N: AuthoredNode>(list: &N, path: &str) -> Result<Vec<N>, ConfigError> {
+    let items: Vec<N> = list.items();
+    for item in &items {
+        let scalar: bool = matches!(
+            item.kind(),
+            NodeKind::Null | NodeKind::Str | NodeKind::Bool(_) | NodeKind::Int { .. }
+        );
+        if !scalar {
+            return Err(ConfigError::compile(format!(
+                "{path} seed csv_settings 'na_values' entries must be strings, integers, \
+                 booleans, or null"
+            )));
+        }
+    }
+    Ok(items)
+}
+
+fn csv_setting_key<N: AuthoredNode>(key: &N) -> bool {
+    CSV_SETTING_KEYS.iter().any(|allowed| key.is_text(allowed))
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/_helpers/sources.rs b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/sources.rs
new file mode 100644
index 0000000000..eb356f6e80
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/_helpers/sources.rs
@@ -0,0 +1,291 @@
+//! One `sources:` entry: its shape, managed loader, settings and the checks across them.
+
+use sqlbuild_model_config::errors::ConfigError;
+use sqlbuild_model_config::header_metadata::main::parse_audit_list::parse_audit_list;
+use sqlbuild_model_config::types::{AuthoredNode, NodeKind};
+
+use crate::yaml_entries::_helpers::columns::yaml_columns;
+use crate::yaml_entries::_helpers::fields::{
+    Site, get, optional_bool, optional_mapping, optional_text, reject_unknown_keys, required_text,
+    stripped_strings,
+};
+use crate::yaml_entries::_helpers::freshness::freshness;
+use crate::yaml_entries::_helpers::integrations::{
+    integration_loader_name, source_integration_loader,
+};
+use crate::yaml_entries::models::{ParsedIntegrationLoader, ParsedSourceEntry, ParsedYamlColumn};
+
+const ENTRY_KEYS: [&str; 18] = [
+    "audits",
+    "columns",
+    "contract",
+    "cursor_column",
+    "database",
+    "description",
+    "expression",
+    "freshness",
+    "ingestr",
+    "load_batch_size",
+    "managed",
+    "meta",
+    "name",
+    "schema",
+    "table",
+    "type_enforcement",
+    "unique_key",
+    "write_strategy",
+];
+const COLUMN_KEYS: [&str; 6] = ["audits", "description", "meta", "name", "nullable", "type"];
+const CONTRACT_POLICIES: [&str; 2] = ["none", "enforced"];
+const WRITE_STRATEGIES: [&str; 4] = ["append", "delete_insert", "merge", "table"];
+const APPEND: &str = "append";
+const DELETE_INSERT: &str = "delete_insert";
+const MERGE: &str = "merge";
+const TABLE: &str = "table";
+
+/// What Python reads of an entry before its name: columns, typing, contract and expression.
+struct SourceShape<N> {
+    columns: Vec<ParsedYamlColumn<N>>,
+    type_enforcement: Option<bool>,
+    contract: Option<N>,
+    expression: Option<N>,
+}
+
+/// `_parse_source_entry`: one entry of `sources`, read in Python's order.
+pub(crate) fn source_entry<N: AuthoredNode>(
+    entry: &[(N, N)],
+    path: &str,
+) -> Result<ParsedSourceEntry<N>, ConfigError> {
+    let site: Site<'_> = Site {
+        path,
+        label: "source",
+    };
+    let shape: SourceShape<N> = source_shape(entry, site)?;
+    let name: N = required_text(entry, "name", site)?;
+    let name_text: String = name.text().unwrap_or_default();
+    let managed: ParsedSourceEntry<N> = managed_source(entry, name, &name_text, site)?;
+    let parsed: ParsedSourceEntry<N> = with_settings(entry, site, shape, managed)?;
+    validate_source(&parsed, &name_text, path)?;
+    Ok(parsed)
+}
+
+fn source_shape<N: AuthoredNode>(
+    entry: &[(N, N)],
+    site: Site<'_>,
+) -> Result<SourceShape<N>, ConfigError> {
+    let columns: Vec<ParsedYamlColumn<N>> = yaml_columns(entry, site, Some(&COLUMN_KEYS))?;
+    let authored_enforcement: Option<bool> = optional_bool(entry, "type_enforcement", site)?
+        .map(|node| node.kind() == NodeKind::Bool(true));
+    let contract: Option<N> = optional_text(entry, "contract", site)?;
+    if contract
+        .as_ref()
+        .and_then(AuthoredNode::text)
+        .is_some_and(|text| !CONTRACT_POLICIES.contains(&text.as_str()))
+    {
+        return Err(site.error("'contract' must be one of: enforced, none"));
+    }
+    let expression: Option<N> = optional_text(entry, "expression", site)?;
+    let typed: bool = columns.iter().any(|column| column.column_type.is_some());
+    let type_enforcement: Option<bool> = authored_enforcement.or_else(|| typed.then_some(true));
+    if get(entry, "loader").is_some() {
+        return Err(site.error(
+            "'loader' is not supported; use managed: true and name the terminal loader after \
+             the source",
+        ));
+    }
+    reject_unknown_keys(entry, &ENTRY_KEYS, site)?;
+    Ok(SourceShape {
+        columns,
+        type_enforcement,
+        contract,
+        expression,
+    })
+}
+
+/// The entry named `name`, managed by its own loader or by its integration loader.
+fn managed_source<N: AuthoredNode>(
+    entry: &[(N, N)],
+    name: N,
+    name_text: &str,
+    site: Site<'_>,
+) -> Result<ParsedSourceEntry<N>, ConfigError> {
+    let integration_loader: Option<ParsedIntegrationLoader<N>> =
+        source_integration_loader(entry, site.path)?;
+    let mut managed: bool = optional_bool(entry, "managed", site)?
+        .is_some_and(|node| node.kind() == NodeKind::Bool(true));
+    let mut loader: Option<String> = managed.then(|| name_text.to_owned());
+    if loader.is_none()
+        && let Some(integration) = &integration_loader
+    {
+        loader = Some(integration_loader_name(integration.kind(), name_text));
+        managed = true;
+    }
+    let mut parsed: ParsedSourceEntry<N> = ParsedSourceEntry::named(name);
+    parsed.managed = managed;
+    parsed.loader = loader;
+    parsed.integration_loader = integration_loader;
+    Ok(parsed)
+}
+
+/// `parsed` with its relation, load settings, metadata and audits read in Python's order.
+fn with_settings<N: AuthoredNode>(
+    entry: &[(N, N)],
+    site: Site<'_>,
+    shape: SourceShape<N>,
+    mut parsed: ParsedSourceEntry<N>,
+) -> Result<ParsedSourceEntry<N>, ConfigError> {
+    let path: &str = site.path;
+    parsed.database = optional_text(entry, "database", site)?;
+    parsed.schema = optional_text(entry, "schema", site)?;
+    parsed.table = optional_text(entry, "table", site)?;
+    parsed.freshness = freshness(entry, &shape.columns, path)?;
+    parsed.write_strategy = write_strategy(entry, site)?;
+    parsed.load_batch_size = positive_int(entry, "load_batch_size", path)?;
+    parsed.cursor_column = optional_text(entry, "cursor_column", site)?;
+    parsed.unique_key = unique_key(entry, path)?;
+    parsed.expression = shape.expression;
+    parsed.description = optional_text(entry, "description", site)?;
+    parsed.type_enforcement = shape.type_enforcement;
+    parsed.contract = shape.contract;
+    parsed.meta = optional_mapping(entry, "meta", site)?;
+    parsed.columns = shape.columns;
+    parsed.audits = parse_audit_list(get(entry, "audits"), path, "source", false)?;
+    Ok(parsed)
+}
+
+fn write_strategy<N: AuthoredNode>(
+    entry: &[(N, N)],
+    site: Site<'_>,
+) -> Result<Option<&'static str>, ConfigError> {
+    let Some(text) = optional_text(entry, "write_strategy", site)?.and_then(|node| node.text())
+    else {
+        return Ok(None);
+    };
+    WRITE_STRATEGIES
+        .iter()
+        .copied()
+        .find(|strategy| *strategy == text)
+        .map(Some)
+        .ok_or_else(|| {
+            site.error(&format!(
+                "write_strategy must be one of: {}",
+                WRITE_STRATEGIES.join(", ")
+            ))
+        })
+}
+
+fn positive_int<N: AuthoredNode>(
+    entry: &[(N, N)],
+    key: &str,
+    path: &str,
+) -> Result<Option<N>, ConfigError> {
+    let Some(value) = get(entry, key).filter(|value| value.kind() != NodeKind::Null) else {
+        return Ok(None);
+    };
+    match value.kind() {
+        NodeKind::Int { negative: false } if value.integer().is_none_or(|amount| amount != 0) => {
+            Ok(Some(value.clone()))
+        }
+        _ => Err(ConfigError::compile(format!(
+            "{path} source '{key}' must be a positive integer"
+        ))),
+    }
+}
+
+fn unique_key<N: AuthoredNode>(entry: &[(N, N)], path: &str) -> Result<Vec<String>, ConfigError> {
+    let error = |text: &str| ConfigError::compile(format!("{path} source 'unique_key' {text}"));
+    let Some(value) = get(entry, "unique_key").filter(|value| value.kind() != NodeKind::Null)
+    else {
+        return Ok(Vec::new());
+    };
+    let keys: Vec<String> = stripped_strings(value, error)?;
+    if keys.is_empty() {
+        return Err(error("must be non-empty"));
+    }
+    Ok(keys)
+}
+
+/// `_validate_source_entry`.
+fn validate_source<N: AuthoredNode>(
+    entry: &ParsedSourceEntry<N>,
+    name: &str,
+    path: &str,
+) -> Result<(), ConfigError> {
+    let error = |text: &str| ConfigError::compile(format!("{path} source '{name}' {text}"));
+    let relation_keys: Vec<&str> = [
+        ("database", &entry.database),
+        ("schema", &entry.schema),
+        ("table", &entry.table),
+    ]
+    .into_iter()
+    .filter(|(_, value)| value.is_some())
+    .map(|(key, _)| key)
+    .collect();
+    if entry.expression.is_some() && !relation_keys.is_empty() {
+        return Err(error(&format!(
+            "cannot define expression with {}",
+            relation_keys.join(", ")
+        )));
+    }
+    if entry.expression.is_some()
+        && entry.type_enforcement == Some(true)
+        && !entry
+            .columns
+            .iter()
+            .any(|column| column.column_type.is_some())
+    {
+        return Err(error(
+            "uses expression with type_enforcement but has no typed columns",
+        ));
+    }
+    if let Some(integration) = &entry.integration_loader {
+        let kind: &str = integration.kind();
+        if entry.loader.as_deref() != Some(integration_loader_name(kind, name).as_str()) {
+            return Err(error(&format!("cannot override loader for {kind}")));
+        }
+        if entry.write_strategy.is_some() {
+            return Err(error(&format!("cannot define write_strategy with {kind}")));
+        }
+    }
+    let strategy: Option<&str> = entry.write_strategy;
+    let has_unique_key: bool = !entry.unique_key.is_empty();
+    let has_cursor: bool = entry.cursor_column.is_some();
+    if strategy.is_some() && entry.loader.is_none() {
+        return Err(error("defines write_strategy but is not managed"));
+    }
+    if strategy == Some(APPEND) && has_unique_key {
+        return Err(error(
+            "unique_key is not supported with write_strategy append",
+        ));
+    }
+    if strategy == Some(MERGE) && !has_unique_key {
+        return Err(error("write_strategy merge requires unique_key"));
+    }
+    if strategy == Some(TABLE) && has_cursor {
+        return Err(error(
+            "cursor_column is not supported with write_strategy table",
+        ));
+    }
+    if strategy == Some(TABLE) && has_unique_key {
+        return Err(error(
+            "unique_key is not supported with write_strategy table",
+        ));
+    }
+    if strategy == Some(DELETE_INSERT) && !has_cursor {
+        return Err(error("write_strategy delete_insert requires cursor_column"));
+    }
+    if strategy == Some(DELETE_INSERT) && has_unique_key {
+        return Err(error(
+            "unique_key is not supported with write_strategy delete_insert",
+        ));
+    }
+    if has_cursor && !matches!(strategy, Some(APPEND | DELETE_INSERT | MERGE)) {
+        return Err(error(
+            "cursor_column requires write_strategy append, delete_insert, or merge",
+        ));
+    }
+    if has_unique_key && strategy != Some(MERGE) {
+        return Err(error("unique_key requires write_strategy merge"));
+    }
+    Ok(())
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/constants.rs b/crates/sqlbuild-discovery/src/yaml_entries/constants.rs
new file mode 100644
index 0000000000..185f6b92f3
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/constants.rs
@@ -0,0 +1,6 @@
+//! The top-level keys of source and schema YAML documents.
+
+/// The keys a schema YAML file under `seeds/` may declare.
+pub(crate) const SEED_FILE_KEYS: [&str; 1] = ["seeds"];
+/// The keys a sources YAML file may declare.
+pub(crate) const SOURCE_FILE_KEYS: [&str; 2] = ["sources", "dlt_sources"];
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/main/mod.rs b/crates/sqlbuild-discovery/src/yaml_entries/main/mod.rs
new file mode 100644
index 0000000000..cb3f72f7bd
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/main/mod.rs
@@ -0,0 +1,2 @@
+pub mod parse_schema_document;
+pub mod parse_sources_document;
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/main/parse_schema_document.rs b/crates/sqlbuild-discovery/src/yaml_entries/main/parse_schema_document.rs
new file mode 100644
index 0000000000..b43b787b86
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/main/parse_schema_document.rs
@@ -0,0 +1,60 @@
+//! Python's `parse_loaded_schema_yml`: the seed declarations of one loaded schema YAML file.
+
+use sqlbuild_model_config::errors::ConfigError;
+use sqlbuild_model_config::types::{AuthoredNode, NodeKind};
+
+use crate::yaml_entries::_helpers::fields::{Site, get, reject_unknown_keys, truthy};
+use crate::yaml_entries::_helpers::seeds::{mapping_list, seed_entry};
+use crate::yaml_entries::constants::SEED_FILE_KEYS;
+use crate::yaml_entries::models::ParsedSeedEntry;
+
+/// Parse a loaded schema document; `in_seeds_directory` is whether `seeds` is among the path's parts.
+pub fn parse_schema_document<N: AuthoredNode>(
+    loaded: &N,
+    path: &str,
+    in_seeds_directory: bool,
+) -> Result<Vec<ParsedSeedEntry<N>>, ConfigError> {
+    let entries: Vec<(N, N)> = match loaded.kind() {
+        NodeKind::Null => Vec::new(),
+        NodeKind::Map => loaded.entries(),
+        _ => {
+            return Err(ConfigError::compile(format!(
+                "{path} must contain a top-level mapping"
+            )));
+        }
+    };
+    let file: Site<'_> = Site { path, label: "" };
+    if let Some(models) = get(&entries, "models") {
+        if truthy(models) {
+            return Err(ConfigError::compile(format!(
+                "{path} declares model metadata in 'models', but model metadata must live in the \
+                 model file MODEL(...). Move description, columns, and audits into the model \
+                 header."
+            )));
+        }
+        mapping_list(models, path, "models")?;
+    }
+    let seeds: Option<&N> = get(&entries, "seeds");
+    if seeds.is_some_and(truthy) && !in_seeds_directory {
+        return Err(ConfigError::compile(format!(
+            "{path} declares seeds, but seed declarations must live under seeds/**/*.yml"
+        )));
+    }
+    if in_seeds_directory {
+        reject_unknown_keys(
+            &entries,
+            &SEED_FILE_KEYS,
+            Site {
+                label: "seed file",
+                ..file
+            },
+        )?;
+    }
+    let Some(seeds) = seeds else {
+        return Ok(Vec::new());
+    };
+    mapping_list(seeds, path, "seeds")?
+        .iter()
+        .map(|seed| seed_entry(&seed.entries(), path))
+        .collect()
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/main/parse_sources_document.rs b/crates/sqlbuild-discovery/src/yaml_entries/main/parse_sources_document.rs
new file mode 100644
index 0000000000..d30212c6fb
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/main/parse_sources_document.rs
@@ -0,0 +1,52 @@
+//! Python's `parse_loaded_sources_yml`: the source declarations of one loaded sources YAML file.
+
+use sqlbuild_model_config::errors::ConfigError;
+use sqlbuild_model_config::types::{AuthoredNode, NodeKind};
+
+use crate::yaml_entries::_helpers::fields::{Site, get, reject_unknown_keys};
+use crate::yaml_entries::_helpers::integrations::dlt_sources;
+use crate::yaml_entries::_helpers::sources::source_entry;
+use crate::yaml_entries::constants::SOURCE_FILE_KEYS;
+use crate::yaml_entries::models::ParsedSourceEntry;
+
+/// Parse a loaded sources document: its `sources`, then the managed sources of `dlt_sources`.
+pub fn parse_sources_document<N: AuthoredNode>(
+    loaded: &N,
+    path: &str,
+) -> Result<Vec<ParsedSourceEntry<N>>, ConfigError> {
+    let payload: Vec<(N, N)> = match loaded.kind() {
+        NodeKind::Null => Vec::new(),
+        NodeKind::Map => loaded.entries(),
+        _ => {
+            return Err(ConfigError::compile(format!(
+                "{path} must contain a top-level mapping"
+            )));
+        }
+    };
+    reject_unknown_keys(
+        &payload,
+        &SOURCE_FILE_KEYS,
+        Site {
+            path,
+            label: "sources file",
+        },
+    )?;
+    let mut sources: Vec<ParsedSourceEntry<N>> = Vec::new();
+    if let Some(raw) = get(&payload, "sources") {
+        if raw.kind() != NodeKind::List {
+            return Err(ConfigError::compile(format!(
+                "{path} sources must be a list"
+            )));
+        }
+        for item in raw.items() {
+            if item.kind() != NodeKind::Map {
+                return Err(ConfigError::compile(format!(
+                    "{path} sources must contain only mappings"
+                )));
+            }
+            sources.push(source_entry(&item.entries(), path)?);
+        }
+    }
+    sources.extend(dlt_sources(&payload, path)?);
+    Ok(sources)
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/mod.rs b/crates/sqlbuild-discovery/src/yaml_entries/mod.rs
new file mode 100644
index 0000000000..1e64f3d116
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/mod.rs
@@ -0,0 +1,7 @@
+pub(crate) mod _helpers;
+pub(crate) mod constants;
+pub mod main;
+pub mod models;
+
+#[cfg(test)]
+mod tests;
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/models.rs b/crates/sqlbuild-discovery/src/yaml_entries/models.rs
new file mode 100644
index 0000000000..62ca7010ee
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/models.rs
@@ -0,0 +1,180 @@
+//! Parsed YAML declaration entries whose leaves are the caller's own authored values.
+
+use sqlbuild_model_config::header_metadata::models::ParsedAudit;
+
+/// One declared column of a seed or schema entry.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ParsedYamlColumn<N> {
+    pub name: N,
+    pub column_type: Option<N>,
+    pub nullable: Option<N>,
+    pub description: Option<N>,
+    /// The authored mapping, or `None` for Python's empty default.
+    pub meta: Option<N>,
+    pub audits: Vec<ParsedAudit<N>>,
+}
+
+/// `na_values`: one list for every column, or a list per named column.
+#[derive(Clone, Debug, PartialEq)]
+pub enum ParsedNaValues<N> {
+    List(Vec<N>),
+    PerColumn(Vec<(N, Vec<N>)>),
+}
+
+/// A seed's `csv_settings`; each field holds the authored value or `None` when unset.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ParsedCsvSettings<N> {
+    pub delimiter: Option<N>,
+    pub quotechar: Option<N>,
+    pub doublequote: Option<N>,
+    pub escapechar: Option<N>,
+    pub skipinitialspace: Option<N>,
+    pub lineterminator: Option<N>,
+    pub encoding: Option<N>,
+    pub na_values: Option<ParsedNaValues<N>>,
+    pub keep_default_na: Option<N>,
+}
+
+/// One seed declaration of a `seeds/**/*.yml` file.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ParsedSeedEntry<N> {
+    pub name: N,
+    pub description: Option<N>,
+    pub database: Option<N>,
+    pub schema: Option<N>,
+    pub meta: Option<N>,
+    pub tags: Vec<N>,
+    /// The settings, or `None` when the entry declares none.
+    pub csv_settings: Option<ParsedCsvSettings<N>>,
+    pub columns: Vec<ParsedYamlColumn<N>>,
+    pub audits: Vec<ParsedAudit<N>>,
+}
+
+/// A source freshness age policy; at least one bound is set.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ParsedAgePolicy<N> {
+    pub warn_after: Option<N>,
+    pub error_after: Option<N>,
+}
+
+/// A source's freshness config, its strategy and value kind resolved as Python stores them.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ParsedFreshness<N> {
+    /// `adapter`, `column` or `sql`.
+    pub strategy: &'static str,
+    /// `timestamp`, `integer` or `string`.
+    pub value_kind: Option<&'static str>,
+    pub column: Option<N>,
+    pub query: Option<N>,
+    pub filter: Option<N>,
+    pub lag_tolerance: Option<N>,
+    pub age_policy: Option<ParsedAgePolicy<N>>,
+}
+
+/// A source-level `ingestr` loader; key lists hold Python's stripped strings.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ParsedIngestrConfig<N> {
+    pub source_uri: N,
+    pub source_table: N,
+    pub strategy: Option<N>,
+    pub incremental_key: Option<N>,
+    pub primary_key: Vec<String>,
+    pub columns: Option<N>,
+    pub extra_args: Vec<String>,
+}
+
+/// One dlt resource as `DltResourceConfig` stores it.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ParsedDltResource<N> {
+    pub name: N,
+    pub dlt_name: N,
+    pub schema: Option<N>,
+    /// The resource entries the loader passes to dlt, in authored order.
+    pub raw_config: Vec<(N, N)>,
+    pub write_disposition: Option<N>,
+    pub primary_key: Option<N>,
+    pub merge_key: Option<N>,
+    pub incremental: Option<N>,
+}
+
+/// A dlt source group's settings shared by the source entry of each resource.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ParsedDltSource<N> {
+    pub source_type: N,
+    pub schema: Option<N>,
+    pub config: N,
+    /// The destination mapping, or `None` for Python's empty default.
+    pub destination: Option<N>,
+    pub resource: ParsedDltResource<N>,
+    pub group_index: usize,
+}
+
+/// The declarative integration loader a source is managed by.
+#[derive(Clone, Debug, PartialEq)]
+pub enum ParsedIntegrationLoader<N> {
+    Ingestr(ParsedIngestrConfig<N>),
+    Dlt(Box<ParsedDltSource<N>>),
+}
+
+impl<N> ParsedIntegrationLoader<N> {
+    /// The loader kind `IntegrationLoaderConfig` records.
+    pub fn kind(&self) -> &'static str {
+        match self {
+            Self::Ingestr(_) => "ingestr",
+            Self::Dlt(_) => "dlt",
+        }
+    }
+}
+
+/// One source declaration of a `sources/*.yml` file.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ParsedSourceEntry<N> {
+    pub name: N,
+    pub database: Option<N>,
+    pub schema: Option<N>,
+    pub table: Option<N>,
+    pub loader: Option<String>,
+    pub managed: bool,
+    pub integration_loader: Option<ParsedIntegrationLoader<N>>,
+    pub freshness: Option<ParsedFreshness<N>>,
+    /// `append`, `delete_insert`, `merge` or `table`.
+    pub write_strategy: Option<&'static str>,
+    pub load_batch_size: Option<N>,
+    pub cursor_column: Option<N>,
+    pub unique_key: Vec<String>,
+    pub expression: Option<N>,
+    pub description: Option<N>,
+    /// The authored flag, or `True` implied by typed columns.
+    pub type_enforcement: Option<bool>,
+    pub contract: Option<N>,
+    pub meta: Option<N>,
+    pub columns: Vec<ParsedYamlColumn<N>>,
+    pub audits: Vec<ParsedAudit<N>>,
+}
+
+impl<N> ParsedSourceEntry<N> {
+    /// A source entry with only its name set, as Python's `SourceEntry` defaults.
+    pub fn named(name: N) -> Self {
+        Self {
+            name,
+            database: None,
+            schema: None,
+            table: None,
+            loader: None,
+            managed: false,
+            integration_loader: None,
+            freshness: None,
+            write_strategy: None,
+            load_batch_size: None,
+            cursor_column: None,
+            unique_key: Vec::new(),
+            expression: None,
+            description: None,
+            type_enforcement: None,
+            contract: None,
+            meta: None,
+            columns: Vec::new(),
+            audits: Vec::new(),
+        }
+    }
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/tests.rs b/crates/sqlbuild-discovery/src/yaml_entries/tests.rs
new file mode 100644
index 0000000000..50a8d8238a
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/tests.rs
@@ -0,0 +1,8 @@
+#[path = "tests/helpers.rs"]
+mod helpers;
+#[path = "tests/test_parse_schema_document.rs"]
+mod parse_schema_document;
+#[path = "tests/test_parse_sources_document.rs"]
+mod parse_sources_document;
+#[path = "tests/test_types.rs"]
+mod test_types;
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/tests/helpers.rs b/crates/sqlbuild-discovery/src/yaml_entries/tests/helpers.rs
new file mode 100644
index 0000000000..ef1080e235
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/tests/helpers.rs
@@ -0,0 +1,90 @@
+use sqlbuild_model_config::types::AuthoredNode;
+
+use crate::yaml_entries::main::parse_schema_document::parse_schema_document;
+use crate::yaml_entries::main::parse_sources_document::parse_sources_document;
+use crate::yaml_entries::models::{ParsedSeedEntry, ParsedSourceEntry};
+use crate::yaml_entries::tests::test_types::Node;
+
+pub(super) const SCHEMA_PATH: &str = "/project/seeds/countries.yml";
+pub(super) const SOURCES_PATH: &str = "/project/sources/shop.yml";
+
+pub(super) fn text(value: &str) -> Node {
+    Node::Str(value.to_owned())
+}
+
+pub(super) fn map(entries: Vec<(&str, Node)>) -> Node {
+    Node::Map(
+        entries
+            .into_iter()
+            .map(|(key, value)| (text(key), value))
+            .collect(),
+    )
+}
+
+/// A schema document declaring one `countries` seed with `columns` and extra keys.
+pub(super) fn seed(columns: Vec<Node>, extra: Vec<(&str, Node)>) -> Node {
+    let mut entries: Vec<(&str, Node)> = vec![
+        ("name", text("countries")),
+        ("columns", Node::List(columns)),
+    ];
+    entries.extend(extra);
+    map(vec![("seeds", Node::List(vec![map(entries)]))])
+}
+
+/// A typed column.
+pub(super) fn column(name: &str, column_type: &str) -> Node {
+    map(vec![("name", text(name)), ("type", text(column_type))])
+}
+
+/// A sources document with one entry.
+pub(super) fn sources(entry: Vec<(&str, Node)>) -> Node {
+    map(vec![("sources", Node::List(vec![map(entry)]))])
+}
+
+/// A `dlt_sources` document with one group.
+pub(super) fn dlt_group(group: Vec<(&str, Node)>) -> Node {
+    map(vec![("dlt_sources", Node::List(vec![map(group)]))])
+}
+
+fn shown(node: Option<&Node>) -> String {
+    node.map_or_else(|| "-".to_owned(), AuthoredNode::python_str)
+}
+
+fn seed_line(seed: &ParsedSeedEntry<Node>) -> String {
+    let tags: Vec<String> = seed.tags.iter().map(AuthoredNode::python_str).collect();
+    format!(
+        "{} columns={} tags={} csv_settings={}",
+        seed.name.python_str(),
+        seed.columns.len(),
+        tags.join(","),
+        seed.csv_settings.is_some()
+    )
+}
+
+fn source_line(source: &ParsedSourceEntry<Node>) -> String {
+    format!(
+        "{} loader={} managed={} schema={} table={}",
+        source.name.python_str(),
+        source.loader.as_deref().unwrap_or("-"),
+        source.managed,
+        shown(source.schema.as_ref()),
+        shown(source.table.as_ref())
+    )
+}
+
+/// One line per parsed seed, or the parse error's message.
+pub(super) fn schema_outcome(
+    document: &Node,
+    in_seeds_directory: bool,
+) -> Result<Vec<String>, String> {
+    parse_schema_document(document, SCHEMA_PATH, in_seeds_directory)
+        .map(|seeds| seeds.iter().map(seed_line).collect())
+        .map_err(|error| error.message)
+}
+
+/// One line per parsed source, or the parse error's message.
+pub(super) fn sources_outcome(document: &Node) -> Result<Vec<String>, String> {
+    parse_sources_document(document, SOURCES_PATH)
+        .map(|sources| sources.iter().map(source_line).collect())
+        .map_err(|error| error.message)
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/tests/test_parse_schema_document.rs b/crates/sqlbuild-discovery/src/yaml_entries/tests/test_parse_schema_document.rs
new file mode 100644
index 0000000000..2e595925c1
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/tests/test_parse_schema_document.rs
@@ -0,0 +1,94 @@
+use crate::yaml_entries::tests::helpers::{column, map, schema_outcome, seed, text};
+use crate::yaml_entries::tests::test_types::{Node, SchemaDocumentTestCase, lines, parse_error};
+
+#[test]
+fn given_schema_documents_when_parsing_then_matches_python_seeds_and_errors() {
+    let test_cases = [
+        SchemaDocumentTestCase {
+            description: "a valid seed keeps its columns and tags",
+            document: seed(
+                vec![column("code", "VARCHAR"), column("label", "VARCHAR")],
+                vec![("tags", Node::List(vec![text("reference")]))],
+            ),
+            in_seeds_directory: true,
+            expected_seeds: lines(&["countries columns=2 tags=reference csv_settings=false"]),
+        },
+        SchemaDocumentTestCase {
+            description: "a document that is not a mapping",
+            document: Node::List(Vec::new()),
+            in_seeds_directory: true,
+            expected_seeds: parse_error(
+                "/project/seeds/countries.yml must contain a top-level mapping",
+            ),
+        },
+        SchemaDocumentTestCase {
+            description: "model metadata in YAML",
+            document: map(vec![(
+                "models",
+                Node::List(vec![map(vec![("name", text("orders"))])]),
+            )]),
+            in_seeds_directory: false,
+            expected_seeds: parse_error(
+                "/project/seeds/countries.yml declares model metadata in 'models', but model \
+                 metadata must live in the model file MODEL(...). Move description, columns, and \
+                 audits into the model header.",
+            ),
+        },
+        SchemaDocumentTestCase {
+            description: "seeds outside the seeds directory",
+            document: seed(vec![column("code", "VARCHAR")], Vec::new()),
+            in_seeds_directory: false,
+            expected_seeds: parse_error(
+                "/project/seeds/countries.yml declares seeds, but seed declarations must live \
+                 under seeds/**/*.yml",
+            ),
+        },
+        SchemaDocumentTestCase {
+            description: "a seed column without a type",
+            document: seed(vec![map(vec![("name", text("code"))])], Vec::new()),
+            in_seeds_directory: true,
+            expected_seeds: parse_error(
+                "/project/seeds/countries.yml seed column 'code' must define non-empty string 'type'",
+            ),
+        },
+        SchemaDocumentTestCase {
+            description: "null audits are not an empty list",
+            document: seed(
+                vec![column("code", "VARCHAR")],
+                vec![("audits", Node::Null)],
+            ),
+            in_seeds_directory: true,
+            expected_seeds: parse_error("/project/seeds/countries.yml seed audits must be a list"),
+        },
+        SchemaDocumentTestCase {
+            description: "an audit name Python strips to nothing",
+            document: seed(
+                vec![column("code", "VARCHAR")],
+                vec![("audits", Node::List(vec![text("\u{1f}")]))],
+            ),
+            in_seeds_directory: true,
+            expected_seeds: parse_error(
+                "/project/seeds/countries.yml seed audits must not contain empty names",
+            ),
+        },
+        SchemaDocumentTestCase {
+            description: "a non-boolean csv setting",
+            document: seed(
+                vec![column("code", "VARCHAR")],
+                vec![("csv_settings", map(vec![("doublequote", Node::Int(1))]))],
+            ),
+            in_seeds_directory: true,
+            expected_seeds: parse_error(
+                "/project/seeds/countries.yml seed csv_settings 'doublequote' must be a boolean",
+            ),
+        },
+    ];
+    for test_case in test_cases {
+        assert_eq!(
+            schema_outcome(&test_case.document, test_case.in_seeds_directory),
+            test_case.expected_seeds,
+            "{}",
+            test_case.description
+        );
+    }
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/tests/test_parse_sources_document.rs b/crates/sqlbuild-discovery/src/yaml_entries/tests/test_parse_sources_document.rs
new file mode 100644
index 0000000000..3f50cadc1c
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/tests/test_parse_sources_document.rs
@@ -0,0 +1,147 @@
+use crate::yaml_entries::_helpers::freshness::freshness_minutes;
+use crate::yaml_entries::tests::helpers::{dlt_group, map, sources, sources_outcome, text};
+use crate::yaml_entries::tests::test_types::{
+    FreshnessDurationTestCase, Node, SourcesDocumentTestCase, lines, parse_error,
+};
+
+#[test]
+fn given_sources_documents_when_parsing_then_matches_python_sources_and_errors() {
+    let test_cases = [
+        SourcesDocumentTestCase {
+            description: "a dlt resource becomes a managed source named after it",
+            document: dlt_group(vec![
+                ("type", text("sql_database")),
+                (
+                    "config",
+                    map(vec![("credentials", text("duckdb:///shop.db"))]),
+                ),
+                ("schema", text("raw")),
+                (
+                    "resources",
+                    Node::List(vec![map(vec![
+                        ("name", text("orders")),
+                        ("table", text("orders_v1")),
+                    ])]),
+                ),
+            ]),
+            expected_sources: lines(&["orders loader=orders managed=true schema=raw table=orders"]),
+        },
+        SourcesDocumentTestCase {
+            description: "merge without a unique key",
+            document: sources(vec![
+                ("name", text("orders")),
+                ("managed", Node::Bool(true)),
+                ("write_strategy", text("merge")),
+            ]),
+            expected_sources: parse_error(
+                "/project/sources/shop.yml source 'orders' write_strategy merge requires unique_key",
+            ),
+        },
+        SourcesDocumentTestCase {
+            description: "a write strategy on an unmanaged source",
+            document: sources(vec![
+                ("name", text("orders")),
+                ("write_strategy", text("append")),
+            ]),
+            expected_sources: parse_error(
+                "/project/sources/shop.yml source 'orders' defines write_strategy but is not managed",
+            ),
+        },
+        SourcesDocumentTestCase {
+            description: "the removed loader key",
+            document: sources(vec![
+                ("name", text("orders")),
+                ("loader", text("load_orders")),
+            ]),
+            expected_sources: parse_error(
+                "/project/sources/shop.yml source 'loader' is not supported; use managed: true \
+                 and name the terminal loader after the source",
+            ),
+        },
+        SourcesDocumentTestCase {
+            description: "freshness type without column or query",
+            document: sources(vec![
+                ("name", text("orders")),
+                ("freshness", map(vec![("type", text("timestamp"))])),
+            ]),
+            expected_sources: parse_error(
+                "/project/sources/shop.yml source freshness type and filter require column or query",
+            ),
+        },
+        SourcesDocumentTestCase {
+            description: "a dlt resource with write_strategy",
+            document: dlt_group(vec![
+                ("type", text("filesystem")),
+                ("config", map(vec![("bucket_url", text("s3://orders"))])),
+                (
+                    "resources",
+                    Node::List(vec![map(vec![
+                        ("name", text("orders")),
+                        ("write_strategy", text("append")),
+                    ])]),
+                ),
+            ]),
+            expected_sources: parse_error(
+                "/project/sources/shop.yml dlt resource 'orders' must use dlt write_disposition, \
+                 not write_strategy",
+            ),
+        },
+    ];
+    for test_case in test_cases {
+        assert_eq!(
+            sources_outcome(&test_case.document),
+            test_case.expected_sources,
+            "{}",
+            test_case.description
+        );
+    }
+}
+
+#[test]
+fn given_freshness_durations_when_measuring_then_matches_python_duration_rules() {
+    let test_cases = [
+        FreshnessDurationTestCase {
+            description: "minutes",
+            text: "15m",
+            expected_minutes: Some(15),
+        },
+        FreshnessDurationTestCase {
+            description: "hours",
+            text: "2h",
+            expected_minutes: Some(120),
+        },
+        FreshnessDurationTestCase {
+            description: "days",
+            text: "1d",
+            expected_minutes: Some(1_440),
+        },
+        FreshnessDurationTestCase {
+            description: "two units",
+            text: "1d2h",
+            expected_minutes: None,
+        },
+        FreshnessDurationTestCase {
+            description: "seconds",
+            text: "30s",
+            expected_minutes: None,
+        },
+        FreshnessDurationTestCase {
+            description: "zero",
+            text: "0m",
+            expected_minutes: None,
+        },
+        FreshnessDurationTestCase {
+            description: "non-ASCII decimal digits",
+            text: "\u{0661}\u{0665}m",
+            expected_minutes: Some(15),
+        },
+    ];
+    for test_case in test_cases {
+        assert_eq!(
+            freshness_minutes(test_case.text),
+            test_case.expected_minutes,
+            "{}",
+            test_case.description
+        );
+    }
+}
diff --git a/crates/sqlbuild-discovery/src/yaml_entries/tests/test_types.rs b/crates/sqlbuild-discovery/src/yaml_entries/tests/test_types.rs
new file mode 100644
index 0000000000..6dee706e7b
--- /dev/null
+++ b/crates/sqlbuild-discovery/src/yaml_entries/tests/test_types.rs
@@ -0,0 +1,121 @@
+use sqlbuild_model_config::types::{AuthoredNode, NodeKind};
+
+/// An authored value tree standing in for the Python objects a loaded YAML document holds.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) enum Node {
+    Null,
+    Bool(bool),
+    Int(i64),
+    Str(String),
+    List(Vec<Node>),
+    Map(Vec<(Node, Node)>),
+}
+
+impl AuthoredNode for Node {
+    fn kind(&self) -> NodeKind {
+        match self {
+            Self::Null => NodeKind::Null,
+            Self::Bool(value) => NodeKind::Bool(*value),
+            Self::Int(value) => NodeKind::Int {
+                negative: *value < 0,
+            },
+            Self::Str(_) => NodeKind::Str,
+            Self::List(_) => NodeKind::List,
+            Self::Map(_) => NodeKind::Map,
+        }
+    }
+
+    fn integer(&self) -> Option<i64> {
+        match self {
+            Self::Int(value) => Some(*value),
+            _ => None,
+        }
+    }
+
+    fn number(&self) -> Option<f64> {
+        self.integer().map(|value| value as f64)
+    }
+
+    fn text(&self) -> Option<String> {
+        match self {
+            Self::Str(value) => Some(value.clone()),
+            _ => None,
+        }
+    }
+
+    fn is_text(&self, text: &str) -> bool {
+        matches!(self, Self::Str(value) if value == text)
+    }
+
+    fn with_text<R>(&self, read: impl FnOnce(&str) -> R) -> Option<R> {
+        match self {
+            Self::Str(value) => Some(read(value)),
+            _ => None,
+        }
+    }
+
+    fn python_str(&self) -> String {
+        match self {
+            Self::Null => "None".to_owned(),
+            Self::Bool(true) => "True".to_owned(),
+            Self::Bool(false) => "False".to_owned(),
+            Self::Int(value) => value.to_string(),
+            Self::Str(value) => value.clone(),
+            other => format!("{other:?}"),
+        }
+    }
+
+    fn python_repr(&self) -> String {
+        self.python_str()
+    }
+
+    fn is_date_like(&self) -> bool {
+        false
+    }
+
+    fn items(&self) -> Vec<Self> {
+        match self {
+            Self::List(items) => items.clone(),
+            _ => Vec::new(),
+        }
+    }
+
+    fn entries(&self) -> Vec<(Self, Self)> {
+        match self {
+            Self::Map(entries) => entries.clone(),
+            _ => Vec::new(),
+        }
+    }
+}
+
+/// One loaded schema document and its seeds or the first parse error.
+pub(super) struct SchemaDocumentTestCase {
+    pub(super) description: &'static str,
+    pub(super) document: Node,
+    pub(super) in_seeds_directory: bool,
+    pub(super) expected_seeds: Result<Vec<String>, String>,
+}
+
+/// One loaded sources document and its sources or the first parse error.
+pub(super) struct SourcesDocumentTestCase {
+    pub(super) description: &'static str,
+    pub(super) document: Node,
+    pub(super) expected_sources: Result<Vec<String>, String>,
+}
+
+/// One freshness duration and its whole minutes, `None` when Python rejects it.
+pub(super) struct FreshnessDurationTestCase {
+    pub(super) description: &'static str,
+    pub(super) text: &'static str,
+    pub(super) expected_minutes: Option<u128>,
+}
+
+/// The summary lines a parse returns.
+pub(super) fn lines(lines: &[&str]) -> Result<Vec<String>, String> {
+    Ok(lines.iter().map(|line| (*line).to_owned()).collect())
+}
+
+/// The parse error message.
+pub(super) fn parse_error(message: &str) -> Result<Vec<String>, String> {
+    Err(message.to_owned())
+}
diff --git a/crates/sqlbuild-model-config/src/header_metadata/_helpers/text.rs b/crates/sqlbuild-model-config/src/header_metadata/_helpers/text.rs
index 1183ecc3f4..17528ee610 100644
--- a/crates/sqlbuild-model-config/src/header_metadata/_helpers/text.rs
+++ b/crates/sqlbuild-model-config/src/header_metadata/_helpers/text.rs
@@ -2,6 +2,8 @@
 
 use crate::model_validation::constants::SETTING_SNIPPET_INDENT;
 
+use sqlbuild_core::text::main::python_strip::python_strip;
+
 use crate::errors::ConfigError;
 use crate::types::{AuthoredNode, NodeKind};
 
@@ -23,7 +25,7 @@ impl Site<'_> {
 
 /// Return the text of a string whose `strip()` Python finds non-empty, `None` otherwise.
 pub(crate) fn non_blank_text<N: AuthoredNode>(node: &N) -> Option<String> {
-    node.text().filter(|text| !str::trim(text).is_empty())
+    node.text().filter(|text| !python_strip(text).is_empty())
 }
 
 /// Read `optional_named_string`: `None`, or a string `strip()` finds non-empty.
diff --git a/crates/sqlbuild-model-config/src/header_metadata/main/mod.rs b/crates/sqlbuild-model-config/src/header_metadata/main/mod.rs
index 91f6ab14fa..1bda607544 100644
--- a/crates/sqlbuild-model-config/src/header_metadata/main/mod.rs
+++ b/crates/sqlbuild-model-config/src/header_metadata/main/mod.rs
@@ -1,5 +1,6 @@
 pub mod audit_factory_references;
 pub mod merged_audit_identities;
+pub mod parse_audit_list;
 pub mod parse_dynamic_columns;
 pub mod parse_header_metadata;
 pub mod parse_measurement_policy;
diff --git a/crates/sqlbuild-model-config/src/header_metadata/main/parse_audit_list.rs b/crates/sqlbuild-model-config/src/header_metadata/main/parse_audit_list.rs
new file mode 100644
index 0000000000..d3fb496993
--- /dev/null
+++ b/crates/sqlbuild-model-config/src/header_metadata/main/parse_audit_list.rs
@@ -0,0 +1,28 @@
+//! `parse_audit_instances`: an authored audit list, with or without null read as empty.
+
+use crate::errors::ConfigError;
+use crate::header_metadata::_helpers::audits::audit_list;
+use crate::header_metadata::_helpers::text::Site;
+use crate::header_metadata::models::ParsedAudit;
+use crate::types::{AuthoredNode, NodeKind};
+
+/// Parse the audits `label` declares in the file at `path`; null is empty only when asked.
+pub fn parse_audit_list<N: AuthoredNode>(
+    audits: Option<&N>,
+    path: &str,
+    label: &str,
+    null_as_empty: bool,
+) -> Result<Vec<ParsedAudit<N>>, ConfigError> {
+    let site: Site<'_> = Site {
+        path,
+        label,
+        column: None,
+    };
+    match audits {
+        None => Ok(Vec::new()),
+        Some(node) if node.kind() == NodeKind::Null && !null_as_empty => {
+            Err(site.error("audits must be a list"))
+        }
+        Some(node) => audit_list(node, site),
+    }
+}
diff --git a/crates/sqlbuild-model-config/src/path_defaults/main/matched_path_default_keys.rs b/crates/sqlbuild-model-config/src/path_defaults/main/matched_path_default_keys.rs
new file mode 100644
index 0000000000..73afea3a66
--- /dev/null
+++ b/crates/sqlbuild-model-config/src/path_defaults/main/matched_path_default_keys.rs
@@ -0,0 +1,32 @@
+//! `select_path_default(...).matched_keys`: every key matching a model path, sorted.
+
+use crate::errors::ConfigError;
+use crate::path_defaults::_helpers::matching::matches_prefix;
+use crate::path_defaults::constants::MODELS_PREFIX;
+use crate::path_defaults::main::select_path_default::select_path_default;
+use crate::path_defaults::models::PathDefaultChoice;
+
+/// The sorted keys matching `model_path`, or the conflict selecting among them raises.
+pub fn matched_path_default_keys(
+    model_path: &str,
+    keys: &[String],
+) -> Result<Vec<String>, ConfigError> {
+    if let PathDefaultChoice::Conflict(error) = select_path_default(model_path, keys) {
+        return Err(error);
+    }
+    let normalized: String = model_path.replace('\\', "/");
+    let normalized: &str = normalized
+        .strip_prefix(MODELS_PREFIX)
+        .unwrap_or(&normalized);
+    let path_parts: Vec<&str> = normalized
+        .split('/')
+        .filter(|part| !part.is_empty())
+        .collect();
+    let mut matched: Vec<String> = keys
+        .iter()
+        .filter(|key| matches_prefix(&path_parts, key))
+        .cloned()
+        .collect();
+    matched.sort();
+    Ok(matched)
+}
diff --git a/crates/sqlbuild-model-config/src/path_defaults/main/mod.rs b/crates/sqlbuild-model-config/src/path_defaults/main/mod.rs
index ac0e1e3b10..775de8bc48 100644
--- a/crates/sqlbuild-model-config/src/path_defaults/main/mod.rs
+++ b/crates/sqlbuild-model-config/src/path_defaults/main/mod.rs
@@ -1 +1,2 @@
+pub mod matched_path_default_keys;
 pub mod select_path_default;
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/compiled_project/model_loop.rs b/crates/sqlbuild-python/src/bindings/_helpers/compiled_project/model_loop.rs
index c19639c182..49237456cb 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/compiled_project/model_loop.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/compiled_project/model_loop.rs
@@ -19,8 +19,8 @@ use crate::bindings::_helpers::compiled_project::model_loop_hooks::{
     ExpandedHooks, HookModel, SqlHookClasses, expanded_hooks,
 };
 use crate::bindings::_helpers::compiled_project::model_loop_host::{
-    FinishedModel, InterpolationRow, ModelLoopRow, RecordClasses, RecordInputs, ReferenceRow,
-    finished_record,
+    FinishedModel, InterpolationRow, ModelLoopInput, ModelLoopRow, ModelPaths, RecordClasses,
+    RecordInputs, ReferenceRow, finished_record,
 };
 use crate::bindings::_helpers::compiled_project::model_loop_inputs::{
     analysis_override, hook_presence, reference_row,
@@ -54,6 +54,7 @@ use crate::bindings::_helpers::compiled_project::source_views::{
 use crate::bindings::_helpers::compiled_project::sql_test_loop::{
     AttachedSqlTests, SqlTestSettings, TestFileRow, TestScope,
 };
+use crate::bindings::_helpers::discovery::model_file_record::NativeModelFile;
 use crate::bindings::_helpers::model_config::header_metadata::ContractClasses;
 use crate::bindings::_helpers::model_config::model_validator::NativeModelValidator;
 use crate::bindings::_helpers::render::declaration_expansion::{
@@ -241,9 +242,13 @@ impl NativeModelLoop {
         slf: &Bound<'py, Self>,
         project: Bound<'py, NativeCompiledProject>,
         host: Bound<'py, PyAny>,
-        models: Vec<ModelLoopRow>,
+        models: Vec<ModelLoopInput>,
     ) -> PyResult<Vec<Bound<'py, NativeModelInput>>> {
         let py: Python<'py> = slf.py();
+        let models: Vec<ModelLoopRow> = models
+            .into_iter()
+            .map(|input| ModelLoopRow::new(py, input))
+            .collect::<PyResult<_>>()?;
         project
             .borrow_mut()
             .keep_attachment_loop(slf.clone().unbind(), host.clone().unbind());
@@ -274,18 +279,27 @@ impl NativeModelLoop {
         let visibility: ModelVisibility<'py> = ModelVisibility::default();
         let signatures: HookSignatures = HookSignatures::default();
         for row in models {
-            let ModelLoopRow((name, _, relative_path, file_path), header, _, _, _, _, _) = &row;
-            let (_, header_values, enums, constants) = header;
+            let ModelPaths {
+                name,
+                relative_path,
+                file_path,
+                ..
+            } = &row.paths;
+            let record: &NativeModelFile = row.model_file.get();
+            let (enums, constants) = record.declaration_tuples(py);
             let visible: VisibleDeclarations<'py> = visibility.for_model(
                 &context,
                 &VisibilityModel {
                     name,
                     file_path,
-                    local: (enums.bind(py), constants.bind(py)),
+                    local: (enums.as_any(), constants.as_any()),
                 },
             )?;
-            let config: Bound<'py, PyAny> =
-                configs.effective(&context, header_values.bind(py), (name, relative_path))?;
+            let config: Bound<'py, PyAny> = configs.effective(
+                &context,
+                record.header_value_dict(py),
+                (name, relative_path),
+            )?;
             let model: LoopModel<'_, 'py> = LoopModel {
                 row: &row,
                 config,
@@ -454,15 +468,20 @@ impl NativeModelLoop {
             signatures,
             visibility,
         } = model;
-        let ModelLoopRow(
-            (name, posix_path, relative_path, file_path),
-            (locations, _, _, _),
+        let ModelLoopRow {
+            paths:
+                ModelPaths {
+                    name,
+                    posix_path,
+                    relative_path,
+                    file_path,
+                },
             authored_query,
             contents,
             scan,
             interpolation,
-            _,
-        ) = row;
+            model_file,
+        } = row;
         let values: Bound<'py, PyDict> = config.getattr(VALUES_ATTRIBUTE)?.downcast_into()?;
         let schema: Option<ModelSchema<'py>> = model_schema(context, &values, name)?;
         let hooked: bool = hook_presence(&values)?;
@@ -620,7 +639,7 @@ impl NativeModelLoop {
         let source: HeaderSource<'_, 'py> = HeaderSource {
             name,
             values: &values,
-            locations: locations.bind(py),
+            model_file: model_file.get(),
             relative_path,
             visible: (&visible.declarations, &visible.consumer),
             schema: schema.as_ref(),
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/compiled_project/model_loop_header.rs b/crates/sqlbuild-python/src/bindings/_helpers/compiled_project/model_loop_header.rs
index b21ececf28..dc7a179449 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/compiled_project/model_loop_header.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/compiled_project/model_loop_header.rs
@@ -21,6 +21,7 @@ use crate::bindings::_helpers::compiled_project::model_loop_schema::{
     ModelSchema, merged_columns, schema_enums,
 };
 use crate::bindings::_helpers::compiled_project::project::schema_fact;
+use crate::bindings::_helpers::discovery::model_file_record::NativeModelFile;
 use crate::bindings::_helpers::model_config::authored_nodes::PyNode;
 use crate::bindings::_helpers::model_config::column_migrations::column_migration_error;
 use crate::bindings::_helpers::model_config::config_errors::native_config_error;
@@ -41,7 +42,7 @@ const ENUMS_FIELD: &str = "enums";
 pub(crate) struct HeaderSource<'a, 'py> {
     pub(crate) name: &'a str,
     pub(crate) values: &'a Bound<'py, PyDict>,
-    pub(crate) locations: &'a Bound<'py, PyDict>,
+    pub(crate) model_file: &'a NativeModelFile,
     pub(crate) relative_path: &'a str,
     /// The model's visible declarations and the identity its usages are recorded for.
     pub(crate) visible: (&'a Bound<'py, PyAny>, &'a Bound<'py, PyAny>),
@@ -99,8 +100,12 @@ pub(crate) fn header_schema<'py>(
     let parsed_columns = metadata
         .columns
         .map_err(|error| raised_config_error(py, context, error))?;
-    let local_columns: Bound<'py, PyTuple> =
-        column_tuple(py, context.contracts, &parsed_columns, source.locations)?;
+    let local_columns: Bound<'py, PyTuple> = column_tuple(
+        py,
+        context.contracts,
+        &parsed_columns,
+        &source.model_file.header_locations(py)?,
+    )?;
     let columns: Bound<'py, PyTuple> = match source.schema {
         Some(schema) => merged_columns(context, schema, &local_columns, model)?,
         None => local_columns,
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/compiled_project/model_loop_host.rs b/crates/sqlbuild-python/src/bindings/_helpers/compiled_project/model_loop_host.rs
index 5d4cc109a3..55a54a0bcb 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/compiled_project/model_loop_host.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/compiled_project/model_loop_host.rs
@@ -21,6 +21,7 @@ use crate::bindings::_helpers::compiled_project::project::{
 use crate::bindings::_helpers::compiled_project::project::{
     DeclarationPy, config_values, declarations,
 };
+use crate::bindings::_helpers::discovery::model_file_record::NativeModelFile;
 use crate::bindings::_helpers::render::declaration_expansion::{
     ExpandedDeclarations, ScannedReference, span_rows,
 };
@@ -35,21 +36,59 @@ const CONSTANTS_ARGUMENT: &str = "constants";
 const LOCAL_ENUMS_ATTRIBUTE: &str = "local_enums";
 const LOCAL_CONSTANTS_ATTRIBUTE: &str = "local_constants";
 const NAME_ATTRIBUTE: &str = "name";
+const STEM_ATTRIBUTE: &str = "stem";
+const AS_POSIX_METHOD: &str = "as_posix";
 
-/// `((name, POSIX path, relative path, file path), column locations, query, contents, scan)`.
-#[derive(FromPyObject)]
-pub(crate) struct ModelLoopRow(
-    pub(crate) (String, String, String, String),
-    /// Header column locations, header values, and the model's own enums and constants.
-    pub(crate) (Py<PyDict>, Py<PyDict>, Py<PyAny>, Py<PyAny>),
-    pub(crate) String,
-    pub(crate) String,
-    pub(crate) Option<(Vec<ScannedReference>, Option<u8>)>,
+/// What the host hands the loop for one model: its file, declaration scan and interpolation.
+pub(crate) type ModelLoopInput = (
+    Py<NativeModelFile>,
+    Option<DeclarationScan>,
+    InterpolationRow,
+);
+/// A model's scanned declaration references and the scan's stop marker.
+pub(crate) type DeclarationScan = (Vec<ScannedReference>, Option<u8>);
+
+/// The names a model's file is known by.
+pub(crate) struct ModelPaths {
+    pub(crate) name: String,
+    pub(crate) posix_path: String,
+    pub(crate) relative_path: String,
+    pub(crate) file_path: String,
+}
+
+/// One model the loop builds: its discovered file and what the host prepared for it.
+pub(crate) struct ModelLoopRow {
+    pub(crate) paths: ModelPaths,
+    pub(crate) authored_query: String,
+    pub(crate) contents: String,
+    pub(crate) scan: Option<DeclarationScan>,
     /// The `@@`-interpolated query, its template reads, its error, and its substitution spans.
-    pub(crate) InterpolationRow,
+    pub(crate) interpolation: InterpolationRow,
     /// The discovered model file, owned by the discovery inputs.
-    pub(crate) Py<PyAny>,
-);
+    pub(crate) model_file: Py<NativeModelFile>,
+}
+
+impl ModelLoopRow {
+    pub(crate) fn new(py: Python<'_>, input: ModelLoopInput) -> PyResult<Self> {
+        let (model_file, scan, interpolation) = input;
+        let record: &NativeModelFile = model_file.get();
+        let (file_path, relative_path) = record.paths(py);
+        let (query_sql, contents) = record.texts(py);
+        Ok(Self {
+            paths: ModelPaths {
+                name: file_path.getattr(STEM_ATTRIBUTE)?.extract()?,
+                posix_path: relative_path.call_method0(AS_POSIX_METHOD)?.extract()?,
+                relative_path: relative_path.str()?.to_str()?.to_owned(),
+                file_path: file_path.str()?.to_str()?.to_owned(),
+            },
+            authored_query: query_sql.to_str()?.to_owned(),
+            contents: contents.to_str()?.to_owned(),
+            scan,
+            interpolation,
+            model_file,
+        })
+    }
+}
 /// `(interpolated query, template reads, error, substitution spans)`.
 pub(crate) type InterpolationRow = (String, Vec<(String, String)>, Option<String>, Vec<SpanRow>);
 /// `(kind, name, package, call argument count)`.
@@ -96,15 +135,19 @@ pub(crate) fn finished_record<'py>(
     finished: FinishedModel<'py>,
 ) -> PyResult<(ModelInputRecord, CompiledModelFacts)> {
     let py: Python<'py> = inputs.visible.py();
-    let ModelLoopRow(
-        (name, relative_path, _, _),
-        _,
-        authored_query_sql,
-        authored_sql,
-        _,
-        (interpolated_sql, _, _, interpolation_spans),
+    let ModelLoopRow {
+        paths:
+            ModelPaths {
+                name,
+                posix_path: relative_path,
+                ..
+            },
+        authored_query: authored_query_sql,
+        contents: authored_sql,
+        interpolation: (interpolated_sql, _, _, interpolation_spans),
         model_file,
-    ) = row;
+        ..
+    } = row;
     let stripped: Bound<'py, PyDict> = stripped_values(py, &finished.values)?;
     let mut usages: Vec<Bound<'py, PyAny>> = finished.declarations.usages;
     if let Some(schema) = &finished.header.schema {
@@ -180,11 +223,7 @@ pub(crate) fn finished_record<'py>(
         type_enforcement: schema.type_enforcement,
         model_schema: schema.model_schema.clone(),
     });
-    let discovered_query: Py<PyString> = model_file
-        .bind(py)
-        .getattr("query_sql")?
-        .downcast_into::<PyString>()?
-        .unbind();
+    let discovered_query: Py<PyString> = model_file.get().texts(py).0.clone().unbind();
     let authored: Py<PyString> = shared_sql(py, &authored_query_sql, &[&discovered_query])?;
     let macro_source: Py<PyString> =
         shared_sql(py, &finished.declarations.spliced.sql, &[&authored])?;
@@ -195,7 +234,7 @@ pub(crate) fn finished_record<'py>(
         &[&authored, &macro_source, &expanded],
     )?;
     let record: ModelInputRecord = ModelInputRecord {
-        model_file: model_file.clone_ref(py),
+        model_file: model_file.clone_ref(py).into_any(),
         config: config.unbind(),
         query_sql: query,
         macro_source_sql: macro_source,
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/discovery/header_declarations.rs b/crates/sqlbuild-python/src/bindings/_helpers/discovery/header_declarations.rs
index 06d34a6a1d..f177fcbbee 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/discovery/header_declarations.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/discovery/header_declarations.rs
@@ -114,11 +114,11 @@ fn optional_raw(
         .transpose()
 }
 
-type HeaderDeclarations<'py> = (Bound<'py, PyTuple>, Bound<'py, PyTuple>);
+pub(crate) type HeaderDeclarations<'py> = (Bound<'py, PyTuple>, Bound<'py, PyTuple>);
 
 /// `parse_model_enum_declarations` then `parse_model_constant_declarations` for one model.
 #[pyfunction]
-fn model_header_declarations<'py>(
+pub(crate) fn model_header_declarations<'py>(
     py: Python<'py>,
     header: (Option<Bound<'py, PyAny>>, Option<Bound<'py, PyAny>>),
     model_name: String,
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/discovery/mod.rs b/crates/sqlbuild-python/src/bindings/_helpers/discovery/mod.rs
index 40244e1477..99bd00951b 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/discovery/mod.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/discovery/mod.rs
@@ -3,6 +3,10 @@ pub(crate) mod globbing;
 pub(crate) mod header_declarations;
 pub(crate) mod key_checks;
 pub(crate) mod locations;
+pub(crate) mod model_file_record;
+pub(crate) mod project_facts;
 pub(crate) mod project_files;
+pub(crate) mod project_validation;
 pub(crate) mod registration;
 pub(crate) mod sql_test_blocks;
+pub(crate) mod yaml_entries;
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/discovery/model_file_record.rs b/crates/sqlbuild-python/src/bindings/_helpers/discovery/model_file_record.rs
new file mode 100644
index 0000000000..d9177933af
--- /dev/null
+++ b/crates/sqlbuild-python/src/bindings/_helpers/discovery/model_file_record.rs
@@ -0,0 +1,335 @@
+//! A discovered SQL model file as a native record whose Python attributes are built on demand.
+
+use pyo3::exceptions::PyTypeError;
+use pyo3::prelude::{Bound, Py, PyAny, PyAnyMethods, PyResult, Python};
+use pyo3::sync::PyOnceLock;
+use pyo3::types::{PyDict, PyDictMethods, PyString, PyTuple};
+use pyo3::{FromPyObject, IntoPyObjectExt, pyclass, pymethods};
+use sqlbuild_discovery::models::LineColumnSpan;
+
+const SOURCE_LOCATION_MODULE: &str = "sqlbuild.spec.contracts.models";
+const SOURCE_LOCATION_CLASS: &str = "SourceLocation";
+const FIELD_NAMES: [&str; 10] = [
+    "file_path",
+    "relative_path",
+    "contents",
+    "header_values",
+    "header_column_locations",
+    "output_column_locations",
+    "query_sql",
+    "enum_declarations",
+    "constant_declarations",
+    "extract_implicit_alias_columns",
+];
+
+/// Authored locations: native rows until Python reads them, then a cached dict.
+struct Locations {
+    rows: Vec<(String, LineColumnSpan)>,
+    projected: PyOnceLock<Py<PyDict>>,
+}
+
+impl Locations {
+    fn from_rows(rows: Vec<(String, LineColumnSpan)>) -> Self {
+        Self {
+            rows,
+            projected: PyOnceLock::new(),
+        }
+    }
+
+    /// These locations for another record: the rows, and the dict once Python has read it.
+    fn shared(&self, py: Python<'_>) -> Self {
+        let projected: PyOnceLock<Py<PyDict>> = PyOnceLock::new();
+        if let Some(dict) = self.projected.get(py) {
+            let _ = projected.set(py, dict.clone_ref(py));
+        }
+        Self {
+            rows: self.rows.clone(),
+            projected,
+        }
+    }
+
+    fn from_dict(py: Python<'_>, dict: Py<PyDict>) -> Self {
+        let projected: PyOnceLock<Py<PyDict>> = PyOnceLock::new();
+        let _ = projected.set(py, dict);
+        Self {
+            rows: Vec::new(),
+            projected,
+        }
+    }
+
+    /// Python's `{name: SourceLocation(...)}`: a repeated name keeps its first position and last value.
+    fn dict<'py>(&self, py: Python<'py>, path: &Py<PyAny>) -> PyResult<Bound<'py, PyDict>> {
+        Ok(self
+            .projected
+            .get_or_try_init(py, || {
+                let class: Bound<'py, PyAny> = py
+                    .import(SOURCE_LOCATION_MODULE)?
+                    .getattr(SOURCE_LOCATION_CLASS)?;
+                let dict: Bound<'py, PyDict> = PyDict::new(py);
+                for (name, span) in &self.rows {
+                    let location: Bound<'py, PyAny> = class.call1((
+                        path.bind(py),
+                        span.line,
+                        span.column,
+                        span.end_line,
+                        span.end_column,
+                    ))?;
+                    dict.set_item(name, location)?;
+                }
+                Ok::<_, pyo3::PyErr>(dict.unbind())
+            })?
+            .bind(py)
+            .clone())
+    }
+}
+
+/// A discovered SQL model file and its raw contents.
+#[pyclass(module = "sqlbuild._native", name = "DiscoveredSqlModelFile", frozen)]
+pub(crate) struct NativeModelFile {
+    file_path: Py<PyAny>,
+    relative_path: Py<PyAny>,
+    contents: Py<PyString>,
+    header_values: Py<PyDict>,
+    header_column_locations: Locations,
+    output_column_locations: Locations,
+    query_sql: Py<PyString>,
+    enum_declarations: Py<PyTuple>,
+    constant_declarations: Py<PyTuple>,
+    extract_implicit_alias_columns: bool,
+}
+
+/// What native discovery read for one model file, before its locations are projected.
+pub(crate) struct ModelFileParts {
+    pub(crate) file_path: Py<PyAny>,
+    pub(crate) relative_path: Py<PyAny>,
+    pub(crate) contents: Py<PyString>,
+    pub(crate) header_values: Py<PyDict>,
+    pub(crate) header_column_locations: Vec<(String, LineColumnSpan)>,
+    pub(crate) output_column_locations: Vec<(String, LineColumnSpan)>,
+    pub(crate) query_sql: Py<PyString>,
+    pub(crate) declarations: (Py<PyTuple>, Py<PyTuple>),
+    pub(crate) extract_implicit_alias_columns: bool,
+}
+
+/// The keyword fields Python constructs a model file record with.
+#[derive(FromPyObject)]
+#[pyo3(from_item_all)]
+struct ModelFileFields {
+    file_path: Py<PyAny>,
+    relative_path: Py<PyAny>,
+    contents: Py<PyString>,
+    header_values: Py<PyDict>,
+    header_column_locations: Py<PyDict>,
+    output_column_locations: Py<PyDict>,
+    query_sql: Py<PyString>,
+    #[pyo3(default)]
+    enum_declarations: Option<Py<PyTuple>>,
+    #[pyo3(default)]
+    constant_declarations: Option<Py<PyTuple>>,
+    #[pyo3(default = true)]
+    extract_implicit_alias_columns: bool,
+}
+
+impl NativeModelFile {
+    pub(crate) fn discovered(parts: ModelFileParts) -> Self {
+        let (enum_declarations, constant_declarations) = parts.declarations;
+        Self {
+            file_path: parts.file_path,
+            relative_path: parts.relative_path,
+            contents: parts.contents,
+            header_values: parts.header_values,
+            header_column_locations: Locations::from_rows(parts.header_column_locations),
+            output_column_locations: Locations::from_rows(parts.output_column_locations),
+            query_sql: parts.query_sql,
+            enum_declarations,
+            constant_declarations,
+            extract_implicit_alias_columns: parts.extract_implicit_alias_columns,
+        }
+    }
+
+    pub(crate) fn header_locations<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
+        self.header_column_locations.dict(py, &self.relative_path)
+    }
+
+    pub(crate) fn header_value_dict<'py>(&self, py: Python<'py>) -> &Bound<'py, PyDict> {
+        self.header_values.bind(py)
+    }
+
+    pub(crate) fn declaration_tuples<'py>(
+        &self,
+        py: Python<'py>,
+    ) -> (&Bound<'py, PyTuple>, &Bound<'py, PyTuple>) {
+        (
+            self.enum_declarations.bind(py),
+            self.constant_declarations.bind(py),
+        )
+    }
+
+    pub(crate) fn paths<'py>(&self, py: Python<'py>) -> (&Bound<'py, PyAny>, &Bound<'py, PyAny>) {
+        (self.file_path.bind(py), self.relative_path.bind(py))
+    }
+
+    pub(crate) fn texts<'py>(
+        &self,
+        py: Python<'py>,
+    ) -> (&Bound<'py, PyString>, &Bound<'py, PyString>) {
+        (self.query_sql.bind(py), self.contents.bind(py))
+    }
+
+    fn fields<'py>(&self, py: Python<'py>) -> PyResult<Vec<Bound<'py, PyAny>>> {
+        Ok(vec![
+            self.file_path.bind(py).clone(),
+            self.relative_path.bind(py).clone(),
+            self.contents.bind(py).clone().into_any(),
+            self.header_values.bind(py).clone().into_any(),
+            self.header_locations(py)?.into_any(),
+            self.output_column_locations
+                .dict(py, &self.relative_path)?
+                .into_any(),
+            self.query_sql.bind(py).clone().into_any(),
+            self.enum_declarations.bind(py).clone().into_any(),
+            self.constant_declarations.bind(py).clone().into_any(),
+            pyo3::types::PyBool::new(py, self.extract_implicit_alias_columns)
+                .to_owned()
+                .into_any(),
+        ])
+    }
+}
+
+#[pymethods]
+impl NativeModelFile {
+    #[new]
+    #[pyo3(signature = (**fields))]
+    fn new(py: Python<'_>, fields: Option<Bound<'_, PyDict>>) -> PyResult<Self> {
+        let Some(fields) = fields else {
+            return Err(PyTypeError::new_err(
+                "DiscoveredSqlModelFile requires its fields",
+            ));
+        };
+        for key in fields.keys() {
+            let key: String = key.extract()?;
+            if !FIELD_NAMES.contains(&key.as_str()) {
+                return Err(PyTypeError::new_err(format!(
+                    "DiscoveredSqlModelFile got an unexpected keyword argument '{key}'"
+                )));
+            }
+        }
+        let fields: ModelFileFields = fields.extract()?;
+        Ok(Self {
+            file_path: fields.file_path,
+            relative_path: fields.relative_path,
+            contents: fields.contents,
+            header_values: fields.header_values,
+            header_column_locations: Locations::from_dict(py, fields.header_column_locations),
+            output_column_locations: Locations::from_dict(py, fields.output_column_locations),
+            query_sql: fields.query_sql,
+            enum_declarations: fields
+                .enum_declarations
+                .unwrap_or_else(|| PyTuple::empty(py).unbind()),
+            constant_declarations: fields
+                .constant_declarations
+                .unwrap_or_else(|| PyTuple::empty(py).unbind()),
+            extract_implicit_alias_columns: fields.extract_implicit_alias_columns,
+        })
+    }
+
+    /// This file with edited contents and query, as `dataclasses.replace` would make it.
+    fn with_text(&self, py: Python<'_>, contents: Py<PyString>, query_sql: Py<PyString>) -> Self {
+        Self {
+            file_path: self.file_path.clone_ref(py),
+            relative_path: self.relative_path.clone_ref(py),
+            contents,
+            header_values: self.header_values.clone_ref(py),
+            header_column_locations: self.header_column_locations.shared(py),
+            output_column_locations: self.output_column_locations.shared(py),
+            query_sql,
+            enum_declarations: self.enum_declarations.clone_ref(py),
+            constant_declarations: self.constant_declarations.clone_ref(py),
+            extract_implicit_alias_columns: self.extract_implicit_alias_columns,
+        }
+    }
+
+    #[getter]
+    fn file_path(&self, py: Python<'_>) -> Py<PyAny> {
+        self.file_path.clone_ref(py)
+    }
+
+    #[getter]
+    fn relative_path(&self, py: Python<'_>) -> Py<PyAny> {
+        self.relative_path.clone_ref(py)
+    }
+
+    #[getter]
+    fn contents(&self, py: Python<'_>) -> Py<PyString> {
+        self.contents.clone_ref(py)
+    }
+
+    #[getter]
+    fn header_values(&self, py: Python<'_>) -> Py<PyDict> {
+        self.header_values.clone_ref(py)
+    }
+
+    #[getter]
+    fn header_column_locations<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
+        self.header_locations(py)
+    }
+
+    #[getter]
+    fn output_column_locations<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
+        self.output_column_locations.dict(py, &self.relative_path)
+    }
+
+    #[getter]
+    fn query_sql(&self, py: Python<'_>) -> Py<PyString> {
+        self.query_sql.clone_ref(py)
+    }
+
+    #[getter]
+    fn enum_declarations(&self, py: Python<'_>) -> Py<PyTuple> {
+        self.enum_declarations.clone_ref(py)
+    }
+
+    #[getter]
+    fn constant_declarations(&self, py: Python<'_>) -> Py<PyTuple> {
+        self.constant_declarations.clone_ref(py)
+    }
+
+    #[getter]
+    fn extract_implicit_alias_columns(&self) -> bool {
+        self.extract_implicit_alias_columns
+    }
+
+    fn __eq__(&self, py: Python<'_>, other: &Bound<'_, PyAny>) -> PyResult<Py<PyAny>> {
+        let Ok(other) = other.downcast::<NativeModelFile>() else {
+            return Ok(py.NotImplemented());
+        };
+        let other: &NativeModelFile = other.get();
+        for (left, right) in self.fields(py)?.iter().zip(other.fields(py)?) {
+            if !left.eq(right)? {
+                return false.into_py_any(py);
+            }
+        }
+        true.into_py_any(py)
+    }
+
+    fn __repr__(&self, py: Python<'_>) -> PyResult<String> {
+        let fields: Vec<String> = FIELD_NAMES
+            .iter()
+            .zip(self.fields(py)?)
+            .map(|(name, value)| Ok(format!("{name}={}", value.repr()?)))
+            .collect::<PyResult<_>>()?;
+        Ok(format!("DiscoveredSqlModelFile({})", fields.join(", ")))
+    }
+
+    /// The keyword fields `copy` and `pickle` rebuild this record from.
+    fn __getnewargs_ex__<'py>(
+        slf: &Bound<'py, Self>,
+    ) -> PyResult<(Bound<'py, PyTuple>, Bound<'py, PyDict>)> {
+        let py: Python<'py> = slf.py();
+        let keywords: Bound<'py, PyDict> = PyDict::new(py);
+        for (name, value) in FIELD_NAMES.iter().zip(slf.get().fields(py)?) {
+            keywords.set_item(name, value)?;
+        }
+        Ok((PyTuple::empty(py), keywords))
+    }
+}
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/discovery/project_facts.rs b/crates/sqlbuild-python/src/bindings/_helpers/discovery/project_facts.rs
new file mode 100644
index 0000000000..39757e7695
--- /dev/null
+++ b/crates/sqlbuild-python/src/bindings/_helpers/discovery/project_facts.rs
@@ -0,0 +1,297 @@
+//! The facts cross-file validation reads, taken from Python's `DiscoveredProjectInputs`.
+
+use pyo3::FromPyObject;
+use pyo3::exceptions::{PyTypeError, PyValueError};
+use pyo3::prelude::{Bound, PyAny, PyAnyMethods, PyResult, Python};
+use pyo3::types::{PyDict, PyDictMethods, PyTuple, PyTypeMethods};
+use sqlbuild_discovery::project_validation::errors::CsvDialectError;
+use sqlbuild_discovery::project_validation::models::{
+    AuditFileFact, CsvSettings, DependencyFact, IntegrationLoaderFact, ModelFact, NamedPath,
+    NodeFact, NodeKind, ProjectFacts, SchemaFileFact, ScopedDeclarationsFact, SeedEntryFact,
+    SeedFileFact, SourceFact, SourceFileFact, TestBlockFact, TestFileFact,
+};
+
+const CSV_MODULE: &str = "csv";
+/// `DeclarationKind.AUDIT`: a generic audit file.
+const GENERIC_AUDIT_KIND: &str = "audit";
+/// `ScopeKind.PRIVATE`.
+const PRIVATE_SCOPE: &str = "private";
+
+/// `(SQL resource name, owning node index, decorated name)` of one dependency.
+type DependencyRow = (Option<String>, Option<usize>, Option<String>);
+
+/// A decorated Python node as the facade describes it.
+#[derive(FromPyObject)]
+#[pyo3(from_item_all)]
+pub(crate) struct NodeRow {
+    kind: String,
+    name: String,
+    path: String,
+    decorator_config: bool,
+    depends_on: Vec<DependencyRow>,
+}
+
+/// The facts of `inputs`, with the Python nodes the facade has described.
+pub(crate) fn project_facts(
+    py: Python<'_>,
+    inputs: &Bound<'_, PyAny>,
+    nodes: Vec<NodeRow>,
+) -> PyResult<ProjectFacts> {
+    let mut declaration_files: Vec<ScopedDeclarationsFact> =
+        each(inputs, "enum_files", declarations_fact)?;
+    declaration_files.extend(each(inputs, "constant_files", declarations_fact)?);
+    let mut model_schemas: Vec<NamedPath> = Vec::new();
+    for schema in inputs.getattr("model_schema_files")?.try_iter()? {
+        model_schemas.extend(each(&schema?, "declarations", named)?);
+    }
+    Ok(ProjectFacts {
+        models: each(inputs, "model_files", model_fact)?,
+        sql_functions: each(inputs, "sql_function_files", stem_named)?,
+        python_functions: each(inputs, "python_function_files", stem_named)?,
+        sql_hooks: each(inputs, "sql_hook_files", named)?,
+        seeds: each(inputs, "seed_files", seed_file_fact)?,
+        schemas: each(inputs, "schema_files", |schema| schema_fact(py, schema))?,
+        sources: each(inputs, "source_files", source_file_fact)?,
+        tests: each(inputs, "test_files", test_file_fact)?,
+        scenarios: each(inputs, "scenario_files", named)?,
+        audits: each(inputs, "audit_files", audit_fact)?,
+        declaration_files,
+        model_schemas,
+        materializations: each(inputs, "materialization_files", named)?,
+        nodes: nodes.into_iter().map(node_fact).collect::<PyResult<_>>()?,
+        hook_functions: each(inputs, "hook_functions", named)?,
+        event_exporters: each(inputs, "event_exporters", named)?,
+        providers: each(inputs, "providers", named)?,
+        path_default_keys: inputs
+            .getattr("project_config")?
+            .getattr("path_defaults")?
+            .try_iter()?
+            .map(|key| key?.extract())
+            .collect::<PyResult<_>>()?,
+        csv_field_limit: Some(csv_field_limit(py)?),
+    })
+}
+
+/// `read` applied to each item of the iterable attribute `name` of `owner`.
+fn each<T>(
+    owner: &Bound<'_, PyAny>,
+    name: &str,
+    read: impl Fn(&Bound<'_, PyAny>) -> PyResult<T>,
+) -> PyResult<Vec<T>> {
+    let mut items: Vec<T> = Vec::new();
+    for item in owner.getattr(name)?.try_iter()? {
+        items.push(read(&item?)?);
+    }
+    Ok(items)
+}
+
+fn text(owner: &Bound<'_, PyAny>, name: &str) -> PyResult<String> {
+    Ok(owner.getattr(name)?.str()?.to_string())
+}
+
+fn optional_text(owner: &Bound<'_, PyAny>, name: &str) -> PyResult<Option<String>> {
+    owner.getattr(name)?.extract()
+}
+
+/// `str(Path(...).stem)` of the path attribute `name`.
+fn stem(owner: &Bound<'_, PyAny>, name: &str) -> PyResult<String> {
+    owner.getattr(name)?.getattr("stem")?.extract()
+}
+
+/// `(resource.name, str(resource.relative_path))`.
+fn named(resource: &Bound<'_, PyAny>) -> PyResult<NamedPath> {
+    Ok(NamedPath {
+        name: resource.getattr("name")?.extract()?,
+        path: text(resource, "relative_path")?,
+    })
+}
+
+/// `(file.file_path.stem, str(file.relative_path))`.
+fn stem_named(file: &Bound<'_, PyAny>) -> PyResult<NamedPath> {
+    Ok(NamedPath {
+        name: stem(file, "file_path")?,
+        path: text(file, "relative_path")?,
+    })
+}
+
+/// `(file.relative_path.stem, str(file.relative_path))`.
+fn relative_stem_named(file: &Bound<'_, PyAny>) -> PyResult<NamedPath> {
+    Ok(NamedPath {
+        name: stem(file, "relative_path")?,
+        path: text(file, "relative_path")?,
+    })
+}
+
+fn enum_value(owner: &Bound<'_, PyAny>, name: &str) -> PyResult<String> {
+    owner.getattr(name)?.getattr("value")?.extract()
+}
+
+fn model_fact(model: &Bound<'_, PyAny>) -> PyResult<ModelFact> {
+    let mut local_declarations: Vec<NamedPath> = each(model, "enum_declarations", named)?;
+    local_declarations.extend(each(model, "constant_declarations", named)?);
+    Ok(ModelFact {
+        file: stem_named(model)?,
+        local_declarations,
+    })
+}
+
+fn seed_file_fact(seed: &Bound<'_, PyAny>) -> PyResult<SeedFileFact> {
+    Ok(SeedFileFact {
+        file: stem_named(seed)?,
+        absolute_path: text(seed, "file_path")?,
+    })
+}
+
+fn column_name(column: &Bound<'_, PyAny>) -> PyResult<String> {
+    column.getattr("name")?.extract()
+}
+
+fn seed_entry_fact(py: Python<'_>, entry: &Bound<'_, PyAny>) -> PyResult<SeedEntryFact> {
+    let settings: Bound<'_, PyAny> = entry.getattr("csv_settings")?;
+    let mut csv: CsvSettings = CsvSettings {
+        delimiter: optional_text(&settings, "delimiter")?,
+        quotechar: optional_text(&settings, "quotechar")?,
+        escapechar: optional_text(&settings, "escapechar")?,
+        doublequote: settings.getattr("doublequote")?.extract()?,
+        skipinitialspace: settings.getattr("skipinitialspace")?.extract()?,
+        dialect_error: None,
+    };
+    csv.dialect_error = csv_dialect_error(py, &csv)?;
+    Ok(SeedEntryFact {
+        name: column_name(entry)?,
+        columns: each(entry, "columns", column_name)?,
+        csv,
+    })
+}
+
+fn schema_fact(py: Python<'_>, schema: &Bound<'_, PyAny>) -> PyResult<SchemaFileFact> {
+    Ok(SchemaFileFact {
+        path: text(schema, "relative_path")?,
+        model_names: each(schema, "model_entries", column_name)?,
+        seeds: each(schema, "seed_entries", |entry| seed_entry_fact(py, entry))?,
+    })
+}
+
+fn source_fact(entry: &Bound<'_, PyAny>) -> PyResult<SourceFact> {
+    let integration: Bound<'_, PyAny> = entry.getattr("integration_loader")?;
+    let integration_loader: Option<IntegrationLoaderFact> = if integration.is_none() {
+        None
+    } else {
+        Some(IntegrationLoaderFact {
+            kind: integration.getattr("kind")?.extract()?,
+        })
+    };
+    Ok(SourceFact {
+        name: column_name(entry)?,
+        managed: entry.getattr("managed")?.extract()?,
+        loader: optional_text(entry, "loader")?,
+        integration_loader,
+    })
+}
+
+fn source_file_fact(file: &Bound<'_, PyAny>) -> PyResult<SourceFileFact> {
+    Ok(SourceFileFact {
+        path: text(file, "relative_path")?,
+        entries: each(file, "source_entries", source_fact)?,
+    })
+}
+
+fn test_block_fact(block: &Bound<'_, PyAny>) -> PyResult<TestBlockFact> {
+    Ok(TestBlockFact {
+        name: optional_text(block, "name")?,
+        cases: each(block, "cases", column_name)?,
+    })
+}
+
+fn test_file_fact(file: &Bound<'_, PyAny>) -> PyResult<TestFileFact> {
+    Ok(TestFileFact {
+        file: relative_stem_named(file)?,
+        blocks: each(file, "blocks", test_block_fact)?,
+    })
+}
+
+fn block_name(block: &Bound<'_, PyAny>) -> PyResult<Option<String>> {
+    optional_text(block, "name")
+}
+
+fn audit_fact(file: &Bound<'_, PyAny>) -> PyResult<AuditFileFact> {
+    Ok(AuditFileFact {
+        file: relative_stem_named(file)?,
+        generic: enum_value(file, "declaration_kind")? == GENERIC_AUDIT_KIND,
+        block_names: each(file, "blocks", block_name)?,
+    })
+}
+
+fn declarations_fact(file: &Bound<'_, PyAny>) -> PyResult<ScopedDeclarationsFact> {
+    Ok(ScopedDeclarationsFact {
+        private: enum_value(file, "scope_kind")? == PRIVATE_SCOPE,
+        declarations: each(file, "declarations", named)?,
+    })
+}
+
+fn node_kind(kind: &str) -> PyResult<NodeKind> {
+    match kind {
+        "loader" => Ok(NodeKind::Loader),
+        "task" => Ok(NodeKind::Task),
+        "asset" => Ok(NodeKind::Asset),
+        "check" => Ok(NodeKind::Check),
+        other => Err(PyValueError::new_err(format!(
+            "unknown Python node kind {other:?}"
+        ))),
+    }
+}
+
+fn dependency_fact((sql_name, owner, decorated_name): DependencyRow) -> DependencyFact {
+    match sql_name {
+        Some(name) => DependencyFact::SqlResource { name },
+        None => DependencyFact::Object {
+            owner,
+            decorated_name,
+        },
+    }
+}
+
+fn node_fact(node: NodeRow) -> PyResult<NodeFact> {
+    Ok(NodeFact {
+        kind: node_kind(&node.kind)?,
+        name: node.name,
+        path: node.path,
+        decorator_config: node.decorator_config,
+        depends_on: node.depends_on.into_iter().map(dependency_fact).collect(),
+    })
+}
+
+/// The error the running Python's `csv.reader` raises for a seed's settings, which vary by version.
+fn csv_dialect_error(py: Python<'_>, csv: &CsvSettings) -> PyResult<Option<CsvDialectError>> {
+    let keywords: Bound<'_, PyDict> = PyDict::new(py);
+    let delimiter: &str = csv
+        .delimiter
+        .as_deref()
+        .filter(|text| !text.is_empty())
+        .unwrap_or(",");
+    keywords.set_item("delimiter", delimiter)?;
+    keywords.set_item("quotechar", csv.quotechar.as_deref())?;
+    keywords.set_item("escapechar", csv.escapechar.as_deref())?;
+    keywords.set_item("doublequote", csv.doublequote.unwrap_or(true))?;
+    keywords.set_item("skipinitialspace", csv.skipinitialspace.unwrap_or(false))?;
+    let reader: Bound<'_, PyAny> = py.import(CSV_MODULE)?.getattr("reader")?;
+    match reader.call((PyTuple::empty(py),), Some(&keywords)) {
+        Ok(_) => Ok(None),
+        Err(error)
+            if error.is_instance_of::<PyTypeError>(py)
+                || error.is_instance_of::<PyValueError>(py) =>
+        {
+            Ok(Some(CsvDialectError {
+                class: error.get_type(py).name()?.to_string(),
+                message: error.value(py).str()?.to_string(),
+            }))
+        }
+        Err(error) => Err(error),
+    }
+}
+
+fn csv_field_limit(py: Python<'_>) -> PyResult<usize> {
+    py.import(CSV_MODULE)?
+        .call_method0("field_size_limit")?
+        .extract()
+}
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/discovery/project_files.rs b/crates/sqlbuild-python/src/bindings/_helpers/discovery/project_files.rs
index 8b45ff5c80..be9bc78a0d 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/discovery/project_files.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/discovery/project_files.rs
@@ -1,8 +1,10 @@
 //! Native discovery results as the plain data the Python discovery facade materialises.
 
-use pyo3::exceptions::{PyRuntimeError, PyValueError};
-use pyo3::prelude::{Bound, IntoPyObject, Py, PyAny, PyModule, PyModuleMethods, PyResult, Python};
-use pyo3::types::{PyBytes, PyTuple};
+use pyo3::exceptions::{PyException, PyRuntimeError, PyValueError};
+use pyo3::prelude::{
+    Bound, IntoPyObject, Py, PyAny, PyAnyMethods, PyModule, PyModuleMethods, PyResult, Python,
+};
+use pyo3::types::{PyBytes, PyDict, PyDictMethods, PyString, PyTuple};
 use pyo3::{IntoPyObjectExt, pyfunction, pymethods, wrap_pyfunction};
 use sqlbuild_discovery::declarations::main::declaration_layout::declaration_layout;
 use sqlbuild_discovery::declarations::models::{
@@ -32,6 +34,10 @@ use std::path::{Path, PathBuf};
 use std::sync::Mutex;
 
 use crate::bindings::_helpers::boundary::config_values::config_value_to_python;
+use crate::bindings::_helpers::discovery::header_declarations::{
+    HeaderDeclarations, model_header_declarations,
+};
+use crate::bindings::_helpers::discovery::model_file_record::{ModelFileParts, NativeModelFile};
 use crate::bindings::_helpers::sqltext::authored_values::map_to_python;
 use crate::bindings::models::{
     ModelDiscoveryRequest, ModelTextRequest, NativeProjectTree, SqlTestDiscoveryRequest,
@@ -40,6 +46,13 @@ use crate::bindings::models::{
 use crate::bindings::types::CompilerDetach;
 
 pub(crate) type PyObject = Py<PyAny>;
+
+const PATHLIB_MODULE: &str = "pathlib";
+const PATH_CLASS: &str = "Path";
+const STEM_ATTRIBUTE: &str = "stem";
+const ENUMS_KEY: &str = "enums";
+const CONSTANTS_KEY: &str = "constants";
+const RAISED_TAG: &str = "raised";
 type Located = (String, usize, usize, usize, usize);
 type Listing = (PyObject, Vec<(PyObject, bool, bool)>);
 
@@ -298,12 +311,13 @@ impl NativeProjectTree {
     }
 }
 
-/// Discover the model files: one payload per file, or the collection's failure payload.
+/// Each model file's `(relative path, record or failure payload)`, or the collection's failure.
 #[pyfunction]
 fn discover_model_files(
     py: Python<'_>,
     request: ModelDiscoveryRequest,
     tree: &NativeProjectTree,
+    project_dir: Bound<'_, PyAny>,
 ) -> PyResult<PyObject> {
     let root = ProjectRoot {
         directory: PathBuf::from(request.project_dir),
@@ -315,10 +329,79 @@ fn discover_model_files(
         extract_implicit_alias_columns: request.extract_implicit_alias_columns,
         extract_output_column_locations: request.extract_output_column_locations,
     };
+    let extract_implicit_alias_columns: bool = options.extract_implicit_alias_columns;
     let discovered = py
         .compiler_detach(|| Ok(discover_models(&root, &tree.inner, &options)))
         .map_err(crate::bindings::_helpers::boundary::panics::compiler_error)?;
-    files_object(py, &tree.inner, discovered, model_object)
+    let files: Vec<DiscoveredFile<DiscoveredModelFile>> = match discovered {
+        Ok(files) => files,
+        Err(failure) => return stage_failure_object(py, &tree.inner, failure),
+    };
+    let path_class: Bound<'_, PyAny> = py.import(PATHLIB_MODULE)?.getattr(PATH_CLASS)?;
+    files
+        .into_iter()
+        .map(|file| {
+            let relative_path: Bound<'_, PyAny> =
+                path_class.call1((path_object(py, &tree.inner, file.relative_path)?,))?;
+            let item: PyObject = match file.outcome {
+                FileOutcome::Parsed(model) => model_record(
+                    py,
+                    model,
+                    (project_dir.div(&relative_path)?, relative_path.clone()),
+                    extract_implicit_alias_columns,
+                )?,
+                FileOutcome::Unreadable(failure) => read_object(py, failure)?,
+                FileOutcome::Failed(failure) => failure_object(py, failure)?,
+            };
+            Ok((relative_path.unbind(), item))
+        })
+        .collect::<PyResult<Vec<(PyObject, PyObject)>>>()?
+        .into_py_any(py)
+}
+
+/// One parsed model file as its native record, or `("raised", error)` for invalid declarations.
+fn model_record<'py>(
+    py: Python<'py>,
+    model: DiscoveredModelFile,
+    paths: (Bound<'py, PyAny>, Bound<'py, PyAny>),
+    extract_implicit_alias_columns: bool,
+) -> PyResult<PyObject> {
+    let (file_path, relative_path) = paths;
+    let header_values: Bound<'py, PyDict> = map_to_python(py, model.header_values)?
+        .into_bound(py)
+        .downcast_into::<PyDict>()?;
+    let model_name: String = file_path.getattr(STEM_ATTRIBUTE)?.extract()?;
+    let declarations: HeaderDeclarations<'py> = match model_header_declarations(
+        py,
+        (
+            header_values.get_item(ENUMS_KEY)?,
+            header_values.get_item(CONSTANTS_KEY)?,
+        ),
+        model_name,
+        relative_path.clone(),
+    ) {
+        Ok(declarations) => declarations,
+        Err(error) if error.is_instance_of::<PyException>(py) => {
+            return tuple_object(
+                py,
+                vec![object(py, RAISED_TAG)?, error.into_value(py).into_any()],
+            );
+        }
+        Err(error) => return Err(error),
+    };
+    let (enum_declarations, constant_declarations) = declarations;
+    let record: NativeModelFile = NativeModelFile::discovered(ModelFileParts {
+        file_path: file_path.unbind(),
+        relative_path: relative_path.unbind(),
+        contents: PyString::new(py, &model.contents).unbind(),
+        header_values: header_values.unbind(),
+        header_column_locations: model.header_column_locations,
+        output_column_locations: model.output_column_locations,
+        query_sql: PyString::new(py, &model.query_sql).unbind(),
+        declarations: (enum_declarations.unbind(), constant_declarations.unbind()),
+        extract_implicit_alias_columns,
+    });
+    record.into_py_any(py)
 }
 
 /// Parse in-memory SQL model contents into the payload model discovery returns for a file.
@@ -576,6 +659,7 @@ pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {
     module.add_function(wrap_pyfunction!(parse_sql_test_contents, module)?)?;
     module.add_function(wrap_pyfunction!(parse_scenario_contents, module)?)?;
     module.add_class::<NativeProjectTree>()?;
+    module.add_class::<NativeModelFile>()?;
     module.add_function(wrap_pyfunction!(discover_model_files, module)?)?;
     module.add_function(wrap_pyfunction!(parse_model_contents, module)?)?;
     module.add_function(wrap_pyfunction!(discover_declaration_layout, module)?)?;
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/discovery/project_validation.rs b/crates/sqlbuild-python/src/bindings/_helpers/discovery/project_validation.rs
new file mode 100644
index 0000000000..7960161131
--- /dev/null
+++ b/crates/sqlbuild-python/src/bindings/_helpers/discovery/project_validation.rs
@@ -0,0 +1,59 @@
+//! Cross-file validation of one discovery's inputs.
+
+use pyo3::prelude::{Bound, PyAny, PyModule, PyModuleMethods, PyResult, Python};
+use pyo3::{pyfunction, wrap_pyfunction};
+use sqlbuild_discovery::project_validation::main::validate_project_inputs::validate_project_inputs;
+use sqlbuild_discovery::project_validation::models::{ProjectFacts, ValidationFailure};
+
+use crate::bindings::_helpers::discovery::project_facts::{NodeRow, project_facts};
+use crate::bindings::_helpers::discovery::project_files::{
+    PyObject, failure_object, object, read_object, tuple_object,
+};
+
+const CSV_ERROR_TAG: &str = "csv";
+const CSV_DIALECT_TAG: &str = "csv_dialect";
+const UNREADABLE_TAG: &str = "unreadable";
+
+/// `None` when the inputs are consistent, else the payload of the first error Python raises.
+#[pyfunction]
+fn discovered_inputs_failure(
+    py: Python<'_>,
+    inputs: Bound<'_, PyAny>,
+    nodes: Vec<NodeRow>,
+) -> PyResult<Option<PyObject>> {
+    let facts: ProjectFacts = project_facts(py, &inputs, nodes)?;
+    let failure: ValidationFailure = match validate_project_inputs(&facts) {
+        Ok(()) => return Ok(None),
+        Err(failure) => failure,
+    };
+    let payload: PyObject = match failure {
+        ValidationFailure::Discovery(failure) => failure_object(py, failure)?,
+        ValidationFailure::Unreadable {
+            absolute_path,
+            failure,
+        } => tuple_object(
+            py,
+            vec![
+                object(py, UNREADABLE_TAG)?,
+                object(py, absolute_path)?,
+                read_object(py, failure)?,
+            ],
+        )?,
+        ValidationFailure::Csv(message) => {
+            tuple_object(py, vec![object(py, CSV_ERROR_TAG)?, object(py, message)?])?
+        }
+        ValidationFailure::CsvDialect(error) => tuple_object(
+            py,
+            vec![
+                object(py, CSV_DIALECT_TAG)?,
+                object(py, error.class)?,
+                object(py, error.message)?,
+            ],
+        )?,
+    };
+    Ok(Some(payload))
+}
+
+pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    module.add_function(wrap_pyfunction!(discovered_inputs_failure, module)?)
+}
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/discovery/registration.rs b/crates/sqlbuild-python/src/bindings/_helpers/discovery/registration.rs
index d4c6034ae8..3cc8e6b882 100644
--- a/crates/sqlbuild-python/src/bindings/_helpers/discovery/registration.rs
+++ b/crates/sqlbuild-python/src/bindings/_helpers/discovery/registration.rs
@@ -4,7 +4,7 @@ use pyo3::prelude::{Bound, PyModule, PyResult};
 
 use crate::bindings::_helpers::discovery::{
     declaration_files, globbing, header_declarations, key_checks, locations, project_files,
-    sql_test_blocks,
+    project_validation, sql_test_blocks, yaml_entries,
 };
 
 pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {
@@ -15,5 +15,7 @@ pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {
     header_declarations::register(module)?;
     key_checks::register(module)?;
     globbing::register(module)?;
+    project_validation::register(module)?;
+    yaml_entries::register(module)?;
     Ok(())
 }
diff --git a/crates/sqlbuild-python/src/bindings/_helpers/discovery/yaml_entries.rs b/crates/sqlbuild-python/src/bindings/_helpers/discovery/yaml_entries.rs
new file mode 100644
index 0000000000..8418ddb2e6
--- /dev/null
+++ b/crates/sqlbuild-python/src/bindings/_helpers/discovery/yaml_entries.rs
@@ -0,0 +1,362 @@
+//! Loaded schema and source YAML documents parsed natively into the Python contract objects.
+
+use pyo3::prelude::{
+    Bound, PyAny, PyAnyMethods, PyErr, PyModule, PyModuleMethods, PyResult, Python,
+};
+use pyo3::types::{PyDict, PyDictMethods, PyTuple};
+use pyo3::{FromPyObject, pyfunction, wrap_pyfunction};
+use sqlbuild_discovery::yaml_entries::main::parse_schema_document::parse_schema_document as parse_schema;
+use sqlbuild_discovery::yaml_entries::main::parse_sources_document::parse_sources_document as parse_sources;
+use sqlbuild_discovery::yaml_entries::models::{
+    ParsedCsvSettings, ParsedDltSource, ParsedFreshness, ParsedIngestrConfig,
+    ParsedIntegrationLoader, ParsedNaValues, ParsedSeedEntry, ParsedSourceEntry, ParsedYamlColumn,
+};
+use sqlbuild_model_config::errors::{ConfigError, ErrorClass};
+
+use crate::bindings::_helpers::model_config::authored_nodes::PyNode;
+use crate::bindings::_helpers::model_config::header_metadata::{ContractClasses, audit_tuple};
+
+const DISCOVERY_ERRORS_MODULE: &str = "sqlbuild.compiler.discovery.exceptions";
+const IDENTITY_ERRORS_MODULE: &str = "sqlbuild.compiler.resource_names.exceptions";
+const IDENTITY_ERROR: &str = "ResourceIdentityError";
+/// The directory whose schema YAML files may declare seeds.
+const SEEDS_DIRECTORY: &str = "seeds";
+const SCHEMA_PARSE_ERROR: &str = "SchemaParseError";
+const SOURCE_PARSE_ERROR: &str = "SourceParseError";
+
+/// The Python classes parsed YAML entries become.
+#[derive(FromPyObject)]
+#[pyo3(from_item_all)]
+struct YamlClasses<'py> {
+    contracts: ContractClasses<'py>,
+    schema_seed_entry: Bound<'py, PyAny>,
+    seed_csv_settings: Bound<'py, PyAny>,
+    source_entry: Bound<'py, PyAny>,
+    source_column_entry: Bound<'py, PyAny>,
+    source_freshness_config: Bound<'py, PyAny>,
+    source_freshness_age_policy: Bound<'py, PyAny>,
+    integration_loader_config: Bound<'py, PyAny>,
+    ingestr_source_config: Bound<'py, PyAny>,
+    dlt_source_config: Bound<'py, PyAny>,
+    dlt_resource_config: Bound<'py, PyAny>,
+    source_write_strategy: Bound<'py, PyAny>,
+    source_freshness_strategy: Bound<'py, PyAny>,
+    source_freshness_value_kind: Bound<'py, PyAny>,
+}
+
+/// The Python error `error` raises: a resource identity error, else the file kind's parse error.
+fn parse_error(py: Python<'_>, error: ConfigError, parse_class: &str) -> PyResult<PyErr> {
+    let class: Bound<'_, PyAny> = match error.class {
+        ErrorClass::ResourceIdentity => {
+            py.import(IDENTITY_ERRORS_MODULE)?.getattr(IDENTITY_ERROR)?
+        }
+        _ => py.import(DISCOVERY_ERRORS_MODULE)?.getattr(parse_class)?,
+    };
+    let keywords: Bound<'_, PyDict> = PyDict::new(py);
+    if let Some(help) = error.help {
+        keywords.set_item("help", help)?;
+    }
+    Ok(PyErr::from_value(
+        class.call((error.message,), Some(&keywords))?,
+    ))
+}
+
+fn optional<'py>(py: Python<'py>, node: Option<&PyNode<'py>>) -> Bound<'py, PyAny> {
+    node.map_or_else(|| py.None().into_bound(py), |node| node.0.clone())
+}
+
+fn meta<'py>(py: Python<'py>, node: Option<&PyNode<'py>>) -> Bound<'py, PyAny> {
+    node.map_or_else(|| PyDict::new(py).into_any(), |node| node.0.clone())
+}
+
+fn texts<'py>(py: Python<'py>, nodes: &[PyNode<'py>]) -> PyResult<Bound<'py, PyTuple>> {
+    PyTuple::new(py, nodes.iter().map(|node| node.0.clone()))
+}
+
+pub(crate) fn yaml_columns<'py>(
+    py: Python<'py>,
+    (classes, column_class): (&ContractClasses<'py>, &Bound<'py, PyAny>),
+    columns: &[ParsedYamlColumn<PyNode<'py>>],
+) -> PyResult<Bound<'py, PyTuple>> {
+    let mut built: Vec<Bound<'py, PyAny>> = Vec::with_capacity(columns.len());
+    for column in columns {
+        let fields: Bound<'py, PyDict> = PyDict::new(py);
+        fields.set_item("name", &column.name.0)?;
+        fields.set_item("type", optional(py, column.column_type.as_ref()))?;
+        fields.set_item("nullable", optional(py, column.nullable.as_ref()))?;
+        fields.set_item("description", optional(py, column.description.as_ref()))?;
+        fields.set_item("meta", meta(py, column.meta.as_ref()))?;
+        fields.set_item("audits", audit_tuple(py, classes, &column.audits)?)?;
+        built.push(column_class.call((), Some(&fields))?);
+    }
+    PyTuple::new(py, built)
+}
+
+fn csv_settings<'py>(
+    py: Python<'py>,
+    class: &Bound<'py, PyAny>,
+    settings: Option<&ParsedCsvSettings<PyNode<'py>>>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let fields: Bound<'py, PyDict> = PyDict::new(py);
+    if let Some(settings) = settings {
+        for (key, value) in [
+            ("delimiter", &settings.delimiter),
+            ("quotechar", &settings.quotechar),
+            ("doublequote", &settings.doublequote),
+            ("escapechar", &settings.escapechar),
+            ("skipinitialspace", &settings.skipinitialspace),
+            ("lineterminator", &settings.lineterminator),
+            ("encoding", &settings.encoding),
+            ("keep_default_na", &settings.keep_default_na),
+        ] {
+            fields.set_item(key, optional(py, value.as_ref()))?;
+        }
+        let na_values: Bound<'py, PyAny> = match &settings.na_values {
+            None => py.None().into_bound(py),
+            Some(ParsedNaValues::List(values)) => texts(py, values)?.into_any(),
+            Some(ParsedNaValues::PerColumn(columns)) => {
+                let mapping: Bound<'py, PyDict> = PyDict::new(py);
+                for (column, values) in columns {
+                    mapping.set_item(&column.0, texts(py, values)?)?;
+                }
+                mapping.into_any()
+            }
+        };
+        fields.set_item("na_values", na_values)?;
+    }
+    class.call((), Some(&fields))
+}
+
+fn seed_entry<'py>(
+    py: Python<'py>,
+    classes: &YamlClasses<'py>,
+    seed: &ParsedSeedEntry<PyNode<'py>>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let fields: Bound<'py, PyDict> = PyDict::new(py);
+    fields.set_item("name", &seed.name.0)?;
+    fields.set_item("description", optional(py, seed.description.as_ref()))?;
+    fields.set_item("database", optional(py, seed.database.as_ref()))?;
+    fields.set_item("schema", optional(py, seed.schema.as_ref()))?;
+    fields.set_item("meta", meta(py, seed.meta.as_ref()))?;
+    fields.set_item(
+        "csv_settings",
+        csv_settings(py, &classes.seed_csv_settings, seed.csv_settings.as_ref())?,
+    )?;
+    fields.set_item(
+        "columns",
+        yaml_columns(
+            py,
+            (&classes.contracts, &classes.contracts.schema_column),
+            &seed.columns,
+        )?,
+    )?;
+    fields.set_item("tags", texts(py, &seed.tags)?)?;
+    fields.set_item("audits", audit_tuple(py, &classes.contracts, &seed.audits)?)?;
+    classes.schema_seed_entry.call((), Some(&fields))
+}
+
+/// The seed entries of one loaded schema YAML document, or the parse error Python raises.
+#[pyfunction]
+fn parse_schema_document<'py>(
+    py: Python<'py>,
+    loaded: Bound<'py, PyAny>,
+    path: &str,
+    classes: YamlClasses<'py>,
+) -> PyResult<Bound<'py, PyTuple>> {
+    let in_seeds_directory: bool = std::path::Path::new(path)
+        .components()
+        .any(|component| component.as_os_str() == SEEDS_DIRECTORY);
+    let seeds: Vec<ParsedSeedEntry<PyNode<'py>>> =
+        parse_schema(&PyNode(loaded), path, in_seeds_directory).map_err(|error| {
+            parse_error(py, error, SCHEMA_PARSE_ERROR).unwrap_or_else(|error| error)
+        })?;
+    let mut built: Vec<Bound<'py, PyAny>> = Vec::with_capacity(seeds.len());
+    for seed in &seeds {
+        built.push(seed_entry(py, &classes, seed)?);
+    }
+    PyTuple::new(py, built)
+}
+
+fn strings<'py>(py: Python<'py>, values: &[String]) -> PyResult<Bound<'py, PyTuple>> {
+    PyTuple::new(py, values)
+}
+
+fn freshness<'py>(
+    py: Python<'py>,
+    classes: &YamlClasses<'py>,
+    freshness: &ParsedFreshness<PyNode<'py>>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let fields: Bound<'py, PyDict> = PyDict::new(py);
+    fields.set_item(
+        "strategy",
+        classes
+            .source_freshness_strategy
+            .call1((freshness.strategy,))?,
+    )?;
+    let value_kind: Bound<'py, PyAny> = match freshness.value_kind {
+        Some(kind) => classes.source_freshness_value_kind.call1((kind,))?,
+        None => py.None().into_bound(py),
+    };
+    fields.set_item("value_kind", value_kind)?;
+    fields.set_item("column", optional(py, freshness.column.as_ref()))?;
+    fields.set_item("query", optional(py, freshness.query.as_ref()))?;
+    fields.set_item("filter", optional(py, freshness.filter.as_ref()))?;
+    fields.set_item(
+        "lag_tolerance",
+        optional(py, freshness.lag_tolerance.as_ref()),
+    )?;
+    let age_policy: Bound<'py, PyAny> = match &freshness.age_policy {
+        Some(policy) => {
+            let policy_fields: Bound<'py, PyDict> = PyDict::new(py);
+            policy_fields.set_item("warn_after", optional(py, policy.warn_after.as_ref()))?;
+            policy_fields.set_item("error_after", optional(py, policy.error_after.as_ref()))?;
+            classes
+                .source_freshness_age_policy
+                .call((), Some(&policy_fields))?
+        }
+        None => py.None().into_bound(py),
+    };
+    fields.set_item("age_policy", age_policy)?;
+    classes.source_freshness_config.call((), Some(&fields))
+}
+
+fn ingestr_config<'py>(
+    py: Python<'py>,
+    classes: &YamlClasses<'py>,
+    config: &ParsedIngestrConfig<PyNode<'py>>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let fields: Bound<'py, PyDict> = PyDict::new(py);
+    fields.set_item("source_uri", &config.source_uri.0)?;
+    fields.set_item("source_table", &config.source_table.0)?;
+    fields.set_item("strategy", optional(py, config.strategy.as_ref()))?;
+    fields.set_item(
+        "incremental_key",
+        optional(py, config.incremental_key.as_ref()),
+    )?;
+    fields.set_item("primary_key", strings(py, &config.primary_key)?)?;
+    fields.set_item("columns", optional(py, config.columns.as_ref()))?;
+    fields.set_item("extra_args", strings(py, &config.extra_args)?)?;
+    classes.ingestr_source_config.call((), Some(&fields))
+}
+
+fn dlt_config<'py>(
+    py: Python<'py>,
+    classes: &YamlClasses<'py>,
+    source: &ParsedDltSource<PyNode<'py>>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let resource = &source.resource;
+    let raw_config: Bound<'py, PyDict> = PyDict::new(py);
+    for (key, value) in &resource.raw_config {
+        raw_config.set_item(&key.0, &value.0)?;
+    }
+    let resource_fields: Bound<'py, PyDict> = PyDict::new(py);
+    resource_fields.set_item("name", &resource.name.0)?;
+    resource_fields.set_item("dlt_name", &resource.dlt_name.0)?;
+    resource_fields.set_item("schema", optional(py, resource.schema.as_ref()))?;
+    resource_fields.set_item("raw_config", raw_config)?;
+    resource_fields.set_item(
+        "write_disposition",
+        optional(py, resource.write_disposition.as_ref()),
+    )?;
+    resource_fields.set_item("primary_key", optional(py, resource.primary_key.as_ref()))?;
+    resource_fields.set_item("merge_key", optional(py, resource.merge_key.as_ref()))?;
+    resource_fields.set_item("incremental", meta(py, resource.incremental.as_ref()))?;
+    let fields: Bound<'py, PyDict> = PyDict::new(py);
+    fields.set_item("source_type", &source.source_type.0)?;
+    fields.set_item("schema", optional(py, source.schema.as_ref()))?;
+    fields.set_item("config", &source.config.0)?;
+    fields.set_item("destination", meta(py, source.destination.as_ref()))?;
+    fields.set_item(
+        "resource",
+        classes
+            .dlt_resource_config
+            .call((), Some(&resource_fields))?,
+    )?;
+    fields.set_item("group_index", source.group_index)?;
+    classes.dlt_source_config.call((), Some(&fields))
+}
+
+fn source_entry<'py>(
+    py: Python<'py>,
+    classes: &YamlClasses<'py>,
+    source: &ParsedSourceEntry<PyNode<'py>>,
+) -> PyResult<Bound<'py, PyAny>> {
+    let integration: Bound<'py, PyAny> = match &source.integration_loader {
+        None => py.None().into_bound(py),
+        Some(loader) => {
+            let config: Bound<'py, PyAny> = match loader {
+                ParsedIntegrationLoader::Ingestr(config) => ingestr_config(py, classes, config)?,
+                ParsedIntegrationLoader::Dlt(source) => dlt_config(py, classes, source)?,
+            };
+            classes
+                .integration_loader_config
+                .call1((loader.kind(), config))?
+        }
+    };
+    let fields: Bound<'py, PyDict> = PyDict::new(py);
+    fields.set_item("name", &source.name.0)?;
+    fields.set_item("database", optional(py, source.database.as_ref()))?;
+    fields.set_item("schema", optional(py, source.schema.as_ref()))?;
+    fields.set_item("table", optional(py, source.table.as_ref()))?;
+    fields.set_item("loader", source.loader.as_deref())?;
+    fields.set_item("managed", source.managed)?;
+    fields.set_item("integration_loader", integration)?;
+    let freshness_config: Bound<'py, PyAny> = match &source.freshness {
+        Some(config) => freshness(py, classes, config)?,
+        None => py.None().into_bound(py),
+    };
+    fields.set_item("freshness", freshness_config)?;
+    let write_strategy: Bound<'py, PyAny> = match source.write_strategy {
+        Some(strategy) => classes.source_write_strategy.call1((strategy,))?,
+        None => py.None().into_bound(py),
+    };
+    fields.set_item("write_strategy", write_strategy)?;
+    fields.set_item(
+        "load_batch_size",
+        optional(py, source.load_batch_size.as_ref()),
+    )?;
+    fields.set_item("cursor_column", optional(py, source.cursor_column.as_ref()))?;
+    fields.set_item("unique_key", strings(py, &source.unique_key)?)?;
+    fields.set_item("expression", optional(py, source.expression.as_ref()))?;
+    fields.set_item("description", optional(py, source.description.as_ref()))?;
+    fields.set_item("type_enforcement", source.type_enforcement)?;
+    fields.set_item("contract", optional(py, source.contract.as_ref()))?;
+    fields.set_item("meta", meta(py, source.meta.as_ref()))?;
+    fields.set_item(
+        "columns",
+        yaml_columns(
+            py,
+            (&classes.contracts, &classes.source_column_entry),
+            &source.columns,
+        )?,
+    )?;
+    fields.set_item(
+        "audits",
+        audit_tuple(py, &classes.contracts, &source.audits)?,
+    )?;
+    classes.source_entry.call((), Some(&fields))
+}
+
+/// The source entries of one loaded sources YAML document, or the parse error Python raises.
+#[pyfunction]
+fn parse_sources_document<'py>(
+    py: Python<'py>,
+    loaded: Bound<'py, PyAny>,
+    path: &str,
+    classes: YamlClasses<'py>,
+) -> PyResult<Bound<'py, PyTuple>> {
+    let sources: Vec<ParsedSourceEntry<PyNode<'py>>> = parse_sources(&PyNode(loaded), path)
+        .map_err(|error| {
+            parse_error(py, error, SOURCE_PARSE_ERROR).unwrap_or_else(|error| error)
+        })?;
+    let mut built: Vec<Bound<'py, PyAny>> = Vec::with_capacity(sources.len());
+    for source in &sources {
+        built.push(source_entry(py, &classes, source)?);
+    }
+    PyTuple::new(py, built)
+}
+
+pub(crate) fn register(module: &Bound<'_, PyModule>) -> PyResult<()> {
+    module.add_function(wrap_pyfunction!(parse_schema_document, module)?)?;
+    module.add_function(wrap_pyfunction!(parse_sources_document, module)?)
+}
diff --git a/python-boundary.toml b/python-boundary.toml
index 205db07533..e0fc938819 100644
--- a/python-boundary.toml
+++ b/python-boundary.toml
@@ -2,7 +2,7 @@
 # migration work that moves to Rust. `remaining_lines` must equal the current count of that work:
 # a PR that moves code lowers it, and adding movable Python fails the check.
 # Native failures must surface as errors; `handled_native_errors` lists the reviewed exceptions.
-remaining_lines = 146314
+remaining_lines = 143789
 
 [[stays]]
 path = "executor"
diff --git a/scripts/setting_help/_helpers/scan.py b/scripts/setting_help/_helpers/scan.py
index 1456e09689..863070a269 100644
--- a/scripts/setting_help/_helpers/scan.py
+++ b/scripts/setting_help/_helpers/scan.py
@@ -32,7 +32,7 @@ def rust_findings(repository_root: Path) -> list[str]:
     findings: list[str] = []
     for path in sorted((repository_root / "crates").rglob("src/**/*.rs")):
         relative: str = path.relative_to(repository_root).as_posix()
-        if RUST_TEST_PATH_MARKER in relative:
+        if RUST_TEST_PATH_MARKER in relative or relative in YAML_FILE_TEXT_MODULES:
             continue
         for number, line in enumerate(path.read_text(encoding="utf-8").splitlines(), start=1):
             if RUST_STRING_DELIMITER in line and names_setting_without_snippet(line):
diff --git a/scripts/setting_help/constants.py b/scripts/setting_help/constants.py
index 6af1b4d7c8..8b98fee30e 100644
--- a/scripts/setting_help/constants.py
+++ b/scripts/setting_help/constants.py
@@ -18,7 +18,7 @@
 YAML_FILE_TEXT_MODULES: frozenset[str] = frozenset(
     {
         "src/sqlbuild/cli/commands/_helpers/playground/copy.py",
-        "src/sqlbuild/compiler/discovery/_helpers/yml/sources.py",
+        "crates/sqlbuild-discovery/src/yaml_entries/_helpers/sources.rs",
     }
 )
 RUST_TEST_PATH_MARKER: str = "/tests/"
diff --git a/src/sqlbuild/_native.pyi b/src/sqlbuild/_native.pyi
index 22dfb2eb6a..aa7a9af123 100644
--- a/src/sqlbuild/_native.pyi
+++ b/src/sqlbuild/_native.pyi
@@ -53,7 +53,6 @@ from sqlbuild.compiler.discovery.models import (
     DiscoveredSourceFile,
     DiscoveredSqlFunctionFile,
     DiscoveredSqlHookFile,
-    DiscoveredSqlModelFile,
     EnumDeclaration,
 )
 from sqlbuild.compiler.references.models import LiteralSqlRelation
@@ -836,9 +835,56 @@ class NativeProjectTree:
     def __init__(self, project_dir: str) -> None: ...
     def listings(self) -> list[tuple[str, list[tuple[str, bool, bool]]]]: ...
 
+class DiscoveredSqlModelFile:
+    """A discovered SQL model file and its raw contents."""
+
+    def __init__(
+        self,
+        file_path: Path,
+        relative_path: Path,
+        contents: str,
+        header_values: dict[str, object],
+        header_column_locations: dict[str, SourceLocation],
+        output_column_locations: dict[str, SourceLocation],
+        query_sql: str,
+        enum_declarations: tuple[EnumDeclaration, ...] = (),
+        constant_declarations: tuple[ConstantDeclaration, ...] = (),
+        extract_implicit_alias_columns: bool = True,
+    ) -> None: ...
+    @property
+    def file_path(self) -> Path: ...
+    @property
+    def relative_path(self) -> Path: ...
+    @property
+    def contents(self) -> str: ...
+    @property
+    def header_values(self) -> dict[str, object]: ...
+    @property
+    def header_column_locations(self) -> dict[str, SourceLocation]: ...
+    @property
+    def output_column_locations(self) -> dict[str, SourceLocation]: ...
+    @property
+    def query_sql(self) -> str: ...
+    def with_text(self, contents: str, query_sql: str) -> DiscoveredSqlModelFile: ...
+    @property
+    def enum_declarations(self) -> tuple[EnumDeclaration, ...]: ...
+    @property
+    def constant_declarations(self) -> tuple[ConstantDeclaration, ...]: ...
+    @property
+    def extract_implicit_alias_columns(self) -> bool: ...
+
+def parse_schema_document(
+    loaded: object, path: str, classes: dict[str, object]
+) -> tuple[SchemaSeedEntry, ...]: ...
+def parse_sources_document(
+    loaded: object, path: str, classes: dict[str, object]
+) -> tuple[SourceEntry, ...]: ...
+def discovered_inputs_failure(
+    inputs: DiscoveredProjectInputs, nodes: list[dict[str, object]]
+) -> tuple[object, ...] | None: ...
 def discover_model_files(
-    request: dict[str, object], tree: NativeProjectTree
-) -> list[tuple[str, tuple[object, ...]]] | tuple[object, ...]: ...
+    request: dict[str, object], tree: NativeProjectTree, project_dir: Path
+) -> list[tuple[Path, object]] | tuple[object, ...]: ...
 def discover_sql_test_files(
     request: dict[str, object], tree: NativeProjectTree
 ) -> list[tuple[str, tuple[object, ...]]] | tuple[object, ...]: ...
diff --git a/src/sqlbuild/compiler/compile/_helpers/attachment/core.py b/src/sqlbuild/compiler/compile/_helpers/attachment/core.py
index e4c67b106b..e262ecad97 100644
--- a/src/sqlbuild/compiler/compile/_helpers/attachment/core.py
+++ b/src/sqlbuild/compiler/compile/_helpers/attachment/core.py
@@ -357,23 +357,9 @@ def _run_native_model_loop(
         host,
         [
             (
-                (
-                    model_file.file_path.stem,
-                    model_file.relative_path.as_posix(),
-                    str(model_file.relative_path),
-                    str(model_file.file_path),
-                ),
-                (
-                    model_file.header_column_locations,
-                    model_file.header_values,
-                    model_file.enum_declarations,
-                    model_file.constant_declarations,
-                ),
-                model_file.query_sql,
-                model_file.contents,
+                model_file,
                 loop.native_declaration_references.get(model_file.file_path),
                 _interpolation_row(interpolations[model_file.file_path]),
-                model_file,
             )
             for model_file in files
         ],
diff --git a/src/sqlbuild/compiler/discovery/_helpers/integrations/loaders.py b/src/sqlbuild/compiler/discovery/_helpers/integrations/loaders.py
index 7a01646d0e..e5612a27ce 100644
--- a/src/sqlbuild/compiler/discovery/_helpers/integrations/loaders.py
+++ b/src/sqlbuild/compiler/discovery/_helpers/integrations/loaders.py
@@ -2,77 +2,7 @@
 
 from __future__ import annotations
 
-from pathlib import Path
-from typing import cast
-
-from sqlbuild.compiler.authored_values.main._optional_mapping import optional_mapping
-from sqlbuild.compiler.authored_values.main._optional_non_empty_string import (
-    optional_non_empty_string,
-)
-from sqlbuild.compiler.authored_values.main._require_non_empty_string import (
-    require_non_empty_string,
-)
-from sqlbuild.compiler.discovery._helpers.validation.supported_keys import (
-    reject_unknown_mapping_keys,
-)
-from sqlbuild.compiler.discovery.constants import (
-    DLT_LOADER_KIND,
-    DLT_RESOURCE_WRITE_STRATEGY_KEY,
-    DLT_SOURCE_TYPE_FILESYSTEM,
-    DLT_SOURCE_TYPE_REST_API,
-    DLT_SOURCE_TYPE_SQL_DATABASE,
-    DLT_SOURCE_TYPES,
-    DLT_WRITE_DISPOSITION_DELETE_INSERT,
-    DLT_WRITE_DISPOSITION_MERGE,
-)
-from sqlbuild.compiler.discovery.exceptions import SourceParseError
 from sqlbuild.compiler.discovery.models import DiscoveredLoaderFunction, DiscoveredSourceFile
-from sqlbuild.integrations.dlt.models import DltResourceConfig, DltSourceConfig
-from sqlbuild.integrations.ingestr.models import IngestrSourceConfig
-from sqlbuild.spec.contracts.models import IntegrationLoaderConfig, SourceEntry
-
-_ingestr_strategies: frozenset[str] = frozenset(
-    {"replace", "append", "merge", "delete+insert", "truncate+insert"}
-)
-_INGESTR_SOURCE_KEYS: frozenset[str] = frozenset(
-    {
-        "columns",
-        "extra_args",
-        "incremental_key",
-        "primary_key",
-        "source_table",
-        "source_uri",
-        "strategy",
-        "unique_key",
-    }
-)
-_DLT_SOURCE_GROUP_KEYS: frozenset[str] = frozenset(
-    {"config", "destination", "resources", "schema", "type"}
-)
-_DLT_RESOURCE_COMMON_KEYS: frozenset[str] = frozenset(
-    {
-        "description",
-        "incremental",
-        "merge_key",
-        "name",
-        "primary_key",
-        "schema",
-        "write_disposition",
-    }
-)
-_DLT_RESOURCE_TYPE_KEYS: dict[str, frozenset[str]] = {
-    DLT_SOURCE_TYPE_FILESYSTEM: frozenset({"reader"}),
-    DLT_SOURCE_TYPE_REST_API: frozenset({"endpoint"}),
-    DLT_SOURCE_TYPE_SQL_DATABASE: frozenset({"table"}),
-}
-
-
-def integration_loader_name(*, kind: str, source_name: str) -> str:
-    """Return the generated loader name for a declarative integration loader."""
-
-    if kind == DLT_LOADER_KIND:
-        return source_name
-    return f"{kind}__{source_name}"
 
 
 def build_integration_loader_functions(
@@ -84,365 +14,3 @@ def build_integration_loader_functions(
     from sqlbuild.integrations.ingestr.main.loaders import build_ingestr_loader_functions
 
     return build_ingestr_loader_functions(source_files) + build_dlt_loader_functions(source_files)
-
-
-def parse_dlt_sources(*, payload: dict[str, object], file_path: Path) -> tuple[SourceEntry, ...]:
-    """Parse top-level dlt_sources declarations into managed SourceEntry records."""
-
-    raw_groups: object = payload.get("dlt_sources", [])
-    if not isinstance(raw_groups, list):
-        raise SourceParseError(f"{file_path} dlt_sources must be a list")
-    sources: list[SourceEntry] = []
-    raw_group: object
-    for group_index, raw_group in enumerate(raw_groups):
-        if not isinstance(raw_group, dict):
-            raise SourceParseError(f"{file_path} dlt_sources must contain only mappings")
-        sources.extend(
-            _parse_dlt_source_group(
-                group=cast(dict[str, object], raw_group),
-                file_path=file_path,
-                group_index=group_index,
-            )
-        )
-    return tuple(sources)
-
-
-def parse_source_integration_loader(
-    *, entry: dict[str, object], file_path: Path
-) -> IntegrationLoaderConfig | None:
-    """Parse any source-level integration loader declaration."""
-
-    raw_ingestr: object | None = entry.get("ingestr")
-    if raw_ingestr is not None:
-        return IntegrationLoaderConfig(
-            kind="ingestr",
-            config=_parse_ingestr_source_config(raw_config=raw_ingestr, file_path=file_path),
-        )
-    return None
-
-
-def _parse_ingestr_source_config(*, raw_config: object, file_path: Path) -> IngestrSourceConfig:
-    if not isinstance(raw_config, dict):
-        raise SourceParseError(f"{file_path} source 'ingestr' must be a mapping")
-    config: dict[str, object] = cast(dict[str, object], raw_config)
-    reject_unknown_mapping_keys(
-        mapping=config,
-        allowed=_INGESTR_SOURCE_KEYS,
-        file_path=file_path,
-        label="source ingestr",
-        error_class=SourceParseError,
-    )
-    parsed: IngestrSourceConfig = IngestrSourceConfig(
-        source_uri=require_non_empty_string(
-            entry=config,
-            key="source_uri",
-            file_path=file_path,
-            label="source ingestr",
-            error_class=SourceParseError,
-        ),
-        source_table=require_non_empty_string(
-            entry=config,
-            key="source_table",
-            file_path=file_path,
-            label="source ingestr",
-            error_class=SourceParseError,
-        ),
-        strategy=optional_non_empty_string(
-            entry=config,
-            key="strategy",
-            file_path=file_path,
-            label="source ingestr",
-            error_class=SourceParseError,
-        ),
-        incremental_key=optional_non_empty_string(
-            entry=config,
-            key="incremental_key",
-            file_path=file_path,
-            label="source ingestr",
-            error_class=SourceParseError,
-        ),
-        primary_key=_optional_ingestr_primary_key(entry=config, file_path=file_path),
-        columns=optional_non_empty_string(
-            entry=config,
-            key="columns",
-            file_path=file_path,
-            label="source ingestr",
-            error_class=SourceParseError,
-        ),
-        extra_args=_optional_ingestr_string_tuple(
-            entry=config, key="extra_args", file_path=file_path
-        ),
-    )
-    if parsed.strategy is not None and parsed.strategy not in _ingestr_strategies:
-        strategies: str = ", ".join(sorted(_ingestr_strategies))
-        raise SourceParseError(f"{file_path} source ingestr strategy must be one of: {strategies}")
-    return parsed
-
-
-def _optional_ingestr_primary_key(*, entry: dict[str, object], file_path: Path) -> tuple[str, ...]:
-    primary_key: tuple[str, ...] = _optional_ingestr_string_tuple(
-        entry=entry, key="primary_key", file_path=file_path
-    )
-    unique_key: tuple[str, ...] = _optional_ingestr_string_tuple(
-        entry=entry, key="unique_key", file_path=file_path
-    )
-    if primary_key and unique_key:
-        raise SourceParseError(
-            f"{file_path} source ingestr cannot define both primary_key and unique_key"
-        )
-    return primary_key or unique_key
-
-
-def _optional_ingestr_string_tuple(
-    *, entry: dict[str, object], key: str, file_path: Path
-) -> tuple[str, ...]:
-    value: object | None = entry.get(key)
-    if value is None:
-        return ()
-    if isinstance(value, str):
-        stripped: str = value.strip()
-        if not stripped:
-            raise SourceParseError(f"{file_path} source ingestr '{key}' must be non-empty")
-        return (stripped,)
-    if isinstance(value, list):
-        items: list[str] = []
-        item: object
-        for item in value:
-            if not isinstance(item, str) or not item.strip():
-                raise SourceParseError(
-                    f"{file_path} source ingestr '{key}' must contain only non-empty strings"
-                )
-            items.append(item.strip())
-        return tuple(items)
-    raise SourceParseError(f"{file_path} source ingestr '{key}' must be a string or list")
-
-
-def _parse_dlt_source_group(
-    *, group: dict[str, object], file_path: Path, group_index: int
-) -> tuple[SourceEntry, ...]:
-    reject_unknown_mapping_keys(
-        mapping=group,
-        allowed=_DLT_SOURCE_GROUP_KEYS,
-        file_path=file_path,
-        label="dlt source",
-        error_class=SourceParseError,
-    )
-    source_type: str = require_non_empty_string(
-        entry=group,
-        key="type",
-        file_path=file_path,
-        label="dlt source",
-        error_class=SourceParseError,
-    )
-    if source_type not in DLT_SOURCE_TYPES:
-        raise SourceParseError(
-            f"{file_path} dlt source type must be one of: filesystem, rest_api, sql_database"
-        )
-    raw_config: object | None = group.get("config")
-    if not isinstance(raw_config, dict):
-        raise SourceParseError(f"{file_path} dlt source config must be a mapping")
-    group_config: dict[str, object] = cast(dict[str, object], raw_config)
-    destination_config: dict[str, object] = optional_mapping(
-        entry=group,
-        key="destination",
-        file_path=file_path,
-        label="dlt source",
-        error_class=SourceParseError,
-    )
-    _validate_dlt_destination_config(config=destination_config, file_path=file_path)
-    group_schema: str | None = optional_non_empty_string(
-        entry=group,
-        key="schema",
-        file_path=file_path,
-        label="dlt source",
-        error_class=SourceParseError,
-    )
-    _validate_dlt_group_config(source_type=source_type, config=group_config, file_path=file_path)
-    raw_resources: object = group.get("resources")
-    if not isinstance(raw_resources, list) or not raw_resources:
-        raise SourceParseError(f"{file_path} dlt source resources must be a non-empty list")
-    sources: list[SourceEntry] = []
-    raw_resource: object
-    for raw_resource in raw_resources:
-        if not isinstance(raw_resource, dict):
-            raise SourceParseError(f"{file_path} dlt source resources must contain only mappings")
-        sources.append(
-            _parse_dlt_resource_entry(
-                source_type=source_type,
-                group_schema=group_schema,
-                group_config=group_config,
-                destination_config=destination_config,
-                resource=cast(dict[str, object], raw_resource),
-                file_path=file_path,
-                group_index=group_index,
-            )
-        )
-    return tuple(sources)
-
-
-def _parse_dlt_resource_entry(
-    *,
-    source_type: str,
-    group_schema: str | None,
-    group_config: dict[str, object],
-    destination_config: dict[str, object],
-    resource: dict[str, object],
-    file_path: Path,
-    group_index: int,
-) -> SourceEntry:
-    name: str = require_non_empty_string(
-        entry=resource,
-        key="name",
-        file_path=file_path,
-        label="dlt resource",
-        error_class=SourceParseError,
-    )
-    if DLT_RESOURCE_WRITE_STRATEGY_KEY in resource:
-        raise SourceParseError(
-            f"{file_path} dlt resource '{name}' must use dlt write_disposition, not write_strategy"
-        )
-    reject_unknown_mapping_keys(
-        mapping=resource,
-        allowed=_DLT_RESOURCE_COMMON_KEYS | _DLT_RESOURCE_TYPE_KEYS[source_type],
-        file_path=file_path,
-        label=f"dlt {source_type} resource '{name}'",
-        error_class=SourceParseError,
-    )
-    dlt_name: str = _dlt_resource_name(
-        source_type=source_type, resource=resource, file_path=file_path
-    )
-    write_disposition: object | None = resource.get("write_disposition")
-    if write_disposition == DLT_WRITE_DISPOSITION_DELETE_INSERT:
-        raise SourceParseError(
-            f"{file_path} dlt resource '{name}' does not support delete_insert; use a Python loader"
-        )
-    if write_disposition == DLT_WRITE_DISPOSITION_MERGE and resource.get("primary_key") is None:
-        raise SourceParseError(f"{file_path} dlt resource '{name}' merge requires primary_key")
-    schema: str | None = (
-        optional_non_empty_string(
-            entry=resource,
-            key="schema",
-            file_path=file_path,
-            label=f"dlt resource '{name}'",
-            error_class=SourceParseError,
-        )
-        or group_schema
-    )
-    dlt_resource: DltResourceConfig = DltResourceConfig(
-        name=name,
-        dlt_name=dlt_name,
-        schema=schema,
-        raw_config=_raw_dlt_resource_config(source_type=source_type, resource=resource),
-        write_disposition=write_disposition,
-        primary_key=resource.get("primary_key"),
-        merge_key=resource.get("merge_key"),
-        incremental=optional_mapping(
-            entry=resource,
-            key="incremental",
-            file_path=file_path,
-            label=f"dlt resource '{name}'",
-            error_class=SourceParseError,
-        ),
-    )
-    return SourceEntry(
-        name=name,
-        description=optional_non_empty_string(
-            entry=resource,
-            key="description",
-            file_path=file_path,
-            label=f"dlt resource '{name}'",
-            error_class=SourceParseError,
-        ),
-        schema=schema,
-        table=name,
-        managed=True,
-        loader=integration_loader_name(kind="dlt", source_name=name),
-        integration_loader=IntegrationLoaderConfig(
-            kind="dlt",
-            config=DltSourceConfig(
-                source_type=source_type,
-                schema=schema,
-                config=group_config,
-                destination=destination_config,
-                resource=dlt_resource,
-                group_index=group_index,
-            ),
-        ),
-    )
-
-
-def _validate_dlt_group_config(
-    *, source_type: str, config: dict[str, object], file_path: Path
-) -> None:
-    if source_type == DLT_SOURCE_TYPE_REST_API:
-        client: object | None = config.get("client")
-        if not isinstance(client, dict):
-            raise SourceParseError(f"{file_path} dlt rest_api config requires client.base_url")
-        client_config: dict[str, object] = cast(dict[str, object], client)
-        if not isinstance(client_config.get("base_url"), str):
-            raise SourceParseError(f"{file_path} dlt rest_api config requires client.base_url")
-    if source_type == DLT_SOURCE_TYPE_SQL_DATABASE and not isinstance(
-        config.get("credentials"), str
-    ):
-        raise SourceParseError(f"{file_path} dlt sql_database config requires credentials")
-    if source_type == DLT_SOURCE_TYPE_FILESYSTEM and not isinstance(config.get("bucket_url"), str):
-        raise SourceParseError(f"{file_path} dlt filesystem config requires bucket_url")
-
-
-def _validate_dlt_destination_config(*, config: dict[str, object], file_path: Path) -> None:
-    blocked_keys: tuple[str, ...] = ("credentials", "dataset_name", "default_schema_name")
-    blocked_key: str
-    for blocked_key in blocked_keys:
-        if blocked_key in config:
-            raise SourceParseError(
-                f"{file_path} dlt source destination cannot define '{blocked_key}'"
-            )
-
-
-def _dlt_resource_name(*, source_type: str, resource: dict[str, object], file_path: Path) -> str:
-    if source_type == DLT_SOURCE_TYPE_SQL_DATABASE:
-        return require_non_empty_string(
-            entry=resource,
-            key="table",
-            file_path=file_path,
-            label="dlt sql_database resource",
-            error_class=SourceParseError,
-        )
-    if source_type == DLT_SOURCE_TYPE_REST_API:
-        endpoint: object | None = resource.get("endpoint")
-        if not isinstance(endpoint, dict):
-            raise SourceParseError(f"{file_path} dlt rest_api resource must define endpoint")
-        endpoint_config: dict[str, object] = cast(dict[str, object], endpoint)
-        endpoint_name: object | None = endpoint_config.get("name")
-        if isinstance(endpoint_name, str) and endpoint_name.strip():
-            return endpoint_name
-        return require_non_empty_string(
-            entry=resource,
-            key="name",
-            file_path=file_path,
-            label="dlt rest_api resource",
-            error_class=SourceParseError,
-        )
-    return require_non_empty_string(
-        entry=resource,
-        key="name",
-        file_path=file_path,
-        label="dlt filesystem resource",
-        error_class=SourceParseError,
-    )
-
-
-def _raw_dlt_resource_config(*, source_type: str, resource: dict[str, object]) -> dict[str, object]:
-    excluded: set[str] = {
-        "name",
-        "table",
-        "write_disposition",
-        "primary_key",
-        "merge_key",
-        "incremental",
-        "schema",
-        "description",
-    }
-    if source_type == DLT_SOURCE_TYPE_REST_API:
-        return {"endpoint": resource["endpoint"]}
-    return {key: value for key, value in resource.items() if key not in excluded}
diff --git a/src/sqlbuild/compiler/discovery/_helpers/native/model_files.py b/src/sqlbuild/compiler/discovery/_helpers/native/model_files.py
index be9389a8f3..bb40b05506 100644
--- a/src/sqlbuild/compiler/discovery/_helpers/native/model_files.py
+++ b/src/sqlbuild/compiler/discovery/_helpers/native/model_files.py
@@ -1,4 +1,4 @@
-"""SQL model files discovered by the native engine, materialised as Python discovery records."""
+"""SQL model files discovered by the native engine as native records."""
 
 from __future__ import annotations
 
@@ -10,7 +10,6 @@
 from sqlbuild.compiler.discovery._helpers.native.payloads import (
     materialise_native_files,
     native_collection,
-    native_locations,
     native_payload_error,
     native_project_tree,
     native_request,
@@ -21,13 +20,10 @@
     REMOVED_SQL_MODEL_HEADER_KEYS,
     SQL_MODEL_HEADER_KEYS,
 )
-from sqlbuild.compiler.discovery.models import (
-    ConstantDeclaration,
-    DiscoveredSqlModelFile,
-    DiscoveryFileFault,
-    EnumDeclaration,
-)
-from sqlbuild.compiler.discovery.types import NativeFiles, NativeLocation
+from sqlbuild.compiler.discovery.models import DiscoveredSqlModelFile, DiscoveryFileFault
+from sqlbuild.compiler.discovery.types import NativeModelFiles
+
+_RAISED_TAG: str = "raised"
 
 
 def discover_native_model_files(
@@ -42,7 +38,7 @@ def discover_native_model_files(
 
     with DirectorySnapshot.scope(project_dir=project_dir):
         tree: _native.NativeProjectTree = native_project_tree(project_dir)
-        files: NativeFiles = native_collection(
+        files: NativeModelFiles = native_collection(
             result=_native.discover_model_files(
                 native_request(
                     project_dir=project_dir,
@@ -54,6 +50,7 @@ def discover_native_model_files(
                     },
                 ),
                 tree,
+                project_dir,
             ),
             project_dir=project_dir,
         )
@@ -61,54 +58,24 @@ def discover_native_model_files(
     return materialise_native_files(
         project_dir=project_dir,
         files=(
-            (Path(relative_path), payload)
-            for relative_path, payload in files
-            if selected_model_names is None or Path(relative_path).stem in selected_model_names
+            (relative_path, item)
+            for relative_path, item in files
+            if selected_model_names is None or relative_path.stem in selected_model_names
         ),
-        build=lambda relative_path, payload: _model_file(
-            project_dir=project_dir,
-            relative_path=relative_path,
-            payload=payload,
-            extract_implicit_alias_columns=extract_implicit_alias_columns,
+        build=lambda relative_path, item: _model_file(
+            project_dir=project_dir, relative_path=relative_path, item=item
         ),
         on_fault=on_fault,
     )
 
 
-def _model_file(
-    *,
-    project_dir: Path,
-    relative_path: Path,
-    payload: tuple[object, ...],
-    extract_implicit_alias_columns: bool,
-) -> DiscoveredSqlModelFile:
-    file_path: Path = project_dir / relative_path
-    error: Exception | None = native_payload_error(payload=payload, file_path=file_path)
-    if error is not None:
-        raise error
-    _tag, contents, values, header_locations, output_locations, query_sql = payload
-    header_values: dict[str, object] = cast(dict[str, object], values)
-    enum_declarations, constant_declarations = cast(
-        tuple[tuple[EnumDeclaration, ...], tuple[ConstantDeclaration, ...]],
-        _native.model_header_declarations(
-            (header_values.get("enums"), header_values.get("constants")),
-            file_path.stem,
-            relative_path,
-        ),
-    )
-    return DiscoveredSqlModelFile(
-        file_path=file_path,
-        relative_path=relative_path,
-        contents=str(contents),
-        header_values=header_values,
-        header_column_locations=native_locations(
-            locations=cast(list[NativeLocation], header_locations), relative_path=relative_path
-        ),
-        output_column_locations=native_locations(
-            locations=cast(list[NativeLocation], output_locations), relative_path=relative_path
-        ),
-        query_sql=str(query_sql),
-        enum_declarations=enum_declarations,
-        constant_declarations=constant_declarations,
-        extract_implicit_alias_columns=extract_implicit_alias_columns,
+def _model_file(*, project_dir: Path, relative_path: Path, item: object) -> DiscoveredSqlModelFile:
+    if isinstance(item, DiscoveredSqlModelFile):
+        return item
+    payload: tuple[object, ...] = cast(tuple[object, ...], item)
+    if payload[0] == _RAISED_TAG:
+        raise cast(Exception, payload[1])
+    error: Exception | None = native_payload_error(
+        payload=payload, file_path=project_dir / relative_path
     )
+    raise error if error is not None else ValueError(payload)
diff --git a/src/sqlbuild/compiler/discovery/_helpers/native/payloads.py b/src/sqlbuild/compiler/discovery/_helpers/native/payloads.py
index eb2106d006..b6255bcc15 100644
--- a/src/sqlbuild/compiler/discovery/_helpers/native/payloads.py
+++ b/src/sqlbuild/compiler/discovery/_helpers/native/payloads.py
@@ -16,10 +16,12 @@
 )
 from sqlbuild.compiler.discovery.exceptions import (
     DeclarationParseError,
+    DiscoveryConflictError,
     DiscoveryError,
     ModelSqlParseError,
     ProjectPathError,
     SchemaParseError,
+    SeedDiscoveryError,
     SourceParseError,
     SqlAuditParseError,
     SqlHookParseError,
@@ -58,6 +60,8 @@
     "sql_hook": SqlHookParseError,
     "sql_audit": SqlAuditParseError,
     "resource_identity": ResourceIdentityError,
+    "conflict": DiscoveryConflictError,
+    "seed": SeedDiscoveryError,
 }
 
 
@@ -119,11 +123,11 @@ def native_collection[ResultT](
     raise native_failure(payload)
 
 
-def materialise_native_files[RecordT](
+def materialise_native_files[ItemT, RecordT](
     *,
     project_dir: Path,
-    files: Iterable[tuple[Path, tuple[object, ...]]],
-    build: Callable[[Path, tuple[object, ...]], RecordT],
+    files: Iterable[tuple[Path, ItemT]],
+    build: Callable[[Path, ItemT], RecordT],
     on_fault: Callable[[DiscoveryFileFault], None] | None,
 ) -> tuple[RecordT, ...]:
     """Build each native file payload, reporting and skipping a failing file when asked."""
diff --git a/src/sqlbuild/compiler/discovery/_helpers/validation/discovery.py b/src/sqlbuild/compiler/discovery/_helpers/validation/discovery.py
index ee1920118e..7301212521 100644
--- a/src/sqlbuild/compiler/discovery/_helpers/validation/discovery.py
+++ b/src/sqlbuild/compiler/discovery/_helpers/validation/discovery.py
@@ -1,275 +1,97 @@
-"""Cross-file discovery validation helpers."""
+"""Cross-file discovery validation, run natively over the facts of one discovery."""
 
 from __future__ import annotations
 
 import csv
+from collections.abc import Callable
 from pathlib import Path
+from typing import Protocol, cast
 
-from sqlbuild.compiler.discovery._helpers.integrations.loaders import integration_loader_name
-from sqlbuild.compiler.discovery._helpers.validation.identities import (
-    validate_discovered_resource_identities,
-)
-from sqlbuild.compiler.discovery.constants import CURRENT_DIRECTORY_PATH, RESERVED_MODEL_NAMES
-from sqlbuild.compiler.discovery.exceptions import DiscoveryConflictError, SeedDiscoveryError
+import sqlbuild._native as _native
+from sqlbuild.compiler.discovery._helpers.native.payloads import native_failure, native_read_error
 from sqlbuild.compiler.discovery.models import (
     DiscoveredAssetFunction,
     DiscoveredCheckFunction,
-    DiscoveredHookFunction,
     DiscoveredLoaderFunction,
     DiscoveredProjectInputs,
-    DiscoveredProvider,
-    DiscoveredPythonFunctionFile,
-    DiscoveredSchemaFile,
-    DiscoveredSeedFile,
-    DiscoveredSourceFile,
-    DiscoveredSqlFunctionFile,
-    DiscoveredSqlHookFile,
-    DiscoveredSqlModelFile,
-    DiscoveredSqlScenarioFile,
-    DiscoveredSqlTestBlock,
-    DiscoveredSqlTestFile,
     DiscoveredTaskFunction,
 )
-from sqlbuild.compiler.path_defaults.main._select import select_path_default
 from sqlbuild.python_nodes.main.read_asset_definition import read_asset_definition
 from sqlbuild.python_nodes.main.read_check_definition import read_check_definition
 from sqlbuild.python_nodes.main.read_loader_definition import read_loader_definition
 from sqlbuild.python_nodes.main.read_task_definition import read_task_definition
-from sqlbuild.python_nodes.models import (
-    AssetDefinition,
-    CheckDefinition,
-    LoaderDefinition,
-    SqlResourceRef,
-    TaskDefinition,
-)
-from sqlbuild.spec.contracts.models import SchemaModelEntry, SchemaSeedEntry, SourceEntry
-
-
-def validate_discovered_inputs(discovered_inputs: DiscoveredProjectInputs) -> None:
-    """Validate cross-file conflicts across discovered project inputs."""
-
-    validate_discovered_resource_identities(discovered_inputs)
-    _validate_unique_model_file_names(discovered_inputs.model_files)
-    _validate_unique_scenario_file_names(discovered_inputs.scenario_files)
-    _validate_unique_source_names(discovered_inputs.source_files)
-    _validate_unique_loader_names(discovered_inputs.loader_functions)
-    _validate_unique_python_node_names(
-        loader_functions=discovered_inputs.loader_functions,
-        task_functions=discovered_inputs.task_functions,
-        asset_functions=discovered_inputs.asset_functions,
-        check_functions=discovered_inputs.check_functions,
-    )
-    _validate_source_loader_name_collisions(
-        source_files=discovered_inputs.source_files,
-        loader_functions=discovered_inputs.loader_functions,
-    )
-    _validate_loader_dependencies(discovered_inputs.loader_functions)
-    _validate_python_node_dependencies(
-        loader_functions=discovered_inputs.loader_functions,
-        task_functions=discovered_inputs.task_functions,
-        asset_functions=discovered_inputs.asset_functions,
-    )
-    _validate_check_dependencies(
-        loader_functions=discovered_inputs.loader_functions,
-        task_functions=discovered_inputs.task_functions,
-        asset_functions=discovered_inputs.asset_functions,
-        check_functions=discovered_inputs.check_functions,
-    )
-    _validate_source_loader_references(
-        source_files=discovered_inputs.source_files,
-        loader_functions=discovered_inputs.loader_functions,
-    )
-    _validate_terminal_loader_config_ownership(
-        source_files=discovered_inputs.source_files,
-        loader_functions=discovered_inputs.loader_functions,
-    )
-    _validate_unique_schema_model_names(discovered_inputs.schema_files)
-    _validate_unique_schema_seed_names(discovered_inputs.schema_files)
-    _validate_unique_logical_relation_names(
-        model_files=discovered_inputs.model_files,
-        source_files=discovered_inputs.source_files,
-        schema_files=discovered_inputs.schema_files,
-    )
-    _validate_declared_seed_files(
-        schema_files=discovered_inputs.schema_files,
-        seed_files=discovered_inputs.seed_files,
-    )
-    _validate_unique_project_resource_names(discovered_inputs)
-    _validate_path_defaults_match_models(
-        path_defaults=discovered_inputs.project_config.path_defaults,
-        model_files=discovered_inputs.model_files,
-    )
-
-
-def _validate_unique_model_file_names(model_files: tuple[DiscoveredSqlModelFile, ...]) -> None:
-    seen_names: dict[str, str] = {}
-    model_file: DiscoveredSqlModelFile
-    for model_file in model_files:
-        model_name: str = model_file.file_path.stem
-        if model_name in RESERVED_MODEL_NAMES:
-            raise DiscoveryConflictError(
-                f"Model name '{model_name}' in {model_file.relative_path} is reserved "
-                "by SQLBuild for compiled output structure"
-            )
-        existing_path: str | None = seen_names.get(model_name)
-        if existing_path is not None:
-            raise DiscoveryConflictError(
-                f"Duplicate model file name found for '{model_name}' in "
-                f"{existing_path} and {model_file.relative_path}"
-            )
-        seen_names[model_name] = str(model_file.relative_path)
-
-
-def _validate_unique_scenario_file_names(
-    scenario_files: tuple[DiscoveredSqlScenarioFile, ...],
-) -> None:
-    seen_names: dict[str, str] = {}
-    scenario_file: DiscoveredSqlScenarioFile
-    for scenario_file in scenario_files:
-        existing_path: str | None = seen_names.get(scenario_file.name)
-        if existing_path is not None:
-            raise DiscoveryConflictError(
-                f"Duplicate scenario file name found for '{scenario_file.name}' in "
-                f"{existing_path} and {scenario_file.relative_path}"
-            )
-        seen_names[scenario_file.name] = str(scenario_file.relative_path)
-
+from sqlbuild.python_nodes.models import SqlResourceRef
 
-def _validate_unique_source_names(source_files: tuple[DiscoveredSourceFile, ...]) -> None:
-    seen_names: dict[str, str] = {}
-    source_file: DiscoveredSourceFile
-    for source_file in source_files:
-        source_entry: SourceEntry
-        for source_entry in source_file.source_entries:
-            existing_path: str | None = seen_names.get(source_entry.name)
-            if existing_path is not None:
-                raise DiscoveryConflictError(
-                    "Duplicate source declaration found for "
-                    f"'{source_entry.name}' in {existing_path} and {source_file.relative_path}"
-                )
-            seen_names[source_entry.name] = str(source_file.relative_path)
-
-
-def _validate_unique_loader_names(loader_functions: tuple[DiscoveredLoaderFunction, ...]) -> None:
-    seen_names: dict[str, str] = {}
-    loader_function: DiscoveredLoaderFunction
-    for loader_function in loader_functions:
-        existing_path: str | None = seen_names.get(loader_function.name)
-        if existing_path is not None:
-            raise DiscoveryConflictError(
-                f"Duplicate source loader found for '{loader_function.name}' in "
-                f"{existing_path} and {loader_function.relative_path}"
-            )
-        seen_names[loader_function.name] = str(loader_function.relative_path)
+type _PythonNode = (
+    DiscoveredLoaderFunction
+    | DiscoveredTaskFunction
+    | DiscoveredAssetFunction
+    | DiscoveredCheckFunction
+)
 
 
-def _validate_unique_python_node_names(
-    *,
-    loader_functions: tuple[DiscoveredLoaderFunction, ...],
-    task_functions: tuple[DiscoveredTaskFunction, ...],
-    asset_functions: tuple[DiscoveredAssetFunction, ...],
-    check_functions: tuple[DiscoveredCheckFunction, ...],
-) -> None:
-    seen_names: dict[str, str] = {}
-    for nodes in (
-        loader_functions,
-        task_functions,
-        asset_functions,
-        check_functions,
-    ):
-        for node in nodes:
-            existing_path: str | None = seen_names.get(node.name)
-            if existing_path is not None:
-                raise DiscoveryConflictError(
-                    f"Duplicate Python node found for '{node.name}' in "
-                    f"{existing_path} and {node.relative_path}; loader, task, asset, and check "
-                    "names must be globally unique"
-                )
-            seen_names[node.name] = str(node.relative_path)
+class _NodeDefinition(Protocol):
+    @property
+    def name(self) -> str: ...
 
 
-def _validate_source_loader_name_collisions(
-    *,
-    source_files: tuple[DiscoveredSourceFile, ...],
-    loader_functions: tuple[DiscoveredLoaderFunction, ...],
-) -> None:
-    loader_paths_by_name: dict[str, str] = {
-        loader.name: str(loader.relative_path) for loader in loader_functions
-    }
-    source_file: DiscoveredSourceFile
-    for source_file in source_files:
-        source_entry: SourceEntry
-        for source_entry in source_file.source_entries:
-            loader_path: str | None = loader_paths_by_name.get(source_entry.name)
-            if loader_path is None:
-                continue
-            if source_entry.managed and source_entry.loader == source_entry.name:
-                continue
-            raise DiscoveryConflictError(
-                f"Source '{source_entry.name}' in {source_file.relative_path} conflicts with "
-                f"loader '{source_entry.name}' in {loader_path}; source and loader names must "
-                "be globally unique unless the source is managed"
-            )
-
+_UNREADABLE_TAG: str = "unreadable"
+_CSV_ERROR_TAG: str = "csv"
+_CSV_DIALECT_TAG: str = "csv_dialect"
+_CSV_DIALECT_ERRORS: dict[str, type[Exception]] = {"TypeError": TypeError, "ValueError": ValueError}
+_DEFINITION_READERS: tuple[Callable[[Callable[..., object]], _NodeDefinition | None], ...] = (
+    read_loader_definition,
+    read_task_definition,
+    read_asset_definition,
+    read_check_definition,
+)
 
-def _validate_source_loader_references(
-    *,
-    source_files: tuple[DiscoveredSourceFile, ...],
-    loader_functions: tuple[DiscoveredLoaderFunction, ...],
-) -> None:
-    loader_names: frozenset[str] = frozenset(loader.name for loader in loader_functions)
-    source_file: DiscoveredSourceFile
-    for source_file in source_files:
-        source_entry: SourceEntry
-        for source_entry in source_file.source_entries:
-            expected_loader: str | None = source_entry.name
-            if source_entry.integration_loader is not None:
-                expected_loader = integration_loader_name(
-                    kind=source_entry.integration_loader.kind,
-                    source_name=source_entry.name,
-                )
-            if source_entry.managed and source_entry.loader != expected_loader:
-                raise DiscoveryConflictError(
-                    f"Managed source '{source_entry.name}' in {source_file.relative_path} must "
-                    f"use terminal loader '{expected_loader}'"
-                )
-            if source_entry.managed and expected_loader not in loader_names:
-                raise DiscoveryConflictError(
-                    f"Managed source '{source_entry.name}' in {source_file.relative_path} "
-                    f"requires loader '{expected_loader}'"
-                )
-            if source_entry.loader is None or source_entry.loader in loader_names:
-                continue
-            raise DiscoveryConflictError(
-                f"Source '{source_entry.name}' in {source_file.relative_path} references "
-                f"unknown loader '{source_entry.loader}'"
-            )
 
+def validate_discovered_inputs(discovered_inputs: DiscoveredProjectInputs) -> None:
+    """Validate cross-file conflicts across discovered project inputs."""
 
-def _validate_terminal_loader_config_ownership(
-    *,
-    source_files: tuple[DiscoveredSourceFile, ...],
-    loader_functions: tuple[DiscoveredLoaderFunction, ...],
-) -> None:
-    loader_by_name: dict[str, DiscoveredLoaderFunction] = {
-        loader.name: loader for loader in loader_functions
+    payload: tuple[object, ...] | None = _native.discovered_inputs_failure(
+        discovered_inputs, _nodes(discovered_inputs)
+    )
+    if payload is None:
+        return
+    tag: object = payload[0]
+    if tag == _UNREADABLE_TAG:
+        raise native_read_error(
+            payload=cast(tuple[object, ...], payload[2]), file_path=Path(str(payload[1]))
+        )
+    if tag == _CSV_ERROR_TAG:
+        raise csv.Error(str(payload[1]))
+    if tag == _CSV_DIALECT_TAG:
+        raise _CSV_DIALECT_ERRORS[str(payload[1])](str(payload[2]))
+    raise native_failure(payload)
+
+
+def _nodes(inputs: DiscoveredProjectInputs) -> list[dict[str, object]]:
+    nodes: tuple[tuple[str, _PythonNode], ...] = (
+        *(("loader", node) for node in inputs.loader_functions),
+        *(("task", node) for node in inputs.task_functions),
+        *(("asset", node) for node in inputs.asset_functions),
+        *(("check", node) for node in inputs.check_functions),
+    )
+    owners: dict[object, int] = {node.function: index for index, (_, node) in enumerate(nodes)}
+    return [_node(kind=kind, node=node, owners=owners) for kind, node in nodes]
+
+
+def _node(*, kind: str, node: _PythonNode, owners: dict[object, int]) -> dict[str, object]:
+    return {
+        "kind": kind,
+        "name": node.name,
+        "path": str(node.relative_path),
+        "decorator_config": isinstance(node, DiscoveredLoaderFunction)
+        and _loader_has_decorator_config(node),
+        "depends_on": [
+            (dependency.name, None, None)
+            if isinstance(dependency, SqlResourceRef)
+            else (None, owners.get(dependency), _decorated_name(dependency))
+            for dependency in node.depends_on
+        ],
     }
-    source_file: DiscoveredSourceFile
-    for source_file in source_files:
-        source_entry: SourceEntry
-        for source_entry in source_file.source_entries:
-            if source_entry.loader is None:
-                continue
-            loader_function: DiscoveredLoaderFunction | None = loader_by_name.get(
-                source_entry.loader
-            )
-            if loader_function is None or not _loader_has_decorator_config(loader_function):
-                continue
-            raise DiscoveryConflictError(
-                f"Source '{source_entry.name}' references loader '{source_entry.loader}', "
-                "but terminal source loader write and schema config must be declared in "
-                "source YAML, not the @loader decorator"
-            )
 
 
 def _loader_has_decorator_config(loader_function: DiscoveredLoaderFunction) -> bool:
@@ -285,574 +107,11 @@ def _loader_has_decorator_config(loader_function: DiscoveredLoaderFunction) -> b
     )
 
 
-def _validate_loader_dependencies(loader_functions: tuple[DiscoveredLoaderFunction, ...]) -> None:
-    loader_by_function: dict[object, DiscoveredLoaderFunction] = {
-        loader.function: loader for loader in loader_functions
-    }
-    visiting: set[str] = set()
-    visited: set[str] = set()
-
-    def visit(
-        *,
-        loader_function: DiscoveredLoaderFunction,
-        path: tuple[str, ...],
-        visiting_names: set[str],
-        visited_names: set[str],
-    ) -> tuple[set[str], set[str]]:
-        if loader_function.name in visited_names:
-            return visiting_names, visited_names
-        if loader_function.name in visiting_names:
-            cycle_path: str = " -> ".join((*path, loader_function.name))
-            raise DiscoveryConflictError(f"Loader dependency cycle detected: {cycle_path}")
-        visiting_names = visiting_names | {loader_function.name}
-        dependency: object
-        for dependency in loader_function.depends_on:
-            if dependency in loader_by_function:
-                visiting_names, visited_names = visit(
-                    loader_function=loader_by_function[dependency],
-                    path=(*path, loader_function.name),
-                    visiting_names=visiting_names,
-                    visited_names=visited_names,
-                )
-        visiting_names = visiting_names - {loader_function.name}
-        visited_names = visited_names | {loader_function.name}
-        return visiting_names, visited_names
-
-    for loader_function in loader_functions:
-        visiting, visited = visit(
-            loader_function=loader_function,
-            path=(),
-            visiting_names=visiting,
-            visited_names=visited,
-        )
-
-
-def _validate_python_node_dependencies(
-    *,
-    loader_functions: tuple[DiscoveredLoaderFunction, ...],
-    task_functions: tuple[DiscoveredTaskFunction, ...],
-    asset_functions: tuple[DiscoveredAssetFunction, ...],
-) -> None:
-    nodes: tuple[
-        DiscoveredLoaderFunction | DiscoveredTaskFunction | DiscoveredAssetFunction, ...
-    ] = (
-        *loader_functions,
-        *task_functions,
-        *asset_functions,
-    )
-    node_by_dependency_key: dict[
-        object | tuple[str, str],
-        DiscoveredLoaderFunction | DiscoveredTaskFunction | DiscoveredAssetFunction,
-    ] = {node.function: node for node in nodes}
-    for node in nodes:
-        node_by_dependency_key[("name", node.name)] = node
-    node: DiscoveredLoaderFunction | DiscoveredTaskFunction | DiscoveredAssetFunction
-    for node in nodes:
-        dependency: object
-        for dependency in node.depends_on:
-            if isinstance(dependency, SqlResourceRef):
-                if isinstance(node, DiscoveredLoaderFunction):
-                    raise DiscoveryConflictError(
-                        f"Loader '{node.name}' depends on SQL resource "
-                        f"'{dependency.name}'; loaders "
-                        "may depend on Python loader/task/asset functions only"
-                    )
-                continue
-            if _python_node_dependency_key(dependency) not in node_by_dependency_key:
-                if isinstance(node, DiscoveredLoaderFunction):
-                    raise DiscoveryConflictError(
-                        f"Loader '{node.name}' depends on an unknown loader"
-                    )
-                raise DiscoveryConflictError(
-                    f"Python node '{node.name}' depends on an unknown Python node; "
-                    "use function references to decorated loaders, tasks, or assets"
-                )
-
-    visiting: set[str] = set()
-    visited: set[str] = set()
-
-    def visit(
-        *,
-        current: DiscoveredLoaderFunction | DiscoveredTaskFunction | DiscoveredAssetFunction,
-        path: tuple[str, ...],
-        visiting_names: set[str],
-        visited_names: set[str],
-    ) -> tuple[set[str], set[str]]:
-        if current.name in visited_names:
-            return visiting_names, visited_names
-        if current.name in visiting_names:
-            cycle_path: str = " -> ".join((*path, current.name))
-            raise DiscoveryConflictError(f"Python node dependency cycle detected: {cycle_path}")
-        visiting_names = visiting_names | {current.name}
-        dependency: object
-        for dependency in current.depends_on:
-            if isinstance(dependency, SqlResourceRef):
-                continue
-            visiting_names, visited_names = visit(
-                current=node_by_dependency_key[_python_node_dependency_key(dependency)],
-                path=(*path, current.name),
-                visiting_names=visiting_names,
-                visited_names=visited_names,
-            )
-        visiting_names = visiting_names - {current.name}
-        visited_names = visited_names | {current.name}
-        return visiting_names, visited_names
-
-    for node in nodes:
-        visiting, visited = visit(
-            current=node,
-            path=(),
-            visiting_names=visiting,
-            visited_names=visited,
-        )
-
-
-def _validate_check_dependencies(
-    *,
-    loader_functions: tuple[DiscoveredLoaderFunction, ...],
-    task_functions: tuple[DiscoveredTaskFunction, ...],
-    asset_functions: tuple[DiscoveredAssetFunction, ...],
-    check_functions: tuple[DiscoveredCheckFunction, ...],
-) -> None:
-    allowed_dependency_keys: frozenset[object | tuple[str, str]] = frozenset(
-        ("name", node.name) for node in (*loader_functions, *task_functions, *asset_functions)
-    )
-    check_dependency_keys: frozenset[object | tuple[str, str]] = frozenset(
-        ("name", check_function.name) for check_function in check_functions
-    )
-    check_function: DiscoveredCheckFunction
-    for check_function in check_functions:
-        dependency: object
-        for dependency in check_function.depends_on:
-            if isinstance(dependency, SqlResourceRef):
-                continue
-            dependency_key: object | tuple[str, str] = _python_node_dependency_key(dependency)
-            if dependency_key in check_dependency_keys:
-                raise DiscoveryConflictError(
-                    f"Check '{check_function.name}' depends on another check; checks may "
-                    "depend on loaders, tasks, assets, models, sources, and seeds only"
-                )
-            if dependency_key not in allowed_dependency_keys:
-                raise DiscoveryConflictError(
-                    f"Check '{check_function.name}' depends on an unknown Python node; "
-                    "use function references to decorated loaders, tasks, or assets"
-                )
-
-
-def _python_node_dependency_key(dependency: object) -> object | tuple[str, str]:
-    loader_definition: LoaderDefinition | None = (
-        read_loader_definition(dependency) if callable(dependency) else None
-    )
-    if loader_definition is not None:
-        return ("name", loader_definition.name)
-    task_definition: TaskDefinition | None = (
-        read_task_definition(dependency) if callable(dependency) else None
-    )
-    if task_definition is not None:
-        return ("name", task_definition.name)
-    asset_definition: AssetDefinition | None = (
-        read_asset_definition(dependency) if callable(dependency) else None
-    )
-    if asset_definition is not None:
-        return ("name", asset_definition.name)
-    check_definition: CheckDefinition | None = (
-        read_check_definition(dependency) if callable(dependency) else None
-    )
-    if check_definition is not None:
-        return ("name", check_definition.name)
-    return dependency
-
-
-def _validate_unique_schema_model_names(schema_files: tuple[DiscoveredSchemaFile, ...]) -> None:
-    seen_names: dict[str, str] = {}
-    schema_file: DiscoveredSchemaFile
-    for schema_file in schema_files:
-        model_entry: SchemaModelEntry
-        for model_entry in schema_file.model_entries:
-            existing_path: str | None = seen_names.get(model_entry.name)
-            if existing_path is not None:
-                raise DiscoveryConflictError(
-                    "Duplicate schema.yml model declaration found for "
-                    f"'{model_entry.name}' in {existing_path} and {schema_file.relative_path}"
-                )
-            seen_names[model_entry.name] = str(schema_file.relative_path)
-
-
-def _validate_unique_schema_seed_names(schema_files: tuple[DiscoveredSchemaFile, ...]) -> None:
-    seen_names: dict[str, str] = {}
-    schema_file: DiscoveredSchemaFile
-    for schema_file in schema_files:
-        seed_entry: SchemaSeedEntry
-        for seed_entry in schema_file.seed_entries:
-            existing_path: str | None = seen_names.get(seed_entry.name)
-            if existing_path is not None:
-                raise DiscoveryConflictError(
-                    "Duplicate seed declaration found for "
-                    f"'{seed_entry.name}' in {existing_path} and {schema_file.relative_path}"
-                )
-            seen_names[seed_entry.name] = str(schema_file.relative_path)
-
-
-def _validate_unique_logical_relation_names(
-    *,
-    model_files: tuple[DiscoveredSqlModelFile, ...],
-    source_files: tuple[DiscoveredSourceFile, ...],
-    schema_files: tuple[DiscoveredSchemaFile, ...],
-) -> None:
-    seen_names: dict[str, tuple[str, str]] = {}
-    model_file: DiscoveredSqlModelFile
-    for model_file in model_files:
-        seen_names[model_file.file_path.stem] = ("model", str(model_file.relative_path))
-
-    source_file: DiscoveredSourceFile
-    for source_file in source_files:
-        source_entry: SourceEntry
-        for source_entry in source_file.source_entries:
-            seen_names[source_entry.name] = _validated_logical_relation_entry(
-                seen_names=seen_names,
-                name=source_entry.name,
-                kind="source",
-                path=str(source_file.relative_path),
-            )
-
-    schema_file: DiscoveredSchemaFile
-    for schema_file in schema_files:
-        seed_entry: SchemaSeedEntry
-        for seed_entry in schema_file.seed_entries:
-            seen_names[seed_entry.name] = _validated_logical_relation_entry(
-                seen_names=seen_names,
-                name=seed_entry.name,
-                kind="seed",
-                path=str(schema_file.relative_path),
-            )
-
-
-def _validated_logical_relation_entry(
-    *, seen_names: dict[str, tuple[str, str]], name: str, kind: str, path: str
-) -> tuple[str, str]:
-    existing_entry: tuple[str, str] | None = seen_names.get(name)
-    if existing_entry is not None:
-        raise DiscoveryConflictError(
-            f"Logical relation name '{name}' is declared as both {existing_entry[0]} "
-            f"in {existing_entry[1]} and {kind} in {path}"
-        )
-    return (kind, path)
-
-
-def _validate_unique_project_resource_names(
-    discovered_inputs: DiscoveredProjectInputs,
-) -> None:
-    seen_names: dict[str, tuple[str, str]] = {}
-
-    model_file: DiscoveredSqlModelFile
-    for model_file in discovered_inputs.model_files:
-        seen_names[model_file.file_path.stem] = _validated_project_resource_entry(
-            seen_names=seen_names,
-            name=model_file.file_path.stem,
-            kind="model",
-            path=str(model_file.relative_path),
-        )
-
-    source_file: DiscoveredSourceFile
-    managed_source_names: set[str] = set()
-    for source_file in discovered_inputs.source_files:
-        source_entry: SourceEntry
-        for source_entry in source_file.source_entries:
-            if source_entry.managed:
-                managed_source_names.add(source_entry.name)
-            seen_names[source_entry.name] = _validated_project_resource_entry(
-                seen_names=seen_names,
-                name=source_entry.name,
-                kind="source",
-                path=str(source_file.relative_path),
-            )
-
-    schema_file: DiscoveredSchemaFile
-    for schema_file in discovered_inputs.schema_files:
-        seed_entry: SchemaSeedEntry
-        for seed_entry in schema_file.seed_entries:
-            seen_names[seed_entry.name] = _validated_project_resource_entry(
-                seen_names=seen_names,
-                name=seed_entry.name,
-                kind="seed",
-                path=str(schema_file.relative_path),
-            )
-
-    sql_function_file: DiscoveredSqlFunctionFile
-    for sql_function_file in discovered_inputs.sql_function_files:
-        seen_names[sql_function_file.file_path.stem] = _validated_project_resource_entry(
-            seen_names=seen_names,
-            name=sql_function_file.file_path.stem,
-            kind="function",
-            path=str(sql_function_file.relative_path),
-        )
-
-    python_function_file: DiscoveredPythonFunctionFile
-    for python_function_file in discovered_inputs.python_function_files:
-        seen_names[python_function_file.file_path.stem] = _validated_project_resource_entry(
-            seen_names=seen_names,
-            name=python_function_file.file_path.stem,
-            kind="function",
-            path=str(python_function_file.relative_path),
-        )
-
-    node: (
-        DiscoveredLoaderFunction
-        | DiscoveredTaskFunction
-        | DiscoveredAssetFunction
-        | DiscoveredCheckFunction
-    )
-    for node in (
-        *discovered_inputs.loader_functions,
-        *discovered_inputs.task_functions,
-        *discovered_inputs.asset_functions,
-        *discovered_inputs.check_functions,
-    ):
-        if isinstance(node, DiscoveredLoaderFunction) and node.name in managed_source_names:
-            continue
-        seen_names[node.name] = _validated_project_resource_entry(
-            seen_names=seen_names,
-            name=node.name,
-            kind=node.__class__.__name__.removeprefix("Discovered")
-            .removesuffix("Function")
-            .lower(),
-            path=str(node.relative_path),
-        )
-
-    provider: DiscoveredProvider
-    for provider in discovered_inputs.providers:
-        seen_names[provider.name] = _validated_project_resource_entry(
-            seen_names=seen_names,
-            name=provider.name,
-            kind="provider",
-            path=str(provider.relative_path),
-        )
-
-    sql_hook_file: DiscoveredSqlHookFile
-    for sql_hook_file in discovered_inputs.sql_hook_files:
-        seen_names[sql_hook_file.name] = _validated_project_resource_entry(
-            seen_names=seen_names,
-            name=sql_hook_file.name,
-            kind="sql hook",
-            path=str(sql_hook_file.relative_path),
-        )
-
-    hook_function: DiscoveredHookFunction
-    for hook_function in discovered_inputs.hook_functions:
-        seen_names[hook_function.name] = _validated_project_resource_entry(
-            seen_names=seen_names,
-            name=hook_function.name,
-            kind="python hook",
-            path=str(hook_function.relative_path),
-        )
-
-    scenario_file: DiscoveredSqlScenarioFile
-    for scenario_file in discovered_inputs.scenario_files:
-        seen_names[scenario_file.name] = _validated_project_resource_entry(
-            seen_names=seen_names,
-            name=scenario_file.name,
-            kind="scenario",
-            path=str(scenario_file.relative_path),
-        )
-
-    test_names: set[str] = set()
-    test_file: DiscoveredSqlTestFile
-    for test_file in discovered_inputs.test_files:
-        block: DiscoveredSqlTestBlock
-        for block in test_file.blocks:
-            test_name: str = block.name or test_file.relative_path.stem
-            if test_name in test_names:
-                continue
-            test_names.add(test_name)
-            seen_names[test_name] = _validated_project_resource_entry(
-                seen_names=seen_names,
-                name=test_name,
-                kind="unit test",
-                path=str(test_file.relative_path),
-            )
-
-
-def _validated_project_resource_entry(
-    *, seen_names: dict[str, tuple[str, str]], name: str, kind: str, path: str
-) -> tuple[str, str]:
-    existing_entry: tuple[str, str] | None = seen_names.get(name)
-    if existing_entry is not None:
-        raise DiscoveryConflictError(
-            f"Project resource name '{name}' is declared as both {existing_entry[0]} "
-            f"in {existing_entry[1]} and {kind} in {path}; model, source, seed, function, "
-            "loader, task, asset, check, provider, hook, unit test, and scenario names must be "
-            "globally unique"
-        )
-    return (kind, path)
-
-
-def _validate_declared_seed_files(
-    *,
-    schema_files: tuple[DiscoveredSchemaFile, ...],
-    seed_files: tuple[DiscoveredSeedFile, ...],
-) -> None:
-    _validate_unique_seed_csv_names(seed_files)
-    declared_seed_entries: list[tuple[SchemaSeedEntry, str]] = []
-    schema_file: DiscoveredSchemaFile
-    for schema_file in schema_files:
-        seed_entry: SchemaSeedEntry
-        for seed_entry in schema_file.seed_entries:
-            declared_seed_entries.append((seed_entry, str(schema_file.relative_path)))
-    seed_files_by_name: dict[str, list[DiscoveredSeedFile]] = {}
-    for seed_file in seed_files:
-        seed_files_by_name.setdefault(seed_file.file_path.stem, []).append(seed_file)
-
-    seed_entry_and_path: tuple[SchemaSeedEntry, str]
-    for seed_entry_and_path in declared_seed_entries:
-        seed_entry: SchemaSeedEntry = seed_entry_and_path[0]
-        declaration_path: str = seed_entry_and_path[1]
-        matching_seed_files: tuple[DiscoveredSeedFile, ...] = tuple(
-            seed_files_by_name.get(seed_entry.name, ())
-        )
-        if not matching_seed_files:
-            raise SeedDiscoveryError(
-                "Seed declaration "
-                f"'{seed_entry.name}' in {declaration_path} has no matching CSV file under seeds/"
-            )
-        if len(matching_seed_files) > 1:
-            matching_paths: str = ", ".join(
-                str(seed_file.relative_path) for seed_file in matching_seed_files
-            )
-            raise SeedDiscoveryError(
-                f"Seed declaration '{seed_entry.name}' matches multiple CSV files: {matching_paths}"
-            )
-
-        _validate_seed_csv_header(seed_entry=seed_entry, seed_file=matching_seed_files[0])
-
-    declared_names: set[str] = {seed_entry.name for seed_entry, _ in declared_seed_entries}
-    seed_file: DiscoveredSeedFile
-    for seed_file in seed_files:
-        if seed_file.file_path.stem not in declared_names:
-            raise SeedDiscoveryError(
-                f"Seed CSV {seed_file.relative_path} has no matching declaration for seed "
-                f"'{seed_file.file_path.stem}' under seeds/**/*.yml"
-            )
-
-
-def _validate_unique_seed_csv_names(seed_files: tuple[DiscoveredSeedFile, ...]) -> None:
-    seen_paths: dict[str, Path] = {}
-    seed_file: DiscoveredSeedFile
-    for seed_file in seed_files:
-        seed_name: str = seed_file.file_path.stem
-        existing_path: Path | None = seen_paths.get(seed_name)
-        if existing_path is not None:
-            raise SeedDiscoveryError(
-                f"Duplicate seed CSV name '{seed_name}' found: {existing_path}, "
-                f"{seed_file.relative_path}. Seed CSV filenames must be unique under seeds/."
-            )
-        seen_paths[seed_name] = seed_file.relative_path
-
-
-def _validate_seed_csv_header(
-    *, seed_entry: SchemaSeedEntry, seed_file: DiscoveredSeedFile
-) -> None:
-    header_columns: tuple[str, ...] = _load_seed_csv_header(
-        file_path=seed_file.file_path,
-        delimiter=seed_entry.csv_settings.delimiter,
-        quotechar=seed_entry.csv_settings.quotechar,
-        escapechar=seed_entry.csv_settings.escapechar,
-        doublequote=seed_entry.csv_settings.doublequote,
-        skipinitialspace=seed_entry.csv_settings.skipinitialspace,
-    )
-    if not header_columns:
-        raise SeedDiscoveryError(f"{seed_file.relative_path} must contain a CSV header row")
-
-    seen_columns: set[str] = set()
-    column_name: str
-    for column_name in header_columns:
-        if column_name in seen_columns:
-            raise SeedDiscoveryError(
-                f"{seed_file.relative_path} contains duplicate CSV header column '{column_name}'"
-            )
-        seen_columns.add(column_name)
-
-    declared_columns: tuple[str, ...] = tuple(column.name for column in seed_entry.columns)
-    if header_columns != declared_columns:
-        raise SeedDiscoveryError(
-            f"{seed_file.relative_path} header {header_columns} does not match "
-            "declared seed columns "
-            f"{declared_columns} for '{seed_entry.name}'"
-        )
-
-
-def _load_seed_csv_header(
-    *,
-    file_path: Path,
-    delimiter: str | None,
-    quotechar: str | None,
-    escapechar: str | None,
-    doublequote: bool | None,
-    skipinitialspace: bool | None,
-) -> tuple[str, ...]:
-    reader_kwargs: dict[str, object] = {}
-    if delimiter is not None:
-        reader_kwargs["delimiter"] = delimiter
-    if quotechar is not None:
-        reader_kwargs["quotechar"] = quotechar
-    if escapechar is not None:
-        reader_kwargs["escapechar"] = escapechar
-    if doublequote is not None:
-        reader_kwargs["doublequote"] = doublequote
-    if skipinitialspace is not None:
-        reader_kwargs["skipinitialspace"] = skipinitialspace
-
-    with file_path.open("r", encoding="utf-8", newline="") as handle:
-        try:
-            header_row: list[str] = next(
-                csv.reader(
-                    handle,
-                    delimiter=delimiter or ",",
-                    quotechar=quotechar,
-                    escapechar=escapechar,
-                    doublequote=True if doublequote is None else doublequote,
-                    skipinitialspace=False if skipinitialspace is None else skipinitialspace,
-                )
-            )
-        except StopIteration:
-            return ()
-    return tuple(header_row)
-
-
-def _validate_path_defaults_match_models(
-    *,
-    path_defaults: dict[str, dict[str, object]],
-    model_files: tuple[DiscoveredSqlModelFile, ...],
-) -> None:
-    if not path_defaults:
-        return
-    model_paths: tuple[str, ...] = tuple(
-        str(model_file.relative_path).replace("\\", "/").removeprefix("models/")
-        for model_file in model_files
-    )
-    matched_keys: set[str] = set()
-    model_path: str
-    for model_path in model_paths:
-        matched_keys.update(
-            select_path_default(
-                model_path=model_path,
-                path_keys=tuple(path_defaults),
-            ).matched_keys
-        )
-    path_key: str
-    for path_key in path_defaults:
-        if path_key in matched_keys:
-            continue
-        model_folders: tuple[str, ...] = tuple(
-            sorted(
-                {
-                    str(Path(model_path).parent)
-                    for model_path in model_paths
-                    if str(Path(model_path).parent) != CURRENT_DIRECTORY_PATH
-                }
-            )
-        )
-        known_folders: str = ", ".join(model_folders[:5]) if model_folders else "<none>"
-        raise DiscoveryConflictError(
-            f"path_defaults['{path_key}'] does not match any model paths. Known model folders "
-            f"include: {known_folders}"
-        )
+def _decorated_name(dependency: object) -> str | None:
+    if not callable(dependency):
+        return None
+    for read_definition in _DEFINITION_READERS:
+        definition: _NodeDefinition | None = read_definition(dependency)
+        if definition is not None:
+            return definition.name
+    return None
diff --git a/src/sqlbuild/compiler/discovery/_helpers/validation/identities.py b/src/sqlbuild/compiler/discovery/_helpers/validation/identities.py
deleted file mode 100644
index da6364381e..0000000000
--- a/src/sqlbuild/compiler/discovery/_helpers/validation/identities.py
+++ /dev/null
@@ -1,123 +0,0 @@
-"""Canonical authored resource identity validation."""
-
-from __future__ import annotations
-
-from collections.abc import Iterator
-from dataclasses import dataclass
-from pathlib import Path
-
-from sqlbuild.compiler.discovery.models import DiscoveredProjectInputs
-from sqlbuild.compiler.resource_names.main._validate_resource_identity import (
-    validate_resource_identity,
-)
-from sqlbuild.compiler.scopes.types import DeclarationKind, ScopeKind
-
-
-@dataclass(frozen=True)
-class _IdentityCandidate:
-    name: str
-    kind: str
-    path: Path
-    private_identity: bool = False
-
-
-def validate_discovered_resource_identities(
-    discovered_inputs: DiscoveredProjectInputs,
-) -> None:
-    """Reject non-canonical identities before graph assembly or persistence."""
-
-    for candidate in _identity_candidates(discovered_inputs):
-        validate_resource_identity(
-            name=candidate.name,
-            kind=candidate.kind,
-            path=candidate.path,
-            private_identity=candidate.private_identity,
-        )
-
-
-def _identity_candidates(
-    discovered_inputs: DiscoveredProjectInputs,
-) -> Iterator[_IdentityCandidate]:
-    for model_file in discovered_inputs.model_files:
-        yield _IdentityCandidate(model_file.file_path.stem, "model", model_file.relative_path)
-        for declaration in (*model_file.enum_declarations, *model_file.constant_declarations):
-            yield _IdentityCandidate(
-                declaration.name,
-                "model-local declaration",
-                declaration.relative_path,
-                private_identity=True,
-            )
-    for function_file in (
-        *discovered_inputs.sql_function_files,
-        *discovered_inputs.python_function_files,
-    ):
-        yield _IdentityCandidate(
-            function_file.file_path.stem, "function", function_file.relative_path
-        )
-    for hook_file in discovered_inputs.sql_hook_files:
-        yield _IdentityCandidate(hook_file.name, "SQL hook", hook_file.relative_path)
-    for seed_file in discovered_inputs.seed_files:
-        yield _IdentityCandidate(seed_file.file_path.stem, "seed", seed_file.relative_path)
-    for schema_file in discovered_inputs.schema_files:
-        for model_entry in schema_file.model_entries:
-            yield _IdentityCandidate(model_entry.name, "schema model", schema_file.relative_path)
-        for seed_entry in schema_file.seed_entries:
-            yield _IdentityCandidate(seed_entry.name, "schema seed", schema_file.relative_path)
-    for source_file in discovered_inputs.source_files:
-        for source_entry in source_file.source_entries:
-            yield _IdentityCandidate(source_entry.name, "source", source_file.relative_path)
-    for test_file in discovered_inputs.test_files:
-        for block in test_file.blocks:
-            yield _IdentityCandidate(
-                block.name or test_file.relative_path.stem,
-                "SQL test",
-                test_file.relative_path,
-            )
-            for case in block.cases:
-                yield _IdentityCandidate(case.name, "SQL test case", test_file.relative_path)
-    for scenario_file in discovered_inputs.scenario_files:
-        yield _IdentityCandidate(scenario_file.name, "scenario", scenario_file.relative_path)
-    for audit_file in discovered_inputs.audit_files:
-        for block in audit_file.blocks:
-            is_generic: bool = audit_file.declaration_kind is DeclarationKind.AUDIT
-            yield _IdentityCandidate(
-                (
-                    audit_file.relative_path.stem
-                    if is_generic
-                    else block.name or audit_file.relative_path.stem
-                ),
-                "audit",
-                audit_file.relative_path,
-            )
-            if is_generic and block.name is not None:
-                yield _IdentityCandidate(
-                    block.name,
-                    "generic audit instance",
-                    audit_file.relative_path,
-                )
-    for declaration_file in (
-        *discovered_inputs.enum_files,
-        *discovered_inputs.constant_files,
-    ):
-        for declaration in declaration_file.declarations:
-            yield _IdentityCandidate(
-                declaration.name,
-                "declaration",
-                declaration.relative_path,
-                private_identity=declaration_file.scope_kind is ScopeKind.PRIVATE,
-            )
-    for schema_file in discovered_inputs.model_schema_files:
-        for declaration in schema_file.declarations:
-            yield _IdentityCandidate(declaration.name, "model schema", declaration.relative_path)
-    for named_resources, kind in (
-        (discovered_inputs.materialization_files, "materialization"),
-        (discovered_inputs.loader_functions, "loader"),
-        (discovered_inputs.task_functions, "task"),
-        (discovered_inputs.asset_functions, "asset"),
-        (discovered_inputs.check_functions, "check"),
-        (discovered_inputs.hook_functions, "Python hook"),
-        (discovered_inputs.event_exporters, "event exporter"),
-        (discovered_inputs.providers, "provider"),
-    ):
-        for resource in named_resources:
-            yield _IdentityCandidate(resource.name, kind, resource.relative_path)
diff --git a/src/sqlbuild/compiler/discovery/_helpers/yml/schema.py b/src/sqlbuild/compiler/discovery/_helpers/yml/schema.py
index 4bce113bd5..c2d1cd2033 100644
--- a/src/sqlbuild/compiler/discovery/_helpers/yml/schema.py
+++ b/src/sqlbuild/compiler/discovery/_helpers/yml/schema.py
@@ -1,72 +1,12 @@
-"""Parsing helpers for authored schema.yml files."""
+"""Parsing of authored schema.yml files, run natively."""
 
 from __future__ import annotations
 
 from pathlib import Path
-from typing import cast
 
-from sqlbuild.compiler.auditing.main._parse_audit_instances import parse_audit_instances
-from sqlbuild.compiler.authored_values.main._optional_bool import optional_bool
-from sqlbuild.compiler.authored_values.main._optional_mapping import optional_mapping
-from sqlbuild.compiler.authored_values.main._optional_non_empty_string import (
-    optional_non_empty_string,
-)
-from sqlbuild.compiler.authored_values.main._optional_string_tuple import optional_string_tuple
-from sqlbuild.compiler.authored_values.main._require_non_empty_string import (
-    require_non_empty_string,
-)
-from sqlbuild.compiler.discovery._helpers.validation.supported_keys import (
-    reject_unknown_mapping_keys,
-)
-from sqlbuild.compiler.discovery.constants import (
-    NOT_NULL_AUDIT_NAME,
-    SEEDS_DIRECTORY_NAME,
-)
-from sqlbuild.compiler.discovery.exceptions import SchemaParseError
-from sqlbuild.spec.contracts.models import (
-    SchemaAuditInstance,
-    SchemaColumn,
-    SchemaModelEntry,
-    SchemaSeedEntry,
-    SeedCsvSettings,
-)
-
-_SEED_CSV_SETTING_KEYS: frozenset[str] = frozenset(
-    {
-        "delimiter",
-        "quotechar",
-        "doublequote",
-        "escapechar",
-        "skipinitialspace",
-        "lineterminator",
-        "encoding",
-        "na_values",
-        "keep_default_na",
-    }
-)
-_SEED_FILE_KEYS: frozenset[str] = frozenset({"seeds"})
-_SEED_ENTRY_KEYS: frozenset[str] = frozenset(
-    {
-        "name",
-        "description",
-        "database",
-        "schema",
-        "meta",
-        "csv_settings",
-        "columns",
-        "tags",
-        "audits",
-    }
-)
-_SEED_COLUMN_KEYS: frozenset[str] = frozenset(
-    {"name", "type", "nullable", "description", "meta", "audits"}
-)
-_SEED_CSV_STRING_SETTINGS: frozenset[str] = frozenset(
-    {"delimiter", "quotechar", "escapechar", "lineterminator", "encoding"}
-)
-_SEED_CSV_BOOL_SETTINGS: frozenset[str] = frozenset(
-    {"doublequote", "skipinitialspace", "keep_default_na"}
-)
+import sqlbuild._native as _native
+from sqlbuild.compiler.discovery._helpers.yml.yaml_classes import yaml_entry_classes
+from sqlbuild.spec.contracts.models import SchemaModelEntry, SchemaSeedEntry
 
 
 def parse_loaded_schema_yml(
@@ -74,356 +14,4 @@ def parse_loaded_schema_yml(
 ) -> tuple[tuple[SchemaModelEntry, ...], tuple[SchemaSeedEntry, ...]]:
     """Parse the document one schema.yml file loads to into raw model and seed metadata."""
 
-    payload: dict[str, object] = _schema_mapping(loaded=loaded, file_path=file_path)
-    return (
-        _parse_model_entries(payload=payload, file_path=file_path),
-        _parse_seed_entries(payload=payload, file_path=file_path),
-    )
-
-
-def _schema_mapping(*, loaded: object, file_path: Path) -> dict[str, object]:
-    payload: object = loaded
-    if payload is None:
-        return {}
-    if not isinstance(payload, dict):
-        raise SchemaParseError(f"{file_path} must contain a top-level mapping")
-    return cast(dict[str, object], payload)
-
-
-def _parse_model_entries(
-    *, payload: dict[str, object], file_path: Path
-) -> tuple[SchemaModelEntry, ...]:
-    raw_models: object = payload.get("models", [])
-    if raw_models:
-        raise SchemaParseError(
-            f"{file_path} declares model metadata in 'models', but model metadata must live "
-            "in the model file MODEL(...). Move description, columns, and audits into the "
-            "model header."
-        )
-    model_mappings: tuple[dict[str, object], ...] = _parse_named_mapping_list(
-        raw_value=raw_models,
-        file_path=file_path,
-        label="models",
-    )
-    return tuple(_parse_model_entry(entry=entry, file_path=file_path) for entry in model_mappings)
-
-
-def _parse_seed_entries(
-    *, payload: dict[str, object], file_path: Path
-) -> tuple[SchemaSeedEntry, ...]:
-    raw_seeds: object = payload.get("seeds", [])
-    if raw_seeds and SEEDS_DIRECTORY_NAME not in file_path.parts:
-        raise SchemaParseError(
-            f"{file_path} declares seeds, but seed declarations must live under seeds/**/*.yml"
-        )
-    if SEEDS_DIRECTORY_NAME in file_path.parts:
-        _reject_unknown_keys(
-            mapping=payload, allowed=_SEED_FILE_KEYS, file_path=file_path, label="seed file"
-        )
-    seed_mappings: tuple[dict[str, object], ...] = _parse_named_mapping_list(
-        raw_value=raw_seeds,
-        file_path=file_path,
-        label="seeds",
-    )
-    return tuple(_parse_seed_entry(entry=entry, file_path=file_path) for entry in seed_mappings)
-
-
-def _parse_named_mapping_list(
-    *,
-    raw_value: object,
-    file_path: Path,
-    label: str,
-) -> tuple[dict[str, object], ...]:
-    if not isinstance(raw_value, list):
-        raise SchemaParseError(f"{file_path} {label} must be a list")
-
-    parsed_entries: list[dict[str, object]] = []
-    entry: object
-    for entry in raw_value:
-        if not isinstance(entry, dict):
-            raise SchemaParseError(f"{file_path} {label} must contain only mappings")
-        parsed_entries.append(cast(dict[str, object], entry))
-    return tuple(parsed_entries)
-
-
-def _parse_model_entry(*, entry: dict[str, object], file_path: Path) -> SchemaModelEntry:
-    return SchemaModelEntry(
-        name=require_non_empty_string(
-            entry=entry,
-            key="name",
-            file_path=file_path,
-            label="model",
-            error_class=SchemaParseError,
-        ),
-        description=optional_non_empty_string(
-            entry=entry,
-            key="description",
-            file_path=file_path,
-            label="model",
-            error_class=SchemaParseError,
-        ),
-        type_enforcement=optional_bool(
-            entry=entry,
-            key="type_enforcement",
-            file_path=file_path,
-            label="model",
-            error_class=SchemaParseError,
-        ),
-        meta=optional_mapping(
-            entry=entry,
-            key="meta",
-            file_path=file_path,
-            label="model",
-            error_class=SchemaParseError,
-        ),
-        columns=_parse_columns(entry=entry, file_path=file_path, label="model"),
-        audits=parse_audit_instances(
-            raw_audits=entry.get("audits", []),
-            file_path=file_path,
-            label="model",
-            error_class=SchemaParseError,
-            null_as_empty=False,
-        ),
-        tags=optional_string_tuple(
-            entry=entry,
-            key="tags",
-            file_path=file_path,
-            label="model",
-            error_class=SchemaParseError,
-        ),
-    )
-
-
-def _reject_unknown_keys(
-    *, mapping: dict[str, object], allowed: frozenset[str], file_path: Path, label: str
-) -> None:
-    reject_unknown_mapping_keys(
-        mapping=mapping,
-        allowed=allowed,
-        file_path=file_path,
-        label=label,
-        error_class=SchemaParseError,
-    )
-
-
-def _parse_seed_entry(*, entry: dict[str, object], file_path: Path) -> SchemaSeedEntry:
-    _reject_unknown_keys(mapping=entry, allowed=_SEED_ENTRY_KEYS, file_path=file_path, label="seed")
-    columns: tuple[SchemaColumn, ...] = _parse_columns(
-        entry=entry, file_path=file_path, label="seed", allowed_column_keys=_SEED_COLUMN_KEYS
-    )
-    if not columns:
-        raise SchemaParseError(f"{file_path} seed must declare at least one column")
-
-    column: SchemaColumn
-    for column in columns:
-        if column.type is None:
-            raise SchemaParseError(
-                f"{file_path} seed column '{column.name}' must define non-empty string 'type'"
-            )
-
-    return SchemaSeedEntry(
-        name=require_non_empty_string(
-            entry=entry, key="name", file_path=file_path, label="seed", error_class=SchemaParseError
-        ),
-        description=optional_non_empty_string(
-            entry=entry,
-            key="description",
-            file_path=file_path,
-            label="seed",
-            error_class=SchemaParseError,
-        ),
-        database=optional_non_empty_string(
-            entry=entry,
-            key="database",
-            file_path=file_path,
-            label="seed",
-            error_class=SchemaParseError,
-        ),
-        schema=optional_non_empty_string(
-            entry=entry,
-            key="schema",
-            file_path=file_path,
-            label="seed",
-            error_class=SchemaParseError,
-        ),
-        meta=optional_mapping(
-            entry=entry, key="meta", file_path=file_path, label="seed", error_class=SchemaParseError
-        ),
-        tags=optional_string_tuple(
-            entry=entry,
-            key="tags",
-            file_path=file_path,
-            label="seed",
-            error_class=SchemaParseError,
-        ),
-        csv_settings=_parse_seed_csv_settings(entry=entry, file_path=file_path),
-        columns=columns,
-        audits=parse_audit_instances(
-            raw_audits=entry.get("audits", []),
-            file_path=file_path,
-            label="seed",
-            error_class=SchemaParseError,
-            null_as_empty=False,
-        ),
-    )
-
-
-def _parse_seed_csv_settings(*, entry: dict[str, object], file_path: Path) -> SeedCsvSettings:
-    raw_settings: object | None = entry.get("csv_settings")
-    if raw_settings is None:
-        return SeedCsvSettings()
-    if not isinstance(raw_settings, dict):
-        raise SchemaParseError(f"{file_path} seed 'csv_settings' must be a mapping")
-    settings: dict[str, object] = cast(dict[str, object], raw_settings)
-    unknown_keys: set[str] = set(settings) - set(_SEED_CSV_SETTING_KEYS)
-    if unknown_keys:
-        raise SchemaParseError(
-            f"{file_path} seed 'csv_settings' has unknown keys: {', '.join(sorted(unknown_keys))}"
-        )
-
-    key: str
-    for key in _SEED_CSV_STRING_SETTINGS:
-        value: object | None = settings.get(key)
-        if value is not None and not isinstance(value, str):
-            raise SchemaParseError(f"{file_path} seed csv_settings '{key}' must be a string")
-    for key in _SEED_CSV_BOOL_SETTINGS:
-        value = settings.get(key)
-        if value is not None and not isinstance(value, bool):
-            raise SchemaParseError(f"{file_path} seed csv_settings '{key}' must be a boolean")
-
-    na_values: tuple[object, ...] | dict[str, tuple[object, ...]] | None = _parse_na_values(
-        raw_value=settings.get("na_values"), file_path=file_path
-    )
-    return SeedCsvSettings(
-        delimiter=cast(str | None, settings.get("delimiter")),
-        quotechar=cast(str | None, settings.get("quotechar")),
-        doublequote=cast(bool | None, settings.get("doublequote")),
-        escapechar=cast(str | None, settings.get("escapechar")),
-        skipinitialspace=cast(bool | None, settings.get("skipinitialspace")),
-        lineterminator=cast(str | None, settings.get("lineterminator")),
-        encoding=cast(str | None, settings.get("encoding")),
-        na_values=na_values,
-        keep_default_na=cast(bool | None, settings.get("keep_default_na")),
-    )
-
-
-def _parse_na_values(
-    *, raw_value: object | None, file_path: Path
-) -> tuple[object, ...] | dict[str, tuple[object, ...]] | None:
-    if raw_value is None:
-        return None
-    if isinstance(raw_value, list):
-        return tuple(_validate_na_scalar(value=value, file_path=file_path) for value in raw_value)
-    if isinstance(raw_value, dict):
-        parsed: dict[str, tuple[object, ...]] = {}
-        raw_mapping: dict[str, object] = cast(dict[str, object], raw_value)
-        column_name: str
-        values: object
-        for column_name, values in raw_mapping.items():
-            if not isinstance(values, list):
-                raise SchemaParseError(
-                    f"{file_path} seed csv_settings 'na_values' mapping values must be lists"
-                )
-            parsed[column_name] = tuple(
-                _validate_na_scalar(value=value, file_path=file_path) for value in values
-            )
-        return parsed
-    raise SchemaParseError(f"{file_path} seed csv_settings 'na_values' must be a list or mapping")
-
-
-def _validate_na_scalar(*, value: object, file_path: Path) -> object:
-    if value is None or isinstance(value, str | int | bool):
-        return value
-    raise SchemaParseError(
-        f"{file_path} seed csv_settings 'na_values' entries must be strings, integers, "
-        "booleans, or null"
-    )
-
-
-def _parse_columns(
-    *,
-    entry: dict[str, object],
-    file_path: Path,
-    label: str,
-    allowed_column_keys: frozenset[str] | None = None,
-) -> tuple[SchemaColumn, ...]:
-    raw_columns: object = entry.get("columns", [])
-    if not isinstance(raw_columns, list):
-        raise SchemaParseError(f"{file_path} {label} columns must be a list")
-
-    parsed_columns: list[SchemaColumn] = []
-    raw_column: object
-    for raw_column in raw_columns:
-        if not isinstance(raw_column, dict):
-            raise SchemaParseError(f"{file_path} {label} columns must contain only mappings")
-        column: dict[str, object] = cast(dict[str, object], raw_column)
-        column_label: str = f"{label} column"
-        if allowed_column_keys is not None:
-            _reject_unknown_keys(
-                mapping=column, allowed=allowed_column_keys, file_path=file_path, label=column_label
-            )
-        column_name: str = require_non_empty_string(
-            entry=column,
-            key="name",
-            file_path=file_path,
-            label=column_label,
-            error_class=SchemaParseError,
-        )
-        nullable: bool | None = optional_bool(
-            entry=column,
-            key="nullable",
-            file_path=file_path,
-            label=column_label,
-            error_class=SchemaParseError,
-        )
-        audits: tuple[SchemaAuditInstance, ...] = parse_audit_instances(
-            raw_audits=column.get("audits", []),
-            file_path=file_path,
-            label=column_label,
-            error_class=SchemaParseError,
-            null_as_empty=False,
-        )
-        _validate_nullable_audits(
-            file_path=file_path,
-            column_name=column_name,
-            nullable=nullable,
-            audit_names=tuple(audit.definition_name for audit in audits),
-        )
-        parsed_columns.append(
-            SchemaColumn(
-                name=column_name,
-                type=optional_non_empty_string(
-                    entry=column,
-                    key="type",
-                    file_path=file_path,
-                    label=column_label,
-                    error_class=SchemaParseError,
-                ),
-                nullable=nullable,
-                description=optional_non_empty_string(
-                    entry=column,
-                    key="description",
-                    file_path=file_path,
-                    label=column_label,
-                    error_class=SchemaParseError,
-                ),
-                meta=optional_mapping(
-                    entry=column,
-                    key="meta",
-                    file_path=file_path,
-                    label=column_label,
-                    error_class=SchemaParseError,
-                ),
-                audits=audits,
-            )
-        )
-    return tuple(parsed_columns)
-
-
-def _validate_nullable_audits(
-    *, file_path: Path, column_name: str, nullable: bool | None, audit_names: tuple[str, ...]
-) -> None:
-    if nullable is True and NOT_NULL_AUDIT_NAME in audit_names:
-        raise SchemaParseError(
-            f"{file_path} column '{column_name}' cannot set nullable = true and audit not_null"
-        )
+    return (), _native.parse_schema_document(loaded, str(file_path), yaml_entry_classes())
diff --git a/src/sqlbuild/compiler/discovery/_helpers/yml/sources.py b/src/sqlbuild/compiler/discovery/_helpers/yml/sources.py
index bf1ad163bd..c92d543598 100644
--- a/src/sqlbuild/compiler/discovery/_helpers/yml/sources.py
+++ b/src/sqlbuild/compiler/discovery/_helpers/yml/sources.py
@@ -1,820 +1,15 @@
-"""Parsing helpers for authored sources/*.yml files."""
+"""Parsing of authored sources/*.yml files, run natively."""
 
 from __future__ import annotations
 
 from pathlib import Path
-from typing import cast
 
-from sqlbuild.compiler.auditing.main._parse_audit_instances import parse_audit_instances
-from sqlbuild.compiler.authored_values.main._optional_bool import optional_bool
-from sqlbuild.compiler.authored_values.main._optional_mapping import optional_mapping
-from sqlbuild.compiler.authored_values.main._optional_non_empty_string import (
-    optional_non_empty_string,
-)
-from sqlbuild.compiler.authored_values.main._require_non_empty_string import (
-    require_non_empty_string,
-)
-from sqlbuild.compiler.discovery._helpers.integrations.loaders import (
-    integration_loader_name,
-    parse_dlt_sources,
-    parse_source_integration_loader,
-)
-from sqlbuild.compiler.discovery._helpers.validation.supported_keys import (
-    reject_unknown_mapping_keys,
-)
-from sqlbuild.compiler.discovery.constants import (
-    NOT_NULL_AUDIT_NAME,
-    SOURCE_AGE_POLICY_CONFIG_KEY,
-    SOURCE_LOADER_CONFIG_KEY,
-)
-from sqlbuild.compiler.discovery.exceptions import SourceParseError
-from sqlbuild.compiler.planner.types import ContractPolicy
-from sqlbuild.cursor_algebra.constants import MINUTE_TO_DAY_DURATION_UNITS
-from sqlbuild.cursor_algebra.models import Duration
-from sqlbuild.spec.contracts.models import (
-    IntegrationLoaderConfig,
-    SchemaAuditInstance,
-    SourceColumnEntry,
-    SourceEntry,
-    SourceFreshnessAgePolicy,
-    SourceFreshnessConfig,
-)
-from sqlbuild.spec.contracts.types import (
-    SourceFreshnessStrategy,
-    SourceFreshnessValueKind,
-    SourceWriteStrategy,
-)
-
-_SOURCE_FILE_KEYS: frozenset[str] = frozenset({"sources", "dlt_sources"})
-_SOURCE_ENTRY_KEYS: frozenset[str] = frozenset(
-    {
-        "audits",
-        "columns",
-        "contract",
-        "cursor_column",
-        "database",
-        "description",
-        "expression",
-        "freshness",
-        "ingestr",
-        "load_batch_size",
-        "managed",
-        "meta",
-        "name",
-        "schema",
-        "table",
-        "type_enforcement",
-        "unique_key",
-        "write_strategy",
-    }
-)
-_SOURCE_COLUMN_KEYS: frozenset[str] = frozenset(
-    {"audits", "description", "meta", "name", "nullable", "type"}
-)
-_SOURCE_FRESHNESS_KEYS: frozenset[str] = frozenset(
-    {"age_policy", "column", "filter", "lag_tolerance", "query", "strategy", "type"}
-)
-_SOURCE_FRESHNESS_AGE_POLICY_KEYS: frozenset[str] = frozenset({"error_after", "warn_after"})
-_SOURCE_WRITE_STRATEGIES: frozenset[str] = frozenset(
-    strategy.value for strategy in SourceWriteStrategy
-)
-_SOURCE_FRESHNESS_STRATEGIES: frozenset[str] = frozenset(
-    strategy.value for strategy in SourceFreshnessStrategy
-)
-_SOURCE_FRESHNESS_VALUE_KINDS: frozenset[str] = frozenset(
-    value_kind.value for value_kind in SourceFreshnessValueKind
-)
-_FRESHNESS_TIMESTAMP_TYPE_NAMES: frozenset[str] = frozenset(
-    {
-        "DATETIME",
-        "DATETIME2",
-        "DATETIMEOFFSET",
-        "SMALLDATETIME",
-        "TIMESTAMP",
-        "TIMESTAMPTZ",
-        "TIMESTAMP_LTZ",
-        "TIMESTAMP_NTZ",
-        "TIMESTAMP_TZ",
-    }
-)
-_FRESHNESS_TIMESTAMP_WITH_ZONE_PREFIXES: tuple[str, ...] = (
-    "TIMESTAMP WITH TIME ZONE",
-    "TIMESTAMP WITHOUT TIME ZONE",
-)
-_FRESHNESS_INTEGER_TYPE_NAMES: frozenset[str] = frozenset(
-    {"BIGINT", "INT", "INT2", "INT4", "INT8", "INT64", "INTEGER", "SMALLINT", "TINYINT"}
-)
-_FRESHNESS_STRING_TYPE_NAMES: frozenset[str] = frozenset(
-    {"CHAR", "CHARACTER", "CHARACTER VARYING", "NCHAR", "NVARCHAR", "STRING", "TEXT", "VARCHAR"}
-)
+import sqlbuild._native as _native
+from sqlbuild.compiler.discovery._helpers.yml.yaml_classes import yaml_entry_classes
+from sqlbuild.spec.contracts.models import SourceEntry
 
 
 def parse_loaded_sources_yml(*, loaded: object, file_path: Path) -> tuple[SourceEntry, ...]:
     """Parse the document one sources/*.yml file loads to into raw source declarations."""
 
-    payload: dict[str, object] = _sources_mapping(loaded=loaded, file_path=file_path)
-    _reject_unknown_source_keys(
-        mapping=payload, allowed=_SOURCE_FILE_KEYS, file_path=file_path, label="sources file"
-    )
-    raw_sources: object = payload.get("sources", [])
-    if not isinstance(raw_sources, list):
-        raise SourceParseError(f"{file_path} sources must be a list")
-
-    parsed_sources: list[SourceEntry] = []
-    raw_source: object
-    for raw_source in raw_sources:
-        if not isinstance(raw_source, dict):
-            raise SourceParseError(f"{file_path} sources must contain only mappings")
-        parsed_sources.append(
-            _parse_source_entry(entry=cast(dict[str, object], raw_source), file_path=file_path)
-        )
-    parsed_sources.extend(parse_dlt_sources(payload=payload, file_path=file_path))
-    return tuple(parsed_sources)
-
-
-def _sources_mapping(*, loaded: object, file_path: Path) -> dict[str, object]:
-    payload: object = loaded
-    if payload is None:
-        return {}
-    if not isinstance(payload, dict):
-        raise SourceParseError(f"{file_path} must contain a top-level mapping")
-    return cast(dict[str, object], payload)
-
-
-def _parse_source_entry(*, entry: dict[str, object], file_path: Path) -> SourceEntry:
-    columns: tuple[SourceColumnEntry, ...] = _parse_columns(entry=entry, file_path=file_path)
-    raw_type_enforcement: bool | None = optional_bool(
-        entry=entry,
-        key="type_enforcement",
-        file_path=file_path,
-        label="source",
-        error_class=SourceParseError,
-    )
-    type_enforcement: bool | None = raw_type_enforcement
-    contract: str | None = optional_non_empty_string(
-        entry=entry,
-        key="contract",
-        file_path=file_path,
-        label="source",
-        error_class=SourceParseError,
-    )
-    if contract is not None and contract not in ContractPolicy:
-        raise SourceParseError(f"{file_path} source 'contract' must be one of: enforced, none")
-    expression: str | None = optional_non_empty_string(
-        entry=entry,
-        key="expression",
-        file_path=file_path,
-        label="source",
-        error_class=SourceParseError,
-    )
-    if type_enforcement is None and any(column.type is not None for column in columns):
-        type_enforcement = True
-
-    if SOURCE_LOADER_CONFIG_KEY in entry:
-        raise SourceParseError(
-            f"{file_path} source 'loader' is not supported; use managed: true and name "
-            "the terminal loader after the source"
-        )
-    _reject_unknown_source_keys(
-        mapping=entry, allowed=_SOURCE_ENTRY_KEYS, file_path=file_path, label="source"
-    )
-    source_name: str = require_non_empty_string(
-        entry=entry,
-        key="name",
-        file_path=file_path,
-        label="source",
-        error_class=SourceParseError,
-    )
-    integration_loader: IntegrationLoaderConfig | None = parse_source_integration_loader(
-        entry=entry, file_path=file_path
-    )
-    managed: bool = bool(
-        optional_bool(
-            entry=entry,
-            key="managed",
-            file_path=file_path,
-            label="source",
-            error_class=SourceParseError,
-        )
-    )
-    resolved_loader: str | None = source_name if managed else None
-    if resolved_loader is None and integration_loader is not None:
-        resolved_loader = integration_loader_name(
-            kind=integration_loader.kind,
-            source_name=source_name,
-        )
-        managed = True
-
-    source_entry: SourceEntry = SourceEntry(
-        name=source_name,
-        database=optional_non_empty_string(
-            entry=entry,
-            key="database",
-            file_path=file_path,
-            label="source",
-            error_class=SourceParseError,
-        ),
-        schema=optional_non_empty_string(
-            entry=entry,
-            key="schema",
-            file_path=file_path,
-            label="source",
-            error_class=SourceParseError,
-        ),
-        table=optional_non_empty_string(
-            entry=entry,
-            key="table",
-            file_path=file_path,
-            label="source",
-            error_class=SourceParseError,
-        ),
-        managed=managed,
-        loader=resolved_loader,
-        integration_loader=integration_loader,
-        freshness=_optional_freshness_config(entry=entry, columns=columns, file_path=file_path),
-        write_strategy=_optional_write_strategy(entry=entry, file_path=file_path),
-        load_batch_size=_optional_positive_int(
-            entry=entry,
-            key="load_batch_size",
-            file_path=file_path,
-        ),
-        cursor_column=optional_non_empty_string(
-            entry=entry,
-            key="cursor_column",
-            file_path=file_path,
-            label="source",
-            error_class=SourceParseError,
-        ),
-        unique_key=_optional_unique_key(entry=entry, file_path=file_path),
-        expression=expression,
-        description=optional_non_empty_string(
-            entry=entry,
-            key="description",
-            file_path=file_path,
-            label="source",
-            error_class=SourceParseError,
-        ),
-        type_enforcement=type_enforcement,
-        contract=contract,
-        meta=optional_mapping(
-            entry=entry,
-            key="meta",
-            file_path=file_path,
-            label="source",
-            error_class=SourceParseError,
-        ),
-        columns=columns,
-        audits=parse_audit_instances(
-            raw_audits=entry.get("audits", []),
-            file_path=file_path,
-            label="source",
-            error_class=SourceParseError,
-            null_as_empty=False,
-        ),
-    )
-    _validate_source_entry(entry=source_entry, file_path=file_path)
-    return source_entry
-
-
-def _validate_source_entry(*, entry: SourceEntry, file_path: Path) -> None:
-    relation_keys: tuple[str, ...] = tuple(
-        key
-        for key, value in (
-            ("database", entry.database),
-            ("schema", entry.schema),
-            ("table", entry.table),
-        )
-        if value is not None
-    )
-    if entry.expression is not None and relation_keys:
-        keys: str = ", ".join(relation_keys)
-        raise SourceParseError(
-            f"{file_path} source '{entry.name}' cannot define expression with {keys}"
-        )
-    if entry.expression is not None and entry.type_enforcement:
-        typed_columns: tuple[SourceColumnEntry, ...] = tuple(
-            column for column in entry.columns if column.type is not None
-        )
-        if not typed_columns:
-            raise SourceParseError(
-                f"{file_path} source '{entry.name}' uses expression with type_enforcement "
-                "but has no typed columns"
-            )
-    if entry.integration_loader is not None:
-        expected_loader_name: str = integration_loader_name(
-            kind=entry.integration_loader.kind, source_name=entry.name
-        )
-        if entry.loader != expected_loader_name:
-            raise SourceParseError(
-                f"{file_path} source '{entry.name}' cannot override loader for "
-                f"{entry.integration_loader.kind}"
-            )
-        if entry.write_strategy is not None:
-            raise SourceParseError(
-                f"{file_path} source '{entry.name}' cannot define write_strategy with "
-                f"{entry.integration_loader.kind}"
-            )
-    if entry.write_strategy is not None and entry.loader is None:
-        raise SourceParseError(
-            f"{file_path} source '{entry.name}' defines write_strategy but is not managed"
-        )
-    if entry.write_strategy == SourceWriteStrategy.APPEND and entry.unique_key:
-        raise SourceParseError(
-            f"{file_path} source '{entry.name}' unique_key is not supported with "
-            "write_strategy append"
-        )
-    if entry.write_strategy == SourceWriteStrategy.MERGE and not entry.unique_key:
-        raise SourceParseError(
-            f"{file_path} source '{entry.name}' write_strategy merge requires unique_key"
-        )
-    if entry.write_strategy == SourceWriteStrategy.TABLE and entry.cursor_column is not None:
-        raise SourceParseError(
-            f"{file_path} source '{entry.name}' cursor_column is not supported with "
-            "write_strategy table"
-        )
-    if entry.write_strategy == SourceWriteStrategy.TABLE and entry.unique_key:
-        raise SourceParseError(
-            f"{file_path} source '{entry.name}' unique_key is not supported with "
-            "write_strategy table"
-        )
-    if entry.write_strategy == SourceWriteStrategy.DELETE_INSERT and entry.cursor_column is None:
-        raise SourceParseError(
-            f"{file_path} source '{entry.name}' write_strategy delete_insert requires cursor_column"
-        )
-    if entry.write_strategy == SourceWriteStrategy.DELETE_INSERT and entry.unique_key:
-        raise SourceParseError(
-            f"{file_path} source '{entry.name}' unique_key is not supported with "
-            "write_strategy delete_insert"
-        )
-    if entry.cursor_column is not None and entry.write_strategy not in {
-        SourceWriteStrategy.APPEND,
-        SourceWriteStrategy.DELETE_INSERT,
-        SourceWriteStrategy.MERGE,
-    }:
-        raise SourceParseError(
-            f"{file_path} source '{entry.name}' cursor_column requires write_strategy "
-            "append, delete_insert, or merge"
-        )
-    if entry.unique_key and entry.write_strategy != SourceWriteStrategy.MERGE:
-        raise SourceParseError(
-            f"{file_path} source '{entry.name}' unique_key requires write_strategy merge"
-        )
-
-
-def _optional_unique_key(*, entry: dict[str, object], file_path: Path) -> tuple[str, ...]:
-    value: object | None = entry.get("unique_key")
-    if value is None:
-        return ()
-    if isinstance(value, str):
-        stripped: str = value.strip()
-        if not stripped:
-            raise SourceParseError(f"{file_path} source 'unique_key' must be non-empty")
-        return (stripped,)
-    if isinstance(value, list):
-        keys: list[str] = []
-        item: object
-        for item in value:
-            if not isinstance(item, str) or not item.strip():
-                raise SourceParseError(
-                    f"{file_path} source 'unique_key' must contain only non-empty strings"
-                )
-            keys.append(item.strip())
-        if not keys:
-            raise SourceParseError(f"{file_path} source 'unique_key' must be non-empty")
-        return tuple(keys)
-    raise SourceParseError(f"{file_path} source 'unique_key' must be a string or list")
-
-
-def _optional_write_strategy(
-    *, entry: dict[str, object], file_path: Path
-) -> SourceWriteStrategy | None:
-    value: str | None = optional_non_empty_string(
-        entry=entry,
-        key="write_strategy",
-        file_path=file_path,
-        label="source",
-        error_class=SourceParseError,
-    )
-    if value is None:
-        return None
-    if value not in _SOURCE_WRITE_STRATEGIES:
-        strategies: str = ", ".join(sorted(_SOURCE_WRITE_STRATEGIES))
-        raise SourceParseError(f"{file_path} source write_strategy must be one of: {strategies}")
-    return SourceWriteStrategy(value)
-
-
-def _optional_freshness_config(
-    *, entry: dict[str, object], columns: tuple[SourceColumnEntry, ...], file_path: Path
-) -> SourceFreshnessConfig | None:
-    raw_freshness: object | None = entry.get("freshness")
-    if raw_freshness is None:
-        return None
-    if not isinstance(raw_freshness, dict):
-        raise SourceParseError(f"{file_path} source 'freshness' must be a mapping")
-    freshness: dict[str, object] = cast(dict[str, object], raw_freshness)
-    _reject_unknown_source_keys(
-        mapping=freshness,
-        allowed=_SOURCE_FRESHNESS_KEYS,
-        file_path=file_path,
-        label="source freshness",
-    )
-    raw_strategy: str | None = optional_non_empty_string(
-        entry=freshness,
-        key="strategy",
-        file_path=file_path,
-        label="source freshness",
-        error_class=SourceParseError,
-    )
-    if raw_strategy is not None and raw_strategy not in _SOURCE_FRESHNESS_STRATEGIES:
-        strategies: str = ", ".join(sorted(_SOURCE_FRESHNESS_STRATEGIES))
-        raise SourceParseError(
-            f"{file_path} source freshness 'strategy' must be one of: {strategies}"
-        )
-    raw_value_kind: str | None = optional_non_empty_string(
-        entry=freshness,
-        key="type",
-        file_path=file_path,
-        label="source freshness",
-        error_class=SourceParseError,
-    )
-    value_kind: SourceFreshnessValueKind | None = None
-    if raw_value_kind is not None:
-        if raw_value_kind not in _SOURCE_FRESHNESS_VALUE_KINDS:
-            value_kinds: str = ", ".join(sorted(_SOURCE_FRESHNESS_VALUE_KINDS))
-            raise SourceParseError(
-                f"{file_path} source freshness 'type' must be one of: {value_kinds}"
-            )
-        value_kind = SourceFreshnessValueKind(raw_value_kind)
-    column: str | None = optional_non_empty_string(
-        entry=freshness,
-        key="column",
-        file_path=file_path,
-        label="source freshness",
-        error_class=SourceParseError,
-    )
-    query: str | None = optional_non_empty_string(
-        entry=freshness,
-        key="query",
-        file_path=file_path,
-        label="source freshness",
-        error_class=SourceParseError,
-    )
-    freshness_filter: str | None = optional_non_empty_string(
-        entry=freshness,
-        key="filter",
-        file_path=file_path,
-        label="source freshness",
-        error_class=SourceParseError,
-    )
-    lag_tolerance: str | None = optional_non_empty_string(
-        entry=freshness,
-        key="lag_tolerance",
-        file_path=file_path,
-        label="source freshness",
-        error_class=SourceParseError,
-    )
-    age_policy: SourceFreshnessAgePolicy | None = _optional_freshness_age_policy(
-        freshness=freshness,
-        file_path=file_path,
-    )
-    strategy: SourceFreshnessStrategy = (
-        SourceFreshnessStrategy(raw_strategy)
-        if raw_strategy is not None
-        else _implied_freshness_strategy(
-            column=column,
-            query=query,
-            has_type=value_kind is not None,
-            has_filter=freshness_filter is not None,
-            file_path=file_path,
-        )
-    )
-    if strategy == SourceFreshnessStrategy.COLUMN and column is not None:
-        value_kind = _resolve_column_freshness_value_kind(
-            column=column, explicit=value_kind, columns=columns, file_path=file_path
-        )
-    config: SourceFreshnessConfig = SourceFreshnessConfig(
-        strategy=strategy,
-        value_kind=value_kind,
-        column=column,
-        query=query,
-        filter=freshness_filter,
-        lag_tolerance=lag_tolerance,
-        age_policy=age_policy,
-    )
-    _validate_freshness_config(config=config, file_path=file_path)
-    return config
-
-
-def _implied_freshness_strategy(
-    *, column: str | None, query: str | None, has_type: bool, has_filter: bool, file_path: Path
-) -> SourceFreshnessStrategy:
-    if column is not None and query is not None:
-        raise SourceParseError(
-            f"{file_path} source freshness cannot set both column and query; set strategy "
-            "or remove one of them"
-        )
-    if column is not None:
-        return SourceFreshnessStrategy.COLUMN
-    if query is not None:
-        return SourceFreshnessStrategy.SQL
-    if has_type or has_filter:
-        raise SourceParseError(
-            f"{file_path} source freshness type and filter require column or query"
-        )
-    return SourceFreshnessStrategy.ADAPTER
-
-
-def _resolve_column_freshness_value_kind(
-    *,
-    column: str,
-    explicit: SourceFreshnessValueKind | None,
-    columns: tuple[SourceColumnEntry, ...],
-    file_path: Path,
-) -> SourceFreshnessValueKind | None:
-    declared: SourceColumnEntry | None = _find_source_column(columns=columns, name=column)
-    declared_type: str | None = None if declared is None else declared.type
-    inferred: SourceFreshnessValueKind | None = (
-        None if declared_type is None else _freshness_value_kind_for_type(declared_type)
-    )
-    if explicit is None:
-        if inferred is None and declared_type is not None:
-            raise SourceParseError(
-                f"{file_path} source freshness cannot infer type from column '{column}' "
-                f"declared as {declared_type}; set type to timestamp, integer, or string"
-            )
-        return inferred
-    if inferred is not None and inferred != explicit:
-        raise SourceParseError(
-            f"{file_path} source freshness type {explicit.value} contradicts column "
-            f"'{column}' declared as {declared_type}; remove type or set it to {inferred.value}"
-        )
-    return explicit
-
-
-def _find_source_column(
-    *, columns: tuple[SourceColumnEntry, ...], name: str
-) -> SourceColumnEntry | None:
-    exact: SourceColumnEntry | None = next(
-        (column for column in columns if column.name == name), None
-    )
-    if exact is not None:
-        return exact
-    folded: list[SourceColumnEntry] = [
-        column for column in columns if column.name.casefold() == name.casefold()
-    ]
-    return folded[0] if len(folded) == 1 else None
-
-
-def _freshness_value_kind_for_type(type_sql: str) -> SourceFreshnessValueKind | None:
-    normalized: str = " ".join(type_sql.upper().split())
-    base_name: str = normalized.partition("(")[0].strip()
-    if base_name in _FRESHNESS_TIMESTAMP_TYPE_NAMES or normalized.startswith(
-        _FRESHNESS_TIMESTAMP_WITH_ZONE_PREFIXES
-    ):
-        return SourceFreshnessValueKind.TIMESTAMP
-    if base_name in _FRESHNESS_INTEGER_TYPE_NAMES:
-        return SourceFreshnessValueKind.INTEGER
-    if base_name in _FRESHNESS_STRING_TYPE_NAMES:
-        return SourceFreshnessValueKind.STRING
-    return None
-
-
-def _validate_freshness_config(*, config: SourceFreshnessConfig, file_path: Path) -> None:
-    if config.lag_tolerance is not None:
-        _validate_source_freshness_lag_tolerance(config=config, file_path=file_path)
-    if config.age_policy is not None:
-        _validate_source_freshness_age_policy(config=config, file_path=file_path)
-    if config.strategy == SourceFreshnessStrategy.ADAPTER:
-        if (
-            config.value_kind is not None
-            or config.column is not None
-            or config.query is not None
-            or config.filter is not None
-        ):
-            raise SourceParseError(
-                f"{file_path} source freshness strategy adapter does not support type, "
-                "column, query, or filter"
-            )
-        return
-    if config.strategy == SourceFreshnessStrategy.COLUMN:
-        if config.column is None:
-            raise SourceParseError(f"{file_path} source freshness strategy column requires column")
-        if not config.column.replace("_", "").isalnum() or config.column[0].isdigit():
-            raise SourceParseError(
-                f"{file_path} source freshness column must be a plain column name; "
-                "use strategy sql for expressions"
-            )
-        if config.value_kind is None:
-            raise SourceParseError(
-                f"{file_path} source freshness strategy column requires type; set type or "
-                "declare the column with a type under columns"
-            )
-        if config.query is not None:
-            raise SourceParseError(
-                f"{file_path} source freshness strategy column does not support query"
-            )
-        return
-    if config.query is None:
-        raise SourceParseError(f"{file_path} source freshness strategy sql requires query")
-    if config.value_kind is None:
-        raise SourceParseError(f"{file_path} source freshness strategy sql requires type")
-    if config.column is not None:
-        raise SourceParseError(f"{file_path} source freshness strategy sql does not support column")
-    if config.filter is not None:
-        raise SourceParseError(f"{file_path} source freshness strategy sql does not support filter")
-
-
-def _optional_freshness_age_policy(
-    *, freshness: dict[str, object], file_path: Path
-) -> SourceFreshnessAgePolicy | None:
-    if SOURCE_AGE_POLICY_CONFIG_KEY not in freshness:
-        return None
-    age_policy: dict[str, object] = optional_mapping(
-        entry=freshness,
-        key="age_policy",
-        file_path=file_path,
-        label="source freshness",
-        error_class=SourceParseError,
-    )
-    _reject_unknown_source_keys(
-        mapping=age_policy,
-        allowed=_SOURCE_FRESHNESS_AGE_POLICY_KEYS,
-        file_path=file_path,
-        label="source freshness age_policy",
-    )
-    warn_after: str | None = optional_non_empty_string(
-        entry=age_policy,
-        key="warn_after",
-        file_path=file_path,
-        label="source freshness age_policy",
-        error_class=SourceParseError,
-    )
-    error_after: str | None = optional_non_empty_string(
-        entry=age_policy,
-        key="error_after",
-        file_path=file_path,
-        label="source freshness age_policy",
-        error_class=SourceParseError,
-    )
-    if warn_after is None and error_after is None:
-        raise SourceParseError(
-            f"{file_path} source freshness age_policy requires warn_after or error_after"
-        )
-    return SourceFreshnessAgePolicy(warn_after=warn_after, error_after=error_after)
-
-
-def _validate_source_freshness_lag_tolerance(
-    *, config: SourceFreshnessConfig, file_path: Path
-) -> None:
-    if config.value_kind is not SourceFreshnessValueKind.TIMESTAMP:
-        raise SourceParseError(
-            f"{file_path} source freshness lag_tolerance requires type timestamp"
-        )
-    raw: str = config.lag_tolerance or ""
-    if not _is_valid_source_freshness_duration(raw):
-        raise SourceParseError(
-            f"{file_path} source freshness lag_tolerance must be a positive duration like "
-            "15m, 2h, or 1d"
-        )
-
-
-def _validate_source_freshness_age_policy(
-    *, config: SourceFreshnessConfig, file_path: Path
-) -> None:
-    if (
-        config.strategy != SourceFreshnessStrategy.ADAPTER
-        and config.value_kind is not SourceFreshnessValueKind.TIMESTAMP
-    ):
-        raise SourceParseError(f"{file_path} source freshness age_policy requires type timestamp")
-    policy: SourceFreshnessAgePolicy = config.age_policy or SourceFreshnessAgePolicy()
-    warn_after: str | None = policy.warn_after
-    error_after: str | None = policy.error_after
-    for raw in (warn_after, error_after):
-        if raw is not None and not _is_valid_source_freshness_duration(raw):
-            raise SourceParseError(
-                f"{file_path} source freshness age_policy values must be positive durations like "
-                "15m, 2h, or 1d"
-            )
-    if warn_after is not None and error_after is not None:
-        if _source_freshness_duration_minutes(warn_after) > _source_freshness_duration_minutes(
-            error_after
-        ):
-            raise SourceParseError(
-                f"{file_path} source freshness age_policy warn_after must be less than or "
-                "equal to error_after"
-            )
-
-
-def _is_valid_source_freshness_duration(value: str) -> bool:
-    duration: Duration | None = Duration.parse(value)
-    return duration is not None and duration.is_single_unit_in(MINUTE_TO_DAY_DURATION_UNITS)
-
-
-def _source_freshness_duration_minutes(value: str) -> int:
-    duration: Duration | None = Duration.parse(value)
-    if duration is None or not duration.is_single_unit_in(MINUTE_TO_DAY_DURATION_UNITS):
-        raise SourceParseError(f"invalid source freshness duration: {value}")
-    return duration.fixed_seconds // 60
-
-
-def _optional_positive_int(*, entry: dict[str, object], key: str, file_path: Path) -> int | None:
-    value: object | None = entry.get(key)
-    if value is None:
-        return None
-    if not isinstance(value, int) or isinstance(value, bool) or value <= 0:
-        raise SourceParseError(f"{file_path} source '{key}' must be a positive integer")
-    return value
-
-
-def _parse_columns(*, entry: dict[str, object], file_path: Path) -> tuple[SourceColumnEntry, ...]:
-    raw_columns: object = entry.get("columns", [])
-    if not isinstance(raw_columns, list):
-        raise SourceParseError(f"{file_path} source columns must be a list")
-
-    parsed_columns: list[SourceColumnEntry] = []
-    raw_column: object
-    for raw_column in raw_columns:
-        if not isinstance(raw_column, dict):
-            raise SourceParseError(f"{file_path} source columns must contain only mappings")
-        column: dict[str, object] = cast(dict[str, object], raw_column)
-        column_label: str = "source column"
-        _reject_unknown_source_keys(
-            mapping=column, allowed=_SOURCE_COLUMN_KEYS, file_path=file_path, label=column_label
-        )
-        column_name: str = require_non_empty_string(
-            entry=column,
-            key="name",
-            file_path=file_path,
-            label=column_label,
-            error_class=SourceParseError,
-        )
-        nullable: bool | None = optional_bool(
-            entry=column,
-            key="nullable",
-            file_path=file_path,
-            label=column_label,
-            error_class=SourceParseError,
-        )
-        audits: tuple[SchemaAuditInstance, ...] = parse_audit_instances(
-            raw_audits=column.get("audits", []),
-            file_path=file_path,
-            label=column_label,
-            error_class=SourceParseError,
-            null_as_empty=False,
-        )
-        _validate_nullable_audits(
-            file_path=file_path,
-            column_name=column_name,
-            nullable=nullable,
-            audit_names=tuple(audit.definition_name for audit in audits),
-        )
-        parsed_columns.append(
-            SourceColumnEntry(
-                name=column_name,
-                type=optional_non_empty_string(
-                    entry=column,
-                    key="type",
-                    file_path=file_path,
-                    label=column_label,
-                    error_class=SourceParseError,
-                ),
-                nullable=nullable,
-                description=optional_non_empty_string(
-                    entry=column,
-                    key="description",
-                    file_path=file_path,
-                    label=column_label,
-                    error_class=SourceParseError,
-                ),
-                meta=optional_mapping(
-                    entry=column,
-                    key="meta",
-                    file_path=file_path,
-                    label=column_label,
-                    error_class=SourceParseError,
-                ),
-                audits=audits,
-            )
-        )
-    return tuple(parsed_columns)
-
-
-def _validate_nullable_audits(
-    *, file_path: Path, column_name: str, nullable: bool | None, audit_names: tuple[str, ...]
-) -> None:
-    if nullable is True and NOT_NULL_AUDIT_NAME in audit_names:
-        raise SourceParseError(
-            f"{file_path} column '{column_name}' cannot set nullable = true and audit not_null"
-        )
-
-
-def _reject_unknown_source_keys(
-    *, mapping: dict[str, object], allowed: frozenset[str], file_path: Path, label: str
-) -> None:
-    reject_unknown_mapping_keys(
-        mapping=mapping,
-        allowed=allowed,
-        file_path=file_path,
-        label=label,
-        error_class=SourceParseError,
-    )
+    return _native.parse_sources_document(loaded, str(file_path), yaml_entry_classes())
diff --git a/src/sqlbuild/compiler/discovery/_helpers/yml/yaml_classes.py b/src/sqlbuild/compiler/discovery/_helpers/yml/yaml_classes.py
new file mode 100644
index 0000000000..2b96c6cf9f
--- /dev/null
+++ b/src/sqlbuild/compiler/discovery/_helpers/yml/yaml_classes.py
@@ -0,0 +1,45 @@
+"""The Python classes native YAML entry parsing builds source and seed declarations as."""
+
+from __future__ import annotations
+
+from functools import cache
+
+from sqlbuild.compiler.model_config.main._native_contract_classes import native_contract_classes
+from sqlbuild.integrations.dlt.models import DltResourceConfig, DltSourceConfig
+from sqlbuild.integrations.ingestr.models import IngestrSourceConfig
+from sqlbuild.spec.contracts.models import (
+    IntegrationLoaderConfig,
+    SchemaSeedEntry,
+    SeedCsvSettings,
+    SourceColumnEntry,
+    SourceEntry,
+    SourceFreshnessAgePolicy,
+    SourceFreshnessConfig,
+)
+from sqlbuild.spec.contracts.types import (
+    SourceFreshnessStrategy,
+    SourceFreshnessValueKind,
+    SourceWriteStrategy,
+)
+
+
+@cache
+def yaml_entry_classes() -> dict[str, object]:
+    """The classes parsed seed and source declarations become."""
+
+    return {
+        "contracts": native_contract_classes(),
+        "schema_seed_entry": SchemaSeedEntry,
+        "seed_csv_settings": SeedCsvSettings,
+        "source_entry": SourceEntry,
+        "source_column_entry": SourceColumnEntry,
+        "source_freshness_config": SourceFreshnessConfig,
+        "source_freshness_age_policy": SourceFreshnessAgePolicy,
+        "integration_loader_config": IntegrationLoaderConfig,
+        "ingestr_source_config": IngestrSourceConfig,
+        "dlt_source_config": DltSourceConfig,
+        "dlt_resource_config": DltResourceConfig,
+        "source_write_strategy": SourceWriteStrategy,
+        "source_freshness_strategy": SourceFreshnessStrategy,
+        "source_freshness_value_kind": SourceFreshnessValueKind,
+    }
diff --git a/src/sqlbuild/compiler/discovery/constants.py b/src/sqlbuild/compiler/discovery/constants.py
index b410e1a895..cf4d52c5ac 100644
--- a/src/sqlbuild/compiler/discovery/constants.py
+++ b/src/sqlbuild/compiler/discovery/constants.py
@@ -9,7 +9,6 @@
 TOML_FILE_SUFFIX: str = ".toml"
 SCHEMA_FILE_NAME: str = "schema.yml"
 YAML_FILE_SUFFIXES: frozenset[str] = frozenset({".yml", ".yaml"})
-RESERVED_MODEL_NAMES: frozenset[str] = frozenset({"_chain_"})
 
 PYTHON_INIT_MODULE_STEM: str = "__init__"
 PYTHON_CACHE_DIRECTORY_NAME: str = "__pycache__"
@@ -122,16 +121,9 @@
 )
 PYTHON_UDF_IMPORT_MODULES: frozenset[str] = frozenset({"sqlbuild", "sqlbuild.functions"})
 
-DLT_LOADER_KIND: str = "dlt"
 DLT_SOURCE_TYPE_SQL_DATABASE: str = "sql_database"
 DLT_SOURCE_TYPE_REST_API: str = "rest_api"
 DLT_SOURCE_TYPE_FILESYSTEM: str = "filesystem"
-DLT_SOURCE_TYPES: frozenset[str] = frozenset(
-    {DLT_SOURCE_TYPE_SQL_DATABASE, DLT_SOURCE_TYPE_REST_API, DLT_SOURCE_TYPE_FILESYSTEM}
-)
-DLT_RESOURCE_WRITE_STRATEGY_KEY: str = "write_strategy"
-DLT_WRITE_DISPOSITION_DELETE_INSERT: str = "delete_insert"
-DLT_WRITE_DISPOSITION_MERGE: str = "merge"
 
 CONFIG_CONCURRENCY_KEY: str = "concurrency"
 LEGACY_CONFIG_CONCURRENCY_KEY: str = "max_concurrency"
@@ -157,12 +149,8 @@
 DBT_PRODUCTION_REF_CONFIG_KEY: str = "production_ref"
 DBT_DEFER_CLONE_CONFIG_KEY: str = "defer_clone_from"
 DBT_REPLAY_ON_CHANGE_CONFIG_KEY: str = "replay_on_change"
-SOURCE_LOADER_CONFIG_KEY: str = "loader"
-SOURCE_AGE_POLICY_CONFIG_KEY: str = "age_policy"
 
 MODELS_DIRECTORY_NAME: str = "models"
-SEEDS_DIRECTORY_NAME: str = "seeds"
-CURRENT_DIRECTORY_PATH: str = "."
 SQL_TESTS_OWNERSHIP_ROOT: str = "tests/unit"
 SQL_SCENARIOS_OWNERSHIP_ROOT: str = "tests/scenarios"
 
diff --git a/src/sqlbuild/compiler/discovery/models.py b/src/sqlbuild/compiler/discovery/models.py
index fdf22d8355..dbba6d76bf 100644
--- a/src/sqlbuild/compiler/discovery/models.py
+++ b/src/sqlbuild/compiler/discovery/models.py
@@ -6,7 +6,7 @@
 from dataclasses import dataclass, field, replace
 from pathlib import Path
 
-from sqlbuild._native import NativeDiscoverySession
+from sqlbuild._native import DiscoveredSqlModelFile, NativeDiscoverySession
 from sqlbuild.compiler.auditing.models import MeasurementContract
 from sqlbuild.compiler.auditing.types import AuditEvaluationMode
 from sqlbuild.compiler.compile.constants import DEFAULT_SQL_TEST_MODE
@@ -33,7 +33,6 @@
     SchemaSeedEntry,
     SourceColumnEntry,
     SourceEntry,
-    SourceLocation,
 )
 from sqlbuild.spec.contracts.types import EventExportSeverity, SourceWriteStrategy
 from sqlbuild.sql_values.models import SqlLogicalType, SqlValue
@@ -69,22 +68,6 @@ class PythonHookEntry:
     kwargs: dict[str, object]
 
 
-@dataclass(frozen=True)
-class DiscoveredSqlModelFile:
-    """A discovered SQL model file and its raw contents."""
-
-    file_path: Path
-    relative_path: Path
-    contents: str
-    header_values: dict[str, object]
-    header_column_locations: dict[str, SourceLocation]
-    output_column_locations: dict[str, SourceLocation]
-    query_sql: str
-    enum_declarations: tuple[EnumDeclaration, ...] = field(default_factory=tuple)
-    constant_declarations: tuple[ConstantDeclaration, ...] = field(default_factory=tuple)
-    extract_implicit_alias_columns: bool = True
-
-
 @dataclass(frozen=True)
 class DiscoveredSqlFunctionFile:
     """A discovered SQL function file and its raw contents."""
diff --git a/src/sqlbuild/compiler/discovery/types.py b/src/sqlbuild/compiler/discovery/types.py
index e06a14f4de..a054a52dca 100644
--- a/src/sqlbuild/compiler/discovery/types.py
+++ b/src/sqlbuild/compiler/discovery/types.py
@@ -16,6 +16,7 @@
 type NativeLocation = tuple[str, int, int, int, int]
 type NativeListing = tuple[str, list[tuple[str, bool, bool]]]
 type NativeFiles = list[tuple[str, tuple[object, ...]]]
+type NativeModelFiles = list[tuple[Path, object]]
 type NativeFileScope = tuple[str, str, str | None, str | None, str | None]
 
 
diff --git a/src/sqlbuild/compiler/frontier/constants.py b/src/sqlbuild/compiler/frontier/constants.py
index 69e2dfea59..9f28dee1d6 100644
--- a/src/sqlbuild/compiler/frontier/constants.py
+++ b/src/sqlbuild/compiler/frontier/constants.py
@@ -33,6 +33,18 @@
     )
 }
 STAGE_CAPTURE_PROJECTED_ATTRIBUTES: dict[str, tuple[str, ...]] = {
+    "sqlbuild._native:DiscoveredSqlModelFile": (
+        "file_path",
+        "relative_path",
+        "contents",
+        "header_values",
+        "header_column_locations",
+        "output_column_locations",
+        "query_sql",
+        "enum_declarations",
+        "constant_declarations",
+        "extract_implicit_alias_columns",
+    ),
     "sqlbuild._native:NativeAuditInput": (
         "audit_file",
         "audit_block",
@@ -271,6 +283,9 @@
     ),
 }
 STAGE_CAPTURE_CANONICAL_TYPES: dict[str, str] = {
+    "sqlbuild._native:DiscoveredSqlModelFile": (
+        "sqlbuild.compiler.discovery.models:DiscoveredSqlModelFile"
+    ),
     "sqlbuild._native:NativeInputsView": "sqlbuild.compiler.compile.models:CompileProjectInputs",
     "sqlbuild._native:NativeProjectView": "sqlbuild.compiler.compile.models:CompiledProject",
     "sqlbuild._native:NativeModelInput": "sqlbuild.compiler.compile.models:CompileModelInput",
diff --git a/src/sqlbuild/lint/_helpers/fixes.py b/src/sqlbuild/lint/_helpers/fixes.py
index e5cd625573..477b9bce3d 100644
--- a/src/sqlbuild/lint/_helpers/fixes.py
+++ b/src/sqlbuild/lint/_helpers/fixes.py
@@ -429,10 +429,9 @@ def _updated_inputs(
     return replace(
         inputs,
         model_files=tuple(
-            replace(
-                model,
-                contents=files[model.file_path],
-                query_sql=files[model.file_path][model.contents.index(model.query_sql) :].strip(),
+            model.with_text(
+                files[model.file_path],
+                files[model.file_path][model.contents.index(model.query_sql) :].strip(),
             )
             if model.file_path in files and files[model.file_path] != model.contents
             else model
diff --git a/tests/integration/src/sqlbuild/cli/commands/main/helpers.py b/tests/integration/src/sqlbuild/cli/commands/main/helpers.py
index 20947e2be4..9b8f37cf44 100644
--- a/tests/integration/src/sqlbuild/cli/commands/main/helpers.py
+++ b/tests/integration/src/sqlbuild/cli/commands/main/helpers.py
@@ -655,9 +655,9 @@ def record_eager_output_column_scans(monkeypatch: pytest.MonkeyPatch) -> list[di
     eager: list[dict[str, object]] = []
     original: Callable[..., object] = native_model_files_module._native.discover_model_files
 
-    def recording(request: dict[str, object], tree: NativeProjectTree) -> object:
+    def recording(request: dict[str, object], tree: NativeProjectTree, project_dir: Path) -> object:
         eager.extend(filter(lambda item: item["extract_output_column_locations"], (request,)))
-        return original(request, tree)
+        return original(request, tree, project_dir)
 
     monkeypatch.setattr(native_model_files_module._native, "discover_model_files", recording)
     return eager
diff --git a/tests/integration/src/sqlbuild/compiler/discovery/_test_types.py b/tests/integration/src/sqlbuild/compiler/discovery/_test_types.py
index 5a466cf6f2..a8cabf8e17 100644
--- a/tests/integration/src/sqlbuild/compiler/discovery/_test_types.py
+++ b/tests/integration/src/sqlbuild/compiler/discovery/_test_types.py
@@ -1,7 +1,10 @@
 from __future__ import annotations
 
+from collections.abc import Callable
 from dataclasses import dataclass
 
+from sqlbuild.compiler.discovery.models import DiscoveredSqlModelFile
+
 
 @dataclass(frozen=True)
 class GeneratedDocumentOracleTestCase:
@@ -224,3 +227,31 @@ class DeepHeaderValuesTestCase:
     header: str
     stack_frames: int
     expected_max_depth: int
+
+
+@dataclass(frozen=True)
+class ProjectValidationTestCase:
+    """A project whose files conflict across discovery, with the error discovery raises."""
+
+    description: str
+    files: tuple[tuple[str, bytes], ...]
+    expected_error_type: str
+    expected_message: str
+
+
+@dataclass(frozen=True)
+class CsvDialectTestCase:
+    """Seed CSV settings; discovery fails as `csv.reader` does for `expected_reader_settings`."""
+
+    description: str
+    settings: bytes
+    expected_reader_settings: dict[str, str]
+
+
+@dataclass(frozen=True)
+class RecordCopyTestCase:
+    """One way Python copies a model file record, which must keep every field."""
+
+    description: str
+    copy_record: Callable[[DiscoveredSqlModelFile], DiscoveredSqlModelFile]
+    expected_query_sql: str
diff --git a/tests/integration/src/sqlbuild/compiler/discovery/helpers.py b/tests/integration/src/sqlbuild/compiler/discovery/helpers.py
index 8376b83de3..a5413fe7f3 100644
--- a/tests/integration/src/sqlbuild/compiler/discovery/helpers.py
+++ b/tests/integration/src/sqlbuild/compiler/discovery/helpers.py
@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import csv
 import dataclasses
 import datetime
 import functools
@@ -47,6 +48,7 @@
 from sqlbuild.compiler.discovery.main.discover import discover_project_inputs
 from sqlbuild.compiler.discovery.models import (
     DiscoveredProjectInputs,
+    DiscoveredSqlModelFile,
     DiscoveryFileFault,
     NamedSqlHookEntry,
     PythonHookEntry,
@@ -1045,3 +1047,56 @@ def native_yaml_tags_and_values(
     )
     loaded: list[tuple[object, ...]] = list(compress(rows, [row[0] == "ok" for row in rows]))
     return [row[0] for row in rows], [row[2] for row in loaded]
+
+
+VALIDATION_MODEL: tuple[str, bytes] = ("models/orders.sql", b"MODEL ();\nSELECT 1 AS order_id")
+
+
+def seed_project_files(*, header: bytes, settings: bytes = b"") -> tuple[tuple[str, bytes], ...]:
+    """A model and a `countries` seed declaring `code` and `label` with optional CSV settings."""
+
+    return (
+        VALIDATION_MODEL,
+        ("seeds/countries.csv", header + b"\nGB,United Kingdom\n"),
+        (
+            "seeds/countries.yml",
+            b"seeds:\n  - name: countries\n"
+            + settings
+            + b"    columns:\n      - name: code\n        type: VARCHAR\n"
+            b"      - name: label\n        type: VARCHAR\n",
+        ),
+    )
+
+
+def csv_reader_error(settings: dict[str, str]) -> tuple[str, str] | None:
+    """The error this Python's `csv.reader` raises for the settings, if any."""
+
+    try:
+        csv.reader((), **cast(dict[str, Any], settings))
+    except (TypeError, ValueError) as error:
+        return type(error).__name__, str(error)
+    return None
+
+
+def discovery_error(*, project_dir: Path) -> tuple[str, str] | None:
+    """The exception discovery raises for the project, if any."""
+
+    try:
+        discover_project_inputs(project_dir=project_dir)
+    except Exception as error:
+        return type(error).__name__, str(error)
+    return None
+
+
+def model_file_record() -> DiscoveredSqlModelFile:
+    """A model file record built through its keyword constructor."""
+
+    return DiscoveredSqlModelFile(
+        file_path=Path("/project/models/orders.sql"),
+        relative_path=Path("models/orders.sql"),
+        contents="MODEL ();\nselect 1 as order_id",
+        header_values={},
+        header_column_locations={},
+        output_column_locations={},
+        query_sql="select 1 as order_id",
+    )
diff --git a/tests/integration/src/sqlbuild/compiler/discovery/test_native_model_file_record.py b/tests/integration/src/sqlbuild/compiler/discovery/test_native_model_file_record.py
new file mode 100644
index 0000000000..439ca19d06
--- /dev/null
+++ b/tests/integration/src/sqlbuild/compiler/discovery/test_native_model_file_record.py
@@ -0,0 +1,43 @@
+"""Native model file records copy, pickle and construct like the dataclass they replace."""
+
+from __future__ import annotations
+
+import copy
+import pickle
+
+import pytest
+
+from sqlbuild.compiler.discovery.models import DiscoveredSqlModelFile
+from tests.integration.src.sqlbuild.compiler.discovery._test_types import RecordCopyTestCase
+from tests.integration.src.sqlbuild.compiler.discovery.helpers import model_file_record
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        RecordCopyTestCase(
+            description="copy.copy",
+            copy_record=copy.copy,
+            expected_query_sql="select 1 as order_id",
+        ),
+        RecordCopyTestCase(
+            description="copy.deepcopy",
+            copy_record=copy.deepcopy,
+            expected_query_sql="select 1 as order_id",
+        ),
+        RecordCopyTestCase(
+            description="a pickle round trip",
+            copy_record=lambda record: pickle.loads(pickle.dumps(record)),
+            expected_query_sql="select 1 as order_id",
+        ),
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_a_model_file_record_when_copying_then_every_field_is_kept(
+    test_case: RecordCopyTestCase,
+) -> None:
+    record: DiscoveredSqlModelFile = model_file_record()
+
+    copied: DiscoveredSqlModelFile = test_case.copy_record(record)
+
+    assert (copied, copied.query_sql) == (record, test_case.expected_query_sql)
diff --git a/tests/integration/src/sqlbuild/compiler/discovery/test_native_project_validation.py b/tests/integration/src/sqlbuild/compiler/discovery/test_native_project_validation.py
new file mode 100644
index 0000000000..103c7ccd6e
--- /dev/null
+++ b/tests/integration/src/sqlbuild/compiler/discovery/test_native_project_validation.py
@@ -0,0 +1,115 @@
+"""Native cross-file validation raises the discovery errors Python raised, with their text."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from tests.integration.src.sqlbuild.compiler.discovery._test_types import (
+    CsvDialectTestCase,
+    ProjectValidationTestCase,
+)
+from tests.integration.src.sqlbuild.compiler.discovery.helpers import (
+    VALIDATION_MODEL,
+    csv_reader_error,
+    discovery_error,
+    seed_project_files,
+    stage_outcome,
+    write_project,
+)
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        ProjectValidationTestCase(
+            description="a seed header that differs from its declared columns",
+            files=seed_project_files(header=b"code,name"),
+            expected_error_type="SeedDiscoveryError",
+            expected_message=(
+                "seeds/countries.csv header ('code', 'name') does not match declared seed "
+                "columns ('code', 'label') for 'countries'"
+            ),
+        ),
+        ProjectValidationTestCase(
+            description="a quoted seed header honours the declared quotechar",
+            files=seed_project_files(
+                header=b'"code";"label";"extra"',
+                settings=b"    csv_settings:\n      delimiter: ';'\n      quotechar: '\"'\n",
+            ),
+            expected_error_type="SeedDiscoveryError",
+            expected_message=(
+                "seeds/countries.csv header ('code', 'label', 'extra') does not match declared "
+                "seed columns ('code', 'label') for 'countries'"
+            ),
+        ),
+        ProjectValidationTestCase(
+            description="a seed CSV without a declaration",
+            files=(VALIDATION_MODEL, ("seeds/regions.csv", b"code\nEU\n")),
+            expected_error_type="SeedDiscoveryError",
+            expected_message=(
+                "Seed CSV seeds/regions.csv has no matching declaration for seed 'regions' under "
+                "seeds/**/*.yml"
+            ),
+        ),
+        ProjectValidationTestCase(
+            description="two model files with one name",
+            files=(
+                VALIDATION_MODEL,
+                ("models/marts/orders.sql", b"MODEL ();\nSELECT 2 AS order_id"),
+            ),
+            expected_error_type="DiscoveryConflictError",
+            expected_message=(
+                "Duplicate model file name found for 'orders' in models/marts/orders.sql and "
+                "models/orders.sql"
+            ),
+        ),
+        ProjectValidationTestCase(
+            description="a non-canonical model identity",
+            files=(("models/Orders.sql", b"MODEL ();\nSELECT 1 AS order_id"),),
+            expected_error_type="ResourceIdentityError",
+            expected_message=(
+                "Invalid model identity 'Orders' in models/Orders.sql; use snake_case 'orders'"
+            ),
+        ),
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_conflicting_project_files_when_discovering_then_raises_the_discovery_error(
+    test_case: ProjectValidationTestCase, tmp_path: Path
+) -> None:
+    write_project(project_dir=tmp_path, files=test_case.files)
+
+    outcome: tuple[object, ...] = stage_outcome(project_dir=tmp_path)
+
+    assert outcome[1:] == (test_case.expected_error_type, test_case.expected_message)
+
+
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        CsvDialectTestCase(
+            description="an empty quotechar",
+            settings=b"    csv_settings:\n      quotechar: ''\n",
+            expected_reader_settings={"quotechar": ""},
+        ),
+        CsvDialectTestCase(
+            description="a delimiter equal to its quotechar",
+            settings=b"    csv_settings:\n      delimiter: ','\n      quotechar: ','\n",
+            expected_reader_settings={"quotechar": ","},
+        ),
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_seed_csv_settings_when_discovering_then_matches_this_pythons_csv_reader(
+    test_case: CsvDialectTestCase, tmp_path: Path
+) -> None:
+    write_project(
+        project_dir=tmp_path,
+        files=seed_project_files(header=b"code,label", settings=test_case.settings),
+    )
+
+    outcome: tuple[str, str] | None = discovery_error(project_dir=tmp_path)
+
+    assert outcome == csv_reader_error(test_case.expected_reader_settings)
diff --git a/tests/integration/src/sqlbuild/compiler/model_config/helpers.py b/tests/integration/src/sqlbuild/compiler/model_config/helpers.py
index 477e9f8342..8800958555 100644
--- a/tests/integration/src/sqlbuild/compiler/model_config/helpers.py
+++ b/tests/integration/src/sqlbuild/compiler/model_config/helpers.py
@@ -393,10 +393,17 @@ def _model_file(
         name: SourceLocation(path=base.relative_path, line=line + 2, column=3)
         for line, name in enumerate(names[: len(names) * (index % 2)])
     }
-    return replace(
-        base,
+    return DiscoveredSqlModelFile(
+        file_path=base.file_path,
+        relative_path=base.relative_path,
+        contents=base.contents,
         header_values={**base.header_values, "columns": columns, "audits": audits},
         header_column_locations=locations,
+        output_column_locations=base.output_column_locations,
+        query_sql=base.query_sql,
+        enum_declarations=base.enum_declarations,
+        constant_declarations=base.constant_declarations,
+        extract_implicit_alias_columns=base.extract_implicit_alias_columns,
     )
 
 
diff --git a/tests/unit/src/sqlbuild/compiler/discovery/_helpers/_test_types.py b/tests/unit/src/sqlbuild/compiler/discovery/_helpers/_test_types.py
index 27a33f0e20..8b11448b1c 100644
--- a/tests/unit/src/sqlbuild/compiler/discovery/_helpers/_test_types.py
+++ b/tests/unit/src/sqlbuild/compiler/discovery/_helpers/_test_types.py
@@ -228,22 +228,6 @@ class DeferredModelOutputLocationTestCase:
     expected_extract_implicit_alias_columns: bool
 
 
-@dataclass(frozen=True)
-class ValidatePathDefaultsMatchModelsTestCase:
-    description: str
-    model_relative_paths: tuple[str, ...]
-    path_defaults: dict[str, dict[str, object]]
-    expected_model_file_count: int
-
-
-@dataclass(frozen=True)
-class ValidatePathDefaultsMatchModelsErrorTestCase:
-    description: str
-    model_relative_paths: tuple[str, ...]
-    path_defaults: dict[str, dict[str, object]]
-    expected_error_fragment: str
-
-
 @dataclass(frozen=True)
 class LoadProjectConfigTestCase:
     description: str
diff --git a/tests/unit/src/sqlbuild/compiler/discovery/_helpers/test_path_defaults.py b/tests/unit/src/sqlbuild/compiler/discovery/_helpers/test_path_defaults.py
deleted file mode 100644
index d94d9ba7a0..0000000000
--- a/tests/unit/src/sqlbuild/compiler/discovery/_helpers/test_path_defaults.py
+++ /dev/null
@@ -1,115 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-
-import pytest
-
-from sqlbuild.compiler.discovery._helpers.validation.discovery import (
-    _validate_path_defaults_match_models,
-)
-from sqlbuild.compiler.discovery.exceptions import DiscoveryConflictError
-from sqlbuild.compiler.discovery.models import DiscoveredSqlModelFile
-from tests.unit.src.sqlbuild.compiler.discovery._helpers._test_types import (
-    ValidatePathDefaultsMatchModelsErrorTestCase,
-    ValidatePathDefaultsMatchModelsTestCase,
-)
-
-
-@pytest.mark.parametrize(
-    "test_case",
-    (
-        ValidatePathDefaultsMatchModelsTestCase(
-            description="accepts Windows-style model paths that match path defaults",
-            model_relative_paths=("models\\staging\\orders.sql",),
-            path_defaults={"staging": {}},
-            expected_model_file_count=1,
-        ),
-        ValidatePathDefaultsMatchModelsTestCase(
-            description="accepts recursive glob matching nested staging prefix",
-            model_relative_paths=("models/commerce/partner_feed/staging/orders.sql",),
-            path_defaults={"commerce/**/staging": {}},
-            expected_model_file_count=1,
-        ),
-        ValidatePathDefaultsMatchModelsTestCase(
-            description="accepts recursive glob matching zero segments",
-            model_relative_paths=("models/commerce/staging/orders.sql",),
-            path_defaults={"commerce/**/staging": {}},
-            expected_model_file_count=1,
-        ),
-        ValidatePathDefaultsMatchModelsTestCase(
-            description="counts broad glob as matched when a literal wins selection",
-            model_relative_paths=("models/commerce/partner_feed/staging/orders.sql",),
-            path_defaults={
-                "commerce/**/staging": {},
-                "commerce/partner_feed/staging": {},
-            },
-            expected_model_file_count=1,
-        ),
-    ),
-    ids=lambda case: case.description,
-)
-def test_given_windows_style_model_paths_when_validating_path_defaults_then_they_match(
-    test_case: ValidatePathDefaultsMatchModelsTestCase,
-) -> None:
-    model_files: tuple[DiscoveredSqlModelFile, ...] = tuple(
-        DiscoveredSqlModelFile(
-            file_path=Path("/repo") / relative_path,
-            relative_path=Path(relative_path),
-            contents="MODEL ();\n\nselect 1\n",
-            header_values={},
-            header_column_locations={},
-            output_column_locations={},
-            query_sql="select 1",
-        )
-        for relative_path in test_case.model_relative_paths
-    )
-
-    _validate_path_defaults_match_models(
-        path_defaults=test_case.path_defaults,
-        model_files=model_files,
-    )
-
-    assert len(model_files) == test_case.expected_model_file_count
-
-
-@pytest.mark.parametrize(
-    "test_case",
-    (
-        ValidatePathDefaultsMatchModelsErrorTestCase(
-            description="rejects recursive glob matching no model paths",
-            model_relative_paths=("models/commerce/partner_feed/marts/orders.sql",),
-            path_defaults={"commerce/**/staging": {}},
-            expected_error_fragment=(
-                r"path_defaults\['commerce/\*\*/staging'\] does not match any model paths"
-            ),
-        ),
-        ValidatePathDefaultsMatchModelsErrorTestCase(
-            description="rejects equally specific matching globs during discovery",
-            model_relative_paths=("models/commerce/eu/staging/orders.sql",),
-            path_defaults={"commerce/*/staging": {}, "commerce/eu/*": {}},
-            expected_error_fragment="matches equally specific path_defaults keys",
-        ),
-    ),
-    ids=lambda case: case.description,
-)
-def test_given_invalid_glob_matches_when_validating_path_defaults_then_raises_conflict(
-    test_case: ValidatePathDefaultsMatchModelsErrorTestCase,
-) -> None:
-    model_files: tuple[DiscoveredSqlModelFile, ...] = tuple(
-        DiscoveredSqlModelFile(
-            file_path=Path("/repo") / relative_path,
-            relative_path=Path(relative_path),
-            contents="MODEL ();\n\nselect 1\n",
-            header_values={},
-            header_column_locations={},
-            output_column_locations={},
-            query_sql="select 1",
-        )
-        for relative_path in test_case.model_relative_paths
-    )
-
-    with pytest.raises(DiscoveryConflictError, match=test_case.expected_error_fragment):
-        _validate_path_defaults_match_models(
-            path_defaults=test_case.path_defaults,
-            model_files=model_files,
-        )