@@ -20,6 +20,18 @@ internal enum CalcCategory
         /// convert via fixed constants), so a valid Angle-category expression always folds fully at
         /// Layer A parse time - see CalcSerializer.
         /// </summary>
-        Angle = 8
+        Angle = 8,
+
+        /// <summary>
+        /// &lt;time&gt; (s/ms). Like Angle, it resolves without layout context. Currently produced only by
+        /// <c>@property</c> <c>syntax: "&lt;time&gt;"</c> validation - no layout property consumes a time
+        /// calc(), so it never reaches CalcEvaluator during a render.
+        /// </summary>
+        Time = 16,
+
+        /// <summary>
+        /// &lt;resolution&gt; (dpi/dpcm/dppx). Context-free like Angle/Time; same @property-only provenance.
+        /// </summary>
+        Resolution = 32
     }
 }
@@ -61,6 +61,23 @@ internal static class CalcEvaluator
                     return new Length((float)percentage.Value, Length.Unit.Percent)
                         .ToPixels(context.EmFactor, context.RemFactor, context.HundredPercent, context.FontAdjust);
 
+                case AngleCalcNode angle:
+                    // An angle leaf evaluates to radians (the canonical angle unit), so an angle-typed
+                    // calc such as `calc(1turn * 0.35)` yields 0.35 turn in radians (a Number leaf stays a
+                    // unitless scalar). Length calc()s never contain an angle leaf, so this never perturbs
+                    // length evaluation; the only current caller is conic-gradient stop-position parsing.
+                    return new Angle((float)angle.Value, angle.Unit).ToRadian();
+
+                case TimeCalcNode time:
+                    // Canonical time unit is milliseconds. No layout property evaluates a time calc() today
+                    // (these nodes only arise from @property `syntax: "<time>"` validation, which type-checks
+                    // rather than evaluates), so this case is defensive completeness paralleling the angle leaf.
+                    return new Time((float)time.Value, time.Unit).ToMilliseconds();
+
+                case ResolutionCalcNode resolution:
+                    // Canonical resolution unit is dots-per-pixel; same @property-only provenance as TimeCalcNode.
+                    return new Resolution((float)resolution.Value, resolution.Unit).ToDotsPerPixel();
+
                 case UnaryCalcNode unary:
                 {
                     var operand = Evaluate(unary.Operand, context);
 
@@ -55,6 +55,30 @@ public AngleCalcNode(double value, Angle.Unit unit)
         public Angle.Unit Unit { get; }
     }
 
+    internal sealed class TimeCalcNode : CalcNode
+    {
+        public TimeCalcNode(double value, Time.Unit unit)
+        {
+            Value = value;
+            Unit = unit;
+        }
+
+        public double Value { get; }
+        public Time.Unit Unit { get; }
+    }
+
+    internal sealed class ResolutionCalcNode : CalcNode
+    {
+        public ResolutionCalcNode(double value, Resolution.Unit unit)
+        {
+            Value = value;
+            Unit = unit;
+        }
+
+        public double Value { get; }
+        public Resolution.Unit Unit { get; }
+    }
+
     /// <summary>A leading unary sign directly before a parenthesized group or a nested function call.</summary>
     internal sealed class UnaryCalcNode : CalcNode
     {
 
@@ -172,6 +172,20 @@ private static CalcNode ParseValue(List<Token> tokens, ref int pos)
                         return new AngleCalcNode(unitToken.Value, angleUnit);
                     }
 
+                    var timeUnit = Time.GetUnit(unitToken.Unit);
+                    if (timeUnit != Time.Unit.None)
+                    {
+                        pos++;
+                        return new TimeCalcNode(unitToken.Value, timeUnit);
+                    }
+
+                    var resolutionUnit = Resolution.GetUnit(unitToken.Unit);
+                    if (resolutionUnit != Resolution.Unit.None)
+                    {
+                        pos++;
+                        return new ResolutionCalcNode(unitToken.Value, resolutionUnit);
+                    }
+
                     return null;
                 }
 
 
@@ -141,6 +141,17 @@ private static string SerializeOperand(CalcNode node, bool isRightOperand, int p
                 case PercentageCalcNode percentage:
                     return new Length((float)percentage.Value, Length.Unit.Percent).ToString(null, CultureInfo.InvariantCulture);
 
+                // Time/Resolution leaves are only produced by @property `<time>`/`<resolution>` validation,
+                // which type-checks rather than serializes, so these arms are defensive completeness. A
+                // Time/Resolution-category Serialize() (were one ever created) folds through neither the Number
+                // nor Angle branch nor TryFoldPixels, so it reaches SerializeExpression and re-serializes to
+                // normalized calc() text using these leaf renderings.
+                case TimeCalcNode time:
+                    return new Time((float)time.Value, time.Unit).ToString(null, CultureInfo.InvariantCulture);
+
+                case ResolutionCalcNode resolution:
+                    return new Resolution((float)resolution.Value, resolution.Unit).ToString(null, CultureInfo.InvariantCulture);
+
                 case UnaryCalcNode unary:
                 {
                     var operand = SerializeOperand(unary.Operand, false, 3);
 
@@ -28,6 +28,12 @@ internal static class CalcTypeChecker
                 case AngleCalcNode _:
                     return CalcCategory.Angle;
 
+                case TimeCalcNode _:
+                    return CalcCategory.Time;
+
+                case ResolutionCalcNode _:
+                    return CalcCategory.Resolution;
+
                 case UnaryCalcNode unary:
                     return Check(unary.Operand);
 
 
@@ -20,6 +20,11 @@ internal sealed class PropertyFactory
 
         private readonly Dictionary<string, LonghandCreator> _fonts;
 
+        // @property descriptors (syntax / initial-value / inherits). Their values have no fixed CSS grammar
+        // (initial-value depends on the syntax; syntax is an arbitrary string), so each is stored raw via an
+        // UnknownProperty (Converters.Any) and validated later against the syntax string.
+        private readonly Dictionary<string, LonghandCreator> _propertyDescriptors;
+
         private readonly Dictionary<string, LonghandCreator> _longhands;
 
         private readonly Dictionary<string, string[]> _mappings;
@@ -353,6 +358,14 @@ private PropertyFactory()
             _fontsBuilder.Add(PropertyNames.UnicodeRange, () => new UnicodeRangeProperty());
 
             _fonts = _fontsBuilder;
+
+            _propertyDescriptors = new Dictionary<string, LonghandCreator>(StringComparer.OrdinalIgnoreCase)
+            {
+                { PropertyNames.Syntax, () => new UnknownProperty(PropertyNames.Syntax) },
+                { PropertyNames.InitialValue, () => new UnknownProperty(PropertyNames.InitialValue) },
+                { PropertyNames.Inherits, () => new UnknownProperty(PropertyNames.Inherits) },
+            };
+
             _longhands = _longhandsBuilder;
             _mappings = _mappingsBuilder;
             _shorthands = _shorthandsBuilder;
@@ -395,6 +408,11 @@ public Property CreateFont(string name)
             return _fonts.TryGetValue(name, out var propertyCreator) ? propertyCreator() : null;
         }
 
+        public Property CreatePropertyDescriptor(string name)
+        {
+            return _propertyDescriptors.TryGetValue(name, out var propertyCreator) ? propertyCreator() : null;
+        }
+
         public Property CreateViewport(string name)
         {
             var feature = MediaFeatureFactory.Instance.Create(name);
 
@@ -39,6 +39,8 @@ public Rule CreateAtRule(Token token)
 
             if (token.Data.Is(RuleNames.Container)) return CreateContainer(token);
 
+            if (token.Data.Is(RuleNames.Property)) return CreateProperty(token);
+
             return token.Data.Is(RuleNames.Document) ? CreateDocument(token) : CreateUnknown(token);
         }
 
@@ -147,6 +149,28 @@ public Rule CreateFontFace(Token current)
             return SkipDeclarations(token);
         }
 
+        public Rule CreateProperty(Token current)
+        {
+            var rule = new PropertyRule(_parser);
+            var start = current.Position;
+            var token = NextToken();
+            _nodes.Push(rule);
+            ParseComments(ref token);
+            rule.Name = GetRuleName(ref token);
+            ParseComments(ref token);
+
+            if (token.Type == TokenType.CurlyBracketOpen)
+            {
+                var end = FillDeclarations(rule, PropertyFactory.Instance.CreatePropertyDescriptor);
+                rule.StylesheetText = CreateView(start, end);
+                _nodes.Pop();
+                return rule;
+            }
+
+            _nodes.Pop();
+            return SkipDeclarations(token);
+        }
+
         public Rule CreateImport(Token current)
         {
             var rule = new ImportRule(_parser);
 
@@ -0,0 +1,21 @@
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>
+    /// A registered custom property declared with an <c>@property</c> at-rule
+    /// (CSS Properties &amp; Values API Level 1 §3). Exposes the three descriptors.
+    /// </summary>
+    internal interface IPropertyRule : IRule, IProperties
+    {
+        /// <summary>The registered custom property name, e.g. <c>--my-color</c>.</summary>
+        string Name { get; set; }
+
+        /// <summary>The raw <c>syntax</c> descriptor value (a string, e.g. <c>&lt;color&gt;</c> or <c>*</c>).</summary>
+        string Syntax { get; set; }
+
+        /// <summary>The raw <c>initial-value</c> descriptor value.</summary>
+        string InitialValue { get; set; }
+
+        /// <summary>The raw <c>inherits</c> descriptor value (<c>true</c> or <c>false</c>).</summary>
+        string Inherits { get; set; }
+    }
+}
@@ -0,0 +1,57 @@
+using System.IO;
+using System.Linq;
+
+namespace TheArtOfDev.HtmlRenderer.Core.CssEngine
+{
+    /// <summary>
+    /// An <c>@property</c> at-rule (CSS Properties &amp; Values API Level 1 §3): registers a typed custom
+    /// property with a <c>syntax</c>, <c>initial-value</c>, and <c>inherits</c> descriptor. The descriptor
+    /// block is stored like <see cref="FontFaceRule"/>; the registered name (a dashed-ident such as
+    /// <c>--my-color</c>) is captured from the prelude like <see cref="KeyframesRule.Name"/>.
+    /// </summary>
+    internal sealed class PropertyRule : DeclarationRule, IPropertyRule
+    {
+        internal PropertyRule(StylesheetParser parser)
+            : base(RuleType.Property, RuleNames.Property, parser)
+        {
+        }
+
+        protected override Property CreateNewProperty(string name)
+        {
+            return PropertyFactory.Instance.CreatePropertyDescriptor(name);
+        }
+
+        protected override void ReplaceWith(IRule rule)
+        {
+            var other = rule as PropertyRule;
+            if (other != null) Name = other.Name;
+            base.ReplaceWith(rule);
+        }
+
+        public string Name { get; set; }
+
+        public string Syntax
+        {
+            get { return GetValue(PropertyNames.Syntax); }
+            set { SetValue(PropertyNames.Syntax, value); }
+        }
+
+        public string InitialValue
+        {
+            get { return GetValue(PropertyNames.InitialValue); }
+            set { SetValue(PropertyNames.InitialValue, value); }
+        }
+
+        public string Inherits
+        {
+            get { return GetValue(PropertyNames.Inherits); }
+            set { SetValue(PropertyNames.Inherits, value); }
+        }
+
+        public override void ToCss(TextWriter writer, IStyleFormatter formatter)
+        {
+            var declarations = formatter.Declarations(Declarations.Where(d => d.HasValue).Select(d => d.ToCss(formatter)));
+            writer.Write(string.Concat("@property ", Name, " { ", declarations, " }"));
+        }
+    }
+}