j-law-ruby 0.0.3

data/vendor/rust/crates/j-law-registry/src/loader.rs

@@ -0,0 +1,221 @@
+use crate::consumption_tax_loader::load_consumption_tax_params;
+use crate::schema::{BrokerageFeeRegistry, HistoryEntry};
+use crate::validator::validate;
+use j_law_core::domains::real_estate::params::{
+    BrokerageFeeParams, LowCostSpecialParams, TierParam,
+};
+use j_law_core::types::date::LegalDate;
+use j_law_core::{InputError, JLawError, RegistryError};
+
+/// `brokerage_fee.json` をロードして `target_date` に対応するパラメータを返す。
+///
+/// # 法的根拠
+/// 宅地建物取引業法 第46条第1項
+///
+/// # エラー
+/// - `target_date` がどの有効期間にも該当しない → `InputError::DateOutOfRange`
+/// - Registry データの不整合 → `RegistryError` でパニック（起動時バリデーション）
+pub fn load_brokerage_fee_params(target_date: LegalDate) -> Result<BrokerageFeeParams, JLawError> {
+    target_date.validate()?;
+
+    let json_str = include_str!("../data/real_estate/brokerage_fee.json");
+
+    let registry: BrokerageFeeRegistry =
+        serde_json::from_str(json_str).map_err(|e| RegistryError::ParseError {
+            path: "real_estate/brokerage_fee.json".into(),
+            cause: e.to_string(),
+        })?;
+    validate(&registry)?;
+
+    let date_str = target_date.to_date_str();
+
+    let entry = find_entry(&registry, &date_str).ok_or_else(|| InputError::DateOutOfRange {
+        date: date_str.clone(),
+    })?;
+
+    to_params(entry, target_date)
+}
+
+/// `date_str` ("YYYY-MM-DD") に対応する履歴エントリを返す。
+fn find_entry<'a>(registry: &'a BrokerageFeeRegistry, date_str: &str) -> Option<&'a HistoryEntry> {
+    registry.history.iter().find(|entry| {
+        let from_ok = entry.effective_from.as_str() <= date_str;
+        let until_ok = match &entry.effective_until {
+            Some(until) => date_str <= until.as_str(),
+            None => true,
+        };
+        from_ok && until_ok
+    })
+}
+
+fn to_params(
+    entry: &HistoryEntry,
+    target_date: LegalDate,
+) -> Result<BrokerageFeeParams, JLawError> {
+    let tiers = entry
+        .params
+        .tiers
+        .iter()
+        .map(|t| TierParam {
+            label: t.label.clone(),
+            price_from: t.price_from,
+            price_to_inclusive: t.price_to_inclusive,
+            rate_numer: t.rate.numer,
+            rate_denom: t.rate.denom,
+        })
+        .collect();
+
+    let low_cost_special = entry
+        .params
+        .low_cost_special
+        .as_ref()
+        .map(|s| LowCostSpecialParams {
+            price_ceiling_inclusive: s.price_ceiling_inclusive,
+            fee_ceiling_exclusive_tax: s.fee_ceiling_exclusive_tax,
+            seller_only: s.seller_only,
+        });
+
+    // 消費税ドメインに委譲（不動産仲介報酬には軽減税率は適用されない）
+    let consumption_tax = load_consumption_tax_params(target_date)?;
+
+    Ok(BrokerageFeeParams {
+        tiers,
+        consumption_tax,
+        low_cost_special,
+    })
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)] // テストコードでは unwrap 使用を許可
+mod tests {
+    use super::*;
+
+    #[test]
+    fn load_2024_active_params() {
+        let params = load_brokerage_fee_params(LegalDate::new(2024, 8, 1)).unwrap();
+        assert_eq!(params.tiers.len(), 3);
+        assert_eq!(params.consumption_tax.standard_rate.numer, 10);
+        assert_eq!(params.consumption_tax.standard_rate.denom, 100);
+        assert!(params.low_cost_special.is_some());
+        let special = params.low_cost_special.unwrap();
+        assert_eq!(special.price_ceiling_inclusive, 8_000_000);
+        assert_eq!(special.fee_ceiling_exclusive_tax, 330_000);
+    }
+
+    #[test]
+    fn load_2019_superseded_params() {
+        let params = load_brokerage_fee_params(LegalDate::new(2019, 12, 1)).unwrap();
+        assert_eq!(params.tiers.len(), 3);
+        // 2019年告示は低廉特例あり（売主限定・400万円以下）
+        let special = params.low_cost_special.as_ref().unwrap();
+        assert_eq!(special.price_ceiling_inclusive, 4_000_000);
+        assert_eq!(special.fee_ceiling_exclusive_tax, 180_000);
+        assert!(special.seller_only);
+        // 2019年10月以降は消費税10%（消費税ドメインから取得）
+        assert_eq!(params.consumption_tax.standard_rate.numer, 10);
+    }
+
+    #[test]
+    fn load_2018_params() {
+        let params = load_brokerage_fee_params(LegalDate::new(2018, 6, 1)).unwrap();
+        assert_eq!(params.tiers.len(), 3);
+        let special = params.low_cost_special.as_ref().unwrap();
+        assert_eq!(special.price_ceiling_inclusive, 4_000_000);
+        assert_eq!(special.fee_ceiling_exclusive_tax, 180_000);
+        assert!(special.seller_only);
+        // 2018年は消費税8%（消費税ドメインから取得）
+        assert_eq!(params.consumption_tax.standard_rate.numer, 8);
+    }
+
+    #[test]
+    fn boundary_2024_07_01_uses_new_params() {
+        let params = load_brokerage_fee_params(LegalDate::new(2024, 7, 1)).unwrap();
+        let special = params.low_cost_special.as_ref().unwrap();
+        assert_eq!(special.price_ceiling_inclusive, 8_000_000);
+        assert_eq!(special.fee_ceiling_exclusive_tax, 330_000);
+        assert!(!special.seller_only);
+    }
+
+    #[test]
+    fn boundary_2024_06_30_uses_old_params() {
+        // 2024-06-30 は旧告示（売主限定・400万円以下の低廉特例）
+        let params = load_brokerage_fee_params(LegalDate::new(2024, 6, 30)).unwrap();
+        let special = params.low_cost_special.as_ref().unwrap();
+        assert_eq!(special.price_ceiling_inclusive, 4_000_000);
+        assert_eq!(special.fee_ceiling_exclusive_tax, 180_000);
+        assert!(special.seller_only);
+    }
+
+    #[test]
+    fn boundary_2019_10_01_uses_10pct_tax() {
+        // 2019-10-01 から消費税10%（消費税ドメインから取得）
+        let params = load_brokerage_fee_params(LegalDate::new(2019, 10, 1)).unwrap();
+        assert_eq!(params.consumption_tax.standard_rate.numer, 10);
+        // 2018-2024-06-30 エントリ内なので低廉特例は売主限定・400万円以下
+        let special = params.low_cost_special.as_ref().unwrap();
+        assert_eq!(special.price_ceiling_inclusive, 4_000_000);
+        assert!(special.seller_only);
+    }
+
+    #[test]
+    fn boundary_2019_09_30_uses_8pct_tax() {
+        // 2019-09-30 まで消費税8%（消費税ドメインから取得）
+        let params = load_brokerage_fee_params(LegalDate::new(2019, 9, 30)).unwrap();
+        assert_eq!(params.consumption_tax.standard_rate.numer, 8);
+    }
+
+    // ─── 2018年以前（全期間対応）─────────────────────────────────────────────
+
+    #[test]
+    fn load_2017_pre_special_params() {
+        // 2017年12月31日（特例導入前）: 低廉特例なし・基本ティア計算のみ
+        let params = load_brokerage_fee_params(LegalDate::new(2017, 12, 31)).unwrap();
+        assert_eq!(params.tiers.len(), 3);
+        assert!(params.low_cost_special.is_none());
+        // 消費税は消費税ドメインから取得（2017年は8%）
+        assert_eq!(params.consumption_tax.standard_rate.numer, 8);
+    }
+
+    #[test]
+    fn boundary_2018_01_01_activates_special() {
+        // 2018-01-01 から低廉特例が有効になる
+        let params = load_brokerage_fee_params(LegalDate::new(2018, 1, 1)).unwrap();
+        assert!(params.low_cost_special.is_some());
+    }
+
+    #[test]
+    fn boundary_2017_12_31_no_special() {
+        // 2017-12-31 では低廉特例なし
+        let params = load_brokerage_fee_params(LegalDate::new(2017, 12, 31)).unwrap();
+        assert!(params.low_cost_special.is_none());
+    }
+
+    #[test]
+    fn load_1990_params() {
+        // 1990年（消費税3%時代）でも計算可能
+        let params = load_brokerage_fee_params(LegalDate::new(1990, 1, 1)).unwrap();
+        assert_eq!(params.tiers.len(), 3);
+        assert!(params.low_cost_special.is_none());
+        // 1990年は消費税3%（消費税ドメインから取得）
+        assert_eq!(params.consumption_tax.standard_rate.numer, 3);
+    }
+
+    #[test]
+    fn registry_validation_passes() {
+        let json_str = include_str!("../data/real_estate/brokerage_fee.json");
+        let registry: BrokerageFeeRegistry = serde_json::from_str(json_str).unwrap();
+        validate(&registry).unwrap();
+    }
+
+    #[test]
+    fn invalid_month_returns_error() {
+        let result = load_brokerage_fee_params(LegalDate::new(2024, 13, 1));
+        assert!(matches!(result, Err(JLawError::Input(_))));
+    }
+
+    #[test]
+    fn invalid_day_returns_error() {
+        let result = load_brokerage_fee_params(LegalDate::new(2024, 2, 30));
+        assert!(matches!(result, Err(JLawError::Input(_))));
+    }
+}

data/vendor/rust/crates/j-law-registry/src/schema.rs

@@ -0,0 +1,73 @@
+use serde::Deserialize;
+
+/// JSON の分数表現 `{ "numer": N, "denom": N }`。
+#[derive(Debug, Clone, Deserialize)]
+pub struct Fraction {
+    pub numer: u64,
+    pub denom: u64,
+}
+
+/// 1ティアの定義。
+#[derive(Debug, Clone, Deserialize)]
+pub struct TierParam {
+    pub label: String,
+    pub price_from: u64,
+    /// `null` は「上限なし」を意味する。
+    pub price_to_inclusive: Option<u64>,
+    pub rate: Fraction,
+}
+
+/// 低廉な空き家特例パラメータ（2018年1月施行・2024年7月改正）。
+#[derive(Debug, Clone, Deserialize)]
+pub struct LowCostSpecialParam {
+    /// 特例が適用される売買価格の上限（以下）。
+    pub price_ceiling_inclusive: u64,
+    /// 税抜き報酬額の上限（最低保証額として機能）。
+    pub fee_ceiling_exclusive_tax: u64,
+    /// `true` の場合、売主側の取引にのみ特例が適用される。
+    ///
+    /// 2018年1月1日〜2024年6月30日の特例は売主のみ対象（平成29年国土交通省告示第98号）。
+    /// `false` の場合、売主・買主双方に適用される（2024年7月1日施行以降）。
+    pub seller_only: bool,
+}
+
+/// 1世代の計算パラメータ群。
+#[derive(Debug, Clone, Deserialize)]
+pub struct ParamsEntry {
+    pub tiers: Vec<TierParam>,
+    pub low_cost_special: Option<LowCostSpecialParam>,
+}
+
+/// 法令引用情報。
+#[derive(Debug, Clone, Deserialize)]
+#[allow(dead_code)]
+pub struct CitationEntry {
+    pub law_id: String,
+    pub law_name: String,
+    pub article: u16,
+    pub paragraph: Option<u16>,
+    pub ministry: String,
+}
+
+/// 1世代の履歴エントリ。
+#[derive(Debug, Clone, Deserialize)]
+pub struct HistoryEntry {
+    /// 施行日 `"YYYY-MM-DD"`。
+    pub effective_from: String,
+    /// 廃止日 `"YYYY-MM-DD"`。現行版は `null`。
+    pub effective_until: Option<String>,
+    /// `"active"` または `"superseded"`。
+    #[allow(dead_code)]
+    pub status: String,
+    #[allow(dead_code)]
+    pub citation: CitationEntry,
+    pub params: ParamsEntry,
+}
+
+/// `brokerage_fee.json` のルートスキーマ。
+#[derive(Debug, Clone, Deserialize)]
+pub struct BrokerageFeeRegistry {
+    #[allow(dead_code)]
+    pub domain: String,
+    pub history: Vec<HistoryEntry>,
+}

data/vendor/rust/crates/j-law-registry/src/stamp_tax_loader.rs

@@ -0,0 +1,374 @@
+use std::collections::BTreeMap;
+use std::str::FromStr;
+
+use crate::stamp_tax_schema::{
+    StampTaxBracketEntry, StampTaxDocumentParamsEntry, StampTaxHistoryEntry, StampTaxRegistry,
+    StampTaxSpecialRuleEntry,
+};
+use j_law_core::domains::stamp_tax::context::{StampTaxDocumentCode, StampTaxFlag};
+use j_law_core::domains::stamp_tax::params::{
+    StampTaxAmountUsage, StampTaxBracket, StampTaxChargeMode, StampTaxCitation,
+    StampTaxDocumentParams, StampTaxParams, StampTaxSpecialRule,
+};
+use j_law_core::types::date::LegalDate;
+use j_law_core::{InputError, JLawError, RegistryError};
+
+const PATH: &str = "stamp_tax/stamp_tax.json";
+
+/// `stamp_tax.json` をロードして `target_date` に対応するパラメータを返す。
+pub fn load_stamp_tax_params(target_date: LegalDate) -> Result<StampTaxParams, JLawError> {
+    target_date.validate()?;
+
+    let json_str = include_str!("../data/stamp_tax/stamp_tax.json");
+
+    let registry: StampTaxRegistry =
+        serde_json::from_str(json_str).map_err(|e| RegistryError::ParseError {
+            path: PATH.into(),
+            cause: e.to_string(),
+        })?;
+    validate_registry(&registry)?;
+
+    let date_str = target_date.to_date_str();
+
+    let entry = find_entry(&registry, &date_str).ok_or_else(|| InputError::DateOutOfRange {
+        date: date_str.clone(),
+    })?;
+
+    to_params(entry)
+}
+
+/// `StampTaxRegistry` の整合性を検証する。
+///
+/// # 検証内容
+/// - 適用期間の重複（Overlap）
+/// - 適用期間の空白（Gap）
+fn validate_registry(registry: &StampTaxRegistry) -> Result<(), RegistryError> {
+    let domain = &registry.domain;
+
+    // 期間の重複・ギャップチェック
+    let mut sorted = registry.history.clone();
+    sorted.sort_by(|a, b| a.effective_from.cmp(&b.effective_from));
+
+    for [current, next] in sorted.array_windows::<2>() {
+        let current_until = match &current.effective_until {
+            Some(d) => d.clone(),
+            None => {
+                return Err(RegistryError::PeriodOverlap {
+                    domain: domain.clone(),
+                    from: next.effective_from.clone(),
+                    until: "open-ended".into(),
+                });
+            }
+        };
+
+        if current_until >= next.effective_from {
+            return Err(RegistryError::PeriodOverlap {
+                domain: domain.clone(),
+                from: next.effective_from.clone(),
+                until: current_until.clone(),
+            });
+        }
+
+        let until_date = LegalDate::from_date_str(&current_until).ok_or_else(|| {
+            RegistryError::InvalidDateFormat {
+                domain: domain.clone(),
+                value: current_until.clone(),
+            }
+        })?;
+        let expected_next_from = until_date.next_day().to_date_str();
+        if expected_next_from != next.effective_from {
+            return Err(RegistryError::PeriodGap {
+                domain: domain.clone(),
+                end: current_until,
+                next_start: next.effective_from.clone(),
+            });
+        }
+    }
+
+    Ok(())
+}
+
+fn find_entry<'a>(
+    registry: &'a StampTaxRegistry,
+    date_str: &str,
+) -> Option<&'a StampTaxHistoryEntry> {
+    registry.history.iter().find(|entry| {
+        let from_ok = entry.effective_from.as_str() <= date_str;
+        let until_ok = match &entry.effective_until {
+            Some(until) => date_str <= until.as_str(),
+            None => true,
+        };
+        from_ok && until_ok
+    })
+}
+
+fn to_params(entry: &StampTaxHistoryEntry) -> Result<StampTaxParams, JLawError> {
+    let mut documents = BTreeMap::new();
+
+    for (key, value) in &entry.params.documents {
+        let document_code = StampTaxDocumentCode::from_str(key).map_err(registry_parse_error)?;
+        let document_params = to_document_params(document_code, value)?;
+        documents.insert(document_code, document_params);
+    }
+
+    if documents.is_empty() {
+        return Err(registry_parse_error(InputError::InvalidStampTaxInput {
+            field: "documents".into(),
+            reason: "印紙税文書コードが1件も定義されていません".into(),
+        }));
+    }
+
+    Ok(StampTaxParams { documents })
+}
+
+fn to_document_params(
+    code: StampTaxDocumentCode,
+    entry: &StampTaxDocumentParamsEntry,
+) -> Result<StampTaxDocumentParams, JLawError> {
+    let charge_mode =
+        StampTaxChargeMode::from_str(&entry.charge_mode).map_err(registry_parse_error)?;
+    let amount_usage =
+        StampTaxAmountUsage::from_str(&entry.amount_usage).map_err(registry_parse_error)?;
+    let brackets = to_brackets(&entry.brackets)?;
+    validate_brackets(code, &brackets)?;
+
+    let special_rules = entry
+        .special_rules
+        .iter()
+        .map(|rule| to_special_rule(code, rule))
+        .collect::<Result<Vec<_>, _>>()?;
+
+    match charge_mode {
+        StampTaxChargeMode::AmountBrackets => {
+            if brackets.is_empty() {
+                return Err(registry_parse_error(InputError::InvalidStampTaxInput {
+                    field: code.to_string(),
+                    reason: "amount_brackets には brackets が必要です".into(),
+                }));
+            }
+            if entry.base_tax_amount.is_some() {
+                return Err(registry_parse_error(InputError::InvalidStampTaxInput {
+                    field: code.to_string(),
+                    reason: "amount_brackets に base_tax_amount は指定できません".into(),
+                }));
+            }
+        }
+        StampTaxChargeMode::FixedPerDocument | StampTaxChargeMode::FixedPerYear => {
+            if entry.base_tax_amount.is_none() {
+                return Err(registry_parse_error(InputError::InvalidStampTaxInput {
+                    field: code.to_string(),
+                    reason: "固定税額文書には base_tax_amount が必要です".into(),
+                }));
+            }
+            if !brackets.is_empty() {
+                return Err(registry_parse_error(InputError::InvalidStampTaxInput {
+                    field: code.to_string(),
+                    reason: "固定税額文書の base brackets は空である必要があります".into(),
+                }));
+            }
+        }
+    }
+
+    if matches!(amount_usage, StampTaxAmountUsage::Unsupported)
+        && entry.no_amount_tax_amount.is_some()
+    {
+        return Err(registry_parse_error(InputError::InvalidStampTaxInput {
+            field: code.to_string(),
+            reason: "amount_usage=unsupported では no_amount_tax_amount を指定できません".into(),
+        }));
+    }
+
+    Ok(StampTaxDocumentParams {
+        code,
+        label: entry.label.clone(),
+        citation: StampTaxCitation {
+            law_name: entry.citation.law_name.clone(),
+            article: entry.citation.article.clone(),
+        },
+        charge_mode,
+        amount_usage,
+        base_rule_label: entry.base_rule_label.clone(),
+        base_tax_amount: entry.base_tax_amount,
+        brackets,
+        no_amount_tax_amount: entry.no_amount_tax_amount,
+        no_amount_rule_label: entry.no_amount_rule_label.clone(),
+        special_rules,
+    })
+}
+
+fn to_special_rule(
+    document_code: StampTaxDocumentCode,
+    entry: &StampTaxSpecialRuleEntry,
+) -> Result<StampTaxSpecialRule, JLawError> {
+    let required_flags = entry
+        .required_flags
+        .iter()
+        .map(|flag| StampTaxFlag::from_str(flag).map_err(registry_parse_error))
+        .collect::<Result<Vec<_>, _>>()?;
+
+    for flag in &required_flags {
+        if !flag.allowed_document_codes().contains(&document_code) {
+            return Err(registry_parse_error(InputError::InvalidStampTaxInput {
+                field: document_code.to_string(),
+                reason: format!(
+                    "特例ルール {} で許可されない flag {} を参照しています",
+                    entry.code, flag
+                ),
+            }));
+        }
+    }
+
+    let brackets = to_brackets(&entry.brackets)?;
+    if !brackets.is_empty() {
+        validate_brackets(document_code, &brackets)?;
+    }
+
+    Ok(StampTaxSpecialRule {
+        code: entry.code.clone(),
+        label: entry.label.clone(),
+        priority: entry.priority,
+        effective_from: entry.effective_from.clone(),
+        effective_until: entry.effective_until.clone(),
+        required_flags,
+        tax_amount: entry.tax_amount,
+        rule_label: entry.rule_label.clone(),
+        brackets,
+        no_amount_tax_amount: entry.no_amount_tax_amount,
+        no_amount_rule_label: entry.no_amount_rule_label.clone(),
+    })
+}
+
+fn to_brackets(entries: &[StampTaxBracketEntry]) -> Result<Vec<StampTaxBracket>, JLawError> {
+    Ok(entries
+        .iter()
+        .map(|entry| StampTaxBracket {
+            label: entry.label.clone(),
+            amount_from: entry.amount_from,
+            amount_to_inclusive: entry.amount_to_inclusive,
+            tax_amount: entry.tax_amount,
+        })
+        .collect())
+}
+
+fn validate_brackets(
+    document_code: StampTaxDocumentCode,
+    brackets: &[StampTaxBracket],
+) -> Result<(), JLawError> {
+    let mut previous_to: Option<u64> = None;
+    for bracket in brackets {
+        if let Some(previous) = previous_to {
+            if bracket.amount_from <= previous {
+                return Err(registry_parse_error(InputError::InvalidStampTaxInput {
+                    field: document_code.to_string(),
+                    reason: format!(
+                        "ブラケットが重複または未整列です: {} starts at {} after {}",
+                        bracket.label, bracket.amount_from, previous
+                    ),
+                }));
+            }
+            if bracket.amount_from != previous.saturating_add(1) {
+                return Err(registry_parse_error(InputError::InvalidStampTaxInput {
+                    field: document_code.to_string(),
+                    reason: format!(
+                        "ブラケットに空白があります: previous_to={}, next_from={}",
+                        previous, bracket.amount_from
+                    ),
+                }));
+            }
+        }
+        previous_to = bracket.amount_to_inclusive;
+    }
+    Ok(())
+}
+
+fn registry_parse_error(err: impl Into<JLawError>) -> JLawError {
+    match err.into() {
+        JLawError::Input(inner) => RegistryError::ParseError {
+            path: PATH.into(),
+            cause: inner.to_string(),
+        }
+        .into(),
+        other => other,
+    }
+}
+
+#[cfg(test)]
+#[allow(clippy::disallowed_methods)]
+mod tests {
+    use super::*;
+    use crate::stamp_tax_schema::{StampTaxHistoryEntry, StampTaxParamsEntry, StampTaxRegistry};
+
+    fn make_registry(entries: Vec<StampTaxHistoryEntry>) -> StampTaxRegistry {
+        StampTaxRegistry {
+            domain: "stamp_tax".into(),
+            history: entries,
+        }
+    }
+
+    fn make_entry(from: &str, until: Option<&str>) -> StampTaxHistoryEntry {
+        StampTaxHistoryEntry {
+            effective_from: from.into(),
+            effective_until: until.map(|s| s.into()),
+            params: StampTaxParamsEntry {
+                documents: BTreeMap::new(),
+            },
+        }
+    }
+
+    #[test]
+    fn registry_validation_passes_for_current_data() {
+        let json_str = include_str!("../data/stamp_tax/stamp_tax.json");
+        let registry: StampTaxRegistry = serde_json::from_str(json_str).unwrap();
+        assert!(validate_registry(&registry).is_ok());
+    }
+
+    #[test]
+    fn registry_validation_detects_overlap() {
+        let reg = make_registry(vec![
+            make_entry("2014-04-01", Some("2020-01-15")),
+            make_entry("2020-01-01", None),
+        ]);
+        let err = validate_registry(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::PeriodOverlap { .. }));
+    }
+
+    #[test]
+    fn registry_validation_detects_gap() {
+        let reg = make_registry(vec![
+            make_entry("2014-04-01", Some("2019-12-31")),
+            make_entry("2020-01-03", None),
+        ]);
+        let err = validate_registry(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::PeriodGap { .. }));
+    }
+
+    #[test]
+    fn registry_validation_detects_open_ended_before_next() {
+        let reg = make_registry(vec![
+            make_entry("2014-04-01", None),
+            make_entry("2020-01-01", None),
+        ]);
+        let err = validate_registry(&reg).unwrap_err();
+        assert!(matches!(err, RegistryError::PeriodOverlap { .. }));
+    }
+
+    #[test]
+    fn load_2024_params() {
+        let params = load_stamp_tax_params(LegalDate::new(2024, 1, 1)).unwrap();
+        assert!(params
+            .documents
+            .contains_key(&StampTaxDocumentCode::Article1RealEstateTransfer));
+        assert!(params
+            .documents
+            .contains_key(&StampTaxDocumentCode::Article20SealBook));
+    }
+
+    #[test]
+    fn date_out_of_range_returns_error() {
+        let result = load_stamp_tax_params(LegalDate::new(2014, 3, 31));
+        assert!(matches!(
+            result,
+            Err(JLawError::Input(InputError::DateOutOfRange { .. }))
+        ));
+    }
+}