@@ -201,7 +201,7 @@ impl HeaderParser {
             self.advance();
             if self.peek().0 == SYMBOL_TOKEN && self.peek().1 == OPEN_PAREN {
                 self.advance();
-                return self.nested(token.2, |parser| parser.parse_call(token.1, options));
+                return self.nested(token.2, |parser| parser.parse_call(token, options));
             }
             return Ok(parse_word(token.1));
         }
@@ -230,17 +230,17 @@ impl HeaderParser {
         Err(format!("expected value at position {}", token.2))
     }
 
-    /// The value after `name(`, which has been consumed.
+    /// The value after a consumed `name(`; a plain call nests a map in a map, two levels.
     fn parse_call(
         &mut self,
-        name: String,
+        (_, name, position): HeaderToken,
         options: ParseValueOptions,
     ) -> Result<AuthoredValue, String> {
         if matches!(name.as_str(), "__ref" | "__seed" | "__source") {
             return self.parse_relation(&name);
         }
         if matches!(name.as_str(), "inline_sql" | "sql" | "python") {
-            return self.parse_hook(&name);
+            return self.parse_hook(&name, position);
         }
         if name == CONSTANT_CALL {
             return Ok(AuthoredValue::TypedConstant(self.parse_map(
@@ -250,23 +250,26 @@ impl HeaderParser {
                 },
             )?));
         }
-        Ok(AuthoredValue::Map(vec![(
-            name,
-            AuthoredValue::Map(self.parse_map(ParseMapOptions {
+        let arguments: Vec<(String, AuthoredValue)> = self.nested(position, |parser| {
+            parser.parse_map(ParseMapOptions {
                 end: Some(")"),
                 threshold_policy: options.threshold_policy,
                 allow_outside: options.allow_outside,
                 ..ParseMapOptions::default()
-            })?),
+            })
+        })?;
+        Ok(AuthoredValue::Map(vec![(
+            name,
+            AuthoredValue::Map(arguments),
         )]))
     }
 
     /// Parse one container opened at `position`, refusing to nest deeper than the limit.
-    fn nested(
+    fn nested<T>(
         &mut self,
         position: usize,
-        parse: impl FnOnce(&mut Self) -> Result<AuthoredValue, String>,
-    ) -> Result<AuthoredValue, String> {
+        parse: impl FnOnce(&mut Self) -> Result<T, String>,
+    ) -> Result<T, String> {
         if self.depth >= MAX_HEADER_NESTING_DEPTH {
             return Err(nesting_error(position));
         }
@@ -334,7 +337,7 @@ impl HeaderParser {
         if !matches!(token.1.as_str(), "inline_sql" | "sql" | "python") {
             return Err(error());
         }
-        self.nested(token.2, |parser| parser.parse_hook(&token.1))
+        self.nested(token.2, |parser| parser.parse_hook(&token.1, token.2))
     }
 
     fn parse_relation(&mut self, name: &str) -> Result<AuthoredValue, String> {
@@ -352,7 +355,8 @@ impl HeaderParser {
         )))
     }
 
-    fn parse_hook(&mut self, name: &str) -> Result<AuthoredValue, String> {
+    /// The hook after `name(` at `position`; its keyword arguments are one more level.
+    fn parse_hook(&mut self, name: &str, position: usize) -> Result<AuthoredValue, String> {
         if name == INLINE_SQL_HOOK {
             let token = self.peek().clone();
             if token.0 != STRING_TOKEN {
@@ -373,7 +377,7 @@ impl HeaderParser {
         if token.1.chars().all(is_python_whitespace) {
             return Err(format!("{name}(...) requires a non-empty hook name"));
         }
-        let kwargs = self.parse_hook_kwargs()?;
+        let kwargs = self.nested(position, Self::parse_hook_kwargs)?;
         if name == SQL_HOOK {
             Ok(AuthoredValue::NamedSqlHook(token.1, kwargs))
         } else {
 
@@ -84,14 +84,32 @@ fn given_nested_header_values_when_parsing_on_an_ordinary_thread_then_depth_is_c
             depth: 100_000,
             expected_error_position: Some(1_285),
         },
+        HeaderNestingTestCase {
+            description: "calls count their map and arguments, so 128 reach the limit",
+            prefix: "meta ",
+            open: "call(key ",
+            close: ")",
+            suffix: "",
+            depth: 128,
+            expected_error_position: None,
+        },
+        HeaderNestingTestCase {
+            description: "calls one past the limit fail at the outermost extra call",
+            prefix: "meta ",
+            open: "call(key ",
+            close: ")",
+            suffix: "",
+            depth: 129,
+            expected_error_position: Some(1_157),
+        },
         HeaderNestingTestCase {
             description: "calls 20k deep",
             prefix: "meta ",
             open: "call(key ",
             close: ")",
             suffix: "",
             depth: 20_000,
-            expected_error_position: Some(2_309),
+            expected_error_position: Some(1_157),
         },
         HeaderNestingTestCase {
             description: "typed constants 1k deep",
@@ -103,13 +121,13 @@ fn given_nested_header_values_when_parsing_on_an_ordinary_thread_then_depth_is_c
             expected_error_position: Some(3_845),
         },
         HeaderNestingTestCase {
-            description: "hook arguments 100k deep count the hook list and each hook",
+            description: "hook arguments 100k deep count the hook list, each hook and its arguments",
             prefix: "post_hooks [",
             open: "sql(\"refresh\", nested: ",
             close: ")",
             suffix: "]",
             depth: 100_000,
-            expected_error_position: Some(5_877),
+            expected_error_position: Some(2_933),
         },
     ];
 
 
@@ -34,6 +34,7 @@
 _MACRO_MODULE: str = "def cents(value):\n    return f'{value} * 100'\n"
 _DEEP_HEADER_DEPTH: int = 20_000
 _DEEP_HEADER_VALUE: str = "[" * _DEEP_HEADER_DEPTH + '"placed"' + "]" * _DEEP_HEADER_DEPTH
+_DEEP_HEADER_CALLS: str = "limit(level " * _DEEP_HEADER_DEPTH + "1" + ")" * _DEEP_HEADER_DEPTH
 _DEEP_HEADER_MESSAGE: str = "contains invalid SQLBuild header syntax: values nest deeper than 256"
 _SEED_DECLARATION: str = (
     "seeds:\n  - name: order_channels\n    description: Order channels.\n"
@@ -165,7 +166,7 @@ def _sql_file_cases() -> tuple[FailureCase, ...]:
             expected_code="D013",
             files={
                 "models/staging/_sqlbuild/_constants/statuses.sql": (
-                    f"CONSTANT (name kept_statuses, value {_DEEP_HEADER_VALUE});\n"
+                    f"CONSTANT (name kept_statuses, value {_DEEP_HEADER_CALLS});\n"
                 )
             },
             expected_message=_DEEP_HEADER_MESSAGE,
 
@@ -5,7 +5,8 @@
 import re
 from bisect import bisect_right
 from collections import OrderedDict
-from dataclasses import dataclass
+from collections.abc import Callable
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import cast
 
@@ -52,6 +53,7 @@
 _MODEL_HEADER_INTEGER_PATTERN: re.Pattern[str] = re.compile(r"^[+-]?\d+$")
 _MODEL_HEADER_FLOAT_PATTERN: re.Pattern[str] = re.compile(r"^[+-]?(?:\d+\.\d*|\d*\.\d+)$")
 _MODEL_HEADER_TOKEN_CACHE_SIZE: int = 4096
+_PROJECTION_PENDING: object = object()
 _MODEL_HEADER_NESTING_ERROR_PATTERN: re.Pattern[str] = re.compile(
     r"values nest deeper than (?P<limit>\d+) levels at position (?P<position>\d+)"
 )
@@ -79,6 +81,15 @@
 _SELECT_SCAN_SPECIAL: re.Pattern[str] = re.compile(r"['\"`()sSfFuU]")
 
 
+@dataclass
+class _ProjectionFrame:
+    """One container being projected: its native children, projected so far, and its builder."""
+
+    children: tuple[object, ...]
+    build: Callable[[list[object]], object]
+    projected: list[object] = field(default_factory=list)
+
+
 @dataclass(frozen=True)
 class _ModelHeaderToken:
     kind: str
@@ -575,17 +586,22 @@ def parse_header_values(
         raise
     except ModelHeaderSyntaxError as error:
         nesting: re.Match[str] | None = _MODEL_HEADER_NESTING_ERROR_PATTERN.fullmatch(str(error))
+        nesting_help: str | None = (
+            None
+            if nesting is None
+            else f"flatten the value so it nests at most {nesting.group('limit')} levels deep"
+        )
         if nesting is None or header_line is None:
             raise error_class(
                 f"{statement_name}(...) in '{file_path}' contains invalid SQLBuild header syntax: "
-                f"{error}"
+                f"{error}",
+                help=nesting_help,
             ) from error
-        limit: str = nesting.group("limit")
         line: int = header_line + header.count("\n", 0, int(nesting.group("position")))
         raise error_class(
             f"{statement_name}(...) in '{file_path}:{line}' contains invalid SQLBuild header "
-            f"syntax: values nest deeper than {limit} levels",
-            help=f"flatten the value so it nests at most {limit} levels deep",
+            f"syntax: values nest deeper than {nesting.group('limit')} levels",
+            help=nesting_help,
         ) from error
 
 
@@ -653,47 +669,98 @@ def project_native_header_values(values: dict[str, object]) -> dict[str, object]
 
 
 def _project_native_header_map(values: dict[str, object]) -> dict[str, object]:
-    return {key: _project_native_header_value(value) for key, value in values.items()}
+    return cast(dict[str, object], _project_native_header_value(values))
 
 
 def _project_native_header_value(value: object) -> object:
+    """Project one native value depth-first with an explicit stack, never Python recursion."""
+
+    frames: list[_ProjectionFrame] = []
+    node: object = value
+    while True:
+        expansion: _ProjectionFrame | None = _projection_frame(node)
+        if expansion is None:
+            projected: object = _project_native_leaf(node)
+        else:
+            frames.append(expansion)
+            projected = _PROJECTION_PENDING
+        while True:
+            if projected is not _PROJECTION_PENDING:
+                if not frames:
+                    return projected
+                frames[-1].projected.append(projected)
+            frame: _ProjectionFrame = frames[-1]
+            if len(frame.projected) < len(frame.children):
+                node = frame.children[len(frame.projected)]
+                break
+            frames.pop()
+            projected = frame.build(frame.projected)
+
+
+def _projection_frame(value: object) -> _ProjectionFrame | None:
     if isinstance(value, dict):
-        return _project_native_header_map(cast(dict[str, object], value))
+        return _map_frame(values=cast(dict[str, object], value), build=dict)
     if isinstance(value, list):
-        return [_project_native_header_value(item) for item in value]
+        return _ProjectionFrame(children=tuple(value), build=list)
     if (
         not isinstance(value, tuple)
         or len(value) != _NATIVE_MARKER_LENGTH
         or not isinstance(value[0], str)
     ):
-        return value
+        return None
     kind: str = value[0]
     payload: object = value[1]
-    if kind == _MODEL_HEADER_WORD_TOKEN and isinstance(payload, str):
-        return _parse_word_value(payload)
     if kind == _NATIVE_SET_MARKER and isinstance(payload, list):
-        return AuthoredSqlSet(tuple(_project_native_header_value(item) for item in payload))
+        return _ProjectionFrame(
+            children=tuple(payload), build=lambda items: AuthoredSqlSet(tuple(items))
+        )
     if kind == _NATIVE_TUPLE_MARKER and isinstance(payload, list):
-        return tuple(_project_native_header_value(item) for item in payload)
+        return _ProjectionFrame(children=tuple(payload), build=tuple)
     if kind == _NATIVE_CONSTANT_MARKER and isinstance(payload, dict):
-        return AuthoredSqlValueCall(
-            arguments=tuple(_project_native_header_map(cast(dict[str, object], payload)).items())
+        return _map_frame(
+            values=cast(dict[str, object], payload),
+            build=lambda items: AuthoredSqlValueCall(arguments=tuple(items)),
         )
-    if kind == _NATIVE_INLINE_SQL_MARKER and isinstance(payload, str):
-        return SqlHookEntry(statement=payload)
     if (
         kind in {_NATIVE_SQL_MARKER, _NATIVE_PYTHON_MARKER}
         and isinstance(payload, tuple)
         and len(payload) == _NATIVE_MARKER_LENGTH
     ):
         name, kwargs = payload
         if isinstance(name, str) and isinstance(kwargs, dict):
-            projected_kwargs: dict[str, object] = _project_native_header_map(
-                cast(dict[str, object], kwargs)
+            entry_type: type[NamedSqlHookEntry] | type[PythonHookEntry] = (
+                NamedSqlHookEntry if kind == _NATIVE_SQL_MARKER else PythonHookEntry
             )
-            if kind == _NATIVE_SQL_MARKER:
-                return NamedSqlHookEntry(name=name, kwargs=projected_kwargs)
-            return PythonHookEntry(name=name, kwargs=projected_kwargs)
+            return _map_frame(
+                values=cast(dict[str, object], kwargs),
+                build=lambda items: entry_type(name=name, kwargs=dict(items)),
+            )
+    return None
+
+
+def _map_frame(
+    *, values: dict[str, object], build: Callable[[list[tuple[str, object]]], object]
+) -> _ProjectionFrame:
+    keys: tuple[str, ...] = tuple(values)
+    return _ProjectionFrame(
+        children=tuple(values.values()),
+        build=lambda projected: build(list(zip(keys, projected, strict=True))),
+    )
+
+
+def _project_native_leaf(value: object) -> object:
+    if (
+        not isinstance(value, tuple)
+        or len(value) != _NATIVE_MARKER_LENGTH
+        or not isinstance(value[0], str)
+    ):
+        return value
+    kind: str = value[0]
+    payload: object = value[1]
+    if kind == _MODEL_HEADER_WORD_TOKEN and isinstance(payload, str):
+        return _parse_word_value(payload)
+    if kind == _NATIVE_INLINE_SQL_MARKER and isinstance(payload, str):
+        return SqlHookEntry(statement=payload)
     raise ModelHeaderSyntaxError(f"Native MODEL header parser returned invalid '{kind}' marker")
 
 
 
@@ -16,7 +16,7 @@
     source_line_starts,
     source_position,
 )
-from sqlbuild.compiler.discovery.exceptions import ModelSqlParseError
+from sqlbuild.compiler.discovery.exceptions import DiscoveryError, ModelSqlParseError
 from sqlbuild.lint.constants import (
     CARRIAGE_RETURN_LINE_FEED,
     CLOSING_PAREN_CHARACTER,
@@ -245,7 +245,7 @@ def _lint_header_values(
                 message=f"{header.kind}() header could not be parsed: {error}",
                 severity=VIOLATION_SEVERITY_FAULT,
                 engine=LINT_ENGINE_SQLBUILD,
-                remediation=f"Correct the {header.kind}() header syntax.",
+                remediation=_header_parse_remediation(kind=header.kind, error=error),
             ),
         )
 
@@ -304,6 +304,11 @@ def _lint_header_values(
     return tuple(violations)
 
 
+def _header_parse_remediation(*, kind: str, error: Exception) -> str:
+    help_text: str | None = error.help if isinstance(error, DiscoveryError) else None
+    return f"Correct the {kind}() header syntax." if help_text is None else help_text
+
+
 def _parse_header_values(*, kind: str, header_text: str) -> dict[str, object]:
     inner: str = _inner_header_text(header_text=header_text)
     return parse_header_values(
 
@@ -985,3 +985,11 @@ class DeepHeaderNestingCompileCase:
     suffix: str
     depth: int
     expected_fragments: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class DeepCallNestingCompileCase:
+    description: str
+    depth: int
+    engines: tuple[str, ...]
+    expected_fragments: tuple[str, ...]