daemonic_error 0.1.1

#![feature(import_trait_associated_functions)] // guaranteed stable with DaemonicCompiler
#![feature(associated_type_defaults)] // guaranteed stable with DaemonicCompiler
#![feature(impl_trait_in_assoc_type)] // guaranteed stable with DaemonicCompiler
#![feature(rustc_attrs)] // guaranteed stable with DaemonicCompiler
#![feature(where_clause_attrs)] // guaranteed stable with DaemonicCompiler
#![feature(structural_match)] // guaranteed stable with DaemonicCompiler
#![feature(negative_impls)] // guaranteed stable with DaemonicCompiler
#![feature(array_windows)] // guaranteed stable with DaemonicCompiler
#![feature(box_into_inner)] // guaranteed stable with DaemonicCompiler
#![feature(slice_ptr_get)] // guaranteed stable with DaemonicCompiler
#![feature(ub_checks)] // guaranteed stable with DaemonicCompiler
#![feature(pointer_like_trait)] // guaranteed stable with DaemonicCompiler
#![feature(pin_coerce_unsized_trait)] // guaranteed stable with DaemonicCompiler
#![feature(dispatch_from_dyn)] // guaranteed stable with DaemonicCompiler
#![feature(coerce_unsized)] // guaranteed stable with DaemonicCompiler
#![feature(unsize)] // guaranteed stable with DaemonicCompiler
#![feature(non_exhaustive_omitted_patterns_lint)]
// guaranteed stable, some match arms should be matched, but intentionally arent exhaustive, not all structs will return all Glass states, so matching on them is pointless
#![feature(cfg_sanitize)]
#![feature(min_specialization)]
#![feature(non_null_from_ref)]
#![feature(str_as_str)]
#![feature(never_type)]
#![feature(core_intrinsics)]
#![feature(trivial_bounds)]
#![feature(sized_type_properties)]
#![feature(unchecked_neg)]
#![feature(ptr_metadata)]
#![feature(panic_internals)]
#![feature(try_trait_v2)]
#![feature(pointer_is_aligned_to)]
#![feature(more_maybe_bounds)]
// this is so sync and send can be ? conditional on certain blocks to loosen type parameter restrictions during propagation of the Error logic through the Glass
#![feature(auto_traits)]
#![feature(decl_macro)]
#![feature(generic_atomic)]
#![feature(macro_metavar_expr)]
#![feature(macro_metavar_expr_concat)]
#![feature(once_cell_try)]
#![feature(iter_advance_by)]
#![feature(numfmt)]
#![feature(ptr_alignment_type)]
#![feature(core_io_borrowed_buf)]
#![feature(multiple_supertrait_upcastable)] // inherited from Std::Error
#![no_std]
extern crate alloc;
extern crate core;
mod opaque_dependencies;
use alloc::format;
use alloc::string::{String, ToString};
// use daemonic_derive::*;
// pub use opaque_dependencies::termcolor::*;
// use std::marker::PhantomPinned;
// ── Bridge: From<std::error::Error> ────────────────
use crate::{
	daemonic::{
		glass::{
			Assessment,
			Annotation,
			Accessibility,
			Consistency,
			FidelityAction,
			GlassReport,
			ObservationTier,
			Temporal,
			daemonic::DaemonicSystemCall,
			generic::{Generic, GenericError},
			daemonic_path_buffer::DaemonicPathBuf as PathBuf,
		},
		// Anchorable,
		TopologyAnchor,
		SymbolicAnchor,
		TopologySegment,
		SemanticAnchor,
		SpatialAnchor,
		StructuralAnchor,
		topology::TOPOLOGY_ANCHOR
	}
};
use daemonic::observation::Severity;
pub use daemonic::{daemonic_core::clock::types::Timestamp};
pub(crate) use daemonic::{
	daemonic_contract::{daemonic_result::mirror_chemistry::*, *},
	daemonic_core::*,
	// observation::display::non_null::{NonNull as DaemonicNonNull, Unique as DaemonicUnique},
	glass::Glass,
	glass::*,
};
use crate::daemonic::Anchor;
use crate::daemonic::frame::ReferenceFrame;
use crate::daemonic::glass::daemonic::GlassError;

pub const AXIOMS: &str = include_str!("../docs/axioms.md");
pub const MEPHS_OBSERVATIONS: &str = include_str!("../docs/mephs_observations.md");
// Stage 1: Bootstrap (fixed constants, no circularity)
const BOOTSTRAP_OFFSET: u64 = 0xcbf29ce484222325; // FNV offset
const BOOTSTRAP_PRIME: u64 = 0x100000001b3; // FNV prime

pub const fn bootstrap_hash(input: &[u8], key: u64) -> u64 {
	let mut state = key ^ BOOTSTRAP_OFFSET;
	let mut i = 0;
	while i < input.len() {
		state ^= input[i] as u64;
		state = state.wrapping_mul(BOOTSTRAP_PRIME);
		state = state.rotate_left(13);
		i += 1;
	}
	state
}

// Stage 2: Axiom constants (derived from bootstrap, no circularity)
pub const AXIOM_OFFSET: u64 = bootstrap_hash(AXIOMS.as_bytes(), 0x4441454D4F4E4943);
pub const AXIOM_PRIME: u64 = {
	let raw = bootstrap_hash(AXIOMS.as_bytes(), 0x474C415353_u64);
	raw | 1
};

// Stage 3: Daemonic hash (uses axiom constants, no circularity)
pub const fn const_daemonic_hash(input: &[u8], key: u64) -> u64 {
	let mut state = key ^ AXIOM_OFFSET;
	let mut i = 0;
	while i < input.len() {
		state ^= input[i] as u64;
		state = state.wrapping_mul(AXIOM_PRIME);
		state = state.rotate_left(13);
		i += 1;
	}
	state
}
// ═══════════════════════════════════════════════════════════════
// DAEMONIC TRAIT LATTICE — COMPLETE MAP v1
// ═══════════════════════════════════════════════════════════════
//
// Total: ~90 traits, enums, and key structs
// Purpose: Structural review under Glass
// Rule: No implementation bodies. Only shape.
//
// ═══════════════════════════════════════════════════════════════
// VISUAL OVERVIEW (read top-to-bottom = deep-to-surface)
// ═══════════════════════════════════════════════════════════════
//
// ┌─────────────────────────────────────────────────────────────┐
// │                SUBSTRATE (autotraits)                       │
// │  Send, Sync, Anchorable                                    │
// └──────────────────────────┬──────────────────────────────────┘
//                            │
// ┌──────────────────────────┴──────────────────────────────────┐
// │                ANCHOR LAYER                                 │
// │  Anchor ─┬─ TemporalAnchor ─┬─ EpochAnchor                  │
// │          │                  ├─ CausalAnchor                 │
// │          │                  └─ RateAnchor                   │
// │          ├─ SpatialAnchor ──┬─ LatticeAnchor                │
// │          │                  └─ TopologicalAnchor            │
// │          ├─ StructuralAnchor┬─ TraitAnchor                  │
// │          │                  ├─ ContractAnchor               │
// │          │                  └─ SchemaAnchor                 │
// │          ├─ PerceptualAnchor┬─ RealityAnchor                │
// │          │                  ├─ BaselineAnchor               │
// │          │                  └─ CalibrationAnchor            │
// │          ├─ SymbolicAnchor ─┬─ SemanticAnchor               │
// │          │                  ├─ SyntacticAnchor              │
// │          │                  ├─ VisualAnchor─── GlyphAnchor  │
// │          │                  └─ NarrativeAnchor              │
// │          ├─ AnchorDynamics (swing, drag)                    │
// │          ├─ TransitionalAnchor (lifecycle)                  │
// │          ├─ AnchorPermit (permission)                       │
// │          ├─ AnchorIdentity                                  │
// │          ├─ AnchorReliability                               │
// │          ├─ AnchorRelationship (bidirectional edges)        │
// │          └─ Frame ──────────┬─ ReferenceFrame               │
// │                             ├─ PerspectiveFrame             │
// │                             ├─ AccessFrame                  │
// │                             └─ ExecutionFrame               │
// └──────────────────────────┬──────────────────────────────────┘
//                            │
// ┌──────────────────────────┴──────────────────────────────────┐
// │                GLASS LAYER (observation engine)             │
// │  Glass<GLASS> ─── implements AnchorPermit (blanket)         │
// │  │                                                          │
// │  ├─ Observation<GLASS> (struct: position, severity, payload)│
// │  ├─ GlassReport (type-erased observation for reporting)     │
// │  ├─ Severity (11 variants: Stable..Unknown)                 │
// │  ├─ ObservationTier (Absolute, Primitive, Composed, Glyph.) │
// │  ├─ FidelityAction (Continue, Degrade, Warn, Drop)          │
// │  └─ Position (lattice path: &[&'static str])                │
// └──────────────────────────┬──────────────────────────────────┘
//                            │
// ┌──────────────────────────┴──────────────────────────────────┐
// │                CLOCK LAYER (temporal substrate)             │
// │  DaemonicClock<'clock>               					     │
// │  │  : Clone + Send + Sync + Debug + TemporalAnchor          │
// │  │  + RateAnchor                                            │
// │  │                                                          │
// │  ├─ associated: Timestamp, DaemonicDuration, Interval               │
// │  ├─ methods: now(), tick(), elapsed(), is_zero()            │
// │  └─ ShadeClock: Daemonic + Send + Sync (convenience)        │
// └──────────────────────────┬──────────────────────────────────┘
//                            │
// ┌──────────────────────────┴──────────────────────────────────┐
// │                DISPLAY LAYER (rendering/observation output) │
// │  DaemonicDisplay<GLASS>    ::fmt() → Observation<()>        │
// │  DaemonicDebug<GLASS>      ::fmt() → Observation<()>        │
// │  DaemonicWrite<GLASS>      ::write_str/char/fmt → Obs<()>   │
// │  DaemonicOctal<GLASS>      ::fmt() → Observation<()>        │
// │  Binary<GLASS>             ::fmt() → Observation<()>        │
// │  DaemonicLowerHex<GLASS>   ::fmt() → Observation<()>        │
// │  DaemonicUpperHex<GLASS>   ::fmt() → Observation<()>        │
// │  DaemonicPointer<GLASS>    ::fmt() → Observation<()>        │
// │  DaemonicLowerExp<GLASS>   ::fmt() → Observation<()>        │
// │  DaemonicUpperExp<GLASS>   ::fmt() → Observation<()>        │
// │                                                             │
// │  DaemonicFormatter<'buffer, GLASS> (struct)                 │
// │  DaemonicFormattingOptions (struct: flags, width, precision)│
// │  DaemonicArguments<'args, GLASS: Glass<GLASS>> [NO Error bd]│
// │  DaemonicArgument<'args, GLASS: Glass<GLASS>> [NO Error bd] │
// │  DaemonicPlaceholder (struct)                               │
// │  DaemonicCount (enum: Is, Param, Implied)                   │
// └──────────────────────────┬──────────────────────────────────┘
//                            │
// ┌──────────────────────────┴──────────────────────────────────┐
// │                ERROR LAYER (typed failures)                 │
// │  DaemonicError<'e, GLASS>                                   │
// │  │  : Glass<GLASS> (blanket impl)                           │
// │  │  + DaemonicDisplay<GLASS> + DaemonicDebug<GLASS>         │
// │  │  + Send + Sync + 'e                                      │
// │  │                                                          │
// │  ├─ associated: Source, Context, Position                   │
// │  ├─ methods: error_payload(), into_error_payload()          │
// │  ├─ DaemonicErrorExt<'e, GLASS>: DaemonicError (extensions) │
// │  ├─ ErrorContext<'e>: Send + Sync (context carrier)         │
// │  ├─ MetaData<'e>: Send + Sync (metadata carrier)            │
// │  ├─ EnumerationRouter (variant routing)                     │
// │  └─ StdErrorBridge (From impls for std errors)              │
// │                                                             │
// │  Error enum tree (concrete variants):                       │
// │  ├─ OsError (Linux, Windows, Mac subcategories)             │
// │  ├─ ShadeClockError (ClockError, SyncError, etc.)           │
// │  ├─ SymbolicError (6+1 SymbolicInsanity variants)           │
// │  ├─ GenericError (fallback)                                 │
// │  └─ BrokenSwordContext { pid, timestamp, source, comment }  │
// └──────────────────────────┬──────────────────────────────────┘
//                            │
// ┌──────────────────────────┴──────────────────────────────────┐
// │                MIRROR CHEMISTRY LAYER (bonding algebra)     │
// │  Reflection          { type Cause: ReflectionCause }        │
// │  ReflectionCause     { name(), recoverable() }              │
// │  Reflective          { reflect() }                          │
// │  ReflectionComposite { combine(), assess_stability() }      │
// │  MirrorType<'m>      : Send + Sync { properties() }         │
// │                                                             │
// │  ReflectionProperties { fidelity, temporality, spatiality,  │
// │                         selectivity, energy_cost }          │
// │  Fidelity     (Specular, Lossy(f64), Destructive, Absorptiv)│
// │  Temporality  (Instantaneous, Delayed, Prophetic, None, Var)│
// │  Spatiality   (Identity, Inverted, Transformed, Collapsed)  │
// │  Selectivity  (Complete, Partial, Single, None)             │
// │  EnergyCost   (Minimal, Finite, Sustained, Unbounded)       │
// │  Stability    (Stable, Metastable, Unstable, Impossible)    │
// │  BondResult   (Compound, Dominated, Contradiction, Unstable)│
// │  BondProvenance { first, second, order_matters }             │
// │  ReflectionGroup (Noble, Reactive, Transitional, Rare, Syn.)│
// │                                                              │
// │  reflection_to_severity() : ReflectionProperties → Severity │
// └──────────────────────────┬──────────────────────────────────┘
//                            │
// ┌──────────────────────────┴──────────────────────────────────┐
// │                REPAIR LAYER (self-healing)                   │
// │  RepairEnclosure<GLASS> (baked-in repair, innate immunity)   │
// │  │  fields: creator_id, repair_fn, fingerprint, trust,      │
// │  │          confidence, verification, created_at             │
// │  │  methods: new(), effective_confidence(), execute()        │
// │  │                                                          │
// │  RepairInjection<GLASS> (external repair, adaptive immunity) │
// │  │  fields: injector_id, repair_fn, fingerprint, trust,     │
// │  │          confidence, verification                        │
// │  │  methods: quarantine_check(), execute()                   │
// │  │                                                          │
// │  RepairStack<GLASS> { self_repair, local, global }           │
// │  │  methods: attempt_repair() → 3-level dispatch            │
// │  │                                                          │
// │  RepairResult (Repaired, Improved, Failed, Panicked,         │
// │                FingerprintMismatch)                           │
// │  RepairFingerprint { context_hash, expected_in/out,          │
// │                      function_checksum }                     │
// │  RepairTrust (Local, Verified{signer}, Untrusted)            │
// │  RepairVerification (Verified{hash,ver}, Unverified)         │
// │                                                              │
// │  SeverityRouter     { route() → FidelityAction }             │
// │  RepairAttempt<G>   { attempt_repair() }                     │
// │  RepairContext       { type Resources }                       │
// └──────────────────────────┬──────────────────────────────────┘
//                            │
// ┌──────────────────────────┴──────────────────────────────────┐
// │                SYSCALL LAYER (OS interaction)                │
// │  DaemonicSyscall: Send + Sync                               │
// │  │  type FailureState: GlassState                           │
// │  │                                                          │
// │  ├─ ObservationSyscall: DaemonicSyscall                     │
// │  │     (read-only, passive observation)                     │
// │  ├─ WriteSyscall: DaemonicSyscall                           │
// │  │     type Justification: WriteJustification               │
// │  │     (state mutation, requires justification)             │
// │  └─ ElevatedSyscall: DaemonicSyscall                        │
// │        type ElevationProof: ElevationProof                  │
// │        type Justification: WriteJustification               │
// │        (privileged ops, requires proof + justification)     │
// │                                                              │
// │  WriteJustification: Send + Sync { justify(), signer() }    │
// │  ElevationProof: Send + Sync { verify(), authority_chain() }│
// │  Authorizer: Send + Sync { authorize(), can_elevate() }     │
// │  PeerReviewable { request_review(), review_count() }        │
// └──────────────────────────┬──────────────────────────────────┘
//                            │
// ┌──────────────────────────┴──────────────────────────────────┐
// │                ENTITY LAYER (living observers)               │
// │  Daemonic (root identity trait)                              │
// │  │  type Clock: DaemonicClock                               │
// │  │  fn id() → u32                                           │
// │  │  fn clock() → &Clock                                     │
// │  │                                                          │
// │  ├─ Entity: Daemonic (death-aware)                          │
// │  │     fn broken_sword(err) → DaemonicError                 │
// │  │                                                          │
// │  └─ ShadeClock: Daemonic + Send + Sync (clock convenience)  │
// │        fn get_time() → Result<Timestamp, DaemonicError>     │
// │        fn daemonic_unwrap() → u64 (panic on clock failure)  │
// └──────────────────────────┬──────────────────────────────────┘
//                            │
// ┌──────────────────────────┴──────────────────────────────────┐
// │                WALKER LAYER (ephemeral observers)            │
// │  WalkerInput: Send + Sync                                   │
// │  │  fn validate() → Result  [INPUT validation]              │
// │  │                                                          │
// │  WalkerOutput: Send + Sync + 'static                        │
// │  │  (blanket impl, no validation currently)                 │
// │  │                                                          │
// │  Walker: Send + Sync                                         │
// │  │  type Input: WalkerInput                                 │
// │  │  type Output: WalkerOutput                               │
// │  │  fn process(input) → WalkerResult<Output>                │
// │  │  fn cancel()                                              │
// │  │                                                          │
// │  ├─ WalkerProgress: Walker (progress reporting)             │
// │  │     fn progress() → (processed, total)                   │
// │  │                                                          │
// │  ├─ WalkerBatch: Walker (batch processing)                  │
// │  │     fn batch_size() → usize                              │
// │  │                                                          │
// │  └─ WalkerLimits: Walker (resource constraints)             │
// │        fn max_depth() → usize                               │
// │        fn max_items() → usize                               │
// │        fn timeout() → DaemonicDuration                               │
// │                                                              │
// │  WalkerHandle (struct: JoinHandle + cancel token)            │
// │  WalkerState (enum: Created, Running, Completed, etc.)       │
// │  WalkerResult<T> (struct: output, time_range, stats)         │
// └──────────────────────────┬──────────────────────────────────┘
//                            │
// ┌──────────────────────────┴──────────────────────────────────┐
// │                NETWORK LAYER (mesh coordination)            │
// │  MeshNetwork: Send + Sync                                   │
// │  │  fn peers() → peer list                                  │
// │  │  fn broadcast(msg)                                       │
// │  │  fn consensus(proposal) → result                         │
// │  │                                                          │
// │  (Future: MeshClock, ShadeDiscovery, PeerAuth)              │
// └──────────────────────────┬──────────────────────────────────┘
//                            │
// ┌──────────────────────────┴──────────────────────────────────┐
// │                CORE LAYER (composition root)                 │
// │  DaemonicCore<GLASS>                                         │
// │  │  : DaemonicClock + DaemonicObserver + Anchor             │
// │  │                                                          │
// │  │  type Clock: DaemonicClock + TemporalAnchor + RateAnchor │
// │  │  type Observer: DaemonicObserver + PerceptualAnchor       │
// │  │                 + CausalAnchor                           │
// │  │                                                          │
// │  │  fn core_anchor_domains() → AnchorDomainSet              │
// └─────────────────────────────────────────────────────────────┘
//
// ═══════════════════════════════════════════════════════════════
// COMPOSITION ALGEBRA (G1-G10 + proposed G11)
// ═══════════════════════════════════════════════════════════════
//
// G1:  Closure         ∀ g₁,g₂ ∈ G: g₁ ⊕ g₂ ∈ G
// G2:  Identity        ∃ e (Specular): e ⊕ g = g ⊕ e = g
// G3:  Sev. Monotone   sev(g₁ ⊕ g₂) ≥ max(sev(g₁), sev(g₂))
// G4:  Tier Monotone   tier(g₁ ⊕ g₂) ≥ max(tier(g₁), tier(g₂))
// G5:  Annihilation    Impossible/Shattered absorb everything
// G6:  Involution      inv(inv(g)) = g [for Inverted spatiality]
// G7:  Cond. Commute   Commutative iff no Transformed spatiality
// G8:  Repair Damp     Repair absorbs cracks mid-chain
// G9:  Category Excl.  Lattice distance determines legality/cost
// G10: Prophetic Inst. Prophetic destabilizes compounds
// G11: Anchor Reliab.  reliability(A⊕B) ≤ √(rel(A)·rel(B))
//
// Test status: 22/23 passing (1 trivial fix remaining)
//
// ═══════════════════════════════════════════════════════════════
// BLANKET IMPLEMENTATIONS (bridges between layers)
// ═══════════════════════════════════════════════════════════════
//
// impl<'e, GLASS, T> Glass<GLASS> for T
//     where T: DaemonicError<'e, GLASS>
//     → Every DaemonicError IS a Glass observation
//     → Severity derived from error variant
//     → Shattered/Impossible: dark (no payload)
//     → Others: delegate to error_payload()
//
// impl<GLASS, T> AnchorPermit for T
//     where T: Glass<GLASS> + Anchorable
//     → Every Glass IS an AnchorPermit
//     → Permissions derived from severity
//     → Stable: all domains permitted
//     → Shattered: no domains permitted
//
// impl<GLASS> Try for Observation<GLASS>
//     → ? operator works in formatting chains
//     → Stable/Cracked: Continue (extract payload)
//     → Dark states: Break (propagate observation)
//
// impl<GLASS> FromResidual<Result<!, fmt::Error>>
//     for Observation<GLASS>
//     → ? on std::fmt::Result converts to Observation
//     → Enables interop with std formatting
//
// ═══════════════════════════════════════════════════════════════
// CROSS-CUTTING CONCERNS
// ═══════════════════════════════════════════════════════════════
//
// GLASS parameter:
//   Threading through: Glass<GLASS>, DaemonicError<'e, GLASS>,
//   DaemonicDisplay<GLASS>, DaemonicCore<GLASS>,
//   RepairEnclosure<GLASS>, RepairInjection<GLASS>,
//   DaemonicArguments<'args, GLASS>
//
//   NOT threading through: Anchor (below Glass, GLASS-independent),
//   Frame (below Glass), DaemonicClock (uses FORMAT+PARTIAL),
//   MirrorChemistry (uses ReflectionProperties, not GLASS),
//   Syscall layer (uses GlassState, may need GLASS migration)
//
// Position:
//   Used by: Glass (position()), SpatialAnchor (anchor_position()),
//   LatticeAnchor (distance_to()), AccessFrame (authorized_positions()),
//   ReferenceFrame (origin()), GlassReport (position field)
//
// Severity:
//   Used by: Glass (severity()), AnchorPermit (permission derivation),
//   RepairFingerprint (expected_in/out), RepairResult (Repaired/Improved),
//   FidelityAction (severity_to_fidelity()), composition algebra (G3)
//
// Timestamp:
//   Used by: DaemonicClock (now(), tick()), TemporalAnchor (anchor_tick()),
//   RepairEnclosure (created_at, last_verified_at),
//   BrokenSwordContext (timestamp field)
//
// DaemonicID / u32 id:
//   Used by: Daemonic (id()), RepairEnclosure (creator_id),
//   RepairInjection (injector_id), AnchorIdentity (anchor_id),
//   BrokenSwordContext (pid)
//   NOTE: Currently u32 in Daemonic, u64 in Repair. Needs unification.
//

mod build;
pub mod daemonic;

/// # DaemonicError — Observation-oriented error handling
///
/// DaemonicError is the primary trait for errors in the Daemonic ecosystem.
/// Every error is an observation. Every observation has a Glass state.
///
///
/// ## Payload Semantics:
///
/// Not all errors are dark. The GLASS parameter represents the payload type
/// that MAY be present depending on severity:
///
/// - Stable: payload guaranteed (this is an observation, not really an "error")
/// - Cracked: payload present with caveats (partial success, annotated value)
/// - Fracture: payload MAY be present (partial data, possibly corrupted)
/// - Warp: payload present but unreliable (came back wrong)
/// - Drift: payload from a different state than expected
/// - Shattered: always dark, no payload
/// - Impossible: always dark, should not exist
/// - Paradox: multiple contradictory payloads possible
/// - Opaque: payload exists but is frame-locked
/// - Echo: payload from a different time
/// - Unknown: unassessed, payload status unknown

// ── Core trait (dyn-compatible) ─────────────────────

/// The dyn-compatible core of DaemonicError.
///
/// Designed to work with `Box<dyn DaemonicError<'_, GLASS>>`.
/// All methods return concrete types or references — no impl Trait,
/// no generic type parameters on methods.
///
/// The GLASS type parameter is the error's payload type — what the
/// error wraps or describes. For dark errors (Shattered, Impossible),
/// payload is always None. For light errors (Cracked, Fracture),
/// payload may contain partial or recoverable data.
#[allow(multiple_supertrait_upcastable)] // inherited from Std::Error
pub trait DaemonicError<'error>: 'error
{
	fn position(&self) -> &TopologySegment;
	
	fn emit(&self) -> Error;
	/// What severity level is this error?
	/// This maps directly to Glass severity — the match quality spectrum.
	/// Determines fidelity_action, recoverability, and payload availability.
	#[must_use]
	fn severity_level(&self) -> Severity {
		Severity::Unknown
	}
	
	/// New, in development
	fn repair_manifest(&self) { () }
	
	
	/// Is this error recoverable?
	/// Default: derived from severity.
	/// Stable/Cracked = recoverable (payload intact).
	/// Fracture/Drift = maybe (payload may be partial).
	/// Everything else = no.
	fn is_recoverable(&self) -> bool {
		/// Stable always recoverable because nothing was fucked to start with
		/// Cracked is always recoverable and constitutes a light error or moderate (nonfatal) warning.
		matches!(self.severity_level(), Severity::Stable | Severity::Cracked)
	}
	
	/// Where did the error originate in source (if different from position)?
	/// Default: None (position IS the source position).
	fn source_position(&self) -> Option<&TopologySegment> {
		None
	}
	
	
	/// Observation tier for this error.
	/// Default: Composed (most errors are about composed types).
	fn error_tier(&self) -> ObservationTier {
		ObservationTier::Composed
	}
	
	/// Temporal state of this error observation.
	/// Default: Current (the error is happening now).
	fn error_temporal(&self) -> Temporal {
		Temporal::Current
	}
	
	/// Annotation attached to this error.
	/// Default: None. Override to attach notes, help text, or suggestions.
	fn error_annotation(&self) -> Annotation {
		Annotation::None
	}
	
	// ── Reporting (free, derived from above) ────────
	
	/// Produce a type-erased report of this error.
	/// Free for all DaemonicError implementors. No allocation beyond Position clone.
	///
	/// GlassReport captures all observation AXES without the PAYLOAD.
	/// This is the universal error exchange format — log it, serialize it,
	/// aggregate it, alert on it. No type parameters needed to read a report.
	fn as_error_report(&self) -> GlassReport {
		let severity = self.severity_level();
		GlassReport {
			position: self.position().clone(),
			severity,
			tier: self.error_tier(),
			annotation: self.error_annotation(),
			temporal: self.error_temporal(),
			accessibility: Accessibility::Clear,
			consistency: Consistency::Singular,
			assessment: Assessment::Assessed,
			fidelity_action: severity_to_fidelity(severity),
		}
	}
}

/// Map severity to fidelity action.
/// Extracted as a free function so both Glass and DaemonicError
/// can use the same mapping without duplication.
pub fn severity_to_fidelity(severity: Severity) -> FidelityAction {
	match severity {
		Severity::Stable => FidelityAction::Continue,
		Severity::Cracked => FidelityAction::Warn,
		Severity::Fracture => FidelityAction::Halt,
		Severity::Warp => FidelityAction::Halt,
		Severity::Shattered => FidelityAction::Halt,
		Severity::Impossible => FidelityAction::Abort,
		Severity::Unknown => FidelityAction::Attend,
		Severity::Drift => FidelityAction::Attend,
		Severity::Paradox => FidelityAction::Warn,
		Severity::Opaque => FidelityAction::Halt,
		Severity::Echo => FidelityAction::Attend,
	}
}

/// Contextualized error report — GlassReport + error-specific metadata.
pub struct ContextualizedReport {
	pub report: GlassReport,
	pub is_recoverable: bool,
	pub has_payload: bool,
	pub source_position: Option<TopologySegment>,
}
// impl DaemonicError<'_> for () {
// 	fn position(&self) -> &TopologySegment {&TopologySegment::new("Daemonic::Glass::Primitives::()").}
//
//
// 	fn severity_level(&self) -> Severity {
// 		Severity::Unknown
// 	}
// }

impl SymbolicAnchor for () {
	fn meaningful_within(&self) -> impl ReferenceFrame {
		todo!()
	}
}

impl SemanticAnchor for () {}
// ── Blanket Glass implementation ────────────────────

// /// Any DaemonicError automatically implements Glass.
// /// This is what makes "Mode 2" work — implement DaemonicError,
// /// get Glass for free.
// ///
// /// The Glass implementation delegates to DaemonicError's methods.
// /// Payload delegation is severity-aware:
// /// - Stable/Cracked/Fracture/Warp/Drift → delegates to error_payload()
// /// - Shattered/Impossible → always None (dark glass)
// /// - Paradox/Opaque/Echo/Unknown → delegates to error_payload()
// ///   (may or may not have data depending on the specific error)
// ///
// /// The GLASS parameter flows through: DaemonicError<'e, GLASS>
// /// provides Glass<GLASS>. The payload type is consistent.
// /// TODO: Blanket impl causing problems, disabled for now
// impl<'error, GLASS, T> Glass<T> for T
// // where
// // 	GLASS: ?Send + ?Sync,
// {
// 	fn position(&self) -> &TopologySegment { todo!() }
//
// 	fn severity(&self) -> Severity {
// 		self.severity_level()
// 	}
//
// 	fn annotation(&self) -> Annotation {
// 		self.error_annotation()
// 	}
//
// 	fn temporal(&self) -> Temporal {
// 		self.error_temporal()
// 	}
//
// 	fn accessibility(&self) -> Accessibility {
// 		Accessibility::Clear
// 	}
//
// 	fn consistency(&self) -> Consistency {
// 		Consistency::Singular
// 	}
//
// 	fn assessment(&self) -> Assessment {
// 		Assessment::Assessed
// 	}
//
// 	fn tier(&self) -> ObservationTier {
// 		self.error_tier()
// 	}
//
// 	/// Payload delegation — severity-aware.
// 	/// Dark severities (Shattered, Impossible) are always None.
// 	/// All other severities delegate to the error's payload method,
// 	/// which defaults to None but can be overridden for errors
// 	/// that carry partial or recoverable data.
// 	fn payload(&self) -> Option<&GLASS> {
// 		match self.severity_level() {
// 			Severity::Shattered | Severity::Impossible => None,
// 			_ => self.error_payload(),
// 		}
// 	}
// 	fn into_payload(self) -> Option<GLASS>
// 	where
// 		Self: Sized,
// 	{
// 		match self.severity_level() {
// 			Severity::Shattered | Severity::Impossible => None,
// 			_ => self.into_error_payload(),
// 		}
// 	}
// }

// ── Extension trait (not dyn-compatible) ────────────

/// Extension methods for DaemonicError that require generic type parameters.
/// These cannot go on the core trait because they break dyn-compatibility.
///
/// These methods are for Rust compiler integration (Diagnostics, Subdiagnostics)
/// and are NOT needed for general error handling. Most users never touch this.
pub trait DaemonicErrorExt<'error, GLASS>: DaemonicError<'error> {
	// TODO: THESE HAVE BEEN TEMPORARILY DISABLED PENDING DAEMONIC LATTICE COMPLETION
	// This is technically rust logic, so falls outside scope for the moment
	// Emit as a Rust compiler Diagnostic.
	// Requires a SPAN, not a Glass observation.
	// Only useful in compiler/tooling contexts.
	// fn emit_diagnostic<D: Diagnostic<'error>>(&self) -> D {
	// 	unimplemented!(
	// 		"[DAEMONIC-ERROR] Diagnostic emission requires compiler context. \
	//          Use as_error_report() for general-purpose error reporting."
	// 	)
	// }
	//
	// Emit as a Rust compiler Subdiagnostic.
	// Requires a parent Diagnostic to anchor on.
	// fn emit_subdiagnostic<S: Subdiagnostic>(&self) -> S {
	// 	unimplemented!(
	// 		"[DAEMONIC-ERROR] Subdiagnostic emission requires compiler context. \
	//          Use as_error_report() for general-purpose error reporting."
	// 	)
	// }
}

// ── Supporting traits ──────────────────────────────

// /// Error context — environmental snapshot at error time.
// pub trait ErrorContext<'error>: Send + Sync + 'error {
// 	fn position(&self) -> &Position;
// 	fn timestamp(&self) -> Timestamp;
// }

/// Additional metadata attached to an error. Optional.
/// /// MetaData is a type of SemanticAnchor
// pub trait MetaData<'error>: Send + Sync + 'error {}

/// Blanket impls for common metadata types
/// MetaData is a type of SemanticAnchor
// impl MetaData<'_> for () {}

// ── Position (simplified per Observer 5) ───────────

// /// Position in the error/observation type tree.
// ///
// /// Positions are hierarchical paths: ["Daemonic", "Symbolic", "CausalChainBroken"]
// /// They serve as both identification AND classification.
// /// Position prefix queries enable aggregation: "all Daemonic::Symbolic errors today."
// ///
// /// Segments are &'static str — positions are compile-time constants.
// /// Stack-allocated for depth ≤ 8 via SmallVec.
// pub struct Position {
// 	segments: SmallVec<[&'static str; 8]>,
// }
/// Position in the observation/error type tree.
///
/// Positions are hierarchical paths: ["Daemonic", "Glass", "primitives", "u8"]
/// They serve as both identification AND classification.
/// Position prefix queries enable aggregation.
///
/// Segments are &'static str — positions are compile-time constants.
// #[derive(PartialEq, Eq, DaemonicHashable)]
// #[derive(Clone)]
// pub struct Position {
// 	segments: Vec<&'static str>, // TODO: replace with SmallVec<[&'static str; 8]>
// }
// impl Position { // todo: needs root function that grabs observer callers position in the lattice
// 	pub const fn new(segments: &[&'static str]) -> Self {
// 		Self {
// 			segments: SmallVec::from_slice(segments),
// 		}
// 	}
//
// 	/// How deep in the hierarchy is this position?
// 	pub fn depth(&self) -> usize {
// 		self.segments.len()
// 	}
//
// 	/// Does this position start with the given prefix?
// 	/// Used for category matching: pos.starts_with(&["Daemonic", "Symbolic"])
// 	pub fn starts_with(&self, prefix: &[&str]) -> bool {
// 		self.segments.len() >= prefix.len()
// 			&& self.segments[..prefix.len()]
// 			.iter()
// 			.zip(prefix.iter())
// 			.all(|(a, b)| a == b)
// 	}
//
// 	/// Human-readable path: "Daemonic::Symbolic::CausalChainBroken"
// 	pub fn as_path(&self) -> String {
// 		self.segments.join("::")
// 	}
//
// 	/// First segment — the top-level category
// 	pub fn category(&self) -> &'static str {
// 		self.segments.first().copied().unwrap_or("Unknown")
// 	}
// }

// impl Clone for Position {
// 	fn clone(&self) -> Self {
// 		Self {
// 			segments: self.segments.clone(),
// 		}
// 	}
// }

// impl core::fmt::Debug for Position {
// 	fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
// 		write!(f, "Position({})", self.as_path())
// 	}
// }

// /// Convenience macro for constructing Position at compile time.
// /// Usage: pos!("Daemonic", "Symbolic", "CausalChainBroken")
// #[macro_export]
// macro_rules! pos {
//     ($($segment:expr),+ $(,)?) => {
//         Position::new(&[$($segment),+])
//     };
// }

// ── Error Categories ───────────────────────────────
//
// The error tree. Position paths identify category:
//   Generic::*             — "something went wrong, here's what I know"
//   OS::*                  — operating system / environment errors
//   Daemonic::*            — trait lattice / Glass / observer errors
//     Daemonic::Glass::*     — Glass observation failures
//     Daemonic::Entity::*    — entity lifecycle errors
//     Daemonic::Symbolic::*  — symbol integrity errors
//     Daemonic::Insanity::*  — SymbolicInsanity (scale-free failure modes)
//     Daemonic::Physics::*   — axiom/physics violations (produces Impossible)

/// Trait router — maps error types to their position in the tree.
/// Implemented on enums that contain error variant structs.
/// The enum provides routing. The structs provide typed error data.

pub trait EnumerationRouter {
	// Where does this enum route to in the position tree?
	// fn route_position(&self) -> Position;
}

/// Convert any std Error into a Generic DaemonicError.
/// This is the incremental adoption path — wrap existing errors
/// at the boundary between std code and Daemonic code.
/// The wrapped error gets Shattered severity (we know it failed,
/// we don't know the Daemonic classification).
// #[daemonic(glass)]
#[doc = " Convert any std Error into a Generic DaemonicError."]
#[doc = " This is the incremental adoption path — wrap existing errors"]
#[doc = " at the boundary between std code and Daemonic code."]
#[doc = " The wrapped error gets Shattered severity (we know it failed,"]
#[doc = " we don\'t know the Daemonic classification)."]

pub struct StdErrorBridge {
	position: TopologySegment,
	message: String,
	source_type: &'static str,
}
const STDERRORBRIDGE_TOPOLOGY: crate::daemonic::TopologySegment =
	crate::daemonic::TopologySegment {
		label: "Daemonic::Glass::Consumer::StdErrorBridge",
		hash: crate::const_daemonic_hash(
			"Daemonic::Glass::Consumer::StdErrorBridge".as_bytes(),
			crate::AXIOM_OFFSET,
		),
		crypto_id: crate::const_daemonic_hash(
			"Daemonic::Glass::Consumer::StdErrorBridge".as_bytes(),
			crate::TOPOLOGY_ANCHOR,
		),
		depth: 3u16,
	};

// unsafe impl<A: SpatialAnchor> Anchorable for StdErrorBridge<A> {}

unsafe impl Send for StdErrorBridge {}

unsafe impl Sync for StdErrorBridge {}

impl Anchor for StdErrorBridge {
	fn anchor_domains(&self) -> crate::daemonic::AnchorDomainSet {
		crate::daemonic::AnchorDomainSet::SPATIAL
			.union(crate::daemonic::AnchorDomainSet::STRUCTURAL)
			.union(crate::daemonic::AnchorDomainSet::SYMBOLIC)
	}
}
impl SymbolicAnchor for StdErrorBridge {
	type Anchor = crate::daemonic::TopologySegment;
	fn meaningful_within(&self) -> Self::Anchor {
		STDERRORBRIDGE_TOPOLOGY.clone()
	}
}
impl crate::daemonic::SemanticAnchor for StdErrorBridge {}
impl crate::daemonic::SpatialAnchor for StdErrorBridge {
	fn anchor_position(&self) -> &crate::daemonic::TopologySegment {
		&STDERRORBRIDGE_TOPOLOGY
	}
	fn neighbors(&self) -> crate::daemonic::TopologySegment {
		STDERRORBRIDGE_TOPOLOGY.clone()
	}
}
impl crate::daemonic::StructuralAnchor for StdErrorBridge {
	fn contract_description(&self) -> &str {
		"StdErrorBridge: auto-derived Daemonic anchor via #[daemonic] proc macro"
	}
}
impl TopologyAnchor for StdErrorBridge {
	fn parent(&self) -> Option<crate::daemonic::TopologySegment> {
		let label = STDERRORBRIDGE_TOPOLOGY.label;
		label
			.rsplit_once("::")
			.map(|(parent, _)| <GlassError as TopologyAnchor>::new_anchor(parent)) // todo: GlassError needs to be updated to something else
	}
	fn children(&self) -> &[crate::daemonic::TopologySegment] {
		&[]
	}
	fn segments(&self) -> &crate::daemonic::TopologySegment {
		&STDERRORBRIDGE_TOPOLOGY
	}
	fn depth(&self) -> usize {
		STDERRORBRIDGE_TOPOLOGY.depth as usize
	}
}

impl crate::daemonic::glass::Glass<StdErrorBridge> for StdErrorBridge {
	type Anchor = TopologySegment;
	fn position(&self) -> &crate::daemonic::TopologySegment {
		&STDERRORBRIDGE_TOPOLOGY
	}
	fn severity(&self) -> crate::daemonic::glass::Severity {
		crate::daemonic::glass::Severity::Stable
	}
	fn tier(&self) -> crate::daemonic::glass::ObservationTier {
		crate::daemonic::glass::ObservationTier::Composed
	}
	fn payload(&self) -> Option<&StdErrorBridge> {
		Some(self)
	}
	fn into_payload(self) -> Option<StdErrorBridge> {
		Some(self)
	}
}
impl StdErrorBridge
{
	pub fn from_std<E: core::error::Error>(err: E) -> Self {
		Self {
			position: STDERRORBRIDGE_TOPOLOGY,
			message: err.to_string(),
			source_type: core::any::type_name::<E>(),
		}
	}
	
	// pub fn from_io(err: core::io::Error) -> Self {
	// 	Self {
	// 		position: pos!("OS", "IO"),
	// 		message: err.to_string(),
	// 		source_type: "std::io::Error",
	// 	}
}
struct Meta {
	message: Option<String>,
}