diff --git a/CHANGELOG.md b/CHANGELOG.md
index 49623fd..fc63a28 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Fixed
+- Ordering facets on `xs:duration` are now enforced (#147). `minInclusive`, `maxInclusive`, `minExclusive`, and `maxExclusive` on duration were ignored because duration has no total order in the generic comparator. A `DurationValue` now implements the XSD 1.0 Datatypes 3.2.6.2 partial order (compare by adding to the four reference dateTimes); a value incomparable to the bound (such as `P1M` against `P30D`) is outside the range and rejected. XSTS: invalid instances accepted 355 to 257.
- Pattern and enumeration facets on a union type are now enforced (#147). A union admits a value valid for any member, but `pattern` and `enumeration` (the only constraining facets XSD allows on a union) had been ignored, so a member-valid value outside the enumeration or failing the pattern was wrongly accepted. Enumeration compares in the value space of the admitting member (so `01` equals an enumerated `1` for an integer member), matching the atomic path. XSTS #147: invalid instances accepted 555 to 355.
- Length facets on the built-in list datatypes now count list items, not characters (#146). A restriction of `NMTOKENS`, `IDREFS`, or `ENTITIES` resolved its base through neither the `BuiltinType` table (which has only the singular `NMTOKEN`) nor the user-type table, so it collapsed to an atomic string and `length`/`minLength`/`maxLength` measured characters, rejecting valid instances. The restriction base now resolves through `simpleTypeReference`, preserving the list variety. Closes the XSTS NIST `list-NMTOKENS`/`IDREFS`/`ENTITIES` facet clusters: valid instances rejected 604 to 547, invalid instances accepted 582 to 555.
- Three crash and hang classes uncovered by running the full XSTS archive to completion (#129). (1) Nested occurrence explosion: the content-model NFA capped each particle's `maxOccurs` unroll at 16384 but not the total state count, so nested high-`maxOccurs` particles multiplied (a sequence of 16384 holding a choice of 16384 is 2.7e8 states) and OOM-killed the process at 8 GB on the Microsoft Particles set; the builder now also caps total states (2^20), degrading further repetition to star. The regex `{n,m}` quantifier builder had the same unbounded unroll and the same cap is applied. (2) Quadratic content-model validation: `sequenceStructureErrors` called `follow(after: prefix)` once per child and `follow` re-walked the whole prefix from the start each time, so a content model over many children spun at 100% CPU; matching is now incremental (one active state-set advanced per child), turning O(children squared) into O(children). (3) Character-class subtraction trap: the regex pattern `[abcd-[d]]` (XSD class subtraction) was parsed as a `d` to `[` range, and since `d` (100) exceeds `[` (91) the reversed `ClosedRange` trapped (SIGBUS); `-[` now always opens a subtraction, and any reversed range (such as `[z-a]`) is a clean rejection rather than a trap.
diff --git a/Sources/Schema/DurationValue.swift b/Sources/Schema/DurationValue.swift
new file mode 100644
index 0000000..4f4cf67
--- /dev/null
+++ b/Sources/Schema/DurationValue.swift
@@ -0,0 +1,111 @@
+extension PureXML.Schema {
+ /// An `xs:duration` as its two independent signed components, months and
+ /// seconds, with the XSD 1.0 order relation. Because a month is 28 to 31
+ /// days, the order is partial: P and Q compare by adding each to the four
+ /// reference dateTimes the spec fixes, and durations whose sign disagrees
+ /// across those references are incomparable (for example `P1M` and `P30D`).
+ /// See XSD 1.0 Datatypes 3.2.6.2. Used by the ordering facets on duration,
+ /// which the generic total-order path cannot represent.
+ struct DurationValue {
+ let months: Int
+ let seconds: Double
+
+ enum Order { case lessThan, equal, greaterThan, incomparable }
+
+ /// The four reference dateTimes (year, month, day) at T00:00:00Z.
+ private static let references: [(year: Int, month: Int, day: Int)] = [
+ (1696, 9, 1), (1697, 2, 1), (1903, 3, 1), (1903, 7, 1),
+ ]
+
+ func compare(to other: DurationValue) -> Order {
+ var sawLess = false
+ var sawGreater = false
+ var sawEqual = false
+ for reference in Self.references {
+ let here = Self.instant(reference, addingMonths: months, seconds: seconds)
+ let there = Self.instant(reference, addingMonths: other.months, seconds: other.seconds)
+ if here < there {
+ sawLess = true
+ } else if here > there {
+ sawGreater = true
+ } else {
+ sawEqual = true
+ }
+ }
+ // P < Q only when s+P < s+Q at every reference; > likewise; equal
+ // when all four coincide (which holds iff the components are equal).
+ if sawLess, !sawGreater, !sawEqual { return .lessThan }
+ if sawGreater, !sawLess, !sawEqual { return .greaterThan }
+ if sawEqual, !sawLess, !sawGreater { return .equal }
+ return .incomparable
+ }
+
+ /// The instant, in seconds, of `reference` + (months, seconds): add the
+ /// months with calendar rollover (clamping the day to the resulting
+ /// month's length, per the spec), then add the seconds component.
+ private static func instant(
+ _ reference: (year: Int, month: Int, day: Int),
+ addingMonths addMonths: Int,
+ seconds: Double,
+ ) -> Double {
+ let total = (reference.month - 1) + addMonths
+ let yearsCarried = Int((Double(total) / 12.0).rounded(.down))
+ let newYear = reference.year + yearsCarried
+ let newMonth = total - yearsCarried * 12 + 1
+ let newDay = Swift.min(reference.day, DateTimeValue.daysInMonth(year: newYear, month: newMonth))
+ let days = DateTimeValue.daysFromCivil(year: newYear, month: newMonth, day: newDay)
+ return Double(days) * 86400 + seconds
+ }
+
+ /// Parses the lexical form `-?P(nY)?(nM)?(nD)?(T(nH)?(nM)?(nS)?)?`. The
+ /// lexical recognizer has already accepted the value, so this trusts the
+ /// shape and only reads out the components.
+ init?(_ string: String) {
+ var characters = Substring(string)
+ var sign = 1.0
+ if characters.first == "-" {
+ sign = -1
+ characters = characters.dropFirst()
+ }
+ guard characters.first == "P" else { return nil }
+ characters = characters.dropFirst()
+
+ var inTime = false
+ var years = 0
+ var monthsPart = 0
+ var days = 0
+ var secondsPart = 0.0
+ var sawComponent = false
+ var number = ""
+
+ func consume(_ designator: Character) -> Bool {
+ guard !number.isEmpty, let magnitude = Double(number) else { return false }
+ switch (inTime, designator) {
+ case (false, "Y"): years = Int(magnitude)
+ case (false, "M"): monthsPart = Int(magnitude)
+ case (false, "D"): days = Int(magnitude)
+ case (true, "H"): secondsPart += magnitude * 3600
+ case (true, "M"): secondsPart += magnitude * 60
+ case (true, "S"): secondsPart += magnitude
+ default: return false
+ }
+ number = ""
+ sawComponent = true
+ return true
+ }
+
+ for character in characters {
+ if character == "T" {
+ inTime = true
+ } else if character.isNumber || character == "." {
+ number.append(character)
+ } else if !consume(character) {
+ return nil
+ }
+ }
+ guard sawComponent, number.isEmpty else { return nil }
+ months = Int(sign) * (years * 12 + monthsPart)
+ seconds = sign * (Double(days) * 86400 + secondsPart)
+ }
+ }
+}
diff --git a/Sources/Schema/SimpleType.swift b/Sources/Schema/SimpleType.swift
index 02f8a2d..de89ad1 100644
--- a/Sources/Schema/SimpleType.swift
+++ b/Sources/Schema/SimpleType.swift
@@ -239,6 +239,7 @@ public extension PureXML.Schema {
}
private func rangeError(_ value: String, _ primitive: Primitive) -> String? {
+ if case .duration = primitive { return durationRangeError(value) }
guard let actual = primitive.ordered(value) else { return nil }
if let bound = facets.minInclusive, let limit = primitive.ordered(bound), actual < limit {
return "\(value) is below the inclusive minimum"
@@ -254,6 +255,29 @@ public extension PureXML.Schema {
}
return nil
}
+
+ /// Ordering facets on `xs:duration`, which is a partial order: a value
+ /// that is incomparable to the bound does not satisfy it (it is not in
+ /// the ordered range), so an incomparable result is a violation.
+ private func durationRangeError(_ value: String) -> String? {
+ guard let actual = DurationValue(value) else { return nil }
+ func order(_ bound: String?) -> DurationValue.Order? {
+ bound.flatMap(DurationValue.init).map(actual.compare(to:))
+ }
+ if let order = order(facets.minInclusive), order == .lessThan || order == .incomparable {
+ return "\(value) is below the inclusive minimum"
+ }
+ if let order = order(facets.maxInclusive), order == .greaterThan || order == .incomparable {
+ return "\(value) is above the inclusive maximum"
+ }
+ if let order = order(facets.minExclusive), order != .greaterThan {
+ return "\(value) is not above the exclusive minimum"
+ }
+ if let order = order(facets.maxExclusive), order != .lessThan {
+ return "\(value) is not below the exclusive maximum"
+ }
+ return nil
+ }
}
/// Validates `value` against a built-in type with no extra facets.
diff --git a/Tests/SchemaDurationFacetTests.swift b/Tests/SchemaDurationFacetTests.swift
new file mode 100644
index 0000000..d32c939
--- /dev/null
+++ b/Tests/SchemaDurationFacetTests.swift
@@ -0,0 +1,45 @@
+@testable import PureXML
+import Testing
+
+/// Ordering facets on `xs:duration` (#147). Duration is a partial order (a month
+/// is 28 to 31 days), compared by adding to four reference dateTimes. The bounds
+/// had not been enforced at all; a value incomparable to the bound (such as
+/// `P1M` against `P30D`) is outside the range and must be rejected.
+@Suite("Duration ordering facets")
+struct SchemaDurationFacetTests {
+ private func schema(_ facet: String) throws -> PureXML.Schema.Document {
+ try PureXML.Schema.Document("""
+
+
+
+ \(facet)
+
+
+
+ """)
+ }
+
+ @Test("minInclusive enforces the lower bound")
+ func test_minInclusive() throws {
+ let s = try schema(#""#)
+ #expect(try s.validate("P1Y").isEmpty) // equal
+ #expect(try s.validate("P2Y").isEmpty) // greater
+ #expect(try !s.validate("P6M").isEmpty) // less
+ }
+
+ @Test("minExclusive rejects the bound itself")
+ func test_minExclusive() throws {
+ let s = try schema(#""#)
+ #expect(try !s.validate("P1Y").isEmpty) // equal: rejected
+ #expect(try s.validate("P2Y").isEmpty) // greater
+ }
+
+ @Test("maxInclusive enforces the upper bound and rejects incomparable values")
+ func test_maxInclusivePartialOrder() throws {
+ let s = try schema(#""#)
+ #expect(try s.validate("P20D").isEmpty) // less
+ #expect(try !s.validate("P40D").isEmpty) // greater
+ // P1M is incomparable to P30D (28..31 days) so it is not <= P30D.
+ #expect(try !s.validate("P1M").isEmpty)
+ }
+}
diff --git a/Tests/XSTSSuiteTests.swift b/Tests/XSTSSuiteTests.swift
index c6c9b5a..2319ea3 100644
--- a/Tests/XSTSSuiteTests.swift
+++ b/Tests/XSTSSuiteTests.swift
@@ -22,15 +22,16 @@ struct XSTSSuiteTests {
/// 2026-06-13, over 14383 groups). These ratchet down as conformance work
/// closes deviations (#145-#148); a count rising is a regression. The
/// instance counts reflect the #146 list-facet fix (built-in list length
- /// facets now count items) and the #147 union-facet fix (pattern and
- /// enumeration enforced on unions). The suite is opt-in, so CI and plain
+ /// counts items), the #147 union-facet fix (pattern and enumeration
+ /// enforced on unions), and the #147 duration-ordering fix (minInclusive and
+ /// friends on xs:duration). The suite is opt-in, so CI and plain
/// `swift test` are unaffected; run it with `swift test -c release --filter
/// XSTS` (debug is far slower and the corpus is large). Per-case deviations
/// are written to /tmp/xsts-failures.txt for the burn-down.
private let knownSchemaValidRejected = 75
private let knownSchemaInvalidAccepted = 2467
private let knownInstanceValidRejected = 547
- private let knownInstanceInvalidAccepted = 355
+ private let knownInstanceInvalidAccepted = 257
@Test("Every XSTS case behaves: compile, reject, validate, invalidate")
func test_suite() throws {