siderust-js 0.1.0

package/qtty-js/qtty/qtty-core/Cargo.toml

@@ -0,0 +1,41 @@
+[package]
+name = "qtty-core"
+description = "Core types for zero-cost strongly-typed physical quantities."
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+license.workspace = true
+repository.workspace = true
+keywords.workspace = true
+categories.workspace = true
+readme = "README.md"
+documentation = "https://docs.rs/qtty-core"
+
+[features]
+default = ["std", "cross-unit-ops"]
+std = []
+cross-unit-ops = []
+serde = ["dep:serde"]
+
+# Optional support
+scalar-decimal = ["rust_decimal"]
+scalar-rational = ["num-rational"]
+pyo3 = ["dep:pyo3"]
+tiberius = ["dep:tiberius"]
+diesel = ["dep:diesel"]
+
+[dependencies]
+rust_decimal = { version = "1.36", optional = true, features = ["maths"] }
+num-rational = { version = "0.4", optional = true, default-features = false }
+serde = { version = "1.0", default-features = false, features = ["derive", "alloc"], optional = true }
+pyo3 = { version = "0.28.2", optional = true, features = ["auto-initialize"] }
+tiberius = { version = "0.12", default-features = false, optional = true }
+diesel = { version = "2.1", default-features = false, optional = true }
+libm = "0.2"
+typenum = "1.17"
+qtty-derive = { version = "0.4.0", path = "../qtty-derive" }
+
+[dev-dependencies]
+approx = "0.5"
+proptest = "1.4"
+serde_json = "1.0"

package/qtty-js/qtty/qtty-core/README.md

@@ -0,0 +1,8 @@
+# qtty-core crate
+
+Centralized documentation lives under the repository `doc/` tree.
+
+- Workspace overview: [`../../doc/users/rust-workspace.md`](../../doc/users/rust-workspace.md)
+- Repository layout: [`../../doc/architecture/repository-layout.md`](../../doc/architecture/repository-layout.md)
+
+This README remains as the crate metadata entrypoint.

package/qtty-js/qtty/qtty-core/examples/diesel_integration.rs

@@ -0,0 +1,145 @@
+//! Example showing how to use `qtty_core::Quantity` types with Diesel ORM.
+//!
+//! This example demonstrates:
+//! - Using `Quantity<U>` types (e.g., `Degrees`, `Meters`) directly in Diesel models
+//! - Automatic serialization/deserialization to/from SQL DOUBLE PRECISION columns
+//! - Type-safe queries with strongly-typed physical quantities
+//!
+//! # Running this example
+//!
+//! ```bash
+//! cargo run -p qtty-core --example diesel_integration --features diesel
+//! ```
+//!
+//! Note: This is a conceptual example showing the API usage. For a real database integration,
+//! you would need to set up an actual database connection and schema.
+
+#[cfg(feature = "diesel")]
+fn main() {
+    use qtty_core::angular::Degrees;
+    use qtty_core::length::Meters;
+
+    println!("=== Diesel ORM Integration Example ===\n");
+
+    // Example 1: Conceptual Diesel model using Quantity types
+    println!("1. Diesel Model with Quantity Types:\n");
+
+    #[derive(Debug)]
+    #[allow(dead_code)]
+    struct Observatory {
+        id: i32,
+        name: String,
+        latitude: Degrees,  // Instead of f64!
+        longitude: Degrees, // Type-safe angles
+        elevation: Meters,  // Type-safe length
+    }
+
+    let obs = Observatory {
+        id: 1,
+        name: "Mauna Kea".to_string(),
+        latitude: Degrees::new(19.8207),
+        longitude: Degrees::new(-155.4681),
+        elevation: Meters::new(4207.0),
+    };
+
+    println!("Observatory: {}", obs.name);
+    println!(
+        "  Location: {:.4}° N, {:.4}° W",
+        obs.latitude.value(),
+        obs.longitude.value().abs()
+    );
+    println!("  Elevation: {:.0} m", obs.elevation.value());
+
+    // Example 2: Type conversion
+    println!("\n2. Type Conversions:");
+    use qtty_core::angular::Radians;
+    use qtty_core::length::Kilometers;
+
+    let lat_rad: Radians = obs.latitude.to();
+    let elev_km: Kilometers = obs.elevation.to();
+
+    println!("  Latitude: {:.6} rad", lat_rad.value());
+    println!("  Elevation: {:.3} km", elev_km.value());
+
+    // Example 3: Conceptual schema definition
+    println!("\n3. Conceptual Diesel Schema:");
+    println!(
+        r#"
+    // In your Diesel schema.rs:
+    table! {{
+        observatories (id) {{
+            id -> Int4,
+            name -> Text,
+            latitude -> Float8,   // Maps to qtty::Degrees
+            longitude -> Float8,  // Maps to qtty::Degrees
+            elevation -> Float8,  // Maps to qtty::Meters
+        }}
+    }}
+
+    // In your models.rs:
+    use qtty::{{Degrees, Meters}};
+    
+    #[derive(Queryable, Selectable)]
+    #[diesel(table_name = observatories)]
+    pub struct Observatory {{
+        pub id: i32,
+        pub name: String,
+        pub latitude: Degrees,   // Direct use of Quantity types!
+        pub longitude: Degrees,
+        pub elevation: Meters,
+    }}
+
+    #[derive(Insertable)]
+    #[diesel(table_name = observatories)]
+    pub struct NewObservatory {{
+        pub name: String,
+        pub latitude: Degrees,
+        pub longitude: Degrees,
+        pub elevation: Meters,
+    }}
+    "#
+    );
+
+    // Example 4: Optional fields
+    println!("\n4. Optional Quantity Fields:");
+
+    #[derive(Debug)]
+    #[allow(dead_code)]
+    struct Telescope {
+        id: i32,
+        name: String,
+        min_altitude: Option<Degrees>, // Optional constraint
+        max_altitude: Option<Degrees>,
+    }
+
+    let telescope = Telescope {
+        id: 1,
+        name: "Keck I".to_string(),
+        min_altitude: Some(Degrees::new(15.0)),
+        max_altitude: Some(Degrees::new(85.0)),
+    };
+
+    println!("Telescope: {}", telescope.name);
+    if let Some(min_alt) = telescope.min_altitude {
+        println!("  Min altitude: {}°", min_alt.value());
+    }
+    if let Some(max_alt) = telescope.max_altitude {
+        println!("  Max altitude: {}°", max_alt.value());
+    }
+
+    // Example 5: Benefits summary
+    println!("\n5. Benefits of Using Quantity Types:");
+    println!("  ✓ Compile-time unit checking");
+    println!("  ✓ No manual unit conversions in database layer");
+    println!("  ✓ Self-documenting code (field type shows units)");
+    println!("  ✓ Automatic serialization/deserialization");
+    println!("  ✓ Zero runtime overhead (newtype pattern)");
+
+    println!("\n=== Example Complete ===");
+}
+
+#[cfg(not(feature = "diesel"))]
+fn main() {
+    println!("This example requires the 'diesel' feature to be enabled.");
+    println!("Run with: cargo run -p qtty-core --example diesel_integration --features diesel");
+}

package/qtty-js/qtty/qtty-core/examples/quantity_db_serde.rs

@@ -0,0 +1,215 @@
+//! Example showing how to use `qtty_core::Quantity` types with `serde` and (optionally) Tiberius DB.
+//!
+//! This demonstrates:
+//! - Default serde behavior: `Quantity<U>` serializes as a raw `f64` by default
+//! - `qtty_core::serde_with_unit`: serialize with unit information using `#[serde(with = "...")]`
+//! - `tiberius` feature: bind/extract `Quantity<U>` directly (conceptual example)
+//!
+//! Run with:
+//! - `cargo run -p qtty-core --example quantity_db_serde --features serde`
+//! - `cargo run -p qtty-core --example quantity_db_serde --features serde,tiberius`
+
+#[cfg(feature = "serde")]
+use qtty_core::angular::Degrees;
+#[cfg(feature = "serde")]
+use qtty_core::time::Seconds;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Example 1: Serde with default f64 serialization
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[cfg(feature = "serde")]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+struct SchedulingConstraints {
+    /// Minimum altitude in degrees (serializes as raw f64 by default)
+    pub min_altitude: Degrees,
+
+    /// Maximum altitude in degrees (serializes as raw f64 by default)
+    pub max_altitude: Degrees,
+
+    /// Minimum azimuth in degrees (serializes as raw f64 by default)
+    pub min_azimuth: Degrees,
+
+    /// Maximum azimuth in degrees (serializes as raw f64 by default)
+    pub max_azimuth: Degrees,
+
+    /// Minimum observation time in seconds (serializes as raw f64 by default)
+    pub min_observation_time: Seconds,
+}
+
+#[cfg(feature = "serde")]
+fn example_serde() {
+    println!("=== Default Serde Example (compact f64) ===\n");
+
+    // Create constraints with typed quantities
+    let constraints = SchedulingConstraints {
+        min_altitude: Degrees::new(30.0),
+        max_altitude: Degrees::new(90.0),
+        min_azimuth: Degrees::new(0.0),
+        max_azimuth: Degrees::new(360.0),
+        min_observation_time: Seconds::new(1200.0),
+    };
+
+    // Serialize to JSON (as raw f64 values - compact!)
+    let json = serde_json::to_string_pretty(&constraints).unwrap();
+    println!("Serialized JSON:\n{}\n", json);
+
+    // Deserialize back
+    let parsed: SchedulingConstraints = serde_json::from_str(&json).unwrap();
+    println!("Deserialized successfully!");
+    assert_eq!(
+        constraints.min_altitude.value(),
+        parsed.min_altitude.value()
+    );
+    println!("✓ Round-trip successful\n");
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Example 1b: Serde with unit information (for self-documenting APIs)
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[cfg(feature = "serde")]
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+struct ConfigWithUnits {
+    /// Maximum speed with unit information preserved
+    #[serde(with = "qtty_core::serde_with_unit")]
+    pub max_altitude: Degrees,
+}
+
+#[cfg(feature = "serde")]
+fn example_serde_with_unit() {
+    println!("=== Serde with Unit Information (self-documenting) ===\n");
+
+    let config = ConfigWithUnits {
+        max_altitude: Degrees::new(90.0),
+    };
+
+    // Serialize to JSON with unit information
+    let json = serde_json::to_string_pretty(&config).unwrap();
+    println!("Serialized JSON:\n{}\n", json);
+    println!("✓ Unit symbol preserved in output for clarity!\n");
+
+    // Deserialize back
+    let parsed: ConfigWithUnits = serde_json::from_str(&json).unwrap();
+    assert_eq!(config.max_altitude.value(), parsed.max_altitude.value());
+    println!("✓ Round-trip successful\n");
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Example 2: Direct DB usage (conceptual - requires actual DB connection)
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[cfg(all(feature = "serde", feature = "tiberius"))]
+fn example_tiberius_concept() {
+    println!("=== Tiberius DB Example (conceptual) ===\n");
+
+    // In real code, you would:
+    // 1. Bind Quantity types directly to queries:
+    println!("// Binding Quantity to query:");
+    println!("let min_alt = Degrees::new(30.0);");
+    println!("query.bind(min_alt);  // Works directly!\n");
+
+    // 2. Extract Quantity types from result rows:
+    println!("// Extracting Quantity from DB row:");
+    println!("let altitude: Degrees = row.try_get(\"altitude\")?.unwrap();");
+    println!("// No manual f64 → Degrees conversion needed!\n");
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Example 3: Migration comparison
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[cfg(feature = "serde")]
+fn example_migration_comparison() {
+    println!("=== Migration Comparison ===\n");
+
+    // Old approach: store as f64, convert on access
+    struct OldConstraints {
+        min_alt: f64,
+        max_alt: f64,
+    }
+
+    impl OldConstraints {
+        fn min_alt(&self) -> Degrees {
+            Degrees::new(self.min_alt)
+        }
+
+        fn max_alt(&self) -> Degrees {
+            Degrees::new(self.max_alt)
+        }
+    }
+
+    let old = OldConstraints {
+        min_alt: 30.0,
+        max_alt: 90.0,
+    };
+
+    println!("Old approach:");
+    println!("  - Store: f64");
+    println!("  - Access: .min_alt() -> Degrees");
+    println!(
+        "  - Values: {}..{} degrees\n",
+        old.min_alt().value(),
+        old.max_alt().value()
+    );
+
+    // New approach: store as Quantity directly
+    #[derive(Serialize, Deserialize)]
+    struct NewConstraints {
+        min_alt: Degrees,
+        max_alt: Degrees,
+    }
+
+    let new = NewConstraints {
+        min_alt: Degrees::new(30.0),
+        max_alt: Degrees::new(90.0),
+    };
+
+    println!("New approach:");
+    println!("  - Store: Degrees (typed!)");
+    println!("  - Access: .min_alt (direct)");
+    println!(
+        "  - Values: {}..{} degrees",
+        new.min_alt.value(),
+        new.max_alt.value()
+    );
+    println!("  ✓ No conversion methods needed!");
+    println!("  ✓ Type safety at compile time!\n");
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Main
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[cfg(feature = "serde")]
+fn run() {
+    println!("\n╔═══════════════════════════════════════════════════════╗");
+    println!("║  qtty-core: Serde and DB Integration Examples         ║");
+    println!("╚═══════════════════════════════════════════════════════╝\n");
+
+    example_serde();
+    example_serde_with_unit();
+
+    #[cfg(feature = "tiberius")]
+    example_tiberius_concept();
+
+    example_migration_comparison();
+
+    println!("═══════════════════════════════════════════════════════");
+    println!("All examples completed successfully!");
+    println!("═══════════════════════════════════════════════════════\n");
+}
+
+fn main() {
+    #[cfg(feature = "serde")]
+    {
+        run();
+    }
+
+    #[cfg(not(feature = "serde"))]
+    {
+        eprintln!("This example requires `--features serde`.");
+    }
+}

package/qtty-js/qtty/qtty-core/src/dimension.rs

@@ -0,0 +1,249 @@
+//! Dimension types and traits.
+//!
+//! Dimensions are modelled as a single generic struct [`Dim`] parameterised by eight
+//! [`typenum`] signed integers representing the exponents of the fundamental physical
+//! dimensions. Multiplying two dimensions adds exponents; dividing subtracts them.
+//! Because typenum arithmetic resolves at compile time, compound types like `Length * Length`
+//! automatically become `Area` (exponent 2), and `Area / Length` collapses back to `Length`
+//! (exponent 1) — all verified by the type checker.
+//!
+//! # Layout
+//!
+//! The eight exponent slots are:
+//!
+//! | Position | Base quantity            | SI symbol |
+//! |----------|--------------------------|-----------|
+//! | `L`      | Length                   | m         |
+//! | `T`      | Time                     | s         |
+//! | `M`      | Mass                     | kg        |
+//! | `Th`     | Thermodynamic temperature| K         |
+//! | `I`      | Electric current         | A         |
+//! | `N`      | Amount of substance      | mol       |
+//! | `J`      | Luminous intensity       | cd        |
+//! | `A`      | Plane angle (auxiliary)  | rad/deg   |
+
+use core::marker::PhantomData;
+use core::ops::{Add, Sub};
+use typenum::Integer;
+
+/// Marker trait for **dimensions**.
+///
+/// Implemented automatically for every [`Dim<L,T,M,Th,I,N,J,A>`] whose type
+/// parameters satisfy the required bounds.
+pub trait Dimension: 'static {}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Core dimension struct
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// A physical dimension encoded as eight typenum integer exponents.
+///
+/// This is a zero-sized type: no runtime cost.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Dim<L, T, M, Th, I, N, J, A>(
+    PhantomData<L>,
+    PhantomData<T>,
+    PhantomData<M>,
+    PhantomData<Th>,
+    PhantomData<I>,
+    PhantomData<N>,
+    PhantomData<J>,
+    PhantomData<A>,
+)
+where
+    L: Integer,
+    T: Integer,
+    M: Integer,
+    Th: Integer,
+    I: Integer,
+    N: Integer,
+    J: Integer,
+    A: Integer;
+
+impl<L, T, M, Th, I, N, J, A> Dimension for Dim<L, T, M, Th, I, N, J, A>
+where
+    L: Integer + 'static,
+    T: Integer + 'static,
+    M: Integer + 'static,
+    Th: Integer + 'static,
+    I: Integer + 'static,
+    N: Integer + 'static,
+    J: Integer + 'static,
+    A: Integer + 'static,
+{
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Dimension multiplication (adds exponents)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Trait for multiplying two dimensions (adds exponents).
+pub trait DimMul<Rhs: Dimension>: Dimension {
+    /// The resulting dimension.
+    type Output: Dimension;
+}
+
+impl<L1, T1, M1, Th1, I1, N1, J1, A1, L2, T2, M2, Th2, I2, N2, J2, A2>
+    DimMul<Dim<L2, T2, M2, Th2, I2, N2, J2, A2>> for Dim<L1, T1, M1, Th1, I1, N1, J1, A1>
+where
+    L1: Integer + Add<L2> + 'static,
+    T1: Integer + Add<T2> + 'static,
+    M1: Integer + Add<M2> + 'static,
+    Th1: Integer + Add<Th2> + 'static,
+    I1: Integer + Add<I2> + 'static,
+    N1: Integer + Add<N2> + 'static,
+    J1: Integer + Add<J2> + 'static,
+    A1: Integer + Add<A2> + 'static,
+    L2: Integer + 'static,
+    T2: Integer + 'static,
+    M2: Integer + 'static,
+    Th2: Integer + 'static,
+    I2: Integer + 'static,
+    N2: Integer + 'static,
+    J2: Integer + 'static,
+    A2: Integer + 'static,
+    <L1 as Add<L2>>::Output: Integer + 'static,
+    <T1 as Add<T2>>::Output: Integer + 'static,
+    <M1 as Add<M2>>::Output: Integer + 'static,
+    <Th1 as Add<Th2>>::Output: Integer + 'static,
+    <I1 as Add<I2>>::Output: Integer + 'static,
+    <N1 as Add<N2>>::Output: Integer + 'static,
+    <J1 as Add<J2>>::Output: Integer + 'static,
+    <A1 as Add<A2>>::Output: Integer + 'static,
+{
+    type Output = Dim<
+        <L1 as Add<L2>>::Output,
+        <T1 as Add<T2>>::Output,
+        <M1 as Add<M2>>::Output,
+        <Th1 as Add<Th2>>::Output,
+        <I1 as Add<I2>>::Output,
+        <N1 as Add<N2>>::Output,
+        <J1 as Add<J2>>::Output,
+        <A1 as Add<A2>>::Output,
+    >;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Dimension division (subtracts exponents)
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Trait for dividing two dimensions (subtracts exponents).
+pub trait DimDiv<Rhs: Dimension>: Dimension {
+    /// The resulting dimension.
+    type Output: Dimension;
+}
+
+impl<L1, T1, M1, Th1, I1, N1, J1, A1, L2, T2, M2, Th2, I2, N2, J2, A2>
+    DimDiv<Dim<L2, T2, M2, Th2, I2, N2, J2, A2>> for Dim<L1, T1, M1, Th1, I1, N1, J1, A1>
+where
+    L1: Integer + Sub<L2> + 'static,
+    T1: Integer + Sub<T2> + 'static,
+    M1: Integer + Sub<M2> + 'static,
+    Th1: Integer + Sub<Th2> + 'static,
+    I1: Integer + Sub<I2> + 'static,
+    N1: Integer + Sub<N2> + 'static,
+    J1: Integer + Sub<J2> + 'static,
+    A1: Integer + Sub<A2> + 'static,
+    L2: Integer + 'static,
+    T2: Integer + 'static,
+    M2: Integer + 'static,
+    Th2: Integer + 'static,
+    I2: Integer + 'static,
+    N2: Integer + 'static,
+    J2: Integer + 'static,
+    A2: Integer + 'static,
+    <L1 as Sub<L2>>::Output: Integer + 'static,
+    <T1 as Sub<T2>>::Output: Integer + 'static,
+    <M1 as Sub<M2>>::Output: Integer + 'static,
+    <Th1 as Sub<Th2>>::Output: Integer + 'static,
+    <I1 as Sub<I2>>::Output: Integer + 'static,
+    <N1 as Sub<N2>>::Output: Integer + 'static,
+    <J1 as Sub<J2>>::Output: Integer + 'static,
+    <A1 as Sub<A2>>::Output: Integer + 'static,
+{
+    type Output = Dim<
+        <L1 as Sub<L2>>::Output,
+        <T1 as Sub<T2>>::Output,
+        <M1 as Sub<M2>>::Output,
+        <Th1 as Sub<Th2>>::Output,
+        <I1 as Sub<I2>>::Output,
+        <N1 as Sub<N2>>::Output,
+        <J1 as Sub<J2>>::Output,
+        <A1 as Sub<A2>>::Output,
+    >;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Base dimension aliases
+// ─────────────────────────────────────────────────────────────────────────────
+
+use typenum::{N1, N2, N3, P1, P2, P3, Z0};
+
+/// Dimensionless (all exponents zero).
+pub type Dimensionless = Dim<Z0, Z0, Z0, Z0, Z0, Z0, Z0, Z0>;
+
+/// Length (L¹).
+pub type Length = Dim<P1, Z0, Z0, Z0, Z0, Z0, Z0, Z0>;
+
+/// Time (T¹).
+pub type Time = Dim<Z0, P1, Z0, Z0, Z0, Z0, Z0, Z0>;
+
+/// Mass (M¹).
+pub type Mass = Dim<Z0, Z0, P1, Z0, Z0, Z0, Z0, Z0>;
+
+/// Thermodynamic temperature (Θ¹).
+pub type Temperature = Dim<Z0, Z0, Z0, P1, Z0, Z0, Z0, Z0>;
+
+/// Electric current (I¹).
+pub type Current = Dim<Z0, Z0, Z0, Z0, P1, Z0, Z0, Z0>;
+
+/// Amount of substance (N¹).
+pub type AmountOfSubstance = Dim<Z0, Z0, Z0, Z0, Z0, P1, Z0, Z0>;
+
+/// Luminous intensity (J¹).
+pub type LuminousIntensity = Dim<Z0, Z0, Z0, Z0, Z0, Z0, P1, Z0>;
+
+/// Plane angle (A¹) — treated as an independent dimension for type safety.
+pub type Angular = Dim<Z0, Z0, Z0, Z0, Z0, Z0, Z0, P1>;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Derived dimension aliases
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Area (L²).
+pub type Area = Dim<P2, Z0, Z0, Z0, Z0, Z0, Z0, Z0>;
+
+/// Volume (L³).
+pub type Volume = Dim<P3, Z0, Z0, Z0, Z0, Z0, Z0, Z0>;
+
+/// Velocity (L¹ · T⁻¹).
+pub type VelocityDim = Dim<P1, N1, Z0, Z0, Z0, Z0, Z0, Z0>;
+
+/// Acceleration (L¹ · T⁻²).
+pub type Acceleration = Dim<P1, N2, Z0, Z0, Z0, Z0, Z0, Z0>;
+
+/// Force (M¹ · L¹ · T⁻²).
+pub type Force = Dim<P1, N2, P1, Z0, Z0, Z0, Z0, Z0>;
+
+/// Energy (M¹ · L² · T⁻²).
+pub type Energy = Dim<P2, N2, P1, Z0, Z0, Z0, Z0, Z0>;
+
+/// Power (M¹ · L² · T⁻³).
+pub type Power = Dim<P2, N3, P1, Z0, Z0, Z0, Z0, Z0>;
+
+/// Frequency — angular per time (A¹ · T⁻¹).
+pub type FrequencyDim = Dim<Z0, N1, Z0, Z0, Z0, Z0, Z0, P1>;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Legacy compatibility alias
+// ─────────────────────────────────────────────────────────────────────────────
+
+/// Backward-compatible alias: `DivDim<N, D>` resolves to `<N as DimDiv<D>>::Output`.
+///
+/// This preserves source compatibility for code that previously used `DivDim<Length, Time>`.
+/// It now resolves to the same concrete type as the `Velocity` alias, since typenum
+/// arithmetic produces the identical `Dim<P1, N1, …>`.
+pub type DivDim<N, D> = <N as DimDiv<D>>::Output;
+
+/// Backward-compatible alias: `MulDim<A, B>` resolves to `<A as DimMul<B>>::Output`.
+pub type MulDim<A, B> = <A as DimMul<B>>::Output;