diff --git a/packages/dim-si/README.md b/packages/dim-si/README.md
index 86d3739..dbefc40 100644
--- a/packages/dim-si/README.md
+++ b/packages/dim-si/README.md
@@ -95,6 +95,31 @@ const speed = divide(kilometer(100), hour(2));
 _<a id="affine">\*</a> [Affine quantity](../dim-unit/README.md#affine-units) —
 zero point is arbitrary, which restricts valid operations._
 
+## Type Annotations
+
+Each quantity module exports a type for use in function signatures:
+
+```typescript
+import type { Length } from "@isentropic/dim-si/length";
+import type { Time } from "@isentropic/dim-si/time";
+import type { Velocity } from "@isentropic/dim-si/velocity";
+import { divide } from "@isentropic/dim-si/ops";
+
+function speed(d: Length, t: Time): Velocity {
+  return divide(d, t);
+}
+```
+
+Temperature has two types — `Temperature` for absolute values (affine) and
+`TemperatureDifference` for deltas (linear):
+
+```typescript
+import type {
+  Temperature,
+  TemperatureDifference,
+} from "@isentropic/dim-si/temperature";
+```
+
 ## Custom Scaled Units
 
 Use SI prefixes to create units not provided out of the box:
@@ -127,15 +152,18 @@ dimension:
     * @module
     */
 
-   import type { Jerk } from "@isentropic/dim-isq";
+   import type { Jerk as JerkDim } from "@isentropic/dim-isq";
+   import type { Linear } from "@isentropic/dim-unit";
    import { jerk } from "@isentropic/dim-isq";
-   import type { BaseUnit } from "./system.ts";
+   import type { BaseUnit } from "./types.ts";
+   import type { Si } from "./system.ts";
    import { si } from "./system.ts";
 
-   export type { Jerk } from "@isentropic/dim-isq";
+   /** An SI jerk quantity. */
+   export type Jerk = Linear<JerkDim, Si>;
 
    /** Meter per second cubed (m/s³) — SI unit of jerk. */
-   export const meterPerSecondCubed: BaseUnit<Jerk> = si.unit(jerk);
+   export const meterPerSecondCubed: BaseUnit<JerkDim> = si.unit(jerk);
    ```
 
    > **Note:** The quantity (`jerk`) must exist in `dim-isq` first. See the
diff --git a/packages/dim-si/src/absorbed-dose.ts b/packages/dim-si/src/absorbed-dose.ts
index 52173ee..9825997 100644
--- a/packages/dim-si/src/absorbed-dose.ts
+++ b/packages/dim-si/src/absorbed-dose.ts
@@ -17,15 +17,18 @@
  * @module
  */
 
-import type { AbsorbedDose } from "@isentropic/dim-isq";
+import type { AbsorbedDose as AbsorbedDoseDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { absorbedDose } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { AbsorbedDose } from "@isentropic/dim-isq";
+/** An SI absorbed dose quantity. */
+export type AbsorbedDose = Linear<AbsorbedDoseDim, Si>;
 
 /** Gray (Gy) — SI unit of absorbed dose. */
-export const gray: BaseUnit<AbsorbedDose> = si.unit(absorbedDose);
+export const gray: BaseUnit<AbsorbedDoseDim> = si.unit(absorbedDose);
 
 /** Sievert (Sv) — SI unit of equivalent dose (same dimension as gray). */
-export const sievert: BaseUnit<AbsorbedDose> = si.unit(absorbedDose);
+export const sievert: BaseUnit<AbsorbedDoseDim> = si.unit(absorbedDose);
diff --git a/packages/dim-si/src/acceleration.ts b/packages/dim-si/src/acceleration.ts
index 44b9a9d..3507e78 100644
--- a/packages/dim-si/src/acceleration.ts
+++ b/packages/dim-si/src/acceleration.ts
@@ -13,14 +13,17 @@
  * @module
  */
 
-import type { Acceleration } from "@isentropic/dim-isq";
+import type { Acceleration as AccelerationDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { acceleration } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Acceleration } from "@isentropic/dim-isq";
+/** An SI acceleration quantity. */
+export type Acceleration = Linear<AccelerationDim, Si>;
 
 /** Meter per second squared (m/s²) — SI unit of acceleration. */
-export const meterPerSecondSquared: BaseUnit<Acceleration> = si.unit(
+export const meterPerSecondSquared: BaseUnit<AccelerationDim> = si.unit(
   acceleration,
 );
diff --git a/packages/dim-si/src/amount.ts b/packages/dim-si/src/amount.ts
index 9486ebd..fad336e 100644
--- a/packages/dim-si/src/amount.ts
+++ b/packages/dim-si/src/amount.ts
@@ -15,19 +15,22 @@
  * @module
  */
 
-import type { Amount } from "@isentropic/dim-isq";
+import type { Amount as AmountDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { amount } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { MICRO, MILLI } from "./prefixes.ts";
 
-export type { Amount } from "@isentropic/dim-isq";
+/** An SI amount quantity. */
+export type Amount = Linear<AmountDim, Si>;
 
 /** Mole (mol) — SI unit of amount of substance. */
-export const mole: BaseUnit<Amount> = si.unit(amount);
+export const mole: BaseUnit<AmountDim> = si.unit(amount);
 
 /** Millimole (mmol) — 10⁻³ moles. */
-export const millimole: ScaledUnit<Amount> = mole.scaled(MILLI);
+export const millimole: ScaledUnit<AmountDim> = mole.scaled(MILLI);
 
 /** Micromole (μmol) — 10⁻⁶ moles. */
-export const micromole: ScaledUnit<Amount> = mole.scaled(MICRO);
+export const micromole: ScaledUnit<AmountDim> = mole.scaled(MICRO);
diff --git a/packages/dim-si/src/area.ts b/packages/dim-si/src/area.ts
index b7c592a..ecee908 100644
--- a/packages/dim-si/src/area.ts
+++ b/packages/dim-si/src/area.ts
@@ -15,15 +15,18 @@
  * @module
  */
 
-import type { Area } from "@isentropic/dim-isq";
+import type { Area as AreaDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { area } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Area } from "@isentropic/dim-isq";
+/** An SI area quantity. */
+export type Area = Linear<AreaDim, Si>;
 
 /** Square meter (m²) — SI unit of area. */
-export const squareMeter: BaseUnit<Area> = si.unit(area);
+export const squareMeter: BaseUnit<AreaDim> = si.unit(area);
 
 /** Hectare (ha) — 10000 square meters. */
-export const hectare: ScaledUnit<Area> = squareMeter.scaled(10000);
+export const hectare: ScaledUnit<AreaDim> = squareMeter.scaled(10000);
diff --git a/packages/dim-si/src/capacitance.ts b/packages/dim-si/src/capacitance.ts
index 66781b8..6b8ab1f 100644
--- a/packages/dim-si/src/capacitance.ts
+++ b/packages/dim-si/src/capacitance.ts
@@ -16,22 +16,25 @@
  * @module
  */
 
-import type { Capacitance } from "@isentropic/dim-isq";
+import type { Capacitance as CapacitanceDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { capacitance } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { MICRO, NANO, PICO } from "./prefixes.ts";
 
-export type { Capacitance } from "@isentropic/dim-isq";
+/** An SI capacitance quantity. */
+export type Capacitance = Linear<CapacitanceDim, Si>;
 
 /** Farad (F) — SI unit of capacitance. */
-export const farad: BaseUnit<Capacitance> = si.unit(capacitance);
+export const farad: BaseUnit<CapacitanceDim> = si.unit(capacitance);
 
 /** Microfarad (μF) — 10⁻⁶ farads. */
-export const microfarad: ScaledUnit<Capacitance> = farad.scaled(MICRO);
+export const microfarad: ScaledUnit<CapacitanceDim> = farad.scaled(MICRO);
 
 /** Nanofarad (nF) — 10⁻⁹ farads. */
-export const nanofarad: ScaledUnit<Capacitance> = farad.scaled(NANO);
+export const nanofarad: ScaledUnit<CapacitanceDim> = farad.scaled(NANO);
 
 /** Picofarad (pF) — 10⁻¹² farads. */
-export const picofarad: ScaledUnit<Capacitance> = farad.scaled(PICO);
+export const picofarad: ScaledUnit<CapacitanceDim> = farad.scaled(PICO);
diff --git a/packages/dim-si/src/catalytic-activity.ts b/packages/dim-si/src/catalytic-activity.ts
index 8070088..178a43f 100644
--- a/packages/dim-si/src/catalytic-activity.ts
+++ b/packages/dim-si/src/catalytic-activity.ts
@@ -13,12 +13,15 @@
  * @module
  */
 
-import type { CatalyticActivity } from "@isentropic/dim-isq";
+import type { CatalyticActivity as CatalyticActivityDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { catalyticActivity } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { CatalyticActivity } from "@isentropic/dim-isq";
+/** An SI catalytic activity quantity. */
+export type CatalyticActivity = Linear<CatalyticActivityDim, Si>;
 
 /** Katal (kat) — SI unit of catalytic activity. */
-export const katal: BaseUnit<CatalyticActivity> = si.unit(catalyticActivity);
+export const katal: BaseUnit<CatalyticActivityDim> = si.unit(catalyticActivity);
diff --git a/packages/dim-si/src/charge.ts b/packages/dim-si/src/charge.ts
index 9c4d70b..fc88adc 100644
--- a/packages/dim-si/src/charge.ts
+++ b/packages/dim-si/src/charge.ts
@@ -17,12 +17,15 @@
  * @module
  */
 
-import type { Charge } from "@isentropic/dim-isq";
+import type { Charge as ChargeDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { charge } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Charge } from "@isentropic/dim-isq";
+/** An SI charge quantity. */
+export type Charge = Linear<ChargeDim, Si>;
 
 /** Coulomb (C) — SI unit of electric charge. */
-export const coulomb: BaseUnit<Charge> = si.unit(charge);
+export const coulomb: BaseUnit<ChargeDim> = si.unit(charge);
diff --git a/packages/dim-si/src/conductance.ts b/packages/dim-si/src/conductance.ts
index a6fb2f0..3f4b2d8 100644
--- a/packages/dim-si/src/conductance.ts
+++ b/packages/dim-si/src/conductance.ts
@@ -13,12 +13,15 @@
  * @module
  */
 
-import type { Conductance } from "@isentropic/dim-isq";
+import type { Conductance as ConductanceDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { conductance } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Conductance } from "@isentropic/dim-isq";
+/** An SI conductance quantity. */
+export type Conductance = Linear<ConductanceDim, Si>;
 
 /** Siemens (S) — SI unit of electrical conductance. */
-export const siemens: BaseUnit<Conductance> = si.unit(conductance);
+export const siemens: BaseUnit<ConductanceDim> = si.unit(conductance);
diff --git a/packages/dim-si/src/current.ts b/packages/dim-si/src/current.ts
index a0f6aba..b091803 100644
--- a/packages/dim-si/src/current.ts
+++ b/packages/dim-si/src/current.ts
@@ -15,19 +15,22 @@
  * @module
  */
 
-import type { Current } from "@isentropic/dim-isq";
+import type { Current as CurrentDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { current } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { MICRO, MILLI } from "./prefixes.ts";
 
-export type { Current } from "@isentropic/dim-isq";
+/** An SI current quantity. */
+export type Current = Linear<CurrentDim, Si>;
 
 /** Ampere (A) — SI unit of electric current. */
-export const ampere: BaseUnit<Current> = si.unit(current);
+export const ampere: BaseUnit<CurrentDim> = si.unit(current);
 
 /** Milliampere (mA) — 10⁻³ amperes. */
-export const milliampere: ScaledUnit<Current> = ampere.scaled(MILLI);
+export const milliampere: ScaledUnit<CurrentDim> = ampere.scaled(MILLI);
 
 /** Microampere (μA) — 10⁻⁶ amperes. */
-export const microampere: ScaledUnit<Current> = ampere.scaled(MICRO);
+export const microampere: ScaledUnit<CurrentDim> = ampere.scaled(MICRO);
diff --git a/packages/dim-si/src/energy.ts b/packages/dim-si/src/energy.ts
index 4f8cec1..7ddf54d 100644
--- a/packages/dim-si/src/energy.ts
+++ b/packages/dim-si/src/energy.ts
@@ -16,27 +16,30 @@
  * @module
  */
 
-import type { Energy } from "@isentropic/dim-isq";
+import type { Energy as EnergyDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { energy } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { KILO, MEGA } from "./prefixes.ts";
 import { kilowatt } from "./power.ts";
 import { hour } from "./time.ts";
 
-export type { Energy } from "@isentropic/dim-isq";
+/** An SI energy quantity. */
+export type Energy = Linear<EnergyDim, Si>;
 
 /** Joule (J) — SI unit of energy. */
-export const joule: BaseUnit<Energy> = si.unit(energy);
+export const joule: BaseUnit<EnergyDim> = si.unit(energy);
 
 /** Kilojoule (kJ) — 1000 joules. */
-export const kilojoule: ScaledUnit<Energy> = joule.scaled(KILO);
+export const kilojoule: ScaledUnit<EnergyDim> = joule.scaled(KILO);
 
 /** Megajoule (MJ) — 10⁶ joules. */
-export const megajoule: ScaledUnit<Energy> = joule.scaled(MEGA);
+export const megajoule: ScaledUnit<EnergyDim> = joule.scaled(MEGA);
 
 /** Kilowatt-hour (kWh) — 3.6 megajoules. */
 // 1 kWh = 1 kW × 1 hour = 3.6 MJ
-export const kilowattHour: ScaledUnit<Energy> = joule.scaled(
+export const kilowattHour: ScaledUnit<EnergyDim> = joule.scaled(
   kilowatt.scale * hour.scale,
 );
diff --git a/packages/dim-si/src/force.ts b/packages/dim-si/src/force.ts
index 1b78086..a9fbce4 100644
--- a/packages/dim-si/src/force.ts
+++ b/packages/dim-si/src/force.ts
@@ -17,12 +17,15 @@
  * @module
  */
 
-import type { Force } from "@isentropic/dim-isq";
+import type { Force as ForceDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { force } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Force } from "@isentropic/dim-isq";
+/** An SI force quantity. */
+export type Force = Linear<ForceDim, Si>;
 
 /** Newton (N) — SI unit of force. */
-export const newton: BaseUnit<Force> = si.unit(force);
+export const newton: BaseUnit<ForceDim> = si.unit(force);
diff --git a/packages/dim-si/src/frequency.ts b/packages/dim-si/src/frequency.ts
index 4367cac..8a203fe 100644
--- a/packages/dim-si/src/frequency.ts
+++ b/packages/dim-si/src/frequency.ts
@@ -19,25 +19,28 @@
  * @module
  */
 
-import type { Frequency } from "@isentropic/dim-isq";
+import type { Frequency as FrequencyDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { frequency } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { GIGA, KILO, MEGA } from "./prefixes.ts";
 
-export type { Frequency } from "@isentropic/dim-isq";
+/** An SI frequency quantity. */
+export type Frequency = Linear<FrequencyDim, Si>;
 
 /** Hertz (Hz) — SI unit of frequency. */
-export const hertz: BaseUnit<Frequency> = si.unit(frequency);
+export const hertz: BaseUnit<FrequencyDim> = si.unit(frequency);
 
 /** Becquerel (Bq) — SI unit of radioactivity (same dimension as hertz). */
-export const becquerel: BaseUnit<Frequency> = si.unit(frequency);
+export const becquerel: BaseUnit<FrequencyDim> = si.unit(frequency);
 
 /** Kilohertz (kHz) — 1000 hertz. */
-export const kilohertz: ScaledUnit<Frequency> = hertz.scaled(KILO);
+export const kilohertz: ScaledUnit<FrequencyDim> = hertz.scaled(KILO);
 
 /** Megahertz (MHz) — 10⁶ hertz. */
-export const megahertz: ScaledUnit<Frequency> = hertz.scaled(MEGA);
+export const megahertz: ScaledUnit<FrequencyDim> = hertz.scaled(MEGA);
 
 /** Gigahertz (GHz) — 10⁹ hertz. */
-export const gigahertz: ScaledUnit<Frequency> = hertz.scaled(GIGA);
+export const gigahertz: ScaledUnit<FrequencyDim> = hertz.scaled(GIGA);
diff --git a/packages/dim-si/src/illuminance.ts b/packages/dim-si/src/illuminance.ts
index df7d064..d524d4f 100644
--- a/packages/dim-si/src/illuminance.ts
+++ b/packages/dim-si/src/illuminance.ts
@@ -13,12 +13,15 @@
  * @module
  */
 
-import type { Illuminance } from "@isentropic/dim-isq";
+import type { Illuminance as IlluminanceDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { illuminance } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Illuminance } from "@isentropic/dim-isq";
+/** An SI illuminance quantity. */
+export type Illuminance = Linear<IlluminanceDim, Si>;
 
 /** Lux (lx) — SI unit of illuminance. */
-export const lux: BaseUnit<Illuminance> = si.unit(illuminance);
+export const lux: BaseUnit<IlluminanceDim> = si.unit(illuminance);
diff --git a/packages/dim-si/src/inductance.ts b/packages/dim-si/src/inductance.ts
index c8f9494..c6ff01e 100644
--- a/packages/dim-si/src/inductance.ts
+++ b/packages/dim-si/src/inductance.ts
@@ -16,19 +16,22 @@
  * @module
  */
 
-import type { Inductance } from "@isentropic/dim-isq";
+import type { Inductance as InductanceDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { inductance } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { MICRO, MILLI } from "./prefixes.ts";
 
-export type { Inductance } from "@isentropic/dim-isq";
+/** An SI inductance quantity. */
+export type Inductance = Linear<InductanceDim, Si>;
 
 /** Henry (H) — SI unit of inductance. */
-export const henry: BaseUnit<Inductance> = si.unit(inductance);
+export const henry: BaseUnit<InductanceDim> = si.unit(inductance);
 
 /** Millihenry (mH) — 10⁻³ henrys. */
-export const millihenry: ScaledUnit<Inductance> = henry.scaled(MILLI);
+export const millihenry: ScaledUnit<InductanceDim> = henry.scaled(MILLI);
 
 /** Microhenry (μH) — 10⁻⁶ henrys. */
-export const microhenry: ScaledUnit<Inductance> = henry.scaled(MICRO);
+export const microhenry: ScaledUnit<InductanceDim> = henry.scaled(MICRO);
diff --git a/packages/dim-si/src/length.ts b/packages/dim-si/src/length.ts
index b67bca7..10ac863 100644
--- a/packages/dim-si/src/length.ts
+++ b/packages/dim-si/src/length.ts
@@ -16,31 +16,34 @@
  * @module
  */
 
-import type { Length } from "@isentropic/dim-isq";
+import type { Length as LengthDim } from "@isentropic/dim-isq";
 import { length } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { CENTI, KILO, MICRO, MILLI, NANO, PICO } from "./prefixes.ts";
 
-export type { Length } from "@isentropic/dim-isq";
+/** An SI length quantity. */
+export type Length = Linear<LengthDim, Si>;
 
 /** Meter (m) — SI unit of length. */
-export const meter: BaseUnit<Length> = si.unit(length);
+export const meter: BaseUnit<LengthDim> = si.unit(length);
 
 /** Kilometer (km) — 1000 meters. */
-export const kilometer: ScaledUnit<Length> = meter.scaled(KILO);
+export const kilometer: ScaledUnit<LengthDim> = meter.scaled(KILO);
 
 /** Centimeter (cm) — 0.01 meters. */
-export const centimeter: ScaledUnit<Length> = meter.scaled(CENTI);
+export const centimeter: ScaledUnit<LengthDim> = meter.scaled(CENTI);
 
 /** Millimeter (mm) — 0.001 meters. */
-export const millimeter: ScaledUnit<Length> = meter.scaled(MILLI);
+export const millimeter: ScaledUnit<LengthDim> = meter.scaled(MILLI);
 
 /** Micrometer (μm) — 10⁻⁶ meters. */
-export const micrometer: ScaledUnit<Length> = meter.scaled(MICRO);
+export const micrometer: ScaledUnit<LengthDim> = meter.scaled(MICRO);
 
 /** Nanometer (nm) — 10⁻⁹ meters. */
-export const nanometer: ScaledUnit<Length> = meter.scaled(NANO);
+export const nanometer: ScaledUnit<LengthDim> = meter.scaled(NANO);
 
 /** Picometer (pm) — 10⁻¹² meters. */
-export const picometer: ScaledUnit<Length> = meter.scaled(PICO);
+export const picometer: ScaledUnit<LengthDim> = meter.scaled(PICO);
diff --git a/packages/dim-si/src/luminosity.ts b/packages/dim-si/src/luminosity.ts
index ae87bdf..9f925a6 100644
--- a/packages/dim-si/src/luminosity.ts
+++ b/packages/dim-si/src/luminosity.ts
@@ -13,12 +13,15 @@
  * @module
  */
 
-import type { Luminosity } from "@isentropic/dim-isq";
+import type { Luminosity as LuminosityDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { luminosity } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Luminosity } from "@isentropic/dim-isq";
+/** An SI luminosity quantity. */
+export type Luminosity = Linear<LuminosityDim, Si>;
 
 /** Candela (cd) — SI unit of luminous intensity. */
-export const candela: BaseUnit<Luminosity> = si.unit(luminosity);
+export const candela: BaseUnit<LuminosityDim> = si.unit(luminosity);
diff --git a/packages/dim-si/src/luminous-flux.ts b/packages/dim-si/src/luminous-flux.ts
index c53278b..c25c9a0 100644
--- a/packages/dim-si/src/luminous-flux.ts
+++ b/packages/dim-si/src/luminous-flux.ts
@@ -13,12 +13,15 @@
  * @module
  */
 
-import type { LuminousFlux } from "@isentropic/dim-isq";
+import type { LuminousFlux as LuminousFluxDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { luminousFlux } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { LuminousFlux } from "@isentropic/dim-isq";
+/** An SI luminous flux quantity. */
+export type LuminousFlux = Linear<LuminousFluxDim, Si>;
 
 /** Lumen (lm) — SI unit of luminous flux. */
-export const lumen: BaseUnit<LuminousFlux> = si.unit(luminousFlux);
+export const lumen: BaseUnit<LuminousFluxDim> = si.unit(luminousFlux);
diff --git a/packages/dim-si/src/magnetic-flux-density.ts b/packages/dim-si/src/magnetic-flux-density.ts
index 3263d74..e50cb78 100644
--- a/packages/dim-si/src/magnetic-flux-density.ts
+++ b/packages/dim-si/src/magnetic-flux-density.ts
@@ -13,14 +13,17 @@
  * @module
  */
 
-import type { MagneticFluxDensity } from "@isentropic/dim-isq";
+import type { MagneticFluxDensity as MagneticFluxDensityDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { magneticFluxDensity } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { MagneticFluxDensity } from "@isentropic/dim-isq";
+/** An SI magnetic flux density quantity. */
+export type MagneticFluxDensity = Linear<MagneticFluxDensityDim, Si>;
 
 /** Tesla (T) — SI unit of magnetic flux density. */
-export const tesla: BaseUnit<MagneticFluxDensity> = si.unit(
+export const tesla: BaseUnit<MagneticFluxDensityDim> = si.unit(
   magneticFluxDensity,
 );
diff --git a/packages/dim-si/src/magnetic-flux.ts b/packages/dim-si/src/magnetic-flux.ts
index da49d01..b5a7974 100644
--- a/packages/dim-si/src/magnetic-flux.ts
+++ b/packages/dim-si/src/magnetic-flux.ts
@@ -13,12 +13,15 @@
  * @module
  */
 
-import type { MagneticFlux } from "@isentropic/dim-isq";
+import type { MagneticFlux as MagneticFluxDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { magneticFlux } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { MagneticFlux } from "@isentropic/dim-isq";
+/** An SI magnetic flux quantity. */
+export type MagneticFlux = Linear<MagneticFluxDim, Si>;
 
 /** Weber (Wb) — SI unit of magnetic flux. */
-export const weber: BaseUnit<MagneticFlux> = si.unit(magneticFlux);
+export const weber: BaseUnit<MagneticFluxDim> = si.unit(magneticFlux);
diff --git a/packages/dim-si/src/mass.ts b/packages/dim-si/src/mass.ts
index 6e6f111..2677b22 100644
--- a/packages/dim-si/src/mass.ts
+++ b/packages/dim-si/src/mass.ts
@@ -16,28 +16,31 @@
  * @module
  */
 
-import type { Mass } from "@isentropic/dim-isq";
+import type { Mass as MassDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { mass } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { KILO, MICRO, MILLI, NANO } from "./prefixes.ts";
 
-export type { Mass } from "@isentropic/dim-isq";
+/** An SI mass quantity. */
+export type Mass = Linear<MassDim, Si>;
 
 /** Kilogram (kg) — SI unit of mass. */
-export const kilogram: BaseUnit<Mass> = si.unit(mass);
+export const kilogram: BaseUnit<MassDim> = si.unit(mass);
 
 /** Gram (g) — 0.001 kilograms. */
-export const gram: ScaledUnit<Mass> = kilogram.scaled(MILLI);
+export const gram: ScaledUnit<MassDim> = kilogram.scaled(MILLI);
 
 /** Milligram (mg) — 10⁻³ grams. */
-export const milligram: ScaledUnit<Mass> = gram.scaled(MILLI);
+export const milligram: ScaledUnit<MassDim> = gram.scaled(MILLI);
 
 /** Microgram (μg) — 10⁻⁶ grams. */
-export const microgram: ScaledUnit<Mass> = gram.scaled(MICRO);
+export const microgram: ScaledUnit<MassDim> = gram.scaled(MICRO);
 
 /** Nanogram (ng) — 10⁻⁹ grams. */
-export const nanogram: ScaledUnit<Mass> = gram.scaled(NANO);
+export const nanogram: ScaledUnit<MassDim> = gram.scaled(NANO);
 
 /** Tonne (t) — 1000 kilograms. */
-export const tonne: ScaledUnit<Mass> = kilogram.scaled(KILO);
+export const tonne: ScaledUnit<MassDim> = kilogram.scaled(KILO);
diff --git a/packages/dim-si/src/power.ts b/packages/dim-si/src/power.ts
index a7c25aa..8f954d3 100644
--- a/packages/dim-si/src/power.ts
+++ b/packages/dim-si/src/power.ts
@@ -16,28 +16,31 @@
  * @module
  */
 
-import type { Power } from "@isentropic/dim-isq";
+import type { Power as PowerDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { power } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { GIGA, KILO, MEGA, MILLI, TERA } from "./prefixes.ts";
 
-export type { Power } from "@isentropic/dim-isq";
+/** An SI power quantity. */
+export type Power = Linear<PowerDim, Si>;
 
 /** Watt (W) — SI unit of power. */
-export const watt: BaseUnit<Power> = si.unit(power);
+export const watt: BaseUnit<PowerDim> = si.unit(power);
 
 /** Milliwatt (mW) — 10⁻³ watts. */
-export const milliwatt: ScaledUnit<Power> = watt.scaled(MILLI);
+export const milliwatt: ScaledUnit<PowerDim> = watt.scaled(MILLI);
 
 /** Kilowatt (kW) — 1000 watts. */
-export const kilowatt: ScaledUnit<Power> = watt.scaled(KILO);
+export const kilowatt: ScaledUnit<PowerDim> = watt.scaled(KILO);
 
 /** Megawatt (MW) — 10⁶ watts. */
-export const megawatt: ScaledUnit<Power> = watt.scaled(MEGA);
+export const megawatt: ScaledUnit<PowerDim> = watt.scaled(MEGA);
 
 /** Gigawatt (GW) — 10⁹ watts. */
-export const gigawatt: ScaledUnit<Power> = watt.scaled(GIGA);
+export const gigawatt: ScaledUnit<PowerDim> = watt.scaled(GIGA);
 
 /** Terawatt (TW) — 10¹² watts. */
-export const terawatt: ScaledUnit<Power> = watt.scaled(TERA);
+export const terawatt: ScaledUnit<PowerDim> = watt.scaled(TERA);
diff --git a/packages/dim-si/src/pressure.ts b/packages/dim-si/src/pressure.ts
index 68ea4f6..5e954b8 100644
--- a/packages/dim-si/src/pressure.ts
+++ b/packages/dim-si/src/pressure.ts
@@ -16,19 +16,22 @@
  * @module
  */
 
-import type { Pressure } from "@isentropic/dim-isq";
+import type { Pressure as PressureDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { pressure } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { MILLI } from "./prefixes.ts";
 
-export type { Pressure } from "@isentropic/dim-isq";
+/** An SI pressure quantity. */
+export type Pressure = Linear<PressureDim, Si>;
 
 /** Pascal (Pa) — SI unit of pressure. */
-export const pascal: BaseUnit<Pressure> = si.unit(pressure);
+export const pascal: BaseUnit<PressureDim> = si.unit(pressure);
 
 /** Bar — 100000 pascals. */
-export const bar: ScaledUnit<Pressure> = pascal.scaled(100000);
+export const bar: ScaledUnit<PressureDim> = pascal.scaled(100000);
 
 /** Millibar (mbar) — 100 pascals. */
-export const millibar: ScaledUnit<Pressure> = bar.scaled(MILLI);
+export const millibar: ScaledUnit<PressureDim> = bar.scaled(MILLI);
diff --git a/packages/dim-si/src/resistance.ts b/packages/dim-si/src/resistance.ts
index b768c54..faa0cb6 100644
--- a/packages/dim-si/src/resistance.ts
+++ b/packages/dim-si/src/resistance.ts
@@ -15,22 +15,25 @@
  * @module
  */
 
-import type { Resistance } from "@isentropic/dim-isq";
+import type { Resistance as ResistanceDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { resistance } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { KILO, MEGA, MILLI } from "./prefixes.ts";
 
-export type { Resistance } from "@isentropic/dim-isq";
+/** An SI resistance quantity. */
+export type Resistance = Linear<ResistanceDim, Si>;
 
 /** Ohm (Ω) — SI unit of electrical resistance. */
-export const ohm: BaseUnit<Resistance> = si.unit(resistance);
+export const ohm: BaseUnit<ResistanceDim> = si.unit(resistance);
 
 /** Milliohm (mΩ) — 10⁻³ ohms. */
-export const milliohm: ScaledUnit<Resistance> = ohm.scaled(MILLI);
+export const milliohm: ScaledUnit<ResistanceDim> = ohm.scaled(MILLI);
 
 /** Kilohm (kΩ) — 1000 ohms. */
-export const kilohm: ScaledUnit<Resistance> = ohm.scaled(KILO);
+export const kilohm: ScaledUnit<ResistanceDim> = ohm.scaled(KILO);
 
 /** Megohm (MΩ) — 10⁶ ohms. */
-export const megohm: ScaledUnit<Resistance> = ohm.scaled(MEGA);
+export const megohm: ScaledUnit<ResistanceDim> = ohm.scaled(MEGA);
diff --git a/packages/dim-si/src/scalar.ts b/packages/dim-si/src/scalar.ts
index bb81d88..e57a021 100644
--- a/packages/dim-si/src/scalar.ts
+++ b/packages/dim-si/src/scalar.ts
@@ -6,4 +6,9 @@
  * @module
  */
 
-export type { Scalar } from "@isentropic/dim-isq";
+import type { Scalar as ScalarDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
+import type { Si } from "./system.ts";
+
+/** An SI scalar (dimensionless) quantity. */
+export type Scalar = Linear<ScalarDim, Si>;
diff --git a/packages/dim-si/src/temperature.ts b/packages/dim-si/src/temperature.ts
index 82ea360..afe8776 100644
--- a/packages/dim-si/src/temperature.ts
+++ b/packages/dim-si/src/temperature.ts
@@ -28,15 +28,21 @@
  * @module
  */
 
-import type { Temperature } from "@isentropic/dim-isq";
+import type { Temperature as TemperatureDim } from "@isentropic/dim-isq";
+import type { Affine, Linear } from "@isentropic/dim-unit";
 import { temperature } from "@isentropic/dim-isq";
 import type { AffineUnit, BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Temperature } from "@isentropic/dim-isq";
+/** An SI absolute temperature quantity (affine). */
+export type Temperature = Affine<TemperatureDim, Si>;
+
+/** An SI temperature difference quantity (linear). */
+export type TemperatureDifference = Linear<TemperatureDim, Si>;
 
 /** Kelvin (K) — SI unit of thermodynamic temperature. */
-export const kelvin: BaseUnit<Temperature> = si.unit(temperature);
+export const kelvin: BaseUnit<TemperatureDim> = si.unit(temperature);
 
 /**
  * Celsius (°C) — temperature offset from kelvin by 273.15.
@@ -47,7 +53,7 @@ export const kelvin: BaseUnit<Temperature> = si.unit(temperature);
  * const newTemp = add(celsius(20), rise);  // 30°C
  * ```
  */
-export const celsius: AffineUnit<Temperature> = kelvin.offset(273.15);
+export const celsius: AffineUnit<TemperatureDim> = kelvin.offset(273.15);
 
 /**
  * Fahrenheit (°F) — temperature with scale 5/9 and offset from kelvin.
@@ -59,6 +65,7 @@ export const celsius: AffineUnit<Temperature> = kelvin.offset(273.15);
  */
 // Fahrenheit to Kelvin: K = (°F + 459.67) × 5/9
 // 459.67 is the offset in Rankine scale (0°R = 0K, 0°F = 459.67°R)
-export const fahrenheit: AffineUnit<Temperature> = kelvin.scaled(5 / 9).offset(
-  459.67 * 5 / 9,
-);
+export const fahrenheit: AffineUnit<TemperatureDim> = kelvin.scaled(5 / 9)
+  .offset(
+    459.67 * 5 / 9,
+  );
diff --git a/packages/dim-si/src/thermal-conductance.ts b/packages/dim-si/src/thermal-conductance.ts
index 49838f9..e81824a 100644
--- a/packages/dim-si/src/thermal-conductance.ts
+++ b/packages/dim-si/src/thermal-conductance.ts
@@ -13,23 +13,28 @@
  * @module
  */
 
-import type { ThermalConductance } from "@isentropic/dim-isq";
+import type { ThermalConductance as ThermalConductanceDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { thermalConductance } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { KILO, MILLI } from "./prefixes.ts";
 
-export type { ThermalConductance } from "@isentropic/dim-isq";
+/** An SI thermal conductance quantity. */
+export type ThermalConductance = Linear<ThermalConductanceDim, Si>;
 
 /** Watt per kelvin (W/K) — SI unit of thermal conductance. */
-export const wattPerKelvin: BaseUnit<ThermalConductance> = si.unit(
+export const wattPerKelvin: BaseUnit<ThermalConductanceDim> = si.unit(
   thermalConductance,
 );
 
 /** Milliwatt per kelvin (mW/K) — 10⁻³ watts per kelvin. */
-export const milliwattPerKelvin: ScaledUnit<ThermalConductance> = wattPerKelvin
-  .scaled(MILLI);
+export const milliwattPerKelvin: ScaledUnit<ThermalConductanceDim> =
+  wattPerKelvin
+    .scaled(MILLI);
 
 /** Kilowatt per kelvin (kW/K) — 1000 watts per kelvin. */
-export const kilowattPerKelvin: ScaledUnit<ThermalConductance> = wattPerKelvin
-  .scaled(KILO);
+export const kilowattPerKelvin: ScaledUnit<ThermalConductanceDim> =
+  wattPerKelvin
+    .scaled(KILO);
diff --git a/packages/dim-si/src/time.ts b/packages/dim-si/src/time.ts
index 697049d..672da87 100644
--- a/packages/dim-si/src/time.ts
+++ b/packages/dim-si/src/time.ts
@@ -16,34 +16,37 @@
  * @module
  */
 
-import type { Time } from "@isentropic/dim-isq";
+import type { Time as TimeDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { time } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { MICRO, MILLI, NANO, PICO } from "./prefixes.ts";
 
-export type { Time } from "@isentropic/dim-isq";
+/** An SI time quantity. */
+export type Time = Linear<TimeDim, Si>;
 
 /** Second (s) — SI unit of time. */
-export const second: BaseUnit<Time> = si.unit(time);
+export const second: BaseUnit<TimeDim> = si.unit(time);
 
 /** Millisecond (ms) — 10⁻³ seconds. */
-export const millisecond: ScaledUnit<Time> = second.scaled(MILLI);
+export const millisecond: ScaledUnit<TimeDim> = second.scaled(MILLI);
 
 /** Microsecond (μs) — 10⁻⁶ seconds. */
-export const microsecond: ScaledUnit<Time> = second.scaled(MICRO);
+export const microsecond: ScaledUnit<TimeDim> = second.scaled(MICRO);
 
 /** Nanosecond (ns) — 10⁻⁹ seconds. */
-export const nanosecond: ScaledUnit<Time> = second.scaled(NANO);
+export const nanosecond: ScaledUnit<TimeDim> = second.scaled(NANO);
 
 /** Picosecond (ps) — 10⁻¹² seconds. */
-export const picosecond: ScaledUnit<Time> = second.scaled(PICO);
+export const picosecond: ScaledUnit<TimeDim> = second.scaled(PICO);
 
 /** Minute (min) — 60 seconds. */
-export const minute: ScaledUnit<Time> = second.scaled(60);
+export const minute: ScaledUnit<TimeDim> = second.scaled(60);
 
 /** Hour (h) — 3600 seconds. */
-export const hour: ScaledUnit<Time> = second.scaled(3600);
+export const hour: ScaledUnit<TimeDim> = second.scaled(3600);
 
 /** Day (d) — 86400 seconds. */
-export const day: ScaledUnit<Time> = second.scaled(86400);
+export const day: ScaledUnit<TimeDim> = second.scaled(86400);
diff --git a/packages/dim-si/src/velocity.ts b/packages/dim-si/src/velocity.ts
index 9b17a8b..67b42d1 100644
--- a/packages/dim-si/src/velocity.ts
+++ b/packages/dim-si/src/velocity.ts
@@ -17,12 +17,15 @@
  * @module
  */
 
-import type { Velocity } from "@isentropic/dim-isq";
+import type { Velocity as VelocityDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { velocity } from "@isentropic/dim-isq";
 import type { BaseUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 
-export type { Velocity } from "@isentropic/dim-isq";
+/** An SI velocity quantity. */
+export type Velocity = Linear<VelocityDim, Si>;
 
 /** Meter per second (m/s) — SI unit of velocity. */
-export const meterPerSecond: BaseUnit<Velocity> = si.unit(velocity);
+export const meterPerSecond: BaseUnit<VelocityDim> = si.unit(velocity);
diff --git a/packages/dim-si/src/voltage.ts b/packages/dim-si/src/voltage.ts
index cf846ad..f0b1eab 100644
--- a/packages/dim-si/src/voltage.ts
+++ b/packages/dim-si/src/voltage.ts
@@ -15,19 +15,22 @@
  * @module
  */
 
-import type { Voltage } from "@isentropic/dim-isq";
+import type { Voltage as VoltageDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { voltage } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { KILO, MILLI } from "./prefixes.ts";
 
-export type { Voltage } from "@isentropic/dim-isq";
+/** An SI voltage quantity. */
+export type Voltage = Linear<VoltageDim, Si>;
 
 /** Volt (V) — SI unit of voltage. */
-export const volt: BaseUnit<Voltage> = si.unit(voltage);
+export const volt: BaseUnit<VoltageDim> = si.unit(voltage);
 
 /** Millivolt (mV) — 10⁻³ volts. */
-export const millivolt: ScaledUnit<Voltage> = volt.scaled(MILLI);
+export const millivolt: ScaledUnit<VoltageDim> = volt.scaled(MILLI);
 
 /** Kilovolt (kV) — 1000 volts. */
-export const kilovolt: ScaledUnit<Voltage> = volt.scaled(KILO);
+export const kilovolt: ScaledUnit<VoltageDim> = volt.scaled(KILO);
diff --git a/packages/dim-si/src/volume.ts b/packages/dim-si/src/volume.ts
index 8b57280..031869f 100644
--- a/packages/dim-si/src/volume.ts
+++ b/packages/dim-si/src/volume.ts
@@ -15,22 +15,25 @@
  * @module
  */
 
-import type { Volume } from "@isentropic/dim-isq";
+import type { Volume as VolumeDim } from "@isentropic/dim-isq";
+import type { Linear } from "@isentropic/dim-unit";
 import { volume } from "@isentropic/dim-isq";
 import type { BaseUnit, ScaledUnit } from "./types.ts";
+import type { Si } from "./system.ts";
 import { si } from "./system.ts";
 import { MICRO, MILLI } from "./prefixes.ts";
 
-export type { Volume } from "@isentropic/dim-isq";
+/** An SI volume quantity. */
+export type Volume = Linear<VolumeDim, Si>;
 
 /** Cubic meter (m³) — SI unit of volume. */
-export const cubicMeter: BaseUnit<Volume> = si.unit(volume);
+export const cubicMeter: BaseUnit<VolumeDim> = si.unit(volume);
 
 /** Liter (L) — 0.001 cubic meters. */
-export const liter: ScaledUnit<Volume> = cubicMeter.scaled(MILLI);
+export const liter: ScaledUnit<VolumeDim> = cubicMeter.scaled(MILLI);
 
 /** Milliliter (mL) — 10⁻³ liters. */
-export const milliliter: ScaledUnit<Volume> = liter.scaled(MILLI);
+export const milliliter: ScaledUnit<VolumeDim> = liter.scaled(MILLI);
 
 /** Microliter (μL) — 10⁻⁶ liters. */
-export const microliter: ScaledUnit<Volume> = liter.scaled(MICRO);
+export const microliter: ScaledUnit<VolumeDim> = liter.scaled(MICRO);