icydb_core/error/

mod.rs

//! Module: error
//!
//! Defines the canonical runtime error taxonomy for `icydb-core`.
//! This module owns the shared error classes, origins, details, and
//! constructor entry points used across storage, planning, execution, and
//! serialization boundaries.

#[cfg(test)]
mod tests;

use candid::CandidType;
use icydb_diagnostic_code as diagnostic_code;
use serde::Deserialize;
use std::fmt;

pub(crate) const COMPACT_QUERY_DIAGNOSTIC_MESSAGE: &str = "query diagnostic";
const COMPACT_RUNTIME_DIAGNOSTIC_MESSAGE: &str = "runtime diagnostic";
const COMPACT_STORE_DIAGNOSTIC_MESSAGE: &str = "store diagnostic";
const COMPACT_INDEX_DIAGNOSTIC_MESSAGE: &str = "index diagnostic";
const COMPACT_SERIALIZE_DIAGNOSTIC_MESSAGE: &str = "serialize diagnostic";
const COMPACT_IDENTITY_DIAGNOSTIC_MESSAGE: &str = "identity diagnostic";

const fn compact_message_for(_class: ErrorClass, origin: ErrorOrigin) -> &'static str {
    match origin {
        ErrorOrigin::Serialize => COMPACT_SERIALIZE_DIAGNOSTIC_MESSAGE,
        ErrorOrigin::Store => COMPACT_STORE_DIAGNOSTIC_MESSAGE,
        ErrorOrigin::Index => COMPACT_INDEX_DIAGNOSTIC_MESSAGE,
        ErrorOrigin::Identity => COMPACT_IDENTITY_DIAGNOSTIC_MESSAGE,
        ErrorOrigin::Query | ErrorOrigin::Planner | ErrorOrigin::Response => {
            COMPACT_QUERY_DIAGNOSTIC_MESSAGE
        }
        ErrorOrigin::Cursor
        | ErrorOrigin::Recovery
        | ErrorOrigin::Executor
        | ErrorOrigin::Interface => COMPACT_RUNTIME_DIAGNOSTIC_MESSAGE,
    }
}

// ============================================================================
// INTERNAL ERROR TAXONOMY — ARCHITECTURAL CONTRACT
// ============================================================================
//
// This file defines the canonical runtime error classification system for
// icydb-core. It is the single source of truth for:
//
//   • ErrorClass   (semantic domain)
//   • ErrorOrigin  (subsystem boundary)
//   • Structured detail payloads
//   • Canonical constructor entry points
//
// -----------------------------------------------------------------------------
// DESIGN INTENT
// -----------------------------------------------------------------------------
//
// 1. InternalError is a *taxonomy carrier*, not a formatting utility.
//
//    - ErrorClass represents semantic meaning (corruption, invariant_violation,
//      unsupported, etc).
//    - ErrorOrigin represents the subsystem boundary (store, index, query,
//      executor, serialize, interface, etc).
//    - The (class, origin) pair must remain stable and intentional.
//
// 2. Call sites MUST prefer canonical constructors.
//
//    Do NOT construct errors manually via:
//        InternalError::new(class, origin)
//    unless you are defining a new canonical helper here.
//
//    If a pattern appears more than once, centralize it here.
//
// 3. Constructors in this file must represent real architectural boundaries.
//
//    Add a new helper ONLY if it:
//
//      • Encodes a cross-cutting invariant,
//      • Represents a subsystem boundary,
//      • Or prevents taxonomy drift across call sites.
//
//    Do NOT add feature-specific helpers.
//    Do NOT add one-off formatting helpers.
//    Do NOT turn this file into a generic message factory.
//
// 4. ErrorDetail must align with ErrorOrigin.
//
//    If detail is present, it MUST correspond to the origin.
//    Do not attach mismatched detail variants.
//
// 5. Plan-layer errors are NOT runtime failures.
//
//    PlanError and CursorPlanError must be translated into
//    executor/query invariants via the canonical mapping functions.
//    Do not leak plan-layer error types across execution boundaries.
//
// 6. Preserve taxonomy stability.
//
//    Do NOT:
//      • Merge error classes.
//      • Reclassify corruption as internal.
//      • Downgrade invariant violations.
//      • Introduce ambiguous class/origin combinations.
//
//    Any change to ErrorClass or ErrorOrigin is an architectural change
//    and must be reviewed accordingly.
//
// -----------------------------------------------------------------------------
// NON-GOALS
// -----------------------------------------------------------------------------
//
// This is NOT:
//
//   • A public API contract.
//   • A generic error abstraction layer.
//   • A feature-specific message builder.
//   • A dumping ground for temporary error conversions.
//
// -----------------------------------------------------------------------------
// MAINTENANCE GUIDELINES
// -----------------------------------------------------------------------------
//
// When modifying this file:
//
//   1. Ensure classification semantics remain consistent.
//   2. Avoid constructor proliferation.
//   3. Prefer narrow, origin-specific helpers over ad-hoc new(...).
//   4. Keep formatting minimal and standardized.
//   5. Keep this file boring and stable.
//
// If this file grows rapidly, something is wrong at the call sites.
//
// ============================================================================

///
/// InternalError
///
/// Structured runtime error with a stable internal classification.
/// Not a stable API; intended for internal use and may change without notice.
///

pub struct InternalError {
    pub(crate) class: ErrorClass,
    pub(crate) origin: ErrorOrigin,

    /// Optional structured error detail.
    /// The variant (if present) must correspond to `origin`.
    pub(crate) detail: Option<ErrorDetail>,
}

#[expect(
    clippy::missing_const_for_fn,
    reason = "internal error constructors stay non-const so compact diagnostic construction does not force const churn across subsystem helper seams"
)]
impl InternalError {
    /// Construct an InternalError with optional origin-specific detail.
    /// This constructor provides default StoreError details for certain
    /// (class, origin) combinations but does not guarantee a detail payload.
    #[must_use]
    #[cold]
    #[inline(never)]
    pub fn new(class: ErrorClass, origin: ErrorOrigin) -> Self {
        let detail = match (class, origin) {
            (ErrorClass::Corruption, ErrorOrigin::Store) => {
                Some(ErrorDetail::Store(StoreError::Corrupt))
            }
            (ErrorClass::InvariantViolation, ErrorOrigin::Store) => {
                Some(ErrorDetail::Store(StoreError::InvariantViolation))
            }
            _ => None,
        };

        Self {
            class,
            origin,
            detail,
        }
    }

    /// Return the internal error class taxonomy.
    #[must_use]
    pub const fn class(&self) -> ErrorClass {
        self.class
    }

    /// Return the internal error origin taxonomy.
    #[must_use]
    pub const fn origin(&self) -> ErrorOrigin {
        self.origin
    }

    /// Return the rendered internal error message.
    #[must_use]
    pub const fn message(&self) -> &'static str {
        compact_message_for(self.class, self.origin)
    }

    /// Return the optional structured detail payload.
    #[must_use]
    pub const fn detail(&self) -> Option<&ErrorDetail> {
        self.detail.as_ref()
    }

    /// Borrow the accepted constraint diagnostic carried by this error.
    #[must_use]
    pub fn constraint_diagnostic(&self) -> Option<&ConstraintDiagnostic> {
        match self.detail.as_ref() {
            Some(ErrorDetail::Executor(detail)) => detail.constraint_diagnostic(),
            Some(
                ErrorDetail::Store(_)
                | ErrorDetail::Query(_)
                | ErrorDetail::Recovery(_)
                | ErrorDetail::Serialize(_),
            )
            | None => None,
        }
    }

    /// Return compact diagnostic identity for this internal error.
    #[must_use]
    pub fn diagnostic(&self) -> diagnostic_code::Diagnostic {
        diagnostic_code::Diagnostic::new(
            self.diagnostic_code(),
            self.origin.diagnostic_origin(),
            self.detail
                .as_ref()
                .and_then(ErrorDetail::diagnostic_detail),
        )
    }

    /// Return the compact diagnostic code for this internal error.
    #[must_use]
    pub fn diagnostic_code(&self) -> diagnostic_code::DiagnosticCode {
        self.detail.as_ref().map_or_else(
            || self.class.diagnostic_code(self.origin),
            ErrorDetail::diagnostic_code,
        )
    }

    /// Consume and return the rendered internal error message.
    #[must_use]
    pub fn into_message(self) -> String {
        self.message().to_string()
    }

    /// Construct an error while preserving an explicit class/origin taxonomy pair.
    #[cold]
    #[inline(never)]
    pub(crate) fn classified(class: ErrorClass, origin: ErrorOrigin) -> Self {
        Self::new(class, origin)
    }

    /// Rebuild this error with a new origin while preserving class taxonomy.
    ///
    /// Origin-scoped detail payloads are intentionally dropped when re-origining.
    #[cold]
    #[inline(never)]
    pub(crate) fn with_origin(self, origin: ErrorOrigin) -> Self {
        Self::classified(self.class, origin)
    }

    /// Construct an index-origin invariant violation.
    #[cold]
    #[inline(never)]
    pub(crate) fn index_invariant() -> Self {
        Self::new(ErrorClass::InvariantViolation, ErrorOrigin::Index)
    }

    /// Construct the canonical index field-count invariant for key building.
    pub(crate) fn index_key_field_count_exceeds_max(
        _index_name: &str,
        _field_count: usize,
        _max_fields: usize,
    ) -> Self {
        Self::index_invariant()
    }

    /// Construct the canonical index-expression source-type mismatch invariant.
    pub(crate) fn index_expression_source_type_mismatch(
        _index_name: &str,
        _expression: impl Sized,
        _expected: impl Sized,
        _source_label: &str,
    ) -> Self {
        Self::index_invariant()
    }

    /// Construct a planner-origin invariant violation for executor-boundary
    /// contract drift.
    #[cold]
    #[inline(never)]
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn planner_executor_invariant() -> Self {
        Self::new(ErrorClass::InvariantViolation, ErrorOrigin::Planner)
    }

    /// Construct a query-origin invariant violation for executor-boundary
    /// contract drift.
    #[cold]
    #[inline(never)]
    pub(crate) fn query_executor_invariant() -> Self {
        Self::new(ErrorClass::InvariantViolation, ErrorOrigin::Query)
    }

    /// Construct a cursor-origin invariant violation for executor-boundary
    /// contract drift.
    #[cold]
    #[inline(never)]
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn cursor_executor_invariant() -> Self {
        Self::new(ErrorClass::InvariantViolation, ErrorOrigin::Cursor)
    }

    /// Construct an executor-origin invariant violation.
    #[cold]
    #[inline(never)]
    pub(crate) fn executor_invariant() -> Self {
        Self::new(ErrorClass::InvariantViolation, ErrorOrigin::Executor)
    }

    /// Construct an executor-origin internal error.
    #[cold]
    #[inline(never)]
    pub(crate) fn executor_internal() -> Self {
        Self::new(ErrorClass::Internal, ErrorOrigin::Executor)
    }

    /// Construct an executor-origin unsupported error.
    #[cold]
    #[inline(never)]
    pub(crate) fn executor_unsupported() -> Self {
        Self::new(ErrorClass::Unsupported, ErrorOrigin::Executor)
    }

    /// Construct an executor-origin database-owned-field authorship rejection.
    pub(crate) fn mutation_database_owned_field_explicit(
        _entity_path: &str,
        _field_name: &str,
    ) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Executor,
            detail: Some(ErrorDetail::Executor(
                ExecutorErrorDetail::MutationDatabaseOwnedFieldExplicit,
            )),
        }
    }

    /// Construct an executor-origin required-field omission rejection.
    #[must_use]
    pub fn mutation_required_field_missing(_entity_path: &str, _field_names: &str) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Executor,
            detail: Some(ErrorDetail::Executor(
                ExecutorErrorDetail::MutationRequiredFieldMissing,
            )),
        }
    }

    /// Construct an executor-origin managed-timestamp clock regression.
    #[must_use]
    pub(crate) fn mutation_managed_timestamp_regression() -> Self {
        Self {
            class: ErrorClass::InvariantViolation,
            origin: ErrorOrigin::Executor,
            detail: Some(ErrorDetail::Executor(
                ExecutorErrorDetail::MutationManagedTimestampRegression,
            )),
        }
    }

    /// Construct an executor-origin accepted constraint or activation-gate violation.
    pub(crate) fn mutation_constraint_violation(diagnostic: ConstraintDiagnostic) -> Self {
        Self {
            class: ErrorClass::InvariantViolation,
            origin: ErrorOrigin::Executor,
            detail: Some(ErrorDetail::Executor(
                ExecutorErrorDetail::ConstraintViolation {
                    diagnostic: Box::new(diagnostic),
                },
            )),
        }
    }

    /// Construct an executor-origin corruption failure for row-constraint authority.
    pub(crate) fn accepted_row_constraint_program_corrupt() -> Self {
        Self {
            class: ErrorClass::Corruption,
            origin: ErrorOrigin::Executor,
            detail: Some(ErrorDetail::Executor(
                ExecutorErrorDetail::AcceptedRowConstraintProgramCorrupt,
            )),
        }
    }

    /// Construct one typed migration conflict for an incomplete activation gate.
    pub(crate) fn mutation_constraint_activation_write_blocked(
        diagnostic: ConstraintDiagnostic,
    ) -> Self {
        Self {
            class: ErrorClass::Conflict,
            origin: ErrorOrigin::Executor,
            detail: Some(ErrorDetail::Executor(
                ExecutorErrorDetail::ConstraintActivationWriteBlocked {
                    diagnostic: Box::new(diagnostic),
                },
            )),
        }
    }

    /// Construct an executor-origin mutation unknown-field invariant.
    pub(crate) fn mutation_structural_field_unknown(_entity_path: &str, _field_name: &str) -> Self {
        Self::executor_invariant()
    }

    /// Construct a query-origin scalar page invariant for missing order at the cursor boundary.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn scalar_page_cursor_boundary_order_required() -> Self {
        Self::query_executor_invariant()
    }

    /// Construct a query-origin scalar page invariant for cursor-before-ordering drift.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn scalar_page_cursor_boundary_after_ordering_required() -> Self {
        Self::query_executor_invariant()
    }

    /// Construct a query-origin scalar page invariant for pagination-before-ordering drift.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn scalar_page_pagination_after_ordering_required() -> Self {
        Self::query_executor_invariant()
    }

    /// Construct a query-origin fast-stream invariant for route kind/request mismatch.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn fast_stream_route_kind_request_match_required() -> Self {
        Self::query_executor_invariant()
    }

    /// Construct a query-origin scan invariant for missing index-prefix executable specs.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn secondary_index_prefix_spec_required() -> Self {
        Self::query_executor_invariant()
    }

    /// Construct a query-origin scan invariant for missing index-range executable specs.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn index_range_limit_spec_required() -> Self {
        Self::query_executor_invariant()
    }

    /// Construct an executor-origin mutation conflict for duplicate atomic save keys.
    pub(crate) fn mutation_atomic_save_duplicate_key(_entity_path: &str, _key: impl Sized) -> Self {
        Self {
            class: ErrorClass::Conflict,
            origin: ErrorOrigin::Executor,
            detail: Some(ErrorDetail::Executor(
                ExecutorErrorDetail::MutationBatchDuplicateKey,
            )),
        }
    }

    /// Construct an executor-origin empty mixed-mutation batch rejection.
    pub(crate) fn mutation_batch_empty() -> Self {
        Self::mutation_batch_unsupported(ExecutorErrorDetail::MutationBatchEmpty)
    }

    /// Construct an executor-origin mixed-mutation item-bound rejection.
    pub(crate) fn mutation_batch_too_many_items() -> Self {
        Self::mutation_batch_unsupported(ExecutorErrorDetail::MutationBatchTooManyItems)
    }

    /// Construct an executor-origin mixed-mutation staged-byte-bound rejection.
    pub(crate) fn mutation_batch_staged_bytes_exceeded() -> Self {
        Self::mutation_batch_unsupported(ExecutorErrorDetail::MutationBatchStagedBytesExceeded)
    }

    /// Construct an executor-origin mixed-mutation result-byte-bound rejection.
    pub(crate) fn mutation_batch_result_bytes_exceeded() -> Self {
        Self::mutation_batch_unsupported(ExecutorErrorDetail::MutationBatchResultBytesExceeded)
    }

    /// Construct an executor-origin mixed-entity batch rejection.
    pub(crate) fn mutation_batch_entity_mismatch() -> Self {
        Self {
            class: ErrorClass::Conflict,
            origin: ErrorOrigin::Executor,
            detail: Some(ErrorDetail::Executor(
                ExecutorErrorDetail::MutationBatchEntityMismatch,
            )),
        }
    }

    fn mutation_batch_unsupported(detail: ExecutorErrorDetail) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Executor,
            detail: Some(ErrorDetail::Executor(detail)),
        }
    }

    /// Construct an executor-origin mutation invariant for index-store generation drift.
    pub(crate) fn mutation_index_store_generation_changed(
        _expected_generation: u64,
        _observed_generation: u64,
    ) -> Self {
        Self::executor_invariant()
    }

    /// Construct a planner-origin invariant violation.
    #[cold]
    #[inline(never)]
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn planner_invariant() -> Self {
        Self::new(ErrorClass::InvariantViolation, ErrorOrigin::Planner)
    }

    /// Construct a planner-origin invalid-logical-plan invariant.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn query_invalid_logical_plan() -> Self {
        Self::planner_invariant()
    }

    /// Construct a store-origin invariant violation.
    pub(crate) fn store_invariant() -> Self {
        Self::new(ErrorClass::InvariantViolation, ErrorOrigin::Store)
    }

    /// Construct a store-origin internal error.
    #[cold]
    #[inline(never)]
    pub(crate) fn store_internal() -> Self {
        Self::new(ErrorClass::Internal, ErrorOrigin::Store)
    }

    /// Construct the canonical unconfigured commit-memory id internal error.
    pub(crate) fn commit_memory_id_unconfigured() -> Self {
        Self::store_internal()
    }

    /// Construct the canonical initialized commit-store lookup invariant.
    pub(crate) fn commit_store_uninitialized() -> Self {
        Self::store_invariant()
    }

    /// Construct the canonical commit-memory id mismatch internal error.
    pub(crate) fn commit_memory_id_mismatch(_cached_id: u8, _configured_id: u8) -> Self {
        Self::store_internal()
    }

    /// Construct the canonical commit-memory stable-key mismatch internal error.
    pub(crate) fn commit_memory_stable_key_mismatch(
        _cached_key: &str,
        _configured_key: &str,
    ) -> Self {
        Self::store_internal()
    }

    /// Construct the canonical database-incarnation generation failure.
    pub(crate) fn database_incarnation_generation_failed() -> Self {
        Self::store_internal()
    }

    /// Construct the canonical zero database-incarnation corruption error.
    pub(crate) fn database_incarnation_invalid() -> Self {
        Self::store_corruption()
    }

    /// Construct a recovery-origin incompatible store-format error.
    pub(crate) fn recovery_unsupported_database_format(found: Option<u16>, required: u16) -> Self {
        Self {
            class: ErrorClass::IncompatiblePersistedFormat,
            origin: ErrorOrigin::Recovery,
            detail: Some(ErrorDetail::Recovery(
                RecoveryErrorDetail::UnsupportedFormatVersion { found, required },
            )),
        }
    }

    /// Construct a recovery-origin malformed store-format marker error.
    pub(crate) fn recovery_malformed_database_format_marker(
        reason: RecoveryFormatMarkerError,
    ) -> Self {
        Self {
            class: ErrorClass::Corruption,
            origin: ErrorOrigin::Recovery,
            detail: Some(ErrorDetail::Recovery(
                RecoveryErrorDetail::MalformedFormatMarker { reason },
            )),
        }
    }

    /// Construct a recovery-origin boot control-memory failure.
    pub(crate) fn recovery_database_format_control_unavailable() -> Self {
        Self::new(ErrorClass::Internal, ErrorOrigin::Recovery)
    }

    /// Construct a commit control-memory growth failure.
    pub(crate) fn commit_control_memory_growth_failed() -> Self {
        Self::store_internal()
    }

    /// Construct a store-format memory registration failure.
    #[cfg(not(test))]
    pub(crate) fn database_format_memory_registration_failed(_err: impl Sized) -> Self {
        Self::store_internal()
    }

    /// Construct the canonical recovered-effect verification failure.
    pub(crate) fn recovery_effect_verification_failed() -> Self {
        Self::store_corruption()
    }

    /// Construct an index-origin internal error.
    #[cold]
    #[inline(never)]
    pub(crate) fn index_internal() -> Self {
        Self::new(ErrorClass::Internal, ErrorOrigin::Index)
    }

    /// Construct the canonical missing old entity-key internal error for structural index removal.
    pub(crate) fn structural_index_removal_entity_key_required() -> Self {
        Self::index_internal()
    }

    /// Construct the canonical missing new entity-key internal error for structural index insertion.
    pub(crate) fn structural_index_insertion_entity_key_required() -> Self {
        Self::index_internal()
    }

    /// Construct the canonical missing old entity-key internal error for index commit-op removal.
    pub(crate) fn index_commit_op_old_entity_key_required() -> Self {
        Self::index_internal()
    }

    /// Construct the canonical missing new entity-key internal error for index commit-op insertion.
    pub(crate) fn index_commit_op_new_entity_key_required() -> Self {
        Self::index_internal()
    }

    /// Construct a query-origin internal error.
    #[cfg(test)]
    pub(crate) fn query_internal() -> Self {
        Self::new(ErrorClass::Internal, ErrorOrigin::Query)
    }

    /// Construct a query-origin unsupported error.
    #[cold]
    #[inline(never)]
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn query_unsupported() -> Self {
        Self::new(ErrorClass::Unsupported, ErrorOrigin::Query)
    }

    /// Construct a query-origin conflict for execution against a superseded
    /// accepted schema revision.
    #[cold]
    #[inline(never)]
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn query_stale_accepted_schema_revision(
        _expected_revision: u64,
        _current_revision: Option<u64>,
    ) -> Self {
        Self {
            class: ErrorClass::Conflict,
            origin: ErrorOrigin::Query,
            detail: Some(ErrorDetail::Query(QueryErrorDetail::StaleSchemaRevision)),
        }
    }

    /// Construct a query-origin SQL DDL admission error with structured detail.
    #[cold]
    #[inline(never)]
    #[cfg(feature = "sql")]
    pub(crate) fn query_schema_ddl_admission(error: SchemaDdlAdmissionError) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Query,
            detail: Some(ErrorDetail::Query(QueryErrorDetail::SchemaDdlAdmission {
                error,
            })),
        }
    }

    /// Construct a query-origin numeric overflow error with structured detail.
    #[cold]
    #[inline(never)]
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn query_numeric_overflow() -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Query,
            detail: Some(ErrorDetail::Query(QueryErrorDetail::NumericOverflow)),
        }
    }

    /// Construct a query-origin non-representable numeric result error with
    /// structured detail.
    #[cold]
    #[inline(never)]
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn query_numeric_not_representable() -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Query,
            detail: Some(ErrorDetail::Query(
                QueryErrorDetail::NumericNotRepresentable,
            )),
        }
    }

    /// Construct a serialize-origin internal error.
    #[cold]
    #[inline(never)]
    pub(crate) fn serialize_internal() -> Self {
        Self::new(ErrorClass::Internal, ErrorOrigin::Serialize)
    }

    /// Construct the canonical persisted-row encode internal error.
    pub(crate) fn persisted_row_encode_failed(_detail: impl Sized) -> Self {
        Self::persisted_row_encode_internal()
    }

    /// Construct the compact persisted-row encode internal error.
    pub(crate) fn persisted_row_encode_internal() -> Self {
        Self::serialize_internal()
    }

    /// Construct the compact persisted-row field encode internal error.
    pub(crate) fn persisted_row_field_encode_internal(_field_name: &str) -> Self {
        Self::persisted_row_encode_internal()
    }

    /// Construct a store-origin corruption error.
    #[cold]
    #[inline(never)]
    pub(crate) fn store_corruption() -> Self {
        Self::new(ErrorClass::Corruption, ErrorOrigin::Store)
    }

    /// Construct a store-origin commit-marker corruption error.
    pub(crate) fn commit_corruption() -> Self {
        Self::store_corruption()
    }

    /// Construct a store-origin commit-marker component corruption error.
    pub(crate) fn commit_component_corruption() -> Self {
        Self::commit_corruption()
    }

    /// Construct the canonical commit-marker id generation internal error.
    pub(crate) fn commit_id_generation_failed() -> Self {
        Self::store_internal()
    }

    /// Construct the canonical commit-marker payload u32-length-limit error.
    pub(crate) fn commit_marker_payload_exceeds_u32_length_limit() -> Self {
        Self::store_unsupported()
    }

    /// Construct the canonical commit-marker component invalid-length corruption error.
    pub(crate) fn commit_component_length_invalid() -> Self {
        Self::commit_corruption()
    }

    /// Construct the canonical commit-marker max-size corruption error.
    pub(crate) fn commit_marker_exceeds_max_size() -> Self {
        Self::commit_corruption()
    }

    /// Construct the canonical commit-control slot max-size unsupported error.
    pub(crate) fn commit_control_slot_exceeds_max_size() -> Self {
        Self::store_unsupported()
    }

    /// Construct the canonical commit-control marker-bytes length-limit error.
    pub(crate) fn commit_control_slot_marker_bytes_exceed_u32_length_limit() -> Self {
        Self::store_unsupported()
    }

    /// Construct the canonical startup index-rebuild invalid-data-key corruption error.
    pub(crate) fn startup_index_rebuild_invalid_data_key() -> Self {
        Self::store_corruption()
    }

    /// Construct an index-origin corruption error.
    #[cold]
    #[inline(never)]
    pub(crate) fn index_corruption() -> Self {
        Self::new(ErrorClass::Corruption, ErrorOrigin::Index)
    }

    /// Construct the canonical unique-validation corruption wrapper.
    pub(crate) fn index_unique_validation_corruption() -> Self {
        Self::index_plan_index_corruption()
    }

    /// Construct the canonical structural index-entry corruption wrapper.
    pub(crate) fn structural_index_entry_corruption() -> Self {
        Self::index_plan_index_corruption()
    }

    /// Construct the canonical missing new entity-key invariant during unique validation.
    pub(crate) fn index_unique_validation_entity_key_required() -> Self {
        Self::index_invariant()
    }

    /// Construct the canonical unique-validation structural row-decode corruption error.
    pub(crate) fn index_unique_validation_row_deserialize_failed() -> Self {
        Self::index_plan_serialize_corruption()
    }

    /// Construct the canonical unique-validation primary-key slot decode corruption error.
    pub(crate) fn index_unique_validation_primary_key_decode_failed() -> Self {
        Self::index_plan_serialize_corruption()
    }

    /// Construct the canonical unique-validation stored key rebuild corruption error.
    pub(crate) fn index_unique_validation_key_rebuild_failed() -> Self {
        Self::index_plan_serialize_corruption()
    }

    /// Construct the canonical unique-validation missing-row corruption error.
    pub(crate) fn index_unique_validation_row_required() -> Self {
        Self::index_plan_store_corruption()
    }

    /// Construct the canonical index-only predicate missing-component invariant.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn index_only_predicate_component_required() -> Self {
        Self::index_invariant()
    }

    /// Construct the canonical index-scan continuation-envelope invariant.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn index_scan_continuation_anchor_within_envelope_required() -> Self {
        Self::index_invariant()
    }

    /// Construct the canonical index-scan continuation-advancement invariant.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn index_scan_continuation_advancement_required() -> Self {
        Self::index_invariant()
    }

    /// Construct the canonical index-scan key-decode corruption error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn index_scan_key_corrupted_during(
        _context: &'static str,
        _err: impl Sized,
    ) -> Self {
        Self::index_corruption()
    }

    /// Construct the canonical index-scan missing projection-component invariant.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn index_projection_component_required(
        _index_name: &str,
        _component_index: usize,
    ) -> Self {
        Self::index_invariant()
    }

    /// Construct the canonical scan-time index-entry decode corruption error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn index_entry_decode_failed() -> Self {
        Self::index_corruption()
    }

    /// Construct a serialize-origin corruption error.
    pub(crate) fn serialize_corruption() -> Self {
        Self::new(ErrorClass::Corruption, ErrorOrigin::Serialize)
    }

    /// Construct the compact persisted-row decode corruption error.
    pub(crate) fn persisted_row_decode_corruption() -> Self {
        Self::serialize_corruption()
    }

    /// Construct a persisted-row layout-window corruption error.
    pub(crate) fn persisted_row_layout_outside_accepted_window() -> Self {
        Self {
            class: ErrorClass::Corruption,
            origin: ErrorOrigin::Serialize,
            detail: Some(ErrorDetail::Serialize(
                SerializeErrorDetail::PersistedRowLayoutOutsideAcceptedWindow,
            )),
        }
    }

    /// Construct a persisted-row stamped-layout slot-count corruption error.
    pub(crate) fn persisted_row_slot_count_mismatch() -> Self {
        Self {
            class: ErrorClass::Corruption,
            origin: ErrorOrigin::Serialize,
            detail: Some(ErrorDetail::Serialize(
                SerializeErrorDetail::PersistedRowSlotCountMismatch,
            )),
        }
    }

    /// Construct the canonical persisted-row field decode corruption error.
    pub(crate) fn persisted_row_field_decode_failed(field_name: &str, _detail: impl Sized) -> Self {
        Self::persisted_row_field_decode_corruption(field_name)
    }

    /// Construct the compact persisted-row field decode corruption error.
    pub(crate) fn persisted_row_field_decode_corruption(_field_name: &str) -> Self {
        Self::persisted_row_decode_corruption()
    }

    /// Construct the canonical persisted-row field-kind decode corruption error.
    pub(crate) fn persisted_row_field_kind_decode_failed(
        field_name: &str,
        _field_kind: impl fmt::Debug,
        _detail: impl Sized,
    ) -> Self {
        Self::persisted_row_field_decode_corruption(field_name)
    }

    /// Construct the canonical persisted-row scalar-payload length corruption error.
    pub(crate) fn persisted_row_field_payload_exact_len_required(field_name: &str) -> Self {
        Self::persisted_row_field_decode_corruption(field_name)
    }

    /// Construct the canonical persisted-row scalar-payload empty-body corruption error.
    pub(crate) fn persisted_row_field_payload_must_be_empty(field_name: &str) -> Self {
        Self::persisted_row_field_decode_corruption(field_name)
    }

    /// Construct the canonical persisted-row scalar-payload invalid-byte corruption error.
    pub(crate) fn persisted_row_field_payload_invalid_byte(field_name: &str) -> Self {
        Self::persisted_row_field_decode_corruption(field_name)
    }

    /// Construct the canonical persisted-row scalar-payload non-finite corruption error.
    pub(crate) fn persisted_row_field_payload_non_finite(field_name: &str) -> Self {
        Self::persisted_row_field_decode_corruption(field_name)
    }

    /// Construct the canonical persisted-row invalid text payload corruption error.
    pub(crate) fn persisted_row_field_text_payload_invalid_utf8(field_name: &str) -> Self {
        Self::persisted_row_field_decode_corruption(field_name)
    }

    /// Construct the canonical persisted-row structural slot-lookup invariant.
    pub(crate) fn persisted_row_slot_lookup_out_of_bounds(_model_path: &str, _slot: usize) -> Self {
        Self::index_invariant()
    }

    /// Construct the canonical persisted-row structural slot-cache invariant.
    pub(crate) fn persisted_row_slot_cache_lookup_out_of_bounds(
        _model_path: &str,
        _slot: usize,
    ) -> Self {
        Self::index_invariant()
    }

    /// Construct the canonical persisted-row primary-key decode corruption error.
    pub(crate) fn persisted_row_primary_key_not_primary_key_encodable(
        _data_key: impl fmt::Debug,
        _detail: impl Sized,
    ) -> Self {
        Self::persisted_row_decode_corruption()
    }

    /// Construct the canonical persisted-row missing primary-key slot corruption error.
    pub(crate) fn persisted_row_primary_key_slot_missing(_data_key: impl fmt::Debug) -> Self {
        Self::persisted_row_decode_corruption()
    }

    /// Construct the canonical persisted-row key mismatch corruption error.
    pub(crate) fn persisted_row_key_mismatch() -> Self {
        Self::store_corruption()
    }

    /// Construct the canonical persisted-row missing declared-field corruption error.
    pub(crate) fn persisted_row_declared_field_missing(field_name: &str) -> Self {
        Self::persisted_row_field_decode_corruption(field_name)
    }

    /// Construct the canonical reverse-index ordinal overflow internal error.
    pub(crate) fn reverse_index_ordinal_overflow(
        _source_path: &str,
        _field_name: &str,
        _target_path: &str,
        _detail: impl Sized,
    ) -> Self {
        Self::index_internal()
    }

    /// Construct the canonical reverse-index entry corruption error.
    pub(crate) fn reverse_index_entry_corrupted(
        _source_path: &str,
        _field_name: &str,
        _target_path: &str,
        _index_key: impl fmt::Debug,
        _detail: impl Sized,
    ) -> Self {
        Self::index_corruption()
    }

    /// Construct the canonical relation-target store missing internal error.
    pub(crate) fn relation_target_store_missing(
        _source_path: &str,
        _field_name: &str,
        _target_path: &str,
        _store_path: &str,
        _detail: impl Sized,
    ) -> Self {
        Self::executor_internal()
    }

    /// Construct the canonical relation-target key decode corruption error.
    pub(crate) fn relation_target_key_decode_failed(
        _context_label: &str,
        _source_path: &str,
        _field_name: &str,
        _target_path: &str,
        _detail: impl Sized,
    ) -> Self {
        Self::identity_corruption()
    }

    /// Construct the canonical relation-target entity mismatch corruption error.
    pub(crate) fn relation_target_entity_mismatch(
        _context_label: &str,
        _source_path: &str,
        _field_name: &str,
        _target_path: &str,
        _target_entity_name: &str,
        _expected_tag: impl Sized,
        _actual_tag: impl Sized,
    ) -> Self {
        Self::store_corruption()
    }

    /// Construct the canonical relation-source row decode corruption error.
    pub(crate) fn relation_source_row_decode_failed(
        _source_path: &str,
        _field_name: &str,
        _target_path: &str,
        _detail: impl Sized,
    ) -> Self {
        Self::persisted_row_decode_corruption()
    }

    /// Construct the canonical relation-source unsupported scalar relation-key corruption error.
    pub(crate) fn relation_source_row_unsupported_scalar_relation_key(
        _source_path: &str,
        _field_name: &str,
        _target_path: &str,
    ) -> Self {
        Self::persisted_row_decode_corruption()
    }

    /// Construct the canonical unsupported relation key-kind corruption error.
    pub(crate) fn relation_source_row_unsupported_key_kind(_field_kind: impl fmt::Debug) -> Self {
        Self::persisted_row_decode_corruption()
    }

    /// Construct the canonical covering-component empty-payload corruption error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn bytes_covering_component_payload_empty() -> Self {
        Self::index_corruption()
    }

    /// Construct the canonical covering-component truncated bool corruption error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn bytes_covering_bool_payload_truncated() -> Self {
        Self::index_corruption()
    }

    /// Construct the canonical covering-component invalid-length corruption error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn bytes_covering_component_payload_invalid_length() -> Self {
        Self::index_corruption()
    }

    /// Construct the canonical covering-component invalid-bool corruption error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn bytes_covering_bool_payload_invalid_value() -> Self {
        Self::index_corruption()
    }

    /// Construct the canonical covering-component invalid text terminator corruption error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn bytes_covering_text_payload_invalid_terminator() -> Self {
        Self::index_corruption()
    }

    /// Construct the canonical covering-component trailing-text corruption error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn bytes_covering_text_payload_trailing_bytes() -> Self {
        Self::index_corruption()
    }

    /// Construct the canonical covering-component invalid-UTF-8 text corruption error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn bytes_covering_text_payload_invalid_utf8() -> Self {
        Self::index_corruption()
    }

    /// Construct the canonical covering-component invalid text escape corruption error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn bytes_covering_text_payload_invalid_escape_byte() -> Self {
        Self::index_corruption()
    }

    /// Construct the canonical covering-component missing text terminator corruption error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn bytes_covering_text_payload_missing_terminator() -> Self {
        Self::index_corruption()
    }

    /// Construct the canonical missing persisted-field decode error.
    #[must_use]
    pub fn missing_persisted_slot(field_name: &'static str) -> Self {
        Self::persisted_row_field_decode_corruption(field_name)
    }

    /// Construct an identity-origin corruption error.
    pub(crate) fn identity_corruption() -> Self {
        Self::new(ErrorClass::Corruption, ErrorOrigin::Identity)
    }

    /// Construct the canonical identity-control-state corruption error.
    pub(crate) fn identity_state_corruption() -> Self {
        Self::identity_corruption()
    }

    /// Construct the typed stale high-water conflict for identity publication.
    pub(crate) fn identity_state_conflict() -> Self {
        Self::new(ErrorClass::Conflict, ErrorOrigin::Identity)
    }

    /// Construct the bounded identity-state inventory exhaustion error.
    pub(crate) fn identity_state_capacity_exhausted() -> Self {
        Self::new(ErrorClass::Unsupported, ErrorOrigin::Identity)
    }

    /// Construct the exact unsigned identity-domain exhaustion error.
    pub(crate) fn identity_exhausted() -> Self {
        Self::new(ErrorClass::Unsupported, ErrorOrigin::Identity)
    }

    /// Construct the bounded pre-key candidate-count exhaustion error.
    pub(crate) fn identity_candidate_count_exhausted() -> Self {
        Self::new(ErrorClass::Unsupported, ErrorOrigin::Identity)
    }

    /// Construct a store-origin unsupported error.
    #[cold]
    #[inline(never)]
    pub(crate) fn store_unsupported() -> Self {
        Self::new(ErrorClass::Unsupported, ErrorOrigin::Store)
    }

    /// Construct the typed optimistic/idempotency conflict for schema application.
    pub(crate) fn schema_application_conflict() -> Self {
        Self::new(ErrorClass::Conflict, ErrorOrigin::Store)
    }

    /// Construct the canonical schema DDL publication race error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn schema_ddl_publication_race_lost(_entity_path: &str) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Store,
            detail: Some(ErrorDetail::Store(StoreError::SchemaDdlPublicationRaceLost)),
        }
    }

    /// Construct the canonical current physical-rewrite migration rejection.
    #[cfg(feature = "sql")]
    pub(crate) fn schema_ddl_rewrite_requires_migration(_entity_path: &str) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Store,
            detail: Some(ErrorDetail::Store(
                StoreError::SchemaDdlRewriteRequiresMigration,
            )),
        }
    }

    /// Construct the fail-closed journal mutation-revision exhaustion error.
    pub(crate) fn journal_mutation_revision_exhausted() -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Store,
            detail: Some(ErrorDetail::Store(
                StoreError::JournalMutationRevisionExhausted,
            )),
        }
    }

    /// Construct a bounded schema-transition resource rejection.
    pub(crate) fn schema_transition_budget_exceeded(
        resource: SchemaTransitionBudgetResource,
    ) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Store,
            detail: Some(ErrorDetail::Store(
                StoreError::SchemaTransitionBudgetExceeded { resource },
            )),
        }
    }

    /// Construct the canonical unsupported persisted entity-tag store error.
    pub(crate) fn unsupported_entity_tag_in_data_store(
        _entity_tag: crate::types::EntityTag,
    ) -> Self {
        Self::store_unsupported()
    }

    /// Construct the canonical commit-memory id registration failure.
    #[cfg(not(test))]
    pub(crate) fn commit_memory_id_registration_failed(_err: impl Sized) -> Self {
        Self::store_internal()
    }

    /// Construct an index-origin unsupported error.
    pub(crate) fn index_unsupported() -> Self {
        Self::new(ErrorClass::Unsupported, ErrorOrigin::Index)
    }

    /// Construct the canonical index-key component size-limit unsupported error.
    pub(crate) fn index_component_exceeds_max_size() -> Self {
        Self::index_unsupported()
    }

    /// Construct a serialize-origin unsupported error.
    pub(crate) fn serialize_unsupported() -> Self {
        Self::new(ErrorClass::Unsupported, ErrorOrigin::Serialize)
    }

    /// Construct a cursor-origin invalid-continuation error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn cursor_invalid_continuation() -> Self {
        Self::new(ErrorClass::Unsupported, ErrorOrigin::Cursor)
    }

    /// Construct a serialize-origin incompatible persisted-format error.
    pub(crate) fn serialize_incompatible_persisted_format() -> Self {
        Self::new(
            ErrorClass::IncompatiblePersistedFormat,
            ErrorOrigin::Serialize,
        )
    }

    /// Construct a query-origin unsupported error preserving one SQL parser
    /// unsupported-feature code in structured error detail.
    #[cfg(feature = "sql")]
    pub(crate) fn query_unsupported_sql_feature(feature: diagnostic_code::SqlFeatureCode) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Query,
            detail: Some(ErrorDetail::Query(
                QueryErrorDetail::UnsupportedSqlFeature { feature },
            )),
        }
    }

    /// Construct a query-origin unsupported SQL lowering error preserving one
    /// compact lowering reason in structured error detail.
    #[cfg(feature = "sql")]
    pub(crate) fn query_sql_lowering(reason: diagnostic_code::SqlLoweringCode) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Query,
            detail: Some(ErrorDetail::Query(QueryErrorDetail::SqlLowering { reason })),
        }
    }

    /// Construct a query-origin unsupported projection error preserving one
    /// compact projection reason in structured error detail.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn query_unsupported_projection(
        reason: diagnostic_code::QueryProjectionCode,
    ) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Query,
            detail: Some(ErrorDetail::Query(
                QueryErrorDetail::UnsupportedProjection { reason },
            )),
        }
    }

    /// Construct a query-origin unsupported aggregate target-field error.
    #[cfg(any(test, feature = "query"))]
    pub(crate) fn query_unknown_aggregate_target_field() -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Query,
            detail: Some(ErrorDetail::Query(
                QueryErrorDetail::UnknownAggregateTargetField,
            )),
        }
    }

    /// Construct a query-origin unsupported error preserving one SQL endpoint
    /// surface mismatch in structured error detail.
    #[cfg(feature = "sql")]
    pub(crate) fn query_sql_surface_mismatch(
        mismatch: diagnostic_code::SqlSurfaceMismatchCode,
    ) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Query,
            detail: Some(ErrorDetail::Query(QueryErrorDetail::SqlSurfaceMismatch {
                mismatch,
            })),
        }
    }

    /// Construct a query-origin unsupported SQL write boundary error.
    pub(crate) fn query_sql_write_boundary(
        boundary: diagnostic_code::SqlWriteBoundaryCode,
    ) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Query,
            detail: Some(ErrorDetail::Query(QueryErrorDetail::SqlWriteBoundary {
                boundary,
            })),
        }
    }

    pub fn store_not_found(_key: impl Sized) -> Self {
        Self {
            class: ErrorClass::NotFound,
            origin: ErrorOrigin::Store,
            detail: Some(ErrorDetail::Store(StoreError::NotFound)),
        }
    }

    /// Construct a standardized unsupported-entity-path error.
    pub fn unsupported_entity_path(_path: impl Sized) -> Self {
        Self::store_unsupported()
    }

    #[must_use]
    pub const fn is_not_found(&self) -> bool {
        matches!(self.detail, Some(ErrorDetail::Store(StoreError::NotFound)))
    }

    /// Construct an index-plan corruption error with a canonical prefix.
    #[cold]
    #[inline(never)]
    pub(crate) fn index_plan_corruption(origin: ErrorOrigin) -> Self {
        Self::new(ErrorClass::Corruption, origin)
    }

    /// Construct an index-plan corruption error for index-origin failures.
    #[cold]
    #[inline(never)]
    pub(crate) fn index_plan_index_corruption() -> Self {
        Self::index_plan_corruption(ErrorOrigin::Index)
    }

    /// Construct an index-plan corruption error for store-origin failures.
    #[cold]
    #[inline(never)]
    pub(crate) fn index_plan_store_corruption() -> Self {
        Self::index_plan_corruption(ErrorOrigin::Store)
    }

    /// Construct an index-plan corruption error for serialize-origin failures.
    #[cold]
    #[inline(never)]
    pub(crate) fn index_plan_serialize_corruption() -> Self {
        Self::index_plan_corruption(ErrorOrigin::Serialize)
    }

    /// Construct an index-plan invariant violation error with a canonical prefix.
    #[cfg(test)]
    pub(crate) fn index_plan_invariant(origin: ErrorOrigin) -> Self {
        Self::new(ErrorClass::InvariantViolation, origin)
    }

    /// Construct an index-plan invariant violation error for store-origin failures.
    #[cfg(test)]
    pub(crate) fn index_plan_store_invariant() -> Self {
        Self::index_plan_invariant(ErrorOrigin::Store)
    }

    /// Construct an index-origin conflict without claiming accepted identity.
    ///
    /// Live accepted uniqueness violations use `ConstraintDiagnostic`.
    /// Schema-domain staging and activation findings use this compact
    /// classification before an accepted write-admission diagnostic exists.
    pub(crate) fn index_conflict() -> Self {
        Self::new(ErrorClass::Conflict, ErrorOrigin::Index)
    }
}

impl From<diagnostic_code::QueryReadAdmissionCode> for InternalError {
    fn from(reason: diagnostic_code::QueryReadAdmissionCode) -> Self {
        Self {
            class: ErrorClass::Unsupported,
            origin: ErrorOrigin::Query,
            detail: Some(ErrorDetail::Query(QueryErrorDetail::QueryReadAdmission {
                reason,
            })),
        }
    }
}

impl fmt::Debug for InternalError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt_compact_diagnostic(
            f,
            self.diagnostic_code(),
            self.detail
                .as_ref()
                .and_then(ErrorDetail::diagnostic_detail),
        )
    }
}

impl fmt::Display for InternalError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(self.message())
    }
}

impl std::error::Error for InternalError {}

///
/// ConstraintDiagnosticKind
///
/// Accepted constraint family attached to one bounded runtime diagnostic.
/// Accepted schema owns the identity; this enum is its error-boundary projection.
///

#[derive(CandidType, Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
pub enum ConstraintDiagnosticKind {
    /// One accepted canonical check expression.
    Check,

    /// One accepted or activating not-null field contract.
    NotNull,

    /// One accepted or activating relation contract.
    Relation,

    /// One accepted durable rule over a nominal value below a persisted root.
    TargetedRule,

    /// One accepted or activating unique-index contract.
    Unique,
}

impl ConstraintDiagnosticKind {
    /// Borrow the stable public label for this constraint family.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Check => "check",
            Self::NotNull => "not_null",
            Self::Relation => "relation",
            Self::TargetedRule => "targeted_rule",
            Self::Unique => "unique",
        }
    }
}

///
/// ConstraintValuePathComponent
///
/// Stable accepted identity or finite-value coordinate in one targeted-rule
/// violation. Display names are deliberately absent so renames cannot change
/// the diagnostic identity.
///

#[derive(CandidType, Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
pub enum ConstraintValuePathComponent {
    /// Persisted root field whose admitted value was traversed.
    RootField { field_id: u32 },

    /// Accepted record member selected by immutable composite/member identity.
    RecordMember {
        composite_type_id: u32,
        member_id: u32,
    },

    /// Tuple element selected by accepted composite identity and ordinal.
    TupleElement {
        composite_type_id: u32,
        ordinal: u32,
    },

    /// Transparent accepted newtype boundary.
    Newtype { composite_type_id: u32 },

    /// Selected accepted enum variant.
    EnumVariant { enum_type_id: u32, variant_id: u32 },

    /// List element in admitted order.
    ListElement { index: u32 },

    /// Set element in canonical admitted order.
    SetElement { index: u32 },

    /// Map key in canonical entry order.
    MapEntryKey { index: u32 },

    /// Map value in canonical entry order.
    MapEntryValue { index: u32 },
}

impl fmt::Display for ConstraintValuePathComponent {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::RootField { field_id } => write!(f, "field#{field_id}"),
            Self::RecordMember {
                composite_type_id,
                member_id,
            } => write!(f, "record#{composite_type_id}.member#{member_id}"),
            Self::TupleElement {
                composite_type_id,
                ordinal,
            } => write!(f, "tuple#{composite_type_id}[{ordinal}]"),
            Self::Newtype { composite_type_id } => write!(f, "newtype#{composite_type_id}"),
            Self::EnumVariant {
                enum_type_id,
                variant_id,
            } => write!(f, "enum#{enum_type_id}.variant#{variant_id}"),
            Self::ListElement { index } => write!(f, "list[{index}]"),
            Self::SetElement { index } => write!(f, "set[{index}]"),
            Self::MapEntryKey { index } => write!(f, "map[{index}].key"),
            Self::MapEntryValue { index } => write!(f, "map[{index}].value"),
        }
    }
}

///
/// ConstraintValuePath
///
/// Bounded typed path to the first deterministic failing value occurrence.
///

#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq)]
pub struct ConstraintValuePath {
    components: Vec<ConstraintValuePathComponent>,
}

impl ConstraintValuePath {
    /// Build one already-bounded accepted occurrence path.
    #[must_use]
    pub(crate) const fn new(components: Vec<ConstraintValuePathComponent>) -> Self {
        Self { components }
    }

    /// Borrow the stable accepted components.
    #[must_use]
    pub const fn components(&self) -> &[ConstraintValuePathComponent] {
        self.components.as_slice()
    }
}

impl fmt::Display for ConstraintValuePath {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        for (ordinal, component) in self.components.iter().enumerate() {
            if ordinal != 0 {
                f.write_str("/")?;
            }
            component.fmt(f)?;
        }
        Ok(())
    }
}

///
/// ConstraintDiagnosticContext
///
/// Boundary at which one accepted constraint failure was observed.
/// This distinguishes incoming write rejection from historical validation.
///

#[derive(CandidType, Clone, Copy, Debug, Deserialize, Eq, PartialEq)]
pub enum ConstraintDiagnosticContext {
    /// Integrity verification found invalid already-accepted state.
    Integrity,

    /// Bounded activation validation found an incompatible historical row.
    MigrationValidation,

    /// A new mutation after-image violated accepted admission authority.
    WriteAdmission,
}

impl ConstraintDiagnosticContext {
    /// Borrow the stable public label for this diagnostic context.
    #[must_use]
    pub const fn as_str(self) -> &'static str {
        match self {
            Self::Integrity => "integrity",
            Self::MigrationValidation => "migration_validation",
            Self::WriteAdmission => "write_admission",
        }
    }
}

///
/// ConstraintDiagnostic
///
/// One bounded accepted-constraint failure carried through runtime and SQL
/// boundaries. It is a projection of accepted identity, not a second schema
/// authority, and its compact error code remains the classification owner.
///

#[derive(CandidType, Clone, Debug, Deserialize, Eq, PartialEq)]
pub struct ConstraintDiagnostic {
    constraint_id: u32,
    constraint_name: String,
    constraint_kind: ConstraintDiagnosticKind,
    entity: String,
    primary_key: Option<Vec<u8>>,
    field_paths: Vec<String>,
    value_path: Option<Box<ConstraintValuePath>>,
    context: ConstraintDiagnosticContext,
    error_code: u16,
}

impl ConstraintDiagnostic {
    /// Build one incoming-write accepted constraint violation.
    #[must_use]
    pub(crate) const fn write_violation(
        constraint_id: u32,
        constraint_name: String,
        constraint_kind: ConstraintDiagnosticKind,
        entity: String,
        primary_key: Option<Vec<u8>>,
        field_paths: Vec<String>,
    ) -> Self {
        Self {
            constraint_id,
            constraint_name,
            constraint_kind,
            entity,
            primary_key,
            field_paths,
            value_path: None,
            context: ConstraintDiagnosticContext::WriteAdmission,
            error_code: diagnostic_code::ErrorCode::RUNTIME_BOUNDARY_CONSTRAINT_VIOLATION.raw(),
        }
    }

    /// Build one incoming-write targeted-rule violation.
    #[must_use]
    pub(crate) fn write_targeted_rule_violation(
        constraint_id: u32,
        constraint_name: String,
        entity: String,
        primary_key: Option<Vec<u8>>,
        field_paths: Vec<String>,
        value_path: ConstraintValuePath,
    ) -> Self {
        Self {
            constraint_id,
            constraint_name,
            constraint_kind: ConstraintDiagnosticKind::TargetedRule,
            entity,
            primary_key,
            field_paths,
            value_path: Some(Box::new(value_path)),
            context: ConstraintDiagnosticContext::WriteAdmission,
            error_code: diagnostic_code::ErrorCode::RUNTIME_BOUNDARY_CONSTRAINT_VIOLATION.raw(),
        }
    }

    /// Build one incoming-write activation barrier rejection.
    #[must_use]
    pub(crate) const fn write_activation_blocked(
        constraint_id: u32,
        constraint_name: String,
        constraint_kind: ConstraintDiagnosticKind,
        entity: String,
        primary_key: Option<Vec<u8>>,
        field_paths: Vec<String>,
    ) -> Self {
        Self {
            constraint_id,
            constraint_name,
            constraint_kind,
            entity,
            primary_key,
            field_paths,
            value_path: None,
            context: ConstraintDiagnosticContext::WriteAdmission,
            error_code:
                diagnostic_code::ErrorCode::RUNTIME_BOUNDARY_CONSTRAINT_ACTIVATION_WRITE_BLOCKED
                    .raw(),
        }
    }

    /// Build one historical activation finding from its durable compact code.
    #[must_use]
    pub(crate) const fn migration_validation(
        constraint_id: u32,
        constraint_name: String,
        constraint_kind: ConstraintDiagnosticKind,
        entity: String,
        primary_key: Vec<u8>,
        field_paths: Vec<String>,
        error_code: u16,
    ) -> Self {
        Self {
            constraint_id,
            constraint_name,
            constraint_kind,
            entity,
            primary_key: Some(primary_key),
            field_paths,
            value_path: None,
            context: ConstraintDiagnosticContext::MigrationValidation,
            error_code,
        }
    }

    /// Build one historical targeted-rule finding with durable path evidence.
    #[must_use]
    pub(crate) fn migration_targeted_rule_validation(
        constraint_id: u32,
        constraint_name: String,
        entity: String,
        primary_key: Vec<u8>,
        field_paths: Vec<String>,
        value_path: ConstraintValuePath,
        error_code: u16,
    ) -> Self {
        Self {
            constraint_id,
            constraint_name,
            constraint_kind: ConstraintDiagnosticKind::TargetedRule,
            entity,
            primary_key: Some(primary_key),
            field_paths,
            value_path: Some(Box::new(value_path)),
            context: ConstraintDiagnosticContext::MigrationValidation,
            error_code,
        }
    }

    /// Return the stable accepted constraint identity.
    #[must_use]
    pub const fn constraint_id(&self) -> u32 {
        self.constraint_id
    }

    /// Borrow the stable accepted constraint name.
    #[must_use]
    pub const fn constraint_name(&self) -> &str {
        self.constraint_name.as_str()
    }

    /// Return the accepted constraint family.
    #[must_use]
    pub const fn constraint_kind(&self) -> ConstraintDiagnosticKind {
        self.constraint_kind
    }

    /// Borrow the accepted entity identity.
    #[must_use]
    pub const fn entity(&self) -> &str {
        self.entity.as_str()
    }

    /// Borrow the canonical persisted primary-key bytes when available.
    #[must_use]
    pub fn primary_key(&self) -> Option<&[u8]> {
        self.primary_key.as_deref()
    }

    /// Borrow bounded accepted field paths implicated by the failure.
    #[must_use]
    pub const fn field_paths(&self) -> &[String] {
        self.field_paths.as_slice()
    }

    /// Borrow the typed concrete value path for a targeted-rule violation.
    #[must_use]
    pub fn value_path(&self) -> Option<&ConstraintValuePath> {
        self.value_path.as_deref()
    }

    /// Return the boundary that observed the failure.
    #[must_use]
    pub const fn context(&self) -> ConstraintDiagnosticContext {
        self.context
    }

    /// Return the compact stable error code for this exact failure.
    #[must_use]
    pub const fn error_code(&self) -> diagnostic_code::ErrorCode {
        diagnostic_code::ErrorCode::from_raw(self.error_code)
    }

    /// Return the broad public error class derived from the compact code.
    #[must_use]
    pub const fn error_class(&self) -> diagnostic_code::ErrorClass {
        self.error_code().class()
    }
}

///
/// ErrorDetail
///
/// Structured, origin-specific error detail carried by [`InternalError`].
/// This enum is intentionally extensible.
///

pub enum ErrorDetail {
    /// Executor-owned mutation and query execution details.
    Executor(ExecutorErrorDetail),
    Store(StoreError),
    Query(QueryErrorDetail),
    Recovery(RecoveryErrorDetail),
    /// Persisted-row serialization and decoding details.
    Serialize(SerializeErrorDetail),
    // Future-proofing:
    // Index(IndexError),
}

/// Executor-specific structured error detail.
pub enum ExecutorErrorDetail {
    /// A complete insert or replacement omitted one or more required fields.
    MutationRequiredFieldMissing,
    /// A logical mutation would move accepted managed time backward.
    MutationManagedTimestampRegression,
    /// A caller explicitly authored a field owned by accepted database policy.
    MutationDatabaseOwnedFieldExplicit,
    /// A mixed structural mutation batch contained no operations.
    MutationBatchEmpty,
    /// A mixed structural mutation batch exceeded its operation-count bound.
    MutationBatchTooManyItems,
    /// A mixed structural mutation batch exceeded its staged-byte bound.
    MutationBatchStagedBytesExceeded,
    /// A mixed structural mutation result exceeded its encoded response bound.
    MutationBatchResultBytesExceeded,
    /// A mixed structural mutation batch resolved to more than one accepted entity.
    MutationBatchEntityMismatch,
    /// More than one mixed structural operation targeted the same accepted key.
    MutationBatchDuplicateKey,
    /// A final canonical after-image violated one accepted constraint or activation gate.
    ConstraintViolation {
        diagnostic: Box<ConstraintDiagnostic>,
    },
    /// Accepted row-constraint metadata or compiled state was inconsistent.
    AcceptedRowConstraintProgramCorrupt,
    /// A write would rely on one incomplete activation-owned physical proof.
    ConstraintActivationWriteBlocked {
        diagnostic: Box<ConstraintDiagnostic>,
    },
}

impl ExecutorErrorDetail {
    /// Borrow the accepted constraint diagnostic carried by this failure.
    #[must_use]
    pub fn constraint_diagnostic(&self) -> Option<&ConstraintDiagnostic> {
        match self {
            Self::ConstraintActivationWriteBlocked { diagnostic }
            | Self::ConstraintViolation { diagnostic } => Some(diagnostic.as_ref()),
            Self::MutationRequiredFieldMissing
            | Self::MutationManagedTimestampRegression
            | Self::MutationDatabaseOwnedFieldExplicit
            | Self::MutationBatchEmpty
            | Self::MutationBatchTooManyItems
            | Self::MutationBatchStagedBytesExceeded
            | Self::MutationBatchResultBytesExceeded
            | Self::MutationBatchEntityMismatch
            | Self::MutationBatchDuplicateKey
            | Self::AcceptedRowConstraintProgramCorrupt => None,
        }
    }
}

/// Persisted-row serialization and decoding error detail.
pub enum SerializeErrorDetail {
    /// The row stamp is older or newer than the accepted layout window.
    PersistedRowLayoutOutsideAcceptedWindow,

    /// The physical slot count does not match the row's stamped layout.
    PersistedRowSlotCountMismatch,
}

///
/// RecoveryErrorDetail
///
/// Recovery-origin structured error detail payload.
///

pub enum RecoveryErrorDetail {
    UnsupportedFormatVersion { found: Option<u16>, required: u16 },

    MalformedFormatMarker { reason: RecoveryFormatMarkerError },
}

/// Store boot-marker corruption classification.
#[derive(Clone, Copy, Eq, PartialEq)]
pub enum RecoveryFormatMarkerError {
    Magic,
    Checksum,
    State,
}

///
/// StoreError
///
/// Store-specific structured error detail.
/// Never returned directly; always wrapped in [`ErrorDetail::Store`].
///

pub enum StoreError {
    NotFound,

    Corrupt,

    InvariantViolation,

    SchemaDdlPublicationRaceLost,

    SchemaDdlRewriteRequiresMigration,

    SchemaRowLayoutVersionExhausted,

    JournalMutationRevisionExhausted,

    SchemaTransitionBudgetExceeded {
        resource: SchemaTransitionBudgetResource,
    },

    /// A generated field would collide with an accepted DDL-owned slot.
    SchemaGeneratedFieldAfterDdlField,

    /// A live generated constraint activation no longer matches its proposal.
    SchemaGeneratedConstraintActivationStale,
}

///
/// QueryErrorDetail
///
/// Query-origin structured error detail payload.
///

pub enum QueryErrorDetail {
    NumericOverflow,

    NumericNotRepresentable,

    UnsupportedSqlFeature {
        feature: diagnostic_code::SqlFeatureCode,
    },

    SqlLowering {
        reason: diagnostic_code::SqlLoweringCode,
    },

    UnsupportedProjection {
        reason: diagnostic_code::QueryProjectionCode,
    },

    UnknownAggregateTargetField,

    ResultShapeMismatch {
        reason: diagnostic_code::QueryResultShapeCode,
    },

    QueryReadAdmission {
        reason: diagnostic_code::QueryReadAdmissionCode,
    },

    SqlSurfaceMismatch {
        mismatch: diagnostic_code::SqlSurfaceMismatchCode,
    },

    SqlWriteBoundary {
        boundary: diagnostic_code::SqlWriteBoundaryCode,
    },

    SchemaDdlAdmission {
        error: SchemaDdlAdmissionError,
    },

    StaleSchemaRevision,
}

impl fmt::Display for QueryErrorDetail {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(COMPACT_QUERY_DIAGNOSTIC_MESSAGE)
    }
}

impl std::error::Error for QueryErrorDetail {}

///
/// SchemaTransitionBudgetResource
///
/// Query-visible identity of the exact schema-transition resource cap that
/// rejected a complete validation or derived-state stage.
///

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum SchemaTransitionBudgetResource {
    /// Number of physical deletion keys retained for replacement.
    DeletionKeys,
    /// Number of row-derived projection entries retained for validation.
    ProjectionEntries,
    /// Deterministic projection and physical-classification work units.
    ProjectionWorkUnits,
    /// Number of authoritative source rows.
    SourceRows,
    /// Cumulative bytes of authoritative source rows.
    SourceRowBytes,
    /// Retained raw payloads plus deterministic-sort workspace bytes.
    StagedRawBytes,
}

///
/// SchemaDdlAdmissionError
///
/// Stable query-visible SQL DDL admission reason. Human diagnostics may carry
/// extra version, fingerprint, and target facts beside this machine-readable
/// variant.
///

#[derive(Clone, Copy, Eq, PartialEq)]
pub enum SchemaDdlAdmissionError {
    MissingExpectedSchemaVersion,

    MissingNextSchemaVersion,

    StaleExpectedSchemaVersion,

    InvalidExpectedSchemaVersion,

    InvalidNextSchemaVersion,

    AcceptedSchemaChangeWithoutVersionBump,

    EmptyVersionBump,

    VersionGap,

    VersionRollback,

    FingerprintMethodMismatch,

    UnsupportedTransitionClass,

    PhysicalRunnerMissing,

    ValidationFailed,

    PublicationRaceLost,

    InvalidAddColumnDefault,

    InvalidAlterColumnDefault,

    RowLayoutVersionExhausted,

    GeneratedIndexDropRejected,

    SchemaRewriteRequiresMigration,

    SchemaTransitionBudgetExceeded {
        resource: SchemaTransitionBudgetResource,
    },

    GeneratedFieldDefaultChangeRejected,

    GeneratedFieldNullabilityChangeRejected,
}

impl fmt::Display for SchemaDdlAdmissionError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.write_str(COMPACT_QUERY_DIAGNOSTIC_MESSAGE)
    }
}

impl std::error::Error for SchemaDdlAdmissionError {}

impl fmt::Debug for ErrorDetail {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt_compact_diagnostic(f, self.diagnostic_code(), self.diagnostic_detail())
    }
}

impl fmt::Debug for ExecutorErrorDetail {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt_compact_diagnostic(f, self.diagnostic_code(), self.diagnostic_detail())
    }
}

impl fmt::Debug for StoreError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt_compact_diagnostic(f, self.diagnostic_code(), self.diagnostic_detail())
    }
}

impl fmt::Debug for QueryErrorDetail {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt_compact_diagnostic(f, self.diagnostic_code(), self.diagnostic_detail())
    }
}

impl fmt::Debug for RecoveryErrorDetail {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt_compact_diagnostic(f, self.diagnostic_code(), self.diagnostic_detail())
    }
}

impl fmt::Debug for SerializeErrorDetail {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt_compact_diagnostic(f, self.diagnostic_code(), self.diagnostic_detail())
    }
}

impl fmt::Debug for RecoveryFormatMarkerError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt_compact_diagnostic(
            f,
            diagnostic_code::DiagnosticCode::RuntimeCorruption,
            Some(diagnostic_code::DiagnosticDetail::RuntimeKind {
                kind: diagnostic_code::RuntimeErrorKind::Corruption,
            }),
        )
    }
}

impl fmt::Debug for SchemaDdlAdmissionError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        fmt_compact_diagnostic(
            f,
            diagnostic_code::DiagnosticCode::SchemaDdlAdmission,
            Some(diagnostic_code::DiagnosticDetail::SchemaDdlAdmission {
                reason: self.diagnostic_code(),
            }),
        )
    }
}

fn fmt_compact_diagnostic(
    f: &mut fmt::Formatter<'_>,
    code: diagnostic_code::DiagnosticCode,
    detail: Option<diagnostic_code::DiagnosticDetail>,
) -> fmt::Result {
    write!(
        f,
        "{}",
        diagnostic_code::ErrorCode::from_parts(code, detail).raw()
    )
}

impl ErrorDetail {
    /// Return the compact diagnostic code for this structured detail.
    #[must_use]
    pub const fn diagnostic_code(&self) -> diagnostic_code::DiagnosticCode {
        match self {
            Self::Executor(error) => error.diagnostic_code(),
            Self::Store(error) => error.diagnostic_code(),
            Self::Query(error) => error.diagnostic_code(),
            Self::Recovery(error) => error.diagnostic_code(),
            Self::Serialize(error) => error.diagnostic_code(),
        }
    }

    /// Return compact structured diagnostic detail when the payload carries one.
    #[must_use]
    pub const fn diagnostic_detail(&self) -> Option<diagnostic_code::DiagnosticDetail> {
        match self {
            Self::Executor(error) => error.diagnostic_detail(),
            Self::Store(error) => error.diagnostic_detail(),
            Self::Query(error) => error.diagnostic_detail(),
            Self::Recovery(error) => error.diagnostic_detail(),
            Self::Serialize(error) => error.diagnostic_detail(),
        }
    }
}

impl ExecutorErrorDetail {
    /// Return the compact diagnostic code for this executor detail.
    #[must_use]
    pub const fn diagnostic_code(&self) -> diagnostic_code::DiagnosticCode {
        match self {
            Self::MutationRequiredFieldMissing
            | Self::MutationDatabaseOwnedFieldExplicit
            | Self::MutationBatchEmpty
            | Self::MutationBatchTooManyItems
            | Self::MutationBatchStagedBytesExceeded
            | Self::MutationBatchResultBytesExceeded => {
                diagnostic_code::DiagnosticCode::RuntimeUnsupported
            }
            Self::MutationBatchEntityMismatch | Self::MutationBatchDuplicateKey => {
                diagnostic_code::DiagnosticCode::RuntimeConflict
            }
            Self::MutationManagedTimestampRegression => {
                diagnostic_code::DiagnosticCode::RuntimeInvariantViolation
            }
            Self::ConstraintViolation { diagnostic }
            | Self::ConstraintActivationWriteBlocked { diagnostic } => {
                diagnostic.error_code().diagnostic_code()
            }
            Self::AcceptedRowConstraintProgramCorrupt => {
                diagnostic_code::DiagnosticCode::RuntimeCorruption
            }
        }
    }

    /// Return compact structured diagnostic detail for this executor detail.
    #[must_use]
    pub const fn diagnostic_detail(&self) -> Option<diagnostic_code::DiagnosticDetail> {
        match self {
            Self::MutationRequiredFieldMissing => {
                Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                    boundary: diagnostic_code::RuntimeBoundaryCode::MutationRequiredFieldMissing,
                })
            }
            Self::MutationDatabaseOwnedFieldExplicit => {
                Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                    boundary:
                        diagnostic_code::RuntimeBoundaryCode::MutationDatabaseOwnedFieldExplicit,
                })
            }
            Self::MutationBatchEmpty => Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                boundary: diagnostic_code::RuntimeBoundaryCode::MutationBatchEmpty,
            }),
            Self::MutationBatchTooManyItems => {
                Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                    boundary: diagnostic_code::RuntimeBoundaryCode::MutationBatchTooManyItems,
                })
            }
            Self::MutationBatchStagedBytesExceeded => {
                Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                    boundary:
                        diagnostic_code::RuntimeBoundaryCode::MutationBatchStagedBytesExceeded,
                })
            }
            Self::MutationBatchResultBytesExceeded => {
                Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                    boundary:
                        diagnostic_code::RuntimeBoundaryCode::MutationBatchResultBytesExceeded,
                })
            }
            Self::MutationBatchEntityMismatch => {
                Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                    boundary: diagnostic_code::RuntimeBoundaryCode::MutationBatchEntityMismatch,
                })
            }
            Self::MutationBatchDuplicateKey => {
                Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                    boundary: diagnostic_code::RuntimeBoundaryCode::MutationBatchDuplicateKey,
                })
            }
            Self::MutationManagedTimestampRegression => {
                Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                    boundary:
                        diagnostic_code::RuntimeBoundaryCode::MutationManagedTimestampRegression,
                })
            }
            Self::ConstraintViolation { diagnostic }
            | Self::ConstraintActivationWriteBlocked { diagnostic } => {
                diagnostic.error_code().diagnostic_detail()
            }
            Self::AcceptedRowConstraintProgramCorrupt => {
                Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                    boundary:
                        diagnostic_code::RuntimeBoundaryCode::AcceptedRowConstraintProgramCorrupt,
                })
            }
        }
    }
}

impl RecoveryErrorDetail {
    /// Return the compact diagnostic code for this recovery detail.
    #[must_use]
    pub const fn diagnostic_code(&self) -> diagnostic_code::DiagnosticCode {
        match self {
            Self::UnsupportedFormatVersion { .. } => {
                diagnostic_code::DiagnosticCode::RuntimeIncompatiblePersistedFormat
            }
            Self::MalformedFormatMarker { .. } => {
                diagnostic_code::DiagnosticCode::RuntimeCorruption
            }
        }
    }

    /// Return compact structured diagnostic detail for this recovery detail.
    #[must_use]
    pub const fn diagnostic_detail(&self) -> Option<diagnostic_code::DiagnosticDetail> {
        let kind = match self {
            Self::UnsupportedFormatVersion { .. } => {
                diagnostic_code::RuntimeErrorKind::IncompatiblePersistedFormat
            }
            Self::MalformedFormatMarker { .. } => diagnostic_code::RuntimeErrorKind::Corruption,
        };

        Some(diagnostic_code::DiagnosticDetail::RuntimeKind { kind })
    }
}

impl SerializeErrorDetail {
    /// Return the compact diagnostic code for this serialization detail.
    #[must_use]
    pub const fn diagnostic_code(&self) -> diagnostic_code::DiagnosticCode {
        match self {
            Self::PersistedRowLayoutOutsideAcceptedWindow | Self::PersistedRowSlotCountMismatch => {
                diagnostic_code::DiagnosticCode::RuntimeCorruption
            }
        }
    }

    /// Return compact structured diagnostic detail for this serialization detail.
    #[must_use]
    pub const fn diagnostic_detail(&self) -> Option<diagnostic_code::DiagnosticDetail> {
        let boundary = match self {
            Self::PersistedRowLayoutOutsideAcceptedWindow => {
                diagnostic_code::RuntimeBoundaryCode::PersistedRowLayoutOutsideAcceptedWindow
            }
            Self::PersistedRowSlotCountMismatch => {
                diagnostic_code::RuntimeBoundaryCode::PersistedRowSlotCountMismatch
            }
        };

        Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary { boundary })
    }
}

impl StoreError {
    /// Return the compact diagnostic code for this store detail.
    #[must_use]
    pub const fn diagnostic_code(&self) -> diagnostic_code::DiagnosticCode {
        match self {
            Self::NotFound => diagnostic_code::DiagnosticCode::StoreNotFound,
            Self::Corrupt => diagnostic_code::DiagnosticCode::StoreCorruption,
            Self::InvariantViolation => diagnostic_code::DiagnosticCode::StoreInvariantViolation,
            Self::SchemaDdlPublicationRaceLost
            | Self::SchemaDdlRewriteRequiresMigration
            | Self::SchemaRowLayoutVersionExhausted
            | Self::SchemaTransitionBudgetExceeded { .. } => {
                diagnostic_code::DiagnosticCode::SchemaDdlAdmission
            }
            Self::JournalMutationRevisionExhausted | Self::SchemaGeneratedFieldAfterDdlField => {
                diagnostic_code::DiagnosticCode::RuntimeUnsupported
            }
            Self::SchemaGeneratedConstraintActivationStale => {
                diagnostic_code::DiagnosticCode::RuntimeConflict
            }
        }
    }

    /// Return compact structured diagnostic detail when the store error has one.
    #[must_use]
    pub const fn diagnostic_detail(&self) -> Option<diagnostic_code::DiagnosticDetail> {
        match self {
            Self::SchemaDdlPublicationRaceLost => {
                Some(diagnostic_code::DiagnosticDetail::SchemaDdlAdmission {
                    reason: diagnostic_code::SchemaDdlAdmissionCode::PublicationRaceLost,
                })
            }
            Self::SchemaDdlRewriteRequiresMigration => {
                Some(diagnostic_code::DiagnosticDetail::SchemaDdlAdmission {
                    reason: diagnostic_code::SchemaDdlAdmissionCode::SchemaRewriteRequiresMigration,
                })
            }
            Self::SchemaRowLayoutVersionExhausted => {
                Some(diagnostic_code::DiagnosticDetail::SchemaDdlAdmission {
                    reason: diagnostic_code::SchemaDdlAdmissionCode::RowLayoutVersionExhausted,
                })
            }
            Self::JournalMutationRevisionExhausted => {
                Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                    boundary:
                        diagnostic_code::RuntimeBoundaryCode::JournalMutationRevisionExhausted,
                })
            }
            Self::SchemaTransitionBudgetExceeded { .. } => {
                Some(diagnostic_code::DiagnosticDetail::SchemaDdlAdmission {
                    reason: diagnostic_code::SchemaDdlAdmissionCode::SchemaTransitionBudgetExceeded,
                })
            }
            Self::SchemaGeneratedFieldAfterDdlField => {
                Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                    boundary: diagnostic_code::RuntimeBoundaryCode::GeneratedFieldAfterDdlField,
                })
            }
            Self::SchemaGeneratedConstraintActivationStale => {
                Some(diagnostic_code::DiagnosticDetail::RuntimeBoundary {
                    boundary:
                        diagnostic_code::RuntimeBoundaryCode::GeneratedConstraintActivationStale,
                })
            }
            Self::NotFound | Self::Corrupt | Self::InvariantViolation => None,
        }
    }
}

impl QueryErrorDetail {
    /// Return the compact diagnostic code for this query detail.
    #[must_use]
    pub const fn diagnostic_code(&self) -> diagnostic_code::DiagnosticCode {
        match self {
            Self::NumericOverflow => diagnostic_code::DiagnosticCode::QueryNumericOverflow,
            Self::NumericNotRepresentable => {
                diagnostic_code::DiagnosticCode::QueryNumericNotRepresentable
            }
            Self::UnsupportedSqlFeature { .. } => {
                diagnostic_code::DiagnosticCode::QueryUnsupportedSqlFeature
            }
            Self::SqlLowering { .. } => diagnostic_code::DiagnosticCode::QueryUnsupportedSqlFeature,
            Self::UnsupportedProjection { .. } => {
                diagnostic_code::DiagnosticCode::QueryUnsupportedProjection
            }
            Self::UnknownAggregateTargetField => {
                diagnostic_code::DiagnosticCode::QueryUnknownAggregateTargetField
            }
            Self::ResultShapeMismatch { .. } => {
                diagnostic_code::DiagnosticCode::QueryResultShapeMismatch
            }
            Self::QueryReadAdmission { .. } => diagnostic_code::DiagnosticCode::QueryReadAdmission,
            Self::SqlSurfaceMismatch { .. } => {
                diagnostic_code::DiagnosticCode::QuerySqlSurfaceMismatch
            }
            Self::SqlWriteBoundary { .. } => diagnostic_code::DiagnosticCode::QuerySqlWriteBoundary,
            Self::SchemaDdlAdmission { .. } => diagnostic_code::DiagnosticCode::SchemaDdlAdmission,
            Self::StaleSchemaRevision => diagnostic_code::DiagnosticCode::RuntimeConflict,
        }
    }

    /// Return compact structured diagnostic detail when the query detail has one.
    #[must_use]
    pub const fn diagnostic_detail(&self) -> Option<diagnostic_code::DiagnosticDetail> {
        match self {
            Self::UnsupportedSqlFeature { feature } => {
                Some(diagnostic_code::DiagnosticDetail::UnsupportedSqlFeature { feature: *feature })
            }
            Self::SqlLowering { reason } => {
                Some(diagnostic_code::DiagnosticDetail::SqlLowering { reason: *reason })
            }
            Self::UnsupportedProjection { reason } => {
                Some(diagnostic_code::DiagnosticDetail::QueryProjection { reason: *reason })
            }
            Self::ResultShapeMismatch { reason } => {
                Some(diagnostic_code::DiagnosticDetail::QueryResultShape { reason: *reason })
            }
            Self::QueryReadAdmission { reason } => {
                Some(diagnostic_code::DiagnosticDetail::QueryReadAdmission { reason: *reason })
            }
            Self::SqlSurfaceMismatch { mismatch } => {
                Some(diagnostic_code::DiagnosticDetail::SqlSurfaceMismatch {
                    mismatch: *mismatch,
                })
            }
            Self::SqlWriteBoundary { boundary } => {
                Some(diagnostic_code::DiagnosticDetail::SqlWriteBoundary {
                    boundary: *boundary,
                })
            }
            Self::SchemaDdlAdmission { error } => {
                Some(diagnostic_code::DiagnosticDetail::SchemaDdlAdmission {
                    reason: error.diagnostic_code(),
                })
            }
            Self::NumericOverflow
            | Self::NumericNotRepresentable
            | Self::UnknownAggregateTargetField
            | Self::StaleSchemaRevision => None,
        }
    }
}

impl SchemaDdlAdmissionError {
    /// Return the compact diagnostic code for this SQL DDL admission reason.
    #[must_use]
    pub const fn diagnostic_code(&self) -> diagnostic_code::SchemaDdlAdmissionCode {
        match self {
            Self::MissingExpectedSchemaVersion => {
                diagnostic_code::SchemaDdlAdmissionCode::MissingExpectedSchemaVersion
            }
            Self::MissingNextSchemaVersion => {
                diagnostic_code::SchemaDdlAdmissionCode::MissingNextSchemaVersion
            }
            Self::StaleExpectedSchemaVersion => {
                diagnostic_code::SchemaDdlAdmissionCode::StaleExpectedSchemaVersion
            }
            Self::InvalidExpectedSchemaVersion => {
                diagnostic_code::SchemaDdlAdmissionCode::InvalidExpectedSchemaVersion
            }
            Self::InvalidNextSchemaVersion => {
                diagnostic_code::SchemaDdlAdmissionCode::InvalidNextSchemaVersion
            }
            Self::AcceptedSchemaChangeWithoutVersionBump => {
                diagnostic_code::SchemaDdlAdmissionCode::AcceptedSchemaChangeWithoutVersionBump
            }
            Self::EmptyVersionBump => diagnostic_code::SchemaDdlAdmissionCode::EmptyVersionBump,
            Self::VersionGap => diagnostic_code::SchemaDdlAdmissionCode::VersionGap,
            Self::VersionRollback => diagnostic_code::SchemaDdlAdmissionCode::VersionRollback,
            Self::FingerprintMethodMismatch => {
                diagnostic_code::SchemaDdlAdmissionCode::FingerprintMethodMismatch
            }
            Self::UnsupportedTransitionClass => {
                diagnostic_code::SchemaDdlAdmissionCode::UnsupportedTransitionClass
            }
            Self::PhysicalRunnerMissing => {
                diagnostic_code::SchemaDdlAdmissionCode::PhysicalRunnerMissing
            }
            Self::ValidationFailed => diagnostic_code::SchemaDdlAdmissionCode::ValidationFailed,
            Self::PublicationRaceLost => {
                diagnostic_code::SchemaDdlAdmissionCode::PublicationRaceLost
            }
            Self::InvalidAddColumnDefault => {
                diagnostic_code::SchemaDdlAdmissionCode::InvalidAddColumnDefault
            }
            Self::InvalidAlterColumnDefault => {
                diagnostic_code::SchemaDdlAdmissionCode::InvalidAlterColumnDefault
            }
            Self::GeneratedIndexDropRejected => {
                diagnostic_code::SchemaDdlAdmissionCode::GeneratedIndexDropRejected
            }
            Self::SchemaRewriteRequiresMigration => {
                diagnostic_code::SchemaDdlAdmissionCode::SchemaRewriteRequiresMigration
            }
            Self::SchemaTransitionBudgetExceeded { .. } => {
                diagnostic_code::SchemaDdlAdmissionCode::SchemaTransitionBudgetExceeded
            }
            Self::GeneratedFieldDefaultChangeRejected => {
                diagnostic_code::SchemaDdlAdmissionCode::GeneratedFieldDefaultChangeRejected
            }
            Self::GeneratedFieldNullabilityChangeRejected => {
                diagnostic_code::SchemaDdlAdmissionCode::GeneratedFieldNullabilityChangeRejected
            }
            Self::RowLayoutVersionExhausted => {
                diagnostic_code::SchemaDdlAdmissionCode::RowLayoutVersionExhausted
            }
        }
    }
}

///
/// ErrorClass
/// Internal error taxonomy for runtime classification.
/// Not a stable API; may change without notice.
///

#[repr(u8)]
#[derive(Clone, Copy, Eq, PartialEq)]
pub enum ErrorClass {
    Corruption,
    IncompatiblePersistedFormat,
    NotFound,
    Internal,
    Conflict,
    Unsupported,
    InvariantViolation,
}

impl ErrorClass {
    /// Return a compact diagnostic code for this broad class and origin pair.
    #[must_use]
    pub const fn diagnostic_code(self, origin: ErrorOrigin) -> diagnostic_code::DiagnosticCode {
        match self {
            Self::Corruption if matches!(origin, ErrorOrigin::Store) => {
                diagnostic_code::DiagnosticCode::StoreCorruption
            }
            Self::Corruption => diagnostic_code::DiagnosticCode::RuntimeCorruption,
            Self::IncompatiblePersistedFormat => {
                diagnostic_code::DiagnosticCode::RuntimeIncompatiblePersistedFormat
            }
            Self::NotFound if matches!(origin, ErrorOrigin::Store) => {
                diagnostic_code::DiagnosticCode::StoreNotFound
            }
            Self::NotFound => diagnostic_code::DiagnosticCode::RuntimeNotFound,
            Self::Internal => diagnostic_code::DiagnosticCode::RuntimeInternal,
            Self::Conflict => diagnostic_code::DiagnosticCode::RuntimeConflict,
            Self::Unsupported if matches!(origin, ErrorOrigin::Cursor) => {
                diagnostic_code::DiagnosticCode::QueryInvalidContinuationCursor
            }
            Self::Unsupported => diagnostic_code::DiagnosticCode::RuntimeUnsupported,
            Self::InvariantViolation if matches!(origin, ErrorOrigin::Store) => {
                diagnostic_code::DiagnosticCode::StoreInvariantViolation
            }
            Self::InvariantViolation => diagnostic_code::DiagnosticCode::RuntimeInvariantViolation,
        }
    }
}

impl fmt::Debug for ErrorClass {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", *self as u8)
    }
}

///
/// ErrorOrigin
/// Internal origin taxonomy for runtime classification.
/// Not a stable API; may change without notice.
///

#[repr(u8)]
#[derive(Clone, Copy, Eq, PartialEq)]
pub enum ErrorOrigin {
    Serialize,
    Store,
    Index,
    Identity,
    Query,
    Planner,
    Cursor,
    Recovery,
    Response,
    Executor,
    Interface,
}

impl ErrorOrigin {
    /// Return the compact diagnostic origin for this internal origin.
    #[must_use]
    pub const fn diagnostic_origin(self) -> diagnostic_code::ErrorOrigin {
        match self {
            Self::Serialize => diagnostic_code::ErrorOrigin::Serialize,
            Self::Store => diagnostic_code::ErrorOrigin::Store,
            Self::Index => diagnostic_code::ErrorOrigin::Index,
            Self::Identity => diagnostic_code::ErrorOrigin::Identity,
            Self::Query => diagnostic_code::ErrorOrigin::Query,
            Self::Planner => diagnostic_code::ErrorOrigin::Planner,
            Self::Cursor => diagnostic_code::ErrorOrigin::Cursor,
            Self::Recovery => diagnostic_code::ErrorOrigin::Recovery,
            Self::Response => diagnostic_code::ErrorOrigin::Response,
            Self::Executor => diagnostic_code::ErrorOrigin::Executor,
            Self::Interface => diagnostic_code::ErrorOrigin::Interface,
        }
    }
}

impl fmt::Debug for ErrorOrigin {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", *self as u8)
    }
}