@@ -85,17 +85,17 @@ pub(crate) fn optional_one_of(text: Option<&str>, vocabulary: &[&str]) -> bool {
     text.is_some_and(|value| one_of(value, vocabulary))
 }
 
-/// Read `_string_sequence`: a string, or the strings of a list or tuple.
-pub(crate) fn string_sequence<N: AuthoredNode>(value: Option<&N>) -> Vec<String> {
+/// Read `_string_sequence`: a string, or the strings of a list or tuple; reject unreadable text.
+pub(crate) fn string_sequence<N: AuthoredNode>(value: Option<&N>) -> Result<Vec<String>, Rejected> {
     match value.map(|node| (node.kind(), node)) {
-        Some((NodeKind::Str, node)) => node.text().into_iter().collect(),
+        Some((NodeKind::Str, node)) => string_value(node).map(|text| vec![text]),
         Some((NodeKind::List | NodeKind::Tuple, node)) => node
             .items()
             .iter()
             .filter(|item| item.kind() == NodeKind::Str)
-            .filter_map(AuthoredNode::text)
+            .map(string_value)
             .collect(),
-        _ => Vec::new(),
+        _ => Ok(Vec::new()),
     }
 }
 
 
@@ -3,7 +3,7 @@
 use crate::model_validation::constants::{
     CLOCK_FIELD_LENGTH, CLOCK_PART_COUNTS, CLOCK_PARTS_WITH_SECONDS, INTEGER_CURSOR,
     ISO_DATE_LENGTH, ISO_DATE_SEPARATOR_OFFSETS, LAST_SHIFTED_MONTH, MAX_HOUR, MAX_MINUTE,
-    TIMESTAMP_CURSOR, UTC_OFFSET_LENGTH,
+    MAX_YEAR, MIN_YEAR, TIMESTAMP_CURSOR, UTC_OFFSET_LENGTH,
 };
 use crate::model_validation::models::Rejected;
 use crate::types::AuthoredNode;
@@ -70,7 +70,14 @@ fn timestamp_key(text: &str) -> Result<i128, Rejected> {
         None => (0, 0),
         Some(clock) => clock_micros(clock)?,
     };
-    Ok((days * SECONDS_PER_DAY - offset_seconds) * MICROS_PER_SECOND + micros)
+    let utc_micros = (days * SECONDS_PER_DAY - offset_seconds) * MICROS_PER_SECOND + micros;
+    let day_micros = SECONDS_PER_DAY * MICROS_PER_SECOND;
+    let first_micros = days_from_civil(MIN_YEAR, 1, 1) * day_micros;
+    let end_micros = days_from_civil(MAX_YEAR + 1, 1, 1) * day_micros;
+    if utc_micros < first_micros || utc_micros >= end_micros {
+        return Err(Rejected);
+    }
+    Ok(utc_micros)
 }
 
 fn date_days(date: &str) -> Result<i128, Rejected> {
 
@@ -241,7 +241,7 @@ fn check_write_strategy<N: AuthoredNode>(
             return Err(Rejected);
         }
         reject_case_insensitive_duplicates(&excluded)?;
-        let unique_columns = string_sequence(values.unique_key.as_ref())
+        let unique_columns = string_sequence(values.unique_key.as_ref())?
             .iter()
             .map(|column| python_lower(column))
             .collect::<Result<HashSet<_>, _>>()?;
@@ -288,8 +288,8 @@ fn check_contract_columns<N: AuthoredNode>(
         .cursor
         .iter()
         .cloned()
-        .chain(string_sequence(values.unique_key.as_ref()))
-        .chain(string_sequence(values.merge_exclude_columns.as_ref()));
+        .chain(string_sequence(values.unique_key.as_ref())?)
+        .chain(string_sequence(values.merge_exclude_columns.as_ref())?);
     require_declared(named, &declared)
 }
 
 
@@ -91,9 +91,9 @@ pub(crate) fn check_snapshot<N: AuthoredNode>(
     let checked_columns = if check_columns.is_some_and(is_wildcard_only) {
         Vec::new()
     } else {
-        string_sequence(check_columns)
+        string_sequence(check_columns)?
     };
-    let named = string_sequence(unique_key)
+    let named = string_sequence(unique_key)?
         .into_iter()
         .chain(updated_at)
         .chain(observed_at)
 
@@ -205,6 +205,10 @@ pub const MAX_HOUR: i128 = 23;
 pub const MAX_MINUTE: i128 = 59;
 /// The length of a `HH:MM` UTC offset.
 pub const UTC_OFFSET_LENGTH: usize = 5;
+/// The first year Python's `datetime` represents.
+pub const MIN_YEAR: i128 = 1;
+/// The last year Python's `datetime` represents.
+pub const MAX_YEAR: i128 = 9999;
 /// The last month whose civil-day computation shifts the year back.
 pub const LAST_SHIFTED_MONTH: i128 = 2;
 /// The position of days among duration units.
 
@@ -61,6 +61,36 @@ fn given_effective_configs_when_validating_natively_then_only_python_valid_confi
             query_sql: "select 1",
             expected_accepted: false,
         },
+        AcceptTestCase {
+            description: "a start bound shifted before year 1 in UTC defers",
+            config: incremental(vec![
+                ("cursor_start", Value::Str("0001-01-01T00:00:00+01:00")),
+                ("cursor_end", Value::Str("2024-01-01")),
+            ]),
+            references: &["ref:orders"],
+            query_sql: "select 1",
+            expected_accepted: false,
+        },
+        AcceptTestCase {
+            description: "an end bound shifted past year 9999 in UTC defers",
+            config: incremental(vec![
+                ("cursor_start", Value::Str("2024-01-01")),
+                ("cursor_end", Value::Str("9999-12-31T23:59:00-01:00")),
+            ]),
+            references: &["ref:orders"],
+            query_sql: "select 1",
+            expected_accepted: false,
+        },
+        AcceptTestCase {
+            description: "bounds at the edges of years 1 and 9999 in UTC",
+            config: incremental(vec![
+                ("cursor_start", Value::Str("0001-01-01T01:00:00+01:00")),
+                ("cursor_end", Value::Str("9999-12-31T22:59:00-01:00")),
+            ]),
+            references: &["ref:orders"],
+            query_sql: "select 1",
+            expected_accepted: true,
+        },
         AcceptTestCase {
             description: "an unusual ISO timestamp defers",
             config: incremental(vec![("cursor_start", Value::Str("2024-W01-1"))]),
 
@@ -41,6 +41,7 @@
 )
 from sqlbuild.cursor_algebra.constants import GRAIN_BATCH_SIZE
 from sqlbuild.cursor_algebra.models import Duration
+from sqlbuild.errors.setting_help.main.model_header_help import model_header_help
 from sqlbuild.spec.contracts.constants import (
     CURSOR_POLICY_DISABLED,
     EFFECTIVE_BATCH_SIZE_TOKEN,
@@ -867,8 +868,12 @@ def _validate_incremental_cursor_rules(
     if (
         cursor_start is not None
         and cursor_end is not None
-        and _cursor_contract_key(value=cursor_start, cursor_type=cursor_type)
-        >= _cursor_contract_key(value=cursor_end, cursor_type=cursor_type)
+        and _cursor_contract_key(
+            value=cursor_start, cursor_type=cursor_type, key="cursor_start", model_name=model_name
+        )
+        >= _cursor_contract_key(
+            value=cursor_end, cursor_type=cursor_type, key="cursor_end", model_name=model_name
+        )
     ):
         raise CompileInputError(
             f"model '{model_name}': cursor_start must be before exclusive cursor_end"
@@ -883,15 +888,26 @@ def _validate_incremental_cursor_rules(
         raise CompileInputError(f"model '{model_name}': append_cursor_inclusive requires cursor")
 
 
-def _cursor_contract_key(*, value: object, cursor_type: str | None) -> Decimal:
+def _cursor_contract_key(
+    *, value: object, cursor_type: str | None, key: str, model_name: str
+) -> Decimal:
     if cursor_type == CursorType.INTEGER:
         return Decimal(str(value))
     parsed: datetime = datetime.fromisoformat(str(value))
     if parsed.tzinfo is None:
-        parsed = parsed.replace(tzinfo=UTC)
-    else:
-        parsed = parsed.astimezone(UTC)
-    return Decimal(str(parsed.timestamp()))
+        return Decimal(str(parsed.replace(tzinfo=UTC).timestamp()))
+    try:
+        utc_parsed: datetime = parsed.astimezone(UTC)
+    except OverflowError:
+        raise CompileInputError(
+            f"model '{model_name}': {key} value '{value}' falls outside years 1-9999 once "
+            "converted to UTC",
+            help=model_header_help(
+                purpose=f"keep {key} within years 1-9999 in UTC",
+                entry=f"{key} '{parsed.replace(tzinfo=UTC).isoformat()}'",
+            ),
+        ) from None
+    return Decimal(str(utc_parsed.timestamp()))
 
 
 def _validate_cursor_safety_overrides(
 
@@ -36,3 +36,13 @@ class ModelConfigProjectTestCase:
     description: str
     engine: str
     expected_models: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class NativeRejectionParityTestCase:
+    """A config native validation must reject so Python reports its exact outcome."""
+
+    description: str
+    values: dict[str, object]
+    expected_native_accepted: bool
+    expected_python_error: str
@@ -193,6 +193,7 @@ def _reference(kind: str, name: str) -> CompileSqlReference:
         "2024-13-01",
         "20240101",
         "2024-W01-1",
+        "0001-01-01T00:00:00+01:00",
         10,
         "15",
         "1e3",
@@ -201,8 +202,16 @@ def _reference(kind: str, name: str) -> CompileSqlReference:
         True,
         _ABSENT,
     ),
-    "cursor_end": ("2024-01-01", "2024-06-01 00:00", 5, 40, "30", "2025-01-01T00:00:00-05:00"),
-    "unique_key": ("order_id", ["order_id", "customer_id"], [], (), 5, _ABSENT),
+    "cursor_end": (
+        "2024-01-01",
+        "2024-06-01 00:00",
+        5,
+        40,
+        "30",
+        "2025-01-01T00:00:00-05:00",
+        "9999-12-31T23:59:00-01:00",
+    ),
+    "unique_key": ("order_id", ["order_id", "customer_id"], ["\udcff"], [], (), 5, _ABSENT),
     "merge_exclude_columns": (["amount"], ["ORDER_ID"], ["a", "A"], [""], "amount", _ABSENT),
     "incremental_mode": ("full", "microbatch", "batch", _ABSENT),
     "microbatch_strategy": ("rolling_window", "watermark", "hourly", _ABSENT),
@@ -247,7 +256,7 @@ def _reference(kind: str, name: str) -> CompileSqlReference:
     "initial_valid_from": ("updated_at", "observed_at", "execution_time", "now", _ABSENT),
     "snapshot_full_refresh": ("deny", "allow", "always", _ABSENT),
     "snapshot_schema_change": ("deny", "append_new_columns", "drop", _ABSENT),
-    "check_columns": (["*"], ["*", "status"], ["status"], [], ("*",), _ABSENT),
+    "check_columns": (["*"], ["*", "status"], ["status"], ["\udcff"], [], ("*",), _ABSENT),
     "invalidate_hard_deletes": (True, False, "yes", _ABSENT),
     "valid_from_column": ("valid_from", "VALID_TO", _ABSENT),
     "valid_to_column": ("valid_to", _ABSENT),
@@ -342,6 +351,35 @@ def model_validation_parity(*, requests: list[ModelValidationRequest]) -> ModelV
     )
 
 
+def validation_outcomes(*, values: dict[str, object]) -> tuple[bool, str]:
+    """Return whether native validation accepts `values` and the Python validators' error."""
+
+    request: ModelValidationRequest = ModelValidationRequest(
+        model_file=_model_file(relative_path="marts/orders_daily.sql", header_values={}),
+        config=CompileModelConfig(values=values),
+        references=(_ORDERS,),
+        declared_columns=None,
+        query_sql="SELECT 1",
+    )
+    session: NativeModelConfigSession = _session(
+        project_config=ProjectConfig(name="orders", adapter="duckdb"),
+        target_config=None,
+        effective_target_name=None,
+    )
+    return (
+        native_model_validators_accept(session=session, request=request),
+        _python_error(request),
+    )
+
+
+def _python_error(request: ModelValidationRequest) -> str:
+    try:
+        run_python_model_validators(context=_VALIDATOR_CONTEXT, request=request)
+    except Exception as error:  # noqa: BLE001 - the exact Python outcome, whatever it is
+        return f"{type(error).__name__}: {error}"
+    return "accepted"
+
+
 def _validation_request(*, rng: random.Random) -> ModelValidationRequest:
     profile, references = rng.choice(_PROFILES)
     values: dict[str, object] = dict(profile)
 
@@ -9,6 +9,7 @@
 from tests.integration.src.sqlbuild.compiler.compile.native_model_config._test_types import (
     ModelConfigBuildParityTestCase,
     ModelValidationParityTestCase,
+    NativeRejectionParityTestCase,
 )
 from tests.integration.src.sqlbuild.compiler.compile.native_model_config.helpers import (
     BUILD_ENVIRONMENT,
@@ -18,6 +19,7 @@
     generated_validation_requests,
     model_config_build_parity,
     model_validation_parity,
+    validation_outcomes,
 )
 
 
@@ -90,5 +92,87 @@ def test_given_generated_layers_when_building_config_then_native_matches_python_
     ) == ([], True, True, True), (parity.built, parity.deferred, parity.python_raised)
 
 
+@pytest.mark.parametrize(
+    "test_case",
+    [
+        NativeRejectionParityTestCase(
+            description="a start bound shifted before year 1 in UTC",
+            values={
+                "materialized": "incremental",
+                "incremental_strategy": "append",
+                "cursor": "updated_at",
+                "cursor_type": "timestamp",
+                "cursor_grain": "day",
+                "cursor_start": "0001-01-01T00:00:00+01:00",
+                "cursor_end": "2024-01-01",
+            },
+            expected_native_accepted=False,
+            expected_python_error=(
+                "CompileInputError: model 'orders_daily': cursor_start value "
+                "'0001-01-01T00:00:00+01:00' falls outside years 1-9999 once converted to UTC"
+            ),
+        ),
+        NativeRejectionParityTestCase(
+            description="an end bound shifted past year 9999 in UTC",
+            values={
+                "materialized": "incremental",
+                "incremental_strategy": "append",
+                "cursor": "updated_at",
+                "cursor_type": "timestamp",
+                "cursor_grain": "day",
+                "cursor_start": "2024-01-01",
+                "cursor_end": "9999-12-31T23:59:00-01:00",
+            },
+            expected_native_accepted=False,
+            expected_python_error=(
+                "CompileInputError: model 'orders_daily': cursor_end value "
+                "'9999-12-31T23:59:00-01:00' falls outside years 1-9999 once converted to UTC"
+            ),
+        ),
+        NativeRejectionParityTestCase(
+            description="an unreadable unique key under an enforced contract",
+            values={
+                "materialized": "incremental",
+                "incremental_strategy": "merge",
+                "unique_key": ["\udcff"],
+                "contract": "enforced",
+                "columns": {"order_id": None},
+            },
+            expected_native_accepted=False,
+            expected_python_error=(
+                "CompileInputError: model 'orders_daily': unique_key references column "
+                "'\udcff' not declared in enforced contract"
+            ),
+        ),
+        NativeRejectionParityTestCase(
+            description="an unreadable snapshot check column under an enforced contract",
+            values={
+                "materialized": "snapshot",
+                "unique_key": "order_id",
+                "snapshot_strategy": "check",
+                "check_columns": ["\udcff"],
+                "contract": "enforced",
+                "columns": {"order_id": None},
+            },
+            expected_native_accepted=False,
+            expected_python_error=(
+                "CompileInputError: model 'orders_daily': check_columns references column "
+                "'\udcff' not declared in enforced contract"
+            ),
+        ),
+    ],
+    ids=lambda case: case.description,
+)
+def test_given_python_rejected_edge_configs_when_validating_then_native_defers_to_python(
+    test_case: NativeRejectionParityTestCase,
+) -> None:
+    accepted, python_error = validation_outcomes(values=test_case.values)
+
+    assert (accepted, python_error) == (
+        test_case.expected_native_accepted,
+        test_case.expected_python_error,
+    )
+
+
 if __name__ == "__main__":
     pytest.main([__file__, "-vv"])