diff --git a/CLAUDE.md b/CLAUDE.md
index 1634540..1dd806c 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -51,7 +51,7 @@ These are now baked into the generator and enforced by tests. **Do not reopen wi
 1. **`V0 - V0` returns the same `V0` of `T.Abs(a - b)`.** Magnitude subtraction stays non-negative; signed subtraction must use the V1 form explicitly.
 2. **Dimensionless and angular quantities have both `Ratio` (V0) and `SignedRatio` (V1) bases.** Ratios that semantically must be non-negative (e.g. `RefractiveIndex`, `MachNumber`, `SpecificGravity`) are V0 overloads of `Ratio`.
 3. **Semantic overloads widen implicitly to their base, narrow explicitly from it.** A `Weight` is implicitly a `ForceMagnitude`; the reverse requires `Weight.From(forceMagnitude)` or an explicit cast.
-4. **Physical constraints are enforced structurally via the V0 (magnitude) form.** `Vector0` factories run `Vector0Guards.EnsureNonNegative` and throw `ArgumentException` on a negative value. That covers absolute zero (Temperature is V0, so Kelvin must be ≥ 0), non-negative frequency, non-negative absolute pressure, etc. Strict-positive or upper-bound constraints are not yet declared in metadata (tracked separately).
+4. **Physical constraints are enforced structurally via the V0 (magnitude) form.** `Vector0` factories run `Vector0Guards.EnsureNonNegative` and throw `ArgumentException` on a negative value. That covers absolute zero (Temperature is V0, so Kelvin must be ≥ 0), non-negative frequency, non-negative absolute pressure, etc. A V0 *overload* can opt into a stricter rule by declaring `physicalConstraints: { "minExclusive": "0" }` in `dimensions.json` (#51); the generator then emits `Vector0Guards.EnsurePositive` and rejects zero too. Used today for `Wavelength`, `Period`, and `HalfLife` — quantities for which zero is unphysical.
 
 ### Physical constants
 
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs
index 508f00c..9b41aa3 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/HalfLife.g.cs
@@ -24,49 +24,49 @@ public record HalfLife<T> : PhysicalQuantity<HalfLife<T>, T>, IVector0<HalfLife<
 	/// <param name="value">The value in Second.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static HalfLife<T> FromSeconds(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
+	public static HalfLife<T> FromSeconds(T value) => Create(Vector0Guards.EnsurePositive(value, nameof(value)));
 /// <summary>
 	/// Creates a new HalfLife from a value in Millisecond.
 	/// </summary>
 	/// <param name="value">The value in Millisecond.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static HalfLife<T> FromMilliseconds(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
+	public static HalfLife<T> FromMilliseconds(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
 /// <summary>
 	/// Creates a new HalfLife from a value in Microsecond.
 	/// </summary>
 	/// <param name="value">The value in Microsecond.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static HalfLife<T> FromMicroseconds(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
+	public static HalfLife<T> FromMicroseconds(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
 /// <summary>
 	/// Creates a new HalfLife from a value in Minute.
 	/// </summary>
 	/// <param name="value">The value in Minute.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static HalfLife<T> FromMinutes(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MinuteToSeconds)), nameof(value)));
+	public static HalfLife<T> FromMinutes(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.MinuteToSeconds)), nameof(value)));
 /// <summary>
 	/// Creates a new HalfLife from a value in Hour.
 	/// </summary>
 	/// <param name="value">The value in Hour.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static HalfLife<T> FromHours(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HourToSeconds)), nameof(value)));
+	public static HalfLife<T> FromHours(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.HourToSeconds)), nameof(value)));
 /// <summary>
 	/// Creates a new HalfLife from a value in Day.
 	/// </summary>
 	/// <param name="value">The value in Day.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static HalfLife<T> FromDays(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DayToSeconds)), nameof(value)));
+	public static HalfLife<T> FromDays(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.DayToSeconds)), nameof(value)));
 /// <summary>
 	/// Creates a new HalfLife from a value in Year.
 	/// </summary>
 	/// <param name="value">The value in Year.</param>
 	/// <returns>A new HalfLife instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static HalfLife<T> FromYears(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YearToSeconds)), nameof(value)));
+	public static HalfLife<T> FromYears(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.YearToSeconds)), nameof(value)));
 /// <summary>Implicit conversion to Duration.</summary>
 	public static implicit operator Duration<T>(HalfLife<T> value) => Duration<T>.Create(value.Value);
 /// <summary>Explicit conversion from Duration.</summary>
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs
index 601bf0e..bf4b7fd 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Period.g.cs
@@ -24,49 +24,49 @@ public record Period<T> : PhysicalQuantity<Period<T>, T>, IVector0<Period<T>, T>
 	/// <param name="value">The value in Second.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Period<T> FromSeconds(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
+	public static Period<T> FromSeconds(T value) => Create(Vector0Guards.EnsurePositive(value, nameof(value)));
 /// <summary>
 	/// Creates a new Period from a value in Millisecond.
 	/// </summary>
 	/// <param name="value">The value in Millisecond.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Period<T> FromMilliseconds(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
+	public static Period<T> FromMilliseconds(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
 /// <summary>
 	/// Creates a new Period from a value in Microsecond.
 	/// </summary>
 	/// <param name="value">The value in Microsecond.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Period<T> FromMicroseconds(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
+	public static Period<T> FromMicroseconds(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
 /// <summary>
 	/// Creates a new Period from a value in Minute.
 	/// </summary>
 	/// <param name="value">The value in Minute.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Period<T> FromMinutes(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MinuteToSeconds)), nameof(value)));
+	public static Period<T> FromMinutes(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.MinuteToSeconds)), nameof(value)));
 /// <summary>
 	/// Creates a new Period from a value in Hour.
 	/// </summary>
 	/// <param name="value">The value in Hour.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Period<T> FromHours(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.HourToSeconds)), nameof(value)));
+	public static Period<T> FromHours(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.HourToSeconds)), nameof(value)));
 /// <summary>
 	/// Creates a new Period from a value in Day.
 	/// </summary>
 	/// <param name="value">The value in Day.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Period<T> FromDays(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.DayToSeconds)), nameof(value)));
+	public static Period<T> FromDays(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.DayToSeconds)), nameof(value)));
 /// <summary>
 	/// Creates a new Period from a value in Year.
 	/// </summary>
 	/// <param name="value">The value in Year.</param>
 	/// <returns>A new Period instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Period<T> FromYears(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YearToSeconds)), nameof(value)));
+	public static Period<T> FromYears(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.YearToSeconds)), nameof(value)));
 /// <summary>Implicit conversion to Duration.</summary>
 	public static implicit operator Duration<T>(Period<T> value) => Duration<T>.Create(value.Value);
 /// <summary>Explicit conversion from Duration.</summary>
diff --git a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs
index b2131e4..c321bd2 100644
--- a/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs
+++ b/Semantics.Quantities/Generated/Semantics.SourceGenerators/Semantics.SourceGenerators.QuantitiesGenerator/Wavelength.g.cs
@@ -24,77 +24,77 @@ public record Wavelength<T> : PhysicalQuantity<Wavelength<T>, T>, IVector0<Wavel
 	/// <param name="value">The value in Meter.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Wavelength<T> FromMeters(T value) => Create(Vector0Guards.EnsureNonNegative(value, nameof(value)));
+	public static Wavelength<T> FromMeters(T value) => Create(Vector0Guards.EnsurePositive(value, nameof(value)));
 /// <summary>
 	/// Creates a new Wavelength from a value in Kilometer.
 	/// </summary>
 	/// <param name="value">The value in Kilometer.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Wavelength<T> FromKilometers(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
+	public static Wavelength<T> FromKilometers(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Kilo)), nameof(value)));
 /// <summary>
 	/// Creates a new Wavelength from a value in Centimeter.
 	/// </summary>
 	/// <param name="value">The value in Centimeter.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Wavelength<T> FromCentimeters(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
+	public static Wavelength<T> FromCentimeters(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Centi)), nameof(value)));
 /// <summary>
 	/// Creates a new Wavelength from a value in Millimeter.
 	/// </summary>
 	/// <param name="value">The value in Millimeter.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Wavelength<T> FromMillimeters(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
+	public static Wavelength<T> FromMillimeters(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Milli)), nameof(value)));
 /// <summary>
 	/// Creates a new Wavelength from a value in Micrometer.
 	/// </summary>
 	/// <param name="value">The value in Micrometer.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Wavelength<T> FromMicrometers(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
+	public static Wavelength<T> FromMicrometers(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Micro)), nameof(value)));
 /// <summary>
 	/// Creates a new Wavelength from a value in Nanometer.
 	/// </summary>
 	/// <param name="value">The value in Nanometer.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Wavelength<T> FromNanometers(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
+	public static Wavelength<T> FromNanometers(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(MetricMagnitudes.Nano)), nameof(value)));
 /// <summary>
 	/// Creates a new Wavelength from a value in Angstrom.
 	/// </summary>
 	/// <param name="value">The value in Angstrom.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Wavelength<T> FromAngstroms(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
+	public static Wavelength<T> FromAngstroms(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.AngstromToMeters)), nameof(value)));
 /// <summary>
 	/// Creates a new Wavelength from a value in Foot.
 	/// </summary>
 	/// <param name="value">The value in Foot.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Wavelength<T> FromFeet(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
+	public static Wavelength<T> FromFeet(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.FeetToMeters)), nameof(value)));
 /// <summary>
 	/// Creates a new Wavelength from a value in Inch.
 	/// </summary>
 	/// <param name="value">The value in Inch.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Wavelength<T> FromInches(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
+	public static Wavelength<T> FromInches(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.InchesToMeters)), nameof(value)));
 /// <summary>
 	/// Creates a new Wavelength from a value in Yard.
 	/// </summary>
 	/// <param name="value">The value in Yard.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Wavelength<T> FromYards(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
+	public static Wavelength<T> FromYards(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.YardToMeters)), nameof(value)));
 /// <summary>
 	/// Creates a new Wavelength from a value in Mile.
 	/// </summary>
 	/// <param name="value">The value in Mile.</param>
 	/// <returns>A new Wavelength instance.</returns>
 	/// <exception cref="System.ArgumentException">Thrown when the resulting magnitude would be negative.</exception>
-	public static Wavelength<T> FromMiles(T value) => Create(Vector0Guards.EnsureNonNegative((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
+	public static Wavelength<T> FromMiles(T value) => Create(Vector0Guards.EnsurePositive((value * T.CreateChecked(Units.ConversionConstants.MileToMeters)), nameof(value)));
 /// <summary>Implicit conversion to Length.</summary>
 	public static implicit operator Length<T>(Wavelength<T> value) => Length<T>.Create(value.Value);
 /// <summary>Explicit conversion from Length.</summary>
diff --git a/Semantics.Quantities/Vector0Guards.cs b/Semantics.Quantities/Vector0Guards.cs
index 0f4c0e8..eab9e2b 100644
--- a/Semantics.Quantities/Vector0Guards.cs
+++ b/Semantics.Quantities/Vector0Guards.cs
@@ -42,4 +42,30 @@ public static T EnsureNonNegative<T>(T value, string paramName)
 
 		return value;
 	}
+
+	/// <summary>
+	/// Returns <paramref name="value"/> unchanged when it is strictly positive; throws
+	/// <see cref="ArgumentException"/> otherwise. Used in generated <c>From{Unit}</c>
+	/// factories on V0 overloads that declare <c>physicalConstraints.minExclusive: "0"</c>
+	/// in <c>dimensions.json</c> (per #51). Examples: <c>Wavelength</c>, <c>Period</c>,
+	/// <c>HalfLife</c> — quantities for which zero is unphysical, distinct from the V0
+	/// default that allows zero.
+	/// </summary>
+	/// <typeparam name="T">The numeric storage type.</typeparam>
+	/// <param name="value">The value (already converted to the SI base unit) to validate.</param>
+	/// <param name="paramName">Name of the originating parameter, used for the exception message.</param>
+	/// <returns>The validated, strictly-positive value.</returns>
+	/// <exception cref="ArgumentException">When <paramref name="value"/> is zero or negative.</exception>
+	public static T EnsurePositive<T>(T value, string paramName)
+		where T : struct, INumber<T>
+	{
+		if (T.Sign(value) <= 0)
+		{
+			throw new ArgumentException(
+				$"Value must be strictly positive; received {value}.",
+				paramName);
+		}
+
+		return value;
+	}
 }
diff --git a/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs b/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
index cd6b916..59866c4 100644
--- a/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
+++ b/Semantics.SourceGenerators/Generators/QuantitiesGenerator.cs
@@ -558,6 +558,10 @@ private static Dictionary<string, UnitDefinition> BuildUnitMap(UnitsMetadata uni
 	/// negative after a unit conversion (e.g. <c>FromCelsius(-300)</c>) — throws
 	/// <see cref="System.ArgumentException"/>. This locks in the V0 non-negativity invariant
 	/// from #50 across every per-unit factory introduced for #48.
+	/// When <paramref name="strictPositive"/> is also true (V0 overloads with
+	/// <c>physicalConstraints.minExclusive: "0"</c> per #51) the guard is upgraded to
+	/// <c>Vector0Guards.EnsurePositive</c>, which rejects zero as well as negative values.
+	/// <paramref name="strictPositive"/> is ignored when <paramref name="applyV0Guard"/> is false.
 	/// </summary>
 	private static void AddUnitFactories(
 		ClassTemplate cls,
@@ -566,13 +570,16 @@ private static void AddUnitFactories(
 		string typeName,
 		string fullType,
 		string crefForComment,
-		bool applyV0Guard)
+		bool applyV0Guard,
+		bool strictPositive = false)
 	{
 		if (availableUnits == null || availableUnits.Count == 0)
 		{
 			return;
 		}
 
+		string guardMethod = strictPositive ? "EnsurePositive" : "EnsureNonNegative";
+
 		string baseUnit = availableUnits[0];
 		foreach (string unitName in availableUnits)
 		{
@@ -582,7 +589,7 @@ private static void AddUnitFactories(
 				: BuildToBaseExpression(unitName, unitMap);
 
 			string body = applyV0Guard
-				? $" => Create(Vector0Guards.EnsureNonNegative({conversionExpr}, nameof(value)));"
+				? $" => Create(Vector0Guards.{guardMethod}({conversionExpr}, nameof(value)));"
 				: $" => Create({conversionExpr});";
 
 			// Issue #49: factory names use the plural form. Prefer an explicit FactoryName from
@@ -997,7 +1004,12 @@ private void EmitOverloadType(
 
 			// Factory methods for every available unit (#48); overloads inherit the dimension's
 			// units. V0 overloads enforce the same non-negativity invariant as their V0 base
-			// type (#50); V1 overloads accept any sign.
+			// type (#50). V0 overloads that declare physicalConstraints.minExclusive in
+			// dimensions.json (#51, e.g. Wavelength, Period, HalfLife) get the stricter
+			// EnsurePositive guard so a zero input is rejected too. V1 overloads accept
+			// any sign.
+			bool strictPositive = vectorForm == 0
+				&& overload.PhysicalConstraints?.MinExclusive == "0";
 			AddUnitFactories(
 				cls,
 				dim.AvailableUnits,
@@ -1005,7 +1017,8 @@ private void EmitOverloadType(
 				typeName,
 				fullType,
 				typeName,
-				applyV0Guard: vectorForm == 0);
+				applyV0Guard: vectorForm == 0,
+				strictPositive: strictPositive);
 
 			// Implicit widening to base type
 			cls.Members.Add(new MethodTemplate()
diff --git a/Semantics.SourceGenerators/Metadata/dimensions.json b/Semantics.SourceGenerators/Metadata/dimensions.json
index c1a6bdb..8370346 100644
--- a/Semantics.SourceGenerators/Metadata/dimensions.json
+++ b/Semantics.SourceGenerators/Metadata/dimensions.json
@@ -46,7 +46,7 @@
             },
             { "name": "Distance", "description": "Separation between two points in space." },
             { "name": "Altitude", "description": "Height above a reference level." },
-            { "name": "Wavelength", "description": "Spatial period of a periodic wave." },
+            { "name": "Wavelength", "description": "Spatial period of a periodic wave.", "physicalConstraints": { "minExclusive": "0" } },
             { "name": "Thickness", "description": "Extent through the thinnest dimension." },
             { "name": "Perimeter", "description": "Total boundary length of a 2D shape." }
           ]
@@ -107,8 +107,8 @@
         "vector0": {
           "base": "Duration",
           "overloads": [
-            { "name": "Period", "description": "Time interval for one complete cycle." },
-            { "name": "HalfLife", "description": "Time for half of a substance to decay." },
+            { "name": "Period", "description": "Time interval for one complete cycle.", "physicalConstraints": { "minExclusive": "0" } },
+            { "name": "HalfLife", "description": "Time for half of a substance to decay.", "physicalConstraints": { "minExclusive": "0" } },
             { "name": "TimeConstant", "description": "Characteristic response time of a system." },
             { "name": "Latency", "description": "Delay before a response begins." },
             { "name": "ReverberationTime", "description": "Time for sound to decay by 60 dB in an enclosed space." },
diff --git a/Semantics.SourceGenerators/Models/DimensionsMetadata.cs b/Semantics.SourceGenerators/Models/DimensionsMetadata.cs
index 6102f42..d83a9df 100644
--- a/Semantics.SourceGenerators/Models/DimensionsMetadata.cs
+++ b/Semantics.SourceGenerators/Models/DimensionsMetadata.cs
@@ -170,6 +170,30 @@ public class OverloadDefinition
 	public string Name { get; set; } = string.Empty;
 	public string Description { get; set; } = string.Empty;
 	public Dictionary<string, string> Relationships { get; set; } = [];
+
+	/// <summary>
+	/// Optional per-overload physical constraints. Currently only <c>minExclusive</c> is
+	/// honoured (per #51): when set on a V0 overload, the generated <c>From{Unit}</c>
+	/// factories use <c>Vector0Guards.EnsurePositive</c> instead of the default
+	/// <c>EnsureNonNegative</c>, so a strict-positive overload like <c>Wavelength</c>
+	/// rejects a zero input. The field is a string so it can hold a literal SI-base-unit
+	/// value (e.g. <c>"0"</c>); the generator emits <c>T.CreateChecked(...)</c> around it.
+	/// </summary>
+	public PhysicalConstraints? PhysicalConstraints { get; set; }
+}
+
+/// <summary>
+/// Per-overload physical constraints applied at construction time, on top of the structural
+/// V0 non-negativity invariant. Only <c>MinExclusive</c> is implemented today; the other
+/// fields are reserved for future per-overload bounds (#51).
+/// </summary>
+public class PhysicalConstraints
+{
+	/// <summary>
+	/// Strict-positive lower bound. When set (typically to <c>"0"</c>), the value must be
+	/// strictly greater than this number after conversion to the SI base unit.
+	/// </summary>
+	public string MinExclusive { get; set; } = string.Empty;
 }
 
 /// <summary>
diff --git a/Semantics.Test/Quantities/Vector0InvariantTests.cs b/Semantics.Test/Quantities/Vector0InvariantTests.cs
index d053a41..430765d 100644
--- a/Semantics.Test/Quantities/Vector0InvariantTests.cs
+++ b/Semantics.Test/Quantities/Vector0InvariantTests.cs
@@ -185,4 +185,102 @@ public void Vector0Guards_Throws_On_Negative_With_ParamName()
 			() => Vector0Guards.EnsureNonNegative(-1.0, "myParam"));
 		Assert.AreEqual("myParam", ex.ParamName);
 	}
+
+	// =========================================================== #51: Strict-positive overloads
+
+	// Wavelength, Period, HalfLife declare physicalConstraints.minExclusive: "0" in
+	// dimensions.json; their generated From{Unit} factories use Vector0Guards.EnsurePositive
+	// instead of EnsureNonNegative, rejecting zero as well as negative values.
+
+	[TestMethod]
+	public void Wavelength_FromMeters_Zero_Throws()
+		=> _ = Assert.ThrowsExactly<ArgumentException>(() => Wavelength<double>.FromMeters(0.0));
+
+	[TestMethod]
+	public void Wavelength_FromMeters_Negative_Throws()
+		=> _ = Assert.ThrowsExactly<ArgumentException>(() => Wavelength<double>.FromMeters(-1e-9));
+
+	[TestMethod]
+	public void Wavelength_FromMeters_Positive_Succeeds()
+	{
+		Wavelength<double> w = Wavelength<double>.FromMeters(550e-9);
+		Assert.AreEqual(550e-9, w.Value, 1e-15);
+	}
+
+	[TestMethod]
+	public void Wavelength_FromNanometers_Zero_Throws()
+		=> _ = Assert.ThrowsExactly<ArgumentException>(() => Wavelength<double>.FromNanometers(0.0));
+
+	[TestMethod]
+	public void Period_FromSeconds_Zero_Throws()
+		=> _ = Assert.ThrowsExactly<ArgumentException>(() => Period<double>.FromSeconds(0.0));
+
+	[TestMethod]
+	public void Period_FromSeconds_Positive_Succeeds()
+	{
+		Period<double> p = Period<double>.FromSeconds(0.001);
+		Assert.AreEqual(0.001, p.Value, Tolerance);
+	}
+
+	[TestMethod]
+	public void HalfLife_FromSeconds_Zero_Throws()
+		=> _ = Assert.ThrowsExactly<ArgumentException>(() => HalfLife<double>.FromSeconds(0.0));
+
+	// The base type (Length, Duration) has no minExclusive, so zero is still allowed —
+	// only the constrained overloads reject it.
+
+	[TestMethod]
+	public void Length_FromMeters_Zero_Allowed()
+	{
+		Length<double> l = Length<double>.FromMeters(0.0);
+		Assert.AreEqual(0.0, l.Value, Tolerance);
+	}
+
+	[TestMethod]
+	public void Duration_FromSeconds_Zero_Allowed()
+	{
+		Duration<double> d = Duration<double>.FromSeconds(0.0);
+		Assert.AreEqual(0.0, d.Value, Tolerance);
+	}
+
+	// Other Length / Duration overloads without the constraint also still allow zero.
+
+	[TestMethod]
+	public void Distance_FromMeters_Zero_Allowed()
+	{
+		Distance<double> d = Distance<double>.FromMeters(0.0);
+		Assert.AreEqual(0.0, d.Value, Tolerance);
+	}
+
+	[TestMethod]
+	public void Latency_FromSeconds_Zero_Allowed()
+	{
+		// Latency has no minExclusive — a zero-latency response is meaningful.
+		Latency<double> l = Latency<double>.FromSeconds(0.0);
+		Assert.AreEqual(0.0, l.Value, Tolerance);
+	}
+
+	// Vector0Guards.EnsurePositive directly.
+
+	[TestMethod]
+	public void Vector0Guards_EnsurePositive_Allows_Positive()
+	{
+		Assert.AreEqual(3.5, Vector0Guards.EnsurePositive(3.5, "v"));
+	}
+
+	[TestMethod]
+	public void Vector0Guards_EnsurePositive_Throws_On_Zero_With_ParamName()
+	{
+		ArgumentException ex = Assert.ThrowsExactly<ArgumentException>(
+			() => Vector0Guards.EnsurePositive(0.0, "myParam"));
+		Assert.AreEqual("myParam", ex.ParamName);
+	}
+
+	[TestMethod]
+	public void Vector0Guards_EnsurePositive_Throws_On_Negative_With_ParamName()
+	{
+		ArgumentException ex = Assert.ThrowsExactly<ArgumentException>(
+			() => Vector0Guards.EnsurePositive(-1.0, "myParam"));
+		Assert.AreEqual("myParam", ex.ParamName);
+	}
 }