blun-king-cli 9.1.587 → 9.1.588

package/standard-skills/translate-native/integrations/website_localization_native_reference_store.py

@@ -0,0 +1,420 @@
+#!/usr/bin/env python3
+"""Durable, fail-closed storage for qualified-native benchmark references.
+
+The trusted host owns the SQLite connection, receipt verifier, evidence
+authority, and external artifact loader. The first fully verified reference is
+bound to one route, benchmark policy, and suite job. Every read reverifies both
+the artifact attestation and the qualified-human receipt before returning text.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import importlib.util
+import json
+import math
+import re
+import sqlite3
+import sys
+import time
+from contextlib import contextmanager
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any, Callable, Iterator
+
+
+STORE_SCHEMA = "blun.website-localization-native-reference-store.v1"
+MAX_ARTIFACT_BYTES = 4 * 1024 * 1024
+ERROR_CODE = re.compile(r"^[a-z][a-z0-9_.-]{0,127}$")
+STORE_COLUMNS = (
+    "reference_id", "route_id", "policy_sha256", "job_sha256",
+    "artifact_json", "artifact_sha256", "created_at",
+)
+
+
+def _load_module(name: str, path: Path):
+    spec = importlib.util.spec_from_file_location(name, path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"cannot load native-reference dependency: {path.name}")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+_ROOT = Path(__file__).resolve().parents[1]
+_BENCHMARK = _load_module(
+    "blun_website_localization_native_reference_benchmark",
+    _ROOT / "integrations" / "website_localization_benchmark.py",
+)
+_WORKER = _BENCHMARK._WORKER
+_SUITE = _BENCHMARK._SUITE
+
+
+class NativeReferenceStoreFailed(RuntimeError):
+    """Content-free failure understood by durable benchmark orchestration."""
+
+    benchmark_campaign_dependency_failure = True
+
+    def __init__(self, code: str, *, retryable: bool):
+        if not isinstance(code, str) or ERROR_CODE.fullmatch(code) is None:
+            raise ValueError("native-reference error code is invalid")
+        if not isinstance(retryable, bool):
+            raise ValueError("native-reference retryability must be boolean")
+        super().__init__(code)
+        self.code = code
+        self.retryable = retryable
+
+
+def _pairs(items):
+    result = {}
+    for key, value in items:
+        if key in result:
+            raise ValueError("duplicate JSON key")
+        result[key] = value
+    return result
+
+
+def _constant(value):
+    raise ValueError("non-finite JSON number")
+
+
+def _json_bytes(value: Any, code: str) -> bytes:
+    try:
+        encoded = json.dumps(
+            value,
+            ensure_ascii=False,
+            allow_nan=False,
+            sort_keys=True,
+            separators=(",", ":"),
+        ).encode("utf-8")
+    except (TypeError, ValueError, UnicodeEncodeError, RecursionError):
+        raise NativeReferenceStoreFailed(code, retryable=False) from None
+    if not encoded or len(encoded) > MAX_ARTIFACT_BYTES:
+        raise NativeReferenceStoreFailed(code, retryable=False)
+    return encoded
+
+
+def _parse_json(value: Any) -> Any:
+    if not isinstance(value, str) or not value:
+        raise NativeReferenceStoreFailed(
+            "native_reference.store.state_invalid", retryable=False,
+        )
+    try:
+        encoded = value.encode("utf-8")
+        if len(encoded) > MAX_ARTIFACT_BYTES:
+            raise ValueError("stored JSON is too large")
+        return json.loads(
+            value, object_pairs_hook=_pairs, parse_constant=_constant,
+        )
+    except (UnicodeEncodeError, ValueError, RecursionError):
+        raise NativeReferenceStoreFailed(
+            "native_reference.store.state_invalid", retryable=False,
+        ) from None
+
+
+def _hash_bytes(value: bytes) -> str:
+    return hashlib.sha256(value).hexdigest()
+
+
+def _hash_text(value: str) -> str:
+    return _hash_bytes(value.encode("utf-8"))
+
+
+def _timestamp(value: Any = None) -> float:
+    value = time.time() if value is None else value
+    if (
+        isinstance(value, bool)
+        or not isinstance(value, (int, float))
+        or not math.isfinite(float(value))
+        or float(value) < 0
+    ):
+        raise NativeReferenceStoreFailed(
+            "native_reference.store.time_invalid", retryable=False,
+        )
+    return float(value)
+
+
+def _identifier(value: Any, code: str) -> str:
+    if not isinstance(value, str) or _BENCHMARK.IDENTIFIER.fullmatch(value) is None:
+        raise NativeReferenceStoreFailed(code, retryable=False)
+    return value
+
+
+def _binding(
+    job_payload: Any,
+    policy: Any,
+    route_id: Any,
+) -> tuple[tuple[str, str, str, str], dict[str, Any], Any]:
+    route = _identifier(
+        route_id, "native_reference.store.route_invalid",
+    )
+    try:
+        validated_policy = _BENCHMARK._validate_policy(policy)
+        job = _WORKER._validated_job(job_payload)
+        _BENCHMARK._validate_candidate_job_binding(job, validated_policy)
+        if job["target"]["locale"] not in validated_policy.required_locales:
+            raise ValueError("locale is not required")
+        _SUITE.case_for_job(job)
+    except Exception:
+        raise NativeReferenceStoreFailed(
+            "native_reference.store.binding_invalid", retryable=False,
+        ) from None
+    policy_sha256 = _hash_bytes(_json_bytes(
+        asdict(validated_policy), "native_reference.store.binding_invalid",
+    ))
+    job_sha256 = _hash_bytes(_json_bytes(
+        job, "native_reference.store.binding_invalid",
+    ))
+    reference_id = "native-reference:" + _hash_bytes(_json_bytes(
+        {
+            "schema": STORE_SCHEMA,
+            "route_id": route,
+            "policy_sha256": policy_sha256,
+            "job_sha256": job_sha256,
+        },
+        "native_reference.store.binding_invalid",
+    ))
+    return (
+        (reference_id, route, policy_sha256, job_sha256),
+        job,
+        validated_policy,
+    )
+
+
+def _validated_artifact(
+    artifact: Any,
+    job: dict[str, Any],
+    policy: Any,
+    native_reference_verifier: Any,
+    evidence_authority: Any,
+) -> dict[str, Any]:
+    try:
+        return _BENCHMARK._validate_native_reference(
+            job,
+            artifact,
+            policy,
+            native_reference_verifier,
+            evidence_authority,
+        )
+    except _BENCHMARK.BenchmarkBlocked as error:
+        retryable = error.code in {
+            "benchmark.attestation.verify_failed",
+            "benchmark.native_reference.verify_failed",
+        }
+        code = (
+            "native_reference.store.verification_unavailable"
+            if retryable else "native_reference.store.artifact_invalid"
+        )
+        raise NativeReferenceStoreFailed(code, retryable=retryable) from None
+    except Exception:
+        raise NativeReferenceStoreFailed(
+            "native_reference.store.artifact_invalid", retryable=False,
+        ) from None
+
+
+@contextmanager
+def _transaction(connection: sqlite3.Connection) -> Iterator[None]:
+    if connection.in_transaction:
+        raise NativeReferenceStoreFailed(
+            "native_reference.store.external_transaction", retryable=False,
+        )
+    try:
+        connection.execute("BEGIN IMMEDIATE")
+        yield
+    except Exception:
+        connection.rollback()
+        raise
+    else:
+        connection.commit()
+
+
+class NativeReferenceArtifactStore:
+    """Persist the first exact verified native reference for one bound route."""
+
+    def __init__(self, connection: sqlite3.Connection):
+        if not isinstance(connection, sqlite3.Connection):
+            raise NativeReferenceStoreFailed(
+                "native_reference.store.connection_invalid", retryable=False,
+            )
+        self.connection = connection
+        self.connection.row_factory = sqlite3.Row
+        self.connection.execute("PRAGMA busy_timeout = 5000")
+        with _transaction(self.connection):
+            self.connection.execute("""
+                CREATE TABLE IF NOT EXISTS benchmark_native_references (
+                    reference_id TEXT PRIMARY KEY,
+                    route_id TEXT NOT NULL,
+                    policy_sha256 TEXT NOT NULL,
+                    job_sha256 TEXT NOT NULL,
+                    artifact_json TEXT NOT NULL,
+                    artifact_sha256 TEXT NOT NULL,
+                    created_at REAL NOT NULL,
+                    UNIQUE(route_id, policy_sha256, job_sha256)
+                )
+            """)
+        columns = tuple(
+            row[1] for row in self.connection.execute(
+                "PRAGMA table_info(benchmark_native_references)"
+            ).fetchall()
+        )
+        if columns != STORE_COLUMNS:
+            raise NativeReferenceStoreFailed(
+                "native_reference.store.schema_unsupported", retryable=False,
+            )
+
+    @staticmethod
+    def identity(
+        job_payload: Any, policy: Any, route_id: Any,
+    ) -> tuple[str, str, str, str]:
+        return _binding(job_payload, policy, route_id)[0]
+
+    def load(
+        self,
+        job_payload: Any,
+        policy: Any,
+        route_id: Any,
+        *,
+        native_reference_verifier: Any,
+        evidence_authority: Any,
+    ) -> dict[str, Any] | None:
+        identity, job, validated_policy = _binding(
+            job_payload, policy, route_id,
+        )
+        row = self.connection.execute("""
+            SELECT * FROM benchmark_native_references
+            WHERE reference_id = ?
+        """, (identity[0],)).fetchone()
+        if row is None:
+            return None
+        if (
+            tuple(row.keys()) != STORE_COLUMNS
+            or tuple(row[name] for name in STORE_COLUMNS[:4]) != identity
+            or isinstance(row["created_at"], bool)
+            or not isinstance(row["created_at"], (int, float))
+            or not math.isfinite(float(row["created_at"]))
+            or float(row["created_at"]) < 0
+            or not isinstance(row["artifact_json"], str)
+            or row["artifact_sha256"] != _hash_text(row["artifact_json"])
+        ):
+            raise NativeReferenceStoreFailed(
+                "native_reference.store.state_invalid", retryable=False,
+            )
+        artifact = _parse_json(row["artifact_json"])
+        return _validated_artifact(
+            artifact,
+            job,
+            validated_policy,
+            native_reference_verifier,
+            evidence_authority,
+        )
+
+    def save(
+        self,
+        job_payload: Any,
+        policy: Any,
+        route_id: Any,
+        artifact: Any,
+        *,
+        native_reference_verifier: Any,
+        evidence_authority: Any,
+        now: Any = None,
+    ) -> dict[str, Any]:
+        identity, job, validated_policy = _binding(
+            job_payload, policy, route_id,
+        )
+        verified = _validated_artifact(
+            artifact,
+            job,
+            validated_policy,
+            native_reference_verifier,
+            evidence_authority,
+        )
+        artifact_json = _json_bytes(
+            verified, "native_reference.store.artifact_invalid",
+        ).decode("utf-8")
+        values = identity + (
+            artifact_json,
+            _hash_text(artifact_json),
+            _timestamp(now),
+        )
+        with _transaction(self.connection):
+            self.connection.execute("""
+                INSERT OR IGNORE INTO benchmark_native_references
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+            """, values)
+        stored = self.load(
+            job_payload,
+            policy,
+            route_id,
+            native_reference_verifier=native_reference_verifier,
+            evidence_authority=evidence_authority,
+        )
+        if stored != verified:
+            raise NativeReferenceStoreFailed(
+                "native_reference.store.conflict", retryable=False,
+            )
+        return stored
+
+
+def resolve_native_reference_artifact(
+    store: NativeReferenceArtifactStore,
+    job_payload: Any,
+    policy: Any,
+    route_id: Any,
+    load_artifact: Callable[[], Any],
+    *,
+    native_reference_verifier: Any,
+    evidence_authority: Any,
+    operation_guard: Callable[[], Any] | None = None,
+    now: Any = None,
+) -> dict[str, Any]:
+    """Reuse verified state or load and persist one exact external artifact."""
+    if any(not callable(getattr(store, name, None)) for name in ("load", "save")):
+        raise TypeError("store must provide load and save")
+    if not callable(load_artifact):
+        raise TypeError("load_artifact must be callable")
+    if operation_guard is not None and not callable(operation_guard):
+        raise TypeError("operation_guard must be callable")
+
+    def guard_operation() -> None:
+        if operation_guard is None:
+            return
+        try:
+            operation_guard()
+        except Exception:
+            raise NativeReferenceStoreFailed(
+                "native_reference.operation_guard_failed", retryable=True,
+            ) from None
+
+    # A cache hit still invokes the configured receipt verifier. Guard it just
+    # like an external vault lookup rather than assuming verification is local.
+    guard_operation()
+    cached = store.load(
+        job_payload,
+        policy,
+        route_id,
+        native_reference_verifier=native_reference_verifier,
+        evidence_authority=evidence_authority,
+    )
+    if cached is not None:
+        return cached
+    guard_operation()
+    try:
+        artifact = load_artifact()
+    except NativeReferenceStoreFailed:
+        raise
+    except Exception:
+        raise NativeReferenceStoreFailed(
+            "native_reference.loader_failed", retryable=True,
+        ) from None
+    guard_operation()
+    return store.save(
+        job_payload,
+        policy,
+        route_id,
+        artifact,
+        native_reference_verifier=native_reference_verifier,
+        evidence_authority=evidence_authority,
+        now=now,
+    )

package/standard-skills/translate-native/integrations/website_localization_quality_profiles.py

@@ -0,0 +1,235 @@
+#!/usr/bin/env python3
+"""Versioned, provider-neutral quality profiles for every EU target locale."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from dataclasses import asdict, dataclass
+from typing import Any
+
+
+SCHEMA = "blun.website-localization-quality-profile.v1"
+CLDR_VERSION = "48"
+CLDR_SUMMARY = "https://www.unicode.org/cldr/charts/48/summary/{language}.html"
+MALTESE_ORTHOGRAPHY_SOURCE = (
+    "https://kunsilltalmalti.gov.mt/mistoqssija-u-twegiba-51-76/"
+)
+REQUIRED_RED_TEAM_CHECKS = (
+    "translationese",
+    "wrong_neighbor_language",
+    "mixed_language_varieties",
+    "ascii_folding",
+    "missing_diacritics_or_native_script",
+    "wrong_inflection",
+    "meaning_omission",
+    "unnatural_cta",
+    "marketing_calque",
+)
+
+
+@dataclass(frozen=True)
+class LocaleQualityProfile:
+    locale: str
+    version: str
+    native_review_focus: tuple[str, ...]
+    fidelity_review_focus: tuple[str, ...]
+    adversarial_focus: tuple[str, ...]
+    required_red_team_checks: tuple[str, ...]
+    source_refs: tuple[str, ...]
+
+    def as_payload(self) -> dict[str, Any]:
+        body = json.loads(_canonical_json({"schema": SCHEMA, **asdict(self)}))
+        body["sha256"] = hashlib.sha256(_canonical_json(body)).hexdigest()
+        return body
+
+
+def _canonical_json(value: Any) -> bytes:
+    return json.dumps(
+        value,
+        ensure_ascii=False,
+        allow_nan=False,
+        sort_keys=True,
+        separators=(",", ":"),
+    ).encode("utf-8")
+
+
+def _profile(
+    locale: str,
+    native: tuple[str, ...],
+    fidelity: tuple[str, ...],
+    adversarial: tuple[str, ...],
+    *,
+    sources: tuple[str, ...] = (),
+) -> LocaleQualityProfile:
+    language = locale.split("-", 1)[0]
+    return LocaleQualityProfile(
+        locale=locale,
+        version=f"eu-{locale}-2026-09-1",
+        native_review_focus=native,
+        fidelity_review_focus=fidelity,
+        adversarial_focus=adversarial,
+        required_red_team_checks=REQUIRED_RED_TEAM_CHECKS,
+        source_refs=(CLDR_SUMMARY.format(language=language), *sources),
+    )
+
+
+PROFILES: tuple[LocaleQualityProfile, ...] = (
+    _profile(
+        "bg-BG",
+        ("Use idiomatic Bulgarian Cyrillic, natural clitic placement, verbal aspect, and postposed definite articles.",),
+        ("Check aspect, tense, evidential meaning, negation, modality, number, gender, and agreement against the source.",),
+        ("Reject transliteration, Russian or Macedonian leakage, missing article suffixes, stiff CTAs, marketing calques, omissions, and ASCII folding.",),
+    ),
+    _profile(
+        "hr-HR",
+        ("Use contemporary Croatian vocabulary, natural clitic order, case government, aspect, and idiomatic information structure.",),
+        ("Check case roles, aspect, tense, modality, negation, quantities, terminology, and every source proposition.",),
+        ("Reject Serbian or Bosnian variety mixing, ekavian leakage, lost diacritics, bad inflection, literal CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "cs-CZ",
+        ("Use idiomatic Czech word order, aspect, case government, agreement, and native characters including č, ř, š, ě, ů, and ž.",),
+        ("Check aspect, case roles, negation, modality, quantities, terminology, and complete propositional coverage.",),
+        ("Reject Slovak leakage, ASCII-folded diacritics, false friends, malformed inflection, source-shaped CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "da-DK",
+        ("Use contemporary Danish syntax, definiteness, compound formation, modal tone, and concise native web rhythm.",),
+        ("Check definiteness, negation, modality, quantities, terminology, and the full source meaning.",),
+        ("Reject Swedish or Norwegian leakage, mixed varieties, lost æ/ø/å, unnatural compounds, literal CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "nl-NL",
+        ("Use Netherlands Dutch word order, separable verbs, natural compounds, register, and idiomatic web copy.",),
+        ("Check verb particles, negation, modality, quantities, terminology, conditions, and complete source coverage.",),
+        ("Reject Belgian-Dutch mixing, German or English calques, bad compounds, stiff CTAs, missing meaning, and inappropriate ASCII substitution.",),
+    ),
+    _profile(
+        "en-IE",
+        ("Use natural contemporary Irish English spelling, idiom, register, punctuation, and concise web-copy rhythm.",),
+        ("Check negation, modality, quantities, terminology, conditions, and every source proposition without semantic inflation.",),
+        ("Reject mixed US and Irish conventions, source-language syntax, translationese, unnatural CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "et-EE",
+        ("Use idiomatic Estonian information structure, case government, quantity degrees, consonant gradation, compounds, and object case.",),
+        ("Check case roles, total versus partial objects, negation, modality, quantities, terminology, and complete meaning.",),
+        ("Reject Finnish or Russian leakage, ASCII-folded õ/ä/ö/ü, wrong quantity or inflection, literal CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "fi-FI",
+        ("Use natural Finnish information structure, case government, agglutination, possessive suffixes, vowel harmony, consonant gradation, clitics, idiomatic compounds, and appropriate politeness.",),
+        ("Check case roles, scope, negation, modality, quantities, terminology, conditions, and every proposition across the complete source.",),
+        ("Reject Swedish, Estonian, English, or German leakage and calques; ASCII-folded ä/ö; broken inflection; unnatural CTAs; marketing calques; and omissions.",),
+    ),
+    _profile(
+        "fr-FR",
+        ("Use France French idiom, natural syntax, contractions, agreement, typography, register, and persuasive but credible web rhythm.",),
+        ("Check gender and number agreement, negation, modality, quantities, terminology, conditions, and complete meaning.",),
+        ("Reject Canadian or Belgian variety mixing, anglicisms, lost accents, literal CTAs, marketing calques, bad inflection, and omissions.",),
+    ),
+    _profile(
+        "de-AT",
+        ("Use Austrian Standard German vocabulary and conventions, idiomatic clause structure, compounds, case government, register, and natural web rhythm.",),
+        ("Check case roles, negation, modality, quantities, terminology, conditions, and every source proposition.",),
+        ("Reject Germany-only defaults where Austrian usage matters, Swiss mixing, ASCII-folded ä/ö/ü/ß, translationese, stiff CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "el-GR",
+        ("Use monotonic Greek with native Greek script, correct accents, aspect, clitic placement, case, gender, agreement, and natural information structure.",),
+        ("Check aspect, case roles, negation, modality, quantities, terminology, conditions, and complete source coverage.",),
+        ("Reject Greeklish, Ancient or Cypriot variety mixing, missing tonos, bad inflection, literal CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "hu-HU",
+        ("Use idiomatic Hungarian focus order, vowel harmony, case suffixes, definite or indefinite conjugation, compounds, and natural politeness.",),
+        ("Check focus and scope, conjugation, negation, modality, quantities, terminology, conditions, and complete meaning.",),
+        ("Reject neighboring-language leakage, ASCII-folded ő/ű, suffix disharmony, bad inflection, source-shaped CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "ga-IE",
+        ("Use contemporary standard Irish with natural VSO structure, initial mutations, broad or slender consonant spelling, case forms, copula versus bí, and appropriate register.",),
+        ("Check mutations, possession, genitive relations, negation, modality, quantities, terminology, and every source proposition.",),
+        ("Reject English word order and calques, Scottish Gaelic leakage, missing fadas, wrong mutations, unnatural CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "it-IT",
+        ("Use contemporary Italian idiom, natural clitic placement, article and preposition contraction, agreement, register, and web-copy rhythm.",),
+        ("Check clitic reference, negation, modality, quantities, terminology, conditions, and complete source meaning.",),
+        ("Reject regional or Swiss-Italian mixing, anglicised syntax, lost accents, bad agreement, literal CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "lv-LV",
+        ("Use idiomatic Latvian case government, declension, agreement, verb prefixes, information structure, and native diacritics.",),
+        ("Check case roles, aspectual prefixes, negation, modality, quantities, terminology, conditions, and complete meaning.",),
+        ("Reject Lithuanian or Russian leakage, ASCII-folded ā/č/ē/ģ/ī/ķ/ļ/ņ/š/ū/ž, bad inflection, literal CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "lt-LT",
+        ("Use idiomatic Lithuanian case government, declension, agreement, participles, aspect, information structure, and native diacritics.",),
+        ("Check case roles, aspect, negation, modality, quantities, terminology, conditions, and complete source coverage.",),
+        ("Reject Latvian, Polish, or Russian leakage, ASCII-folded ą/č/ę/ė/į/š/ų/ū/ž, bad inflection, literal CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "mt-MT",
+        ("Use contemporary Maltese orthography with ċ, ġ, għ, ħ, and ż; natural Semitic and Romance morphology; fused articles and prepositions; idiomatic syntax; register; and rhythm.",),
+        ("Check articles, prepositions, agreement, verb morphology, negation, modality, quantities, terminology, conditions, and every source proposition.",),
+        ("Reject English or Italian calques and word order, neighboring-language leakage, ASCII-folded Maltese letters, false plurals or inflection, unnatural CTAs, marketing calques, and omissions.",),
+        sources=(MALTESE_ORTHOGRAPHY_SOURCE,),
+    ),
+    _profile(
+        "pl-PL",
+        ("Use idiomatic Polish aspect, case government, gender and virility agreement, natural word order, register, and native diacritics.",),
+        ("Check aspect, case roles, negation, modality, quantities, terminology, conditions, and complete meaning.",),
+        ("Reject Czech, Slovak, or Russian leakage, ASCII-folded ą/ć/ę/ł/ń/ó/ś/ź/ż, bad inflection, literal CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "pt-PT",
+        ("Use European Portuguese vocabulary, clitic placement, infinitive choices, agreement, register, punctuation, and natural web rhythm.",),
+        ("Check clitic reference, negation, modality, quantities, terminology, conditions, and every source proposition.",),
+        ("Reject Brazilian-Portuguese mixing, Spanish or English calques, lost diacritics, bad inflection, unnatural CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "ro-RO",
+        ("Use contemporary Romanian idiom, enclitic definite articles, case marking, agreement, clitic placement, register, and native diacritics.",),
+        ("Check article and clitic reference, negation, modality, quantities, terminology, conditions, and complete meaning.",),
+        ("Reject Moldovan or Italian mixing, ASCII-folded ă/â/î/ș/ț, cedilla substitutions, bad inflection, literal CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "sk-SK",
+        ("Use idiomatic Slovak aspect, case government, agreement, rhythmic law where relevant, natural word order, and native diacritics.",),
+        ("Check aspect, case roles, negation, modality, quantities, terminology, conditions, and complete source coverage.",),
+        ("Reject Czech leakage, ASCII-folded ľ/ĺ/ŕ/ť/ď/ň/ô/ä, bad inflection, source-shaped CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "sl-SI",
+        ("Use idiomatic Slovenian dual forms, case government, agreement, aspect, clitic order, natural information structure, and native diacritics.",),
+        ("Check dual and plural number, case roles, negation, modality, quantities, terminology, conditions, and complete meaning.",),
+        ("Reject Croatian or Serbian leakage, ASCII-folded č/š/ž, lost dual forms, bad inflection, literal CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "es-ES",
+        ("Use Spain Spanish idiom, natural clitic use, mood and aspect, agreement, register, punctuation, and credible web-copy rhythm.",),
+        ("Check mood, aspect, pronoun reference, negation, modality, quantities, terminology, conditions, and complete meaning.",),
+        ("Reject Latin-American variety mixing, anglicisms, lost accents or ñ, bad inflection, literal CTAs, marketing calques, and omissions.",),
+    ),
+    _profile(
+        "sv-SE",
+        ("Use Sweden Swedish word order, definiteness, compound formation, modal tone, punctuation, register, and concise native web rhythm.",),
+        ("Check definiteness, negation, modality, quantities, terminology, conditions, and every source proposition.",),
+        ("Reject Finnish-Swedish, Danish, or Norwegian mixing, ASCII-folded å/ä/ö, split compounds, literal CTAs, marketing calques, and omissions.",),
+    ),
+)
+
+_BY_LOCALE = {profile.locale: profile for profile in PROFILES}
+if len(_BY_LOCALE) != len(PROFILES):
+    raise RuntimeError("duplicate website-localization quality profile")
+
+
+def quality_profile_for(locale: str) -> dict[str, Any]:
+    try:
+        profile = _BY_LOCALE[locale]
+    except (KeyError, TypeError):
+        raise ValueError("unsupported quality-profile locale") from None
+    return profile.as_payload()