refactor(workspace): enforce layered crate boundaries

crates/aether-admission-core/src/budget.rs

@@ -0,0 +1,106 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum DbClass {
+    None,
+    ForegroundRead,
+    ForegroundWrite,
+    Background,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum RedisLane {
+    None,
+    Fast,
+    Stream,
+    Admin,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub enum ResourceClass {
+    Interactive,
+    Streaming,
+    Upload,
+    Background,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+pub struct ResourceBudget {
+    pub request_permits: usize,
+    pub body_bytes: usize,
+    pub db_class: DbClass,
+    pub redis_lane: RedisLane,
+    pub upstream_permits: usize,
+    pub stream_permits: usize,
+}
+
+impl ResourceBudget {
+    pub const fn interactive() -> Self {
+        Self {
+            request_permits: 1,
+            body_bytes: 0,
+            db_class: DbClass::ForegroundRead,
+            redis_lane: RedisLane::Fast,
+            upstream_permits: 1,
+            stream_permits: 0,
+        }
+    }
+
+    pub const fn streaming() -> Self {
+        Self {
+            request_permits: 1,
+            body_bytes: 0,
+            db_class: DbClass::ForegroundWrite,
+            redis_lane: RedisLane::Fast,
+            upstream_permits: 1,
+            stream_permits: 1,
+        }
+    }
+
+    pub const fn for_class(class: ResourceClass) -> Self {
+        match class {
+            ResourceClass::Interactive => Self::interactive(),
+            ResourceClass::Streaming => Self::streaming(),
+            ResourceClass::Upload => Self {
+                body_bytes: 64 * 1024 * 1024,
+                ..Self::interactive()
+            },
+            ResourceClass::Background => Self {
+                request_permits: 1,
+                body_bytes: 0,
+                db_class: DbClass::Background,
+                redis_lane: RedisLane::Admin,
+                upstream_permits: 0,
+                stream_permits: 0,
+            },
+        }
+    }
+
+    pub fn validate(&self) -> Result<(), AdmissionConfigError> {
+        if self.request_permits == 0 {
+            return Err(AdmissionConfigError::ZeroRequestPermits);
+        }
+        if self.upstream_permits == 0 && self.stream_permits > 0 {
+            return Err(AdmissionConfigError::StreamWithoutUpstream);
+        }
+        Ok(())
+    }
+}
+
+#[derive(Debug, thiserror::Error, PartialEq, Eq)]
+pub enum AdmissionConfigError {
+    #[error("admission budget must reserve at least one request permit")]
+    ZeroRequestPermits,
+    #[error("stream permits require an upstream permit")]
+    StreamWithoutUpstream,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::ResourceBudget;
+
+    #[test]
+    fn streaming_budget_has_valid_upstream_shape() {
+        assert!(ResourceBudget::streaming().validate().is_ok());
+    }
+}

crates/aether-admission-core/src/lib.rs

@@ -0,0 +1,18 @@
+//! Transport-independent admission contracts.
+//!
+//! This crate deliberately contains no Tokio, HTTP client, database, or Redis
+//! dependency. Runtime adapters can implement the decisions without pulling
+//! the gateway's infrastructure graph into domain crates.
+
+mod budget;
+mod metrics;
+mod permit;
+mod policy;
+
+pub use budget::{AdmissionConfigError, DbClass, RedisLane, ResourceBudget, ResourceClass};
+pub use metrics::AdmissionMetricsSnapshot;
+pub use permit::{PermitKind, RequestPermitSet};
+pub use policy::{
+    AdmissionDecision, AdmissionPolicy, AdmissionRejectReason, AdmissionRequest,
+    DefaultAdmissionPolicy,
+};

crates/aether-admission-core/src/metrics.rs

@@ -0,0 +1,7 @@
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub struct AdmissionMetricsSnapshot {
+    pub admitted_total: u64,
+    pub rejected_total: u64,
+    pub saturated_total: u64,
+    pub queue_deadline_exceeded_total: u64,
+}

crates/aether-admission-core/src/permit.rs

@@ -0,0 +1,32 @@
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PermitKind {
+    Request,
+    Body,
+    Planning,
+    Database,
+    Upstream,
+    Stream,
+}
+
+#[derive(Debug)]
+pub struct RequestPermitSet<Permit> {
+    pub request: Permit,
+    pub body: Option<Permit>,
+    pub planning: Option<Permit>,
+    pub db: Option<Permit>,
+    pub upstream: Option<Permit>,
+    pub stream: Option<Permit>,
+}
+
+impl<Permit> RequestPermitSet<Permit> {
+    pub fn new(request: Permit) -> Self {
+        Self {
+            request,
+            body: None,
+            planning: None,
+            db: None,
+            upstream: None,
+            stream: None,
+        }
+    }
+}

crates/aether-admission-core/src/policy.rs

@@ -0,0 +1,64 @@
+use crate::{ResourceBudget, ResourceClass};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct AdmissionRequest<'a> {
+    pub trace_id: &'a str,
+    pub class: ResourceClass,
+    pub body_bytes: usize,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AdmissionDecision {
+    Admit(ResourceBudget),
+    Reject(AdmissionRejectReason),
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AdmissionRejectReason {
+    InvalidRequest,
+    BodyTooLarge,
+    ResourceSaturated,
+    QueueDeadlineExceeded,
+}
+
+pub trait AdmissionPolicy: Send + Sync {
+    fn decide(&self, request: AdmissionRequest<'_>) -> AdmissionDecision;
+}
+
+#[derive(Debug, Clone, Copy, Default)]
+pub struct DefaultAdmissionPolicy;
+
+impl AdmissionPolicy for DefaultAdmissionPolicy {
+    fn decide(&self, request: AdmissionRequest<'_>) -> AdmissionDecision {
+        if request.trace_id.trim().is_empty() {
+            return AdmissionDecision::Reject(AdmissionRejectReason::InvalidRequest);
+        }
+        let budget = ResourceBudget::for_class(request.class);
+        if budget.body_bytes > 0 && request.body_bytes > budget.body_bytes {
+            return AdmissionDecision::Reject(AdmissionRejectReason::BodyTooLarge);
+        }
+        AdmissionDecision::Admit(budget)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{
+        AdmissionDecision, AdmissionPolicy, AdmissionRejectReason, AdmissionRequest,
+        DefaultAdmissionPolicy,
+    };
+    use crate::ResourceClass;
+
+    #[test]
+    fn default_policy_rejects_empty_trace_ids() {
+        let decision = DefaultAdmissionPolicy.decide(AdmissionRequest {
+            trace_id: " ",
+            class: ResourceClass::Interactive,
+            body_bytes: 0,
+        });
+        assert_eq!(
+            decision,
+            AdmissionDecision::Reject(AdmissionRejectReason::InvalidRequest)
+        );
+    }
+}