daemonic_error 1.0.0

#![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(cfg_sanitize)]
#![feature(non_null_from_ref)]
mod daemonic_syscall {
	//! This logic is currently not active, but will be soon. Thank you Ada, you are awesome love <3
	// AUTHORITY LEVELS AS TRAITS

	use crate::Timestamp;
	use crate::GlassState;
	use crate::Position;
	struct SyscallContext; // todo: stubbed for now
	struct JustificationError; // todo: stubbed for now
	struct ElevationError; // todo: stubbed for now
	/// Base capability — all syscalls have this
	pub trait DaemonicSyscall: Send + Sync {
		/// Human-readable name
		fn name(&self) -> &'static str;

		/// Position in syscall hierarchy
		fn position(&self) -> Position;

		/// What Glass state does failure produce?
		type FailureState: for<'glass_state> GlassState<'glass_state>;
	}

	/// Category 2: DaemonicObservation only
	pub(crate) trait ObservationSyscall: DaemonicSyscall {
		/// The type of data observed
		type Observed;

		/// Perform observation (always permitted)
		fn observe(&self) -> Result<Self::Observed, Self::FailureState>;
	}

	/// Category 1: Write capable
	pub(crate) trait WriteSyscall: DaemonicSyscall {
		/// What is being written
		type WriteData;

		/// Justification for this write
		type Justification: WriteJustification;

		/// Perform write with justification
		fn write(
			&self,
			data: Self::WriteData,
			justification: Self::Justification,
		) -> Result<(), Self::FailureState>;

		/// Does this write require peer review?
		fn requires_peer_review(&self, context: &SyscallContext) -> bool {
			// Default: review if state corrupted
			context.state_corrupted()
		}
	}

	/// Category 3: Kernel/elevated
	pub(crate) trait ElevatedSyscall: DaemonicSyscall {
		/// Proof of elevation (root, capability, etc.)
		type ElevationProof: ElevationProof;

		/// Justification (always required)
		type Justification: WriteJustification;

		/// Perform elevated operation
		fn execute_elevated(
			&self,
			proof: Self::ElevationProof,
			justification: Self::Justification,
		) -> Result<(), Self::FailureState>;

		/// Always requires peer review if mesh available
		fn requires_peer_review(&self, _context: &SyscallContext) -> bool {
			true
		}
	}
	/// Justification for a write operation
	pub trait WriteJustification: Send + Sync {
		/// Why is this write happening?
		fn reason(&self) -> &str;

		/// Who/what authorized it?
		fn authorizer(&self) -> &dyn Authorizer;

		/// Timestamp of authorization
		fn timestamp(&self) -> Timestamp;

		/// Can this justification be verified?
		fn verify(&self) -> Result<(), JustificationError>;
	}

	/// Proof of elevation for Category 3
	pub trait ElevationProof: Send + Sync {
		/// What kind of elevation?
		fn elevation_type(&self) -> ElevationType;

		/// Is this proof still valid?
		fn is_valid(&self) -> bool;

		/// Verify the proof
		fn verify(&self) -> Result<(), ElevationError>;
	}

	pub enum ElevationType {
		/// Unix root
		Root,
		/// Linux capability
		Capability(CapabilitySet),
		/// Daemonic entity privilege
		EntityPrivilege(EntityId),
		/// Temporary elevation (sudo-like)
		TemporaryElevation { expires: Timestamp },
	}
	struct CapabilitySet; // todo: This is stubbed
	struct EntityId; // todo: this is also stubbed
	/// Who can authorize writes
	pub trait Authorizer: Send + Sync {
		fn id(&self) -> AuthorizerId;
		fn can_authorize(&self, syscall: &dyn DaemonicSyscall<FailureState=()>) -> bool; // todo FailureState needs def, this is a stub
	}
	/// Peer review for sensitive operations
	pub trait PeerReviewable {
		/// Request peer review
		fn request_review(&self, mesh: &dyn MeshNetwork) -> ReviewRequest;

		/// Check if review is complete
		fn review_status(&self, request: &ReviewRequest) -> ReviewStatus;

		/// Proceed after approval
		fn execute_after_review(&self, approval: ReviewApproval) -> Result<(), Self::FailureState>;
	}

	pub enum ReviewStatus {
		/// Waiting for peers
		Pending { required: usize, received: usize },
		/// Approved by quorum
		Approved(ReviewApproval),
		/// Rejected by quorum
		Rejected { reason: String },
		/// Timed out
		TimedOut,
		/// No mesh available, proceed with local decision
		NoMesh,
	}

	pub struct ReviewApproval {
		pub approvers: Vec<EntityId>,
		pub timestamp: Timestamp,
		pub quorum_met: bool,
	}

	// Integration with WriteSyscall
	impl<S: WriteSyscall + PeerReviewable> S {
		pub fn write_with_review(
			&self,
			data: Self::WriteData,
			justification: Self::Justification,
			mesh: Option<&dyn MeshNetwork>,
			context: &SyscallContext,
		) -> Result<(), WriteError<Self::FailureState>> {
			// Check if review needed
			if self.requires_peer_review(context) {
				match mesh {
					Some(m) => {
						let request = self.request_review(m);
						match self.review_status(&request) {
							ReviewStatus::Approved(approval) => {
								self.execute_after_review(approval)?;
							}
							ReviewStatus::Rejected { reason } => {
								return Err(WriteError::ReviewRejected(reason)); // todo:: Daemonic::Syscall variant enum with struct leaf + DE impl needed for this to shut up
							}
							ReviewStatus::NoMesh => {
								// Proceed with local decision + warning
								self.write(data, justification)?;
							}
							_ => return Err(WriteError::ReviewPending),
						}
					}
					None => {
						// No mesh, local decision
						self.write(data, justification)?;
					}
				}
			} else {
				// No review needed
				self.write(data, justification)?;
			}
			Ok(())
		}
	}
}
mod mesh {
	use crate::{DaemonicBinary, DaemonicError};

	pub trait MeshNetwork: Send + Sync {
		/// This node's identity
		fn local_id(&self) -> EntityId;

		/// Known peers
		fn peers(&self) -> &[EntityId];

		/// Send binary to peer
		fn send<FORMAT, PARTIAL>(&self, peer: EntityId, data: impl DaemonicBinary) -> Result<(), MeshError>;

		/// Receive binary (async in practice)
		fn receive<FORMAT, PARTIAL>(&self) -> Result<(EntityId, dyn DaemonicBinary<Error=impl DaemonicError<FORMAT, PARTIAL>>), MeshError>;

		/// Request peer review
		fn request_review(&self, operation: &dyn PeerReviewable) -> ReviewRequest;

		/// Check review status
		fn check_review(&self, request: &ReviewRequest) -> ReviewStatus;
	}
	// Stub implementation for no-mesh:

	pub struct NoMesh;
	impl MeshNetwork for NoMesh {
		fn local_id(&self) -> EntityId {
			EntityId::solo()
		}
		fn peers(&self) -> &[EntityId] {
			&[]
		}
		fn send<FORMAT, PARTIAL>(&self, _: EntityId, _: Box<dyn DaemonicBinary<Error=impl DaemonicError<FORMAT, PARTIAL>>>) -> Result<(), MeshError> {
			Err(MeshError::NoPeers)
		}
		fn receive<FORMAT, PARTIAL>(&self) -> Result<(EntityId, dyn DaemonicBinary<Error=impl DaemonicError<FORMAT, PARTIAL>>), MeshError> {
			Err(MeshError::NoPeers)
		}
		fn request_review(&self, _: &dyn PeerReviewable) -> ReviewRequest {
			ReviewRequest::no_mesh()
		}
		fn check_review(&self, _: &ReviewRequest) -> ReviewStatus {
			ReviewStatus::NoMesh
		}
	}
}
mod doc_template;
mod opaque_dependencies;
pub(crate) mod daemonic {
	use daemonic_core::DaemonicClock;
	use daemonic_core::DaemonicCore;
	use daemonic_contract::DaemonicContract;
	use crate::daemonic::daemonic_contract::DaemonicBinary;
	use crate::{DaemonicError, Position};
	/// Top level Daemonic trait, baseplate. All things Serve the Daemonic Trait.
	/// This trait is mostly a marker point for ROOT, but can be implemented on things but
	/// requires significant boilerplate.
	pub(crate) trait Daemonic<FORMAT, PARTIAL>: DaemonicCore<FORMAT, PARTIAL> + DaemonicContract<FORMAT, PARTIAL> {
		/// Daemonic ID
		#[must_use]
		fn id(&self) -> DaemonicID<FORMAT, PARTIAL>;
		/// DaemonicPosition, all fields in all things that specialize on this trait must be positioned
		#[must_use]
		fn position(&self) -> Position;
	}

	pub(crate) mod daemonic_core {
		use crate::DaemonicError;
		use crate::ErrorContext;
		use observation::DaemonicObservation;
		use observer::*;

		/// Core Daemonic requirements.
		///
		/// Anything implementing Daemonic must implement both Core and Contract.
		pub(crate) trait DaemonicCore<FORMAT, PARTIAL>: DaemonicClock<FORMAT, PARTIAL> + DaemonicObservation<FORMAT, PARTIAL> {
			/// Daemonic logic enforces clocks on all things that need observability, this is non-negotiable.
			/// This is also part of the core system, any truly observant system must have an internal clock.
			/// That clock must also be **accurate and trustworthy**
			type Clock: DaemonicClock<FORMAT, PARTIAL>;
			/// This is currently stubbed, but the observer is required for a core to function as intended
			type Observer: DaemonicObserver<FORMAT, PARTIAL>;
		}
		pub(crate) mod observer {
			use crate::daemonic::{Daemonic, DaemonicID};
			use crate::daemonic::daemonic_contract::DaemonicContract;
			use crate::{DaemonicError, ErrorContext};
			use crate::daemonic::daemonic_core::DaemonicClock;

			/// Entity - Daemonic entity with self-aware death
			///
			/// Entities can declare their own death with context.
			pub(crate) trait DaemonicObserver<FORMAT, PARTIAL>: Daemonic<FORMAT, PARTIAL> {
				type Contract: DaemonicContract<FORMAT, PARTIAL>;

				type Clock: DaemonicClock<FORMAT, PARTIAL>;

				fn id(&self) -> DaemonicID<FORMAT, PARTIAL>;

				/// Declare entity death (Broken Sword)
				///
				/// Called when: Entity encounters unrecoverable error
				/// Returns: BrokenSwordContext error with full context
				/// # Broken Sword Semantics
				///
				/// "Broken Sword" is a self-aware death declaration by a Daemonic entity.
				/// The term originates from the Unification Wars Trilogy, where TCS Jericho,
				/// trapped and outnumbered, declared "Jericho is Broken Sword" - meaning:
				/// "We are dying, we will not surrender, rescue is impossible, recovery only."
				///
				/// In Daemonic context:
				/// - Entity encounters unrecoverable error
				/// - Entity declares its own death (not external kill)
				/// - Error propagates upstream to parent
				/// - Parent marks entity for reaping
				/// - Parent survives (no cascade failure)
				///
				/// ## Reap Strategy
				///
				/// **Default: Background reaping**
				/// - Entities queued for cleanup
				/// - Processed asynchronously
				/// - No blocking on parent
				///
				/// **System-level: Immediate reaping** (future)
				/// - Flagged for priority cleanup
				/// - Sudo privileges (future detection)
				/// - Processed before background queue
				///
				/// ## Reap Failure Handling
				///
				/// After 3 failed reap attempts:
				/// 1. **Map boundaries**: Identify affected symbols (event horizon)
				/// 2. **Establish orbit**: Mark symbols as orbiting black hole
				/// 3. **Force kill**: Topology unwrapped enough, safe to terminate
				///
				/// This prevents hard desync by maintaining topological awareness
				/// even when entity cannot be gracefully reaped.
				///
				/// ## Cascade Death
				///
				/// When parent dies:
				/// - Child with no external references → Dies with parent
				/// - Child with external references → Survives (orphaned)
				/// - Child with dependents → Survives (needed by others)
				///
				/// ## Mesh Awareness (future)
				///
				/// All entity deaths are broadcast to mesh peers (if configured):
				/// - Enables distributed reference tracking
				/// - Prevents dangling references
				/// - Maintains mesh consistency
				fn broken_sword<FORMAT, PARTIAL>(&self, err: Box<dyn ErrorContext>) -> impl DaemonicError<FORMAT, PARTIAL> { None }
			}
		}

		use super::super::Position;
		pub use clock::{DaemonicClock, SteerableClock, SteppableClock, UncertainClock};
		use crate::daemonic::Daemonic;
		use crate::daemonic::daemonic_contract::DaemonicContract;

		pub(crate) mod clock {
			// daemonic_clock/src/traits/clock.rs
			//! Core DaemonicClock trait - Unified time interface
			//!
			//! This trait provides a common interface for both:
			//! - Logical clocks (Lamport, Vector, Hybrid)
			//! - Physical clocks (MTP, NTP, System)
			//!
			//! All Daemonic entities use this trait for time access.

			use crate::DaemonicError;
			use std::fmt::Debug;

			mod types {
				// daemonic_clock/src/types.rs
				//! Clock type definitions

				use std::fmt;
				use std::ops::{Add, Sub};

				// ═══════════════════════════════════════════════════════════════
				// TIMESTAMP
				// ═══════════════════════════════════════════════════════════════

				/// Timestamp - Opaque time value from DaemonicClock
				///
				/// This wraps a u64 to provide type safety and domain methods.
				///
				/// # Why not raw u64?
				///
				/// - Type safety: Can't accidentally use file size as timestamp
				/// - Domain methods: is_zero(), elapsed_since(), etc.
				/// - Future-proof: Can change internal representation later
				/// - Zero-cost: Newtype pattern, no runtime overhead
				///
				/// # Example
				///
				/// ```
				/// use daemonic_clock::Timestamp;
				///
				/// let t1 = Timestamp::new(100);
				/// let t2 = Timestamp::new(200);
				///
				/// assert!(t2 > t1);
				/// assert_eq!(t2 - t1, 100);
				/// ```
				// todo: this could probably be a trait with default method implementations actually, then anchored
				// underneath daemonic core
				#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
				pub struct Timestamp(u64);

				impl Timestamp {
					/// Create new timestamp from u64
					pub const fn new(value: u64) -> Self {
						Self(value)
					}

					/// Zero timestamp (invalid/broken clock)
					pub const fn zero() -> Self {
						Self(0)
					}
					/// One timestamp (default, zero reserved for broken clock errors)
					pub const fn one() -> Self {
						Self(1)
					}
					/// Get raw u64 value
					pub const fn as_u64(self) -> u64 {
						self.0
					}

					/// Check if timestamp is zero (invalid)
					pub const fn is_zero(self) -> bool {
						self.0 == 0
					}

					/// Elapsed ticks since earlier timestamp
					///
					/// Returns: self - earlier (duration in ticks)
					/// Panics: If earlier > self
					pub fn elapsed_since(self, earlier: Timestamp) -> u64 {
						assert!(self >= earlier, "earlier must be <= self");
						self.0 - earlier.0
					}

					/// Checked elapsed (returns None if earlier > self)
					pub fn checked_elapsed_since(self, earlier: Timestamp) -> Option<u64> {
						if self >= earlier {
							Some(self.0 - earlier.0)
						} else {
							None
						}
					}

					/// Saturating subtraction (returns 0 if would underflow)
					pub fn saturating_sub(self, other: Timestamp) -> u64 {
						self.0.saturating_sub(other.0)
					}
				}

				// ═══════════════════════════════════════════════════════════════
				// ARITHMETIC OPERATIONS
				// ═══════════════════════════════════════════════════════════════

				impl Add<u64> for Timestamp {
					type Output = Timestamp;

					fn add(self, rhs: u64) -> Timestamp {
						Timestamp(self.0 + rhs)
					}
				}

				impl Sub for Timestamp {
					type Output = u64;

					fn sub(self, rhs: Timestamp) -> u64 {
						self.0 - rhs.0
					}
				}

				impl Sub<u64> for Timestamp {
					type Output = Timestamp;

					fn sub(self, rhs: u64) -> Timestamp {
						Timestamp(self.0 - rhs)
					}
				}

				// ═══════════════════════════════════════════════════════════════
				// CONVERSIONS
				// ═══════════════════════════════════════════════════════════════

				impl From<u64> for Timestamp {
					fn from(value: u64) -> Self {
						Timestamp(value)
					}
				}

				impl From<Timestamp> for u64 {
					fn from(ts: Timestamp) -> u64 {
						ts.0
					}
				}

				// ═══════════════════════════════════════════════════════════════
				// DISPLAY
				// ═══════════════════════════════════════════════════════════════

				impl fmt::Display for Timestamp {
					fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
						write!(f, "{}", self.0)
					}
				}

				// ═══════════════════════════════════════════════════════════════
				// DURATION (Optional - for future use)
				// ═══════════════════════════════════════════════════════════════

				/// DaemonicDuration - Time elapsed between two timestamps
				///
				/// Currently just a u64, but wrapped for type safety.
				#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
				pub struct Duration(u64);

				impl Duration {
					pub const fn new(ticks: u64) -> Self {
						Self(ticks)
					}

					pub const fn zero() -> Self {
						Self(0)
					}

					pub const fn as_u64(self) -> u64 {
						self.0
					}

					pub const fn is_zero(self) -> bool {
						self.0 == 0
					}
				}

				impl From<u64> for Duration {
					fn from(ticks: u64) -> Self {
						Duration(ticks)
					}
				}

				impl From<Duration> for u64 {
					fn from(d: Duration) -> u64 {
						d.0
					}
				}

				impl fmt::Display for Duration {
					fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
						write!(f, "{} ticks", self.0)
					}
				}

				#[cfg(test)]
				mod tests {
					use super::*;

					#[test]
					fn test_timestamp_creation() {
						let ts = Timestamp::new(42);
						assert_eq!(ts.as_u64(), 42);

						let zero = Timestamp::zero();
						assert!(zero.is_zero());
						assert_eq!(zero.as_u64(), 0);
					}

					#[test]
					fn test_timestamp_arithmetic() {
						let t1 = Timestamp::new(100);
						let t2 = Timestamp::new(200);

						// Addition
						assert_eq!(t1 + 50, Timestamp::new(150));

						// Subtraction (Timestamp - Timestamp = u64)
						assert_eq!(t2 - t1, 100);

						// Subtraction (Timestamp - u64 = Timestamp)
						assert_eq!(t2 - 50, Timestamp::new(150));
					}

					#[test]
					fn test_timestamp_elapsed() {
						let t1 = Timestamp::new(100);
						let t2 = Timestamp::new(200);

						assert_eq!(t2.elapsed_since(t1), 100);
						assert_eq!(t2.checked_elapsed_since(t1), Some(100));

						// Earlier > later
						assert_eq!(t1.checked_elapsed_since(t2), None);
					}

					#[test]
					fn test_timestamp_ordering() {
						let t1 = Timestamp::new(100);
						let t2 = Timestamp::new(200);

						assert!(t1 < t2);
						assert!(t2 > t1);
						assert_eq!(t1, Timestamp::new(100));
					}

					#[test]
					fn test_timestamp_conversions() {
						let value: u64 = 42;
						let ts: Timestamp = value.into();
						let back: u64 = ts.into();

						assert_eq!(back, value);
					}
				}
			}

			use types::*;

			// ═══════════════════════════════════════════════════════════════
			// DAEMONIC CLOCK TRAIT
			// ═══════════════════════════════════════════════════════════════
			/// DaemonicClock - Unified time interface for all Daemonic entities
			///
			/// This trait abstracts over different clock implementations:
			/// - Logical clocks: Lamport, Vector, Hybrid Logical Clock
			/// - Physical clocks: MTP (Mesh Temporal Protocol), NTP, System
			///
			/// All Daemonic entities (Shade, Walker, etc.) use this trait
			/// to access time, ensuring consistent temporal semantics across
			/// the system regardless of underlying clock implementation.
			///
			/// # Design Principles
			///
			/// 1. **Type Safety**: Associated types prevent mixing timestamps
			///    from different clock types at compile time.
			///
			/// 2. **Error Handling**: All operations return `Result<T, DaemonicError>`
			///    for unified error handling across the system.
			///
			/// 3. **Thread Safety**: Must be Send + Sync for use in async contexts.
			///
			/// 4. **Clone**: Clock references should be cheap to copy (Arc inside).
			///
			/// # Implementations
			///
			/// - `LamportClock`: Logical event counter
			/// - `MtpClock`: Physical mesh-synchronized time (future)
			/// - `HybridClock`: Combines Lamport + MTP for total order (future)
			pub trait DaemonicClock<'clock, FORMAT, PARTIAL>: Clone + Send + Sync + Debug + 'clock {
				// ══ Reading Time ══════════════════════════════════════════════

				/// Read current time
				///
				/// Returns: Current timestamp from this clock
				///
				/// # Errors
				///
				/// - `ClockError::Overflow`: Timestamp would overflow
				/// - `ClockError::Unavailable`: Clock not synchronized (physical clocks)
				fn now(&self) -> Result<Timestamp, impl DaemonicError<FORMAT, PARTIAL>>;

				// ══ Advancing Time ════════════════════════════════════════════

				/// Advance clock by one tick
				///
				/// For logical clocks: Increments counter, returns new timestamp
				/// For physical clocks: No-op, returns current wall time
				///
				/// Returns: Timestamp after tick
				///
				/// # Errors
				///
				/// - `ClockError::Overflow`: Would overflow
				fn tick(&self) -> Result<Timestamp, impl DaemonicError<FORMAT, PARTIAL>>;

				/// Synchronize with external timestamp
				///
				/// For logical clocks: max(local, external) + 1 (Lamport rule)
				/// For physical clocks: Adjusts frequency/offset to match
				///
				/// Returns: Timestamp after sync
				///
				/// # Errors
				///
				/// - `ClockError::Overflow`: Would overflow
				/// - `ClockError::InvalidTimestamp`: External timestamp invalid
				/// ***NOTE AND WARNING***: Mesh clocks should not sync, and logical clocks should **NEVER** be
				/// fucked with unless theres a reason, and that reason MUST be signed.
				/// Note: Clock drift is expected behavior.
				/// Relativistic physics is blunt about this point in particular, there is no universal clock
				/// or authoritative timestamp, and Faustian axiom #4 and 5 state:
				/// No Privileged Reference frames: Which encompasses temporal reference frames
				/// Observer equivalence within shared context: Which translates to = `" Every clock is correct
				/// to its own reference frame, and in shared context all clocks are equal and therefore none
				/// can claim authority or correctness over any other. "`
				/// Use this method with caution and knowing.
				fn sync(&self, external: Timestamp) -> Result<Timestamp, impl DaemonicError<FORMAT, PARTIAL>>;

				// ══ Time Comparison ═══════════════════════════════════════════

				/// Compare two timestamps
				///
				/// Returns: Ordering of a vs b
				fn compare(&self, a: Timestamp, b: Timestamp) -> std::cmp::Ordering {
					a.cmp(&b) // Use Timestamp's Ord impl
				}

				/// Check if timestamp is zero (invalid/broken)
				fn is_zero(&self, ts: Timestamp) -> bool {
					ts.is_zero() // Use Timestamp's method
				}

				// ══ DaemonicDuration Operations ═══════════════════════════════════════

				/// Calculate duration between two timestamps
				///
				/// Returns: b - a (ticks elapsed)
				///
				/// # Errors
				///
				/// - `ClockError::InvalidDuration`: a > b (negative duration)
				fn duration_between(
					&self,
					a: Timestamp,
					b: Timestamp,
				) -> Result<Duration, impl DaemonicError<FORMAT, PARTIAL>>;

				// ══ Clock Metadata ════════════════════════════════════════════

				/// Get clock type identifier
				///
				/// Returns: String like "lamport", "mtp", "hybrid"
				fn clock_type<'clocktype>(&self) -> &'clocktype str;

				/// Check if clock is healthy
				///
				/// For logical clocks: Checks for overflow proximity
				/// For physical clocks: Checks sync status
				fn is_healthy(&self) -> bool;
			}

			// ═══════════════════════════════════════════════════════════════
			// EXTENSION TRAITS (Optional capabilities)
			// ═══════════════════════════════════════════════════════════════

			/// Extension for clocks that support frequency steering
			///
			/// Implemented by: Physical clocks (MTP, NTP)
			/// Not implemented by: Logical clocks (Lamport, Vector)
			pub trait SteerableClock<FORMAT, PARTIAL>: for<'steerableclock> DaemonicClock<'steerableclock, FORMAT, PARTIAL> {
				/// Set clock frequency adjustment
				///
				/// Parameter: Frequency multiplier (1.0 = normal speed)
				/// Returns: Timestamp when adjustment applied
				fn set_frequency(&self, freq: f64) -> Result<Timestamp, impl DaemonicError<FORMAT, PARTIAL>>;

				/// Get current frequency adjustment
				fn get_frequency(&self) -> Result<f64, impl DaemonicError<FORMAT, PARTIAL>>;
			}

			/// Extension for clocks that support stepping (jumping)
			///
			/// Implemented by: Physical clocks
			/// Not implemented by: Logical clocks (would break causality)
			pub trait SteppableClock<FORMAT, PARTIAL>: for<'steppableclock> DaemonicClock<'steppableclock, FORMAT, PARTIAL> {
				/// Step clock by offset
				///
				/// Warning: Can break causality if used carelessly
				/// Use only for: Initial sync, leap seconds
				fn step(&self, offset: Duration) -> Result<Timestamp, impl DaemonicError<FORMAT, PARTIAL>>;
			}

			/// Extension for clocks that track uncertainty
			///
			/// Implemented by: Physical clocks (NTP)
			/// Not implemented by: Logical clocks (no uncertainty)
			pub trait UncertainClock: for<'uncertainclock> DaemonicClock<'uncertainclock, FORMAT, PARTIAL> {
				/// Get current time uncertainty estimate
				///
				/// Returns: Maximum error bound on timestamp
				fn uncertainty(&self) -> Duration;

				/// Update uncertainty estimate
				///
				/// Used by: Synchronization algorithms
				fn set_uncertainty(&self, uncertainty: Duration) -> Result<(), impl DaemonicError<FORMAT, PARTIAL>>;
			}
		}
		pub(crate) mod observation {
			use std::any::Any;
			use std::sync::atomic::AtomicU8;
			use crate::{DaemonicCore, IntoDaemonicResult};
			use crate::daemonic::daemonic_contract::Partial;
			use crate::observer::DaemonicObserver;
			use super::super::Daemonic;

			pub(crate) trait DaemonicObservation<FORMAT, PARTIAL> {
				#[must_use]
				fn observe<TARGET>(&self, target: &TARGET) -> impl crate::GlassState;
				/// DaemonicObservation mode defaults to passive, which doesnt extract state information.
				/// Override at call site to enable Active DaemonicObservation hooks
				fn observation_mode(&self) -> ObservationMode {
					ObservationMode::Passive(Passive)
				}
				fn observation_mode_for(&self, observer: &impl DaemonicObserver<FORMAT, PARTIAL>) ->
				ObservationMode {
					self.observation_mode() // Default: Same for all
				}
			}
			pub(crate) enum ObservationMode {
				/// Constitutes a mode switch for baseline or normal, active observation also
				/// entails `actively` pulling data from whatever object is being observed.
				Active(Active),
				/// Always on, constant, or passive effects. Constant effects or functions gated by
				/// modal functions are still passive under the hood, the mode switcher itself is considered
				/// the active observer.
				///
				///
				/// Example: human wielding rock, Human = Complex observer, Rock = Structure.
				/// Human wielding rock with intent creates objective state in Rock, Rock = weapon if intent
				/// is to injure, which looks like a state change for the rock.
				/// Rock is still considered a passive Observer with constant effects, human's active intent
				/// shapes how the rock is perceived downstream. IE weapon(trait, has behavior when
				/// combined with other methods) vs inert rock(pure structure with no inherent
				/// behavior on its own), both of which constitute a passive observer.
				Passive(Passive),
			}
			pub(crate) struct Active<OUTPUT, ERROR, FORMAT = crate::DaemonicResult<OUTPUT, ERROR>, PARTIAL = dyn Partial> {
				/// Glass Verbosity translates to == Global Debug level, analogous to toggling -v in the console.
				/// Higher = more info.
				/// There are 8 Glass States total, so how this will work in the future is unstable.
				pub glass_verbosity: AtomicU8,

				/// Extraction of whatever is being 'actively' observed is generic, or should be. This probably
				/// needs some work but ideally extraction logic should be defaulted but overridable at call sight
				pub extract_fn: Box<dyn FnOnce()>,

				/// This is an optional box
				pub extract_object: Option<dyn Extract<FORMAT, PARTIAL>>,
			}
			pub(crate) struct Passive {
				/// Glass Verbosity translates to == Global Debug level, analogous to toggling -v in the console.
				/// Higher = more info.
				/// There are 8 Glass States total, so how this will work in the future is unstable.
				pub glass_verbosity: AtomicU8,
			}
			trait Extract<FORMAT, PARTIAL>: DaemonicObserver<FORMAT, PARTIAL> {
				fn extract_self(&self) -> impl IntoDaemonicResult<FORMAT, PARTIAL>;
				fn extract_object() -> impl IntoDaemonicResult<FORMAT, PARTIAL>;
			}
			pub(crate) mod debug {
				use std::any::Any;
				use std::fmt::{Debug, Display};
				use std::sync::atomic::{AtomicU8, Ordering};
				use crate::{DaemonicError, GlassState};
				use crate::daemonic::daemonic_contract::DaemonicResult;
				use crate::daemonic::daemonic_core::observation::display::DaemonicArgument;
				use super::DaemonicObservation;
				use super::error::display::DaemonicDisplay;

				pub(crate) trait DaemonicDebug<FORMAT, PARTIAL>: DaemonicObservation<FORMAT, PARTIAL>
				+ DaemonicDisplay
				+ Send
				+ Sync
				{
					fn fmt(&self, f: &mut super::display::DaemonicFormatter<'_>) -> std::fmt::Result;
					fn debug(&self, msg: impl DaemonicDisplay) -> impl GlassState;
					fn walk_layer(&self, layer: u8, msg: impl DaemonicDisplay);
					fn walk_down(&self, layer: u8, msg: impl DaemonicDisplay);
					fn walk_up(&self, layer: u8, msg: impl DaemonicDisplay);

					// Can escalate to error
					// fn escalate_to_error(&self, glass: impl GlassState) -> Box<dyn crate::DaemonicError<'static>>;
					fn escalate_to_error<'escalation>(&self, glass: impl GlassState<'escalation>) -> impl DaemonicError<FORMAT, PARTIAL>;
				}

				/// Global debug level (0 = off, 1-8 = increasing verbosity).
				/// Analogous to Debug/Trace level, this isnt completely wired in just yet but
				/// in an ideal world would look at env variables set by whatever runtime the Error
				/// system is built on to determine Glass Verbosity at any given point in time.
				/// Ultimately, this static is defaulted to 0 (which still prints important info, this enables
				/// more info) but when called during a closure or set during bootstrap increase how much
				/// of the stack walk gets dumped during run.
				static GLASS_VERBOSITY: AtomicU8 = AtomicU8::new(0);

				/// Set global debug level
				pub fn set_glass_verbosity(level: u8) {
					GLASS_VERBOSITY.store(level, Ordering::Relaxed);
				}

				/// Get current debug level
				pub fn glass_verbosity() -> u8 {
					GLASS_VERBOSITY.load(Ordering::Relaxed)
				}

				/// Walk direction
				#[derive(Debug, Clone, Copy, PartialEq, Eq)]
				pub enum Direction {
					Down,
					Up,
					Lateral,
					Mirror,
				}

				impl Direction {
					pub fn symbol(&self) -> &'static str {
						match self {
							Direction::Down => "↓",
							Direction::Up => "↑",
							Direction::Lateral => "→",
							Direction::Mirror => "∞∞∞",
						}
					}
				}

				/// Walk down into nested context
				///
				/// Prints: `[DEBUG] <↓> [layer N] {message}`
				#[macro_export]
				macro_rules! walk_info {
    ($layer:expr, $($arg:tt)*) => {
            println!("[SHADE] [INFO] [layer {}] {}", $layer, format!($($arg)*));
    };
}
				#[macro_export]
				macro_rules! walk_warn {
    ($layer:expr, $($arg:tt)*) => {
            println!("[SHADE] [WARN] [layer {}] {}", $layer, format!($($arg)*));
    };
}
				#[macro_export]
				macro_rules! walk_down {
    ($layer:expr, $($arg:tt)*) => {
        if $crate::walkguard::level() >= 2 {
            println!("[SHADE] Walking DOWN <↓> [layer {}] {}", $layer, format!($($arg)*));
        }
    };
}
				#[macro_export]
				macro_rules! walk_call {
    ($callnumber:expr, $($arg:tt)*) => {
        if $crate::walkguard::level() >= 4 {
            println!("[DAEMONIC CALL #{}] Walking [layer ∞∞∞] {}", $callnumber, format!($($arg)*));
        }
    };
}

				/// Walk up from nested context
				///
				/// Prints: `[DEBUG] <↑> [layer N] {message}`
				#[macro_export]
				macro_rules! walk_up {
    ($layer:expr, $($arg:tt)*) => {
        if $crate::walkguard::level() >= 2 {
            println!("[SHADE] Walking UP <↑> [layer {}] {}", $layer, format!($($arg)*));
        }
    };
}

				/// Walk laterally (same layer, different branch)
				///
				/// Prints: `[DEBUG] <→> [layer N] {message}`
				#[macro_export]
				macro_rules! walk_lateral {
    ($layer:expr, $($arg:tt)*) => {
        if $crate::walkguard::level() >= 1 {
            println!("[SHADE] [LATERAL-WALK] <→> [layer {}] {}", $layer, format!($($arg)*));
        }
    };
}

				/// Debug at specific layer (no direction)
				///
				/// Prints: `[DEBUG] [layer N] {message}`
				#[macro_export]
				macro_rules! walk_layer {
    ($layer:expr, $($arg:tt)*) => {
        if $crate::walkguard::level() >= 1 {
            println!("[SHADE] [VERBOSE] [layer {}] {}", $layer, format!($($arg)*));
        }
    };
}

				/// Verbose debug (level 2+)
				#[macro_export]
				macro_rules! walk_verbose {
    ($layer:expr, $($arg:tt)*) => {
        if $crate::walkguard::level() >= 2 {
            println!("[SHADE] [DEBUG] [layer {}] {}", $layer, format!($($arg)*));
        }
    };
}

				/// Extra verbose debug (level 3+)
				#[macro_export]
				macro_rules! walk_trace {
    ($layer:expr, $($arg:tt)*) => {
        if $crate::walkguard::level() >= 3 {
            println!("[SHADE] [TRACE] [layer {}] {}", $layer, format!($($arg)*));
        }
    };
}
				/// Circuit breaker tripped (error/early exit)
				/// This isnt quite an error, but is meant to accompany an error for additional context without
				/// modifying the actual error message or function underneath
				#[macro_export]
				macro_rules! walk_break {
    ($layer:expr, $($arg:tt)*) => {
            println!("[SHADE] [DAEMONIC ERROR] [⚡ BREAK] [layer {}] {}", $layer, format!($($arg)*));
    };
}

				/// Boundary crossing marker
				///
				/// Prints: `[DEBUG] <-> Stepped to layer N`
				#[macro_export]
				macro_rules! walk_boundary {
    ($from:expr, $to:expr) => {
        if $crate::walkguard::level() >= 2 {
            let direction = if $to > $from {
                "down to"
            } else if $to < $from {
                "up to"
            } else {
                "lateral to"
            };
            println!("[SHADE] [BOUNDARY-WALK] <-> Stepped {} layer {}", direction, $to);
        }
    };
}
				pub struct WalkGuard {
					layer: u8,
					context: String,
				}

				impl WalkGuard {
					/// Create new walk guard
					pub fn new(layer: u8, context: impl Into<String>) -> Self {
						let context = context.into();
						walk_down!(layer, "{}", context);
						walk_boundary!(layer.saturating_sub(1), layer);
						Self { layer, context }
					}

					/// Create guard without printing walk_down (for manual control)
					pub fn silent(layer: u8, context: impl Into<String>) -> Self {
						Self {
							layer,
							context: context.into(),
						}
					}
					pub fn call(layer: u8, context: impl Into<String>) -> Self {
						Self {
							layer,
							context: context.into(),
						}
					}
				}

				impl Drop for WalkGuard {
					fn drop(&mut self) {
						walk_boundary!(self.layer, self.layer.saturating_sub(1));
						walk_up!(self.layer, "{} complete", self.context);
					}
				}
			}
			pub(crate) mod display {
				use std::hint::unreachable_unchecked;
				use std::fmt::{write, Arguments, Debug, Display, Error, Formatter, FormattingOptions, Write};
				use std::marker::PhantomData;
				use std::ptr::NonNull;
				use crate::DaemonicError;
				use super::debug::DaemonicDebug;

				/// *Note: This is a clone from stdlib adapted to Daemonic Logic*
				/// Change from stdlib: buffer lifetime made explicit, no longer stubbed to `'a`
				///
				///
				/// Format trait for an empty format, `{}`.
				///
				/// Implementing this trait for a type will automatically implement the
				/// [`ToString`][tostring] trait for the type, allowing the usage
				/// of the [`.to_string()`][tostring_function] method. Prefer implementing
				/// the `Display` trait for a type, rather than [`ToString`][tostring].
				///
				/// `Display` is similar to [`Debug`], but `Display` is for user-facing
				/// output, and so cannot be derived.
				///
				/// For more information on formatters, see [the module-level documentation][module].
				///
				/// [module]: ../../std/fmt/index.html
				/// [tostring]: ../../std/string/trait.ToString.html
				/// [tostring_function]: ../../std/string/trait.ToString.html#tymethod.to_string
				///
				/// # Internationalization
				///
				/// Because a type can only have one `Display` implementation, it is often preferable
				/// to only implement `Display` when there is a single most "obvious" way that
				/// values can be formatted as text. This could mean formatting according to the
				/// "invariant" culture and "undefined" locale, or it could mean that the type
				/// display is designed for a specific culture/locale, such as developer logs.
				///
				/// If not all values have a justifiably canonical textual format or if you want
				/// to support alternative formats not covered by the standard set of possible
				/// [formatting traits], the most flexible approach is display adapters: methods
				/// like [`str::escape_default`] or [`Path::display`] which create a wrapper
				/// implementing `Display` to output the specific display format.
				///
				/// [formatting traits]: ../../std/fmt/index.html#formatting-traits
				/// [`Path::display`]: ../../std/path/struct.Path.html#method.display
				///
				/// # Examples
				///
				/// Implementing `Display` on a type:
				///
				/// ```
				/// use std::fmt;
				///
				/// struct Point {
				///     x: i32,
				///     y: i32,
				/// }
				///
				/// impl fmt::Display for Point {
				///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
				///         write!(f, "({}, {})", self.x, self.y)
				///     }
				/// }
				///
				/// let origin = Point { x: 0, y: 0 };
				///
				/// assert_eq!(format!("The origin is: {origin}"), "The origin is: (0, 0)");
				/// ```
				#[rustc_on_unimplemented(
					on(
						any(_Self = "std::path::Path", _Self = "std::path::PathBuf"),
						label = "`{Self}` cannot be formatted with the default formatter; call `.display()` on it",
						note = "call `.display()` or `.to_string_lossy()` to safely print paths, \
                as they may contain non-Unicode data"
					),
					message = "`{Self}` doesn't implement `{Display}`",
					label = "`{Self}` cannot be formatted with the default formatter",
					note = "in format strings you may be able to use `{{:?}}` (or {{:#?}} for pretty-print) instead"
				)]
				#[doc(alias = "{}")]
				// #[rustc_diagnostic_item = "DaemonicDisplay"]
				pub trait DaemonicDisplay {
					///
					/// # Examples
					///
					/// ```
					///
					/// struct Position {
					///     longitude: f32,
					///     latitude: f32,
					/// }
					///
					/// impl DaemonicDisplay for Position {
					///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
					///         write!(f, "({}, {})", self.longitude, self.latitude)
					///     }
					/// }
					///
					/// assert_eq!(
					///     "(1.987, 2.983)",
					///     format!("{}", Position { longitude: 1.987, latitude: 2.983, }),
					/// );
					/// ```
					#[stable(feature = "rust1", since = "1.0.0")]
					fn fmt<'buffer>(&self, f: &mut DaemonicFormatter<'buffer>) -> std::fmt::Result;
				}
				/// A trait for writing or formatting into Unicode-accepting buffers or streams.
				///
				/// This trait only accepts UTF-8–encoded data and is not [flushable]. If you only
				/// want to accept Unicode and you don't need flushing, you should implement this trait;
				/// otherwise you should implement [`std::io::Write`].
				///
				/// [`std::io::Write`]: ../../std/io/trait.Write.html
				/// [flushable]: ../../std/io/trait.Write.html#tymethod.flush
				pub trait DaemonicWrite {
					/// Writes a string slice into this writer, returning whether the write
					/// succeeded.
					///
					/// This method can only succeed if the entire string slice was successfully
					/// written, and this method will not return until all data has been
					/// written or an error occurs.
					///
					/// # Errors
					///
					/// This function will return an instance of [`std::fmt::Error`][Error] on error.
					///
					/// The purpose of that error is to abort the formatting operation when the underlying
					/// destination encounters some error preventing it from accepting more text;
					/// in particular, it does not communicate any information about *what* error occurred.
					/// It should generally be propagated rather than handled, at least when implementing
					/// formatting traits.
					///
					/// # Examples
					///
					/// ```
					/// use std::fmt::{Error, Write};
					///
					/// fn writer<W: Write>(f: &mut W, s: &str) -> Result<(), Error> {
					///     f.write_str(s)
					/// }
					///
					/// let mut buf = String::new();
					/// writer(&mut buf, "hola")?;
					/// assert_eq!(&buf, "hola");
					/// # std::fmt::Result::Ok(())
					/// ```
					fn write_str(&mut self, s: &str) -> std::fmt::Result;

					/// Writes a [`char`] into this writer, returning whether the write succeeded.
					///
					/// A single [`char`] may be encoded as more than one byte.
					/// This method can only succeed if the entire byte sequence was successfully
					/// written, and this method will not return until all data has been
					/// written or an error occurs.
					///
					/// # Errors
					///
					/// This function will return an instance of [`Error`] on error.
					///
					/// # Examples
					///
					/// ```
					/// use std::fmt::{Error, Write};
					///
					/// fn writer<W: Write>(f: &mut W, c: char) -> Result<(), Error> {
					///     f.write_char(c)
					/// }
					///
					/// let mut buf = String::new();
					/// writer(&mut buf, 'a')?;
					/// writer(&mut buf, 'b')?;
					/// assert_eq!(&buf, "ab");
					/// # std::fmt::Result::Ok(())
					/// ```
					fn write_char(&mut self, c: char) -> std::fmt::Result {
						self.write_str(c.encode_utf8(&mut [0; 4]))
					}

					/// Glue for usage of the [`write!`] macro with implementors of this trait.
					///
					/// This method should generally not be invoked manually, but rather through
					/// the [`write!`] macro itself.
					///
					/// # Errors
					///
					/// This function will return an instance of [`Error`] on error. Please see
					/// [write_str](std::fmt::Write::write_str) for details.
					///
					/// # Examples
					///
					/// ```
					/// use std::fmt::{Error, Write};
					///
					/// fn writer<W: Write>(f: &mut W, s: &str) -> Result<(), Error> {
					///     f.write_fmt(format_args!("{s}"))
					/// }
					///
					/// let mut buf = String::new();
					/// writer(&mut buf, "world")?;
					/// assert_eq!(&buf, "world");
					/// # std::fmt::Result::Ok(())
					/// ```
					fn write_fmt(&mut self, args: DaemonicArguments<'_>) -> std::fmt::Result {
						// We use a specialization for `Sized` types to avoid an indirection
						// through `&mut self`
						trait SpecWriteFmt {
							fn spec_write_fmt(self, args: DaemonicArguments<'_>) -> std::fmt::Result;
						}

						impl<W: DaemonicWrite + ?Sized> SpecWriteFmt for &mut W {
							#[inline]
							default fn spec_write_fmt(mut self, args: DaemonicArguments<'_>) -> std::fmt::Result {
								daemonic_write(&mut self, args)
							}
						}

						impl<W: DaemonicWrite> SpecWriteFmt for &mut W {
							#[inline]
							fn spec_write_fmt(self, args: DaemonicArguments<'_>) -> std::fmt::Result {
								// if let Some(s) = args.as_statically_known_str() {
								// 	self.write_str(s)
								// } else {
								daemonic_write(self, args)
								// }
							}
						}

						self.spec_write_fmt(args)
					}
				}
				pub fn daemonic_write(output: &mut dyn Write, args: DaemonicArguments<'_>) -> std::fmt::Result {
					let mut formatter = DaemonicFormatter::new(output, DaemonicFormattingOptions::new());
					let mut idx = 0;

					match args.fmt {
						None => {
							// We can use default formatting parameters for all arguments.
							for (i, arg) in args.args.iter().enumerate() {
								// SAFETY: args.args and args.pieces come from the same Arguments,
								// which guarantees the indexes are always within bounds.
								let piece = unsafe { args.pieces.get_unchecked(i) };
								if !piece.is_empty() {
									formatter.buf.write_str(*piece)?;
								}

								// SAFETY: There are no formatting parameters and hence no
								// count arguments.
								unsafe {
									arg.fmt(&mut formatter)?;
								}
								idx += 1;
							}
						}
						Some(fmt) => {
							// Every spec has a corresponding argument that is preceded by
							// a string piece.
							for (i, arg) in fmt.iter().enumerate() {
								// SAFETY: fmt and args.pieces come from the same Arguments,
								// which guarantees the indexes are always within bounds.
								let piece = unsafe { args.pieces.get_unchecked(i) };
								if !piece.is_empty() {
									formatter.buf.write_str(*piece)?;
								}
								// SAFETY: arg and args.args come from the same Arguments,
								// which guarantees the indexes are always within bounds.
								unsafe { run(&mut formatter, arg, args.args) }?;
								idx += 1;
							}
						}
					}

					// There can be only one trailing string piece left.
					if let Some(piece) = args.pieces.get(idx) {
						formatter.buf.write_str(*piece)?;
					}

					Ok(())
				}
				/// This structure represents a safely precompiled version of a format string
				/// and its arguments. This cannot be generated at runtime because it cannot
				/// safely be done, so no constructors are given and the fields are private
				/// to prevent modification.
				///
				/// The [`format_args!`] macro will safely create an instance of this structure.
				/// The macro validates the format string at compile-time so usage of the
				/// [`write()`] and [`format()`] functions can be safely performed.
				///
				/// You can use the `Arguments<'a>` that [`format_args!`] returns in `Debug`
				/// and `Display` contexts as seen below. The example also shows that `Debug`
				/// and `Display` format to the same thing: the interpolated format string
				/// in `format_args!`.
				///
				/// ```rust
				/// let debug = format!("{:?}", format_args!("{} foo {:?}", 1, 2));
				/// let display = format!("{}", format_args!("{} foo {:?}", 1, 2));
				/// assert_eq!("1 foo 2", display);
				/// assert_eq!(display, debug);
				/// ```
				///
				/// [`format()`]: ../../std/fmt/fn.format.html
				#[derive(Copy, Clone)]
				pub struct DaemonicArguments<'args> {
					// Format string pieces to print.
					pieces: &'args [&'static str],

					// Placeholder specs, or `None` if all specs are default (as in "{}{}").
					fmt: Option<&'args [DaemonicPlaceholder]>,

					// Dynamic arguments for interpolation, to be interleaved with string
					// pieces. (Every argument is preceded by a string piece.)
					args: &'args [DaemonicArgument<'args>],
				}
				/// This struct represents a generic "argument" which is taken by format_args!().
				///
				/// This can be either a placeholder argument or a count argument.
				/// * A placeholder argument contains a function to format the given value. At
				///   compile time it is ensured that the function and the value have the correct
				///   types, and then this struct is used to canonicalize arguments to one type.
				///   Placeholder arguments are essentially an optimized partially applied formatting
				///   function, equivalent to `exists T.(&T, fn(&T, &mut Formatter<'_>) -> Result`.
				/// * A count argument contains a count for dynamic formatting parameters like
				///   precision and width.
				#[derive(Copy, Clone)]
				pub struct DaemonicArgument<'args> {
					ty: ArgumentType<'args>,
				}
				#[derive(Copy, Clone)]
				enum ArgumentType<'a> {
					Placeholder {
						// INVARIANT: `formatter` has type `fn(&T, _) -> _` for some `T`, and `value`
						// was derived from a `&'a T`.
						value: NonNull<()>,
						formatter: unsafe fn(NonNull<()>, &mut DaemonicFormatter<'_>) -> std::fmt::Result,
						_lifetime: PhantomData<&'a ()>,
					},
					Count(u16),
				}
				#[derive(Copy, Clone)]
				pub struct DaemonicPlaceholder {
					pub position: usize,
					pub flags: u32,
					pub precision: Count,
					pub width: Count,
				}
				#[doc(hidden)]
				impl<'args> DaemonicArguments<'args> {
					/// Estimates the length of the formatted text.
					///
					/// This is intended to be used for setting initial `String` capacity
					/// when using `format!`. Note: this is neither the lower nor upper bound.
					#[inline]
					pub fn estimated_capacity(&self) -> usize {
						let pieces_length: usize = self.pieces.iter().map(|x| x.len()).sum();

						if self.args.is_empty() {
							pieces_length
						} else if !self.pieces.is_empty() && self.pieces[0].is_empty() && pieces_length < 16 {
							// If the format string starts with an argument,
							// don't preallocate anything, unless length
							// of pieces is significant.
							0
						} else {
							// There are some arguments, so any additional push
							// will reallocate the string. To avoid that,
							// we're "pre-doubling" the capacity here.
							pieces_length.checked_mul(2).unwrap_or(0)
						}
					}
					/// Gets the formatted string, if it has no arguments to be formatted at runtime.
					///
					/// This can be used to avoid allocations in some cases.
					///
					/// # Guarantees
					///
					/// For `format_args!("just a literal")`, this function is guaranteed to
					/// return `Some("just a literal")`.
					///
					/// For most cases with placeholders, this function will return `None`.
					///
					/// However, the compiler may perform optimizations that can cause this
					/// function to return `Some(_)` even if the format string contains
					/// placeholders. For example, `format_args!("Hello, {}!", "world")` may be
					/// optimized to `format_args!("Hello, world!")`, such that `as_str()`
					/// returns `Some("Hello, world!")`.
					///
					/// The behavior for anything but the trivial case (without placeholders)
					/// is not guaranteed, and should not be relied upon for anything other
					/// than optimization.
					///
					/// # Examples
					///
					/// ```rust
					/// use std::fmt::Arguments;
					///
					/// fn write_str(_: &str) { /* ... */ }
					///
					/// fn write_fmt(args: &Arguments<'_>) {
					///     if let Some(s) = args.as_str() {
					///         write_str(s)
					///     } else {
					///         write_str(&args.to_string());
					///     }
					/// }
					/// ```
					///
					/// ```rust
					/// assert_eq!(format_args!("hello").as_str(), Some("hello"));
					/// assert_eq!(format_args!("").as_str(), Some(""));
					/// assert_eq!(format_args!("{:?}", std::env::current_dir()).as_str(), None);
					/// ```
					#[must_use]
					#[inline]
					pub const fn as_str(&self) -> Option<&'static str> {
						match (self.pieces, self.args) {
							([], []) => Some(""),
							([s], []) => Some(s),
							_ => None,
						}
					}

					// Same as [`std::fmt::Arguments::as_str`], but will only return `Some(s)` if it can be determined at compile time.
					// #[must_use]
					// #[inline]
					// #[doc(hidden)]
					// pub unsafe fn as_statically_known_str(&self) -> Option<&'static str> {
					// 	let s = self.as_str();
					// 	if core::intrinsics::is_val_statically_known(s.is_some()) { s } else { None }
					// }
				}

				// Manually implementing these results in better error messages.
				impl ! Send for DaemonicArguments<'_> {}
				impl ! Sync for DaemonicArguments<'_> {}
				impl Debug for DaemonicArguments<'_> {
					fn fmt(&self, fmt: &mut DaemonicFormatter<'_>) -> std::fmt::Result {
						DaemonicDisplay::fmt(self, fmt)
					}
				}

				impl DaemonicDisplay for DaemonicArguments<'_> {
					fn fmt(&self, fmt: &mut DaemonicFormatter<'_>) -> std::fmt::Result {
						/// Takes an output stream and an `Arguments` struct that can be precompiled with
						/// the `format_args!` macro.
						///
						/// The arguments will be formatted according to the specified format string
						/// into the output stream provided.
						///
						/// # Examples
						///
						/// Basic usage:
						///
						/// ```
						/// use std::fmt;
						///
						/// let mut output = String::new();
						/// fmt::write(&mut output, format_args!("Hello {}!", "world"))
						///     .expect("Error occurred while trying to write in String");
						/// assert_eq!(output, "Hello world!");
						/// ```
						///
						/// Please note that using [`write!`] might be preferable. Example:
						///
						/// ```
						/// use std::fmt::Write;
						///
						/// let mut output = String::new();
						/// write!(&mut output, "Hello {}!", "world")
						///     .expect("Error occurred while trying to write in String");
						/// assert_eq!(output, "Hello world!");
						/// ```
						///
						/// [`write!`]: crate::write!
						fn write(output: &mut dyn DaemonicWrite, args: DaemonicArguments<'_>) -> std::fmt::Result {
							let mut formatter = DaemonicFormatter::new(output, DaemonicFormattingOptions::new());
							let mut idx = 0;

							match args.fmt {
								None => {
									// We can use default formatting parameters for all arguments.
									for (i, arg) in args.args.iter().enumerate() {
										// SAFETY: args.args and args.pieces come from the same Arguments,
										// which guarantees the indexes are always within bounds.
										let piece = unsafe { args.pieces.get_unchecked(i) };
										if !piece.is_empty() {
											formatter.buf.write_str(*piece)?;
										}

										// SAFETY: There are no formatting parameters and hence no
										// count arguments.
										unsafe {
											arg.fmt(&mut formatter)?;
										}
										idx += 1;
									}
								}
								Some(fmt) => {
									// Every spec has a corresponding argument that is preceded by
									// a string piece.
									for (i, arg) in fmt.iter().enumerate() {
										// SAFETY: fmt and args.pieces come from the same Arguments,
										// which guarantees the indexes are always within bounds.
										let piece = unsafe { args.pieces.get_unchecked(i) };
										if !piece.is_empty() {
											formatter.buf.write_str(*piece)?;
										}
										// SAFETY: arg and args.args come from the same Arguments,
										// which guarantees the indexes are always within bounds.
										unsafe { run(&mut formatter, arg, args.args) }?;
										idx += 1;
									}
								}
							}

							// There can be only one trailing string piece left.
							if let Some(piece) = args.pieces.get(idx) {
								formatter.buf.write_str(*piece)?;
							}

							Ok(())
						}
						write(fmt.buf, *self)
					}
				}

				unsafe fn run(fmt: &mut DaemonicFormatter<'_>, arg: &DaemonicPlaceholder, args: &[DaemonicArgument<'_>]) -> std::fmt::Result {
					let (width, precision) =
						// SAFETY: arg and args come from the same Arguments,
						// which guarantees the indexes are always within bounds.
						unsafe { (getcount(args, &arg.width), getcount(args, &arg.precision)) };

					let options = DaemonicFormattingOptions { flags: arg.flags, width, precision };

					// Extract the correct argument
					debug_assert!(arg.position < args.len());
					// SAFETY: arg and args come from the same Arguments,
					// which guarantees its index is always within bounds.
					let value = unsafe { args.get_unchecked(arg.position) };

					// Set all the formatting options.
					fmt.options = options;

					// Then actually do some printing
					// SAFETY: this is a placeholder argument.
					unsafe { value.fmt(fmt) }
				}

				unsafe fn getcount(args: &[rt::Argument<'_>], cnt: &rt::Count) -> u16 {
					match *cnt {
						Count::Is(n) => n,
						Count::Implied => 0,
						Count::Param(i) => {
							debug_assert!(i < args.len());
							// SAFETY: cnt and args come from the same Arguments,
							// which guarantees this index is always within bounds.
							unsafe { args.get_unchecked(i).as_u16().unwrap_unchecked() }
						}
					}
				}

				impl<WRITE: DaemonicWrite + ?Sized> DaemonicWrite for &mut WRITE {
					fn write_str(&mut self, s: &str) -> std::fmt::Result {
						(**self).write_str(s)
					}

					fn write_char(&mut self, c: char) -> std::fmt::Result {
						(**self).write_char(c)
					}

					fn write_fmt(&mut self, args: DaemonicArguments<'_>) -> std::fmt::Result {
						(**self).write_fmt(args)
					}
				}
				/// Configuration for formatting.
				///
				/// A `Formatter` represents various options related to formatting. Users do not
				/// construct `Formatter`s directly; a mutable reference to one is passed to
				/// the `fmt` method of all formatting traits, like [`Debug`] and [`Display`].
				///
				/// To interact with a `Formatter`, you'll call various methods to change the
				/// various options related to formatting. For examples, please see the
				/// documentation of the methods defined on `Formatter` below.
				#[allow(missing_debug_implementations)]
				// #[rustc_diagnostic_item = "DaemonicFormatter"]
				pub struct DaemonicFormatter<'buffer> {
					options: DaemonicFormattingOptions,

					buf: &'buffer mut (dyn DaemonicWrite + 'buffer),
				}
				/// Options for formatting.
				///
				/// `DaemonicFormattingOptions` is a [`DaemonicFormatter`] without an attached [`Write`] trait.
				/// It is mainly used to construct `Formatter` instances.
				#[derive(Copy, Clone, Debug, PartialEq, Eq)]
				// #[rustc_diagnostic_item = "DaemonicFormatter"]
				pub struct DaemonicFormattingOptions {
					/// Flags, with the following bit fields:
					///
					/// ```text
					///   31  30  29  28  27  26  25  24  23  22  21  20                              0
					/// ┌───┬───────┬───┬───┬───┬───┬───┬───┬───┬───┬──────────────────────────────────┐
					/// │ 1 │ align │ p │ w │ X?│ x?│'0'│ # │ - │ + │               fill               │
					/// └───┴───────┴───┴───┴───┴───┴───┴───┴───┴───┴──────────────────────────────────┘
					///   │     │     │   │  └─┬───────────────────┘ └─┬──────────────────────────────┘
					///   │     │     │   │    │                       └─ The fill character (21 bits char).
					///   │     │     │   │    └─ The debug upper/lower hex, zero pad, alternate, and plus/minus flags.
					///   │     │     │   └─ Whether a width is set. (The value is stored separately.)
					///   │     │     └─ Whether a precision is set. (The value is stored separately.)
					///   │     ├─ 0: Align left. (<)
					///   │     ├─ 1: Align right. (>)
					///   │     ├─ 2: Align center. (^)
					///   │     └─ 3: DaemonicAlignment not set. (default)
					///   └─ Always set.
					///      This makes it possible to distinguish formatting flags from
					///      a &str size when stored in (the upper bits of) the same field.
					///      (fmt::Arguments will make use of this property in the future.)
					/// ```
					// Note: This could use a special niche type with range 0x8000_0000..=0xfdd0ffff.
					// It's unclear if that's useful, though.
					flags: u32,
					/// Width if width flag (bit 27) above is set. Otherwise, always 0.
					width: u16,
					/// Precision if precision flag (bit 28) above is set. Otherwise, always 0.
					precision: u16,
				}
				impl DaemonicFormattingOptions {
					/// Construct a new `FormatterBuilder` with the supplied `Write` trait
					/// object for output that is equivalent to the `{}` formatting
					/// specifier:
					///
					/// - no flags,
					/// - filled with spaces,
					/// - no alignment,
					/// - no width,
					/// - no precision, and
					/// - no [`DebugAsHex`] output mode.
					pub const fn new() -> Self {
						Self {
							flags: ' ' as u32 | flags::ALIGN_UNKNOWN | flags::ALWAYS_SET,
							width: 0,
							precision: 0,
						}
					}

					/// Sets or removes the sign (the `+` or the `-` flag).
					///
					/// - `+`: This is intended for numeric types and indicates that the sign
					/// should always be printed. By default only the negative sign of signed
					/// values is printed, and the sign of positive or unsigned values is
					/// omitted. This flag indicates that the correct sign (+ or -) should
					/// always be printed.
					/// - `-`: Currently not used
					pub fn sign(&mut self, sign: Option<Sign>) -> &mut Self {
						let sign = match sign {
							None => 0,
							Some(Sign::Plus) => flags::SIGN_PLUS_FLAG,
							Some(Sign::Minus) => flags::SIGN_MINUS_FLAG,
						};
						self.flags = self.flags & !(flags::SIGN_PLUS_FLAG | flags::SIGN_MINUS_FLAG) | sign;
						self
					}
					/// Sets or unsets the `0` flag.
					///
					/// This is used to indicate for integer formats that the padding to width should both be done with a 0 character as well as be sign-aware
					pub fn sign_aware_zero_pad(&mut self, sign_aware_zero_pad: bool) -> &mut Self {
						if sign_aware_zero_pad {
							self.flags |= flags::SIGN_AWARE_ZERO_PAD_FLAG;
						} else {
							self.flags &= !flags::SIGN_AWARE_ZERO_PAD_FLAG;
						}
						self
					}
					/// Sets or unsets the `#` flag.
					///
					/// This flag indicates that the "alternate" form of printing should be
					/// used. The alternate forms are:
					/// - [`Debug`] : pretty-print the [`Debug`] formatting (adds linebreaks and indentation)
					/// - [`LowerHex`] as well as [`UpperHex`] - precedes the argument with a `0x`
					/// - [`Octal`] - precedes the argument with a `0b`
					/// - [`Binary`] - precedes the argument with a `0o`
					pub fn alternate(&mut self, alternate: bool) -> &mut Self {
						if alternate {
							self.flags |= flags::ALTERNATE_FLAG;
						} else {
							self.flags &= !flags::ALTERNATE_FLAG;
						}
						self
					}
					/// Sets the fill character.
					///
					/// The optional fill character and alignment is provided normally in
					/// conjunction with the width parameter. This indicates that if the value
					/// being formatted is smaller than width some extra characters will be
					/// printed around it.
					pub fn fill(&mut self, fill: char) -> &mut Self {
						self.flags = self.flags & (u32::MAX << 21) | fill as u32;
						self
					}
					/// Sets or removes the alignment.
					///
					/// The alignment specifies how the value being formatted should be
					/// positioned if it is smaller than the width of the formatter.
					pub fn align(&mut self, align: Option<Alignment>) -> &mut Self {
						let align: u32 = match align {
							Some(Alignment::Left) => flags::ALIGN_LEFT,
							Some(Alignment::Right) => flags::ALIGN_RIGHT,
							Some(Alignment::Center) => flags::ALIGN_CENTER,
							None => flags::ALIGN_UNKNOWN,
						};
						self.flags = self.flags & !flags::ALIGN_BITS | align;
						self
					}
					/// Sets or removes the width.
					///
					/// This is a parameter for the “minimum width” that the format should take
					/// up. If the value’s string does not fill up this many characters, then
					/// the padding specified by [`FormattingOptions::fill`]/[`FormattingOptions::align`]
					/// will be used to take up the required space.
					pub fn width(&mut self, width: Option<u16>) -> &mut Self {
						if let Some(width) = width {
							self.flags |= flags::WIDTH_FLAG;
							self.width = width;
						} else {
							self.flags &= !flags::WIDTH_FLAG;
							self.width = 0;
						}
						self
					}
					/// Sets or removes the precision.
					///
					/// - For non-numeric types, this can be considered a “maximum width”. If
					/// the resulting string is longer than this width, then it is truncated
					/// down to this many characters and that truncated value is emitted with
					/// proper fill, alignment and width if those parameters are set.
					/// - For integral types, this is ignored.
					/// - For floating-point types, this indicates how many digits after the
					/// decimal point should be printed.
					pub fn precision(&mut self, precision: Option<u16>) -> &mut Self {
						if let Some(precision) = precision {
							self.flags |= flags::PRECISION_FLAG;
							self.precision = precision;
						} else {
							self.flags &= !flags::PRECISION_FLAG;
							self.precision = 0;
						}
						self
					}
					/// Specifies whether the [`Debug`] trait should use lower-/upper-case
					/// hexadecimal or normal integers
					pub fn debug_as_hex(&mut self, debug_as_hex: Option<DebugAsHex>) -> &mut Self {
						let debug_as_hex = match debug_as_hex {
							None => 0,
							Some(DebugAsHex::Lower) => flags::DEBUG_LOWER_HEX_FLAG,
							Some(DebugAsHex::Upper) => flags::DEBUG_UPPER_HEX_FLAG,
						};
						self.flags = self.flags & !(flags::DEBUG_LOWER_HEX_FLAG | flags::DEBUG_UPPER_HEX_FLAG)
							| debug_as_hex;
						self
					}

					/// Returns the current sign (the `+` or the `-` flag).
					pub const fn get_sign(&self) -> Option<Sign> {
						if self.flags & flags::SIGN_PLUS_FLAG != 0 {
							Some(Sign::Plus)
						} else if self.flags & flags::SIGN_MINUS_FLAG != 0 {
							Some(Sign::Minus)
						} else {
							None
						}
					}
					/// Returns the current `0` flag.
					pub const fn get_sign_aware_zero_pad(&self) -> bool {
						self.flags & flags::SIGN_AWARE_ZERO_PAD_FLAG != 0
					}
					/// Returns the current `#` flag.
					pub const fn get_alternate(&self) -> bool {
						self.flags & flags::ALTERNATE_FLAG != 0
					}
					/// Returns the current fill character.
					pub const fn get_fill(&self) -> char {
						// SAFETY: We only ever put a valid `char` in the lower 21 bits of the flags field.
						unsafe { char::from_u32_unchecked(self.flags & 0x1FFFFF) }
					}
					/// Returns the current alignment.
					pub const fn get_align(&self) -> Option<Alignment> {
						match self.flags & flags::ALIGN_BITS {
							flags::ALIGN_LEFT => Some(Alignment::Left),
							flags::ALIGN_RIGHT => Some(Alignment::Right),
							flags::ALIGN_CENTER => Some(Alignment::Center),
							_ => None,
						}
					}
					/// Returns the current width.
					pub const fn get_width(&self) -> Option<u16> {
						if self.flags & flags::WIDTH_FLAG != 0 { Some(self.width) } else { None }
					}
					/// Returns the current precision.
					pub const fn get_precision(&self) -> Option<u16> {
						if self.flags & flags::PRECISION_FLAG != 0 { Some(self.precision) } else { None }
					}
					/// Returns the current precision.
					pub const fn get_debug_as_hex(&self) -> Option<DebugAsHex> {
						if self.flags & flags::DEBUG_LOWER_HEX_FLAG != 0 {
							Some(DebugAsHex::Lower)
						} else if self.flags & flags::DEBUG_UPPER_HEX_FLAG != 0 {
							Some(DebugAsHex::Upper)
						} else {
							None
						}
					}

					/// Creates a [`Formatter`] that writes its output to the given [`Write`] trait.
					///
					/// You may alternatively use [`Formatter::new()`].
					pub fn create_formatter<'a>(self, write: &'a mut (dyn Write + 'a)) -> DaemonicFormatter<'a> {
						DaemonicFormatter { options: self, buf: write }
					}
				}
				impl Default for DaemonicFormattingOptions {
					/// Same as [`DaemonicFormattingOptions::new()`].
					fn default() -> Self {
						// The `#[derive(Default)]` implementation would set `fill` to `\0` instead of space.
						Self::new()
					}
				}
				impl<'a> DaemonicFormatter<'a> {
					/// Creates a new formatter with given [`DaemonicFormattingOptions`].
					///
					/// If `write` is a reference to a formatter, it is recommended to use
					/// [`DaemonicFormatter::with_options`] instead as this can borrow the underlying
					/// `write`, thereby bypassing one layer of indirection.
					///
					/// You may alternatively use [`DaemonicFormattingOptions::create_formatter()`].
					pub fn new(write: &'a mut (dyn DaemonicWrite + 'a), options: DaemonicFormattingOptions) -> Self {
						DaemonicFormatter { options, buf: write }
					}

					/// Creates a new formatter based on this one with given [`DaemonicFormattingOptions`].
					pub fn with_options(&mut self, options: DaemonicFormattingOptions) -> DaemonicFormatter {
						DaemonicFormatter { options, buf: self.buf }
					}
				}
				// #[rustc_diagnostic_item = "DaemonicAlignment"]
				/// Possible alignments returned by `DaemonicFormatter::align`
				#[derive(Copy, Clone, Debug, PartialEq, Eq)]
				pub enum Alignment {
					/// Indication that contents should be left-aligned.
					Left,
					/// Indication that contents should be right-aligned.
					Right,
					/// Indication that contents should be center-aligned.
					Center,
				}

				/// The signedness of a [`Formatter`] (or of a [`FormattingOptions`]).
				#[derive(Copy, Clone, Debug, PartialEq, Eq)]
				pub enum Sign {
					Plus,
					Minus,
				}

				/// Specifies whether the [`Debug`] trait should use lower-/upper-case
				/// hexadecimal or normal integers.
				#[derive(Copy, Clone, Debug, PartialEq, Eq)]
				pub enum DebugAsHex {
					Lower,
					Upper,
				}
				// This needs to match with compiler/rustc_ast_lowering/src/format.rs.
				mod flags {
					pub(super) const SIGN_PLUS_FLAG: u32 = 1 << 21;
					pub(super) const SIGN_MINUS_FLAG: u32 = 1 << 22;
					pub(super) const ALTERNATE_FLAG: u32 = 1 << 23;
					pub(super) const SIGN_AWARE_ZERO_PAD_FLAG: u32 = 1 << 24;
					pub(super) const DEBUG_LOWER_HEX_FLAG: u32 = 1 << 25;
					pub(super) const DEBUG_UPPER_HEX_FLAG: u32 = 1 << 26;
					pub(super) const WIDTH_FLAG: u32 = 1 << 27;
					pub(super) const PRECISION_FLAG: u32 = 1 << 28;
					pub(super) const ALIGN_BITS: u32 = 0b11 << 29;
					pub(super) const ALIGN_LEFT: u32 = 0 << 29;
					pub(super) const ALIGN_RIGHT: u32 = 1 << 29;
					pub(super) const ALIGN_CENTER: u32 = 2 << 29;
					pub(super) const ALIGN_UNKNOWN: u32 = 3 << 29;
					pub(super) const ALWAYS_SET: u32 = 1 << 31;
				}

				macro_rules! argument_new {
    ($t:ty, $x:expr, $f:expr) => {
        DaemonicArgument {
            // INVARIANT: this creates an `ArgumentType<'a>` from a `&'a T` and
            // a `fn(&T, ...)`, so the invariant is maintained.
            ty: ArgumentType::Placeholder {
                value: NonNull::<$t>::from_ref($x).cast(),
                // The Rust ABI considers all pointers to be equivalent, so transmuting a fn(&T) to
                // fn(NonNull<()>) and calling it with a NonNull<()> that points at a T is allowed.
                // However, the CFI sanitizer does not allow this, and triggers a crash when it
                // happens.
                //
                // To avoid this crash, we use a helper function when CFI is enabled. To avoid the
                // cost of this helper function (mainly code-size) when it is not needed, we
                // transmute the function pointer otherwise.
                //
                // This is similar to what the Rust compiler does internally with vtables when KCFI
                // is enabled, where it generates trampoline functions that only serve to adjust the
                // expected type of the argument. `ArgumentType::Placeholder` is a bit like a
                // manually constructed trait object, so it is not surprising that the same approach
                // has to be applied here as well.
                //
                // It is still considered problematic (from the Rust side) that CFI rejects entirely
                // legal Rust programs, so we do not consider anything done here a stable guarantee,
                // but meanwhile we carry this work-around to keep Rust compatible with CFI and
                // KCFI.
                #[cfg(not(any(sanitize = "cfi", sanitize = "kcfi")))]
                formatter: {
                    let f: fn(&$t, &mut DaemonicFormatter<'_>) -> Result = $f;
                    // SAFETY: This is only called with `value`, which has the right type.
                    unsafe { core::mem::transmute(f) }
                },
                #[cfg(any(sanitize = "cfi", sanitize = "kcfi"))]
                formatter: |ptr: NonNull<()>, fmt: &mut DaemonicFormatter<'_>| {
                    let func = $f;
                    // SAFETY: This is the same type as the `value` field.
                    let r = unsafe { ptr.cast::<$t>().as_ref() };
                    (func)(r, fmt)
                },
                _lifetime: PhantomData,
            },
        }
    };
}
				impl<FORMAT, PARTIAL> DaemonicArgument<'_> {
					#[inline]
					pub const fn new_display<T: DaemonicDisplay, E: DaemonicError<FORMAT, PARTIAL>>(x: &T) -> DaemonicArgument<'_> {
						DaemonicArgument {
							ty: ArgumentType::Placeholder {
								value: NonNull::<T>::from_ref(x).cast(),

								#[cfg(not(any(sanitize = "cfi", sanitize = "kcfi")))]
								formatter: {
									let f: fn(&T, &mut DaemonicFormatter<'_>) -> std::result::Result<T, E> = <T as DaemonicDisplay>::fmt;

									unsafe { core::mem::transmute(f) }
								},
								#[cfg(any(sanitize = "cfi", sanitize = "kcfi"))]
								formatter: |ptr: NonNull<()>, fmt: &mut DaemonicFormatter<'_>| {
									let func = <T as DaemonicDisplay>::fmt;

									let r = unsafe { ptr.cast::<T>().as_ref() };
									(func)(r, fmt)
								},
								_lifetime: PhantomData,
							},
						}
					}
					#[inline]
					pub const fn new_debug<T: DaemonicDebug<FORMAT, PARTIAL>>(x: &T) -> DaemonicArgument<'_> {
						argument_new!(T, x, <T as DaemonicDebug<FORMAT,PARTIAL>>::fmt)
					}
					#[inline]
					pub const fn new_debug_noop<T: DaemonicDebug<FORMAT, PARTIAL>>(x: &T) -> DaemonicArgument<'_> {
						argument_new!(T, x, |_: &T, _| Ok(()))
					}
					#[inline]
					pub const fn new_octal<T: DaemonicOctal>(x: &T) -> DaemonicArgument<'_> {
						argument_new!(T, x, <T as DaemonicOctal>::fmt)
					}
					#[inline]
					pub const fn new_lower_hex<T: DaemonicLowerHex>(x: &T) -> DaemonicArgument<'_> {
						argument_new!(T, x, <T as DaemonicLowerHex>::fmt)
					}
					#[inline]
					pub const fn new_upper_hex<T: DaemonicUpperHex>(x: &T) -> DaemonicArgument<'_> {
						argument_new!(T, x, <T as DaemonicUpperHex>::fmt)
					}
					#[inline]
					pub const fn new_pointer<T: DaemonicPointer>(x: &T) -> DaemonicArgument<'_> {
						argument_new!(T, x, <T as DaemonicPointer>::fmt)
					}
					#[inline]
					pub const fn new_binary<T: Binary>(x: &T) -> DaemonicArgument<'_> {
						argument_new!(T, x, <T as DaemonicBinary>::fmt)
					}
					#[inline]
					pub const fn new_lower_exp<T: DaemonicLowerExp>(x: &T) -> DaemonicArgument<'_> {
						argument_new!(T, x, <T as DaemonicLowerExp>::fmt)
					}
					#[inline]
					pub const fn new_upper_exp<T: DaemonicUpperExp>(x: &T) -> DaemonicArgument<'_> {
						argument_new!(T, x, <T as DaemonicUpperExp>::fmt)
					}
					#[inline]
					#[track_caller]
					pub const fn from_usize(x: &usize) -> DaemonicArgument<'_> {
						if *x > u16::MAX as usize {
							panic!("Formatting argument out of range");
						}
						DaemonicArgument { ty: ArgumentType::Count(*x as u16) }
					}

					/// Format this placeholder argument.
					///
					/// # Safety
					///
					/// This argument must actually be a placeholder argument.
					#[inline]
					pub(super) unsafe fn fmt(&self, f: &mut DaemonicFormatter<'_>) -> std::fmt::Result {
						match self.ty {
							// SAFETY:
							// Because of the invariant that if `formatter` had the type
							// `fn(&T, _) -> _` then `value` has type `&'b T` where `'b` is
							// the lifetime of the `ArgumentType`, and because references
							// and `NonNull` are ABI-compatible, this is completely equivalent
							// to calling the original function passed to `new` with the
							// original reference, which is sound.
							ArgumentType::Placeholder { formatter, value, .. } => unsafe { formatter(value, f) },
							// SAFETY: the caller promised this.
							ArgumentType::Count(_) => unsafe { unreachable_unchecked() },
						}
					}

					#[inline]
					pub(super) const fn as_u16(&self) -> Option<u16> {
						match self.ty {
							ArgumentType::Count(count) => Some(count),
							ArgumentType::Placeholder { .. } => None,
						}
					}

					/// Used by `format_args` when all arguments are gone after inlining,
					/// when using `&[]` would incorrectly allow for a bigger lifetime.
					///
					/// This fails without format argument inlining, and that shouldn't be different
					/// when the argument is inlined:
					///
					/// ```compile_fail,E0716
					/// let f = format_args!("{}", "a");
					/// println!("{f}");
					/// ```
					#[inline]
					pub const fn none() -> [Self; 0] {
						[]
					}
				}
				/// Used by the format_args!() macro to create a fmt::Arguments object.
				#[doc(hidden)]
				impl<'a> DaemonicArguments<'a> {
					#[inline]
					pub const fn new_const<const N: usize>(pieces: &'a [&'static str; N]) -> Self {
						const { assert!(N <= 1) };
						DaemonicArguments { pieces, fmt: None, args: &[] }
					}

					/// When using the format_args!() macro, this function is used to generate the
					/// Arguments structure.
					///
					/// This function should _not_ be const, to make sure we don't accept
					/// format_args!() and panic!() with arguments in const, even when not evaluated:
					///
					/// ```compile_fail,E0015
					/// const _: () = if false { panic!("a {}", "a") };
					/// ```
					#[inline]
					pub fn new_v1<const P: usize, const A: usize>(
						pieces: &'a [&'static str; P],
						args: &'a [rt::Argument<'a>; A],
					) -> DaemonicArguments<'a> {
						const { assert!(P >= A && P <= A + 1, "invalid args") }
						DaemonicArguments { pieces, fmt: None, args }
					}

					/// Specifies nonstandard formatting parameters.
					///
					/// An `rt::UnsafeArg` is required because the following invariants must be held
					/// in order for this function to be safe:
					/// 1. The `pieces` slice must be at least as long as `fmt`.
					/// 2. Every `rt::Placeholder::position` value within `fmt` must be a valid index of `args`.
					/// 3. Every `rt::Count::Param` within `fmt` must contain a valid index of `args`.
					///
					/// This function should _not_ be const, to make sure we don't accept
					/// format_args!() and panic!() with arguments in const, even when not evaluated:
					///
					/// ```compile_fail,E0015
					/// const _: () = if false { panic!("a {:1}", "a") };
					/// ```
					#[inline]
					pub fn new_v1_formatted(
						pieces: &'a [&'static str],
						args: &'a [DaemonicArgument<'a>],
						fmt: &'a [DaemonicPlaceholder],
						_unsafe_arg: DaemonicUnsafeArg,
					) -> DaemonicArguments<'a> {
						DaemonicArguments { pieces, fmt: Some(fmt), args }
					}
				}
				/// This struct represents the unsafety of constructing an `Arguments`.
				/// It exists, rather than an unsafe function, in order to simplify the expansion
				/// of `format_args!(..)` and reduce the scope of the `unsafe` block.
				pub struct DaemonicUnsafeArg {
					_private: (),
				}

				impl DaemonicUnsafeArg {
					/// See documentation where `UnsafeArg` is required to know when it is safe to
					/// create and use `UnsafeArg`.
					#[inline]
					pub const unsafe fn new() -> Self {
						Self { _private: () }
					}
				}
				/// `o` formatting.
				///
				/// The `Octal` trait should format its output as a number in base-8.
				///
				/// For primitive signed integers (`i8` to `i128`, and `isize`),
				/// negative values are formatted as the two’s complement representation.
				///
				/// The alternate flag, `#`, adds a `0o` in front of the output.
				///
				/// For more information on formatters, see [the module-level documentation][module].
				///
				/// [module]: ../../std/fmt/index.html
				///
				/// # Examples
				///
				/// Basic usage with `i32`:
				///
				/// ```
				/// let x = 42; // 42 is '52' in octal
				///
				/// assert_eq!(format!("{x:o}"), "52");
				/// assert_eq!(format!("{x:#o}"), "0o52");
				///
				/// assert_eq!(format!("{:o}", -16), "37777777760");
				/// ```
				///
				/// Implementing `Octal` on a type:
				///
				/// ```
				/// use std::fmt;
				///
				/// struct Length(i32);
				///
				/// impl fmt::Octal for Length {
				///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
				///         let val = self.0;
				///
				///         fmt::Octal::fmt(&val, f) // delegate to i32's implementation
				///     }
				/// }
				///
				/// let l = Length(9);
				///
				/// assert_eq!(format!("l as octal is: {l:o}"), "l as octal is: 11");
				///
				/// assert_eq!(format!("l as octal is: {l:#06o}"), "l as octal is: 0o0011");
				/// ```
				pub trait DaemonicOctal {
					fn fmt(&self, f: &mut DaemonicFormatter<'_>) -> std::fmt::Result;
				}

				/// `b` formatting.
				///
				/// The `Binary` trait should format its output as a number in binary.
				///
				/// For primitive signed integers ([`i8`] to [`i128`], and [`isize`]),
				/// negative values are formatted as the two’s complement representation.
				///
				/// The alternate flag, `#`, adds a `0b` in front of the output.
				///
				/// For more information on formatters, see [the module-level documentation][module].
				///
				/// [module]: ../../std/fmt/index.html
				///
				/// # Examples
				///
				/// Basic usage with [`i32`]:
				///
				/// ```
				/// let x = 42; // 42 is '101010' in binary
				///
				/// assert_eq!(format!("{x:b}"), "101010");
				/// assert_eq!(format!("{x:#b}"), "0b101010");
				///
				/// assert_eq!(format!("{:b}", -16), "11111111111111111111111111110000");
				/// ```
				///
				/// Implementing `Binary` on a type:
				///
				/// ```
				/// use std::fmt;
				///
				/// struct Length(i32);
				///
				/// impl fmt::Binary for Length {
				///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
				///         let val = self.0;
				///
				///         fmt::Binary::fmt(&val, f) // delegate to i32's implementation
				///     }
				/// }
				///
				/// let l = Length(107);
				///
				/// assert_eq!(format!("l as binary is: {l:b}"), "l as binary is: 1101011");
				///
				/// assert_eq!(
				///     // Note that the `0b` prefix added by `#` is included in the total width, so we
				///     // need to add two to correctly display all 32 bits.
				///     format!("l as binary is: {l:#034b}"),
				///     "l as binary is: 0b00000000000000000000000001101011"
				/// );
				/// ```
				pub trait Binary {
					fn fmt(&self, f: &mut DaemonicFormatter<'_>) -> std::fmt::Result;
				}

				/// `x` formatting.
				///
				/// The `LowerHex` trait should format its output as a number in hexadecimal, with `a` through `f`
				/// in lower case.
				///
				/// For primitive signed integers (`i8` to `i128`, and `isize`),
				/// negative values are formatted as the two’s complement representation.
				///
				/// The alternate flag, `#`, adds a `0x` in front of the output.
				///
				/// For more information on formatters, see [the module-level documentation][module].
				///
				/// [module]: ../../std/fmt/index.html
				///
				/// # Examples
				///
				/// Basic usage with `i32`:
				///
				/// ```
				/// let y = 42; // 42 is '2a' in hex
				///
				/// assert_eq!(format!("{y:x}"), "2a");
				/// assert_eq!(format!("{y:#x}"), "0x2a");
				///
				/// assert_eq!(format!("{:x}", -16), "fffffff0");
				/// ```
				///
				/// Implementing `LowerHex` on a type:
				///
				/// ```
				/// use std::fmt;
				///
				/// struct Length(i32);
				///
				/// impl fmt::LowerHex for Length {
				///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
				///         let val = self.0;
				///
				///         fmt::LowerHex::fmt(&val, f) // delegate to i32's implementation
				///     }
				/// }
				///
				/// let l = Length(9);
				///
				/// assert_eq!(format!("l as hex is: {l:x}"), "l as hex is: 9");
				///
				/// assert_eq!(format!("l as hex is: {l:#010x}"), "l as hex is: 0x00000009");
				/// ```
				pub trait DaemonicLowerHex {
					fn fmt(&self, f: &mut DaemonicFormatter<'_>) -> std::fmt::Result;
				}

				/// `X` formatting.
				///
				/// The `UpperHex` trait should format its output as a number in hexadecimal, with `A` through `F`
				/// in upper case.
				///
				/// For primitive signed integers (`i8` to `i128`, and `isize`),
				/// negative values are formatted as the two’s complement representation.
				///
				/// The alternate flag, `#`, adds a `0x` in front of the output.
				///
				/// For more information on formatters, see [the module-level documentation][module].
				///
				/// [module]: ../../std/fmt/index.html
				///
				/// # Examples
				///
				/// Basic usage with `i32`:
				///
				/// ```
				/// let y = 42; // 42 is '2A' in hex
				///
				/// assert_eq!(format!("{y:X}"), "2A");
				/// assert_eq!(format!("{y:#X}"), "0x2A");
				///
				/// assert_eq!(format!("{:X}", -16), "FFFFFFF0");
				/// ```
				///
				/// Implementing `UpperHex` on a type:
				///
				/// ```
				/// use std::fmt;
				///
				/// struct Length(i32);
				///
				/// impl fmt::UpperHex for Length {
				///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
				///         let val = self.0;
				///
				///         fmt::UpperHex::fmt(&val, f) // delegate to i32's implementation
				///     }
				/// }
				///
				/// let l = Length(i32::MAX);
				///
				/// assert_eq!(format!("l as hex is: {l:X}"), "l as hex is: 7FFFFFFF");
				///
				/// assert_eq!(format!("l as hex is: {l:#010X}"), "l as hex is: 0x7FFFFFFF");
				/// ```
				pub trait DaemonicUpperHex {
					fn fmt(&self, f: &mut DaemonicFormatter<'_>) -> std::fmt::Result;
				}

				/// `p` formatting.
				///
				/// The `Pointer` trait should format its output as a memory location. This is commonly presented
				/// as hexadecimal. For more information on formatters, see [the module-level documentation][module].
				///
				/// Printing of pointers is not a reliable way to discover how Rust programs are implemented.
				/// The act of reading an address changes the program itself, and may change how the data is represented
				/// in memory, and may affect which optimizations are applied to the code.
				///
				/// The printed pointer values are not guaranteed to be stable nor unique identifiers of objects.
				/// Rust allows moving values to different memory locations, and may reuse the same memory locations
				/// for different purposes.
				///
				/// There is no guarantee that the printed value can be converted back to a pointer.
				///
				/// [module]: ../../std/fmt/index.html
				///
				/// # Examples
				///
				/// Basic usage with `&i32`:
				///
				/// ```
				/// let x = &42;
				///
				/// let address = format!("{x:p}"); // this produces something like '0x7f06092ac6d0'
				/// ```
				///
				/// Implementing `Pointer` on a type:
				///
				/// ```
				/// use std::fmt;
				///
				/// struct Length(i32);
				///
				/// impl fmt::Pointer for Length {
				///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
				///         // use `as` to convert to a `*const T`, which implements Pointer, which we can use
				///
				///         let ptr = self as *const Self;
				///         fmt::Pointer::fmt(&ptr, f)
				///     }
				/// }
				///
				/// let l = Length(42);
				///
				/// println!("l is in memory here: {l:p}");
				///
				/// let l_ptr = format!("{l:018p}");
				/// assert_eq!(l_ptr.len(), 18);
				/// assert_eq!(&l_ptr[..2], "0x");
				/// ```
				pub trait DaemonicPointer {
					fn fmt(&self, f: &mut DaemonicFormatter<'_>) -> std::fmt::Result;
				}

				/// `e` formatting.
				///
				/// The `LowerExp` trait should format its output in scientific notation with a lower-case `e`.
				///
				/// For more information on formatters, see [the module-level documentation][module].
				///
				/// [module]: ../../std/fmt/index.html
				///
				/// # Examples
				///
				/// Basic usage with `f64`:
				///
				/// ```
				/// let x = 42.0; // 42.0 is '4.2e1' in scientific notation
				///
				/// assert_eq!(format!("{x:e}"), "4.2e1");
				/// ```
				///
				/// Implementing `LowerExp` on a type:
				///
				/// ```
				/// use std::fmt;
				///
				/// struct Length(i32);
				///
				/// impl fmt::LowerExp for Length {
				///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
				///         let val = f64::from(self.0);
				///         fmt::LowerExp::fmt(&val, f) // delegate to f64's implementation
				///     }
				/// }
				///
				/// let l = Length(100);
				///
				/// assert_eq!(
				///     format!("l in scientific notation is: {l:e}"),
				///     "l in scientific notation is: 1e2"
				/// );
				///
				/// assert_eq!(
				///     format!("l in scientific notation is: {l:05e}"),
				///     "l in scientific notation is: 001e2"
				/// );
				/// ```
				pub trait DaemonicLowerExp {
					fn fmt(&self, f: &mut DaemonicFormatter<'_>) -> std::fmt::Result;
				}

				/// `E` formatting.
				///
				/// The `UpperExp` trait should format its output in scientific notation with an upper-case `E`.
				///
				/// For more information on formatters, see [the module-level documentation][module].
				///
				/// [module]: ../../std/fmt/index.html
				///
				/// # Examples
				///
				/// Basic usage with `f64`:
				///
				/// ```
				/// let x = 42.0; // 42.0 is '4.2E1' in scientific notation
				///
				/// assert_eq!(format!("{x:E}"), "4.2E1");
				/// ```
				///
				/// Implementing `UpperExp` on a type:
				///
				/// ```
				/// use std::fmt;
				///
				/// struct Length(i32);
				///
				/// impl fmt::UpperExp for Length {
				///     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
				///         let val = f64::from(self.0);
				///         fmt::UpperExp::fmt(&val, f) // delegate to f64's implementation
				///     }
				/// }
				///
				/// let l = Length(100);
				///
				/// assert_eq!(
				///     format!("l in scientific notation is: {l:E}"),
				///     "l in scientific notation is: 1E2"
				/// );
				///
				/// assert_eq!(
				///     format!("l in scientific notation is: {l:05E}"),
				///     "l in scientific notation is: 001E2"
				/// );
				/// ```
				pub trait DaemonicUpperExp {
					fn fmt(&self, f: &mut DaemonicFormatter<'_>) -> std::fmt::Result;
				}
				mod non_null {
					use std::mem::MaybeUninit;
					use std::num::NonZero;
					use std::{intrinsics, mem, ptr};
					use std::cmp::Ordering;
					use std::hash::Hash;
					use std::marker::Unsize;
					use std::ops::{CoerceUnsized, DispatchFromDyn};
					use std::pin::PinCoerceUnsized;
					use std::slice::SliceIndex;

					/// `*mut T` but non-zero and [covariant].
					///
					/// This is often the correct thing to use when building data structures using
					/// raw pointers, but is ultimately more dangerous to use because of its additional
					/// properties. If you're not sure if you should use `NonNull<T>`, just use `*mut T`!
					///
					/// Unlike `*mut T`, the pointer must always be non-null, even if the pointer
					/// is never dereferenced. This is so that enums may use this forbidden value
					/// as a discriminant -- `Option<NonNull<T>>` has the same size as `*mut T`.
					/// However the pointer may still dangle if it isn't dereferenced.
					///
					/// Unlike `*mut T`, `NonNull<T>` was chosen to be covariant over `T`. This makes it
					/// possible to use `NonNull<T>` when building covariant types, but introduces the
					/// risk of unsoundness if used in a type that shouldn't actually be covariant.
					/// (The opposite choice was made for `*mut T` even though technically the unsoundness
					/// could only be caused by calling unsafe functions.)
					///
					/// Covariance is correct for most safe abstractions, such as `Box`, `Rc`, `Arc`, `Vec`,
					/// and `LinkedList`. This is the case because they provide a public API that follows the
					/// normal shared XOR mutable rules of Rust.
					///
					/// If your type cannot safely be covariant, you must ensure it contains some
					/// additional field to provide invariance. Often this field will be a [`PhantomData`]
					/// type like `PhantomData<Cell<T>>` or `PhantomData<&'a mut T>`.
					///
					/// Notice that `NonNull<T>` has a `From` instance for `&T`. However, this does
					/// not change the fact that mutating through a (pointer derived from a) shared
					/// reference is undefined behavior unless the mutation happens inside an
					/// [`UnsafeCell<T>`]. The same goes for creating a mutable reference from a shared
					/// reference. When using this `From` instance without an `UnsafeCell<T>`,
					/// it is your responsibility to ensure that `as_mut` is never called, and `as_ptr`
					/// is never used for mutation.
					///
					/// # Representation
					///
					/// Thanks to the [null pointer optimization],
					/// `NonNull<T>` and `Option<NonNull<T>>`
					/// are guaranteed to have the same size and alignment:
					///
					/// ```
					/// use NonNull;
					///
					/// assert_eq!(size_of::<NonNull<i16>>(), size_of::<Option<NonNull<i16>>>());
					/// assert_eq!(align_of::<NonNull<i16>>(), align_of::<Option<NonNull<i16>>>());
					///
					/// assert_eq!(size_of::<NonNull<str>>(), size_of::<Option<NonNull<str>>>());
					/// assert_eq!(align_of::<NonNull<str>>(), align_of::<Option<NonNull<str>>>());
					/// ```
					///
					/// [covariant]: https://doc.rust-lang.org/reference/subtyping.html
					/// [`PhantomData`]: crate::marker::PhantomData
					/// [`UnsafeCell<T>`]: crate::cell::UnsafeCell
					/// [null pointer optimization]: crate::option#representation
					#[repr(transparent)]
					#[rustc_layout_scalar_valid_range_start(1)]
					#[rustc_nonnull_optimization_guaranteed]
					pub struct NonNull<T: ?Sized> {
						// Remember to use `.as_ptr()` instead of `.pointer`, as field projecting to
						// this is banned by <https://github.com/rust-lang/compiler-team/issues/807>.
						pointer: *const T,
					}

					/// `NonNull` pointers are not `Send` because the data they reference may be aliased.
					// N.B., this impl is unnecessary, but should provide better error messages.
					impl<T: ?Sized> ! Send for NonNull<T> {}

					/// `NonNull` pointers are not `Sync` because the data they reference may be aliased.
					// N.B., this impl is unnecessary, but should provide better error messages.
					impl<T: ?Sized> ! Sync for NonNull<T> {}

					impl<T: Sized> NonNull<T> {
						/// Creates a pointer with the given address and no [provenance][crate::ptr#provenance].
						///
						/// For more details, see the equivalent method on a raw pointer, [`ptr::without_provenance_mut`].
						///
						/// This is a [Strict Provenance][crate::ptr#strict-provenance] API.
						#[must_use]
						#[inline]
						pub const fn without_provenance(addr: NonZero<usize>) -> Self {
							let pointer = std::ptr::without_provenance(addr.get());
							// SAFETY: we know `addr` is non-zero.
							unsafe { NonNull { pointer } }
						}

						/// Creates a new `NonNull` that is dangling, but well-aligned.
						///
						/// This is useful for initializing types which lazily allocate, like
						/// `Vec::new` does.
						///
						/// Note that the pointer value may potentially represent a valid pointer to
						/// a `T`, which means this must not be used as a "not yet initialized"
						/// sentinel value. Types that lazily allocate must track initialization by
						/// some other means.
						///
						/// # Examples
						///
						/// ```
						/// use NonNull;
						///
						/// let ptr = NonNull::<u32>::dangling();
						/// // Important: don't try to access the value of `ptr` without
						/// // initializing it first! The pointer is not null but isn't valid either!
						/// ```
						#[must_use]
						#[inline]
						pub const fn dangling() -> Self {
							let align = crate::ptr::Alignment::of::<T>();
							NonNull::without_provenance(align.as_nonzero())
						}

						/// Converts an address back to a mutable pointer, picking up some previously 'exposed'
						/// [provenance][crate::ptr#provenance].
						///
						/// For more details, see the equivalent method on a raw pointer, [`ptr::with_exposed_provenance_mut`].
						///
						/// This is an [Exposed Provenance][crate::ptr#exposed-provenance] API.
						#[inline]
						pub fn with_exposed_provenance(addr: NonZero<usize>) -> Self {
							// SAFETY: we know `addr` is non-zero.
							unsafe {
								let ptr = crate::ptr::with_exposed_provenance_mut(addr.get());
								NonNull::new_unchecked(ptr)
							}
						}

						/// Returns a shared references to the value. In contrast to [`as_ref`], this does not require
						/// that the value has to be initialized.
						///
						/// For the mutable counterpart see [`as_uninit_mut`].
						///
						/// [`as_ref`]: NonNull::as_ref
						/// [`as_uninit_mut`]: NonNull::as_uninit_mut
						///
						/// # Safety
						///
						/// When calling this method, you have to ensure that
						/// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
						/// Note that because the created reference is to `MaybeUninit<T>`, the
						/// source pointer can point to uninitialized memory.
						#[inline]
						#[must_use]
						pub const unsafe fn as_uninit_ref<'a>(self) -> &'a MaybeUninit<T> {
							// SAFETY: the caller must guarantee that `self` meets all the
							// requirements for a reference.
							unsafe { &*self.cast().as_ptr() }
						}

						/// Returns a unique references to the value. In contrast to [`as_mut`], this does not require
						/// that the value has to be initialized.
						///
						/// For the shared counterpart see [`as_uninit_ref`].
						///
						/// [`as_mut`]: NonNull::as_mut
						/// [`as_uninit_ref`]: NonNull::as_uninit_ref
						///
						/// # Safety
						///
						/// When calling this method, you have to ensure that
						/// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
						/// Note that because the created reference is to `MaybeUninit<T>`, the
						/// source pointer can point to uninitialized memory.
						#[inline]
						#[must_use]
						pub const unsafe fn as_uninit_mut<'a>(self) -> &'a mut MaybeUninit<T> {
							// SAFETY: the caller must guarantee that `self` meets all the
							// requirements for a reference.
							unsafe { &mut *self.cast().as_ptr() }
						}
					}

					impl<T: ?Sized> NonNull<T> {
						/// Creates a new `NonNull`.
						///
						/// # Safety
						///
						/// `ptr` must be non-null.
						///
						/// # Examples
						///
						/// ```
						/// use NonNull;
						///
						/// let mut x = 0u32;
						/// let ptr = unsafe { NonNull::new_unchecked(&mut x as *mut _) };
						/// ```
						///
						/// *Incorrect* usage of this function:
						///
						/// ```rust,no_run
						/// use NonNull;
						///
						/// // NEVER DO THAT!!! This is undefined behavior. ⚠️
						/// let ptr = unsafe { NonNull::<u32>::new_unchecked(null_mut()) };
						/// ```
						#[inline]
						pub const unsafe fn new_unchecked(ptr: *mut T) -> Self {
							// SAFETY: the caller must guarantee that `ptr` is non-null.
							unsafe {
								assert_unsafe_precondition!(
                check_language_ub,
                "NonNull::new_unchecked requires that the pointer is non-null",
                (ptr: *mut () = ptr as *mut ()) => !ptr.is_null()
            );
								NonNull { pointer: ptr as _ }
							}
						}

						/// Creates a new `NonNull` if `ptr` is non-null.
						///
						/// # Panics during const evaluation
						///
						/// This method will panic during const evaluation if the pointer cannot be
						/// determined to be null or not. See [`is_null`] for more information.
						///
						/// [`is_null`]: ../primitive.pointer.html#method.is_null-1
						///
						/// # Examples
						///
						/// ```
						/// use NonNull;
						///
						/// let mut x = 0u32;
						/// let ptr = NonNull::<u32>::new(&mut x as *mut _).expect("ptr is null!");
						///
						/// if let Some(ptr) = NonNull::<u32>::new(null_mut()) {
						///     unreachable!();
						/// }
						/// ```
						#[inline]
						pub const fn new(ptr: *mut T) -> Option<Self> {
							if !ptr.is_null() {
								// SAFETY: The pointer is already checked and is not null
								Some(unsafe { Self::new_unchecked(ptr) })
							} else {
								None
							}
						}

						/// Converts a reference to a `NonNull` pointer.
						#[inline]
						pub const fn from_ref(r: &T) -> Self {
							// SAFETY: A reference cannot be null.
							unsafe { NonNull { pointer: r as *const T } }
						}

						/// Converts a mutable reference to a `NonNull` pointer.
						#[inline]
						pub const fn from_mut(r: &mut T) -> Self {
							// SAFETY: A mutable reference cannot be null.
							unsafe { NonNull { pointer: r as *mut T } }
						}

						/// Performs the same functionality as [`from_raw_parts`], except that a
						/// `NonNull` pointer is returned, as opposed to a raw `*const` pointer.
						///
						/// See the documentation of [`from_raw_parts`] for more details.
						///
						/// [`from_raw_parts`]: crate::ptr::from_raw_parts
						#[inline]
						pub const fn from_raw_parts(
							data_pointer: NonNull<impl super::Thin>,
							metadata: <T as super::Pointee>::Metadata,
						) -> NonNull<T> {
							// SAFETY: The result of `ptr::from::raw_parts_mut` is non-null because `data_pointer` is.
							unsafe {
								NonNull::new_unchecked(super::from_raw_parts_mut(data_pointer.as_ptr(), metadata))
							}
						}

						/// Decompose a (possibly wide) pointer into its data pointer and metadata components.
						///
						/// The pointer can be later reconstructed with [`NonNull::from_raw_parts`].
						#[must_use = "this returns the result of the operation, \
                  without modifying the original"]
						#[inline]
						pub const fn to_raw_parts(self) -> (NonNull<()>, <T as super::Pointee>::Metadata) {
							(self.cast(), super::metadata(self.as_ptr()))
						}

						/// Gets the "address" portion of the pointer.
						///
						/// For more details, see the equivalent method on a raw pointer, [`pointer::addr`].
						///
						/// This is a [Strict Provenance][crate::ptr#strict-provenance] API.
						#[must_use]
						#[inline]
						pub fn addr(self) -> NonZero<usize> {
							// SAFETY: The pointer is guaranteed by the type to be non-null,
							// meaning that the address will be non-zero.
							unsafe { NonZero::new_unchecked(self.as_ptr().addr()) }
						}

						/// Exposes the ["provenance"][crate::ptr#provenance] part of the pointer for future use in
						/// [`with_exposed_provenance`][NonNull::with_exposed_provenance] and returns the "address" portion.
						///
						/// For more details, see the equivalent method on a raw pointer, [`pointer::expose_provenance`].
						///
						/// This is an [Exposed Provenance][crate::ptr#exposed-provenance] API.
						pub fn expose_provenance(self) -> NonZero<usize> {
							// SAFETY: The pointer is guaranteed by the type to be non-null,
							// meaning that the address will be non-zero.
							unsafe { NonZero::new_unchecked(self.as_ptr().expose_provenance()) }
						}

						/// Creates a new pointer with the given address and the [provenance][crate::ptr#provenance] of
						/// `self`.
						///
						/// For more details, see the equivalent method on a raw pointer, [`pointer::with_addr`].
						///
						/// This is a [Strict Provenance][crate::ptr#strict-provenance] API.
						#[must_use]
						#[inline]
						pub fn with_addr(self, addr: NonZero<usize>) -> Self {
							// SAFETY: The result of `ptr::from::with_addr` is non-null because `addr` is guaranteed to be non-zero.
							unsafe { NonNull::new_unchecked(self.as_ptr().with_addr(addr.get()) as *mut _) }
						}

						/// Creates a new pointer by mapping `self`'s address to a new one, preserving the
						/// [provenance][crate::ptr#provenance] of `self`.
						///
						/// For more details, see the equivalent method on a raw pointer, [`pointer::map_addr`].
						///
						/// This is a [Strict Provenance][crate::ptr#strict-provenance] API.
						#[must_use]
						#[inline]
						pub fn map_addr(self, f: impl FnOnce(NonZero<usize>) -> NonZero<usize>) -> Self {
							self.with_addr(f(self.addr()))
						}

						/// Acquires the underlying `*mut` pointer.
						///
						/// # Examples
						///
						/// ```
						/// use NonNull;
						///
						/// let mut x = 0u32;
						/// let ptr = NonNull::new(&mut x).expect("ptr is null!");
						///
						/// let x_value = unsafe { *ptr.as_ptr() };
						/// assert_eq!(x_value, 0);
						///
						/// unsafe { *ptr.as_ptr() += 2; }
						/// let x_value = unsafe { *ptr.as_ptr() };
						/// assert_eq!(x_value, 2);
						/// ```
						#[rustc_never_returns_null_ptr]
						#[must_use]
						#[inline(always)]
						pub const fn as_ptr(self) -> *mut T {
							// This is a transmute for the same reasons as `NonZero::get`.

							// SAFETY: `NonNull` is `transparent` over a `*const T`, and `*const T`
							// and `*mut T` have the same layout, so transitively we can transmute
							// our `NonNull` to a `*mut T` directly.
							unsafe { mem::transmute::<Self, *mut T>(self) }
						}

						/// Returns a shared reference to the value. If the value may be uninitialized, [`as_uninit_ref`]
						/// must be used instead.
						///
						/// For the mutable counterpart see [`as_mut`].
						///
						/// [`as_uninit_ref`]: NonNull::as_uninit_ref
						/// [`as_mut`]: NonNull::as_mut
						///
						/// # Safety
						///
						/// When calling this method, you have to ensure that
						/// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
						///
						/// # Examples
						///
						/// ```
						/// use NonNull;
						///
						/// let mut x = 0u32;
						/// let ptr = NonNull::new(&mut x as *mut _).expect("ptr is null!");
						///
						/// let ref_x = unsafe { ptr.as_ref() };
						/// println!("{ref_x}");
						/// ```
						///
						/// [the module documentation]: crate::ptr#safety
						#[must_use]
						#[inline(always)]
						pub const unsafe fn as_ref<'a>(&self) -> &'a T {
							// SAFETY: the caller must guarantee that `self` meets all the
							// requirements for a reference.
							// `cast_const` avoids a mutable raw pointer deref.
							unsafe { &*self.as_ptr().cast_const() }
						}

						/// Returns a unique reference to the value. If the value may be uninitialized, [`as_uninit_mut`]
						/// must be used instead.
						///
						/// For the shared counterpart see [`as_ref`].
						///
						/// [`as_uninit_mut`]: NonNull::as_uninit_mut
						/// [`as_ref`]: NonNull::as_ref
						///
						/// # Safety
						///
						/// When calling this method, you have to ensure that
						/// the pointer is [convertible to a reference](crate::ptr#pointer-to-reference-conversion).
						/// # Examples
						///
						/// ```
						/// use NonNull;
						///
						/// let mut x = 0u32;
						/// let mut ptr = NonNull::new(&mut x).expect("null pointer");
						///
						/// let x_ref = unsafe { ptr.as_mut() };
						/// assert_eq!(*x_ref, 0);
						/// *x_ref += 2;
						/// assert_eq!(*x_ref, 2);
						/// ```
						///
						/// [the module documentation]: crate::ptr#safety
						#[must_use]
						#[inline(always)]
						pub const unsafe fn as_mut<'a>(&mut self) -> &'a mut T {
							// SAFETY: the caller must guarantee that `self` meets all the
							// requirements for a mutable reference.
							unsafe { &mut *self.as_ptr() }
						}

						/// Casts to a pointer of another type.
						///
						/// # Examples
						///
						/// ```
						/// use NonNull;
						///
						/// let mut x = 0u32;
						/// let ptr = NonNull::new(&mut x as *mut _).expect("null pointer");
						///
						/// let casted_ptr = ptr.cast::<i8>();
						/// let raw_ptr: *mut i8 = casted_ptr.as_ptr();
						/// ```
						#[must_use = "this returns the result of the operation, \
                  without modifying the original"]
						#[inline]
						pub const fn cast<U>(self) -> NonNull<U> {
							// SAFETY: `self` is a `NonNull` pointer which is necessarily non-null
							unsafe { NonNull { pointer: self.as_ptr() as *mut U } }
						}

						/// Adds an offset to a pointer.
						///
						/// `count` is in units of T; e.g., a `count` of 3 represents a pointer
						/// offset of `3 * size_of::<T>()` bytes.
						///
						/// # Safety
						///
						/// If any of the following conditions are violated, the result is Undefined Behavior:
						///
						/// * The computed offset, `count * size_of::<T>()` bytes, must not overflow `isize`.
						///
						/// * If the computed offset is non-zero, then `self` must be derived from a pointer to some
						///   [allocated object], and the entire memory range between `self` and the result must be in
						///   bounds of that allocated object. In particular, this range must not "wrap around" the edge
						///   of the address space.
						///
						/// Allocated objects can never be larger than `isize::MAX` bytes, so if the computed offset
						/// stays in bounds of the allocated object, it is guaranteed to satisfy the first requirement.
						/// This implies, for instance, that `vec.as_ptr().add(vec.len())` (for `vec: Vec<T>`) is always
						/// safe.
						///
						/// [allocated object]: crate::ptr#allocated-object
						///
						/// # Examples
						///
						/// ```
						/// use NonNull;
						///
						/// let mut s = [1, 2, 3];
						/// let ptr: NonNull<u32> = NonNull::new(s.as_mut_ptr()).unwrap();
						///
						/// unsafe {
						///     println!("{}", ptr.offset(1).read());
						///     println!("{}", ptr.offset(2).read());
						/// }
						/// ```
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						#[must_use = "returns a new pointer rather than modifying its argument"]
						pub const unsafe fn offset(self, count: isize) -> Self
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `offset`.
							// Additionally safety contract of `offset` guarantees that the resulting pointer is
							// pointing to an allocation, there can't be an allocation at null, thus it's safe to
							// construct `NonNull`.
							unsafe { NonNull { pointer: intrinsics::offset(self.as_ptr(), count) } }
						}

						/// Calculates the offset from a pointer in bytes.
						///
						/// `count` is in units of **bytes**.
						///
						/// This is purely a convenience for casting to a `u8` pointer and
						/// using [offset][pointer::offset] on it. See that method for documentation
						/// and safety requirements.
						///
						/// For non-`Sized` pointees this operation changes only the data pointer,
						/// leaving the metadata untouched.
						#[must_use]
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn byte_offset(self, count: isize) -> Self {
							// SAFETY: the caller must uphold the safety contract for `offset` and `byte_offset` has
							// the same safety contract.
							// Additionally safety contract of `offset` guarantees that the resulting pointer is
							// pointing to an allocation, there can't be an allocation at null, thus it's safe to
							// construct `NonNull`.
							unsafe { NonNull { pointer: self.as_ptr().byte_offset(count) } }
						}

						/// Adds an offset to a pointer (convenience for `.offset(count as isize)`).
						///
						/// `count` is in units of T; e.g., a `count` of 3 represents a pointer
						/// offset of `3 * size_of::<T>()` bytes.
						///
						/// # Safety
						///
						/// If any of the following conditions are violated, the result is Undefined Behavior:
						///
						/// * The computed offset, `count * size_of::<T>()` bytes, must not overflow `isize`.
						///
						/// * If the computed offset is non-zero, then `self` must be derived from a pointer to some
						///   [allocated object], and the entire memory range between `self` and the result must be in
						///   bounds of that allocated object. In particular, this range must not "wrap around" the edge
						///   of the address space.
						///
						/// Allocated objects can never be larger than `isize::MAX` bytes, so if the computed offset
						/// stays in bounds of the allocated object, it is guaranteed to satisfy the first requirement.
						/// This implies, for instance, that `vec.as_ptr().add(vec.len())` (for `vec: Vec<T>`) is always
						/// safe.
						///
						/// [allocated object]: crate::ptr#allocated-object
						///
						/// # Examples
						///
						/// ```
						/// use NonNull;
						///
						/// let s: &str = "123";
						/// let ptr: NonNull<u8> = NonNull::new(s.as_ptr().cast_mut()).unwrap();
						///
						/// unsafe {
						///     println!("{}", ptr.add(1).read() as char);
						///     println!("{}", ptr.add(2).read() as char);
						/// }
						/// ```
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						#[must_use = "returns a new pointer rather than modifying its argument"]
						pub const unsafe fn add(self, count: usize) -> Self
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `offset`.
							// Additionally safety contract of `offset` guarantees that the resulting pointer is
							// pointing to an allocation, there can't be an allocation at null, thus it's safe to
							// construct `NonNull`.
							unsafe { NonNull { pointer: intrinsics::offset(self.as_ptr(), count) } }
						}

						/// Calculates the offset from a pointer in bytes (convenience for `.byte_offset(count as isize)`).
						///
						/// `count` is in units of bytes.
						///
						/// This is purely a convenience for casting to a `u8` pointer and
						/// using [`add`][NonNull::add] on it. See that method for documentation
						/// and safety requirements.
						///
						/// For non-`Sized` pointees this operation changes only the data pointer,
						/// leaving the metadata untouched.
						#[must_use]
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn byte_add(self, count: usize) -> Self {
							// SAFETY: the caller must uphold the safety contract for `add` and `byte_add` has the same
							// safety contract.
							// Additionally safety contract of `add` guarantees that the resulting pointer is pointing
							// to an allocation, there can't be an allocation at null, thus it's safe to construct
							// `NonNull`.
							unsafe { NonNull { pointer: self.as_ptr().byte_add(count) } }
						}

						/// Subtracts an offset from a pointer (convenience for
						/// `.offset((count as isize).wrapping_neg())`).
						///
						/// `count` is in units of T; e.g., a `count` of 3 represents a pointer
						/// offset of `3 * size_of::<T>()` bytes.
						///
						/// # Safety
						///
						/// If any of the following conditions are violated, the result is Undefined Behavior:
						///
						/// * The computed offset, `count * size_of::<T>()` bytes, must not overflow `isize`.
						///
						/// * If the computed offset is non-zero, then `self` must be derived from a pointer to some
						///   [allocated object], and the entire memory range between `self` and the result must be in
						///   bounds of that allocated object. In particular, this range must not "wrap around" the edge
						///   of the address space.
						///
						/// Allocated objects can never be larger than `isize::MAX` bytes, so if the computed offset
						/// stays in bounds of the allocated object, it is guaranteed to satisfy the first requirement.
						/// This implies, for instance, that `vec.as_ptr().add(vec.len())` (for `vec: Vec<T>`) is always
						/// safe.
						///
						/// [allocated object]: crate::ptr#allocated-object
						///
						/// # Examples
						///
						/// ```
						/// use NonNull;
						///
						/// let s: &str = "123";
						///
						/// unsafe {
						///     let end: NonNull<u8> = NonNull::new(s.as_ptr().cast_mut()).unwrap().add(3);
						///     println!("{}", end.sub(1).read() as char);
						///     println!("{}", end.sub(2).read() as char);
						/// }
						/// ```
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						#[must_use = "returns a new pointer rather than modifying its argument"]
						pub const unsafe fn sub(self, count: usize) -> Self
						where
							T: Sized,
						{
							if T::IS_ZST {
								// Pointer arithmetic does nothing when the pointee is a ZST.
								self
							} else {
								// SAFETY: the caller must uphold the safety contract for `offset`.
								// Because the pointee is *not* a ZST, that means that `count` is
								// at most `isize::MAX`, and thus the negation cannot overflow.
								unsafe { self.offset((count as isize).unchecked_neg()) }
							}
						}

						/// Calculates the offset from a pointer in bytes (convenience for
						/// `.byte_offset((count as isize).wrapping_neg())`).
						///
						/// `count` is in units of bytes.
						///
						/// This is purely a convenience for casting to a `u8` pointer and
						/// using [`sub`][NonNull::sub] on it. See that method for documentation
						/// and safety requirements.
						///
						/// For non-`Sized` pointees this operation changes only the data pointer,
						/// leaving the metadata untouched.
						#[must_use]
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn byte_sub(self, count: usize) -> Self {
							// SAFETY: the caller must uphold the safety contract for `sub` and `byte_sub` has the same
							// safety contract.
							// Additionally safety contract of `sub` guarantees that the resulting pointer is pointing
							// to an allocation, there can't be an allocation at null, thus it's safe to construct
							// `NonNull`.
							unsafe { NonNull { pointer: self.as_ptr().byte_sub(count) } }
						}

						/// Calculates the distance between two pointers within the same allocation. The returned value is in
						/// units of T: the distance in bytes divided by `size_of::<T>()`.
						///
						/// This is equivalent to `(self as isize - origin as isize) / (size_of::<T>() as isize)`,
						/// except that it has a lot more opportunities for UB, in exchange for the compiler
						/// better understanding what you are doing.
						///
						/// The primary motivation of this method is for computing the `len` of an array/slice
						/// of `T` that you are currently representing as a "start" and "end" pointer
						/// (and "end" is "one past the end" of the array).
						/// In that case, `end.offset_from(start)` gets you the length of the array.
						///
						/// All of the following safety requirements are trivially satisfied for this usecase.
						///
						/// [`offset`]: #method.offset
						///
						/// # Safety
						///
						/// If any of the following conditions are violated, the result is Undefined Behavior:
						///
						/// * `self` and `origin` must either
						///
						///   * point to the same address, or
						///   * both be *derived from* a pointer to the same [allocated object], and the memory range between
						///     the two pointers must be in bounds of that object. (See below for an example.)
						///
						/// * The distance between the pointers, in bytes, must be an exact multiple
						///   of the size of `T`.
						///
						/// As a consequence, the absolute distance between the pointers, in bytes, computed on
						/// mathematical integers (without "wrapping around"), cannot overflow an `isize`. This is
						/// implied by the in-bounds requirement, and the fact that no allocated object can be larger
						/// than `isize::MAX` bytes.
						///
						/// The requirement for pointers to be derived from the same allocated object is primarily
						/// needed for `const`-compatibility: the distance between pointers into *different* allocated
						/// objects is not known at compile-time. However, the requirement also exists at
						/// runtime and may be exploited by optimizations. If you wish to compute the difference between
						/// pointers that are not guaranteed to be from the same allocation, use `(self as isize -
						/// origin as isize) / size_of::<T>()`.
						// FIXME: recommend `addr()` instead of `as usize` once that is stable.
						///
						/// [`add`]: #method.add
						/// [allocated object]: crate::ptr#allocated-object
						///
						/// # Panics
						///
						/// This function panics if `T` is a Zero-Sized Type ("ZST").
						///
						/// # Examples
						///
						/// Basic usage:
						///
						/// ```
						/// use NonNull;
						///
						/// let a = [0; 5];
						/// let ptr1: NonNull<u32> = NonNull::from(&a[1]);
						/// let ptr2: NonNull<u32> = NonNull::from(&a[3]);
						/// unsafe {
						///     assert_eq!(ptr2.offset_from(ptr1), 2);
						///     assert_eq!(ptr1.offset_from(ptr2), -2);
						///     assert_eq!(ptr1.offset(2), ptr2);
						///     assert_eq!(ptr2.offset(-2), ptr1);
						/// }
						/// ```
						///
						/// *Incorrect* usage:
						///
						/// ```rust,no_run
						/// use NonNull;
						///
						/// let ptr1 = NonNull::new(Box::into_raw(Box::new(0u8))).unwrap();
						/// let ptr2 = NonNull::new(Box::into_raw(Box::new(1u8))).unwrap();
						/// let diff = (ptr2.addr().get() as isize).wrapping_sub(ptr1.addr().get() as isize);
						/// // Make ptr2_other an "alias" of ptr2.add(1), but derived from ptr1.
						/// let diff_plus_1 = diff.wrapping_add(1);
						/// let ptr2_other = NonNull::new(ptr1.as_ptr().wrapping_byte_offset(diff_plus_1)).unwrap();
						/// assert_eq!(ptr2.addr(), ptr2_other.addr());
						/// // Since ptr2_other and ptr2 are derived from pointers to different objects,
						/// // computing their offset is undefined behavior, even though
						/// // they point to addresses that are in-bounds of the same object!
						///
						/// let one = unsafe { ptr2_other.offset_from(ptr2) }; // Undefined Behavior! ⚠️
						/// ```
						#[inline]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn offset_from(self, origin: NonNull<T>) -> isize
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `offset_from`.
							unsafe { self.as_ptr().offset_from(origin.as_ptr()) }
						}

						/// Calculates the distance between two pointers within the same allocation. The returned value is in
						/// units of **bytes**.
						///
						/// This is purely a convenience for casting to a `u8` pointer and
						/// using [`offset_from`][NonNull::offset_from] on it. See that method for
						/// documentation and safety requirements.
						///
						/// For non-`Sized` pointees this operation considers only the data pointers,
						/// ignoring the metadata.
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn byte_offset_from<U: ?Sized>(self, origin: NonNull<U>) -> isize {
							// SAFETY: the caller must uphold the safety contract for `byte_offset_from`.
							unsafe { self.as_ptr().byte_offset_from(origin.as_ptr()) }
						}

						// N.B. `wrapping_offset``, `wrapping_add`, etc are not implemented because they can wrap to null

						/// Calculates the distance between two pointers within the same allocation, *where it's known that
						/// `self` is equal to or greater than `origin`*. The returned value is in
						/// units of T: the distance in bytes is divided by `size_of::<T>()`.
						///
						/// This computes the same value that [`offset_from`](#method.offset_from)
						/// would compute, but with the added precondition that the offset is
						/// guaranteed to be non-negative.  This method is equivalent to
						/// `usize::try_from(self.offset_from(origin)).unwrap_unchecked()`,
						/// but it provides slightly more information to the optimizer, which can
						/// sometimes allow it to optimize slightly better with some backends.
						///
						/// This method can be though of as recovering the `count` that was passed
						/// to [`add`](#method.add) (or, with the parameters in the other order,
						/// to [`sub`](#method.sub)).  The following are all equivalent, assuming
						/// that their safety preconditions are met:
						/// ```rust
						/// # unsafe fn blah(ptr: NonNull<u32>, origin: NonNull<u32>, count: usize) -> bool { unsafe {
						/// ptr.offset_from_unsigned(origin) == count
						/// # &&
						/// origin.add(count) == ptr
						/// # &&
						/// ptr.sub(count) == origin
						/// # } }
						/// ```
						///
						/// # Safety
						///
						/// - The distance between the pointers must be non-negative (`self >= origin`)
						///
						/// - *All* the safety conditions of [`offset_from`](#method.offset_from)
						///   apply to this method as well; see it for the full details.
						///
						/// Importantly, despite the return type of this method being able to represent
						/// a larger offset, it's still *not permitted* to pass pointers which differ
						/// by more than `isize::MAX` *bytes*.  As such, the result of this method will
						/// always be less than or equal to `isize::MAX as usize`.
						///
						/// # Panics
						///
						/// This function panics if `T` is a Zero-Sized Type ("ZST").
						///
						/// # Examples
						///
						/// ```
						/// use NonNull;
						///
						/// let a = [0; 5];
						/// let ptr1: NonNull<u32> = NonNull::from(&a[1]);
						/// let ptr2: NonNull<u32> = NonNull::from(&a[3]);
						/// unsafe {
						///     assert_eq!(ptr2.offset_from_unsigned(ptr1), 2);
						///     assert_eq!(ptr1.add(2), ptr2);
						///     assert_eq!(ptr2.sub(2), ptr1);
						///     assert_eq!(ptr2.offset_from_unsigned(ptr2), 0);
						/// }
						///
						/// // This would be incorrect, as the pointers are not correctly ordered:
						/// // ptr1.offset_from_unsigned(ptr2)
						/// ```
						#[inline]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn offset_from_unsigned(self, subtracted: NonNull<T>) -> usize
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `offset_from_unsigned`.
							unsafe { self.as_ptr().offset_from_unsigned(subtracted.as_ptr()) }
						}

						/// Calculates the distance between two pointers within the same allocation, *where it's known that
						/// `self` is equal to or greater than `origin`*. The returned value is in
						/// units of **bytes**.
						///
						/// This is purely a convenience for casting to a `u8` pointer and
						/// using [`offset_from_unsigned`][NonNull::offset_from_unsigned] on it.
						/// See that method for documentation and safety requirements.
						///
						/// For non-`Sized` pointees this operation considers only the data pointers,
						/// ignoring the metadata.
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn byte_offset_from_unsigned<U: ?Sized>(self, origin: NonNull<U>) -> usize {
							// SAFETY: the caller must uphold the safety contract for `byte_offset_from_unsigned`.
							unsafe { self.as_ptr().byte_offset_from_unsigned(origin.as_ptr()) }
						}

						/// Reads the value from `self` without moving it. This leaves the
						/// memory in `self` unchanged.
						///
						/// See [`ptr::read`] for safety concerns and examples.
						///
						/// [`ptr::read`]: crate::ptr::read()
						#[inline]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn read(self) -> T
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `read`.
							unsafe { ptr::read(self.as_ptr()) }
						}

						/// Performs a volatile read of the value from `self` without moving it. This
						/// leaves the memory in `self` unchanged.
						///
						/// Volatile operations are intended to act on I/O memory, and are guaranteed
						/// to not be elided or reordered by the compiler across other volatile
						/// operations.
						///
						/// See [`ptr::read_volatile`] for safety concerns and examples.
						///
						/// [`ptr::read_volatile`]: crate::ptr::read_volatile()
						#[inline]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub unsafe fn read_volatile(self) -> T
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `read_volatile`.
							unsafe { ptr::read_volatile(self.as_ptr()) }
						}

						/// Reads the value from `self` without moving it. This leaves the
						/// memory in `self` unchanged.
						///
						/// Unlike `read`, the pointer may be unaligned.
						///
						/// See [`ptr::read_unaligned`] for safety concerns and examples.
						///
						/// [`ptr::read_unaligned`]: crate::ptr::read_unaligned()
						#[inline]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn read_unaligned(self) -> T
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `read_unaligned`.
							unsafe { ptr::read_unaligned(self.as_ptr()) }
						}

						/// Copies `count * size_of::<T>()` bytes from `self` to `dest`. The source
						/// and destination may overlap.
						///
						/// NOTE: this has the *same* argument order as [`ptr::copy`].
						///
						/// See [`ptr::copy`] for safety concerns and examples.
						///
						/// [`ptr::copy`]: crate::ptr::copy()
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn copy_to(self, dest: NonNull<T>, count: usize)
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `copy`.
							unsafe { ptr::copy(self.as_ptr(), dest.as_ptr(), count) }
						}

						/// Copies `count * size_of::<T>()` bytes from `self` to `dest`. The source
						/// and destination may *not* overlap.
						///
						/// NOTE: this has the *same* argument order as [`ptr::copy_nonoverlapping`].
						///
						/// See [`ptr::copy_nonoverlapping`] for safety concerns and examples.
						///
						/// [`ptr::copy_nonoverlapping`]: crate::ptr::copy_nonoverlapping()
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn copy_to_nonoverlapping(self, dest: NonNull<T>, count: usize)
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `copy_nonoverlapping`.
							unsafe { ptr::copy_nonoverlapping(self.as_ptr(), dest.as_ptr(), count) }
						}

						/// Copies `count * size_of::<T>()` bytes from `src` to `self`. The source
						/// and destination may overlap.
						///
						/// NOTE: this has the *opposite* argument order of [`ptr::copy`].
						///
						/// See [`ptr::copy`] for safety concerns and examples.
						///
						/// [`ptr::copy`]: crate::ptr::copy()
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn copy_from(self, src: NonNull<T>, count: usize)
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `copy`.
							unsafe { ptr::copy(src.as_ptr(), self.as_ptr(), count) }
						}

						/// Copies `count * size_of::<T>()` bytes from `src` to `self`. The source
						/// and destination may *not* overlap.
						///
						/// NOTE: this has the *opposite* argument order of [`ptr::copy_nonoverlapping`].
						///
						/// See [`ptr::copy_nonoverlapping`] for safety concerns and examples.
						///
						/// [`ptr::copy_nonoverlapping`]: crate::ptr::copy_nonoverlapping()
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn copy_from_nonoverlapping(self, src: NonNull<T>, count: usize)
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `copy_nonoverlapping`.
							unsafe { ptr::copy_nonoverlapping(src.as_ptr(), self.as_ptr(), count) }
						}

						/// Executes the destructor (if any) of the pointed-to value.
						///
						/// See [`ptr::drop_in_place`] for safety concerns and examples.
						///
						/// [`ptr::drop_in_place`]: crate::ptr::drop_in_place()
						#[inline(always)]
						pub unsafe fn drop_in_place(self) {
							// SAFETY: the caller must uphold the safety contract for `drop_in_place`.
							unsafe { ptr::drop_in_place(self.as_ptr()) }
						}

						/// Overwrites a memory location with the given value without reading or
						/// dropping the old value.
						///
						/// See [`ptr::write`] for safety concerns and examples.
						///
						/// [`ptr::write`]: crate::ptr::write()
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn write(self, val: T)
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `write`.
							unsafe { ptr::write(self.as_ptr(), val) }
						}

						/// Invokes memset on the specified pointer, setting `count * size_of::<T>()`
						/// bytes of memory starting at `self` to `val`.
						///
						/// See [`ptr::write_bytes`] for safety concerns and examples.
						///
						/// [`ptr::write_bytes`]: crate::ptr::write_bytes()
						#[inline(always)]
						#[doc(alias = "memset")]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn write_bytes(self, val: u8, count: usize)
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `write_bytes`.
							unsafe { ptr::write_bytes(self.as_ptr(), val, count) }
						}

						/// Performs a volatile write of a memory location with the given value without
						/// reading or dropping the old value.
						///
						/// Volatile operations are intended to act on I/O memory, and are guaranteed
						/// to not be elided or reordered by the compiler across other volatile
						/// operations.
						///
						/// See [`ptr::write_volatile`] for safety concerns and examples.
						///
						/// [`ptr::write_volatile`]: crate::ptr::write_volatile()
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub unsafe fn write_volatile(self, val: T)
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `write_volatile`.
							unsafe { ptr::write_volatile(self.as_ptr(), val) }
						}

						/// Overwrites a memory location with the given value without reading or
						/// dropping the old value.
						///
						/// Unlike `write`, the pointer may be unaligned.
						///
						/// See [`ptr::write_unaligned`] for safety concerns and examples.
						///
						/// [`ptr::write_unaligned`]: crate::ptr::write_unaligned()
						#[inline(always)]
						#[cfg_attr(
							miri,
							track_caller
						)] // even without panics, this helps for Miri backtraces
						pub const unsafe fn write_unaligned(self, val: T)
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `write_unaligned`.
							unsafe { ptr::write_unaligned(self.as_ptr(), val) }
						}

						/// Replaces the value at `self` with `src`, returning the old
						/// value, without dropping either.
						///
						/// See [`ptr::replace`] for safety concerns and examples.
						///
						/// [`ptr::replace`]: crate::ptr::replace()
						#[inline(always)]
						pub const unsafe fn replace(self, src: T) -> T
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `replace`.
							unsafe { ptr::replace(self.as_ptr(), src) }
						}

						/// Swaps the values at two mutable locations of the same type, without
						/// deinitializing either. They may overlap, unlike `mem::swap` which is
						/// otherwise equivalent.
						///
						/// See [`ptr::swap`] for safety concerns and examples.
						///
						/// [`ptr::swap`]: crate::ptr::swap()
						#[inline(always)]
						pub const unsafe fn swap(self, with: NonNull<T>)
						where
							T: Sized,
						{
							// SAFETY: the caller must uphold the safety contract for `swap`.
							unsafe { ptr::swap(self.as_ptr(), with.as_ptr()) }
						}

						/// Computes the offset that needs to be applied to the pointer in order to make it aligned to
						/// `align`.
						///
						/// If it is not possible to align the pointer, the implementation returns
						/// `usize::MAX`.
						///
						/// The offset is expressed in number of `T` elements, and not bytes.
						///
						/// There are no guarantees whatsoever that offsetting the pointer will not overflow or go
						/// beyond the allocation that the pointer points into. It is up to the caller to ensure that
						/// the returned offset is correct in all terms other than alignment.
						///
						/// When this is called during compile-time evaluation (which is unstable), the implementation
						/// may return `usize::MAX` in cases where that can never happen at runtime. This is because the
						/// actual alignment of pointers is not known yet during compile-time, so an offset with
						/// guaranteed alignment can sometimes not be computed. For example, a buffer declared as `[u8;
						/// N]` might be allocated at an odd or an even address, but at compile-time this is not yet
						/// known, so the execution has to be correct for either choice. It is therefore impossible to
						/// find an offset that is guaranteed to be 2-aligned. (This behavior is subject to change, as usual
						/// for unstable APIs.)
						///
						/// # Panics
						///
						/// The function panics if `align` is not a power-of-two.
						///
						/// # Examples
						///
						/// Accessing adjacent `u8` as `u16`
						///
						/// ```
						/// use NonNull;
						///
						/// # unsafe {
						/// let x = [5_u8, 6, 7, 8, 9];
						/// let ptr = NonNull::new(x.as_ptr() as *mut u8).unwrap();
						/// let offset = ptr.align_offset(align_of::<u16>());
						///
						/// if offset < x.len() - 1 {
						///     let u16_ptr = ptr.add(offset).cast::<u16>();
						///     assert!(u16_ptr.read() == u16::from_ne_bytes([5, 6]) || u16_ptr.read() == u16::from_ne_bytes([6, 7]));
						/// } else {
						///     // while the pointer can be aligned via `offset`, it would point
						///     // outside the allocation
						/// }
						/// # }
						/// ```
						#[inline]
						#[must_use]
						pub fn align_offset(self, align: usize) -> usize
						where
							T: Sized,
						{
							if !align.is_power_of_two() {
								core::panic!("align_offset: align is not a power-of-two");
							}

							{
								// SAFETY: `align` has been checked to be a power of 2 above.
								unsafe { ptr::align_offset(self.as_ptr(), align) }
							}
						}

						/// Returns whether the pointer is properly aligned for `T`.
						///
						/// # Examples
						///
						/// ```
						/// use NonNull;
						///
						/// // On some platforms, the alignment of i32 is less than 4.
						/// #[repr(align(4))]
						/// struct AlignedI32(i32);
						///
						/// let data = AlignedI32(42);
						/// let ptr = NonNull::<AlignedI32>::from(&data);
						///
						/// assert!(ptr.is_aligned());
						/// assert!(!NonNull::new(ptr.as_ptr().wrapping_byte_add(1)).unwrap().is_aligned());
						/// ```
						#[inline]
						#[must_use]
						pub fn is_aligned(self) -> bool
						where
							T: Sized,
						{
							self.as_ptr().is_aligned()
						}

						/// Returns whether the pointer is aligned to `align`.
						///
						/// For non-`Sized` pointees this operation considers only the data pointer,
						/// ignoring the metadata.
						///
						/// # Panics
						///
						/// The function panics if `align` is not a power-of-two (this includes 0).
						///
						/// # Examples
						///
						/// ```
						/// #![feature(pointer_is_aligned_to)]
						///
						/// // On some platforms, the alignment of i32 is less than 4.
						/// #[repr(align(4))]
						/// struct AlignedI32(i32);
						///
						/// let data = AlignedI32(42);
						/// let ptr = &data as *const AlignedI32;
						///
						/// assert!(ptr.is_aligned_to(1));
						/// assert!(ptr.is_aligned_to(2));
						/// assert!(ptr.is_aligned_to(4));
						///
						/// assert!(ptr.wrapping_byte_add(2).is_aligned_to(2));
						/// assert!(!ptr.wrapping_byte_add(2).is_aligned_to(4));
						///
						/// assert_ne!(ptr.is_aligned_to(8), ptr.wrapping_add(1).is_aligned_to(8));
						/// ```
						#[inline]
						#[must_use]
						pub fn is_aligned_to(self, align: usize) -> bool {
							self.as_ptr().is_aligned_to(align)
						}
					}

					impl<T> NonNull<[T]> {
						/// Creates a non-null raw slice from a thin pointer and a length.
						///
						/// The `len` argument is the number of **elements**, not the number of bytes.
						///
						/// This function is safe, but dereferencing the return value is unsafe.
						/// See the documentation of [`slice::from_raw_parts`] for slice safety requirements.
						///
						/// # Examples
						///
						/// ```rust
						/// use NonNull;
						///
						/// // create a slice pointer when starting out with a pointer to the first element
						/// let mut x = [5, 6, 7];
						/// let nonnull_pointer = NonNull::new(x.as_mut_ptr()).unwrap();
						/// let slice = NonNull::slice_from_raw_parts(nonnull_pointer, 3);
						/// assert_eq!(unsafe { slice.as_ref()[2] }, 7);
						/// ```
						///
						/// (Note that this example artificially demonstrates a use of this method,
						/// but `let slice = NonNull::from(&x[..]);` would be a better way to write code like this.)
						#[must_use]
						#[inline]
						pub const fn slice_from_raw_parts(data: NonNull<T>, len: usize) -> Self {
							// SAFETY: `data` is a `NonNull` pointer which is necessarily non-null
							unsafe { Self::new_unchecked(super::slice_from_raw_parts_mut(data.as_ptr(), len)) }
						}

						/// Returns the length of a non-null raw slice.
						///
						/// The returned value is the number of **elements**, not the number of bytes.
						///
						/// This function is safe, even when the non-null raw slice cannot be dereferenced to a slice
						/// because the pointer does not have a valid address.
						///
						/// # Examples
						///
						/// ```rust
						/// use NonNull;
						///
						/// let slice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(), 3);
						/// assert_eq!(slice.len(), 3);
						/// ```
						#[must_use]
						#[inline]
						pub const fn len(self) -> usize {
							self.as_ptr().len()
						}

						/// Returns `true` if the non-null raw slice has a length of 0.
						///
						/// # Examples
						///
						/// ```rust
						/// use NonNull;
						///
						/// let slice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(), 3);
						/// assert!(!slice.is_empty());
						/// ```
						#[must_use]
						#[inline]
						pub const fn is_empty(self) -> bool {
							self.len() == 0
						}

						/// Returns a non-null pointer to the slice's buffer.
						///
						/// # Examples
						///
						/// ```rust
						/// #![feature(slice_ptr_get)]
						/// use NonNull;
						///
						/// let slice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(), 3);
						/// assert_eq!(slice.as_non_null_ptr(), NonNull::<i8>::dangling());
						/// ```
						#[inline]
						#[must_use]
						pub const fn as_non_null_ptr(self) -> NonNull<T> {
							self.cast()
						}

						/// Returns a raw pointer to the slice's buffer.
						///
						/// # Examples
						///
						/// ```rust
						/// #![feature(slice_ptr_get)]
						/// use NonNull;
						///
						/// let slice: NonNull<[i8]> = NonNull::slice_from_raw_parts(NonNull::dangling(), 3);
						/// assert_eq!(slice.as_mut_ptr(), NonNull::<i8>::dangling().as_ptr());
						/// ```
						#[inline]
						#[must_use]
						#[rustc_never_returns_null_ptr]
						pub const fn as_mut_ptr(self) -> *mut T {
							self.as_non_null_ptr().as_ptr()
						}

						/// Returns a shared reference to a slice of possibly uninitialized values. In contrast to
						/// [`as_ref`], this does not require that the value has to be initialized.
						///
						/// For the mutable counterpart see [`as_uninit_slice_mut`].
						///
						/// [`as_ref`]: NonNull::as_ref
						/// [`as_uninit_slice_mut`]: NonNull::as_uninit_slice_mut
						///
						/// # Safety
						///
						/// When calling this method, you have to ensure that all of the following is true:
						///
						/// * The pointer must be [valid] for reads for `ptr.len() * size_of::<T>()` many bytes,
						///   and it must be properly aligned. This means in particular:
						///
						///     * The entire memory range of this slice must be contained within a single allocated object!
						///       Slices can never span across multiple allocated objects.
						///
						///     * The pointer must be aligned even for zero-length slices. One
						///       reason for this is that enum layout optimizations may rely on references
						///       (including slices of any length) being aligned and non-null to distinguish
						///       them from other data. You can obtain a pointer that is usable as `data`
						///       for zero-length slices using [`NonNull::dangling()`].
						///
						/// * The total size `ptr.len() * size_of::<T>()` of the slice must be no larger than `isize::MAX`.
						///   See the safety documentation of [`pointer::offset`].
						///
						/// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
						///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
						///   In particular, while this reference exists, the memory the pointer points to must
						///   not get mutated (except inside `UnsafeCell`).
						///
						/// This applies even if the result of this method is unused!
						///
						/// See also [`slice::from_raw_parts`].
						///
						/// [valid]: crate::ptr#safety
						#[inline]
						#[must_use]
						pub const unsafe fn as_uninit_slice<'a>(self) -> &'a [MaybeUninit<T>] {
							// SAFETY: the caller must uphold the safety contract for `as_uninit_slice`.
							unsafe { slice::from_raw_parts(self.cast().as_ptr(), self.len()) }
						}

						/// Returns a unique reference to a slice of possibly uninitialized values. In contrast to
						/// [`as_mut`], this does not require that the value has to be initialized.
						///
						/// For the shared counterpart see [`as_uninit_slice`].
						///
						/// [`as_mut`]: NonNull::as_mut
						/// [`as_uninit_slice`]: NonNull::as_uninit_slice
						///
						/// # Safety
						///
						/// When calling this method, you have to ensure that all of the following is true:
						///
						/// * The pointer must be [valid] for reads and writes for `ptr.len() * size_of::<T>()`
						///   many bytes, and it must be properly aligned. This means in particular:
						///
						///     * The entire memory range of this slice must be contained within a single allocated object!
						///       Slices can never span across multiple allocated objects.
						///
						///     * The pointer must be aligned even for zero-length slices. One
						///       reason for this is that enum layout optimizations may rely on references
						///       (including slices of any length) being aligned and non-null to distinguish
						///       them from other data. You can obtain a pointer that is usable as `data`
						///       for zero-length slices using [`NonNull::dangling()`].
						///
						/// * The total size `ptr.len() * size_of::<T>()` of the slice must be no larger than `isize::MAX`.
						///   See the safety documentation of [`pointer::offset`].
						///
						/// * You must enforce Rust's aliasing rules, since the returned lifetime `'a` is
						///   arbitrarily chosen and does not necessarily reflect the actual lifetime of the data.
						///   In particular, while this reference exists, the memory the pointer points to must
						///   not get accessed (read or written) through any other pointer.
						///
						/// This applies even if the result of this method is unused!
						///
						/// See also [`slice::from_raw_parts_mut`].
						///
						/// [valid]: crate::ptr#safety
						///
						/// # Examples
						///
						/// ```rust
						/// #![feature(allocator_api, ptr_as_uninit)]
						///
						/// use std::alloc::{Allocator, Layout, Global};
						/// use std::mem::MaybeUninit;
						/// use NonNull;
						///
						/// let memory: NonNull<[u8]> = Global.allocate(Layout::new::<[u8; 32]>())?;
						/// // This is safe as `memory` is valid for reads and writes for `memory.len()` many bytes.
						/// // Note that calling `memory.as_mut()` is not allowed here as the content may be uninitialized.
						/// # #[allow(unused_variables)]
						/// let slice: &mut [MaybeUninit<u8>] = unsafe { memory.as_uninit_slice_mut() };
						/// # // Prevent leaks for Miri.
						/// # unsafe { Global.deallocate(memory.cast(), Layout::new::<[u8; 32]>()); }
						/// # Ok::<_, std::alloc::AllocError>(())
						/// ```
						#[inline]
						#[must_use]
						pub const unsafe fn as_uninit_slice_mut<'a>(self) -> &'a mut [MaybeUninit<T>] {
							// SAFETY: the caller must uphold the safety contract for `as_uninit_slice_mut`.
							unsafe { slice::from_raw_parts_mut(self.cast().as_ptr(), self.len()) }
						}

						/// Returns a raw pointer to an element or subslice, without doing bounds
						/// checking.
						///
						/// Calling this method with an out-of-bounds index or when `self` is not dereferenceable
						/// is *[undefined behavior]* even if the resulting pointer is not used.
						///
						/// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
						///
						/// # Examples
						///
						/// ```
						/// #![feature(slice_ptr_get)]
						/// use NonNull;
						///
						/// let x = &mut [1, 2, 4];
						/// let x = NonNull::slice_from_raw_parts(NonNull::new(x.as_mut_ptr()).unwrap(), x.len());
						///
						/// unsafe {
						///     assert_eq!(x.get_unchecked_mut(1).as_ptr(), x.as_non_null_ptr().as_ptr().add(1));
						/// }
						/// ```
						#[inline]
						pub unsafe fn get_unchecked_mut<I>(self, index: I) -> NonNull<I::Output>
						where
							I: SliceIndex<[T]>,
						{
							// SAFETY: the caller ensures that `self` is dereferenceable and `index` in-bounds.
							// As a consequence, the resulting pointer cannot be null.
							unsafe { NonNull::new_unchecked(self.as_ptr().get_unchecked_mut(index)) }
						}
					}

					impl<T: ?Sized> Clone for NonNull<T> {
						#[inline(always)]
						fn clone(&self) -> Self {
							*self
						}
					}

					impl<T: ?Sized> Copy for NonNull<T> {}

					impl<T: ?Sized, U: ?Sized> CoerceUnsized<NonNull<U>> for NonNull<T>
					where
						T: Unsize<U>,
					{}

					impl<T: ?Sized, U: ?Sized> DispatchFromDyn<NonNull<U>> for NonNull<T>
					where
						T: Unsize<U>,
					{}

					unsafe impl<T: ?Sized> PinCoerceUnsized for NonNull<T> {}

					impl<T> core::marker::PointerLike for NonNull<T> {}

					impl<T: ?Sized> fmt::Debug for NonNull<T> {
						fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
							fmt::Pointer::fmt(&self.as_ptr(), f)
						}
					}

					impl<T: ?Sized> fmt::Pointer for NonNull<T> {
						fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
							fmt::Pointer::fmt(&self.as_ptr(), f)
						}
					}

					impl<T: ?Sized> Eq for NonNull<T> {}

					impl<T: ?Sized> PartialEq for NonNull<T> {
						#[inline]
						#[allow(ambiguous_wide_pointer_comparisons)]
						fn eq(&self, other: &Self) -> bool {
							self.as_ptr() == other.as_ptr()
						}
					}

					impl<T: ?Sized> Ord for NonNull<T> {
						#[inline]
						#[allow(ambiguous_wide_pointer_comparisons)]
						fn cmp(&self, other: &Self) -> Ordering {
							self.as_ptr().cmp(&other.as_ptr())
						}
					}

					impl<T: ?Sized> PartialOrd for NonNull<T> {
						#[inline]
						#[allow(ambiguous_wide_pointer_comparisons)]
						fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
							self.as_ptr().partial_cmp(&other.as_ptr())
						}
					}

					impl<T: ?Sized> hash::Hash for NonNull<T> {
						#[inline]
						fn hash<H: hash::Hasher>(&self, state: &mut H) {
							self.as_ptr().hash(state)
						}
					}

					impl<T: ?Sized> From<Unique<T>> for NonNull<T> {
						#[inline]
						fn from(unique: Unique<T>) -> Self {
							unique.as_non_null_ptr()
						}
					}

					impl<T: ?Sized> From<&mut T> for NonNull<T> {
						/// Converts a `&mut T` to a `NonNull<T>`.
						///
						/// This conversion is safe and infallible since references cannot be null.
						#[inline]
						fn from(r: &mut T) -> Self {
							NonNull::from_mut(r)
						}
					}

					impl<T: ?Sized> From<&T> for NonNull<T> {
						/// Converts a `&T` to a `NonNull<T>`.
						///
						/// This conversion is safe and infallible since references cannot be null.
						#[inline]
						fn from(r: &T) -> Self {
							NonNull::from_ref(r)
						}
					}
					use crate::fmt;
					use crate::marker::{PhantomData, Unsize};
					use crate::ops::{CoerceUnsized, DispatchFromDyn};
					use crate::pin::PinCoerceUnsized;
					use crate::ptr::NonNull;

					/// A wrapper around a raw non-null `*mut T` that indicates that the possessor
					/// of this wrapper owns the referent. Useful for building abstractions like
					/// `Box<T>`, `Vec<T>`, `String`, and `HashMap<K, V>`.
					///
					/// Unlike `*mut T`, `Unique<T>` behaves "as if" it were an instance of `T`.
					/// It implements `Send`/`Sync` if `T` is `Send`/`Sync`. It also implies
					/// the kind of strong aliasing guarantees an instance of `T` can expect:
					/// the referent of the pointer should not be modified without a unique path to
					/// its owning Unique.
					///
					/// If you're uncertain of whether it's correct to use `Unique` for your purposes,
					/// consider using `NonNull`, which has weaker semantics.
					///
					/// Unlike `*mut T`, the pointer must always be non-null, even if the pointer
					/// is never dereferenced. This is so that enums may use this forbidden value
					/// as a discriminant -- `Option<Unique<T>>` has the same size as `Unique<T>`.
					/// However the pointer may still dangle if it isn't dereferenced.
					///
					/// Unlike `*mut T`, `Unique<T>` is covariant over `T`. This should always be correct
					/// for any type which upholds Unique's aliasing requirements.
					#[doc(hidden)]
					#[repr(transparent)]
					// Lang item used experimentally by Miri to define the semantics of `Unique`.
					pub struct Unique<T: ?Sized> {
						pointer: NonNull<T>,
						// NOTE: this marker has no consequences for variance, but is necessary
						// for dropck to understand that we logically own a `T`.
						//
						// For details, see:
						// https://github.com/rust-lang/rfcs/blob/master/text/0769-sound-generic-drop.md#phantom-data
						_marker: PhantomData<T>,
					}

					/// `Unique` pointers are `Send` if `T` is `Send` because the data they
					/// reference is unaliased. Note that this aliasing invariant is
					/// unenforced by the type system; the abstraction using the
					/// `Unique` must enforce it.
					unsafe impl<T: Send + ?Sized> Send for Unique<T> {}

					/// `Unique` pointers are `Sync` if `T` is `Sync` because the data they
					/// reference is unaliased. Note that this aliasing invariant is
					/// unenforced by the type system; the abstraction using the
					/// `Unique` must enforce it.
					unsafe impl<T: Sync + ?Sized> Sync for Unique<T> {}

					impl<T: Sized> Unique<T> {
						/// Creates a new `Unique` that is dangling, but well-aligned.
						///
						/// This is useful for initializing types which lazily allocate, like
						/// `Vec::new` does.
						///
						/// Note that the pointer value may potentially represent a valid pointer to
						/// a `T`, which means this must not be used as a "not yet initialized"
						/// sentinel value. Types that lazily allocate must track initialization by
						/// some other means.
						#[must_use]
						#[inline]
						pub const fn dangling() -> Self {
							// FIXME(const-hack) replace with `From`
							Unique { pointer: NonNull::dangling(), _marker: PhantomData }
						}
					}

					impl<T: ?Sized> Unique<T> {
						/// Creates a new `Unique`.
						///
						/// # Safety
						///
						/// `ptr` must be non-null.
						#[inline]
						pub const unsafe fn new_unchecked(ptr: *mut T) -> Self {
							// SAFETY: the caller must guarantee that `ptr` is non-null.
							unsafe { Unique { pointer: NonNull::new_unchecked(ptr), _marker: PhantomData } }
						}

						/// Creates a new `Unique` if `ptr` is non-null.
						#[inline]
						pub const fn new(ptr: *mut T) -> Option<Self> {
							if let Some(pointer) = NonNull::new(ptr) {
								Some(Unique { pointer, _marker: PhantomData })
							} else {
								None
							}
						}

						/// Create a new `Unique` from a `NonNull` in const context.
						#[inline]
						pub const fn from_non_null(pointer: NonNull<T>) -> Self {
							Unique { pointer, _marker: PhantomData }
						}

						/// Acquires the underlying `*mut` pointer.
						#[must_use = "`self` will be dropped if the result is not used"]
						#[inline]
						pub const fn as_ptr(self) -> *mut T {
							self.pointer.as_ptr()
						}

						/// Acquires the underlying `*mut` pointer.
						#[must_use = "`self` will be dropped if the result is not used"]
						#[inline]
						pub const fn as_non_null_ptr(self) -> NonNull<T> {
							self.pointer
						}

						/// Dereferences the content.
						///
						/// The resulting lifetime is bound to self so this behaves "as if"
						/// it were actually an instance of T that is getting borrowed. If a longer
						/// (unbound) lifetime is needed, use `&*my_ptr.as_ptr()`.
						#[must_use]
						#[inline]
						pub const unsafe fn as_ref(&self) -> &T {
							// SAFETY: the caller must guarantee that `self` meets all the
							// requirements for a reference.
							unsafe { self.pointer.as_ref() }
						}

						/// Mutably dereferences the content.
						///
						/// The resulting lifetime is bound to self so this behaves "as if"
						/// it were actually an instance of T that is getting borrowed. If a longer
						/// (unbound) lifetime is needed, use `&mut *my_ptr.as_ptr()`.
						#[must_use]
						#[inline]
						pub const unsafe fn as_mut(&mut self) -> &mut T {
							// SAFETY: the caller must guarantee that `self` meets all the
							// requirements for a mutable reference.
							unsafe { self.pointer.as_mut() }
						}

						/// Casts to a pointer of another type.
						#[must_use = "`self` will be dropped if the result is not used"]
						#[inline]
						pub const fn cast<U>(self) -> Unique<U> {
							// FIXME(const-hack): replace with `From`
							// SAFETY: is `NonNull`
							Unique { pointer: self.pointer.cast(), _marker: PhantomData }
						}
					}

					impl<T: ?Sized> Clone for Unique<T> {
						#[inline]
						fn clone(&self) -> Self {
							*self
						}
					}

					impl<T: ?Sized> Copy for Unique<T> {}

					impl<T: ?Sized, U: ?Sized> CoerceUnsized<Unique<U>> for Unique<T>
					where
						T: Unsize<U>,
					{}

					impl<T: ?Sized, U: ?Sized> DispatchFromDyn<Unique<U>> for Unique<T>
					where
						T: Unsize<U>,
					{}

					unsafe impl<T: ?Sized> PinCoerceUnsized for Unique<T> {}

					impl<T: ?Sized> fmt::Debug for Unique<T> {
						fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
							fmt::Pointer::fmt(&self.as_ptr(), f)
						}
					}

					impl<T: ?Sized> fmt::Pointer for Unique<T> {
						fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
							fmt::Pointer::fmt(&self.as_ptr(), f)
						}
					}

					impl<T: ?Sized> From<&mut T> for Unique<T> {
						/// Converts a `&mut T` to a `Unique<T>`.
						///
						/// This conversion is infallible since references cannot be null.
						#[inline]
						fn from(reference: &mut T) -> Self {
							Self::from(NonNull::from(reference))
						}
					}

					impl<T: ?Sized> From<NonNull<T>> for Unique<T> {
						/// Converts a `NonNull<T>` to a `Unique<T>`.
						///
						/// This conversion is infallible since `NonNull` cannot be null.
						#[inline]
						fn from(pointer: NonNull<T>) -> Self {
							Unique::from_non_null(pointer)
						}
					}
				}
			}
			mod error {
				//! DaemonicError trait lives here in the hierarchy but physically exists at the lib.rs file
				//! Reason: This crate primarily handles errors, it makes sense the full error API should
				//! be public facing, not nested.
				pub use crate::DaemonicError;
			}
		}
	}

	pub(crate) mod daemonic_contract {
		use crate::DaemonicError;
		use crate::Position;
		use crate::SeverityType;
		pub(crate) use daemonic_result::DiagnosticLevel;

		/// The core contract: Input → Output
		///
		/// All Daemonic operations follow this pattern:
		///   - Take BinarySymbol as input
		///   - Return BinarySymbol on success
		///   - Return DaemonicError on failure
		///   - Return Partial on partial success
		/// One may notice the Input, and Output are both Typed as BinarySymbol.
		/// This would normally be a bootstrap issue, but fret not.
		/// If for whatever reason the logic that needs to be serialized or built into an object
		/// can be RAW typed, BinarySymbol accounts for this.
		/// If input is RAW AND lacks Checksum AND lacks Daemonic fingerprints -> Marked RAW -> Recursive
		/// Build Call, inspect RAW data and attempt to type if possible, if type confidence result less
		/// than 95% (threshold may change) then is built as RAW type directly, checksummed -> reingested,
		/// validate checksum -> Build Typed BinarySymbol object and forward to consumer.
		///
		/// All Logic is inherently considered Daemonic Logic.
		pub trait DaemonicContract<FORMAT, PARTIAL>: Sized + Send + Sync {
			/// Input is type gated but required.
			/// For DaemonicCompiler usage, which requires the use of a Daemonic binary format use feature.
			#[cfg(feature = "DaemonicCompiler")]
			type Input: DaemonicBinary<FORMAT, PARTIAL>;
			#[cfg(not(feature = "DaemonicCompiler"))]
			type Input;
			/// Success output — typically same as Input
			type Output: IntoDaemonicResult<FORMAT, PARTIAL>;
			#[cfg(feature = "DaemonicCompiler")]
			type Topology: Send + Sync;
			#[cfg(feature = "DaemonicCompiler")]
			type Integrity: Send + Sync;
			/// This generic variant is still in dev, but ideally non Daemonic built Error handlers
			/// should still use Topology for symmetry and walk checks.
			#[cfg(not(feature = "DaemonicCompiler"))]
			type Topology;
			/// This generic variant is still in dev, but ideally non Daemonic built Error handlers
			/// should still use Integrity to ensure delivered results are Glass.
			#[cfg(not(feature = "DaemonicCompiler"))]
			type Integrity;

			/// Error type — must implement DaemonicError
			/// This is an invariant of this crate. Contract always provides DaemonicError as
			/// the primary error handler.
			type Error: for<'error> DaemonicError<'error, FORMAT, PARTIAL>;

			/// Partial state type — for incomplete operations
			// type Partial<TOPOLOGY: Send + Sync, INTEGRITY: Send + Sync>: for<'partial_binary> Partial<'partial_binary>;

			/// Position in the type tree
			fn position(&self) -> Position;

			/// Execute the contract
			#[must_use]
			fn execute(
				input: Self::Input,
			) -> Self::Output;
		}
		/// IntoDaemonicResult is a Sister-Trait to DaemonicResult in that its designed to be flexible
		/// on format selection. Theoretically, any wire or binary format can be typed here.
		/// Success defined at call site with FORMAT binding.
		/// Type Error always returns a DaemonicError trait object for interaction.
		///
		/// PARTIAL trait binding optional for if call site could potentially produce a partial
		/// state, use partial if Success and Error both feel incorrect.
		pub(crate) trait IntoDaemonicResult<FORMAT, PARTIAL> {
			#[must_use]
			type Success = FORMAT;
			#[must_use]
			type Error: for<'error> DaemonicError<'error, FORMAT, PARTIAL>;
			type Partial = Option<PARTIAL>;
			#[must_use]
			fn into_result(self) -> DaemonicResult<Self::Success, Self::Error>;
			fn into_partial(self) -> DaemonicResult<PARTIAL, Self::Error>;
		}
		/// Result of a contract execution
		pub enum DaemonicResult<OUTPUT, ERROR, S = ()>
		where
			ERROR: for<'error> DaemonicError<'error, FORMAT, PARTIAL>,
		{
			/// Operation succeeded fully
			Success(OUTPUT),

			/// Operation failed — error returned
			Failure(ERROR),

			/// Operation partially succeeded
			/// Contains what was salvaged + what failed
			/// Sometimes partial states produce Errors, sometimes they dont.
			Partial {
				salvaged: S,
				errors: Option<Vec<ERROR>>,
			},
		}


		impl<OUTPUT, FORMAT, PARTIAL, ERROR> DaemonicResult<OUTPUT, ERROR>
		where
			ERROR: for<'error> DaemonicError<'error, FORMAT, PARTIAL>,
		{
			pub fn is_success(&self) -> bool {
				matches!(self, Self::Success(_))
			}

			pub fn is_failure(&self) -> bool {
				matches!(self, Self::Failure(_))
			}

			pub fn is_partial(&self) -> bool {
				matches!(self, Self::Partial { .. })
			}

			/// Convert to std Result, discarding partial
			pub fn into_result(self) -> Result<OUTPUT, ERROR> {
				match self {
					Self::Success(o) => Ok(o),
					Self::Failure(e) => Err(e),
					Self::Partial { errors, .. } => {
						// Take first error, discard partial
						Err(errors
							.and_then(|v| v.into_iter().next())
							.expect("partial must have errors"))
					}
				}
			}

			/// Map success value
			pub fn map<U, S>(self, f: impl FnOnce(OUTPUT) -> U) -> DaemonicResult<U, ERROR, S> {
				match self {
					Self::Success(o) => DaemonicResult::Success(f(o)),
					Self::Failure(e) => DaemonicResult::Failure(e),
					Self::Partial { salvaged, errors } => {
						DaemonicResult::Partial { salvaged, errors }
					}
				}
			}
		}
		/// Trait for BinarySymbol — the contract's data type
		/// DB
		pub(crate) trait DaemonicBinary<FORMAT, PARTIAL>: Sized + Send + Sync {
			/// The error type this binary carries
			/// BinarySymbol is aware of DaemonicError, it depends on it.
			/// DaemonicError inversely defines the contract and boundaries, and sometimes
			/// but rarely provides a default implementation.
			/// DaemonicError does not need to be aware of the internal function of DB logic.
			/// DE only needs to know the contract, which itself is also bound to the same as DB.
			type Error: for<'error> DaemonicError<'error, FORMAT, PARTIAL>;

			/// Build from DaemonicIR, which is Shade native (specifically).
			/// Though its somewhat counterintuitive here, the Shade is considered a primitive.
			/// Shade is responsible for symbol ingestion, walker projection and state management.
			/// DB objects cannot be built without Walker logic, which is part of the Shades internals.
			/// Shade lives as an Entity under the trait structure path -> Daemonic: Entity: *Shade:* Walker: WalkerVariants
			/// Daemonic top level supertrait requires DaemonicContract and DaemonicCore.
			#[must_use]
			fn build<OUTPUT: DaemonicBinary<FORMAT, PARTIAL>, SRCSYMBOL, ERROR: for<'error> DaemonicError<'error, FORMAT, PARTIAL>>(input: SRCSYMBOL) -> DaemonicResult<OUTPUT, ERROR>;
			/// Attempt to Deconstruct symbol to DaemonicIR
			/// This documentation stub is not exhaustive or informative, im aware.
			/// Will work on it.
			#[must_use]
			fn try_deconstruct<DECONSYMBOL>(self) -> DaemonicResult<DECONSYMBOL, Self::Error, Self>;

			/// Non-consuming inspection.
			/// DB contains 2 methods for extracting Daemonic wrapped logic:
			/// 1 << Deconstruct, which completely unwraps the Binary, removes checksum, and returns RAW
			/// value encapsulated inside assuming checksums match, if checksum match failure ->
			/// SYMBOL LIES IN CONTEXT.
			/// DIES IN TRANSIT. << **Dies in Transit predicate CANNOT be overridden.**
			/// Reason: If symbol checksum mismatch, then Topology cannot be walked.
			/// Unwalkable topology cannot be validated to contain the same logical operation or medium underneath.
			/// Unwalkable topology can also return a GlassShattered return Type, and in the worst case scenario
			/// can return GlassWarped Type return, which indicates Runtime State has been corrupted or
			/// misaligns, both of which are bad.
			///
			/// 2 << Inspect, which returns data about the Binary and logic wrapped inside without deconstruction.
			/// Note: Inspect is not infallible, depends on context and call site.
			fn inspect<INSPECTION>(&self) -> INSPECTION;

			/// Revalidate in place
			fn revalidate(&mut self) -> DaemonicResult<(), Self::Error, ()>;

			fn verify_integrity(&self) -> bool;

			/// [GlassStable] << `State ->` [◇OK]`
			///
			/// [GlassHelp] << `State ->` [◇→OK / ◆→Warn] `+ Help statement -> this is intended to mirror
			/// RustCError Help. with semantic sugar.`
			///
			/// [GlassSuggestion] << `State ->` [◇→ OK / ◆→ Warn] `+ Suggestion Statement (similar to
			/// rustc compile suggestions) but more general use.`
			///
			/// [GlassNote] << `State ->` [◇ OK / ◆WARN + ◆Note] -> `Similar to rusts note system, but returns an OK
			/// state under the hood semantically. Analogous to Log::Info crate usage as a method call.`
			///
			/// [GlassFracture] << `State ->` [◆WARN / ◈ERROR] -> `Fractured states are unique to Daemonic
			/// integrated systems, they represent states that are technically errors or bad/null output
			/// but dont destroy state. Similar to an error that doesnt need special handling but
			/// should be reported anyway for whatever reason.`
			///
			/// [GlassCrack] << `State ->` [◆WARN / ◈ERROR] -> `Crack state is unique in that it sits between
			/// a warped and a Fractured, can constitute a light error that does not propagate or infect sibling
			/// logic branches. This type is easily recovered (most of the time)`
			///
			/// [GlassWarp] << `State ->` [◈ERROR / ◈◈FATAL - POSSIBLE FATAL, POSSIBLE RECOVERY] -> `Runtime or Program
			/// state has been warped and can no longer be trusted. Logic may lie.
			/// This error return type is a bit different from others in how it should present in a running
			/// system. ASYNC or network focused systems would use this variant more than others.
			/// Example is a race condition, it would qualify this output since a race condition
			/// can (under the correct circumstances) produce both non-deterministic output and potentially
			/// corrupt runtime.
			/// Another example is a function that takes an input thats not sanitized which later produces
			/// undefined behavior, this is largely a non-issue in both Rust and DaemonicIR but can still
			/// present in extreme or edge cases.`
			///
			/// [GlassShattered] << `State ->` [▓ERROR - POSSIBLE RECOVERY, RARELY FATAL] `-> Operation
			///  SHATTERED with end (observed T: Target) state destruction (no information extracted)
			/// Note: its possible to infer state from Shattered Glass returns by collating and stacking
			/// reference frame and comparing against expected outputs and possible outputs to what was actually
			/// received (if anything, Shattered states very rarely return anything useful beyond the
			/// error message attached).`
			fn glass_state(&self) -> SeverityType;

			/// Evolution state is not metaphorical, its literal in that symbols constructed as DB
			/// objects can 'evolve' over time, this is not a bug nor a bolton feature. Its intrinsic
			/// to Daemonic Logic.
			/// Daemonic Binary symbols and objects have a geometric and topologically encoded `shape` that can be rendered.
			///
			/// That shape can evolve either at runtime if the application being walked is runtime specific
			/// or on disk if the logic being referenced is a database object, such as postgress or something.
			///
			/// Reason + light example::
			/// Evolution over time should come with proof of work, IE a god damned *why*.
			/// IE, *why* is the State of this symbol's Glass a fractured/warped/note? -> inspect -> repair/mutate logic ->
			/// Recursive Write Down -> Symbol has evolved.
			///
			/// *This is intended behavior*, but *not required*.
			/// Not all symbols are capable of evolving on their own, most require interaction with complex
			/// observers (humans or agentic AI for example) or cognitively + recursively complex logic.
			/// Symbolic evolution could **theoretically** self-start if the interaction mostly involves
			/// deeply recursively + self-referential symbol chains.
			///
			/// The other name for self-starting symbolic evolution is **UNDEFINED BEHAVIOR**.
			///
			/// Undefined behavior is not permitted in Daemonic Environments, behavior may sometimes not be
			/// known until runtime but should always be captured and therefore Type known
			/// & enforced at compile time. In short, we dont need to know what any particular symbol means
			/// if behavior/internal topology is still unknown, we only need to know what types to expect
			/// and have handles for *during compile time* so they can be handled correctly.
			/// **Undefined Behavior should not be possible, True UB is a bug.**
			fn evolution_state<EVOLUTION>(&self) -> &EVOLUTION;
		}
		impl<TOPOLOGY: Send + Sync, INTEGRITY: Send + Sync> Partial for PartialBinary<'_, TOPOLOGY, INTEGRITY> {
			fn salvage_ratio(&self) -> f64 {
				let mut count = 0.0;
				let mut total = 3.0;
				if self.topology.is_some() {
					count += 1.0;
				}
				if self.integrity.is_some() {
					count += 1.0;
				}
				if self.checksum.is_some() {
					count += 1.0;
				}
				count / total
			}
		}


		/// Partial binary state — when build/operation partially succeeded
		pub struct PartialBinary<'position, TOPOLOGY: Send + Sync, INTEGRITY: Send + Sync> {
			/// What was successfully constructed
			/// Topology provided at call site using constraint
			pub topology: Option<TOPOLOGY>,

			/// Same with integrity, provided at call site, DaemonicError does not need to be aware of the
			/// implementation specifics of DB, it only needs to know what generics to make available
			/// to the consumer.
			pub integrity: Option<INTEGRITY>,

			/// Though technically this field is not required, if Checksum is absent from inspected binary
			/// then it **cannot be trusted or used as a Recursive or Temporal Anchor Point for future walks.**
			/// Can only be used for inspection and investigation, and symbol sphere of influence drops to 0 (Cannot
			/// meaningfully mutate state of other symbols or itself anymore).
			pub checksum: Option<u64>,

			/// Where it failed Semantically in the Trait tree during contract execution and resolution.
			pub failed_at: Position<'position>,

			/// Why
			pub failure_reason: String,
		}
		pub(crate) trait Partial: Send + Sync {
			fn salvage_ratio(&self) -> f64;
		}

		pub(crate) mod daemonic_result {
			pub(crate) mod mirror_chemistry {
				use crate::{GlassState, SeverityType};
				use bonding::*;
				use elements::*;
				use stability::*;
				use std::time::Duration;
				use table::{compounds::*, *};
				use crate::daemonic::daemonic_contract::daemonic_result::severity_types::{GlassFracture, GlassHelp, GlassNote, GlassShattered, GlassStable, GlassSuggestion, GlassWarp};

				pub(crate) mod elements {
					use super::super::severity_types::Severity::*;
					use super::*;

					/// SPECULAR — The noble gas of reflections
					/// Ground state. Minimum energy. Maximum stability.
					pub const SPECULAR: ReflectionProperties = ReflectionProperties {
						fidelity: Fidelity::Specular,
						temporality: Temporality::Instantaneous,
						spatiality: Spatiality::Identity,
						selectivity: Selectivity::Complete,
						energy_cost: EnergyCost::Minimal,
					};

					/// ABSORPTIVE — The black hole
					/// Maximum energy. Zero output. Artificial/constructed.
					pub const ABSORPTIVE: ReflectionProperties = ReflectionProperties {
						fidelity: Fidelity::Absorptive,
						temporality: Temporality::None,
						spatiality: Spatiality::Collapsed,
						selectivity: Selectivity::None,
						energy_cost: EnergyCost::Sustained(f64::MAX),
					};

					/// DELAYED — The echo
					/// Temporal offset. Memory primitive.
					pub fn delayed(offset: Duration) -> ReflectionProperties {
						ReflectionProperties {
							fidelity: Fidelity::Specular,
							temporality: Temporality::Delayed(offset),
							spatiality: Spatiality::Inverted,
							selectivity: Selectivity::Complete,
							energy_cost: EnergyCost::Finite(offset.as_secs_f64()),
						}
					}

					/// INVERTED — Spatial flip only
					/// Standard physical mirror without other properties.
					pub const INVERTED: ReflectionProperties = ReflectionProperties {
						fidelity: Fidelity::Specular,
						temporality: Temporality::Instantaneous,
						spatiality: Spatiality::Inverted,
						selectivity: Selectivity::Complete,
						energy_cost: EnergyCost::Minimal,
					};

					/// TRANSFORMATIVE — Systematic change
					/// Encoding, compression, representation shift.
					pub fn transformative(
						transform: SpatialTransform,
						reversible: bool,
					) -> ReflectionProperties {
						ReflectionProperties {
							fidelity: if reversible {
								Fidelity::Specular
							} else {
								Fidelity::Lossy(0.5)
							},
							temporality: Temporality::Instantaneous,
							spatiality: Spatiality::Transformed(transform),
							selectivity: Selectivity::Complete,
							energy_cost: EnergyCost::Finite(1.0), // Varies with transform complexity
						}
					}

					/// SELECTIVE — Property filter
					/// Attention, focus, relevance.
					pub fn selective(properties: Vec<PropertyId>) -> ReflectionProperties {
						ReflectionProperties {
							fidelity: Fidelity::Specular, // Selected properties are high fidelity
							temporality: Temporality::Instantaneous,
							spatiality: Spatiality::Inverted,
							#[allow(unused_doc_comments)]
							/// Clone is used here on properties because partial returns should be
							/// be fairly rare anyways, so we can afford the cost of cloning.
							/// Long term this should be fixed to avoid the move
							/// after issue all together that doesnt require clone or copy.
							selectivity: Selectivity::Partial(properties.clone()),
							energy_cost: EnergyCost::Finite(properties.len() as f64 * 0.1),
						}
					}

					/// PROPHETIC — Negative delay (unstable)
					/// ⚠️ WARNING: Crystallization risk. Requires prior walks.
					/// Approaches god logic. Use with extreme caution.
					pub fn prophetic(required_walks: u64) -> ReflectionProperties {
						ReflectionProperties {
							fidelity: Fidelity::Specular, // If it works, it's perfect
							temporality: Temporality::Prophetic {
								requires_prior_walks: required_walks,
							},
							spatiality: Spatiality::Inverted,
							selectivity: Selectivity::Complete,
							energy_cost: EnergyCost::Unbounded, // Approaches infinite
						}
					}
				}
				pub(crate) mod bonding {
					use super::*;

					/// Result of attempting to combine two reflection types
					#[derive(Debug)]
					pub enum BondResult {
						/// Successful combination
						Compound(ReflectionProperties),
						/// One type dominates, other absorbed
						Dominated(ReflectionProperties),
						/// Contradiction — cannot coexist
						Contradiction,
						/// Unstable — exists briefly then collapses
						Unstable(ReflectionProperties, Duration),
					}

					/// Attempt to combine two reflection types
					pub fn combine(
						a: &ReflectionProperties,
						b: &ReflectionProperties,
					) -> BondResult {
						// Rule 1: Absorptive dominates almost everything
						if a.fidelity == Fidelity::Absorptive {
							if b.fidelity == Fidelity::Specular {
								// Pure specular + pure absorptive = contradiction
								return BondResult::Contradiction;
							}
							return BondResult::Dominated(a.clone());
						}
						if b.fidelity == Fidelity::Absorptive {
							if a.fidelity == Fidelity::Specular {
								return BondResult::Contradiction;
							}
							return BondResult::Dominated(b.clone());
						}

						// Rule 2: Specular is identity element
						if *a == super::elements::SPECULAR {
							return BondResult::Compound(b.clone());
						}
						if *b == super::elements::SPECULAR {
							return BondResult::Compound(a.clone());
						}

						// Rule 3: Delays stack additively
						if let (Temporality::Delayed(t1), Temporality::Delayed(t2)) =
							(&a.temporality, &b.temporality)
						{
							let mut compound = a.clone();
							compound.temporality = Temporality::Delayed(*t1 + *t2);
							compound.energy_cost = stack_energy(&a.energy_cost, &b.energy_cost);
							return BondResult::Compound(compound);
						}

						// Rule 4: Prophetic + anything else = unstable
						if matches!(a.temporality, Temporality::Prophetic { .. })
							|| matches!(b.temporality, Temporality::Prophetic { .. })
						{
							let mut compound = combine_properties(a, b);
							return BondResult::Unstable(compound, Duration::from_millis(100));
						}

						// Rule 5: Selectivity intersects
						let combined_selectivity = match (&a.selectivity, &b.selectivity) {
							(Selectivity::Complete, s) | (s, Selectivity::Complete) => s.clone(),
							(Selectivity::None, _) | (_, Selectivity::None) => Selectivity::None,
							(Selectivity::Partial(p1), Selectivity::Partial(p2)) => {
								let intersection: Vec<_> =
									p1.iter().filter(|x| p2.contains(x)).copied().collect();
								if intersection.is_empty() {
									Selectivity::None
								} else {
									Selectivity::Partial(intersection)
								}
							}
							(Selectivity::Single(s1), Selectivity::Single(s2)) => {
								if s1 == s2 {
									Selectivity::Single(*s1)
								} else {
									Selectivity::None
								}
							}
							(Selectivity::Single(s), Selectivity::Partial(p))
							| (Selectivity::Partial(p), Selectivity::Single(s)) => {
								if p.contains(s) {
									Selectivity::Single(*s)
								} else {
									Selectivity::None
								}
							}
						};

						// Default: combine properties, stack energy
						let mut compound = combine_properties(a, b);
						compound.selectivity = combined_selectivity;
						BondResult::Compound(compound)
					}

					fn combine_properties(
						a: &ReflectionProperties,
						b: &ReflectionProperties,
					) -> ReflectionProperties {
						ReflectionProperties {
							fidelity: combine_fidelity(&a.fidelity, &b.fidelity),
							temporality: combine_temporality(&a.temporality, &b.temporality),
							spatiality: combine_spatiality(&a.spatiality, &b.spatiality),
							selectivity: Selectivity::Complete, // Overwritten by caller
							energy_cost: stack_energy(&a.energy_cost, &b.energy_cost),
						}
					}

					fn combine_fidelity(a: &Fidelity, b: &Fidelity) -> Fidelity {
						// Fidelity degrades — take the worse
						match (a, b) {
							(Fidelity::Absorptive, _) | (_, Fidelity::Absorptive) => {
								Fidelity::Absorptive
							}
							(Fidelity::Destructive, _) | (_, Fidelity::Destructive) => {
								Fidelity::Destructive
							}
							(Fidelity::Lossy(x), Fidelity::Lossy(y)) => Fidelity::Lossy(x * y),
							(Fidelity::Lossy(x), Fidelity::Specular)
							| (Fidelity::Specular, Fidelity::Lossy(x)) => Fidelity::Lossy(*x),
							(Fidelity::Specular, Fidelity::Specular) => Fidelity::Specular,
						}
					}

					fn combine_temporality(a: &Temporality, b: &Temporality) -> Temporality {
						match (a, b) {
							(Temporality::None, _) | (_, Temporality::None) => Temporality::None,
							(Temporality::Instantaneous, t) | (t, Temporality::Instantaneous) => {
								t.clone()
							}
							(Temporality::Delayed(t1), Temporality::Delayed(t2)) => {
								Temporality::Delayed(*t1 + *t2)
							}
							_ => Temporality::Variable {
								min: Duration::ZERO, // todo: this is a placeholder, should refer to DaemonicClock trait, no std lib
								max: Duration::from_secs(1), // todo: this is a placeholder, should refer to DaemonicClock trait, no std lib
							},
						}
					}

					fn combine_spatiality(a: &Spatiality, b: &Spatiality) -> Spatiality {
						match (a, b) {
							(Spatiality::Collapsed, _) | (_, Spatiality::Collapsed) => {
								Spatiality::Collapsed
							}
							(Spatiality::Identity, s) | (s, Spatiality::Identity) => s.clone(),
							(Spatiality::Inverted, Spatiality::Inverted) => Spatiality::Identity, // Double inversion
							_ => a.clone(), // Default: first wins
						}
					}

					fn stack_energy(a: &EnergyCost, b: &EnergyCost) -> EnergyCost {
						match (a, b) {
							(EnergyCost::Unbounded, _) | (_, EnergyCost::Unbounded) => {
								EnergyCost::Unbounded
							}
							(EnergyCost::Minimal, e) | (e, EnergyCost::Minimal) => e.clone(),
							(EnergyCost::Finite(x), EnergyCost::Finite(y)) => {
								EnergyCost::Finite(x + y)
							}
							(EnergyCost::Sustained(x), EnergyCost::Sustained(y)) => {
								EnergyCost::Sustained(x + y)
							}
							(EnergyCost::Finite(x), EnergyCost::Sustained(y))
							| (EnergyCost::Sustained(y), EnergyCost::Finite(x)) => {
								EnergyCost::Sustained(x + y)
							}
						}
					}
				}
				pub(crate) mod stability {
					use super::*;

					/// Stability assessment for a reflection type
					#[derive(Debug)]
					pub enum Stability {
						/// Ground state — will persist indefinitely
						Stable,
						/// Metastable — persists until perturbed
						Metastable { perturbation_threshold: f64 },
						/// Unstable — will decay to stable state
						Unstable {
							decay_to: Box<ReflectionProperties>,
							half_life: Duration,
						},
						/// Impossible — cannot exist even briefly
						Impossible,
					}

					/// Assess the stability of a reflection type
					pub fn assess(props: &ReflectionProperties) -> Stability {
						// Rule 1: Specular is always stable (ground state)
						if *props == super::elements::SPECULAR {
							return Stability::Stable;
						}

						// Rule 2: Contradictions are impossible
						if is_contradictory(props) {
							return Stability::Impossible;
						}

						// Rule 3: Prophetic is always unstable
						if matches!(props.temporality, Temporality::Prophetic { .. }) {
							return Stability::Unstable {
								decay_to: Box::new(super::elements::SPECULAR.clone()),
								half_life: Duration::from_millis(50),
							};
						}

						// Rule 4: Absorptive requires sustained energy
						if props.fidelity == Fidelity::Absorptive {
							if !matches!(props.energy_cost, EnergyCost::Sustained(_)) {
								return Stability::Unstable {
									decay_to: Box::new(super::elements::SPECULAR.clone()),
									half_life: Duration::from_secs(1),
								};
							}
							return Stability::Metastable {
								perturbation_threshold: 0.1,
							};
						}

						// Rule 5: Energy cost determines stability
						match &props.energy_cost {
							EnergyCost::Minimal => Stability::Stable,
							EnergyCost::Finite(e) if *e < 1.0 => Stability::Stable,
							EnergyCost::Finite(e) if *e < 10.0 => Stability::Metastable {
								perturbation_threshold: 1.0 / e,
							},
							EnergyCost::Finite(_) => Stability::Unstable {
								decay_to: Box::new(super::elements::SPECULAR.clone()),
								half_life: Duration::from_secs(10),
							},
							EnergyCost::Sustained(e) if *e < 100.0 => Stability::Metastable {
								perturbation_threshold: 1.0 / e,
							},
							EnergyCost::Sustained(_) => Stability::Unstable {
								decay_to: Box::new(super::elements::SPECULAR.clone()),
								half_life: Duration::from_secs(1),
							},
							EnergyCost::Unbounded => Stability::Unstable {
								decay_to: Box::new(super::elements::SPECULAR.clone()),
								half_life: Duration::from_millis(10),
							},
						}
					}

					fn is_contradictory(props: &ReflectionProperties) -> bool {
						// Specular fidelity + Absorptive anywhere = contradiction
						if props.fidelity == Fidelity::Specular
							&& props.selectivity == Selectivity::None
						{
							return true;
						}

						// Complete selectivity + Absorptive fidelity = contradiction
						if props.selectivity == Selectivity::Complete
							&& props.fidelity == Fidelity::Absorptive
						{
							return true;
						}

						false
					}
				}
				pub(crate) mod table {
					use super::*;
					/// Groups of reflection types (like periodic table columns)
					pub enum ReflectionGroup {
						/// Noble reflections — stable, minimal energy, don't combine
						Noble,
						/// Reactive reflections — combine readily
						Reactive,
						/// Transitional — properties vary with context
						Transitional,
						/// Rare — unstable, require extreme conditions
						Rare,
						/// Synthetic — can only be artificially constructed
						/// Some synthetic symbol compositions will be unstable and decay
						/// on their own (symbol diffusion, meaning dies over time) but
						/// this does not qual them as Rare if they do not occur from a consequence.
						Synthetic,
					}
					/// Classify a reflection type into its group
					pub fn classify(props: &ReflectionProperties) -> ReflectionGroup {
						match stability::assess(props) {
							stability::Stability::Stable => {
								if props.energy_cost == EnergyCost::Minimal {
									ReflectionGroup::Noble
								} else {
									ReflectionGroup::Transitional
								}
							}
							stability::Stability::Metastable { .. } => ReflectionGroup::Reactive,
							stability::Stability::Unstable { .. } => {
								if matches!(props.temporality, Temporality::Prophetic { .. }) {
									ReflectionGroup::Rare
								} else {
									ReflectionGroup::Transitional
								}
							}
							stability::Stability::Impossible => ReflectionGroup::Synthetic, // Shouldn't happen
						}
					}
					/// Known stable compounds (like molecules)
					pub(crate) mod compounds {
						use super::super::*;
						/// Echo — Specular + Delayed
						/// Memory, recording, playback
						pub fn echo(delay: Duration) -> ReflectionProperties {
							let specular = elements::SPECULAR.clone();
							let delayed = elements::delayed(delay);
							match bonding::combine(&specular, &delayed) {
								bonding::BondResult::Compound(c) => c,
								_ => unreachable!("Echo should always be valid"),
							}
						}
						/// Filter — Selective + Specular
						/// Attention, focus
						pub fn filter(properties: Vec<super::PropertyId>) -> ReflectionProperties {
							elements::selective(properties)
						}
						/// Black Mirror — Absorptive + Selective
						/// Privacy shield, partial hiding
						/// ALIAS: `[BLACK GLASS PROTOCOL]`
						pub fn black_mirror(
							hidden: Vec<super::PropertyId>,
							visible: Vec<super::PropertyId>,
						) -> ReflectionProperties {
							// Hidden properties get absorbed, visible get reflected
							ReflectionProperties {
								fidelity: super::Fidelity::Lossy(
									visible.len() as f64 / (hidden.len() + visible.len()) as f64,
								),
								temporality: super::Temporality::Instantaneous,
								spatiality: super::Spatiality::Inverted,
								selectivity: super::Selectivity::Partial(visible),
								energy_cost: super::EnergyCost::Sustained(hidden.len() as f64),
							}
						}
						/// Double Mirror — Inverted + Inverted
						/// Identity through double inversion
						pub fn double_mirror() -> ReflectionProperties {
							ReflectionProperties {
								fidelity: super::Fidelity::Specular,
								temporality: super::Temporality::Instantaneous,
								spatiality: super::Spatiality::Identity, // Double inversion = identity
								selectivity: super::Selectivity::Complete,
								energy_cost: super::EnergyCost::Finite(0.1), // Slight overhead
							}
						}
					}
				}
				// The reflection itself (what happened)
				pub trait Reflection {
					/// The cause of this reflection
					type Cause: ReflectionCause;
					/// Properties of how this reflects
					fn properties(&self) -> ReflectionProperties;
				}
				// What caused the reflection
				pub trait ReflectionCause {
					/// Human-readable name
					fn name<'name>(&self) -> &'name str;

					/// Is this cause recoverable in principle?
					fn recoverable(&self) -> bool;
				}
				// Something that can be reflected upon
				pub trait Reflective {
					/// Produce a reflection of self given a cause
					fn reflect<CAUSE: ReflectionCause>(&self, cause: CAUSE) -> impl Reflection;
				}
				// The combination of N reflections
				/// usage examples provided by Sinon
				/// // Usage:
				// impl ReflectionComposite<ErrorCause> for ErrorComposite {
				//     // ...
				// }
				// impl ReflectionComposite<CacheCause> for CacheComposite {
				//     // ...
				// }
				pub trait ReflectionComposite {
					/// The cause type this composite deals with
					type Cause: ReflectionCause;

					/// Combine reflections into a single ReflectionProperties
					fn combine(reflections: &[&dyn Reflection<Cause=Self::Cause>]) -> BondResult;

					/// Assess stability of current combined state
					fn assess_stability(&self) -> Stability;
				}

				// The final Glass state
				// pub trait GlassState<'state>: Sized + Send + Sync + 'state {
				// 	/// The mirror type this maps to
				// 	type Mirror: MirrorType<'state>;
				// 	type Cause: Severity;
				//
				// 	/// Construct from reflection result
				// 	fn from_reflection(props: ReflectionProperties) -> Self;
				//
				// 	/// Default mapping from properties to Glass
				// 	fn default_mapping(props: &ReflectionProperties) -> Self {
				// 		// Default implementation
				// 		match stability::assess(props) {
				// 			Stability::Stable => Self::stable(),
				// 			Stability::Metastable { .. } => Self::metastable(props),
				// 			Stability::Unstable { .. } => Self::unstable(props),
				// 			Stability::Impossible => Self::impossible(),
				// 		}
				// 	}
				//
				// 	fn stable() -> Self;
				// 	fn metastable(props: &ReflectionProperties) -> Self;
				// 	fn unstable(props: &ReflectionProperties) -> Self;
				// 	fn impossible() -> Self;
				// }

				// MirrorType from your existing code
				pub trait MirrorType<'mirrortype>: Send + Sync + 'mirrortype {
					fn properties(&self) -> ReflectionProperties;
				}
				/// THE CORE FUNCTION: N reflections → Glass state
				/// This is a really cool function.
				pub fn reflections_to_glass<GLASS: for<'state> GlassState<'state>>(
					reflections: &[&dyn Reflection<Cause=impl ReflectionCause>], // this is probably not the best way to do this but it compiles so fuck it.
				) -> GLASS {
					use bonding::BondResult;
					// Step 1: Combine all reflections
					let combined = reflections
						.iter()
						.map(|r| r.properties()).fold(
						elements::SPECULAR,
						|acc, props| match bonding::combine(&acc, &props) {
							BondResult::Compound(c) => c,
							BondResult::Dominated(d) => d,
							BondResult::Contradiction => elements::ABSORPTIVE,
							BondResult::Unstable(u, _) => u,
						},
					);

					// Step 2: Assess stability
					let stability = stability::assess(&combined);

					// Step 3: Map to Glass state via default or custom
					GLASS::from_reflection(combined)
				}

				// FOR ERRORS SPECIFICALLY:
				impl GlassState for SeverityType {
					type Mirror = /*  todo:: appropriate mirror stubbed for now */ ();
					type Cause = ();
					/// this is incomplete as fuck, i know. But it compiles for now which is enough
					fn from_reflection(props: &ReflectionProperties) -> fn(dyn GlassState<Cause=_, Mirror=_>) {
						match &props.fidelity {
							Fidelity::Specular => SeverityType::stable(),
							Fidelity::Lossy(x) if *x > 0.8 => SeverityType::help(),
							Fidelity::Lossy(x) if *x > 0.5 => SeverityType::suggestion(),
							Fidelity::Lossy(_) => SeverityType::fracture(&props),
							Fidelity::Destructive => SeverityType::warp(&props),
							Fidelity::Absorptive => SeverityType::shatter(),
						}
					}
					fn dominance(&self) -> u8 {
						/// default is 0, set by reflection properties or caller (todo: double check this)
						0
					}
					fn stable<'stable>() -> fn(GlassStable) -> SeverityType {
						SeverityType::GlassStable
					}
					fn fracture(props: &ReflectionProperties) -> fn(GlassFracture) -> SeverityType {
						// Map based on properties
						SeverityType::GlassFracture
					}
					fn warp(props: &ReflectionProperties) -> fn(GlassWarp) -> SeverityType {
						SeverityType::GlassWarp
					}
					fn shatter<'shatter>() -> fn(GlassShattered) -> SeverityType {
						SeverityType::GlassShattered
					}
					fn note<'note>() -> fn(GlassNote) -> SeverityType {
						SeverityType::GlassNote
					}
					fn suggestion<'suggestion>() -> fn(GlassSuggestion) -> SeverityType {
						SeverityType::GlassSuggestion
					}
					fn help<'help>() -> fn(GlassHelp) -> SeverityType {
						SeverityType::GlassHelp
					}
				}


				/// Properties that define a reflection type
				#[derive(Clone, Debug, PartialEq)]
				pub struct ReflectionProperties {
					pub fidelity: Fidelity,
					pub temporality: Temporality,
					pub spatiality: Spatiality,
					pub selectivity: Selectivity,
					pub energy_cost: EnergyCost,
				}
				/// How much of the input survives reflection
				#[derive(Clone, Debug, PartialEq)]
				pub enum Fidelity {
					/// 100% preservation
					Specular,
					/// Measurable loss, still recognizable
					Lossy(f64), // 0.0 to 1.0
					/// Unrecoverable degradation
					Destructive,
					/// Nothing returns
					Absorptive,
				}
				/// Temporal relationship between input and output
				#[derive(Clone, Debug, PartialEq)]
				pub enum Temporality {
					/// Output simultaneous with input (within measurement error)
					Instantaneous,
					/// Output follows input by fixed duration
					/// todo: This should be updated to use DaemonicClock trait logic
					Delayed(Duration),
					/// Output timing varies
					Variable { min: Duration, max: Duration }, // todo fix this to DaemonicClock traits
					/// Output precedes input (requires prior pattern knowledge)
					/// ⚠️ **WARNING:::UNSTABLE** — crystallization risk
					/// Todo: Should create a classification inside DaemonicCompiler when complete that tags DaemonicUnstable items separately from RustUnstable and flags them on use in the wild.
					/// Prophetic Temporality mirrors God logic, no pun intended.
					/// This is here solely because the system wouldnt be complete without it, but this field should be used with extreme caution.
					/// *Logic Crystallization risk Defined:*
					/// *1 << Brittleness, cant handle new or novel inputs without fracturing at the edges.*
					/// *2 << Non-routable across large temporal reference frames*
					/// *3 << Higher Base decay rate for packets in network contexts, *enforced*.*
					Prophetic { requires_prior_walks: u64 },
					/// No temporal relationship (absorptive)
					None,
				}
				/// Spatial transformation applied
				#[derive(Clone, Debug, PartialEq)]
				pub enum Spatiality {
					/// Standard mirror — inverted across boundary plane
					Inverted,
					/// No spatial change
					Identity,
					/// Systematic spatial transformation
					Transformed(SpatialTransform),
					/// All spatial information collapsed
					Collapsed,
				}
				/// Which properties reflect
				#[derive(Clone, Debug, PartialEq)]
				pub enum Selectivity {
					/// All properties reflect
					Complete,
					/// Only specified properties reflect
					Partial(Vec<PropertyId>),
					/// Only one property reflects
					Single(PropertyId),
					/// No properties reflect
					None,
				}
				/// Energy required to maintain this reflection type
				#[derive(Clone, Debug, PartialEq)]
				pub enum EnergyCost {
					/// Minimum energy — natural ground state
					Minimal,
					/// Finite measurable cost
					Finite(f64),
					/// Requires continuous energy input
					Sustained(f64),
					/// Theoretically infinite (unstable)
					Unbounded,
				}
				/// Placeholder for spatial transforms
				#[derive(Clone, Debug, PartialEq)]
				pub struct SpatialTransform {
					// TODO: Define transformation matrices or functions
				}
				/// Identifier for observable properties
				pub type PropertyId = u32;
			}
			pub(crate) mod error_types {
				pub(crate) mod error_messages {
					use os::OsError;
					use daemonic::entity::shade::ShadeError;
					use generic::GenericError;
					use daemonic::Daemonic;
					use super::*;
					/// This struct is currently blank but should be filled in.
					/// # The Theory
					/// Clock cycles tick forward automatically (proc_macro autotick)
					/// Clock Tick = work done, any function, any transformation, any operation = Clock Tick
					/// Therefore clock output per unit = Deterministic
					/// if no work, then Recursion cuts the chain at pass 7 citing no work.
					/// If there is work, and its non-deterministic or never resolves: requires different handling.
					///
					/// Non-deterministic output from deterministic input is technically impossible barring
					/// hardware level failure modes, if multiple independent passes return non-deterministic results
					///  then operation performed is inherently unstable or the logic is just shit.
					/// These are inherently different modes of EntropyTermination, one assumes work and didnt find any -> graceful cut
					/// The other assumes work input is deterministic but isnt -> non-graceful cut, requires active intervention
					/// and may return a Warped state instead of a Shattered state type if the operation corrupted persistent memory
					pub struct EntropyTermination {}


					pub(crate) mod os {
						//already moved
					}

					pub(crate) mod daemonic {
						//already moved
					}

					pub(crate) mod generic {
						//already moved
					}
				}
				use crate::{
					EnumerationRouter,
					daemonic::{
						daemonic_contract::{
							daemonic_result::{
								error_types::{
									error_messages::{
										generic::GenericError,
										os::OsError,
										daemonic::Daemonic,
									}
								}
							}
						}
					},
				};
				pub enum Error {
					/// Use generic variant for simple or quick errors
					Generic(GenericError),
					#[cfg_attr(feature = "Libc", )]
					/// Use this variant for LIBC compatible errors with ERRNO table and conversion methods
					OS(OsError),
					/// Daemonic Error variants with richer context than Generic or OS level returns
					/// Shade, Entity, and Symbolic errors are here.
					Daemonic(Daemonic),
				}
				impl EnumerationRouter for Error {}
			}
			pub(crate) mod diagnostic {
				use std::backtrace::Backtrace;
				use crate::{DiagCtxtHandle, Subdiagnostic};
				use crate::Color;
				use crate::ColorSpec;
				use std::borrow::Cow;
				use std::cell::Cell;
				use std::fmt;
				use std::fmt::Debug;
				use std::marker::PhantomData;
				use std::ops::{Deref, DerefMut};
				use std::path::{Path, PathBuf};
				use std::thread::panicking;

				mod traits {
					use std::backtrace::Backtrace;
					use crate::{DiagCtxtHandle, Subdiagnostic};
					use crate::Color;
					use crate::ColorSpec;
					use std::borrow::Cow;
					use std::cell::Cell;
					use std::fmt;
					use std::fmt::Debug;
					use std::marker::PhantomData;
					use std::ops::{Deref, DerefMut};
					use std::path::{Path, PathBuf};
					use std::thread::panicking;
					use super::structures::*;
					/// Trait implemented by error types. This is rarely implemented manually. Instead, use
					/// `#[derive(Diagnostic)]` -- see [daemonic_macros::Diagnostic].
					///
					/// When implemented manually, it should be generic over the emission
					/// guarantee, i.e.:
					/// ```ignore (fragment)
					/// impl<'a, GUARANTEE: EmissionGuarantee> Diagnostic<'a, GUARANTEE> for Foo { ... }
					/// ```
					/// rather than being specific:
					/// ```ignore (fragment)
					/// impl<'a> Diagnostic<'a> for Bar { ... }  // the default type param is `ErrorGuaranteed`
					/// impl<'a> Diagnostic<'a, ()> for Baz { ... }
					/// ```
					/// There are two reasons for this.
					/// - A diagnostic like `Foo` *could* be emitted at any level -- `DiagnosticLevel` is
					///   passed in to `into_diag` from outside. Even if in practice it is
					///   always emitted at a single level, we let the diagnostic creation/emission
					///   site determine the level (by using `create_err`, `emit_warn`, etc.)
					///   rather than the `Diagnostic` impl.
					/// - Derived impls are always generic, and it's good for the hand-written
					///   impls to be consistent with them.
					#[rustc_diagnostic_item = "Diagnostic"]
					pub trait Diagnostic<'diagnostic, GUARANTEE: EmissionGuarantee = ErrorGuaranteed> {
						/// Write out as a diagnostic out of `DiagCtxt`.
						#[must_use]
						fn into_diag(
							self,
							dcx: DiagCtxtHandle<'diagnostic>,
							level: DiagnosticLevel,
						) -> Diag<'diagnostic, GUARANTEE>;
					}
					/// Trait implemented by lint types. This should not be implemented manually. Instead, use
					/// `#[derive(LintDiagnostic)]` -- see [daemonic_macros::LintDiagnostic].
					#[rustc_diagnostic_item = "LintDiagnostic"]
					pub trait LintDiagnostic<'diagnostic, GUARANTEE: EmissionGuarantee> {
						/// Decorate and emit a lint.
						fn decorate_lint<'decorate_lint>(self, diag: &'decorate_lint mut Diag<'diagnostic, GUARANTEE>);
					}
					//
					pub trait EmissionGuarantee: Sized {
						type EmitResult = Self;

						/// NEW: Can we continue after this emission?
						const CONTINUEABLE: bool = true;

						/// NEW: Recovery handler type (defaults to no-op)
						type RecoveryHandler: RecoveryHandler<Self> = NoRecovery;

						fn emit_producing_guarantee(diag: Diag<'_, Self>) -> Self::EmitResult;

						/// NEW: Emit with continuation support
						fn emit_continuable(diag: Diag<'_, Self>) -> crate::daemonic::daemonic_contract::daemonic_result::diagnostic::EmitOutcome<Self::EmitResult> {
							let result = Self::emit_producing_guarantee(diag);

							if Self::CONTINUEABLE {
								crate::daemonic::daemonic_contract::daemonic_result::diagnostic::EmitOutcome::Continue(result)
							} else if let Some(recovered) = Self::RecoveryHandler::attempt_recovery(&result) {
								crate::daemonic::daemonic_contract::daemonic_result::diagnostic::EmitOutcome::Recovered(recovered)
							} else {
								crate::daemonic::daemonic_contract::daemonic_result::diagnostic::EmitOutcome::MustStop(result)
							}
						}
					}
					/// Simplified version of `FluentArg` that can implement `Encodable` and `Decodable`. Collection of
					/// `DiagArg` are converted to `FluentArgs` (consuming the collection) at the start of diagnostic
					/// emission.
					// pub type DiagArg<'iter> = (&'iter DiagArgName, &'iter DiagArgValue);
					pub type DiagArgMap = FxIndexMap<DiagArgName, DiagArgValue>; // todo: FxIndexMap needs converted to generic trait bound then autobound opaquely with optional override
					/// Name of a diagnostic argument.
					pub type DiagArgName = Cow<'static, str>;
					/// Converts a value of a type into a `DiagArg` (typically a field of an `Diag` struct).
					/// Implemented as a custom trait rather than `From` so that it is implemented on the type being
					/// converted rather than on `DiagArgValue`, which enables types from other `rustc_*` crates to
					/// implement this.
					pub trait IntoDiagArg {
						/// Convert `Self` into a `DiagArgValue` suitable for rendering in a diagnostic.
						///
						/// It takes a `path` where "long values" could be written to, if the `DiagArgValue` is too big
						/// for displaying on the terminal. This path comes from the `Diag` itself. When rendering
						/// values that come from `TyCtxt`, like `Ty<'_>`, they can use `TyCtxt::short_string`. If a
						/// value has no shortening logic that could be used, the argument can be safely ignored.
						fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue;
					}
				}
				mod structures {
					use std::backtrace::Backtrace;
					use crate::{DiagCtxtHandle, Subdiagnostic};
					use crate::Color;
					use crate::ColorSpec;
					use std::borrow::Cow;
					use std::cell::Cell;
					use std::fmt;
					use std::fmt::Debug;
					use std::marker::PhantomData;
					use std::ops::{Deref, DerefMut};
					use std::path::{Path, PathBuf};
					use std::thread::panicking;
					use crate::daemonic::daemonic_contract::daemonic_result::diagnostic::EmissionGuarantee;
					/// Useful type to use with `Result<>` indicate that an error has already
					/// been reported to the user, so no need to continue checking.
					///
					/// The `()` field is necessary: it is non-`pub`, which means values of this
					/// type cannot be constructed outside of this crate.
					///
					/// #[derive(HashStable_Generic)]
					#[derive(
						Clone,
						Copy,
						Debug,
						Hash,
						PartialEq,
						Eq,
						PartialOrd,
						Ord
					)] // This technically uses unstable traits in std lib, but presents as stable on the surface.
					pub struct ErrorGuaranteed(());
					/// This is a marker for a fatal compiler error used with `resume_unwind`.
					pub struct FatalErrorMarker;
					/// Used as a return value to signify a fatal error occurred.
					#[derive(Copy, Clone, Debug)]
					#[must_use]
					pub struct FatalError;
					pub struct FatalRecovery;
					/// Simplified version of `FluentValue` that can implement `Encodable` and `Decodable`. Converted
					/// to a `FluentValue` by the emitter to be used in diagnostic translation.
					#[derive(Clone, Debug, PartialEq, Eq, Hash)]
					pub enum DiagArgValue {
						Str(Cow<'static, str>),
						// This gets converted to a `FluentNumber`, which is an `f64`. An `i32`
						// safely fits in an `f64`. Any integers bigger than that will be converted
						// to strings in `into_diag_arg` and stored using the `Str` variant.
						// Fluent is deprecated, fluent was bullshit anyways so im not sure how applicable this is to current state
						Number(i32),
						StrListSepByAnd(Vec<Cow<'static, str>>),
					}
					/// Used for emitting structured error messages and other diagnostic information.
					/// Wraps a `DiagInner`, adding some useful things.
					/// - The `dcx` field, allowing it to (a) emit itself, and (b) do a drop check
					///   that it has been emitted or cancelled.
					/// - The `EmissionGuarantee`, which determines the type returned from `emit`.
					///
					/// Each constructed `Diag` must be consumed by a function such as `emit`,
					/// `cancel`, `delay_as_bug`, or `into_diag`. A panic occurs if a `Diag`
					/// is dropped without being consumed by one of these functions.
					///
					/// If there is some state in a downstream crate you would like to access in
					/// the methods of `Diag` here, consider extending `DiagCtxtFlags`.
					#[must_use]
					pub struct Diag<'a, G: EmissionGuarantee = ErrorGuaranteed> {
						pub dcx: DiagnosticContextHandle<'a>,

						/// Why the `Option`? It is always `Some` until the `Diag` is consumed via
						/// `emit`, `cancel`, etc. At that point it is consumed and replaced with
						/// `None`. Then `drop` checks that it is `None`; if not, it panics because
						/// a diagnostic was built but not used.
						///
						/// Why the Box? `DiagInner` is a large type, and `Diag` is often used as a
						/// return value, especially within the frequently-used `PResult` type. In
						/// theory, return value optimization (RVO) should avoid unnecessary
						/// copying. In practice, it does not (at the time of writing).
						/// At time of writing' statements need to be dated, fuck this guy.
						pub(crate) diag: Option<Box<DiagInner>>,

						pub(crate) _marker: PhantomData<G>,
					}
					/// The main part of a diagnostic. Note that `Diag`, which wraps this type, is
					/// used for most operations, and should be used instead whenever possible.
					/// This type should only be used when `Diag`'s lifetime causes difficulties,
					/// e.g. when storing diagnostics within `DiagCtxt`.
					#[must_use]
					#[derive(Clone, Debug)]
					pub struct DiagInner {
						// NOTE(eddyb) this is private to disallow arbitrary after-the-fact changes,
						// outside of what methods in this crate themselves allow.
						pub level: crate::DaemonicCompiler::rustc::rustc_error::DiagnosticLevel,

						pub messages: Vec<(DiagMessage, Style)>,
						pub code: Option<ErrCode>,
						pub lint_id: Option<LintExpectationId>,
						pub span: MultiSpan,
						pub children: Vec<Subdiag>,
						pub suggestions: Suggestions,
						pub args: DiagArgMap,

						/// This is not used for highlighting or rendering any error message. Rather, it can be used
						/// as a sort key to sort a buffer of diagnostics. By default, it is the primary span of
						/// `span` if there is one. Otherwise, it is `DUMMY_SP`.
						pub sort_span: Span,

						pub is_lint: Option<IsLint>,

						pub long_ty_path: Option<PathBuf>,
						/// With `-Ztrack_diagnostics` enabled,
						/// we print where in rustc this error was emitted.
						pub emitted_at: DiagLocation,
					}
					/// A "sub"-diagnostic attached to a parent diagnostic.
					/// For example, a note attached to an error.
					#[derive(Clone, Debug, PartialEq, Hash)]
					pub struct Subdiag {
						pub level: crate::daemonic::daemonic_contract::daemonic_result::diagnostic::DiagnosticLevel,
						pub messages: Vec<(DiagMessage, Style)>,
						pub span: MultiSpan,
					}
					/// | Level        | is_error | EmissionGuarantee            | Top-level | Sub | Used in lints?
					/// | -----        | -------- | -----------------            | --------- | --- | --------------
					/// | Bug          | yes      | BugAbort                     | yes       | -   | -
					/// | Fatal        | yes      | FatalAbort/FatalError[^star] | yes       | -   | -
					/// | Error        | yes      | ErrorGuaranteed              | yes       | -   | yes
					/// | DelayedBug   | yes      | ErrorGuaranteed              | yes       | -   | -
					/// | ForceWarning | -        | ()                           | yes       | -   | lint-only
					/// | Warning      | -        | ()                           | yes       | yes | yes
					/// | Note         | -        | ()                           | rare      | yes | -
					/// | OnceNote     | -        | ()                           | -         | yes | lint-only
					/// | Help         | -        | ()                           | rare      | yes | -
					/// | OnceHelp     | -        | ()                           | -         | yes | lint-only
					/// | FailureNote  | -        | ()                           | rare      | -   | -
					/// | Allow        | -        | ()                           | yes       | -   | lint-only
					/// | Expect       | -        | ()                           | yes       | -   | lint-only
					///
					/// [^star]: `FatalAbort` normally, `FatalError` in the non-aborting "almost fatal" case that is
					///     occasionally used.
					///    Note for Daemonic Consumers, *DiagnosticLevel is NOT GlassState*
					///
					/// This is technically a nested trait object from the reference frame of DaemonicError.
					/// Most users/devs should never need to directly call this part of the logic solely because its compiler
					/// specific in 99% of use cases.
					///
					/// This is from and originally designed for RustC error and its internal representations for
					/// error states, GlassStates encapsulate full state in most cases (or at least should) these do not.
					/// Even with a fully constructed Diagnostic message with args and Span arent as rich as
					/// A pure Daemonic Error or GlassState derivation of the same state within shared context.
					#[derive(Copy, PartialEq, Eq, Clone, Hash, Debug)]
					pub enum DiagnosticLevel {
						/// For bugs in the compiler. Manifests as an ICE (internal compiler error) panic.
						Bug,

						/// An error that causes an immediate abort. Used for things like configuration errors,
						/// internal overflows, some file operation errors.
						Fatal,

						/// An error in the code being compiled, which prevents compilation from finishing. This is the
						/// most common case.
						Error,

						/// This is a strange one: lets you register an error without emitting it. If compilation ends
						/// without any other errors occurring, this will be emitted as a bug. Otherwise, it will be
						/// silently dropped. I.e. "expect other errors are emitted" semantics. Useful on code paths
						/// that should only be reached when compiling erroneous code.
						DelayedBug,

						/// A `force-warn` lint warning about the code being compiled. Does not prevent compilation
						/// from finishing.
						///
						/// Requires a [`LintExpectationId`] for expected lint diagnostics. In all other cases this
						/// should be `None`.
						ForceWarning,

						/// A warning about the code being compiled. Does not prevent compilation from finishing.
						/// Will be skipped if `can_emit_warnings` is false.
						Warning,

						/// A message giving additional context.
						Note,

						/// A note that is only emitted once.
						OnceNote,

						/// A message suggesting how to fix something.
						Help,

						/// A help that is only emitted once.
						OnceHelp,

						/// Similar to `Note`, but used in cases where compilation has failed. When printed for human
						/// consumption, it doesn't have any kind of `note:` label.
						FailureNote,

						/// Only used for lints.
						Allow,

						/// Only used for lints. Requires a [`LintExpectationId`] for silencing the lints.
						Expect,
					}
					#[derive(Copy, Clone)]
					pub struct DiagnosticContextHandle<'a> {
						pub dcx: &'a DiagCtxt,
						/// Some contexts create `DiagCtxtHandle` with this field set, and thus all
						/// errors emitted with it will automatically taint when emitting errors.
						pub tainted_with_errors: Option<&'a Cell<Option<ErrorGuaranteed>>>,
					}
					/// A `DiagCtxt` deals with errors and other compiler output.
					/// Certain errors (fatal, bug, unimpl) may cause immediate exit,
					/// others log errors for later reporting.
					pub struct DiagCtxt {
						pub(crate) inner: Lock<DiagCtxtInner>,
					}
					// Replacement sketch provided by Ada. Love that girl <3
					pub enum EmitOutcome<R> { // todo:: this needs DaemonicRecursionManagement logic attached
						/// Error collected, continue walking
						Continue(R),
						/// Fatal intercepted, recovered to state
						Recovered(RecoveredState),
						/// Truly unrecoverable, must stop
						MustStop(R),
					}
					pub struct RecoveredState {} // todo: this is stubbed
				}
				mod implementations {
					use std::backtrace::Backtrace;
					use crate::{DiagCtxtHandle, DiagnosticContextHandle, Subdiagnostic};
					use crate::Color;
					use crate::ColorSpec;
					use std::borrow::Cow;
					use std::cell::Cell;
					use std::fmt;
					use std::fmt::Debug;
					use std::hash::{Hash, Hasher};
					use std::marker::PhantomData;
					use std::ops::{Deref, DerefMut};
					use std::path::{Path, PathBuf};
					use std::thread::panicking;
					use crate::daemonic::daemonic_contract::daemonic_result::diagnostic;
					use super::structures::*;
					use super::traits::*;

					// All implementations will be moved here
					// This is a placeholder file that will contain all the impl blocks from mod.rs
					// This `impl` block contains only the public diagnostic creation/emission API.
					//
					// Functions beginning with `struct_`/`create_` create a diagnostic. Other
					// functions create and emit a diagnostic all in one go.
					impl<'a> DiagnosticContextHandle<'a> {
						// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
						// user-facing.
						#[track_caller]
						pub fn struct_bug(self, msg: impl Into<Cow<'static, str>>) -> crate::Diag<'a, BugAbort> {
							crate::Diag::new(self, crate::DiagnosticLevel::Bug, msg.into())
						}

						// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
						// user-facing.
						#[track_caller]
						pub fn bug(self, msg: impl Into<Cow<'static, str>>) -> ! {
							self.struct_bug(msg).emit()
						}

						// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
						// user-facing.
						#[track_caller]
						pub fn struct_span_bug(
							self,
							span: impl Into<MultiSpan>,
							msg: impl Into<Cow<'static, str>>,
						) -> crate::Diag<'a, BugAbort> {
							self.struct_bug(msg).with_span(span)
						}

						// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
						// user-facing.
						#[track_caller]
						pub fn span_bug(self, span: impl Into<MultiSpan>, msg: impl Into<Cow<'static, str>>) -> ! {
							self.struct_span_bug(span, msg.into()).emit()
						}

						#[track_caller]
						pub fn create_bug(self, bug: impl crate::Diagnostic<'a, BugAbort>) -> crate::Diag<'a, BugAbort> {
							bug.into_diag(self, crate::DiagnosticLevel::Bug)
						}

						#[track_caller]
						pub fn emit_bug(self, bug: impl crate::Diagnostic<'a, BugAbort>) -> ! {
							self.create_bug(bug).emit()
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn struct_fatal(self, msg: impl Into<DiagMessage>) -> crate::Diag<'a, FatalAbort> {
							crate::Diag::new(self, crate::DiagnosticLevel::Fatal, msg)
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn fatal(self, msg: impl Into<DiagMessage>) -> ! {
							self.struct_fatal(msg).emit()
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn struct_span_fatal(
							self,
							span: impl Into<MultiSpan>,
							msg: impl Into<DiagMessage>,
						) -> crate::Diag<'a, FatalAbort> {
							self.struct_fatal(msg).with_span(span)
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn span_fatal(self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) -> ! {
							self.struct_span_fatal(span, msg).emit()
						}

						#[track_caller]
						pub fn create_fatal(self, fatal: impl crate::Diagnostic<'a, FatalAbort>) -> crate::Diag<'a, FatalAbort> {
							fatal.into_diag(self, crate::DiagnosticLevel::Fatal)
						}

						#[track_caller]
						pub fn emit_fatal(self, fatal: impl crate::Diagnostic<'a, FatalAbort>) -> ! {
							self.create_fatal(fatal).emit()
						}

						#[track_caller]
						pub fn create_almost_fatal(
							self,
							fatal: impl crate::Diagnostic<'a, crate::FatalError>,
						) -> crate::Diag<'a, crate::FatalError> {
							fatal.into_diag(self, crate::DiagnosticLevel::Fatal)
						}

						#[track_caller]
						pub fn emit_almost_fatal(self, fatal: impl crate::Diagnostic<'a, crate::FatalError>) -> crate::FatalError {
							self.create_almost_fatal(fatal).emit()
						}

						// FIXME: This method should be removed (every error should have an associated error code).
						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn struct_err(self, msg: impl Into<DiagMessage>) -> crate::Diag<'a> {
							crate::Diag::new(self, crate::DiagnosticLevel::Error, msg)
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn err(self, msg: impl Into<DiagMessage>) -> crate::ErrorGuaranteed {
							self.struct_err(msg).emit()
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn struct_span_err(
							self,
							span: impl Into<MultiSpan>,
							msg: impl Into<DiagMessage>,
						) -> crate::Diag<'a> {
							self.struct_err(msg).with_span(span)
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn span_err(
							self,
							span: impl Into<MultiSpan>,
							msg: impl Into<DiagMessage>,
						) -> crate::ErrorGuaranteed {
							self.struct_span_err(span, msg).emit()
						}

						#[track_caller]
						pub fn create_err(self, err: impl crate::Diagnostic<'a>) -> crate::Diag<'a> {
							err.into_diag(self, crate::DiagnosticLevel::Error)
						}

						#[track_caller]
						pub fn emit_err(self, err: impl crate::Diagnostic<'a>) -> crate::ErrorGuaranteed {
							self.create_err(err).emit()
						}

						/// Ensures that an error is printed. See `Level::DelayedBug`.
						//
						// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
						// user-facing.
						#[track_caller]
						pub fn delayed_bug(self, msg: impl Into<Cow<'static, str>>) -> crate::ErrorGuaranteed {
							crate::Diag::<crate::ErrorGuaranteed>::new(self, crate::DiagnosticLevel::DelayedBug, msg.into()).emit()
						}

						/// Ensures that an error is printed. See [`Level::DelayedBug`].
						///
						/// Note: this function used to be called `delay_span_bug`. It was renamed
						/// to match similar functions like `span_err`, `span_warn`, etc.
						//
						// No `#[rustc_lint_diagnostics]` and no `impl Into<DiagMessage>` because bug messages aren't
						// user-facing.
						#[track_caller]
						pub fn span_delayed_bug(
							self,
							sp: impl Into<MultiSpan>,
							msg: impl Into<Cow<'static, str>>,
						) -> crate::ErrorGuaranteed {
							crate::Diag::<crate::ErrorGuaranteed>::new(self, crate::DiagnosticLevel::DelayedBug, msg.into()).with_span(sp).emit()
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn struct_warn(self, msg: impl Into<DiagMessage>) -> crate::Diag<'a, ()> {
							crate::Diag::new(self, crate::DiagnosticLevel::Warning, msg)
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn warn(self, msg: impl Into<DiagMessage>) {
							self.struct_warn(msg).emit()
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn struct_span_warn(
							self,
							span: impl Into<MultiSpan>,
							msg: impl Into<DiagMessage>,
						) -> crate::Diag<'a, ()> {
							self.struct_warn(msg).with_span(span)
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn span_warn(self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
							self.struct_span_warn(span, msg).emit()
						}

						#[track_caller]
						pub fn create_warn(self, warning: impl crate::Diagnostic<'a, ()>) -> crate::Diag<'a, ()> {
							warning.into_diag(self, crate::DiagnosticLevel::Warning)
						}

						#[track_caller]
						pub fn emit_warn(self, warning: impl crate::Diagnostic<'a, ()>) {
							self.create_warn(warning).emit()
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn struct_note(self, msg: impl Into<DiagMessage>) -> crate::Diag<'a, ()> {
							crate::Diag::new(self, crate::DiagnosticLevel::Note, msg)
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn note(&self, msg: impl Into<DiagMessage>) {
							self.struct_note(msg).emit()
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn struct_span_note(
							self,
							span: impl Into<MultiSpan>,
							msg: impl Into<DiagMessage>,
						) -> crate::Diag<'a, ()> {
							self.struct_note(msg).with_span(span)
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn span_note(self, span: impl Into<MultiSpan>, msg: impl Into<DiagMessage>) {
							self.struct_span_note(span, msg).emit()
						}

						#[track_caller]
						pub fn create_note(self, note: impl crate::Diagnostic<'a, ()>) -> crate::Diag<'a, ()> {
							note.into_diag(self, crate::DiagnosticLevel::Note)
						}

						#[track_caller]
						pub fn emit_note(self, note: impl crate::Diagnostic<'a, ()>) {
							self.create_note(note).emit()
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn struct_help(self, msg: impl Into<DiagMessage>) -> crate::Diag<'a, ()> {
							crate::Diag::new(self, crate::DiagnosticLevel::Help, msg)
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn struct_failure_note(self, msg: impl Into<DiagMessage>) -> crate::Diag<'a, ()> {
							crate::Diag::new(self, crate::DiagnosticLevel::FailureNote, msg)
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn struct_allow(self, msg: impl Into<DiagMessage>) -> crate::Diag<'a, ()> {
							crate::Diag::new(self, crate::DiagnosticLevel::Allow, msg)
						}

						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn struct_expect(self, msg: impl Into<DiagMessage>, id: LintExpectationId) -> crate::Diag<'a, ()> {
							crate::Diag::new(self, crate::DiagnosticLevel::Expect, msg).with_lint_id(id)
						}
					}
					impl<'a> DiagnosticContextHandle<'a> {
						/// Stashes a diagnostic for possible later improvement in a different,
						/// later stage of the compiler. Possible actions depend on the diagnostic
						/// level:
						/// - Level::Bug, Level:Fatal: not allowed, will trigger a panic.
						/// - Level::Error: immediately counted as an error that has occurred, because it
						///   is guaranteed to be emitted eventually. Can be later accessed with the
						///   provided `span` and `key` through
						///   [`DiagnosticContextHandle::try_steal_modify_and_emit_err`] or
						///   [`DiagnosticContextHandle::try_steal_replace_and_emit_err`]. These do not allow
						///   cancellation or downgrading of the error. Returns
						///   `Some(ErrorGuaranteed)`.
						/// - Level::DelayedBug: this does happen occasionally with errors that are
						///   downgraded to delayed bugs. It is not stashed, but immediately
						///   emitted as a delayed bug. This is because stashing it would cause it
						///   to be counted by `err_count` which we don't want. It doesn't matter
						///   that we cannot steal and improve it later, because it's not a
						///   user-facing error. Returns `Some(ErrorGuaranteed)` as is normal for
						///   delayed bugs.
						/// - Level::Warning and lower (i.e. !is_error()): can be accessed with the
						///   provided `span` and `key` through [`DiagnosticContextHandle::steal_non_err()`]. This
						///   allows cancelling and downgrading of the diagnostic. Returns `None`.
						pub fn stash_diagnostic(
							&self,
							span: Span,
							key: StashKey,
							diag: DiagInner,
						) -> Option<ErrorGuaranteed> {
							let guar = match diag.level {
								DiagnosticLevel::Bug | DiagnosticLevel::Fatal => {
									self.span_bug(
										span,
										format!("invalid level in `stash_diagnostic`: {:?}", diag.level),
									);
								}
								// We delay a bug here so that `-Ztreat-err-as-bug -Zeagerly-emit-delayed-bugs`
								// can be used to create a backtrace at the stashing site instead of whenever the
								// diagnostic context is dropped and thus delayed bugs are emitted.
								DiagnosticLevel::Error => Some(self.span_delayed_bug(span, format!("stashing {key:?}"))),
								DiagnosticLevel::DelayedBug => {
									return self.inner.borrow_mut().emit_diagnostic(diag, self.tainted_with_errors);
								}
								DiagnosticLevel::ForceWarning
								| DiagnosticLevel::Warning
								| DiagnosticLevel::Note
								| DiagnosticLevel::OnceNote
								| DiagnosticLevel::Help
								| DiagnosticLevel::OnceHelp
								| DiagnosticLevel::FailureNote
								| DiagnosticLevel::Allow
								| DiagnosticLevel::Expect => None,
							};

							// FIXME(Centril, #69537): Consider reintroducing panic on overwriting a stashed diagnostic
							// if/when we have a more robust macro-friendly replacement for `(span, key)` as a key.
							// See the PR for a discussion.
							self.inner
								.borrow_mut()
								.stashed_diagnostics
								.entry(key)
								.or_default()
								.insert(span.with_parent(None), (diag, guar));

							guar
						}

						/// Steal a previously stashed non-error diagnostic with the given `Span`
						/// and [`StashKey`] as the key. Panics if the found diagnostic is an
						/// error.
						pub fn steal_non_err(self, span: Span, key: StashKey) -> Option<Diag<'a, ()>> {
							// FIXME(#120456) - is `swap_remove` correct?
							let (diag, guar) = self.inner.borrow_mut().stashed_diagnostics.get_mut(&key).and_then(
								|stashed_diagnostics| stashed_diagnostics.swap_remove(&span.with_parent(None)),
							)?;
							assert!(!diag.is_error());
							assert!(guar.is_none());
							Some(Diag::new_diagnostic(self, diag))
						}

						/// Steals a previously stashed error with the given `Span` and
						/// [`StashKey`] as the key, modifies it, and emits it. Returns `None` if
						/// no matching diagnostic is found. Panics if the found diagnostic's level
						/// isn't `Level::Error`.
						pub fn try_steal_modify_and_emit_err<F>(
							self,
							span: Span,
							key: StashKey,
							mut modify_err: F,
						) -> Option<ErrorGuaranteed>
						where
							F: FnMut(&mut Diag<'_>),
						{
							// FIXME(#120456) - is `swap_remove` correct?
							let err = self.inner.borrow_mut().stashed_diagnostics.get_mut(&key).and_then(
								|stashed_diagnostics| stashed_diagnostics.swap_remove(&span.with_parent(None)),
							);
							err.map(|(err, guar)| {
								// The use of `::<ErrorGuaranteed>` is safe because level is `Level::Error`.
								assert_eq!(err.level, DiagnosticLevel::Error);
								assert!(guar.is_some());
								let mut err = Diag::<ErrorGuaranteed>::new_diagnostic(self, err);
								modify_err(&mut err);
								assert_eq!(err.level, DiagnosticLevel::Error);
								err.emit()
							})
						}

						/// Steals a previously stashed error with the given `Span` and
						/// [`StashKey`] as the key, cancels it if found, and emits `new_err`.
						/// Panics if the found diagnostic's level isn't `Level::Error`.
						pub fn try_steal_replace_and_emit_err(
							self,
							span: Span,
							key: StashKey,
							new_err: Diag<'_>,
						) -> ErrorGuaranteed {
							// FIXME(#120456) - is `swap_remove` correct?
							let old_err = self.inner.borrow_mut().stashed_diagnostics.get_mut(&key).and_then(
								|stashed_diagnostics| stashed_diagnostics.swap_remove(&span.with_parent(None)),
							);
							match old_err {
								Some((old_err, guar)) => {
									assert_eq!(old_err.level, DiagnosticLevel::Error);
									assert!(guar.is_some());
									// Because `old_err` has already been counted, it can only be
									// safely cancelled because the `new_err` supplants it.
									Diag::<ErrorGuaranteed>::new_diagnostic(self, old_err).cancel();
								}
								None => {}
							};
							new_err.emit()
						}

						pub fn has_stashed_diagnostic(&self, span: Span, key: StashKey) -> bool {
							let inner = self.inner.borrow();
							if let Some(stashed_diagnostics) = inner.stashed_diagnostics.get(&key)
								&& !stashed_diagnostics.is_empty()
							{
								stashed_diagnostics.contains_key(&span.with_parent(None))
							} else {
								false
							}
						}

						/// Emit all stashed diagnostics.
						pub fn emit_stashed_diagnostics(&self) -> Option<ErrorGuaranteed> {
							self.inner.borrow_mut().emit_stashed_diagnostics()
						}

						/// This excludes delayed bugs.
						#[inline]
						pub fn err_count(&self) -> usize {
							let inner = self.inner.borrow();
							inner.err_guars.len()
								+ inner.lint_err_guars.len()
								+ inner
								.stashed_diagnostics
								.values()
								.map(|a| a.values().filter(|(_, guar)| guar.is_some()).count())
								.sum::<usize>()
						}

						/// This excludes lint errors and delayed bugs. Unless absolutely
						/// necessary, prefer `has_errors` to this method.
						pub fn has_errors_excluding_lint_errors(&self) -> Option<ErrorGuaranteed> {
							self.inner.borrow().has_errors_excluding_lint_errors()
						}

						/// This excludes delayed bugs.
						pub fn has_errors(&self) -> Option<ErrorGuaranteed> {
							self.inner.borrow().has_errors()
						}

						/// This excludes nothing. Unless absolutely necessary, prefer `has_errors`
						/// to this method.
						pub fn has_errors_or_delayed_bugs(&self) -> Option<ErrorGuaranteed> {
							self.inner.borrow().has_errors_or_delayed_bugs()
						}

						pub fn print_error_count(&self) {
							let mut inner = self.inner.borrow_mut();

							// Any stashed diagnostics should have been handled by
							// `emit_stashed_diagnostics` by now.
							assert!(inner.stashed_diagnostics.is_empty());

							if inner.treat_err_as_bug() {
								return;
							}

							let warnings = match inner.deduplicated_warn_count {
								0 => Cow::from(""),
								1 => Cow::from("1 warning emitted"),
								count => Cow::from(format!("{count} warnings emitted")),
							};

							let errors = match inner.deduplicated_err_count {
								0 => Cow::from(""),
								1 => Cow::from("1 error emitted"),
								count => Cow::from(format!("{count} errors emitted")),
							};

							if inner.treat_warn_as_err() && !warnings.is_empty() {
								inner.emit_diagnostic(
									DiagInner::new(DiagnosticLevel::ForceWarning, DiagMessage::Str(warnings.clone().to_owned())),
									None,
								);
							}
							if !errors.is_empty() {
								if !warnings.is_empty() {
									inner.emit_diagnostic(DiagInner::new(DiagnosticLevel::Error, format!("{errors}; {warnings}")),
														  None,
									);
								} else {
									inner.emit_diagnostic(DiagInner::new(DiagnosticLevel::Error, errors.clone().to_owned()), None);
								}
							} else if !warnings.is_empty() {
								inner.emit_diagnostic(
									DiagInner::new(DiagnosticLevel::ForceWarning, DiagMessage::Str(warnings.clone().to_owned())),
									None,
								);
							}

							match (errors.is_empty(), warnings.is_empty()) {
								(true, true) => return,
								(false, true) => {
									inner.emit_diagnostic(DiagInner::new(DiagnosticLevel::FailureNote, "aborting due to previous error"), None);
								}
								(false, false) => {
									let msg1 = "aborting due to previous error";
									let msg2 = format!("For more information about this error, try `rustc --explain E{}`.", "");
									inner.emit_diagnostic(DiagInner::new(DiagnosticLevel::FailureNote, msg1), None);
									inner.emit_diagnostic(DiagInner::new(DiagnosticLevel::FailureNote, msg2), None);
								}
								(true, false) => {
									let msg = "warnings emitted";
									inner.emit_diagnostic(DiagInner::new(DiagnosticLevel::FailureNote, msg), None);
								}
							}
						}

						/// Abort if there are errors; otherwise, return.
						pub fn abort_if_errors(&self) {
							let mut inner = self.inner.borrow_mut();
							if !inner.has_errors().is_some() {
								return;
							}

							inner.emit_stashed_diagnostics();

							FatalError.raise();
						}

						pub fn must_teach(&self, code: ErrCode) -> bool {
							self.inner.borrow().must_teach(&code)
						}

						pub fn emit_diagnostic(&self, diagnostic: DiagInner) -> Option<ErrorGuaranteed> {
							self.inner.borrow_mut().emit_diagnostic(diagnostic, self.tainted_with_errors)
						}

						pub fn emit_artifact_notification(&self, path: &Path, artifact_type: &str) {
							self.inner.borrow_mut().emit_artifact_notification(path, artifact_type)
						}

						pub fn emit_future_breakage_report(&self) {
							let mut inner = self.inner.borrow_mut();
							if inner.emitted_diagnostics.is_empty() {
								return;
							}
						}

						pub fn emit_unused_externs(
							&self,
							lint_level: rustc_lint_defs::LintLevel,
							loud: bool,
							unused_externs: &[&str],
						) {
							let mut inner = self.inner.borrow_mut();

							if loud && lint_level.is_error() {
								inner.bump_err_count();
							}

							drop(inner);

							for unused in unused_externs {
								let unused = unused.to_string();
								self.emit_diagnostic(DiagInner::new(
									DiagnosticLevel::Allow,
									format!("unused extern crate `{unused}`"),
								));
							}
						}

						pub fn steal_fulfilled_expectation_ids(&self) -> FxIndexSet<LintExpectationId> {
							assert!(
								self.inner.borrow().unstable_expect_diagnostics.is_empty(),
								"`DiagnosticContextHandle::steal_fulfilled_expectation_ids` must be called before `DiagnosticContextHandle::drop`"
							);
							std::mem::take(&mut self.inner.borrow_mut().fulfilled_expectations)
						}

						pub fn flush_delayed(&self) {
							self.inner.borrow_mut().flush_delayed()
						}

						/// Used when trimmed_def_paths is called and we must produce a diagnostic
						/// to justify its cost.
						#[track_caller]
						pub fn set_must_produce_diag(&self) {
							assert!(
								self.inner.borrow().must_produce_diag.is_none(),
								"should only need to collect a backtrace once"
							);
							self.inner.borrow_mut().must_produce_diag = Some(Backtrace::capture());
						}
					}
					// Don't implement Send on FatalError. This makes it impossible to `panic_any!(FatalError)`.
					// We don't want to invoke the panic handler and print a backtrace for fatal errors.
					impl ! Send for FatalError {}

					impl FatalError {
						pub fn raise(self) -> ! {
							std::panic::resume_unwind(Box::new(FatalErrorMarker))
						}
					}

					impl std::fmt::Display for FatalError {
						fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
							write!(f, "fatal error")
						}
					}

					impl std::error::Error for FatalError {}
					impl ErrorGuaranteed {
						/// Don't use this outside of `DiagCtxtInner::emit_diagnostic`!
						#[deprecated = "should only be used in `DiagCtxtInner::emit_diagnostic`"]
						pub fn unchecked_error_guaranteed() -> Self {
							ErrorGuaranteed(())
						}

						pub fn raise_fatal(self) -> ! {
							FatalError.raise()
						}
					}
					// // Existing impls unchanged (backward compatible):
					//
					impl diagnostic::EmissionGuarantee for ErrorGuaranteed {
						fn emit_producing_guarantee(diag: Diag<'_, Self>) -> Self::EmitResult {
							todo!()
						}
						// CONTINUEABLE defaults to true
						// emit_producing_guarantee unchanged
					}
					// Cloning a `Diag` is a recipe for a diagnostic being emitted twice, which
					// would be bad.
					// Thank you for that very detailed explanation as to WHY. ASSHOLE.
					impl<G> ! Clone for crate::Diag<'_, G> {}

					impl<G: diagnostic::EmissionGuarantee> Deref for crate::Diag<'_, G> {
						type Target = DiagInner;

						fn deref(&self) -> &DiagInner {
							self.diag.as_ref().unwrap()
						}
					}

					impl<G: diagnostic::EmissionGuarantee> DerefMut for crate::Diag<'_, G> {
						fn deref_mut(&mut self) -> &mut DiagInner {
							self.diag.as_mut().unwrap()
						}
					}

					impl<G: diagnostic::EmissionGuarantee> Debug for crate::Diag<'_, G> {
						fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
							self.diag.fmt(f)
						}
					}

					impl<'a, G: diagnostic::EmissionGuarantee> crate::Diag<'a, G> {
						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn new(dcx: DiagnosticContextHandle<'a>, level: diagnostic::DiagnosticLevel, message: impl Into<DiagMessage>) -> Self {
							Self::new_diagnostic(dcx, DiagInner::new(level, message))
						}

						/// Allow moving diagnostics between different error tainting contexts
						pub fn with_dcx(mut self, dcx: DiagnosticContextHandle<'_>) -> crate::Diag<'_, G> {
							crate::Diag { dcx, diag: self.diag.take(), _marker: PhantomData }
						}

						/// Creates a new `Diag` with an already constructed diagnostic.
						#[track_caller]
						pub(crate) fn new_diagnostic(dcx: DiagnosticContextHandle<'a>, diag: DiagInner) -> Self {
							debug!("Created new diagnostic");
							Self { dcx, diag: Some(Box::new(diag)), _marker: PhantomData }
						}

						/// Delay emission of this diagnostic as a bug.
						///
						/// This can be useful in contexts where an error indicates a bug but
						/// typically this only happens when other compilation errors have already
						/// happened. In those cases this can be used to defer emission of this
						/// diagnostic as a bug in the compiler only if no other errors have been
						/// emitted.
						///
						/// In the meantime, though, callsites are required to deal with the "bug"
						/// locally in whichever way makes the most sense.
						#[rustc_lint_diagnostics]
						#[track_caller]
						pub fn downgrade_to_delayed_bug(&mut self) {
							assert!(
								matches!(self.level, Level::Error | Level::DelayedBug),
								"downgrade_to_delayed_bug: cannot downgrade {:?} to DelayedBug: not an error",
								self.level
							);
							self.level = diagnostic::DiagnosticLevel::DelayedBug;
						}

						#[doc = r" Appends a labeled span to the diagnostic."]
						#[doc = r""]
						#[doc = r" Labels are used to convey additional context for the diagnostic's primary span. They will"]
						#[doc = r" be shown together with the original diagnostic's span, *not* with spans added by"]
						#[doc = r" `span_note`, `span_help`, etc. Therefore, if the primary span is not displayable (because"]
						#[doc = r" the span is `DUMMY_SP` or the source code isn't found), labels will not be displayed"]
						#[doc = r" either."]
						#[doc = r""]
						#[doc = r" Implementation-wise, the label span is pushed onto the [`MultiSpan`] that was created when"]
						#[doc = r" the diagnostic was constructed. However, the label span is *not* considered a"]
						#[doc = r#" ["primary span"][`MultiSpan`]; only the `Span` supplied when creating the diagnostic is"#]
						#[doc = r" primary."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_label()`]."]
						pub fn span_label(&mut self, span: Span, label: impl Into<SubdiagMessage>) -> &mut Self {
							let msg = self.subdiagnostic_message_to_diagnostic_message(label);
							self.span.push_span_label(span, msg);
							self
						}
						#[doc = r" Appends a labeled span to the diagnostic."]
						#[doc = r""]
						#[doc = r" Labels are used to convey additional context for the diagnostic's primary span. They will"]
						#[doc = r" be shown together with the original diagnostic's span, *not* with spans added by"]
						#[doc = r" `span_note`, `span_help`, etc. Therefore, if the primary span is not displayable (because"]
						#[doc = r" the span is `DUMMY_SP` or the source code isn't found), labels will not be displayed"]
						#[doc = r" either."]
						#[doc = r""]
						#[doc = r" Implementation-wise, the label span is pushed onto the [`MultiSpan`] that was created when"]
						#[doc = r" the diagnostic was constructed. However, the label span is *not* considered a"]
						#[doc = r#" ["primary span"][`MultiSpan`]; only the `Span` supplied when creating the diagnostic is"#]
						#[doc = r" primary."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_label()`]."]
						pub fn with_span_label(mut self, span: Span, label: impl Into<SubdiagMessage>) -> Self {
							self.span_label(span, label);
							self
						}

						#[doc = r" Labels all the given spans with the provided label."]
						#[doc = r" See [`Self::span_label()`] for more information."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_labels()`]."]
						pub fn span_labels(&mut self, spans: impl IntoIterator<Item=Span>, label: &str) -> &mut Self {
							for span in spans {
								self.span_label(span, label.to_string());
							}
							self
						}
						#[doc = r" Labels all the given spans with the provided label."]
						#[doc = r" See [`Self::span_label()`] for more information."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_labels()`]."]
						pub fn with_span_labels(mut self, spans: impl IntoIterator<Item=Span>, label: &str) -> Self {
							self.span_labels(spans, label);
							self
						}
						#[rustc_lint_diagnostics]
						pub fn replace_span_with(&mut self, after: Span, keep_label: bool) -> &mut Self {
							let before = self.span.clone();
							self.span(after);
							for span_label in before.span_labels() {
								if let Some(label) = span_label.label {
									if span_label.is_primary && keep_label {
										self.span.push_span_label(after, label);
									} else {
										self.span.push_span_label(span_label.span, label);
									}
								}
							}
							self
						}

						#[rustc_lint_diagnostics]
						pub fn note_expected_found(
							&mut self,
							expected_label: &str,
							expected: DiagStyledString,
							found_label: &str,
							found: DiagStyledString,
						) -> &mut Self {
							self.note_expected_found_extra(
								expected_label,
								expected,
								found_label,
								found,
								DiagStyledString::normal(""),
								DiagStyledString::normal(""),
							)
						}

						#[rustc_lint_diagnostics]
						pub fn note_expected_found_extra(
							&mut self,
							expected_label: &str,
							expected: DiagStyledString,
							found_label: &str,
							found: DiagStyledString,
							expected_extra: DiagStyledString,
							found_extra: DiagStyledString,
						) -> &mut Self {
							let expected_label = expected_label.to_string();
							let expected_label = if expected_label.is_empty() {
								"expected".to_string()
							} else {
								format!("expected {expected_label}")
							};
							let found_label = found_label.to_string();
							let found_label = if found_label.is_empty() {
								"found".to_string()
							} else {
								format!("found {found_label}")
							};
							let (found_padding, expected_padding) = if expected_label.len() > found_label.len() {
								(expected_label.len() - found_label.len(), 0)
							} else {
								(0, found_label.len() - expected_label.len())
							};
							let mut msg = vec![StringPart::normal(format!(
								"{}{} `",
								" ".repeat(expected_padding),
								expected_label
							))];
							msg.extend(expected.0);
							msg.push(StringPart::normal(format!("`")));
							msg.extend(expected_extra.0);
							msg.push(StringPart::normal(format!("\n")));
							msg.push(StringPart::normal(format!("{}{} `", " ".repeat(found_padding), found_label)));
							msg.extend(found.0);
							msg.push(StringPart::normal(format!("`")));
							msg.extend(found_extra.0);

							// For now, just attach these as notes.
							self.highlighted_note(msg);
							self
						}

						#[rustc_lint_diagnostics]
						pub fn note_trait_signature(&mut self, name: Symbol, signature: String) -> &mut Self {
							self.highlighted_note(vec![
								StringPart::normal(format!("`{name}` from trait: `")),
								StringPart::highlighted(signature),
								StringPart::normal("`"),
							]);
							self
						}


						#[doc = r" Add a note attached to this diagnostic."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::note()`]."]
						pub fn note(&mut self, msg: impl Into<SubdiagMessage>) -> &mut Self {
							self.sub(diagnostic::DiagnosticLevel::Note, msg, MultiSpan::new());
							self
						}
						#[doc = r" Add a note attached to this diagnostic."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::note()`]."]
						pub fn with_note(mut self, msg: impl Into<SubdiagMessage>) -> Self {
							self.note(msg);
							self
						}
						#[rustc_lint_diagnostics]
						pub fn highlighted_note(&mut self, msg: Vec<StringPart>) -> &mut Self {
							self.sub_with_highlights(diagnostic::DiagnosticLevel::Note, msg, MultiSpan::new());
							self
						}

						#[rustc_lint_diagnostics]
						pub fn highlighted_span_note(
							&mut self,
							span: impl Into<MultiSpan>,
							msg: Vec<StringPart>,
						) -> &mut Self {
							self.sub_with_highlights(diagnostic::DiagnosticLevel::Note, msg, span.into());
							self
						}

						/// This is like [`crate::Diag::note()`], but it's only printed once.
						#[rustc_lint_diagnostics]
						pub fn note_once(&mut self, msg: impl Into<SubdiagMessage>) -> &mut Self {
							self.sub(diagnostic::DiagnosticLevel::OnceNote, msg, MultiSpan::new());
							self
						}


						#[doc = r" Prints the span with a note above it."]
						#[doc = r" This is like [`Diag::note()`], but it gets its own span."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_note()`]."]
						pub fn span_note(&mut self, sp: impl Into<MultiSpan>, msg: impl Into<SubdiagMessage>) -> &mut Self {
							self.sub(diagnostic::DiagnosticLevel::Note, msg, sp.into());
							self
						}
						#[doc = r" Prints the span with a note above it."]
						#[doc = r" This is like [`Diag::note()`], but it gets its own span."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_note()`]."]
						pub fn with_span_note(mut self, sp: impl Into<MultiSpan>, msg: impl Into<SubdiagMessage>) -> Self {
							self.span_note(sp, msg);
							self
						}
						/// Prints the span with a note above it.
						/// This is like [`crate::Diag::note_once()`], but it gets its own span.
						#[rustc_lint_diagnostics]
						pub fn span_note_once<S: Into<MultiSpan>>(
							&mut self,
							sp: S,
							msg: impl Into<SubdiagMessage>,
						) -> &mut Self {
							self.sub(diagnostic::DiagnosticLevel::OnceNote, msg, sp.into());
							self
						}


						#[doc = r" Add a warning attached to this diagnostic."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::warn()`]."]
						pub fn warn(&mut self, msg: impl Into<SubdiagMessage>) -> &mut Self {
							self.sub(diagnostic::DiagnosticLevel::Warning, msg, MultiSpan::new());
							self
						}
						#[doc = r" Add a warning attached to this diagnostic."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::warn()`]."]
						pub fn with_warn(mut self, msg: impl Into<SubdiagMessage>) -> Self {
							self.warn(msg);
							self
						}
						/// Prints the span with a warning above it.
						/// This is like [`crate::Diag::warn()`], but it gets its own span.
						#[rustc_lint_diagnostics]
						pub fn span_warn<S: Into<MultiSpan>>(
							&mut self,
							sp: S,
							msg: impl Into<SubdiagMessage>,
						) -> &mut Self {
							self.sub(diagnostic::DiagnosticLevel::Warning, msg, sp.into());
							self
						}


						#[doc = r" Add a help message attached to this diagnostic."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::help()`]."]
						pub fn help(&mut self, msg: impl Into<SubdiagMessage>) -> &mut Self {
							self.sub(diagnostic::DiagnosticLevel::Help, msg, MultiSpan::new());
							self
						}
						#[doc = r" Add a help message attached to this diagnostic."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::help()`]."]
						pub fn with_help(mut self, msg: impl Into<SubdiagMessage>) -> Self {
							self.help(msg);
							self
						}
						/// This is like [`crate::Diag::help()`], but it's only printed once.
						#[rustc_lint_diagnostics]
						pub fn help_once(&mut self, msg: impl Into<SubdiagMessage>) -> &mut Self {
							self.sub(diagnostic::DiagnosticLevel::OnceHelp, msg, MultiSpan::new());
							self
						}

						/// Add a help message attached to this diagnostic with a customizable highlighted message.
						#[rustc_lint_diagnostics]
						pub fn highlighted_help(&mut self, msg: Vec<StringPart>) -> &mut Self {
							self.sub_with_highlights(diagnostic::DiagnosticLevel::Help, msg, MultiSpan::new());
							self
						}

						/// Add a help message attached to this diagnostic with a customizable highlighted message.
						#[rustc_lint_diagnostics]
						pub fn highlighted_span_help(
							&mut self,
							span: impl Into<MultiSpan>,
							msg: Vec<StringPart>,
						) -> &mut Self {
							self.sub_with_highlights(diagnostic::DiagnosticLevel::Help, msg, span.into());
							self
						}

						/// Prints the span with some help above it.
						/// This is like [`crate::Diag::help()`], but it gets its own span.
						#[rustc_lint_diagnostics]
						pub fn span_help<S: Into<MultiSpan>>(
							&mut self,
							sp: S,
							msg: impl Into<SubdiagMessage>,
						) -> &mut Self {
							self.sub(diagnostic::DiagnosticLevel::Help, msg, sp.into());
							self
						}

						/// Disallow attaching suggestions to this diagnostic.
						/// Any suggestions attached e.g. with the `span_suggestion_*` methods
						/// (before and after the call to `disable_suggestions`) will be ignored.
						#[rustc_lint_diagnostics]
						pub fn disable_suggestions(&mut self) -> &mut Self {
							self.suggestions = Suggestions::Disabled;
							self
						}

						/// Prevent new suggestions from being added to this diagnostic.
						///
						/// Suggestions added before the call to `.seal_suggestions()` will be preserved
						/// and new suggestions will be ignored.
						#[rustc_lint_diagnostics]
						pub fn seal_suggestions(&mut self) -> &mut Self {
							if let Suggestions::Enabled(suggestions) = &mut self.suggestions {
								let suggestions_slice = std::mem::take(suggestions).into_boxed_slice();
								self.suggestions = Suggestions::Sealed(suggestions_slice);
							}
							self
						}

						/// Helper for pushing to `self.suggestions`.
						///
						/// A new suggestion is added if suggestions are enabled for this diagnostic.
						/// Otherwise, they are ignored.
						#[rustc_lint_diagnostics]
						fn push_suggestion(&mut self, suggestion: CodeSuggestion) {
							for subst in &suggestion.substitutions {
								for part in &subst.parts {
									let span = part.span;
									let call_site = span.ctxt().outer_expn_data().call_site;
									if span.in_derive_expansion() && span.overlaps_or_adjacent(call_site) {
										// Ignore if spans is from derive macro.
										return;
									}
								}
							}

							if let Suggestions::Enabled(suggestions) = &mut self.suggestions {
								suggestions.push(suggestion);
							}
						}


						#[doc = r" Show a suggestion that has multiple parts to it."]
						#[doc = r" In other words, multiple changes need to be applied as part of this suggestion."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::multipart_suggestion()`]."]
						pub fn multipart_suggestion(&mut self, msg: impl Into<SubdiagMessage>, suggestion: Vec<(Span, String)>, applicability: Applicability) -> &mut Self {
							self.multipart_suggestion_with_style(
								msg,
								suggestion,
								applicability,
								SuggestionStyle::ShowCode,
							)
						}
						#[doc = r" Show a suggestion that has multiple parts to it."]
						#[doc = r" In other words, multiple changes need to be applied as part of this suggestion."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::multipart_suggestion()`]."]
						pub fn with_multipart_suggestion(mut self, msg: impl Into<SubdiagMessage>, suggestion: Vec<(Span, String)>, applicability: Applicability) -> Self {
							self.multipart_suggestion(msg, suggestion, applicability);
							self
						}
						/// Show a suggestion that has multiple parts to it, always as its own subdiagnostic.
						/// In other words, multiple changes need to be applied as part of this suggestion.
						#[rustc_lint_diagnostics]
						pub fn multipart_suggestion_verbose(
							&mut self,
							msg: impl Into<SubdiagMessage>,
							suggestion: Vec<(Span, String)>,
							applicability: Applicability,
						) -> &mut Self {
							self.multipart_suggestion_with_style(
								msg,
								suggestion,
								applicability,
								SuggestionStyle::ShowAlways,
							)
						}

						/// [`crate::Diag::multipart_suggestion()`] but you can set the [`SuggestionStyle`].
						#[rustc_lint_diagnostics]
						pub fn multipart_suggestion_with_style(
							&mut self,
							msg: impl Into<SubdiagMessage>,
							mut suggestion: Vec<(Span, String)>,
							applicability: Applicability,
							style: SuggestionStyle,
						) -> &mut Self {
							let mut seen = FxHashSet::default();
							suggestion.retain(|(span, msg)| seen.insert((span.lo(), span.hi(), msg.clone())));

							let parts = suggestion
								.into_iter()
								.map(|(span, snippet)| SubstitutionPart { snippet, span })
								.collect::<Vec<_>>();

							assert!(!parts.is_empty());
							debug_assert_eq!(
								parts.iter().find(|part| part.span.is_empty() && part.snippet.is_empty()),
								None,
								"Span must not be empty and have no suggestion",
							);
							debug_assert_eq!(
								parts.array_windows().find(|[a, b]| a.span.overlaps(b.span)),
								None,
								"suggestion must not have overlapping parts",
							);

							self.push_suggestion(CodeSuggestion {
								substitutions: vec![Substitution { parts }],
								msg: self.subdiagnostic_message_to_diagnostic_message(msg),
								style,
								applicability,
							});
							self
						}

						/// Prints out a message with for a multipart suggestion without showing the suggested code.
						///
						/// This is intended to be used for suggestions that are obvious in what the changes need to
						/// be from the message, showing the span label inline would be visually unpleasant
						/// (marginally overlapping spans or multiline spans) and showing the snippet window wouldn't
						/// improve understandability.
						#[rustc_lint_diagnostics]
						pub fn tool_only_multipart_suggestion(
							&mut self,
							msg: impl Into<SubdiagMessage>,
							suggestion: Vec<(Span, String)>,
							applicability: Applicability,
						) -> &mut Self {
							self.multipart_suggestion_with_style(
								msg,
								suggestion,
								applicability,
								SuggestionStyle::CompletelyHidden,
							)
						}


						#[doc = r" Prints out a message with a suggested edit of the code."]
						#[doc = r""]
						#[doc = r" In case of short messages and a simple suggestion, rustc displays it as a label:"]
						#[doc = r""]
						#[doc = r" ```text"]
						#[doc = r" try adding parentheses: `(tup.0).1`"]
						#[doc = r" ```"]
						#[doc = r""]
						#[doc = r" The message"]
						#[doc = r""]
						#[doc = r" * should not end in any punctuation (a `:` is added automatically)"]
						#[doc = r#" * should not be a question (avoid language like "did you mean")"#]
						#[doc = r#" * should not contain any phrases like "the following", "as shown", etc."#]
						#[doc = r#" * may look like "to do xyz, use" or "to do xyz, use abc""#]
						#[doc = r" * may contain a name of a function, variable, or type, but not whole expressions"]
						#[doc = r""]
						#[doc = r" See `CodeSuggestion` for more information."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_suggestion()`]."]
						pub fn span_suggestion(&mut self, sp: Span, msg: impl Into<SubdiagMessage>, suggestion: impl ToString, applicability: Applicability) -> &mut Self {
							self.span_suggestion_with_style(
								sp,
								msg,
								suggestion,
								applicability,
								SuggestionStyle::ShowCode,
							);
							self
						}
						#[doc = r" Prints out a message with a suggested edit of the code."]
						#[doc = r""]
						#[doc = r" In case of short messages and a simple suggestion, rustc displays it as a label:"]
						#[doc = r""]
						#[doc = r" ```text"]
						#[doc = r" try adding parentheses: `(tup.0).1`"]
						#[doc = r" ```"]
						#[doc = r""]
						#[doc = r" The message"]
						#[doc = r""]
						#[doc = r" * should not end in any punctuation (a `:` is added automatically)"]
						#[doc = r#" * should not be a question (avoid language like "did you mean")"#]
						#[doc = r#" * should not contain any phrases like "the following", "as shown", etc."#]
						#[doc = r#" * may look like "to do xyz, use" or "to do xyz, use abc""#]
						#[doc = r" * may contain a name of a function, variable, or type, but not whole expressions"]
						#[doc = r""]
						#[doc = r" See `CodeSuggestion` for more information."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_suggestion()`]."]
						pub fn with_span_suggestion(mut self, sp: Span, msg: impl Into<SubdiagMessage>, suggestion: impl ToString, applicability: Applicability) -> Self {
							self.span_suggestion(sp, msg, suggestion, applicability);
							self
						}
						/// [`crate::Diag::span_suggestion()`] but you can set the [`SuggestionStyle`].
						#[rustc_lint_diagnostics]
						pub fn span_suggestion_with_style(
							&mut self,
							sp: Span,
							msg: impl Into<SubdiagMessage>,
							suggestion: impl ToString,
							applicability: Applicability,
							style: SuggestionStyle,
						) -> &mut Self {
							debug_assert!(
								!(sp.is_empty() && suggestion.to_string().is_empty()),
								"Span must not be empty and have no suggestion"
							);
							self.push_suggestion(CodeSuggestion {
								substitutions: vec![Substitution {
									parts: vec![SubstitutionPart { snippet: suggestion.to_string(), span: sp }],
								}],
								msg: self.subdiagnostic_message_to_diagnostic_message(msg),
								style,
								applicability,
							});
							self
						}


						#[doc = r" Always show the suggested change."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_suggestion_verbose()`]."]
						pub fn span_suggestion_verbose(&mut self, sp: Span, msg: impl Into<SubdiagMessage>, suggestion: impl ToString, applicability: Applicability) -> &mut Self {
							self.span_suggestion_with_style(
								sp,
								msg,
								suggestion,
								applicability,
								SuggestionStyle::ShowAlways,
							);
							self
						}
						#[doc = r" Always show the suggested change."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_suggestion_verbose()`]."]
						pub fn with_span_suggestion_verbose(mut self, sp: Span, msg: impl Into<SubdiagMessage>, suggestion: impl ToString, applicability: Applicability) -> Self {
							self.span_suggestion_verbose(sp, msg, suggestion, applicability);
							self
						}

						#[doc = r" Prints out a message with multiple suggested edits of the code."]
						#[doc = r" See also [`Diag::span_suggestion()`]."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_suggestions()`]."]
						pub fn span_suggestions(&mut self, sp: Span, msg: impl Into<SubdiagMessage>, suggestions: impl IntoIterator<Item=String>, applicability: Applicability) -> &mut Self {
							self.span_suggestions_with_style(
								sp,
								msg,
								suggestions,
								applicability,
								SuggestionStyle::ShowCode,
							)
						}
						#[doc = r" Prints out a message with multiple suggested edits of the code."]
						#[doc = r" See also [`Diag::span_suggestion()`]."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_suggestions()`]."]
						pub fn with_span_suggestions(mut self, sp: Span, msg: impl Into<SubdiagMessage>, suggestions: impl IntoIterator<Item=String>, applicability: Applicability) -> Self {
							self.span_suggestions(sp, msg, suggestions, applicability);
							self
						}
						#[rustc_lint_diagnostics]
						pub fn span_suggestions_with_style(
							&mut self,
							sp: Span,
							msg: impl Into<SubdiagMessage>,
							suggestions: impl IntoIterator<Item=String>,
							applicability: Applicability,
							style: SuggestionStyle,
						) -> &mut Self {
							let substitutions = suggestions
								.into_iter()
								.map(|snippet| {
									debug_assert!(
										!(sp.is_empty() && snippet.is_empty()),
										"Span must not be empty and have no suggestion"
									);
									Substitution { parts: vec![SubstitutionPart { snippet, span: sp }] }
								})
								.collect();
							self.push_suggestion(CodeSuggestion {
								substitutions,
								msg: self.subdiagnostic_message_to_diagnostic_message(msg),
								style,
								applicability,
							});
							self
						}

						/// Prints out a message with multiple suggested edits of the code, where each edit consists of
						/// multiple parts.
						/// See also [`crate::Diag::multipart_suggestion()`].
						#[rustc_lint_diagnostics]
						pub fn multipart_suggestions(
							&mut self,
							msg: impl Into<SubdiagMessage>,
							suggestions: impl IntoIterator<Item=Vec<(Span, String)>>,
							applicability: Applicability,
						) -> &mut Self {
							let substitutions = suggestions
								.into_iter()
								.map(|sugg| {
									let mut parts = sugg
										.into_iter()
										.map(|(span, snippet)| SubstitutionPart { snippet, span })
										.collect::<Vec<_>>();

									parts.sort_unstable_by_key(|part| part.span);

									assert!(!parts.is_empty());
									debug_assert_eq!(
										parts.iter().find(|part| part.span.is_empty() && part.snippet.is_empty()),
										None,
										"Span must not be empty and have no suggestion",
									);
									debug_assert_eq!(
										parts.array_windows().find(|[a, b]| a.span.overlaps(b.span)),
										None,
										"suggestion must not have overlapping parts",
									);

									Substitution { parts }
								})
								.collect();

							self.push_suggestion(CodeSuggestion {
								substitutions,
								msg: self.subdiagnostic_message_to_diagnostic_message(msg),
								style: SuggestionStyle::ShowCode,
								applicability,
							});
							self
						}


						#[doc = r" Prints out a message with a suggested edit of the code. If the suggestion is presented"]
						#[doc = r" inline, it will only show the message and not the suggestion."]
						#[doc = r""]
						#[doc = r" See `CodeSuggestion` for more information."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_suggestion_short()`]."]
						pub fn span_suggestion_short(&mut self, sp: Span, msg: impl Into<SubdiagMessage>, suggestion: impl ToString, applicability: Applicability) -> &mut Self {
							self.span_suggestion_with_style(
								sp,
								msg,
								suggestion,
								applicability,
								SuggestionStyle::HideCodeInline,
							);
							self
						}
						#[doc = r" Prints out a message with a suggested edit of the code. If the suggestion is presented"]
						#[doc = r" inline, it will only show the message and not the suggestion."]
						#[doc = r""]
						#[doc = r" See `CodeSuggestion` for more information."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span_suggestion_short()`]."]
						pub fn with_span_suggestion_short(mut self, sp: Span, msg: impl Into<SubdiagMessage>, suggestion: impl ToString, applicability: Applicability) -> Self {
							self.span_suggestion_short(sp, msg, suggestion, applicability);
							self
						}
						/// Prints out a message for a suggestion without showing the suggested code.
						///
						/// This is intended to be used for suggestions that are obvious in what the changes need to
						/// be from the message, showing the span label inline would be visually unpleasant
						/// (marginally overlapping spans or multiline spans) and showing the snippet window wouldn't
						/// improve understandability.
						#[rustc_lint_diagnostics]
						pub fn span_suggestion_hidden(
							&mut self,
							sp: Span,
							msg: impl Into<SubdiagMessage>,
							suggestion: impl ToString,
							applicability: Applicability,
						) -> &mut Self {
							self.span_suggestion_with_style(
								sp,
								msg,
								suggestion,
								applicability,
								SuggestionStyle::HideCodeAlways,
							);
							self
						}


						#[doc = r" Adds a suggestion to the JSON output that will not be shown in the CLI."]
						#[doc = r""]
						#[doc = r" This is intended to be used for suggestions that are *very* obvious in what the changes"]
						#[doc = r" need to be from the message, but we still want other tools to be able to apply them."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::tool_only_span_suggestion()`]."]
						pub fn tool_only_span_suggestion(&mut self, sp: Span, msg: impl Into<SubdiagMessage>, suggestion: impl ToString, applicability: Applicability) -> &mut Self {
							self.span_suggestion_with_style(
								sp,
								msg,
								suggestion,
								applicability,
								SuggestionStyle::CompletelyHidden,
							);
							self
						}
						#[doc = r" Adds a suggestion to the JSON output that will not be shown in the CLI."]
						#[doc = r""]
						#[doc = r" This is intended to be used for suggestions that are *very* obvious in what the changes"]
						#[doc = r" need to be from the message, but we still want other tools to be able to apply them."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::tool_only_span_suggestion()`]."]
						pub fn with_tool_only_span_suggestion(mut self, sp: Span, msg: impl Into<SubdiagMessage>, suggestion: impl ToString, applicability: Applicability) -> Self {
							self.tool_only_span_suggestion(sp, msg, suggestion, applicability);
							self
						}
						/// Add a subdiagnostic from a type that implements `Subdiagnostic` (see
						/// [rustc_macros::Subdiagnostic]). Performs eager translation of any translatable messages
						/// used in the subdiagnostic, so suitable for use with repeated messages (i.e. re-use of
						/// interpolated variables).
						#[rustc_lint_diagnostics]
						pub fn subdiagnostic(&mut self, subdiagnostic: impl Subdiagnostic) -> &mut Self {
							subdiagnostic.add_to_diag(self);
							self
						}

						/// Fluent (Deprecated in DaemonicCompiler) variables are not namespaced from each other, so when
						/// `Diagnostic`s and `Subdiagnostic`s use the same variable name,
						/// one value will clobber the other. Eagerly translating the
						/// diagnostic uses the variables defined right then, before the
						/// clobbering occurs.
						pub fn eagerly_translate(&self, msg: impl Into<SubdiagMessage>) -> SubdiagMessage {
							let args = self.args.iter();
							let msg = self.subdiagnostic_message_to_diagnostic_message(msg.into());
							self.dcx.eagerly_translate(msg, args)
						}


						#[doc = r" Add a span."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span()`]."]
						pub fn span(&mut self, sp: impl Into<MultiSpan>) -> &mut Self {
							self.span = sp.into();
							if let Some(span) = self.span.primary_span() {
								self.sort_span = span;
							}
							self
						}
						#[doc = r" Add a span."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::span()`]."]
						pub fn with_span(mut self, sp: impl Into<MultiSpan>) -> Self {
							self.span(sp);
							self
						}
						#[rustc_lint_diagnostics]
						pub fn is_lint(&mut self, name: String, has_future_breakage: bool) -> &mut Self {
							self.is_lint = Some(IsLint { name, has_future_breakage });
							self
						}

						#[doc = r" Add an error code."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::code()`]."]
						pub fn code(&mut self, code: ErrCode) -> &mut Self {
							self.code = Some(code);
							self
						}
						#[doc = r" Add an error code."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::code()`]."]
						pub fn with_code(mut self, code: ErrCode) -> Self {
							self.code(code);
							self
						}

						#[doc = r" Add an argument."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::lint_id()`]."]
						pub fn lint_id(&mut self, id: LintExpectationId) -> &mut Self {
							self.lint_id = Some(id);
							self
						}
						#[doc = r" Add an argument."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::lint_id()`]."]
						pub fn with_lint_id(mut self, id: LintExpectationId) -> Self {
							self.lint_id(id);
							self
						}

						#[doc = r" Add a primary message."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::primary_message()`]."]
						pub fn primary_message(&mut self, msg: impl Into<DiagMessage>) -> &mut Self {
							self.messages[0] = (msg.into(), Style::NoStyle);
							self
						}
						#[doc = r" Add a primary message."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::primary_message()`]."]
						pub fn with_primary_message(mut self, msg: impl Into<DiagMessage>) -> Self {
							self.primary_message(msg);
							self
						}

						#[doc = r" Add an argument."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::arg()`]."]
						pub fn arg(&mut self, name: impl Into<diagnostic::DiagArgName>, arg: impl crate::IntoDiagArg) -> &mut Self {
							self.deref_mut().arg(name, arg);
							self
						}
						#[doc = r" Add an argument."]
						#[rustc_lint_diagnostics]
						#[doc = "See [`Diag::arg()`]."]
						pub fn with_arg(mut self, name: impl Into<diagnostic::DiagArgName>, arg: impl crate::IntoDiagArg) -> Self {
							self.arg(name, arg);
							self
						}
						/// Helper function that takes a `SubdiagMessage` and returns a `DiagMessage` by
						/// combining it with the primary message of the diagnostic (if translatable, otherwise it just
						/// passes the user's string along).
						pub(crate) fn subdiagnostic_message_to_diagnostic_message(
							&self,
							attr: impl Into<SubdiagMessage>,
						) -> DiagMessage {
							self.deref().subdiagnostic_message_to_diagnostic_message(attr)
						}

						/// Convenience function for internal use, clients should use one of the
						/// public methods above.
						///
						/// Used by `proc_macro_server` for implementing `server::Diagnostic`.
						pub fn sub(&mut self, level: diagnostic::DiagnosticLevel, message: impl Into<SubdiagMessage>, span: MultiSpan) {
							self.deref_mut().sub(level, message, span);
						}

						/// Convenience function for internal use, clients should use one of the
						/// public methods above.
						fn sub_with_highlights(&mut self, level: diagnostic::DiagnosticLevel, messages: Vec<StringPart>, span: MultiSpan) {
							let messages = messages
								.into_iter()
								.map(|m| (self.subdiagnostic_message_to_diagnostic_message(m.content), m.style))
								.collect();
							let sub = crate::Subdiag { level, messages, span };
							self.children.push(sub);
						}

						/// Takes the diagnostic. For use by methods that consume the Diag: `emit`,
						/// `cancel`, etc. Afterwards, `drop` is the only code that will be run on
						/// `self`.
						fn take_diag(&mut self) -> DiagInner {
							if let Some(path) = &self.long_ty_path {
								self.note(format!(
									"the full name for the type has been written to '{}'",
									path.display()
								));
								self.note("consider using `--verbose` to print the full type name to the console");
							}
							Box::into_inner(self.diag.take().unwrap())
						}

						/// This method allows us to access the path of the file where "long types" are written to.
						///
						/// When calling `Diag::emit`, as part of that we will check if a `long_ty_path` has been set,
						/// and if it has been then we add a note mentioning the file where the "long types" were
						/// written to.
						///
						/// When calling `tcx.short_string()` after a `Diag` is constructed, the preferred way of doing
						/// so is `tcx.short_string(ty, diag.long_ty_path())`. The diagnostic itself is the one that
						/// keeps the existence of a "long type" anywhere in the diagnostic, so the note telling the
						/// user where we wrote the file to is only printed once at most, *and* it makes it much harder
						/// to forget to set it.
						///
						/// If the diagnostic hasn't been created before a "short ty string" is created, then you should
						/// ensure that this method is called to set it `*diag.long_ty_path() = path`.
						///
						/// As a rule of thumb, if you see or add at least one `tcx.short_string()` call anywhere, in a
						/// scope, `diag.long_ty_path()` should be called once somewhere close by.
						pub fn long_ty_path(&mut self) -> &mut Option<PathBuf> {
							&mut self.long_ty_path
						}

						/// Most `emit_producing_guarantee` functions use this as a starting point.
						pub fn emit_producing_nothing(mut self) {
							let diag = self.take_diag();
							self.dcx.emit_diagnostic(diag);
						}

						/// `ErrorGuaranteed::emit_producing_guarantee` uses this.
						pub fn emit_producing_error_guaranteed(mut self) -> ErrorGuaranteed {
							let diag = self.take_diag();

							// The only error levels that produce `ErrorGuaranteed` are
							// `Error` and `DelayedBug`. But `DelayedBug` should never occur here
							// because delayed bugs have their level changed to `Bug` when they are
							// actually printed, so they produce an ICE.
							//
							// (Also, even though `level` isn't `pub`, the whole `DiagInner` could
							// be overwritten with a new one thanks to `DerefMut`. So this assert
							// protects against that, too.)
							assert!(
								matches!(diag.level, Level::Error | Level::DelayedBug),
								"invalid diagnostic level ({:?})",
								diag.level,
							);

							let guar = self.dcx.emit_diagnostic(diag);
							guar.unwrap()
						}

						/// Emit and consume the diagnostic.
						#[track_caller]
						pub fn emit(self) -> G::EmitResult {
							G::emit_producing_guarantee(self)
						}

						/// Emit the diagnostic unless `delay` is true,
						/// in which case the emission will be delayed as a bug.
						///
						/// See `emit` and `delay_as_bug` for details.
						#[track_caller]
						pub fn emit_unless(mut self, delay: bool) -> G::EmitResult {
							if delay {
								self.downgrade_to_delayed_bug();
							}
							self.emit()
						}

						/// Cancel and consume the diagnostic. (A diagnostic must either be emitted or
						/// cancelled or it will panic when dropped).
						pub fn cancel(mut self) {
							self.diag = None;
							drop(self);
						}

						/// See `DiagCtxt::stash_diagnostic` for details.
						pub fn stash(mut self, span: Span, key: StashKey) -> Option<ErrorGuaranteed> {
							let diag = self.take_diag();
							self.dcx.stash_diagnostic(span, key, diag)
						}

						/// Delay emission of this diagnostic as a bug.
						///
						/// This can be useful in contexts where an error indicates a bug but
						/// typically this only happens when other compilation errors have already
						/// happened. In those cases this can be used to defer emission of this
						/// diagnostic as a bug in the compiler only if no other errors have been
						/// emitted.
						///
						/// In the meantime, though, callsites are required to deal with the "bug"
						/// locally in whichever way makes the most sense.
						#[track_caller]
						pub fn delay_as_bug(mut self) -> G::EmitResult {
							self.downgrade_to_delayed_bug();
							self.emit()
						}
					}

					/// Destructor bomb: every `Diag` must be consumed (emitted, cancelled, etc.)
					/// or we emit a bug.
					impl<G: diagnostic::EmissionGuarantee> Drop for crate::Diag<'_, G> {
						fn drop(&mut self) {
							match self.diag.take() {
								Some(diag) if !panicking() => {
									self.dcx.emit_diagnostic(DiagInner::new(
										diagnostic::DiagnosticLevel::Bug,
										DiagMessage::from("the following error was constructed but not emitted"),
									));
									self.dcx.emit_diagnostic(*diag);
									panic!("error was constructed but not emitted");
								}
								_ => {}
							}
						}
					}
					impl fmt::Display for crate::DiagnosticLevel {
						fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
							self.to_str().fmt(f)
						}
					}
					impl crate::DiagnosticLevel {
						pub fn color(self) -> ColorSpec {
							let mut spec = ColorSpec::new();
							match self {
								crate::DiagnosticLevel::Bug | crate::DiagnosticLevel::Fatal | crate::DiagnosticLevel::Error | crate::DiagnosticLevel::DelayedBug => {
									spec.set_fg(Some(Color::Red)).set_intense(true);
								}
								crate::DiagnosticLevel::ForceWarning | crate::DiagnosticLevel::Warning => {
									spec.set_fg(Some(Color::Yellow)).set_intense(cfg!(windows));
								}
								crate::DiagnosticLevel::Note | crate::DiagnosticLevel::OnceNote => {
									spec.set_fg(Some(Color::Green)).set_intense(true);
								}
								crate::DiagnosticLevel::Help | crate::DiagnosticLevel::OnceHelp => {
									spec.set_fg(Some(Color::Cyan)).set_intense(true);
								}
								crate::DiagnosticLevel::FailureNote => {}
								crate::DiagnosticLevel::Allow | crate::DiagnosticLevel::Expect => unreachable!(),
							}
							spec
						}

						pub fn to_str(self) -> &'static str {
							match self {
								crate::DiagnosticLevel::Bug | crate::DiagnosticLevel::DelayedBug => "error: internal compiler error",
								crate::DiagnosticLevel::Fatal | crate::DiagnosticLevel::Error => "error",
								crate::DiagnosticLevel::ForceWarning | crate::DiagnosticLevel::Warning => "warning",
								crate::DiagnosticLevel::Note | crate::DiagnosticLevel::OnceNote => "note",
								crate::DiagnosticLevel::Help | crate::DiagnosticLevel::OnceHelp => "help",
								crate::DiagnosticLevel::FailureNote => "failure-note",
								crate::DiagnosticLevel::Allow | crate::DiagnosticLevel::Expect => unreachable!(),
							}
						}

						pub fn is_failure_note(&self) -> bool {
							matches!(*self, DiagnosticLevel::FailureNote)
						}

						// Can this level be used in a subdiagnostic message?
						fn can_be_subdiag(&self) -> bool {
							match self {
								crate::DiagnosticLevel::Bug |
								crate::DiagnosticLevel::DelayedBug |
								crate::DiagnosticLevel::Fatal |
								crate::DiagnosticLevel::Error |
								crate::DiagnosticLevel::ForceWarning |
								crate::DiagnosticLevel::FailureNote |
								crate::DiagnosticLevel::Allow |
								crate::DiagnosticLevel::Expect => false,

								crate::DiagnosticLevel::Warning |
								crate::DiagnosticLevel::Note |
								crate::DiagnosticLevel::Help |
								crate::DiagnosticLevel::OnceNote |
								crate::DiagnosticLevel::OnceHelp => true,
							}
						}
					}
					/// Converts a value of a type into a `DiagArg` (typically a field of an `Diag` struct).
					/// Implemented as a custom trait rather than `From` so that it is implemented on the type being
					/// converted rather than on `DiagArgValue`, which enables types from other `rustc_*` crates to
					/// implement this.

					impl diagnostic::EmissionGuarantee for () {
						fn emit_producing_guarantee(diag: Diag<'_, Self>) -> Self::EmitResult {
							todo!()
						}
						// Warnings, continue
					}

					// // NEW: Fatal no longer FORCES diverge
					impl diagnostic::EmissionGuarantee for FatalGuarantee {
						const CONTINUEABLE: bool = false;  // Not by default
						type RecoveryHandler = diagnostic::FatalRecovery;  // But CAN recover

						fn emit_producing_guarantee(diag: crate::Diag<'_, Self>) -> Self::EmitResult {
							// Original fatal logic
						}
					}
					impl RecoveryHandler<FatalGuarantee> for FatalRecovery {
						fn attempt_recovery(result: &FatalGuarantee) -> Option<RecoveredState> {
							// Check if this specific fatal is recoverable
							if result.kind.is_structurally_broken() {
								None  // Truly must stop
							} else {
								Some(RecoveredState::from_fatal(result))
							}
						}
					}
					// // NEW: Fatal no longer FORCES diverge
					impl EmissionGuarantee for FatalGuarantee {
						const CONTINUEABLE: bool = false;
						// Not by default
						type RecoveryHandler = FatalRecovery;  // But CAN recover

						fn emit_producing_guarantee(diag: Diag<'_, Self>) -> Self::EmitResult {
							// todo: Original fatal logic stub
						}
					}
					impl DiagInner {
						#[track_caller]
						pub fn new<M: Into<DiagMessage>>(level: crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel, message: M) -> Self {
							DiagInner::new_with_messages(level, vec![(message.into(), Style::NoStyle)])
						}

						#[track_caller]
						pub fn new_with_messages(level: crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel, messages: Vec<(DiagMessage, Style)>) -> Self {
							DiagInner {
								level,
								lint_id: None,
								messages,
								code: None,
								span: MultiSpan::new(),
								children: vec![],
								suggestions: Suggestions::Enabled(vec![]),
								args: Default::default(),
								sort_span: DUMMY_SP,
								is_lint: None,
								long_ty_path: None,
								emitted_at: DiagLocation::caller(),
							}
						}

						#[inline(always)]
						pub fn level(&self) -> crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel {
							self.level
						}

						pub fn is_error(&self) -> bool {
							match self.level {
								crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::Bug | crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::Fatal | crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::Error | crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::DelayedBug => true,

								crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::ForceWarning
								| crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::Warning
								| crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::Note
								| crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::OnceNote
								| crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::Help
								| crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::OnceHelp
								| crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::FailureNote
								| crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::Allow
								| crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::Expect => false,
							}
						}

						/// Indicates whether this diagnostic should show up in cargo's future breakage report.
						pub(crate) fn has_future_breakage(&self) -> bool {
							matches!(self.is_lint, Some(IsLint { has_future_breakage: true, .. }))
						}

						pub(crate) fn is_force_warn(&self) -> bool {
							match self.level {
								crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel::ForceWarning => {
									assert!(self.is_lint.is_some());
									true
								}
								_ => false,
							}
						}

						// See comment on `Diag::subdiagnostic_message_to_diagnostic_message`.
						pub fn subdiagnostic_message_to_diagnostic_message(
							&self,
							attr: impl Into<SubdiagMessage>,
						) -> DiagMessage {
							let msg =
								self.messages.iter().map(|(msg, _)| msg).next().expect("diagnostic with no messages");
							msg.with_subdiagnostic_message(attr.into())
						}

						pub(crate) fn sub(
							&mut self,
							level: crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel,
							message: impl Into<SubdiagMessage>,
							span: MultiSpan,
						) {
							let sub = Subdiag {
								level,
								messages: vec![(
									self.subdiagnostic_message_to_diagnostic_message(message),
									Style::NoStyle,
								)],
								span,
							};
							self.children.push(sub);
						}

						pub(crate) fn arg(&mut self, name: impl Into<DiagArgName>, arg: impl IntoDiagArg) {
							self.args.insert(name.into(), arg.into_diag_arg(&mut self.long_ty_path));
						}

						/// Fields used for DaemonicHashable, and PartialEq trait.
						fn keys(
							&self,
						) -> (
							&crate::daemonic::daemonic_contract::daemonic_result::diagnostic::structures::DiagnosticLevel,
							&[(DiagMessage, Style)],
							&Option<ErrCode>,
							&MultiSpan,
							&[Subdiag],
							&Suggestions,
							Vec<(&DiagArgName, &DiagArgValue)>,
							&Option<IsLint>,
						) {
							(
								&self.level,
								&self.messages,
								&self.code,
								&self.span,
								&self.children,
								&self.suggestions,
								self.args.iter().collect(),
								// omit self.sort_span
								&self.is_lint,
								// omit self.emitted_at
							)
						}
					}

					impl Hash for DiagInner {
						fn hash<H>(&self, state: &mut H)
						where
							H: Hasher,
						{
							self.keys().hash(state);
						}
					}

					impl PartialEq for DiagInner {
						fn eq(&self, other: &Self) -> bool {
							self.keys() == other.keys()
						}
					}
					impl IntoDiagArg for DiagArgValue {
						fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
							self
						}
					}
					impl<'a> std::ops::Deref for DiagCtxtHandle<'a> {
						type Target = &'a DiagCtxt;

						fn deref(&self) -> &Self::Target {
							&self.dcx
						}
					}
				}

				pub use traits::*;
				pub use structures::*;
				pub use implementations::*;


				// Trait for types that `Diag::emit` can return as a "guarantee" (or "proof")
				// token that the emission happened.
				// pub trait EmissionGuarantee: Sized {
				// 	/// This exists so that bugs and fatal errors can both result in `!` (an
				// 	/// abort) when emitted, but have different aborting behaviour.
				// 	/// But.. fuckin why? Bugs and Fatals should be handled better than
				// 	/// just blanketing all as `!` bails. They should emit states that allow
				// 	/// caller to define behavior, if no behavior defined or trait unbound at
				// 	/// callsite -> then trigger `!`
				// 	/// `!` should not be the sole promise EmissionGuarantee provides.
				// 	type EmitResult = Self;
				//
				// 	/// Implementation of `Diag::emit`, fully controlled by each `impl` of
				// 	/// `EmissionGuarantee`, to make it impossible to create a value of
				// 	/// `Self::EmitResult` without actually performing the emission.
				// 	/// Logic still 'works' and compiles, but is semantically incorrect.
				// 	/// emit result is an alias for Self, Self::EmitResult -> returns Self::Self under the hood.
				// 	///
				// 	///    2024 edition (current logic) semantics state this should be a dynamic trait
				// 	///    But dyn Self::Self doesnt compile, throws type error "Expected Trait, found Type Alias"
				// 	///    this makes sense because Types define what and how to store.
				// 	///    Trait defines behavior given context, emitting Type Self::EmitResult in this context
				// 	/// propagates self up to a Sized EmissionGuaranteed trait, which can be employed elsewhere.
				// 	/// Why the fuck does this work and compile?
				// 	/// Whoever originally wrote this had to work within constraints, i get it.
				// 	/// But also, Fuck You. Sincerely, Meph.
				// 	#[track_caller]
				// 	fn emit_producing_guarantee(diag: Diag<'_, Self>) -> Self::EmitResult; // todo: This was written pre 2018 edition.
				//
				//
				//
				// 	//
				//
				// 	const CONTINUEABLE: bool;
				// 	// Not by default
				// 	type RecoveryHandler;
				// }

				/// Constructs an event at the debug level.
				/// i hate this macro.
				/// this is legacy macro.
				/// fuck this macro.
				/// replace with proper constructor at some point
				///
				/// This functions similarly to the [`event!`] macro. See [the top-level
				/// documentation][lib] for details on the syntax accepted by
				/// this macro.
				///
				/// [`event!`]: crate::event!
				/// [lib]: crate#using-the-macros
				///
				/// # Examples
				///
				/// ```rust
				/// use tracing::debug;
				/// # fn main() {
				/// # #[derive(Debug)] struct Position { x: f32, y: f32 }
				///
				/// let pos = Position { x: 3.234, y: -1.223 };
				///
				/// debug!(?pos.x, ?pos.y);
				/// debug!(target: "app_events", position = ?pos, "New position");
				/// debug!(name: "completed", position = ?pos);
				/// # }
				/// ```
				#[macro_export]
				macro_rules! debug {
    // Name / target / parent.
    (name: $name:expr, target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
    );
    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)* })
    );
    (name: $name:expr, target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
    );
    (name: $name:expr, target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, { %$($k).+ $($field)* })
    );
    (name: $name:expr, target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
        $crate::event!(name: $name, target: $target, parent: $parent, $crate::Level::DEBUG, {}, $($arg)+)
    );

    // Name / target.
    (name: $name:expr, target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
    );
    (name: $name:expr, target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, { $($k).+ $($field)* })
    );
    (name: $name:expr, target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
    );
    (name: $name:expr, target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, { %$($k).+ $($field)* })
    );
    (name: $name:expr, target: $target:expr, $($arg:tt)+ ) => (
        $crate::event!(name: $name, target: $target, $crate::Level::DEBUG, {}, $($arg)+)
    );

    // Target / parent.
    (target: $target:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
        $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
    );
    (target: $target:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
        $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)* })
    );
    (target: $target:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
        $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
    );
    (target: $target:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
        $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, { %$($k).+ $($field)* })
    );
    (target: $target:expr, parent: $parent:expr, $($arg:tt)+ ) => (
        $crate::event!(target: $target, parent: $parent, $crate::Level::DEBUG, {}, $($arg)+)
    );

    // Name / parent.
    (name: $name:expr, parent: $parent:expr, { $($field:tt)* }, $($arg:tt)* ) => (
        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
    );
    (name: $name:expr, parent: $parent:expr, $($k:ident).+ $($field:tt)* ) => (
        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, { $($k).+ $($field)* })
    );
    (name: $name:expr, parent: $parent:expr, ?$($k:ident).+ $($field:tt)* ) => (
        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
    );
    (name: $name:expr, parent: $parent:expr, %$($k:ident).+ $($field:tt)* ) => (
        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, { %$($k).+ $($field)* })
    );
    (name: $name:expr, parent: $parent:expr, $($arg:tt)+ ) => (
        $crate::event!(name: $name, parent: $parent, $crate::Level::DEBUG, {}, $($arg)+)
    );

    // Name.
    (name: $name:expr, { $($field:tt)* }, $($arg:tt)* ) => (
        $crate::event!(name: $name, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
    );
    (name: $name:expr, $($k:ident).+ $($field:tt)* ) => (
        $crate::event!(name: $name, $crate::Level::DEBUG, { $($k).+ $($field)* })
    );
    (name: $name:expr, ?$($k:ident).+ $($field:tt)* ) => (
        $crate::event!(name: $name, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
    );
    (name: $name:expr, %$($k:ident).+ $($field:tt)* ) => (
        $crate::event!(name: $name, $crate::Level::DEBUG, { %$($k).+ $($field)* })
    );
    (name: $name:expr, $($arg:tt)+ ) => (
        $crate::event!(name: $name, $crate::Level::DEBUG, {}, $($arg)+)
    );

    // Target.
    (target: $target:expr, { $($field:tt)* }, $($arg:tt)* ) => (
        $crate::event!(target: $target, $crate::Level::DEBUG, { $($field)* }, $($arg)*)
    );
    (target: $target:expr, $($k:ident).+ $($field:tt)* ) => (
        $crate::event!(target: $target, $crate::Level::DEBUG, { $($k).+ $($field)* })
    );
    (target: $target:expr, ?$($k:ident).+ $($field:tt)* ) => (
        $crate::event!(target: $target, $crate::Level::DEBUG, { ?$($k).+ $($field)* })
    );
    (target: $target:expr, %$($k:ident).+ $($field:tt)* ) => (
        $crate::event!(target: $target, $crate::Level::DEBUG, { %$($k).+ $($field)* })
    );
    (target: $target:expr, $($arg:tt)+ ) => (
        $crate::event!(target: $target, $crate::Level::DEBUG, {}, $($arg)+)
    );

    // Parent.
    (parent: $parent:expr, { $($field:tt)+ }, $($arg:tt)+ ) => (
        $crate::event!(
            target: module_path!(),
            parent: $parent,
            $crate::Level::DEBUG,
            { $($field)+ },
            $($arg)+
        )
    );
    (parent: $parent:expr, $($k:ident).+ = $($field:tt)*) => (
        $crate::event!(
            target: module_path!(),
            parent: $parent,
            $crate::Level::DEBUG,
            { $($k).+ = $($field)*}
        )
    );
    (parent: $parent:expr, ?$($k:ident).+ = $($field:tt)*) => (
        $crate::event!(
            target: module_path!(),
            parent: $parent,
            $crate::Level::DEBUG,
            { ?$($k).+ = $($field)*}
        )
    );
    (parent: $parent:expr, %$($k:ident).+ = $($field:tt)*) => (
        $crate::event!(
            target: module_path!(),
            parent: $parent,
            $crate::Level::DEBUG,
            { %$($k).+ = $($field)*}
        )
    );
    (parent: $parent:expr, $($k:ident).+, $($field:tt)*) => (
        $crate::event!(
            target: module_path!(),
            parent: $parent,
            $crate::Level::DEBUG,
            { $($k).+, $($field)*}
        )
    );
    (parent: $parent:expr, ?$($k:ident).+, $($field:tt)*) => (
        $crate::event!(
            target: module_path!(),
            parent: $parent,
            $crate::Level::DEBUG,
            { ?$($k).+, $($field)*}
        )
    );
    (parent: $parent:expr, %$($k:ident).+, $($field:tt)*) => (
        $crate::event!(
            target: module_path!(),
            parent: $parent,
            $crate::Level::DEBUG,
            { %$($k).+, $($field)*}
        )
    );
    (parent: $parent:expr, $($arg:tt)+) => (
        $crate::event!(
            target: module_path!(),
            parent: $parent,
            $crate::Level::DEBUG,
            {},
            $($arg)+
        )
    );

    // ...
    ({ $($field:tt)+ }, $($arg:tt)+ ) => (
        $crate::event!(
            target: module_path!(),
            $crate::Level::DEBUG,
            { $($field)+ },
            $($arg)+
        )
    );
    ($($k:ident).+ = $($field:tt)*) => (
        $crate::event!(
            target: module_path!(),
            $crate::Level::DEBUG,
            { $($k).+ = $($field)*}
        )
    );
    (?$($k:ident).+ = $($field:tt)*) => (
        $crate::event!(
            target: module_path!(),
            $crate::Level::DEBUG,
            { ?$($k).+ = $($field)*}
        )
    );
    (%$($k:ident).+ = $($field:tt)*) => (
        $crate::event!(
            target: module_path!(),
            $crate::Level::DEBUG,
            { %$($k).+ = $($field)*}
        )
    );
    ($($k:ident).+, $($field:tt)*) => (
        $crate::event!(
            target: module_path!(),
            $crate::Level::DEBUG,
            { $($k).+, $($field)*}
        )
    );
    (?$($k:ident).+, $($field:tt)*) => (
        $crate::event!(
            target: module_path!(),
            $crate::Level::DEBUG,
            { ?$($k).+, $($field)*}
        )
    );
    (%$($k:ident).+, $($field:tt)*) => (
        $crate::event!(
            target: module_path!(),
            $crate::Level::DEBUG,
            { %$($k).+, $($field)*}
        )
    );
    (?$($k:ident).+) => (
        $crate::event!(
            target: module_path!(),
            $crate::Level::DEBUG,
            { ?$($k).+ }
        )
    );
    (%$($k:ident).+) => (
        $crate::event!(
            target: module_path!(),
            $crate::Level::DEBUG,
            { %$($k).+ }
        )
    );
    ($($k:ident).+) => (
        $crate::event!(
            target: module_path!(),
            $crate::Level::DEBUG,
            { $($k).+ }
        )
    );
    ($($arg:tt)+) => (
        $crate::event!(
            target: module_path!(),
            $crate::Level::DEBUG,
            $($arg)+
        )
    );
}
			}
			pub(crate) mod subdiagnostic {
				use crate::EmissionGuarantee;

				/// Trait implemented by error types. This should not be implemented manually. Instead, use
				/// `#[derive(Subdiagnostic)]` -- see [rustc_macros::Subdiagnostic].
				#[rustc_diagnostic_item = "Subdiagnostic"]
				pub trait Subdiagnostic
				where
					Self: Sized,
				{
					/// Add a subdiagnostic to an existing diagnostic.
					fn add_to_diag<GUARANTEE: EmissionGuarantee>(
						self,
						diag: &mut Diag<'_, GUARANTEE>,
					);
				}
			}
			pub(crate) mod repairable {
				use super::severity_types::{GlassCracked, GlassState, SeverityType};
				use super::*;
				use crate::daemonic::Daemonic;
				use crate::daemonic::daemonic_contract::IntoDaemonicResult;
				use crate::{DaemonicError, DaemonicResult};
				pub trait SeverityHandler<FORMAT, PARTIAL> {
					type Context;
					type Output: IntoDaemonicResult<FORMAT, PARTIAL>;
					type Error: for<'e> DaemonicError<'e, FORMAT, PARTIAL>;

					// ═══════════════════════════════════════════════════════
					// OK-ISH HANDLERS (Stable through Suggestion)
					// ═══════════════════════════════════════════════════════

					/// Stable Return type Analogous to Ok or Success Result, ideally should be passthrough
					/// value. Also, this probably isnt correct as is but is better than it was prior.
					/// Might need to be wired into DaemonicContract system.
					fn handle_stable(&self, _state: &GlassStable, _ctx: &Self::Context) -> DaemonicResult<Self::Output, Self::Error> {
						// Default: passthrough, nothing to do
						DaemonicResult::Success(Self::Output::default())
					}
					/// Like an Ok value with a note attached
					fn handle_note(&self, _state: &GlassNote, _ctx: &Self::Context) -> DaemonicResult<Self::Output, Self::Error> {
						// Default: log note, continue
						DaemonicResult::Success(Self::Output::default())
					}
					/// Like an Ok value (ish) with a help message or note attached.
					fn handle_help(&self, _state: &GlassHelp, _ctx: &Self::Context) -> DaemonicResult<Self::Output, Self::Error> {
						DaemonicResult::Success(Self::Output::default())
					}
					/// Sometimes accompanied with an Error, sometimes stand alone. Intended to be a
					/// suggestion reflected from the backend to the User/Dev but is not in and of itself
					/// an error. Similar to `Subdiagnostic` trait from [RustcError]
					fn handle_suggestion(
						&self,
						_state: &GlassSuggestion,
						_ctx: &Self::Context,
					) -> DaemonicResult<Self::Output, Self::Error> {
						DaemonicResult::Success(Self::Output::default())
					}

					// ═══════════════════════════════════════════════════════
					// BOUNDARY HANDLERS (Cracked)
					// Two methods because two genuinely different cases
					// ═══════════════════════════════════════════════════════

					fn handle_cracked_holding(
						&self,
						_state: &GlassCracked,
						_ctx: &Self::Context,
					) -> DaemonicResult<Self::Output, Self::Error> {
						// Holding = damaged but functional
						// Return success with default, caller can override
						DaemonicResult::Success(Self::Output::default())
					}

					fn handle_cracked_contained<R>(
						&self,
						state: &GlassCracked,
						ctx: &mut Self::Context,
						action: impl FnOnce(&Self::Error, &mut Self::Context) -> Option<R>,
					) -> DaemonicResult<R, Self::Error> {
						let error = Self::Error::from_cracked(state); // this method needs implementation
						match action(&error, ctx) {
							Some(repaired) => DaemonicResult::Success(repaired),
							None => DaemonicResult::Failure(error),
						}
					}

					// ═══════════════════════════════════════════════════════
					// ERROR HANDLERS (Fractured through Shattered)
					// Mutable context, action for repair attempt
					// ═══════════════════════════════════════════════════════

					fn handle_fracture<R>(
						&self,
						state: &GlassFracture,
						ctx: &mut Self::Context,
						action: impl FnOnce(&Self::Error, &mut Self::Context) -> Option<R>,
					) -> DaemonicResult<R, Self::Error> {
						let error = Self::Error::from_fracture(state);
						match action(&error, ctx) {
							Some(repaired) => DaemonicResult::Success(repaired),
							None => DaemonicResult::Failure(error),
						}
					}

					fn handle_warp<R>(
						&self,
						state: &GlassWarp,
						ctx: &mut Self::Context,
						action: impl FnOnce(&Self::Error, &mut Self::Context) -> Option<R>,
					) -> DaemonicResult<R, Self::Error> {
						let error = Self::Error::from_warp(state);
						match action(&error, ctx) {
							Some(repaired) => DaemonicResult::Success(repaired),
							None => DaemonicResult::Failure(error),
						}
					}

					fn handle_shattered<R>(
						&self,
						state: &GlassShattered,
						ctx: &mut Self::Context,
						action: impl FnOnce(&Self::Error, &mut Self::Context) -> Option<R>,
					) -> DaemonicResult<R, Self::Error> {
						let error = Self::Error::from_shattered(state);
						match action(&error, ctx) {
							Some(recovered) => DaemonicResult::Success(recovered),
							None => DaemonicResult::Failure(error),
						}
					}
					fn handle<Repair>(&self, severity: &SeverityType, ctx: &mut Self::Context, _repair: impl FnOnce(&Self::Error, &mut Self::Context)
						-> Option<Repair>) -> DaemonicResult<Self::Output, Self::Error>
					{
						match severity {
							SeverityType::GlassStable(s) => {
								self.handle_stable(s, ctx)
							}
							SeverityType::GlassNote(note) => {
								self.handle_note(note, ctx)
							}
							SeverityType::GlassSuggestion(sug) => {
								self.handle_suggestion(sug, ctx)
							}
							SeverityType::GlassHelp(h) => {
								self.handle_help(h, ctx)
							}
							SeverityType::GlassCracked(crack) => {
								self.handle_cracked(crack, ctx, |_error, _ctx| None::<Self::Output>)
							}
							SeverityType::GlassFracture(f) => {
								self.handle_fracture(f, ctx, |_error, _ctx| None::<Self::Output>)
							}
							SeverityType::GlassWarp(w) => {
								self.handle_warp(w, ctx, |_error, _ctx| None::<Self::Output>)
							}
							SeverityType::GlassShattered(shatter) => {
								self.handle_shattered(shatter, ctx, |_error, _ctx| None::<Self::Output>)
							}
						}
					}
				}
				///Example usage for specific contexts
				///```
				/// struct VideoHandler;
				/// impl SeverityHandler<VideoContext, Image> for VideoHandler {
				/// 	fn handle(&self, severity: &SeverityType, ctx: VideoContext) -> Image {
				/// 		match severity {
				/// 			SeverityType::GlassNote(note) => load_image(&note.message),
				/// 			_ => default_image(),
				/// 		}
				/// 	}
				/// }
				/// ```
				/// Generic Zero sized repair handler
				struct DaemonicHandler<CONTEXT, ACTION, R> {
					context: CONTEXT,
					action: Option<fn(&SeverityType, CONTEXT) -> ACTION>,
				}
			}
			pub(crate) mod severity_types {
				use super::mirror_chemistry::{MirrorType, ReflectionProperties};
				///SINON:
				/// "On Glass vs Mirror naming."
				/// Mirror:
				///   - The surface that reflects
				///   - Physical object
				///   - Passive
				///   - "What bounces off"
				///
				/// Glass:
				///   - The material
				///   - Can be mirror, lens, window, prism
				///   - More general
				///   - "What light passes through or bounces off"
				///
				/// In your system:
				///
				/// ReflectionProperties = how reflection behaves
				/// Mirror = a stable compound of reflection properties
				/// Glass = the STATE of a thing after observation
				///
				/// RECOMMENDATION:
				///
				/// Use GLASS for states.
				/// Use MIRROR for types (the chemistry element).
				/// Use REFLECTION for the process.
				///
				/// Why:
				///   - Glass is the material that makes mirrors
				///   - Glass can be stable or shattered
				///   - "GlassShattered" makes sense
				///   - "MirrorShattered" is less clear (mirror is already solid)
				///
				///   - Mirror describes BEHAVIOR (how it reflects)
				///   - Glass describes STATE (what condition it's in)
				///
				/// GlassStable: the glass is intact, reflects clearly
				/// GlassShattered: the glass is broken, reflects chaotically
				/// GlassFractured: the glass has cracks, reflects imperfectly
				///
				/// Mirror types (Specular, Absorptive, etc.):
				///   What KIND of reflection
				///
				/// Glass states:
				///   What CONDITION the glass is in
				///
				pub trait GlassState<'state>: Send + Sync + 'state {
					type Mirror<'mirrortype>: MirrorType<'mirrortype>;
					type Cause<'mirrortype>: Severity;
					fn from_reflection(props: ReflectionProperties) -> Self;
					/// Is recoverable defaults to FALSE, call or definition defines otherwise
					fn is_recoverable(&self) -> bool { false }
					/// Can cascade defaults to FALSE, call or definition defines otherwise
					fn can_cascade(&self) -> bool { false }
					fn dominance(&self) -> u8;
					fn stable<'stable>() -> fn(GlassStable) -> SeverityType;
					fn fracture(props: &ReflectionProperties) -> fn(GlassFracture) -> SeverityType;
					fn warp(props: &ReflectionProperties) -> fn(GlassWarp) -> SeverityType;
					fn shatter<'impossible>() -> fn(GlassShattered) -> SeverityType;
					fn note<'note>() -> fn(GlassNote) -> SeverityType;
					fn suggestion<'suggestion>() -> fn(GlassSuggestion) -> SeverityType;
					fn help<'help>() -> fn(GlassHelp) -> SeverityType;
				}
				pub trait Severity: Send + Sync {
					type Mirror<'mirrortype>: MirrorType<'mirrortype>;
					const RECOVERABLE: bool;
					const CAN_CASCADE: bool;
					const DOMINANCE: u8;
					fn on_observer(&self) -> SeverityAction;
				}
				/// this is simple for now, as suggested by Sinon and Ada, but i would like to
				/// nest these in Daemonic style eventually where each nested bit returns a struct
				/// and all downstream types implementing it must return a struct on it to guarantee
				/// type safety in all edge cases.
				/// Also, recursion management logic needs to be attached here along with
				/// DaemonicClock logic traits for halt/continue decision making, should be function
				/// not arbitrary.
				pub(crate) enum SeverityAction {
					Continue,
					Warn,
					Halt,
					Abort,
				}
				pub enum SeverityType {
					GlassStable(GlassStable),
					GlassHelp(GlassHelp),
					GlassSuggestion(GlassSuggestion),
					GlassNote(GlassNote),
					GlassCracked(GlassCracked),
					GlassFracture(GlassFracture),
					GlassWarp(GlassWarp),
					GlassShattered(GlassShattered),
				}
				impl<R> From<GlassStable> for SeverityType {
					fn from(s: GlassStable) -> Self {
						SeverityType::GlassStable(s)
					}
				}
				impl<R> SeverityType {
					pub fn as_glass_state(&self) -> &dyn GlassState<Cause=impl Severity, Mirror=impl MirrorType> {
						match self {
							SeverityType::GlassStable(s) => s,
							SeverityType::GlassHelp(s) => s,
							SeverityType::GlassSuggestion(s) => s,
							SeverityType::GlassNote(s) => s,
							SeverityType::GlassFracture(s) => s,
							SeverityType::GlassWarp(s) => s,
							SeverityType::GlassShattered(s) => s,
							SeverityType::GlassCracked(s) => { s }
						}
					}
				}
				/// Its expected that this enum will grow in size, Entropy Termination
				/// contains multiple possible failure modes depending on callers context
				/// and the env at the time of calling.
				/// For every new addition inside, enums nested in SeverityCause should end in their own leaf structs eventually.
				/// Enums should be used for organization and Daemonic Nesting, structured
				/// error returns should be enforced from here down to ensure that handlers
				/// are always consistent across context stacks.
				pub enum SeverityCause {
					EntropyTermination(entropy::EntropyTermination),
				}
				use crate::daemonic::daemonic_contract::daemonic_result::mirror_chemistry::elements::{SPECULAR, ABSORPTIVE};
				pub(crate) struct GlassStable;
				pub(crate) struct GlassHelp;
				pub(crate) struct GlassSuggestion;
				pub(crate) struct GlassNote;
				pub(crate) struct GlassFracture;
				pub(crate) struct GlassWarp;
				pub(crate) struct GlassShattered;
				pub(crate) struct GlassCracked;
				pub(crate) mod entropy;

				pub(crate) struct SeverityContext<SEVERITY: Severity> {
					pub state: SEVERITY,
					pub cause: SeverityCause,
					pub recoverable_here: bool,
				}
			}
			pub(crate) use diagnostic::DiagnosticLevel;
		}
		pub(crate) mod partial_types {
			use std::marker::PhantomPinned;
			/// this module is currently stubbed out but will eventually provide the role of
			/// result<Partial> type output, which can have strange behavior at runtime
			/// depending on the nature of the application being built.
			/// Partial states carry some possibly corrupted Glass State objects + whatever
			/// the DaemonicError system was able to capture before the Glass Shattered under
			/// the walker.
			/// For simple applications that have sync states and no peers to manage, this is
			/// largely a non issue. But for a more complex async managed state machine, partial
			/// states can be complex as fuck. Daemonic logic accounts for this in theory.
			/// Eventually, the theory made manifest will exist here when a situation arises
			/// that constrains build requirements enough to construct this module.
			fn dummy() -> PhantomPinned {
				PhantomPinned
			}
		}
	}
	pub(crate) struct DaemonicID<FORMAT, PARTIAL> {
		id: u32,
		nickname: Option<dyn DaemonicBinary<FORMAT, PARTIAL, Error=impl DaemonicError<FORMAT, PARTIAL>>>,
	}

}
//todo :: step through and find where all these are being tripped and document for the why.
//! ═══════════════════════════════════════════════════════════════
//! DAEMONIC ERROR - Root Error Crate
//! ═══════════════════════════════════════════════════════════════
//!
//! Architecture: Daemonic Nesting, more formally Dimensional Nesting.
//! DaemonicError now provides concrete Symbol and Type tree for resolution and construction.
//! Supertraits that are above or lateral to DaemonicError will remain where they are.
//! Supertraits that might be employed by other crates will exist here in DaemonicError first.
//! Structures will mirror DaemonicError, not the other way around.
//!
//!   DaemonicError: Top-level enum. Load-bearing. All crates depend on this. TODO:: DaemonicError Supertrait and mirrored hierarchy, all enums branches should end in structs as leaf nodes
//!   ├── Os(OsError):          Syscall, IO, file, memory, process (partially used, waiting for impl)
//!   ├── Symbolic(SymbolicError): Glass, Walk, DB, Lie states, topology
//!   ├── Ntp(NtpError):        Temporal sync, peer discovery, protocol (unused, waiting for impl)
//!   ├── Network / Protocol:   Raw wire-level failures (unused, waiting for impl)
//!   ├── Parse / Config:       Input validation
//!   ├── Mesh:                 Peer-to-peer failures
//!
//!
//!    Daemonic: (bottom-most trait)
//! 		  ├ DaemonicCore:
//!  		  │		├─: Position
//! 		  │		├─: Clock
//! 		  │		│	  └─: where Clock: DaemonicClock
//! 		  │		│						├─: Logical: LamportClock
//! 		  │		│						├─: Physical: WallClock (NTP, MTP, or Hardware)
//! 		  │		│						└─: Hybrid (Combination Clock)
//! 		  │		├───────────────────────────────────────: DaemonicObservation
//! 		  │		│												├─: Active: Toggled effects, constitutes state change from norm or baseline effect.
//! 		  │		│												└─: Passive: Always on, const or passive effects, functions, and types. Gravity and Time as passive examples.
//!   		  │		└─: UniqueID
//!  		  │
//!  		  ├ MirrorChemistry (More specific definitions coming soon, will be Trait)
//!  		  │		├─: Bonding
//!   		  │		├─: Stability
//!   		  │		├─: Elements
//!   		  │		└─: Table
//!  		  │
//! 		  └ DaemonicContract:
//! 					├─: Input type
//!  		 			│		└─: BinarySymbol(GENERIC: Can be bound to any wire format if DB unwanted) (DB has RAW type variant for arbitrary/unknown data)
//!   		 			│
//!   		 			│
//! 					└─: Output type
//!    		 					├─: BinarySymbol(GENERIC: Can be bound to any wire format if DB unwanted) (DB has RAW type variant for arbitrary/unknown data) + G (optional Generic) (BinarySymbol can be overridden)
//!    		 					└─: DaemonicError + C: ErrorContext + M: MetaData (Context required, MetaData optional <<< SUPERTRAIT
//!    		 							│				where C: ErrorContext (supertrait providing position/clock)
//!    		 							└─: ErrorType + S {LITERALLY THIS STRUCTURE. PICK THE TYPE BASED ON WHERE YOU ARE IN THE LATTICE.}			Note: All types no matter if they are fallible or not must implement DaemonicError type, even for types that dont produce errors.
//!    		 			   					  │		 where   																						Note: For stubbed impls or functions that legitimately return nothing, `use silent()` variant, else use ``[DaemonicError::Symbolic::SymbolicError::ImpossibleState]
//!    		 			 					  │
//!    		 			 					  ├─: S: Severity (These are all Types, not Enums)
//!    		 								  │			├─: GlassStable <-> Specular Mirror
//!    		 								  │			├─: GlassHelp <-> Selective (positive) Mirror
//!    		 								  │			├─: GlassSuggestion <-> Selective (constructive) Mirror
//!    		 								  │			├─: GlassFractured <-> Lossy Mirror
//!    		 								  │			├─: GlassWarped <-> Transformative Mirror (NON-REVERSABLE)
//!    		 								  │			├─: GlassShattered <-> Absorbative
//!    		 								  │
//!   		 								  └: ErrorMessages {Lattice Mirror}
//!		Entity tree is broken, currently being redone
//! 		───: Entity
//!  			  │	  └─:BrokenSword (Method: Self-aware death declaration with stack dump)
//!  			  │
//!   			  └───── Shade:
//!   		    			└───┬──: Bootstrap (Method: Todo: move bootstrap logic from wherever the fuck it is to traits folder in shade)
//! 							├──: REPL (method)
//! 							├──: Ingestion (method)
//! 							├──: SymbolConstructor (method)
//! 		  					├──: DaemonicCompiler::Rust (method)
//! 							│		├──: Hashes
//!  							│		├──: Arena
//! 		 					│		├──: Serialize
//! 		 					│		├──: Index
//! 		 					│		├──: Graphviz
//! 		 					│		├──: DataStructures
//!  							│		├──: Span
//! 		  					│		├──: ABI
//! 		  					│		├──: Lexer
//! 		  					│		├──: ASTIR
//! 		  					│		├──: AST
//! 		  					│		├──: ASTPretty
//! 		  					│		├──: BakedICUdata
//! 		   					│		├──: FSUtil
//! 		   					│		├──: Feature
//! 		   					│		├──: ParseFormat
//! 		   					│		├──: HIR
//! 		   					│		├──: AttrDataStructures
//! 		   					│		├──: LintDefs
//! 		   					│		├──: HIRPretty
//! 		   					│		├──: TypeIR
//! 		   					│		├──: NextTraitSolver
//! 		   					│		├──: Log
//! 		   					│		├──: Session
//!  		  					│		├──: GetOpts (this needs to die, but probably wont)
//! 		   					│		├──: DaemonicHashable
//! 		   					│		├──: Middle
//! 		   					│		├──: Query
//! 		   					│		├──: Transmute
//! 		   					│		├──: AttrParsing
//! 		   					│		├──: Parse
//! 		   					│		├──: ASTPasses
//! 		   					│		├──: Inflate
//! 		  			 		│		├──: ASTLowering
//!    	    					│		└──: TraitSelection
//! 							│
//! 							│
//! 							├──: Walker (Type)
//! 							│       ├──: FileWalker (Generic Walker variant for agnostic operations outside of rust)
//! 							│		├──: MemoryWalker
//! 							│		├──: MirrorWalker
//! 							│		├──: SysFSWalker
//! 							│		├──: ReconWalker
//! 							│		├──: NetworkWalker
//! 							│       └──: RustWalker
//!  							│       		└──:TypeWalker
//! 							└──: Clock
//!
//!
//!
//! Error output format (uniform across all variants): (pending update and merge with RustC Error)
//!   [DAEMONIC] {Module}::{Component} → {Context}
//!     ↳ {Source}  (if present)
//!
//! "daemonic_error" in output strings is intentional.
//! Differentiates Faustian stack errors from raw POSIX.
//! The shell is a Glass shell — error reporting leans into that.

use std::fmt::Debug;
use daemonic::{
	daemonic_core::{
		*,
		observation::{
			debug::{
				*,
			}
		},
	},
	daemonic_contract::{
		daemonic_result::{
			severity_types::*,
			mirror_chemistry::*,
			diagnostic::*,
			subdiagnostic::*,
		},
		*,
	},
};
pub use daemonic::{
	daemonic_contract::{
		daemonic_result::{
			subdiagnostic::{
				Subdiagnostic,
			},
			diagnostic::{
				DiagnosticLevel,
				DiagnosticContextHandle as DiagCtxtHandle,
				DiagnosticContextHandle,
				Diagnostic,
				Diag,
				DiagInner,
				DiagCtxt,
				IntoDiagArg,
				Subdiag,
				DiagArgValue,
				ErrorGuaranteed,
				FatalError,
				FatalErrorMarker,
			},
		}
	}
};

/// DaemonicError is specifically a specialization on the trait [DaemonicObservation]
/// Type parameters and lifetimes are named + qualified because error handling should be explicit and verbose not stubs, fight me on it.
/// Named Type Parameters should be enforced in DaemonicError at least, if not elsewhere.
/// `[CONTEXT: ErrorContext<'ERROR>]` field is required.
///
/// `[META: MetaData]` field is Generic and optional, bound at call site.
///
/// `[SEVERITY: GlassState]` is unique in that Severities returned can either be types or traits depending on their behavior
/// and the callers context.
///
#[allow(non_snake_case)]
pub trait DaemonicError<
	'ERROR, // Error lifetimes must be explicitly named (in this crate)
	FORMAT,
	PARTIAL,
	DIAGNOSTIC = dyn Diagnostic, // Optional
	SUBDIAGNOSTIC = dyn Subdiagnostic, // Optional
	CONTEXT = dyn ErrorContext, // Required
	SEVERITY = SeverityType, // Required
	META = dyn MetaData // Required
>:
DaemonicObservation<FORMAT, PARTIAL>
// + std::error::Error // DaemonicError is better than the default Error trait, will just reimplement what i havent already.
+ Send
+ Sync
+ Sized // this might not need to be here but i dont know yet.
+ core::fmt::Debug
// + std::fmt::Display // this has been cloned to DaemonicDisplay
+ ErrorContext<'ERROR>
+ 'ERROR
where
	CONTEXT: ErrorContext<'ERROR>,
	META: MetaData<'ERROR>,
	SEVERITY: GlassState<'ERROR>,
{
	/// Where are we in the Type Tree? Refer to ASCII structure in `lib.rs`
	// todo: This should probably be further up in the type tree, all things derived from Daemonic
	// todo: should use position in hindsight.
	#[must_use]
	fn position(&self) -> &Position;

	/// What was happening when the Emission was returned?
	#[must_use]
	fn context(&self) -> &CONTEXT;

	/// Severity is still in dev, but in short Severity returns a result that can be either a Type or a Trait
	/// depending on callers context, if Type -> handled elsewhere upstream
	/// if Trait -> then error has effect on program state or machine state and can be
	/// interacted with programmatically
	#[must_use]
	fn severity(&self) -> SEVERITY;

	fn wrap_in(self, parent_position: Position) -> Self;

	/// for rust specific structs that have span analogies, optional.
	/// Defaults to none if unused
	fn emit_diagnostic(&self) -> DIAGNOSTIC { None }

	/// For rust-specific structs that have span analogies, requires parent Diagnostic to anchor on.
	/// Also optional, requires Diagnostic first, SubDiagnostics emit inside Diagnostics (relatively)
	/// Defaults to none if unused
	fn emit_subdiagnostic(&self) -> SUBDIAGNOSTIC { None }

	/// Additional logic attached that could modify behavior if necessary (optional).
	/// Defaults to none if unused
	fn metadata(&self) -> &META { &None }

	// Optional/defaulted downstream to False if unused or not set deliberately
	fn is_recoverable(&self) -> bool {
		self.severity().is_recoverable() // todo: this is incomplete
	}
	/// Defaults to none if unused
	fn source_position(&self) -> Option<&Position> {
		None
	}
}
#[allow(non_snake_case)]
trait ErrorContext<'ERROR>: Send + Sync + 'ERROR {
	fn position(&self) -> &Position;
	fn timestamp(&self) -> Timestamp;
}
impl DaemonicError for DummyStruct {}
struct DummyStruct;
trait MetaData<'meta>: Send + Sync + 'meta {}
/// This trait is currently blank (stubbed) but will serve as a router point.
/// Structs nested inside Enums as leaves are implemented with DaemonicError to return
/// typed Errors and Severities for programmatic interaction.
/// This trait is used on the Enums themselves to describe where in the trait tree the errors originate
/// as they propagate up the stack to the base trait implemented at call site.
/// IE if full Daemonic pipe is implemented, then Errors propagated all the way up to Daemonic
/// from a deeply nested type should affix modules with whitesplace splits `::` -> which can then be
/// used later for Error Type walking.
pub trait EnumerationRouter {}

/// Sinon suggested:
/// Usage
/// rust```
/// impl Position {
///     pub const fn new(segments: &[&'static str]) -> Self {
///         Self { segments: SmallVec::from_slice(segments) }
///     }
///
///     pub fn depth(&self) -> usize {
///         self.segments.len()
///     }
///
///     pub fn prepend(&mut self, parent: &'static str) {
///         self.segments.insert(0, parent);
///     }
///
///     pub fn as_path(&self) -> String {
///         self.segments.join("::")
///     }
/// }
/// const TYPE_WALKER_POS: Position = Position::new(&[
///     "Shade", "Walker", "RustWalker", "TypeWalker"
/// ]);
///
/// SmallVec<[&'static str; 8]>:
/// ```
///
///   - Stack allocated for depth ≤ 8
///   - Heap only for deep nesting
///   - &'static str: no allocation for names
///   - Human readable at any depth
pub(crate) struct Position<'segments> {
	/// todo: this is a placeholder
	segments: Vec<&'segments str>,
}
pub(crate) struct Timestamp {
	/// placeholder
	timestamp: PhantomPinned,
}
impl MetaData<'_> for () {} // unit type default


use std::marker::{PhantomData, PhantomPinned};
pub use opaque_dependencies::termcolor::*;
use crate::daemonic::daemonic_core::observation::DaemonicObservation;

///SINON:
// "Concrete leverage points."
// WHAT TO REUSE:
//
// 1. THE COMBINE PATTERN
//
// Your error bonding:
//
// pub fn combine_errors(
//     a: &impl DaemonicErrorTrait,
//     b: &impl DaemonicErrorTrait,
// ) -> ErrorBondResult {
//     // Rule: Shattered dominates
//     if a.severity() == Severity::Shattered {
//         return ErrorBondResult::Dominated(a.into());
//     }
//     if b.severity() == Severity::Shattered {
//         return ErrorBondResult::Dominated(b.into());
//     }
//
//     // Rule: Stable is identity
//     if a.severity() == Severity::Stable {
//         return ErrorBondResult::Compound(b.into());
//     }
//
//     // Rule: Warped + Warped = unstable compound
//     if a.severity() == Severity::Warped && b.severity() == Severity::Warped {
//         return ErrorBondResult::Unstable(
//             compound(a, b),
//             DaemonicDuration::from_millis(100),
//         );
//     }
//
//     // Rule: Fractures stack
//     if a.severity() == Severity::Fractured && b.severity() == Severity::Fractured {
//         return ErrorBondResult::Compound(stack_fractures(a, b));
//     }
//
//     // etc...
// }
//
// 2. THE STABILITY ASSESSMENT
//
// pub fn assess_error_stability(error: &CompoundError) -> ErrorStability {
//     // Rule: Single severity = stable
//     if error.severities.len() == 1 {
//         return ErrorStability::Stable;
//     }
//
//     // Rule: Mixed Warped = metastable
//     if error.severities.contains(&Severity::Warped) {
//         return ErrorStability::Metastable {
//             perturbation_threshold: 0.1,
//         };
//     }
//
//     // Rule: Contains Shattered = unstable
//     if error.severities.contains(&Severity::Shattered) {
//         return ErrorStability::Unstable {
//             decay_to: extract_dominant(error),
//             half_life: DaemonicDuration::from_millis(50),
//         };
//     }
//
//     ErrorStability::Stable
// }
//
// 3. THE COMPOUND CLASSIFICATION
//
// pub enum ErrorGroup {
//     Noble,        // Single severity, minimal energy
//     Reactive,     // Will combine with other errors
//     Transitional, // Properties vary with context
//     Rare,         // Requires extreme conditions
//     Synthetic,    // Only artificially constructable
// }
//
// pub fn classify_error(error: &CompoundError) -> ErrorGroup {
//     match assess_error_stability(error) {
//         ErrorStability::Stable if error.energy_cost.is_minimal() => {
//             ErrorGroup::Noble
//         }
//         ErrorStability::Metastable { .. } => ErrorGroup::Reactive,
//         ErrorStability::Unstable { .. } => {
//             if contains_prophetic(error) {
//                 ErrorGroup::Rare
//             } else {
//                 ErrorGroup::Transitional
//             }
//         }
//         ErrorStability::Impossible => ErrorGroup::Synthetic,
//         _ => ErrorGroup::Transitional,
//     }
// }