Merge remote-tracking branch 'origin/main' into feat/native-reference-errors

# Conflicts:
#	tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py

Author: kvlonge

.release-please-manifest.json

@@ -1,3 +1,3 @@
 {
-  ".": "0.143.1"
+  ".": "0.144.0"
 }

CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## [0.144.0](https://github.com/chio-labs/sqlbuild/compare/v0.143.1...v0.144.0) (2026-10-08)
+
+
+### Features
+
+* **native:** build model config and validate models natively behind the preview engine ([#1034](https://github.com/chio-labs/sqlbuild/issues/1034)) ([24e47aa](https://github.com/chio-labs/sqlbuild/commit/24e47aa5399b702a92e2fbc13aac70cf39f8d15a))
+* **native:** report attachment errors natively ([#1038](https://github.com/chio-labs/sqlbuild/issues/1038)) ([ee19894](https://github.com/chio-labs/sqlbuild/commit/ee19894bb5328fcb3310e21eff3962934189fb48))
+* **native:** report declaration and scope errors natively ([#1033](https://github.com/chio-labs/sqlbuild/issues/1033)) ([241fb56](https://github.com/chio-labs/sqlbuild/commit/241fb56ef8454c7e9c5739cbb3169d4b5e2a0fd1))
+
 ## [0.143.1](https://github.com/chio-labs/sqlbuild/compare/v0.143.0...v0.143.1) (2026-10-08)
 
 

Cargo.lock

@@ -37,7 +37,7 @@ python-boundary = "sqlbuild-python"
 polyglot-floor = "sqlbuild-analysis"
 
 [workspace.package]
-version = "0.143.1"
+version = "0.144.0"
 edition = "2024"
 license = "Apache-2.0"
 publish = false

Cargo.toml

@@ -0,0 +1,51 @@
+//! The first config field, in Python's walk order, whose string holds a macro call.
+
+use crate::config_presence::_helpers::macro_calls::macro_call;
+use crate::config_presence::models::{MacroPath, Presence};
+use crate::types::{AuthoredNode, NodeKind};
+
+/// Walk config values as `validate_no_macros_in_config_value` does, skipping the `skipped` keys.
+pub fn first_macro_path<N: AuthoredNode>(values: &N, skipped: &[&str]) -> MacroPath {
+    let mut entries = values.entries();
+    entries.retain(|(key, _)| !skipped.iter().any(|name| key.is_text(name)));
+    walk_entries(&entries, &[])
+}
+
+fn walk<N: AuthoredNode>(node: &N, path: &[String]) -> MacroPath {
+    match node.kind() {
+        NodeKind::Str => match node.with_text(macro_call) {
+            Some(Presence::Present) => MacroPath::Found(path.to_vec()),
+            Some(Presence::Absent) => MacroPath::Absent,
+            Some(Presence::Deferred) | None => MacroPath::Deferred,
+        },
+        NodeKind::Map => walk_entries(&node.entries(), path),
+        NodeKind::List | NodeKind::Tuple => {
+            for item in node.items() {
+                let found = walk(&item, path);
+                if found != MacroPath::Absent {
+                    return found;
+                }
+            }
+            MacroPath::Absent
+        }
+        _ => MacroPath::Absent,
+    }
+}
+
+fn walk_entries<N: AuthoredNode>(entries: &[(N, N)], path: &[String]) -> MacroPath {
+    for (key, value) in entries {
+        if key.kind() != NodeKind::Str {
+            continue;
+        }
+        let Some(name) = key.text() else {
+            return MacroPath::Deferred;
+        };
+        let mut child: Vec<String> = path.to_vec();
+        child.push(name);
+        let found = walk(value, &child);
+        if found != MacroPath::Absent {
+            return found;
+        }
+    }
+    MacroPath::Absent
+}

crates/sqlbuild-model-config/src/config_presence/main/first_macro_path.rs

@@ -1,2 +1,3 @@
 pub mod contains_macro_call;
 pub mod contains_template;
+pub mod first_macro_path;

crates/sqlbuild-model-config/src/config_presence/main/mod.rs

@@ -8,3 +8,13 @@ pub enum Presence {
     /// A string needs Python's Unicode `\s` class to decide.
     Deferred,
 }
+
+/// Where Python's config walk first finds a macro call.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum MacroPath {
+    /// The mapping keys leading to the first string holding a macro call.
+    Found(Vec<String>),
+    Absent,
+    /// A string before any match needs Python's Unicode rules to decide.
+    Deferred,
+}

crates/sqlbuild-model-config/src/config_presence/models.rs

@@ -0,0 +1,69 @@
+//! Errors the native config stages report exactly as the Python stages raise them.
+
+/// The Python exception class one error raises.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ErrorClass {
+    /// `CompileInputError`.
+    CompileInput,
+    /// `ConfigValueTypeError` for a config key that must hold a string.
+    ConfigValueType,
+    /// `ResourceIdentityError` for an identity that is not canonical snake_case.
+    ResourceIdentity,
+    /// `DiscoveryConflictError` for equally specific path-default keys.
+    DiscoveryConflict,
+}
+
+/// One error with the class, message, code and help the Python stage raises.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ConfigError {
+    pub class: ErrorClass,
+    /// The message; empty for `ConfigValueTypeError`, which Python words from the value's type.
+    pub message: String,
+    /// The diagnostic code when it is not the class default.
+    pub code: Option<&'static str>,
+    pub help: Option<String>,
+    /// The config key a `ConfigValueTypeError` names.
+    pub key: Option<String>,
+}
+
+impl ConfigError {
+    /// A `CompileInputError` with this message.
+    pub fn compile(message: String) -> Self {
+        Self {
+            class: ErrorClass::CompileInput,
+            message,
+            code: None,
+            help: None,
+            key: None,
+        }
+    }
+
+    /// The `ConfigValueTypeError` `get_config_str` raises for a non-string `key`.
+    pub fn config_value_type(key: &str) -> Self {
+        Self {
+            class: ErrorClass::ConfigValueType,
+            message: String::new(),
+            code: None,
+            help: None,
+            key: Some(key.to_owned()),
+        }
+    }
+
+    /// This error of another class.
+    pub fn with_class(mut self, class: ErrorClass) -> Self {
+        self.class = class;
+        self
+    }
+
+    /// This error with help text.
+    pub fn with_help(mut self, help: impl Into<String>) -> Self {
+        self.help = Some(help.into());
+        self
+    }
+
+    /// This error with a diagnostic code.
+    pub fn with_code(mut self, code: &'static str) -> Self {
+        self.code = Some(code);
+        self
+    }
+}