@ifc-lite/ids 1.15.50 → 1.15.52

package/dist/constraints/match-family.js

@@ -0,0 +1,265 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+import { compareBoolean, compareNumeric, compareString, isStrictNumericLiteral, isBooleanLiteral, } from './comparators.js';
+import { isNumericXsdBase, isBooleanXsdBase } from './xsd-cast.js';
+import { translateXsdRegex } from './xsd-regex.js';
+/** Tolerance for the bounds matcher's exclusive comparators. */
+export const NUMERIC_TOLERANCE = 1e-6;
+/**
+ * The conjunctive facets `parseRestriction` attached to this constraint
+ * from the same `<xs:restriction>`, or `undefined` when it declared one
+ * facet family (the common case). `simpleValue` never carries any: it
+ * does not come from a restriction.
+ */
+export function conjunctiveFacetsOf(constraint) {
+    return constraint.type === 'simpleValue' ? undefined : constraint.and;
+}
+export function matchOneFamily(constraint, actualValue, ci) {
+    switch (constraint.type) {
+        case 'simpleValue':
+            return matchSimpleValue(constraint, actualValue, ci);
+        case 'pattern':
+            return matchPattern(constraint, actualValue, ci);
+        case 'enumeration':
+            return matchEnumeration(constraint, actualValue, ci);
+        case 'bounds':
+            return matchBounds(constraint, actualValue);
+        default:
+            return false;
+    }
+}
+/**
+ * Per-constraint comparator applicability. `compareNumeric` runs two
+ * regex tests and `compareBoolean` two equality checks per call — and
+ * simple-value matching sits inside per-entity × per-specification hot
+ * loops (name matching against every pset/property). Whether the IDS
+ * literal could EVER match numerically or boolean-ly depends only on
+ * the constraint, so decide it once.
+ */
+const SIMPLE_VALUE_COERCIBLE = new WeakMap();
+function isCoercibleSimpleValue(constraint) {
+    let coercible = SIMPLE_VALUE_COERCIBLE.get(constraint);
+    if (coercible === undefined) {
+        coercible =
+            isStrictNumericLiteral(constraint.value) ||
+                isBooleanLiteral(constraint.value);
+        SIMPLE_VALUE_COERCIBLE.set(constraint, coercible);
+    }
+    return coercible;
+}
+/**
+ * Match against a simple value. Tries each comparator in order:
+ * string → numeric → boolean. The first decisive result wins;
+ * `undefined` lets the next strategy run.
+ */
+function matchSimpleValue(constraint, actualValue, caseInsensitive) {
+    const expected = constraint.value;
+    const stringResult = compareString(expected, actualValue, caseInsensitive);
+    if (stringResult !== undefined)
+        return stringResult;
+    // A non-numeric, non-boolean literal can only match through string
+    // equality — skip the comparators that would return undefined anyway.
+    if (!isCoercibleSimpleValue(constraint))
+        return false;
+    const numericResult = compareNumeric(expected, actualValue);
+    if (numericResult !== undefined)
+        return numericResult;
+    const booleanResult = compareBoolean(expected, actualValue);
+    if (booleanResult !== undefined)
+        return booleanResult;
+    return false;
+}
+/**
+ * Match against a regex pattern
+ * IDS uses XSD regex syntax which is slightly different from JavaScript
+ */
+function matchPattern(constraint, actualValue, caseInsensitive = false) {
+    // An XSD `xs:pattern` facet constrains the *lexical* space of its base
+    // datatype, so it matches the textual representation of the value — the
+    // official IDS reference (ifctester) does `re.fullmatch(pattern,
+    // str(value))`. A numeric value therefore satisfies e.g.
+    // `<restriction base="xs:decimal"><pattern value="^.*$"/>` ("any
+    // decimal value present"), which the previous blanket number/boolean
+    // bail-out wrongly failed on every numeric property.
+    //
+    // But the runtime value must first be type-compatible with the declared
+    // base: a number only matches a numeric base and a boolean only a
+    // boolean base. A number tested against `base="xs:string"` is a type
+    // mismatch — buildingSMART's corpus encodes exactly this as
+    // `patterns_always_fail_on_any_number`. (A string actual is already the
+    // lexical form, so it is matched directly regardless of base.)
+    if (typeof actualValue === 'number') {
+        if (!isNumericXsdBase(constraint.base))
+            return false;
+    }
+    else if (typeof actualValue === 'boolean') {
+        if (!isBooleanXsdBase(constraint.base))
+            return false;
+    }
+    const actualStr = String(actualValue);
+    const regex = compilePatternRegex(constraint, caseInsensitive);
+    // An un-compilable pattern can't match anything (e.g. an unbalanced
+    // `[`); treat it as a non-match rather than throwing.
+    return regex ? regex.test(actualStr) : false;
+}
+/**
+ * Compiled-pattern cache. Translating XSD → JS regex and building the
+ * `RegExp` on every value check dominated pattern-heavy validation; the
+ * compiled form depends only on (constraint, caseInsensitive), and the
+ * constraint object is stable per parsed document.
+ */
+const PATTERN_REGEX_CACHE = new WeakMap();
+function compilePatternRegex(constraint, caseInsensitive) {
+    let entry = PATTERN_REGEX_CACHE.get(constraint);
+    if (!entry) {
+        entry = {};
+        PATTERN_REGEX_CACHE.set(constraint, entry);
+    }
+    const slot = caseInsensitive ? 'ci' : 'cs';
+    let regex = entry[slot];
+    if (regex === undefined) {
+        regex = buildPatternRegex(constraint.pattern, caseInsensitive);
+        entry[slot] = regex;
+    }
+    return regex;
+}
+function buildPatternRegex(xsdPattern, caseInsensitive) {
+    // XSD char-class subtraction `[a-z-[aeiou]]` has no JS equivalent;
+    // approximate as the positive class (drop the exclusion) so the rest
+    // of the pattern still evaluates, matching long-standing behaviour.
+    const desubtracted = xsdPattern.replace(/\[([^\]]+)-\[[^\]]+\]\]/g, '[$1]');
+    // Shared XSD → JS translation: `\i`/`\c`/`\d`/`\w` (and their
+    // negations) map to Unicode property escapes, and verbatim `\p{…}`
+    // classes pass through — both require the `u` flag for full fidelity.
+    const { pattern } = translateXsdRegex(desubtracted);
+    // IDS patterns must match the entire lexical value. Wrapping in a
+    // non-capturing group anchors top-level alternation correctly
+    // (`a|b` → `^(?:a|b)$`, not `^a|b$`). Case-insensitive matching is
+    // opt-in per the call site (entity / predefined-type names use it;
+    // property and attribute values do not).
+    const anchored = `^(?:${pattern})$`;
+    try {
+        return new RegExp(anchored, caseInsensitive ? 'iu' : 'u');
+    }
+    catch {
+        // Some patterns are valid under JS's lenient (Annex-B) dialect but
+        // rejected under `u`. Retry without it so plain patterns keep
+        // matching; this loses `\p{…}` fidelity for that one pattern only.
+        try {
+            return new RegExp(anchored, caseInsensitive ? 'i' : '');
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * Compiled exact-match sets per enumeration constraint. Real-world IDS
+ * code lists carry hundreds of values and are matched against every
+ * candidate entity, so the linear comparator walk dominated validation
+ * time. Constraint objects are stable per parsed document, making a
+ * WeakMap cache safe.
+ */
+const ENUM_VALUE_SETS = new WeakMap();
+function getEnumValueSets(constraint) {
+    let sets = ENUM_VALUE_SETS.get(constraint);
+    if (!sets) {
+        const exact = new Set(constraint.values);
+        const upper = new Set();
+        let anyCoercible = false;
+        for (const v of constraint.values) {
+            upper.add(v.toUpperCase());
+            if (isStrictNumericLiteral(v) || isBooleanLiteral(v))
+                anyCoercible = true;
+        }
+        sets = { exact, upper, anyCoercible };
+        ENUM_VALUE_SETS.set(constraint, sets);
+    }
+    return sets;
+}
+/**
+ * Match against an enumeration. The actual value matches if ANY of the
+ * declared options matches under string / numeric / boolean comparison
+ * — same strategy table as `matchSimpleValue`, just iterated.
+ */
+function matchEnumeration(constraint, actualValue, caseInsensitive) {
+    // O(1) fast path: a set hit is exactly the condition under which
+    // `compareString` would have returned true for some value, so this
+    // never changes the outcome — misses fall through to the full
+    // comparator walk for numeric / boolean semantics.
+    const sets = getEnumValueSets(constraint);
+    const actualStr = String(actualValue);
+    if (sets.exact.has(actualStr))
+        return true;
+    if (caseInsensitive && sets.upper.has(actualStr.toUpperCase()))
+        return true;
+    // Pure-string enumerations are fully decided by the set lookups —
+    // only numeric/boolean literals can still match in the slow walk.
+    if (!sets.anyCoercible)
+        return false;
+    return constraint.values.some((v) => {
+        const stringResult = compareString(v, actualValue, caseInsensitive);
+        if (stringResult !== undefined)
+            return stringResult;
+        const numericResult = compareNumeric(v, actualValue);
+        if (numericResult !== undefined)
+            return numericResult;
+        const booleanResult = compareBoolean(v, actualValue);
+        if (booleanResult !== undefined)
+            return booleanResult;
+        return false;
+    });
+}
+/**
+ * Match against numeric bounds
+ */
+function matchBounds(constraint, actualValue) {
+    // String-length facets (xs:length / xs:minLength / xs:maxLength)
+    // operate on the textual length, not on numeric magnitude. When any
+    // of them are present, evaluate the length constraints first.
+    if (constraint.length !== undefined ||
+        constraint.minLength !== undefined ||
+        constraint.maxLength !== undefined) {
+        const str = String(actualValue);
+        if (constraint.length !== undefined && str.length !== constraint.length) {
+            return false;
+        }
+        if (constraint.minLength !== undefined && str.length < constraint.minLength) {
+            return false;
+        }
+        if (constraint.maxLength !== undefined && str.length > constraint.maxLength) {
+            return false;
+        }
+        // Length-only restrictions don't impose numeric bounds; if the
+        // constraint also carries min/max we fall through to the numeric
+        // check below (rare in practice).
+        if (constraint.minInclusive === undefined &&
+            constraint.maxInclusive === undefined &&
+            constraint.minExclusive === undefined &&
+            constraint.maxExclusive === undefined) {
+            return true;
+        }
+    }
+    const num = typeof actualValue === 'number'
+        ? actualValue
+        : parseFloat(String(actualValue));
+    if (isNaN(num))
+        return false;
+    if (constraint.minInclusive !== undefined &&
+        num < constraint.minInclusive) {
+        return false;
+    }
+    if (constraint.maxInclusive !== undefined &&
+        num > constraint.maxInclusive) {
+        return false;
+    }
+    if (constraint.minExclusive !== undefined && num <= constraint.minExclusive) {
+        return false;
+    }
+    if (constraint.maxExclusive !== undefined && num >= constraint.maxExclusive) {
+        return false;
+    }
+    return true;
+}
+//# sourceMappingURL=match-family.js.map

package/dist/constraints/match-family.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-family.js","sourceRoot":"","sources":["../../src/constraints/match-family.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAmB/D,OAAO,EACL,cAAc,EACd,cAAc,EACd,aAAa,EAEb,sBAAsB,EACtB,gBAAgB,GACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAEnD,gEAAgE;AAChE,MAAM,CAAC,MAAM,iBAAiB,GAAG,IAAI,CAAC;AAEtC;;;;;GAKG;AACH,MAAM,UAAU,mBAAmB,CACjC,UAAyB;IAEzB,OAAO,UAAU,CAAC,IAAI,KAAK,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,GAAG,CAAC;AACxE,CAAC;AAED,MAAM,UAAU,cAAc,CAC5B,UAAyB,EACzB,WAAsC,EACtC,EAAW;IAEX,QAAQ,UAAU,CAAC,IAAI,EAAE,CAAC;QACxB,KAAK,aAAa;YAChB,OAAO,gBAAgB,CAAC,UAAU,EAAE,WAAW,EAAE,EAAE,CAAC,CAAC;QACvD,KAAK,SAAS;YACZ,OAAO,YAAY,CAAC,UAAU,EAAE,WAAW,EAAE,EAAE,CAAC,CAAC;QACnD,KAAK,aAAa;YAChB,OAAO,gBAAgB,CAAC,UAAU,EAAE,WAAW,EAAE,EAAE,CAAC,CAAC;QACvD,KAAK,QAAQ;YACX,OAAO,WAAW,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;QAC9C;YACE,OAAO,KAAK,CAAC;IACjB,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,sBAAsB,GAAG,IAAI,OAAO,EAA2B,CAAC;AAEtE,SAAS,sBAAsB,CAAC,UAA0B;IACxD,IAAI,SAAS,GAAG,sBAAsB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IACvD,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;QAC5B,SAAS;YACP,sBAAsB,CAAC,UAAU,CAAC,KAAK,CAAC;gBACxC,gBAAgB,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;QACrC,sBAAsB,CAAC,GAAG,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;IACpD,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;;GAIG;AACH,SAAS,gBAAgB,CACvB,UAA0B,EAC1B,WAAsC,EACtC,eAAwB;IAExB,MAAM,QAAQ,GAAG,UAAU,CAAC,KAAK,CAAC;IAClC,MAAM,YAAY,GAAG,aAAa,CAAC,QAAQ,EAAE,WAAW,EAAE,eAAe,CAAC,CAAC;IAC3E,IAAI,YAAY,KAAK,SAAS;QAAE,OAAO,YAAY,CAAC;IACpD,mEAAmE;IACnE,sEAAsE;IACtE,IAAI,CAAC,sBAAsB,CAAC,UAAU,CAAC;QAAE,OAAO,KAAK,CAAC;IACtD,MAAM,aAAa,GAAG,cAAc,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IAC5D,IAAI,aAAa,KAAK,SAAS;QAAE,OAAO,aAAa,CAAC;IACtD,MAAM,aAAa,GAAG,cAAc,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IAC5D,IAAI,aAAa,KAAK,SAAS;QAAE,OAAO,aAAa,CAAC;IACtD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,SAAS,YAAY,CACnB,UAAgC,EAChC,WAAsC,EACtC,eAAe,GAAG,KAAK;IAEvB,uEAAuE;IACvE,wEAAwE;IACxE,iEAAiE;IACjE,yDAAyD;IACzD,iEAAiE;IACjE,qEAAqE;IACrE,qDAAqD;IACrD,EAAE;IACF,wEAAwE;IACxE,kEAAkE;IAClE,qEAAqE;IACrE,4DAA4D;IAC5D,wEAAwE;IACxE,+DAA+D;IAC/D,IAAI,OAAO,WAAW,KAAK,QAAQ,EAAE,CAAC;QACpC,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC;YAAE,OAAO,KAAK,CAAC;IACvD,CAAC;SAAM,IAAI,OAAO,WAAW,KAAK,SAAS,EAAE,CAAC;QAC5C,IAAI,CAAC,gBAAgB,CAAC,UAAU,CAAC,IAAI,CAAC;YAAE,OAAO,KAAK,CAAC;IACvD,CAAC;IACD,MAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;IAEtC,MAAM,KAAK,GAAG,mBAAmB,CAAC,UAAU,EAAE,eAAe,CAAC,CAAC;IAC/D,oEAAoE;IACpE,sDAAsD;IACtD,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC;AAC/C,CAAC;AAED;;;;;GAKG;AACH,MAAM,mBAAmB,GAAG,IAAI,OAAO,EAGpC,CAAC;AAEJ,SAAS,mBAAmB,CAC1B,UAAgC,EAChC,eAAwB;IAExB,IAAI,KAAK,GAAG,mBAAmB,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAChD,IAAI,CAAC,KAAK,EAAE,CAAC;QACX,KAAK,GAAG,EAAE,CAAC;QACX,mBAAmB,CAAC,GAAG,CAAC,UAAU,EAAE,KAAK,CAAC,CAAC;IAC7C,CAAC;IACD,MAAM,IAAI,GAAG,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,IAAI,CAAC;IAC3C,IAAI,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;IACxB,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,KAAK,GAAG,iBAAiB,CAAC,UAAU,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC;QAC/D,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;IACtB,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,iBAAiB,CACxB,UAAkB,EAClB,eAAwB;IAExB,mEAAmE;IACnE,qEAAqE;IACrE,oEAAoE;IACpE,MAAM,YAAY,GAAG,UAAU,CAAC,OAAO,CACrC,0BAA0B,EAC1B,MAAM,CACP,CAAC;IACF,8DAA8D;IAC9D,mEAAmE;IACnE,sEAAsE;IACtE,MAAM,EAAE,OAAO,EAAE,GAAG,iBAAiB,CAAC,YAAY,CAAC,CAAC;IACpD,kEAAkE;IAClE,8DAA8D;IAC9D,mEAAmE;IACnE,mEAAmE;IACnE,yCAAyC;IACzC,MAAM,QAAQ,GAAG,OAAO,OAAO,IAAI,CAAC;IACpC,IAAI,CAAC;QACH,OAAO,IAAI,MAAM,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC5D,CAAC;IAAC,MAAM,CAAC;QACP,mEAAmE;QACnE,8DAA8D;QAC9D,mEAAmE;QACnE,IAAI,CAAC;YACH,OAAO,IAAI,MAAM,CAAC,QAAQ,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC1D,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,eAAe,GAAG,IAAI,OAAO,EAGhC,CAAC;AAEJ,SAAS,gBAAgB,CAAC,UAAoC;IAK5D,IAAI,IAAI,GAAG,eAAe,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC;IAC3C,IAAI,CAAC,IAAI,EAAE,CAAC;QACV,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;QACzC,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;QAChC,IAAI,YAAY,GAAG,KAAK,CAAC;QACzB,KAAK,MAAM,CAAC,IAAI,UAAU,CAAC,MAAM,EAAE,CAAC;YAClC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;YAC3B,IAAI,sBAAsB,CAAC,CAAC,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC;gBAAE,YAAY,GAAG,IAAI,CAAC;QAC5E,CAAC;QACD,IAAI,GAAG,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,EAAE,CAAC;QACtC,eAAe,CAAC,GAAG,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,SAAS,gBAAgB,CACvB,UAAoC,EACpC,WAAsC,EACtC,eAAwB;IAExB,iEAAiE;IACjE,mEAAmE;IACnE,8DAA8D;IAC9D,mDAAmD;IACnD,MAAM,IAAI,GAAG,gBAAgB,CAAC,UAAU,CAAC,CAAC;IAC1C,MAAM,SAAS,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;IACtC,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC;QAAE,OAAO,IAAI,CAAC;IAC3C,IAAI,eAAe,IAAI,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,WAAW,EAAE,CAAC;QAAE,OAAO,IAAI,CAAC;IAC5E,kEAAkE;IAClE,kEAAkE;IAClE,IAAI,CAAC,IAAI,CAAC,YAAY;QAAE,OAAO,KAAK,CAAC;IAErC,OAAO,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE;QAClC,MAAM,YAAY,GAAG,aAAa,CAAC,CAAC,EAAE,WAAW,EAAE,eAAe,CAAC,CAAC;QACpE,IAAI,YAAY,KAAK,SAAS;YAAE,OAAO,YAAY,CAAC;QACpD,MAAM,aAAa,GAAG,cAAc,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;QACrD,IAAI,aAAa,KAAK,SAAS;YAAE,OAAO,aAAa,CAAC;QACtD,MAAM,aAAa,GAAG,cAAc,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC;QACrD,IAAI,aAAa,KAAK,SAAS;YAAE,OAAO,aAAa,CAAC;QACtD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;GAEG;AACH,SAAS,WAAW,CAClB,UAA+B,EAC/B,WAAsC;IAEtC,iEAAiE;IACjE,oEAAoE;IACpE,8DAA8D;IAC9D,IACE,UAAU,CAAC,MAAM,KAAK,SAAS;QAC/B,UAAU,CAAC,SAAS,KAAK,SAAS;QAClC,UAAU,CAAC,SAAS,KAAK,SAAS,EAClC,CAAC;QACD,MAAM,GAAG,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC;QAChC,IAAI,UAAU,CAAC,MAAM,KAAK,SAAS,IAAI,GAAG,CAAC,MAAM,KAAK,UAAU,CAAC,MAAM,EAAE,CAAC;YACxE,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,UAAU,CAAC,SAAS,KAAK,SAAS,IAAI,GAAG,CAAC,MAAM,GAAG,UAAU,CAAC,SAAS,EAAE,CAAC;YAC5E,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,UAAU,CAAC,SAAS,KAAK,SAAS,IAAI,GAAG,CAAC,MAAM,GAAG,UAAU,CAAC,SAAS,EAAE,CAAC;YAC5E,OAAO,KAAK,CAAC;QACf,CAAC;QACD,+DAA+D;QAC/D,iEAAiE;QACjE,kCAAkC;QAClC,IACE,UAAU,CAAC,YAAY,KAAK,SAAS;YACrC,UAAU,CAAC,YAAY,KAAK,SAAS;YACrC,UAAU,CAAC,YAAY,KAAK,SAAS;YACrC,UAAU,CAAC,YAAY,KAAK,SAAS,EACrC,CAAC;YACD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IAED,MAAM,GAAG,GACP,OAAO,WAAW,KAAK,QAAQ;QAC7B,CAAC,CAAC,WAAW;QACb,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;IAEtC,IAAI,KAAK,CAAC,GAAG,CAAC;QAAE,OAAO,KAAK,CAAC;IAE7B,IACE,UAAU,CAAC,YAAY,KAAK,SAAS;QACrC,GAAG,GAAG,UAAU,CAAC,YAAY,EAC7B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IACE,UAAU,CAAC,YAAY,KAAK,SAAS;QACrC,GAAG,GAAG,UAAU,CAAC,YAAY,EAC7B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,UAAU,CAAC,YAAY,KAAK,SAAS,IAAI,GAAG,IAAI,UAAU,CAAC,YAAY,EAAE,CAAC;QAC5E,OAAO,KAAK,CAAC;IACf,CAAC;IAED,IAAI,UAAU,CAAC,YAAY,KAAK,SAAS,IAAI,GAAG,IAAI,UAAU,CAAC,YAAY,EAAE,CAAC;QAC5E,OAAO,KAAK,CAAC;IACf,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/constraints/xsd-cast.d.ts

@@ -1,3 +1,13 @@
+/**
+ * The specials upstream's xs:double pattern accepts, spelled exactly as it
+ * spells them:
+ *
+ *     ^([-+]?[0-9]*\.?[0-9]*([eE][-+]?[0-9]+)?|NaN|\+INF|-INF)$
+ *
+ * Bare `INF` is absent because that pattern has `\+INF`, not `\+?INF`; and
+ * `Infinity` because it appears in neither upstream nor XSD.
+ */
+export declare const XSD_NUMERIC_SPECIALS: Set<string>;
 /**
  * Returns true iff the IDS literal `value` casts successfully under at
  * least one of `xsdTypes`. Empty / undefined `xsdTypes` returns `true`
@@ -10,5 +20,14 @@ export declare function literalCastsUnder(value: string, xsdType: string): boole
 export declare function isNumericXsdBase(base: string | undefined): boolean;
 /** True iff the restriction `@base` declares the boolean value space. */
 export declare function isBooleanXsdBase(base: string | undefined): boolean;
-export declare function ifcMeasureToXsdTypes(measure: string | undefined): readonly string[];
+/**
+ * `IfcTimeStamp`'s XSD types are the one answer here that depends on the
+ * schema version, so the mapper takes it rather than returning a union that
+ * is wrong somewhere. See the `IFCTIMESTAMP` branch below.
+ *
+ * Callers that genuinely have no version pass `undefined` and get the union
+ * across versions — permissive, which for a cast GATE means it defers rather
+ * than rejecting a value some schema allows.
+ */
+export declare function ifcMeasureToXsdTypes(measure: string | undefined, schemaVersion?: string | undefined): readonly string[];
 //# sourceMappingURL=xsd-cast.d.ts.map

package/dist/constraints/xsd-cast.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"xsd-cast.d.ts","sourceRoot":"","sources":["../../src/constraints/xsd-cast.ts"],"names":[],"mappings":"AAuBA;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACtC,OAAO,CAGT;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAyBzE;AA4CD,uEAAuE;AACvE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAElE;AAED,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAElE;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,MAAM,EAAE,CAuBnF"}
+{"version":3,"file":"xsd-cast.d.ts","sourceRoot":"","sources":["../../src/constraints/xsd-cast.ts"],"names":[],"mappings":"AAsBA;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB,aAAmC,CAAC;AASrE;;;;;GAKG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACtC,OAAO,CAGT;AAED,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAkCzE;AA4CD,uEAAuE;AACvE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAElE;AAED,yEAAyE;AACzE,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAElE;AA6BD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,GAAG,SAAS,EAC3B,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,GACjC,SAAS,MAAM,EAAE,CAkDnB"}

package/dist/constraints/xsd-cast.js

@@ -4,13 +4,29 @@
 /**
  * XSD strict-cast helpers shared by the attribute and property facets.
  *
- * Mirrors the `int.TryParse` / `double.TryParse` / `DateTime.TryParse`
- * rules upstream `IDS-Audit-tool` applies before doing the value
- * comparison. An IDS literal must cast successfully under at least one
+ * Mirrors what upstream `IDS-Audit-tool` accepts before doing the value
+ * comparison.
+ *
+ * NOT `TryParse`, which this said until #3336: upstream decides these with
+ * GENERATED REGEXES (`ids-lib.codegen/XmlSchema_XsTypesGenerator.cs`), and its
+ * xs:double pattern is neither .NET nor XSD. It takes `+INF` (an XSD 1.1
+ * spelling) while rejecting bare `INF` (the 1.0 one), and rejects `Infinity`
+ * (the .NET one). Parity with upstream is the contract, so that is what these
+ * arms implement. An IDS literal must cast successfully under at least one
  * of the slot's declared XSD types — `xs:integer` rejects `42.0`,
  * `xs:double` accepts either, etc.
  */
 import { isWhollyNumeric } from '@ifc-lite/encoding';
+/**
+ * The specials upstream's xs:double pattern accepts, spelled exactly as it
+ * spells them:
+ *
+ *     ^([-+]?[0-9]*\.?[0-9]*([eE][-+]?[0-9]+)?|NaN|\+INF|-INF)$
+ *
+ * Bare `INF` is absent because that pattern has `\+INF`, not `\+?INF`; and
+ * `Infinity` because it appears in neither upstream nor XSD.
+ */
+export const XSD_NUMERIC_SPECIALS = new Set(['NaN', '+INF', '-INF']);
 const INTEGER_RE = /^[+-]?\d+$/;
 const DATE_RE = /^\d{4}-\d{2}-\d{2}(Z|[+-]\d{2}:\d{2})?$/;
 const DATETIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})?$/;
@@ -31,12 +47,21 @@ export function literalCastsUnder(value, xsdType) {
         case 'xs:integer':
             return INTEGER_RE.test(value);
         case 'xs:double':
-            // Same language the local `DOUBLE_RE` decided, via the shared
-            // linear scan. That regex was
-            // `/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/` — the #3113 shape,
-            // quadratic on a failing match — and an IDS literal is as
+            // The finite part goes through the shared linear scan, not a regex: the
+            // natural pattern `/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/` is the
+            // #3113 shape, quadratic on a failing match, and an IDS literal is as
             // untrusted as the file it came out of.
-            return isWhollyNumeric(value);
+            //
+            // Deliberate deviation from upstream (#3336). Every part of upstream's
+            // pattern is optional, so it accepts a family of digitless and
+            // mantissa-less forms that are not numbers: "", "+", ".", "-", "+.",
+            // "-.", and the exponent-only class "e5" / "+e5" / ".e5". Those fall out
+            // of how the regex is written rather than being a contract, and an empty
+            // string is not a double, so the finite scan keeps rejecting them.
+            //
+            // NOT an exhaustive list -- the family is larger than the rows pinned in
+            // xsd-cast-specials.test.ts, which are representatives.
+            return isWhollyNumeric(value) || XSD_NUMERIC_SPECIALS.has(value);
         case 'xs:boolean':
             return value === 'true' || value === 'false';
         case 'xs:date':
@@ -101,10 +126,48 @@ export function isNumericXsdBase(base) {
 export function isBooleanXsdBase(base) {
     return baseLocalName(base) === 'boolean';
 }
-export function ifcMeasureToXsdTypes(measure) {
+/**
+ * Measures whose EXPRESS base contradicts the `*MEASURE` / `*RATIO`
+ * suffix heuristic below, or that the heuristic does not reach at all.
+ * Derived from `TYPE <name> = <base>;` in
+ * `packages/codegen/schemas/IFC4_ADD2_TC1.exp` and `IFC4X3.exp`, over
+ * the closure of the `IfcValue` SELECT (the value space an IFC property
+ * can actually carry); `xsd-cast-express.test.ts` re-derives that diff
+ * and fails if this table drifts from the schemas.
+ *
+ * - `IfcDescriptiveMeasure` is `STRING`, not a number, despite the name.
+ * - `IfcIntegerCountRateMeasure` is `INTEGER`, not `REAL`.
+ * - `IfcParameterValue` (`REAL`) and `IfcPositiveInteger` (`INTEGER`)
+ *   end in neither suffix, so they previously got no cast gate at all.
+ * - `IfcTime` and `IfcUriReference` are `STRING`. `xs:string` accepts
+ *   every literal, so naming them changes no verdict; they are listed
+ *   so the re-derivation covers the whole reachable value space rather
+ *   than carrying a second exception list of its own.
+ */
+const MEASURE_XSD_OVERRIDES = new Map([
+    ['IFCDESCRIPTIVEMEASURE', ['xs:string']],
+    ['IFCINTEGERCOUNTRATEMEASURE', ['xs:integer']],
+    ['IFCPARAMETERVALUE', ['xs:double']],
+    ['IFCPOSITIVEINTEGER', ['xs:integer']],
+    ['IFCTIME', ['xs:string']],
+    ['IFCURIREFERENCE', ['xs:string']],
+]);
+/**
+ * `IfcTimeStamp`'s XSD types are the one answer here that depends on the
+ * schema version, so the mapper takes it rather than returning a union that
+ * is wrong somewhere. See the `IFCTIMESTAMP` branch below.
+ *
+ * Callers that genuinely have no version pass `undefined` and get the union
+ * across versions — permissive, which for a cast GATE means it defers rather
+ * than rejecting a value some schema allows.
+ */
+export function ifcMeasureToXsdTypes(measure, schemaVersion) {
     if (!measure)
         return [];
     const m = measure.toUpperCase();
+    const override = MEASURE_XSD_OVERRIDES.get(m);
+    if (override)
+        return override;
     if (m === 'IFCINTEGER' || m === 'IFCCOUNTMEASURE')
         return ['xs:integer'];
     if (m === 'IFCBOOLEAN')
@@ -115,8 +178,34 @@ export function ifcMeasureToXsdTypes(measure) {
         return ['xs:date'];
     if (m === 'IFCDATETIME')
         return ['xs:dateTime'];
-    if (m === 'IFCDURATION' || m === 'IFCTIMESTAMP')
+    if (m === 'IFCDURATION')
         return ['xs:duration'];
+    // `TYPE IfcTimeStamp = INTEGER;` — a UNIX epoch second, not an ISO-8601
+    // duration. It was bundled onto the `IFCDURATION` row above on the strength
+    // of the name, which made this gate reject every value a timestamp property
+    // can legally hold. The generated `xsdTypesByEntity` table — the SAME
+    // question, answered from upstream `SchemaInfo.Attributes.g.cs`, and what
+    // the attribute facet gates on — answers PER SCHEMA VERSION, and it splits:
+    // `IfcOwnerHistory.CreationDate` carries `["xs:integer"]` under IFC2X3 and
+    // `["xs:dateTime","xs:integer"]` under IFC4 and IFC4X3.
+    //
+    // So there is no single correct answer to give, and taking the union ACROSS
+    // versions would recreate the disagreement in the other direction: under
+    // IFC2X3 an ISO-8601 date-time literal would pass this gate and be rejected
+    // by the attribute facet, on the same file. Swapping a total false-REJECT
+    // for a narrower false-ACCEPT is not a fix for "the two gates must agree",
+    // so answer per version instead and let the caller supply it.
+    //
+    // With no version the union is returned: a caller that cannot say which
+    // schema it is reading gets the permissive answer, which for a gate means
+    // deferring rather than rejecting a value some schema allows.
+    if (m === 'IFCTIMESTAMP') {
+        if (schemaVersion === undefined)
+            return ['xs:integer', 'xs:dateTime'];
+        return schemaVersion.toUpperCase() === 'IFC2X3'
+            ? ['xs:integer']
+            : ['xs:integer', 'xs:dateTime'];
+    }
     // All numeric measures (REAL, *MEASURE, *RATIO) accept doubles.
     if (m === 'IFCREAL' || m.endsWith('MEASURE') || m.endsWith('RATIO')) {
         return ['xs:double'];

package/dist/constraints/xsd-cast.js.map

@@ -1 +1 @@
-{"version":3,"file":"xsd-cast.js","sourceRoot":"","sources":["../../src/constraints/xsd-cast.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"xsd-cast.js","sourceRoot":"","sources":["../../src/constraints/xsd-cast.ts"],"names":[],"mappings":"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"}

package/dist/facets/property-facet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"property-facet.d.ts","sourceRoot":"","sources":["../../src/facets/property-facet.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EAEhB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAsGnD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,gBAAgB,EACvB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,eAAe,GACxB,OAAO,CAoBT;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,gBAAgB,EACvB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,eAAe,GACxB,gBAAgB,CAmGlB"}
+{"version":3,"file":"property-facet.d.ts","sourceRoot":"","sources":["../../src/facets/property-facet.ts"],"names":[],"mappings":"AAIA;;GAEG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,eAAe,EAEhB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAyGnD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,gBAAgB,EACvB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,eAAe,GACxB,OAAO,CAqBT;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,gBAAgB,EACvB,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,eAAe,GACxB,gBAAgB,CAmGlB"}

package/dist/facets/property-facet.js

@@ -45,16 +45,17 @@ function qualifiedPropertyNames(pset) {
  * check; the outcome depends only on (literal, measure name).
  */
 const CAST_GATE_CACHE = new WeakMap();
-function passesCastGate(value, dataType) {
+function passesCastGate(value, dataType, schemaVersion) {
     let byType = CAST_GATE_CACHE.get(value);
     if (!byType) {
         byType = new Map();
         CAST_GATE_CACHE.set(value, byType);
     }
-    const key = dataType ?? '';
+    // `IFCTIMESTAMP` casts differently under IFC2X3, so the version is in the key.
+    const key = `${dataType ?? ''}|${schemaVersion ?? ''}`;
     let passes = byType.get(key);
     if (passes === undefined) {
-        const xsdTypes = ifcMeasureToXsdTypes(dataType);
+        const xsdTypes = ifcMeasureToXsdTypes(dataType, schemaVersion);
         passes = xsdTypes.length === 0 || literalCastsUnderAnyType(value.value, xsdTypes);
         byType.set(key, passes);
     }
@@ -64,7 +65,7 @@ function passesCastGate(value, dataType) {
  * Diagnostics-free verdict for a single property — the exact `passed`
  * boolean `checkSingleProperty` would compute.
  */
-function singlePropertyPasses(facet, prop) {
+function singlePropertyPasses(facet, prop, schemaVersion) {
     // "No value" fails any check, including existence-only ones.
     if (prop.value === null || prop.value === undefined || prop.value === '') {
         return false;
@@ -75,8 +76,9 @@ function singlePropertyPasses(facet, prop) {
         }
     }
     if (facet.value) {
-        if (facet.value.type === 'simpleValue' && !passesCastGate(facet.value, prop.dataType)) {
-            return false;
+        if (facet.value.type === 'simpleValue') {
+            if (!passesCastGate(facet.value, prop.dataType, schemaVersion))
+                return false;
         }
         const candidateValues = prop.values && prop.values.length > 0 ? prop.values : [prop.value];
         return candidateValues.some((v) => matchConstraint(facet.value, v));
@@ -101,6 +103,7 @@ export function propertyFacetPasses(facet, expressId, accessor) {
     const propertySets = accessor.getPropertySets(expressId);
     if (propertySets.length === 0)
         return false;
+    const schemaVersion = accessor.getSchemaVersion?.();
     let anyMatchingPset = false;
     for (const pset of propertySets) {
         if (!matchConstraint(facet.propertySet, pset.name))
@@ -111,7 +114,7 @@ export function propertyFacetPasses(facet, expressId, accessor) {
             if (!matchConstraint(facet.baseName, prop.name))
                 continue;
             anyMatchingProp = true;
-            if (!singlePropertyPasses(facet, prop))
+            if (!singlePropertyPasses(facet, prop, schemaVersion))
                 return false;
         }
         if (!anyMatchingProp)
@@ -160,7 +163,7 @@ export function checkPropertyFacet(facet, expressId, accessor) {
     let lastPass;
     let firstFailure;
     for (const pset of matchingPsets) {
-        const result = checkPropertyInPset(facet, pset);
+        const result = checkPropertyInPset(facet, pset, accessor.getSchemaVersion?.());
         if (result.passed) {
             lastPass = result;
             continue;
@@ -218,7 +221,7 @@ export function checkPropertyFacet(facet, expressId, accessor) {
  * Tries ALL matching properties and returns on first pass.
  * If none pass, returns the most specific failure.
  */
-function checkPropertyInPset(facet, pset) {
+function checkPropertyInPset(facet, pset, schemaVersion) {
     // Find matching properties
     const matchingProps = pset.properties.filter((prop) => matchConstraint(facet.baseName, prop.name));
     if (matchingProps.length === 0) {
@@ -242,7 +245,7 @@ function checkPropertyInPset(facet, pset) {
     let lastPass;
     let firstFailure;
     for (const prop of matchingProps) {
-        const result = checkSingleProperty(facet, pset, prop);
+        const result = checkSingleProperty(facet, pset, prop, schemaVersion);
         if (result.passed) {
             lastPass = result;
             continue;
@@ -263,7 +266,7 @@ function checkPropertyInPset(facet, pset) {
 /**
  * Check a single property against the facet's dataType and value constraints.
  */
-function checkSingleProperty(facet, pset, prop) {
+function checkSingleProperty(facet, pset, prop, schemaVersion) {
     // Per IDS spec, a property whose stored value is "no value" (null,
     // undefined, empty string, or IfcLogical UNKNOWN) fails ANY check —
     // including a name-only existence check. Detect those up front so
@@ -326,28 +329,22 @@ function checkSingleProperty(facet, pset, prop) {
                 },
             };
         }
-        // Strict XSD-cast gate: the IDS literal MUST cast successfully
-        // under at least one of the IFC measure's XSD types. Mirrors the
-        // attribute facet's check — an `IFCINTEGER` slot rejects `42.0`,
-        // an `IFCBOOLEAN` slot rejects numeric literals, etc. The shared
-        // `ifcMeasureToXsdTypes` mapping turns the parser-side measure
-        // name into the XSD types the cast helper understands.
-        if (facet.value.type === 'simpleValue') {
-            const xsdTypes = ifcMeasureToXsdTypes(prop.dataType);
-            if (xsdTypes.length > 0 &&
-                !literalCastsUnderAnyType(facet.value.value, xsdTypes)) {
-                return {
-                    passed: false,
-                    actualValue: String(propValue),
-                    expectedValue: formatConstraint(facet.value),
-                    failure: {
-                        type: 'PROPERTY_VALUE_MISMATCH',
-                        field: `${pset.name}.${prop.name}`,
-                        actual: String(propValue),
-                        expected: formatConstraint(facet.value),
-                    },
-                };
-            }
+        // Strict XSD-cast gate, mirroring the attribute facet. Shared with
+        // `singlePropertyPasses` rather than repeated: the two must return the
+        // same verdict, and a second copy is what lets them drift.
+        if (facet.value.type === 'simpleValue' &&
+            !passesCastGate(facet.value, prop.dataType, schemaVersion)) {
+            return {
+                passed: false,
+                actualValue: String(propValue),
+                expectedValue: formatConstraint(facet.value),
+                failure: {
+                    type: 'PROPERTY_VALUE_MISMATCH',
+                    field: `${pset.name}.${prop.name}`,
+                    actual: String(propValue),
+                    expected: formatConstraint(facet.value),
+                },
+            };
         }
         // Multi-valued IFC properties (IfcPropertyEnumeratedValue,
         // IfcPropertyListValue) pass if ANY individual value satisfies the