@itwin/ecschema-rpcinterface-tests 5.6.0-dev.7 → 5.7.0-dev.1

package/lib/dist/bundled-tests.js

@@ -44957,7 +44957,7 @@ class TextStyleSettings {
     listMarker;
     /** The frame settings of the [[TextAnnotation]]. */
     frame;
-    /** The margins to surround the document content. */
+    /** Multiplier used to calculate the margins to surround the document content. */
     margins;
     /** The alignment of the text content. */
     justification;
@@ -63738,6 +63738,18 @@ class JsonParser extends _AbstractParser__WEBPACK_IMPORTED_MODULE_2__.AbstractPa
             throw new _Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaStatus.InvalidECJson, `The Format ${this._currentItemFullName} has an invalid 'uomSeparator' attribute. It should be of type 'string'.`);
         if (undefined !== jsonObj.scientificType && typeof (jsonObj.scientificType) !== "string")
             throw new _Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaStatus.InvalidECJson, `The Format ${this._currentItemFullName} has an invalid 'scientificType' attribute. It should be of type 'string'.`);
+        if (undefined !== jsonObj.ratioType && typeof (jsonObj.ratioType) !== "string")
+            throw new _Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaStatus.InvalidECJson, `The Format ${this._currentItemFullName} has an invalid 'ratioType' attribute. It should be of type 'string'.`);
+        if (undefined !== jsonObj.ratioSeparator && typeof (jsonObj.ratioSeparator) !== "string")
+            throw new _Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaStatus.InvalidECJson, `The Format ${this._currentItemFullName} has an invalid 'ratioSeparator' attribute. It should be of type 'string'.`);
+        if (undefined !== jsonObj.ratioFormatType && typeof (jsonObj.ratioFormatType) !== "string")
+            throw new _Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaStatus.InvalidECJson, `The Format ${this._currentItemFullName} has an invalid 'ratioFormatType' attribute. It should be of type 'string'.`);
+        // Validate EC version if ratio properties exist - they require EC version 3.3+
+        if (jsonObj.ratioType !== undefined || jsonObj.ratioSeparator !== undefined || jsonObj.ratioFormatType !== undefined) {
+            if (this._ecSpecVersion === undefined || this._ecSpecVersion.readVersion < 3 || (this._ecSpecVersion.readVersion === 3 && this._ecSpecVersion.writeVersion < 3)) {
+                throw new _Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaStatus.InvalidECJson, `The Format ${this._currentItemFullName} has ratio properties that require EC version 3.3 or newer.`);
+            }
+        }
         if (undefined !== jsonObj.stationOffsetSize && typeof (jsonObj.stationOffsetSize) !== "number")
             throw new _Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_0__.ECSchemaStatus.InvalidECJson, `The Format ${this._currentItemFullName} has an invalid 'stationOffsetSize' attribute. It should be of type 'number'.`);
         if (undefined !== jsonObj.stationSeparator && typeof (jsonObj.stationSeparator) !== "string")
@@ -64451,6 +64463,15 @@ class XmlParser extends _AbstractParser__WEBPACK_IMPORTED_MODULE_5__.AbstractPar
         const thousandSeparator = this.getOptionalAttribute(xmlElement, "thousandSeparator");
         const uomSeparator = this.getOptionalAttribute(xmlElement, "uomSeparator");
         const scientificType = this.getOptionalAttribute(xmlElement, "scientificType");
+        const ratioType = this.getOptionalAttribute(xmlElement, "ratioType");
+        const ratioSeparator = this.getOptionalAttribute(xmlElement, "ratioSeparator");
+        const ratioFormatType = this.getOptionalAttribute(xmlElement, "ratioFormatType");
+        // Validate EC version if ratio properties exist - they require EC version 3.3+
+        if (ratioType !== undefined || ratioSeparator !== undefined || ratioFormatType !== undefined) {
+            if (this._ecSpecVersion === undefined || this._ecSpecVersion.readVersion < 3 || (this._ecSpecVersion.readVersion === 3 && this._ecSpecVersion.writeVersion < 3)) {
+                throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidSchemaXML, `The Format ${this._currentItemFullName} has ratio properties that require EC version 3.3 or newer.`);
+            }
+        }
         const stationOffsetSize = this.getOptionalIntAttribute(xmlElement, "stationOffsetSize", `The Format ${this._currentItemFullName} has an invalid 'stationOffsetSize' attribute. It should be a numeric value.`);
         const stationSeparator = this.getOptionalAttribute(xmlElement, "stationSeparator");
         let composite;
@@ -64493,6 +64514,9 @@ class XmlParser extends _AbstractParser__WEBPACK_IMPORTED_MODULE_5__.AbstractPar
             thousandSeparator,
             uomSeparator,
             scientificType,
+            ratioType,
+            ratioSeparator,
+            ratioFormatType,
             stationOffsetSize,
             stationSeparator,
             composite,
@@ -66236,7 +66260,7 @@ class SchemaFormatsProvider {
         // If no matching presentation format was found, use persistence unit format if it matches unit system.
         const persistenceUnit = await kindOfQuantity.persistenceUnit;
         const persistenceUnitSystem = await persistenceUnit?.unitSystem;
-        if (persistenceUnitSystem && unitSystemMatchers.some((matcher) => matcher(persistenceUnitSystem))) {
+        if (persistenceUnit && persistenceUnitSystem && unitSystemMatchers.some((matcher) => matcher(persistenceUnitSystem))) {
             this._formatsRetrieved.add(itemKey.fullName);
             const props = getPersistenceUnitFormatProps(persistenceUnit);
             return this.convertToFormatDefinition(props, kindOfQuantity);
@@ -68833,6 +68857,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+const loggingCategory = "ECClass";
 /**
  * A common abstract class for all of the ECClass types.
  * @public @preview
@@ -68887,7 +68912,13 @@ class ECClass extends _SchemaItem__WEBPACK_IMPORTED_MODULE_9__.SchemaItem {
     async getDerivedClasses() {
         const derivedClasses = [];
         for (const derivedClassKey of this.schema.context.classHierarchy.getDerivedClassKeys(this.key)) {
-            const derivedClass = await this.schema.context.getSchemaItem(derivedClassKey, ECClass);
+            let derivedClass = await this.schema.getItem(derivedClassKey.name, ECClass); // if the derived class is in the same schema this will get it without going to the context
+            if (derivedClass) {
+                derivedClasses.push(derivedClass);
+                continue;
+            }
+            _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.Logger.logInfo(loggingCategory, `Derived class ${derivedClassKey.name} not found in schema ${this.schema.name}, looking in schema context.`);
+            derivedClass = await this.schema.context.getSchemaItem(derivedClassKey, ECClass);
             if (derivedClass)
                 derivedClasses.push(derivedClass);
         }
@@ -69275,18 +69306,56 @@ class ECClass extends _SchemaItem__WEBPACK_IMPORTED_MODULE_9__.SchemaItem {
      */
     async *getAllBaseClasses() {
         for (const baseClassKey of this.schema.context.classHierarchy.getBaseClassKeys(this.key)) {
-            const baseClass = await this.schema.lookupItem(baseClassKey, ECClass);
+            const baseClass = await this.getClassFromReferencesRecursively(baseClassKey); // Search in schema ref tree all the way to the top
             if (baseClass)
                 yield baseClass;
         }
     }
+    /**
+     * gets a class from this schema or its references recursively using the item key
+     * @param itemKey
+     * @returns ECClass if it could be found, undefined otherwise
+     * @internal
+     */
+    async getClassFromReferencesRecursively(itemKey) {
+        const schemaList = [this.schema];
+        while (schemaList.length > 0) {
+            const currentSchema = schemaList.shift();
+            if (currentSchema.schemaKey.compareByName(itemKey.schemaKey)) {
+                const baseClass = await currentSchema.getItem(itemKey.name, ECClass);
+                schemaList.splice(0); // clear the list
+                return baseClass;
+            }
+            schemaList.push(...currentSchema.references);
+        }
+        return undefined;
+    }
     *getAllBaseClassesSync() {
         for (const baseClassKey of this.schema.context.classHierarchy.getBaseClassKeys(this.key)) {
-            const baseClass = this.schema.lookupItemSync(baseClassKey, ECClass);
+            const baseClass = this.getClassFromReferencesRecursivelySync(baseClassKey); // Search in schema ref tree all the way to the top
             if (baseClass)
                 yield baseClass;
         }
     }
+    /**
+     * gets a class from this schema or its references recursively using the item key synchronously
+     * @param itemKey
+     * @returns ECClass if it could be found, undefined otherwise
+     * @internal
+     */
+    getClassFromReferencesRecursivelySync(itemKey) {
+        const schemaList = [this.schema];
+        while (schemaList.length > 0) {
+            const currentSchema = schemaList.shift();
+            if (currentSchema.schemaKey.compareByName(itemKey.schemaKey)) {
+                const baseClass = currentSchema.getItemSync(itemKey.name, ECClass);
+                schemaList.splice(0); // clear the list
+                return baseClass;
+            }
+            schemaList.push(...currentSchema.references);
+        }
+        return undefined;
+    }
     /**
      *
      * @param cache
@@ -70422,6 +70491,9 @@ class Format extends _SchemaItem__WEBPACK_IMPORTED_MODULE_5__.SchemaItem {
     get stationSeparator() { return this._base.stationSeparator; }
     get stationOffsetSize() { return this._base.stationOffsetSize; }
     get stationBaseFactor() { return this._base.stationBaseFactor; }
+    get ratioType() { return this._base.ratioType; }
+    get ratioSeparator() { return this._base.ratioSeparator; }
+    get ratioFormatType() { return this._base.ratioFormatType; }
     get formatTraits() { return this._base.formatTraits; }
     get spacer() { return this._base.spacer; }
     get includeZero() { return this._base.includeZero; }
@@ -70443,10 +70515,13 @@ class Format extends _SchemaItem__WEBPACK_IMPORTED_MODULE_5__.SchemaItem {
     addUnit(unit, label) {
         if (undefined === this._units)
             this._units = [];
-        else { // Validate that a duplicate is not added.
-            for (const existingUnit of this._units) {
-                if (unit.fullName.toLowerCase() === existingUnit[0].fullName.toLowerCase())
-                    throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, `The Format ${this.fullName} has duplicate units, '${unit.fullName}'.`); // TODO: Validation - this should be a validation error not a hard failure.
+        else {
+            const isDuplicateAllowed = this.type === _itwin_core_quantity__WEBPACK_IMPORTED_MODULE_3__.FormatType.Ratio;
+            if (!isDuplicateAllowed) {
+                for (const existingUnit of this._units) {
+                    if (unit.fullName.toLowerCase() === existingUnit[0].fullName.toLowerCase())
+                        throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, `The Format ${this.fullName} has duplicate units, '${unit.fullName}'.`); // TODO: Validation - this should be a validation error not a hard failure.
+                }
             }
         }
         this._units.push([unit, label]);
@@ -70471,37 +70546,87 @@ class Format extends _SchemaItem__WEBPACK_IMPORTED_MODULE_5__.SchemaItem {
             if (formatProps.composite.units.length <= 0 || formatProps.composite.units.length > 4)
                 throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, `The Format ${this.fullName} has an invalid 'Composite' attribute. It should have 1-4 units.`);
         }
+        // For Ratio formats: validate that composite is provided
+        if (this.type === _itwin_core_quantity__WEBPACK_IMPORTED_MODULE_3__.FormatType.Ratio) {
+            const hasComposite = undefined !== formatProps.composite && formatProps.composite.units.length > 0;
+            if (!hasComposite) {
+                throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, `The Format ${this.fullName} is 'Ratio' type and must have 'composite' units.`);
+            }
+        }
     }
     fromJSONSync(formatProps) {
         super.fromJSONSync(formatProps);
         this.typecheck(formatProps);
-        if (undefined === formatProps.composite)
-            return;
-        // Units are separated from the rest of the deserialization because of the need to have separate sync and async implementation
-        for (const unit of formatProps.composite.units) {
-            const newUnit = this.schema.lookupItemSync(unit.name);
-            if (undefined === newUnit || (!_Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(newUnit) && !_InvertedUnit__WEBPACK_IMPORTED_MODULE_4__.InvertedUnit.isInvertedUnit(newUnit)))
-                throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, ``);
-            if (_Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(newUnit))
-                this.addUnit(new _DelayedPromise__WEBPACK_IMPORTED_MODULE_7__.DelayedPromiseWithProps(newUnit.key, async () => newUnit), unit.label);
-            else if (_InvertedUnit__WEBPACK_IMPORTED_MODULE_4__.InvertedUnit.isInvertedUnit(newUnit))
-                this.addUnit(new _DelayedPromise__WEBPACK_IMPORTED_MODULE_7__.DelayedPromiseWithProps(newUnit.key, async () => newUnit), unit.label);
+        // Process composite units
+        if (undefined !== formatProps.composite) {
+            for (const unit of formatProps.composite.units) {
+                const newUnit = this.schema.lookupItemSync(unit.name);
+                if (undefined === newUnit || (!_Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(newUnit) && !_InvertedUnit__WEBPACK_IMPORTED_MODULE_4__.InvertedUnit.isInvertedUnit(newUnit)))
+                    throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, ``);
+                const lazyUnit = _Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(newUnit)
+                    ? new _DelayedPromise__WEBPACK_IMPORTED_MODULE_7__.DelayedPromiseWithProps(newUnit.key, async () => newUnit)
+                    : new _DelayedPromise__WEBPACK_IMPORTED_MODULE_7__.DelayedPromiseWithProps(newUnit.key, async () => newUnit);
+                this.addUnit(lazyUnit, unit.label);
+            }
+            // For Ratio formats with 2 units: validate both units have the same phenomenon
+            if (this.type === _itwin_core_quantity__WEBPACK_IMPORTED_MODULE_3__.FormatType.Ratio && this._units && this._units.length === 2) {
+                const unit1Item = this.schema.lookupItemSync(this._units[0][0].fullName);
+                const unit2Item = this.schema.lookupItemSync(this._units[1][0].fullName);
+                if (!unit1Item || !unit2Item || (!_Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(unit1Item) && !_InvertedUnit__WEBPACK_IMPORTED_MODULE_4__.InvertedUnit.isInvertedUnit(unit1Item)) || (!_Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(unit2Item) && !_InvertedUnit__WEBPACK_IMPORTED_MODULE_4__.InvertedUnit.isInvertedUnit(unit2Item)))
+                    throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, `The Format ${this.fullName} has invalid units.`);
+                const getPhenomenon = (unitItem) => {
+                    if (_Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(unitItem)) {
+                        return unitItem.phenomenon;
+                    }
+                    const invertsUnit = unitItem.invertsUnit;
+                    if (invertsUnit) {
+                        const resolvedUnit = this.schema.lookupItemSync(invertsUnit.fullName);
+                        return resolvedUnit && _Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(resolvedUnit) ? resolvedUnit.phenomenon : undefined;
+                    }
+                    return undefined;
+                };
+                const phenomenon1 = getPhenomenon(unit1Item);
+                const phenomenon2 = getPhenomenon(unit2Item);
+                if (phenomenon1?.fullName !== phenomenon2?.fullName) {
+                    throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, `The Format ${this.fullName} has 2-unit composite with different phenomena. Both units must have the same phenomenon.`);
+                }
+            }
         }
     }
     async fromJSON(formatProps) {
         await super.fromJSON(formatProps);
         this.typecheck(formatProps);
-        if (undefined === formatProps.composite)
-            return;
-        // Units are separated from the rest of the deserialization because of the need to have separate sync and async implementation
-        for (const unit of formatProps.composite.units) {
-            const newUnit = await this.schema.lookupItem(unit.name);
-            if (undefined === newUnit || (!_Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(newUnit) && !_InvertedUnit__WEBPACK_IMPORTED_MODULE_4__.InvertedUnit.isInvertedUnit(newUnit)))
-                throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, ``);
-            if (_Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(newUnit))
-                this.addUnit(new _DelayedPromise__WEBPACK_IMPORTED_MODULE_7__.DelayedPromiseWithProps(newUnit.key, async () => newUnit), unit.label);
-            else if (_InvertedUnit__WEBPACK_IMPORTED_MODULE_4__.InvertedUnit.isInvertedUnit(newUnit))
-                this.addUnit(new _DelayedPromise__WEBPACK_IMPORTED_MODULE_7__.DelayedPromiseWithProps(newUnit.key, async () => newUnit), unit.label);
+        // Process composite units
+        if (undefined !== formatProps.composite) {
+            for (const unit of formatProps.composite.units) {
+                const newUnit = await this.schema.lookupItem(unit.name);
+                if (undefined === newUnit || (!_Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(newUnit) && !_InvertedUnit__WEBPACK_IMPORTED_MODULE_4__.InvertedUnit.isInvertedUnit(newUnit)))
+                    throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, ``);
+                const lazyUnit = _Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(newUnit)
+                    ? new _DelayedPromise__WEBPACK_IMPORTED_MODULE_7__.DelayedPromiseWithProps(newUnit.key, async () => newUnit)
+                    : new _DelayedPromise__WEBPACK_IMPORTED_MODULE_7__.DelayedPromiseWithProps(newUnit.key, async () => newUnit);
+                this.addUnit(lazyUnit, unit.label);
+            }
+            // For Ratio formats with 2 units: validate both units have the same phenomenon
+            if (this.type === _itwin_core_quantity__WEBPACK_IMPORTED_MODULE_3__.FormatType.Ratio && this._units && this._units.length === 2) {
+                const unit1Item = await this.schema.lookupItem(this._units[0][0].fullName);
+                const unit2Item = await this.schema.lookupItem(this._units[1][0].fullName);
+                if (!unit1Item || !unit2Item || (!_Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(unit1Item) && !_InvertedUnit__WEBPACK_IMPORTED_MODULE_4__.InvertedUnit.isInvertedUnit(unit1Item)) || (!_Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(unit2Item) && !_InvertedUnit__WEBPACK_IMPORTED_MODULE_4__.InvertedUnit.isInvertedUnit(unit2Item)))
+                    throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, `The Format ${this.fullName} has invalid units.`);
+                // Helper to extract phenomenon from Unit or InvertedUnit
+                const getPhenomenon = async (unitItem) => {
+                    if (_Unit__WEBPACK_IMPORTED_MODULE_6__.Unit.isUnit(unitItem)) {
+                        return unitItem.phenomenon;
+                    }
+                    const invertsUnit = await unitItem.invertsUnit;
+                    return invertsUnit ? invertsUnit.phenomenon : undefined;
+                };
+                const phenomenon1 = await getPhenomenon(unit1Item);
+                const phenomenon2 = await getPhenomenon(unit2Item);
+                if (phenomenon1?.fullName !== phenomenon2?.fullName) {
+                    throw new _Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_2__.ECSchemaStatus.InvalidECJson, `The Format ${this.fullName} has 2-unit composite with different phenomena. Both units must have the same phenomenon.`);
+                }
+            }
         }
     }
     /**
@@ -70538,6 +70663,15 @@ class Format extends _SchemaItem__WEBPACK_IMPORTED_MODULE_5__.SchemaItem {
             if (" " !== this.stationSeparator)
                 schemaJson.stationSeparator = this.stationSeparator;
         }
+        // Only include ratio properties for EC version 3.3+
+        if (_itwin_core_quantity__WEBPACK_IMPORTED_MODULE_3__.FormatType.Ratio === this.type && this.schema.originalECSpecMajorVersion === 3 && this.schema.originalECSpecMinorVersion !== undefined && this.schema.originalECSpecMinorVersion >= 3) {
+            if (undefined !== this.ratioType)
+                schemaJson.ratioType = this.ratioType;
+            if (undefined !== this.ratioSeparator)
+                schemaJson.ratioSeparator = this.ratioSeparator;
+            if (undefined !== this.ratioFormatType)
+                schemaJson.ratioFormatType = this.ratioFormatType;
+        }
         if (undefined === this.units)
             return schemaJson;
         schemaJson.composite = {};
@@ -70569,6 +70703,15 @@ class Format extends _SchemaItem__WEBPACK_IMPORTED_MODULE_5__.SchemaItem {
             itemElement.setAttribute("minWidth", this.minWidth.toString());
         if (undefined !== this.scientificType)
             itemElement.setAttribute("scientificType", this.scientificType);
+        // Only include ratio properties for EC version 3.3+
+        if (this.schema.originalECSpecMajorVersion === 3 && this.schema.originalECSpecMinorVersion !== undefined && this.schema.originalECSpecMinorVersion >= 3) {
+            if (undefined !== this.ratioType)
+                itemElement.setAttribute("ratioType", this.ratioType);
+            if (undefined !== this.ratioSeparator)
+                itemElement.setAttribute("ratioSeparator", this.ratioSeparator);
+            if (undefined !== this.ratioFormatType)
+                itemElement.setAttribute("ratioFormatType", this.ratioFormatType);
+        }
         if (undefined !== this.stationOffsetSize)
             itemElement.setAttribute("stationOffsetSize", this.stationOffsetSize.toString());
         const formatTraits = (0,_itwin_core_quantity__WEBPACK_IMPORTED_MODULE_3__.formatTraitsToArray)(this.formatTraits);
@@ -71315,6 +71458,9 @@ class OverrideFormat {
     get type() { return this.parent.type; }
     get minWidth() { return this.parent.minWidth; }
     get scientificType() { return this.parent.scientificType; }
+    get ratioType() { return this.parent.ratioType; }
+    get ratioSeparator() { return this.parent.ratioSeparator; }
+    get ratioFormatType() { return this.parent.ratioFormatType; }
     get showSignOption() { return this.parent.showSignOption; }
     get decimalSeparator() { return this.parent.decimalSeparator; }
     get thousandSeparator() { return this.parent.thousandSeparator; }
@@ -71339,7 +71485,7 @@ class OverrideFormat {
         for (const [unit, unitLabel] of this._units) {
             const unitSchema = koqSchema.context.getSchemaSync(unit.schemaKey);
             if (unitSchema === undefined)
-                throw new _Exception__WEBPACK_IMPORTED_MODULE_3__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_3__.ECSchemaStatus.InvalidECJson, `The unit schema ${unit.schemaKey} is not found in the context.`);
+                throw new _Exception__WEBPACK_IMPORTED_MODULE_3__.ECSchemaError(_Exception__WEBPACK_IMPORTED_MODULE_3__.ECSchemaStatus.InvalidECJson, `The unit schema ${unit.schemaKey.toString()} is not found in the context.`);
             fullName += "[";
             fullName += _Deserialization_XmlSerializationUtils__WEBPACK_IMPORTED_MODULE_0__.XmlSerializationUtils.createXmlTypedName(koqSchema, unitSchema, unit.name);
             if (unitLabel !== undefined)
@@ -88550,6 +88696,10 @@ class IModelApp {
      * @beta
      */
     static applicationLogoCard;
+    /** Applications may implement this method to supply a Logo Card footer which will always be placed last.
+     * @beta
+     */
+    static applicationLogoCardFooter;
     /** Make a new Logo Card. Call this method from your implementation of [[IModelApp.applicationLogoCard]]
      * @param opts Options for Logo Card
      * @beta
@@ -102601,6 +102751,9 @@ class ScreenViewport extends Viewport {
             for (const ref of this.getTileTreeRefs()) {
                 promises.push(ref.addAttributions(logos, this));
             }
+            if (undefined !== _IModelApp__WEBPACK_IMPORTED_MODULE_10__.IModelApp.applicationLogoCardFooter) {
+                logos.appendChild(_IModelApp__WEBPACK_IMPORTED_MODULE_10__.IModelApp.applicationLogoCardFooter());
+            }
             await Promise.all(promises);
             ev.stopPropagation();
         };
@@ -108178,7 +108331,9 @@ function createMeshArgs(mesh) {
     if (!mesh.triangles || mesh.triangles.isEmpty || mesh.points.length === 0)
         return undefined;
     const texture = mesh.displayParams.textureMapping?.texture;
-    const textureMapping = texture && mesh.uvParams.length > 0 ? { texture, uvParams: mesh.uvParams } : undefined;
+    const useConstantLod = mesh.displayParams.textureMapping?.params?.useConstantLod;
+    const constantLodParams = mesh.displayParams.textureMapping?.params?.constantLodParams;
+    const textureMapping = texture && mesh.uvParams.length > 0 ? { texture, uvParams: mesh.uvParams, useConstantLod, constantLodParams } : undefined;
     const colors = new _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.ColorIndex();
     mesh.colorMap.toColorIndex(colors, mesh.colors);
     const features = new _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.FeatureIndex();
@@ -149957,7 +150112,7 @@ function readPnts(stream, dataOffset, pnts) {
 }
 async function decodeDracoPointCloud(buf) {
     try {
-        const dracoLoader = (await __webpack_require__.e(/*! import() */ "vendors-common_temp_node_modules_pnpm_loaders_gl_draco_4_3_4_node_modules_loaders_gl_draco_di-40e622").then(__webpack_require__.bind(__webpack_require__, /*! @loaders.gl/draco */ "../../common/temp/node_modules/.pnpm/@loaders.gl+draco@4.3.4/node_modules/@loaders.gl/draco/dist/index.js"))).DracoLoader;
+        const dracoLoader = (await __webpack_require__.e(/*! import() */ "vendors-common_temp_node_modules_pnpm_loaders_gl_draco_4_3_4__loaders_gl_core_4_3_4_node_modu-4c1fc9").then(__webpack_require__.bind(__webpack_require__, /*! @loaders.gl/draco */ "../../common/temp/node_modules/.pnpm/@loaders.gl+draco@4.3.4_@loaders.gl+core@4.3.4/node_modules/@loaders.gl/draco/dist/index.js"))).DracoLoader;
         const mesh = await dracoLoader.parse(buf, {});
         if (mesh.topology !== "point-list")
             return undefined;
@@ -161396,14 +161551,47 @@ class GltfReader {
         }
     }
     createDisplayParams(material, hasBakedLighting, isPointPrimitive = false) {
+        let constantLodParamProps;
+        let normalMapUseConstantLod = false;
+        if (!(0,_common_gltf_GltfSchema__WEBPACK_IMPORTED_MODULE_12__.isGltf1Material)(material)) {
+            // NOTE: EXT_textureInfo_constant_lod is not supported for occlusionTexture and metallicRoughnessTexture
+            // Use the same texture fallback logic as extractTextureId
+            const textureInfo = material.pbrMetallicRoughness?.baseColorTexture ?? material.emissiveTexture;
+            const extConstantLod = textureInfo?.extensions?.EXT_textureInfo_constant_lod;
+            const offset = extConstantLod?.offset;
+            extConstantLod ? constantLodParamProps = {
+                repetitions: extConstantLod?.repetitions,
+                offset: offset ? { x: offset[0], y: offset[1] } : undefined,
+                minDistClamp: extConstantLod?.minClampDistance,
+                maxDistClamp: extConstantLod?.maxClampDistance,
+            } : undefined;
+            // Normal map only uses constant LOD if both the base texture and normal texture have the extension
+            normalMapUseConstantLod = extConstantLod !== undefined && material.normalTexture?.extensions?.EXT_textureInfo_constant_lod !== undefined;
+        }
         const isTransparent = this.isMaterialTransparent(material);
         const textureId = this.extractTextureId(material);
         const normalMapId = this.extractNormalMapId(material);
-        let textureMapping = (undefined !== textureId || undefined !== normalMapId) ? this.findTextureMapping(textureId, isTransparent, normalMapId) : undefined;
+        let textureMapping = (undefined !== textureId || undefined !== normalMapId) ? this.findTextureMapping(textureId, isTransparent, normalMapId, constantLodParamProps, normalMapUseConstantLod) : undefined;
         const color = colorFromMaterial(material, isTransparent);
         let renderMaterial;
-        if (undefined !== textureMapping && undefined !== textureMapping.normalMapParams) {
-            const args = { diffuse: { color }, specular: { color: _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.ColorDef.white }, textureMapping };
+        if (undefined !== textureMapping) {
+            // Convert result of findTextureMapping (TextureMapping object) to MaterialTextureMappingProps interface
+            const textureMappingProps = {
+                texture: textureMapping.texture,
+                normalMapParams: textureMapping.normalMapParams,
+                mode: textureMapping.params.mode,
+                transform: textureMapping.params.textureMatrix,
+                weight: textureMapping.params.weight,
+                worldMapping: textureMapping.params.worldMapping,
+                useConstantLod: textureMapping.params.useConstantLod,
+                constantLodProps: textureMapping.params.useConstantLod ? {
+                    repetitions: textureMapping.params.constantLodParams.repetitions,
+                    offset: textureMapping.params.constantLodParams.offset,
+                    minDistClamp: textureMapping.params.constantLodParams.minDistClamp,
+                    maxDistClamp: textureMapping.params.constantLodParams.maxDistClamp,
+                } : undefined,
+            };
+            const args = { diffuse: { color }, specular: { color: _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.ColorDef.white }, textureMapping: textureMappingProps };
             renderMaterial = _IModelApp__WEBPACK_IMPORTED_MODULE_3__.IModelApp.renderSystem.createRenderMaterial(args);
             // DisplayParams doesn't want a separate texture mapping if the material already has one.
             textureMapping = undefined;
@@ -161415,7 +161603,30 @@ class GltfReader {
                 width = pointStyle.diameter;
             }
         }
-        return new _common_internal_render_DisplayParams__WEBPACK_IMPORTED_MODULE_8__.DisplayParams(_common_internal_render_DisplayParams__WEBPACK_IMPORTED_MODULE_8__.DisplayParams.Type.Mesh, color, color, width, _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.LinePixels.Solid, _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.FillFlags.None, renderMaterial, undefined, hasBakedLighting, textureMapping);
+        // Process BENTLEY_materials_planar_fill extension
+        let fillFlags = _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.FillFlags.None;
+        if (!(0,_common_gltf_GltfSchema__WEBPACK_IMPORTED_MODULE_12__.isGltf1Material)(material)) {
+            const planarFill = material.extensions?.BENTLEY_materials_planar_fill;
+            if (planarFill) {
+                // Map wireframeFill: 0=NONE (no fill flags), 1=ALWAYS (Always flag), 2=TOGGLE (ByView flag)
+                const wireframeFill = planarFill.wireframeFill ?? 0;
+                if (wireframeFill === 1) {
+                    fillFlags |= _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.FillFlags.Always;
+                }
+                else if (wireframeFill === 2) {
+                    fillFlags |= _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.FillFlags.ByView;
+                }
+                // Map backgroundFill to Background flag
+                if (planarFill.backgroundFill === true) {
+                    fillFlags |= _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.FillFlags.Background;
+                }
+                // Map behind to Behind flag
+                if (planarFill.behind === true) {
+                    fillFlags |= _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.FillFlags.Behind;
+                }
+            }
+        }
+        return new _common_internal_render_DisplayParams__WEBPACK_IMPORTED_MODULE_8__.DisplayParams(_common_internal_render_DisplayParams__WEBPACK_IMPORTED_MODULE_8__.DisplayParams.Type.Mesh, color, color, width, _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.LinePixels.Solid, fillFlags, renderMaterial, undefined, hasBakedLighting, textureMapping);
     }
     readMeshPrimitives(node, featureTable, thisTransform, thisBias, instances) {
         const meshes = [];
@@ -162217,7 +162428,7 @@ class GltfReader {
             if (_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.ProcessDetector.isIEBrowser) {
                 throw new Error("Unsupported browser for Draco decoding");
             }
-            const dracoLoader = (await __webpack_require__.e(/*! import() */ "vendors-common_temp_node_modules_pnpm_loaders_gl_draco_4_3_4_node_modules_loaders_gl_draco_di-40e622").then(__webpack_require__.bind(__webpack_require__, /*! @loaders.gl/draco */ "../../common/temp/node_modules/.pnpm/@loaders.gl+draco@4.3.4/node_modules/@loaders.gl/draco/dist/index.js"))).DracoLoader;
+            const dracoLoader = (await __webpack_require__.e(/*! import() */ "vendors-common_temp_node_modules_pnpm_loaders_gl_draco_4_3_4__loaders_gl_core_4_3_4_node_modu-4c1fc9").then(__webpack_require__.bind(__webpack_require__, /*! @loaders.gl/draco */ "../../common/temp/node_modules/.pnpm/@loaders.gl+draco@4.3.4_@loaders.gl+core@4.3.4/node_modules/@loaders.gl/draco/dist/index.js"))).DracoLoader;
             await Promise.all(dracoMeshes.map(async (x) => this.decodeDracoMesh(x, dracoLoader)));
         }
         catch (err) {
@@ -162361,7 +162572,7 @@ class GltfReader {
         });
         return renderTexture ?? false;
     }
-    findTextureMapping(id, isTransparent, normalMapId) {
+    findTextureMapping(id, isTransparent, normalMapId, constantLodParamProps, normalMapUseConstantLod = false) {
         if (undefined === id && undefined === normalMapId)
             return undefined;
         let texture;
@@ -162383,16 +162594,18 @@ class GltfReader {
                 nMap = {
                     normalMap,
                     greenUp,
+                    useConstantLod: normalMapUseConstantLod,
                 };
             }
             else {
                 texture = normalMap;
-                nMap = { greenUp };
+                nMap = { greenUp, useConstantLod: normalMapUseConstantLod };
             }
         }
         if (!texture)
             return undefined;
-        const textureMapping = new _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.TextureMapping(texture, new _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.TextureMapping.Params());
+        const useConstantLod = constantLodParamProps !== undefined;
+        const textureMapping = new _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.TextureMapping(texture, new _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.TextureMapping.Params({ useConstantLod, constantLodProps: constantLodParamProps }));
         textureMapping.normalMapParams = nMap;
         return textureMapping;
     }
@@ -162429,7 +162642,7 @@ async function readGltfTemplate(args) {
 }
 /** Produce a [[RenderGraphic]] from a [glTF](https://www.khronos.org/gltf/) asset suitable for use in [view decorations]($docs/learning/frontend/ViewDecorations).
  * @returns a graphic produced from the glTF asset's default scene, or `undefined` if a graphic could not be produced from the asset.
- * The returned graphic also includes the bounding boxes of the glTF model in world and local coordiantes.
+ * The returned graphic also includes the bounding boxes of the glTF model in world and local coordinates.
  * @note Support for the full [glTF 2.0 specification](https://www.khronos.org/registry/glTF/specs/2.0/glTF-2.0.html) is currently a work in progress.
  * If a particular glTF asset fails to load and/or display properly, please
  * [submit an issue](https://github.com/iTwin/itwinjs-core/issues).
@@ -162457,6 +162670,7 @@ class GltfGraphicsReader extends GltfReader {
     _contentRange;
     _transform;
     _isLeaf;
+    _useViewportRenderMode;
     binaryData; // strictly for tests
     meshes; // strictly for tests
     constructor(props, args) {
@@ -162470,6 +162684,7 @@ class GltfGraphicsReader extends GltfReader {
         this._contentRange = args.contentRange;
         this._transform = args.transform;
         this._isLeaf = true !== args.hasChildren;
+        this._useViewportRenderMode = args.useViewportRenderMode ?? false;
         this.binaryData = props.binaryData;
         const pickableId = args.pickableOptions?.id;
         if (pickableId) {
@@ -162480,7 +162695,8 @@ class GltfGraphicsReader extends GltfReader {
     get viewFlagOverrides() {
         return {
             whiteOnWhiteReversal: false,
-            renderMode: _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.RenderMode.SmoothShade,
+            // Don't override renderMode if using viewport's render mode - let the viewport control it.
+            renderMode: this._useViewportRenderMode ? undefined : _itwin_core_common__WEBPACK_IMPORTED_MODULE_2__.RenderMode.SmoothShade,
         };
     }
     get meshElementIdToFeatureIndex() {
@@ -304088,6 +304304,8 @@ class BaseFormat {
     _stationOffsetSize; // required when type is station; positive integer > 0
     _stationBaseFactor; // optional positive integer base factor for station formatting; default is 1
     _ratioType; // required if type is ratio; options: oneToN, NToOne, ValueBased, useGreatestCommonDivisor
+    _ratioFormatType; // defaults to Decimal if not specified
+    _ratioSeparator; // default is ":"; separator character used in ratio formatting
     _azimuthBase; // value always clockwise from north
     _azimuthBaseUnit; // unit for azimuthBase value
     _azimuthCounterClockwise; // if set to true, azimuth values are returned counter-clockwise from base
@@ -304109,6 +304327,10 @@ class BaseFormat {
     set scientificType(scientificType) { this._scientificType = scientificType; }
     get ratioType() { return this._ratioType; }
     set ratioType(ratioType) { this._ratioType = ratioType; }
+    get ratioFormatType() { return this._ratioFormatType; }
+    set ratioFormatType(ratioFormatType) { this._ratioFormatType = ratioFormatType; }
+    get ratioSeparator() { return this._ratioSeparator; }
+    set ratioSeparator(ratioSeparator) { this._ratioSeparator = ratioSeparator; }
     get showSignOption() { return this._showSignOption; }
     set showSignOption(showSignOption) { this._showSignOption = showSignOption; }
     get decimalSeparator() { return this._decimalSeparator; }
@@ -304177,6 +304399,22 @@ class BaseFormat {
             if (undefined === formatProps.ratioType)
                 throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidJson, `The Format ${this.name} is 'Ratio' type therefore the attribute 'ratioType' is required.`);
             this._ratioType = (0,_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.parseRatioType)(formatProps.ratioType, this.name);
+            if (undefined !== formatProps.ratioSeparator) {
+                if (typeof (formatProps.ratioSeparator) !== "string")
+                    throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidJson, `The Format ${this.name} has an invalid 'ratioSeparator' attribute. It should be of type 'string'.`);
+                if (formatProps.ratioSeparator.length !== 1)
+                    throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidJson, `The Format ${this.name} has an invalid 'ratioSeparator' attribute. It should be a one character string.`);
+                this._ratioSeparator = formatProps.ratioSeparator;
+            }
+            else {
+                this._ratioSeparator = ":"; // Apply default
+            }
+            if (undefined !== formatProps.ratioFormatType) {
+                this._ratioFormatType = (0,_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.parseRatioFormatType)(formatProps.ratioFormatType, this.name);
+            }
+            else {
+                this._ratioFormatType = _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.RatioFormatType.Decimal; // Apply default
+            }
         }
         if (undefined !== formatProps.roundFactor) { // optional; default is 0.0
             if (typeof (formatProps.roundFactor) !== "number")
@@ -304301,6 +304539,8 @@ class Format extends BaseFormat {
         newFormat._azimuthBaseUnit = this._azimuthBaseUnit;
         newFormat._azimuthCounterClockwise = this._azimuthCounterClockwise;
         newFormat._ratioType = this._ratioType;
+        newFormat._ratioFormatType = this._ratioFormatType;
+        newFormat._ratioSeparator = this._ratioSeparator;
         newFormat._revolutionUnit = this._revolutionUnit;
         newFormat._customProps = this._customProps;
         this._units && (newFormat._units = [...this._units]);
@@ -304361,25 +304601,28 @@ class Format extends BaseFormat {
                     throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidJson, `The Format ${this.name} has a Composite with an invalid 'units' attribute. It must be of type 'array'`);
                 }
                 if (jsonObj.composite.units.length > 0 && jsonObj.composite.units.length <= 4) { // Composite requires 1-4 units
-                    for (const nextUnit of jsonObj.composite.units) {
-                        if (this._units) {
-                            for (const existingUnit of this._units) {
-                                const unitObj = existingUnit[0].name;
-                                if (unitObj.toLowerCase() === nextUnit.unit.name.toLowerCase()) {
-                                    throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidJson, `The unit ${unitObj} has a duplicate name.`);
-                                }
+                    const isDuplicateAllowed = this.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Ratio;
+                    const seenUnits = new Set();
+                    this._units = [];
+                    for (const unitSpec of jsonObj.composite.units) {
+                        if (!isDuplicateAllowed) {
+                            const unitName = unitSpec.unit.name.toLowerCase();
+                            const existingName = seenUnits.has(unitName);
+                            if (existingName) {
+                                throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidJson, `The Format ${this.name} contains duplicate units: '${unitSpec.unit.name}'`);
                             }
+                            seenUnits.add(unitName);
                         }
-                        if (undefined === this._units) {
-                            this._units = [];
-                        }
-                        this._units.push([nextUnit.unit, nextUnit.label]);
+                        this._units.push([unitSpec.unit, unitSpec.label]);
                     }
                 }
             }
             if (undefined === this.units || this.units.length === 0)
                 throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidJson, `The Format ${this.name} has a Composite with no valid 'units'`);
         }
+        if (this.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Ratio && (!this._units || this._units.length === 0)) {
+            throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidJson, `The Format ${this.name} is 'Ratio' type and must have 'composite' units.`);
+        }
         if (this.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Azimuth || this.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Bearing) {
             this._azimuthBaseUnit = jsonObj.azimuthBaseUnit;
             this._revolutionUnit = jsonObj.revolutionUnit;
@@ -304446,6 +304689,8 @@ class Format extends BaseFormat {
             uomSeparator: this.uomSeparator,
             scientificType: this.scientificType ? this.scientificType : undefined,
             ratioType: this.ratioType,
+            ratioFormatType: this.ratioFormatType,
+            ratioSeparator: this.ratioSeparator,
             stationOffsetSize: this.stationOffsetSize,
             stationSeparator: this.stationSeparator,
             stationBaseFactor: this.stationBaseFactor,
@@ -304490,6 +304735,15 @@ async function resolveFormatProps(formatName, unitsProvider, jsonObj) {
             const unit = await resolveCompositeUnit(unitsProvider, entry.name);
             return { unit, label: entry.label };
         }));
+        // For Ratio formats with 2 units: validate both units have the same phenomenon
+        const formatType = (0,_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.parseFormatType)(jsonObj.type, formatName);
+        if (formatType === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Ratio && units.length === 2) {
+            const phenomenon1 = units[0].unit.phenomenon;
+            const phenomenon2 = units[1].unit.phenomenon;
+            if (phenomenon1 !== phenomenon2) {
+                throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidJson, `The Format ${formatName} has 2-unit composite with different phenomena. Both units must have the same phenomenon. Found '${phenomenon1}' and '${phenomenon2}'.`);
+            }
+        }
     }
     let azimuthBaseUnit, revolutionUnit;
     const type = (0,_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.parseFormatType)(jsonObj.type, formatName);
@@ -304530,6 +304784,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   FormatTraits: () => (/* binding */ FormatTraits),
 /* harmony export */   FormatType: () => (/* binding */ FormatType),
 /* harmony export */   FractionalPrecision: () => (/* binding */ FractionalPrecision),
+/* harmony export */   RatioFormatType: () => (/* binding */ RatioFormatType),
 /* harmony export */   RatioType: () => (/* binding */ RatioType),
 /* harmony export */   ScientificType: () => (/* binding */ ScientificType),
 /* harmony export */   ShowSignOption: () => (/* binding */ ShowSignOption),
@@ -304543,6 +304798,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   parseFormatType: () => (/* binding */ parseFormatType),
 /* harmony export */   parseFractionalPrecision: () => (/* binding */ parseFractionalPrecision),
 /* harmony export */   parsePrecision: () => (/* binding */ parsePrecision),
+/* harmony export */   parseRatioFormatType: () => (/* binding */ parseRatioFormatType),
 /* harmony export */   parseRatioType: () => (/* binding */ parseRatioType),
 /* harmony export */   parseScientificType: () => (/* binding */ parseScientificType),
 /* harmony export */   parseShowSignOption: () => (/* binding */ parseShowSignOption),
@@ -304687,6 +304943,16 @@ var RatioType;
     /**  scales the input ratio to its simplest integer form using the greatest common divisor (GCD) of the values. e.g. 0.3 turns into 3:10 */
     RatioType["UseGreatestCommonDivisor"] = "UseGreatestCommonDivisor";
 })(RatioType || (RatioType = {}));
+/** The format type for the numbers within a ratio.
+ * @beta
+ */
+var RatioFormatType;
+(function (RatioFormatType) {
+    /** Decimal display (ie 2.125) */
+    RatioFormatType["Decimal"] = "Decimal";
+    /** Fractional display (ie 2-1/8) */
+    RatioFormatType["Fractional"] = "Fractional";
+})(RatioFormatType || (RatioFormatType = {}));
 /** Determines how the sign of values are displayed
  * @beta */
 var ShowSignOption;
@@ -304732,6 +304998,18 @@ function parseRatioType(ratioType, formatName) {
     }
     throw new _Exception__WEBPACK_IMPORTED_MODULE_0__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_0__.QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'ratioType' attribute.`);
 }
+/**  @beta   */
+function parseRatioFormatType(ratioFormatType, formatName) {
+    const normalizedValue = ratioFormatType.toLowerCase();
+    for (const key in RatioFormatType) {
+        if (RatioFormatType.hasOwnProperty(key)) {
+            const enumValue = RatioFormatType[key];
+            if (enumValue.toLowerCase() === normalizedValue)
+                return enumValue;
+        }
+    }
+    throw new _Exception__WEBPACK_IMPORTED_MODULE_0__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_0__.QuantityStatus.InvalidJson, `The Format ${formatName} has an invalid 'ratioFormatType' attribute.`);
+}
 /** @beta    */
 function parseShowSignOption(showSignOption, formatName) {
     switch (showSignOption.toLowerCase()) {
@@ -304893,10 +305171,18 @@ function parsePrecision(precision, type, formatName) {
         case FormatType.Decimal:
         case FormatType.Scientific:
         case FormatType.Station:
-        case FormatType.Ratio:
         case FormatType.Bearing:
         case FormatType.Azimuth:
             return parseDecimalPrecision(precision, formatName);
+        case FormatType.Ratio:
+            // Ratio type can use either decimal or fractional precision depending on ratioFormatType
+            // Try decimal first, if it fails, try fractional
+            try {
+                return parseDecimalPrecision(precision, formatName);
+            }
+            catch {
+                return parseFractionalPrecision(precision, formatName);
+            }
         case FormatType.Fractional:
             return parseFractionalPrecision(precision, formatName);
         default:
@@ -304920,8 +305206,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ });
 /* harmony import */ var _Constants__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../Constants */ "../../core/quantity/lib/esm/Constants.js");
 /* harmony import */ var _Exception__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../Exception */ "../../core/quantity/lib/esm/Exception.js");
-/* harmony import */ var _FormatEnums__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./FormatEnums */ "../../core/quantity/lib/esm/Formatter/FormatEnums.js");
-/* harmony import */ var _Quantity__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../Quantity */ "../../core/quantity/lib/esm/Quantity.js");
+/* harmony import */ var _FormatterSpec__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./FormatterSpec */ "../../core/quantity/lib/esm/Formatter/FormatterSpec.js");
+/* harmony import */ var _FormatEnums__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./FormatEnums */ "../../core/quantity/lib/esm/Formatter/FormatEnums.js");
+/* harmony import */ var _Quantity__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ../Quantity */ "../../core/quantity/lib/esm/Quantity.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -304933,6 +305220,7 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
 /**  rounding additive
  * @internal
  */
@@ -305033,7 +305321,7 @@ class Formatter {
     static integerPartToText(wholePart, spec) {
         // build invariant string represent wholePart
         let formattedValue = wholePart.toFixed(0);
-        if ((formattedValue.length > 3) && (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.Use1000Separator) && (spec.format.thousandSeparator.length > 0))) {
+        if ((formattedValue.length > 3) && (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.Use1000Separator) && (spec.format.thousandSeparator.length > 0))) {
             let numSeparators = Math.floor(formattedValue.length / 3);
             let groupLength = formattedValue.length % 3;
             if (groupLength === 0) {
@@ -305080,7 +305368,7 @@ class Formatter {
         else {
             componentText = Formatter.formatMagnitude(compositeValue, spec);
         }
-        if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.ShowUnitLabel)) {
+        if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.ShowUnitLabel)) {
             componentText = componentText + spec.format.uomSeparator + label;
         }
         return componentText;
@@ -305100,12 +305388,11 @@ class Formatter {
                 throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidCompositeFormat, `The Format ${spec.format.name} has a invalid unit specification.`);
             if (i > 0 && unitConversion.offset !== 0) // offset should only ever be defined for major unit
                 throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidCompositeFormat, `The Format ${spec.format.name} has a invalid unit specification.`);
-            let unitValue = 0.0;
-            if (spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Ratio) {
-                if (1 !== (spec.format.units?.length ?? 0))
-                    throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidCompositeFormat, `The Format '${spec.format.name}' with type 'ratio' must have exactly one unit.`);
+            // Handle ratio format with composite units
+            if (spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Ratio) {
+                let ratioUnitValue = 0.0;
                 try {
-                    unitValue = (0,_Quantity__WEBPACK_IMPORTED_MODULE_3__.applyConversion)(remainingMagnitude, unitConversion) + this.FPV_MINTHRESHOLD;
+                    ratioUnitValue = (0,_Quantity__WEBPACK_IMPORTED_MODULE_4__.applyConversion)(remainingMagnitude, unitConversion) + this.FPV_MINTHRESHOLD;
                 }
                 catch (e) {
                     // The "InvertingZero" error is thrown when the value is zero and the conversion factor is inverted.
@@ -305113,12 +305400,13 @@ class Formatter {
                     if (e instanceof _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError && e.errorNumber === _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvertingZero) {
                         return { componentText: "1:0", isNegative: false };
                     }
+                    throw e;
                 }
-                compositeStrings.push(this.formatRatio(unitValue, spec));
-                isNegative = unitValue < 0;
+                compositeStrings.push(this.formatRatio(ratioUnitValue, spec));
+                isNegative = ratioUnitValue < 0;
                 continue;
             }
-            unitValue = (0,_Quantity__WEBPACK_IMPORTED_MODULE_3__.applyConversion)(remainingMagnitude, unitConversion) + this.FPV_MINTHRESHOLD;
+            let unitValue = (0,_Quantity__WEBPACK_IMPORTED_MODULE_4__.applyConversion)(remainingMagnitude, unitConversion) + this.FPV_MINTHRESHOLD;
             if (0 === i) {
                 // Only set isNegative from the first (major) unit conversion
                 isNegative = unitValue < 0;
@@ -305126,16 +305414,16 @@ class Formatter {
                 // but use higher precision if the format specifies it
                 const precisionScale = Math.pow(10, Math.max(8, spec.format.precision));
                 unitValue = Math.floor(unitValue * precisionScale + FPV_ROUNDFACTOR) / precisionScale;
-                if ((Math.abs(unitValue) < 0.0001) && spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.ZeroEmpty))
+                if ((Math.abs(unitValue) < 0.0001) && spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.ZeroEmpty))
                     return { componentText: "", isNegative: false };
             }
             if (i < (spec.format.units?.length ?? 0) - 1) {
                 let wholePart = Math.trunc(unitValue);
                 // Check if the remaining fractional part will round up to a full unit in the next (smaller) component
-                if (spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Fractional && i === spec.unitConversions.length - 2) {
+                if (spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Fractional && i === spec.unitConversions.length - 2) {
                     // For the second-to-last unit with fractional formatting, check if rounding causes carry-over
                     const fractionalPart = unitValue - wholePart;
-                    const nextUnitValue = (0,_Quantity__WEBPACK_IMPORTED_MODULE_3__.applyConversion)(fractionalPart, spec.unitConversions[i + 1].conversion);
+                    const nextUnitValue = (0,_Quantity__WEBPACK_IMPORTED_MODULE_4__.applyConversion)(fractionalPart, spec.unitConversions[i + 1].conversion);
                     // Create a FractionalNumeric to determine what the rounded value would be
                     const fn = new FractionalNumeric(Math.abs(nextUnitValue), spec.format.precision, true);
                     // If the fractional numeric rounds to a whole unit (integral part increased due to rounding)
@@ -305165,18 +305453,18 @@ class Formatter {
      */
     static formatMagnitude(magnitude, spec) {
         let posMagnitude = Math.abs(magnitude);
-        if ((Math.abs(posMagnitude) < 0.0001) && spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.ZeroEmpty))
+        if ((Math.abs(posMagnitude) < 0.0001) && spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.ZeroEmpty))
             return "";
-        if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.ApplyRounding))
+        if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.ApplyRounding))
             posMagnitude = Math.abs(Formatter.roundDouble(magnitude, spec.format.roundFactor));
-        const isSci = ((posMagnitude > 1.0e12) || spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Scientific);
-        const isDecimal = (isSci || spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Decimal || spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Bearing || spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Azimuth) || spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Ratio;
-        const isFractional = (!isDecimal && spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Fractional);
+        const isSci = ((posMagnitude > 1.0e12) || spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Scientific);
+        const isDecimal = (isSci || spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Decimal || spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Bearing || spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Azimuth) || spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Ratio;
+        const isFractional = (!isDecimal && spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Fractional);
         /* const usesStops = spec.format.type === FormatType.Station; */
-        const isPrecisionZero = spec.format.precision === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.DecimalPrecision.Zero;
-        const isKeepSingleZero = spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.KeepSingleZero);
+        const isPrecisionZero = spec.format.precision === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.DecimalPrecision.Zero;
+        const isKeepSingleZero = spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.KeepSingleZero);
         const precisionScale = Math.pow(10.0, spec.format.precision);
-        const isKeepTrailingZeroes = spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.TrailZeroes);
+        const isKeepTrailingZeroes = spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.TrailZeroes);
         let expInt = 0.0;
         if (isSci && (posMagnitude !== 0.0)) {
             let exp = Math.log10(posMagnitude);
@@ -305186,10 +305474,10 @@ class Formatter {
                 negativeExp = true;
             }
             expInt = Math.floor(exp);
-            if (spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Scientific) {
-                if (spec.format.scientificType === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.ScientificType.ZeroNormalized && posMagnitude > 1.0)
+            if (spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Scientific) {
+                if (spec.format.scientificType === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.ScientificType.ZeroNormalized && posMagnitude > 1.0)
                     expInt += 1.0;
-                else if (spec.format.scientificType === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.ScientificType.Normalized && posMagnitude < 1.0)
+                else if (spec.format.scientificType === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.ScientificType.Normalized && posMagnitude < 1.0)
                     expInt += 1.0;
                 if (negativeExp)
                     expInt = -expInt;
@@ -305211,7 +305499,7 @@ class Formatter {
             }
             formattedValue = Formatter.integerPartToText(wholePart, spec);
             if (isPrecisionZero) {
-                if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.KeepDecimalPoint) && !isKeepSingleZero)
+                if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.KeepDecimalPoint) && !isKeepSingleZero)
                     formattedValue = formattedValue + spec.format.decimalSeparator;
                 else if (isKeepSingleZero)
                     formattedValue = `${formattedValue + spec.format.decimalSeparator}0`;
@@ -305226,7 +305514,7 @@ class Formatter {
                 if (fractionString.length > 0)
                     formattedValue = formattedValue + spec.format.decimalSeparator + fractionString;
                 else {
-                    if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.KeepDecimalPoint))
+                    if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.KeepDecimalPoint))
                         formattedValue = formattedValue + spec.format.decimalSeparator + (isKeepSingleZero ? "0" : "");
                 }
             }
@@ -305239,7 +305527,7 @@ class Formatter {
             const fn = new FractionalNumeric(posMagnitude, spec.format.precision, true);
             formattedValue = fn.getIntegralString();
             if (!fn.isZero && fn.hasFractionPart) {
-                const wholeFractionSeparator = spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.FractionDash) ? "-" : " ";
+                const wholeFractionSeparator = spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.FractionDash) ? "-" : " ";
                 const fractionString = `${fn.getNumeratorString()}/${fn.getDenominatorString()}`;
                 formattedValue = formattedValue + wholeFractionSeparator + fractionString;
             }
@@ -305268,7 +305556,7 @@ class Formatter {
             else {
                 if (isKeepTrailingZeroes)
                     fractionString = spec.format.decimalSeparator + "".padEnd(spec.format.precision, "0");
-                else if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.KeepDecimalPoint))
+                else if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.KeepDecimalPoint))
                     fractionString = spec.format.decimalSeparator;
                 formattedValue = stationString + fractionString;
             }
@@ -305297,21 +305585,21 @@ class Formatter {
         let prefix = "";
         let suffix = "";
         switch (showSignOption) {
-            case _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.ShowSignOption.NegativeParentheses:
+            case _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.ShowSignOption.NegativeParentheses:
                 if (isNegative) {
                     prefix = "(";
                     suffix = ")";
                 }
                 break;
-            case _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.ShowSignOption.OnlyNegative:
-                if (isNegative && formatType !== _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Bearing && formatType !== _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Azimuth) {
+            case _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.ShowSignOption.OnlyNegative:
+                if (isNegative && formatType !== _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Bearing && formatType !== _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Azimuth) {
                     prefix = "-";
                 }
                 break;
-            case _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.ShowSignOption.SignAlways:
+            case _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.ShowSignOption.SignAlways:
                 prefix = isNegative ? "-" : "+";
                 break;
-            case _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.ShowSignOption.NoSign:
+            case _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.ShowSignOption.NoSign:
             default:
                 break;
         }
@@ -305327,14 +305615,20 @@ class Formatter {
         let suffix = "";
         let formattedValue = "";
         // Handle bearing/azimuth special formatting
-        if (spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Bearing || spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Azimuth) {
+        if (spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Bearing || spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Azimuth) {
             const result = this.processBearingAndAzimuth(magnitude, spec);
             magnitude = result.magnitude;
             prefix = result.prefix ?? "";
             suffix = result.suffix ?? "";
         }
         let formattedMagnitude = "";
-        if (spec.format.hasUnits) {
+        if (spec.format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Ratio && spec.unitConversions.length >= 3) {
+            // Handle ratio formatting separately when 2-unit composite provides 3 conversion specs
+            const ratioResult = this.formatRatioQuantity(magnitude, spec);
+            formattedMagnitude = ratioResult.componentText;
+            valueIsNegative = ratioResult.isNegative;
+        }
+        else if (spec.format.hasUnits) {
             const compositeResult = Formatter.formatComposite(magnitude, spec);
             formattedMagnitude = compositeResult.componentText;
             // Override the sign detection with the composite conversion result
@@ -305343,8 +305637,8 @@ class Formatter {
         else {
             // unitless quantity
             formattedMagnitude = Formatter.formatMagnitude(magnitude, spec);
-            if (formattedMagnitude.length > 0 && spec.unitConversions.length > 0 && spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.ShowUnitLabel)) {
-                if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatTraits.PrependUnitLabel))
+            if (formattedMagnitude.length > 0 && spec.unitConversions.length > 0 && spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.ShowUnitLabel)) {
+                if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.PrependUnitLabel))
                     formattedMagnitude = spec.unitConversions[0].label + spec.format.uomSeparator + formattedMagnitude;
                 else
                     formattedMagnitude = formattedMagnitude + spec.format.uomSeparator + spec.unitConversions[0].label;
@@ -305364,12 +305658,12 @@ class Formatter {
     }
     static processBearingAndAzimuth(magnitude, spec) {
         const type = spec.format.type;
-        if (type !== _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Bearing && type !== _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Azimuth)
+        if (type !== _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Bearing && type !== _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Azimuth)
             return { magnitude };
         const revolution = this.getRevolution(spec);
         magnitude = this.normalizeAngle(magnitude, revolution);
         const quarterRevolution = revolution / 4;
-        if (type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Bearing) {
+        if (type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Bearing) {
             let quadrant = 0;
             while (magnitude > quarterRevolution) {
                 magnitude -= quarterRevolution;
@@ -305396,7 +305690,7 @@ class Formatter {
             if (quadrant === 2 && spec.unitConversions.length > 0) {
                 // To determine if value is small, we need to convert it to the smallest unit presented and use the provided precision on it
                 const unitConversion = spec.unitConversions[spec.unitConversions.length - 1].conversion;
-                const smallestFormattedDelta = (0,_Quantity__WEBPACK_IMPORTED_MODULE_3__.applyConversion)((quarterRevolution - magnitude), unitConversion) + this.FPV_MINTHRESHOLD;
+                const smallestFormattedDelta = (0,_Quantity__WEBPACK_IMPORTED_MODULE_4__.applyConversion)((quarterRevolution - magnitude), unitConversion) + this.FPV_MINTHRESHOLD;
                 const precisionScale = Math.pow(10.0, spec.format.precision);
                 const floor = Math.floor((smallestFormattedDelta) * precisionScale + FPV_ROUNDFACTOR) / precisionScale;
                 if (floor === 0) {
@@ -305405,13 +305699,13 @@ class Formatter {
             }
             return { magnitude, prefix, suffix };
         }
-        if (type === _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Azimuth) {
+        if (type === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Azimuth) {
             let azimuthBase = 0; // default base is North
             if (spec.format.azimuthBase !== undefined) {
                 if (spec.azimuthBaseConversion === undefined) {
                     throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.MissingRequiredProperty, `Missing azimuth base conversion for interpreting ${spec.name}'s azimuth base.`);
                 }
-                const azBaseQuantity = new _Quantity__WEBPACK_IMPORTED_MODULE_3__.Quantity(spec.format.azimuthBaseUnit, spec.format.azimuthBase);
+                const azBaseQuantity = new _Quantity__WEBPACK_IMPORTED_MODULE_4__.Quantity(spec.format.azimuthBaseUnit, spec.format.azimuthBase);
                 const azBaseConverted = azBaseQuantity.convertTo(spec.persistenceUnit, spec.azimuthBaseConversion);
                 if (azBaseConverted === undefined || !azBaseConverted.isValid) {
                     throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.UnsupportedUnit, `Failed to convert azimuth base unit to ${spec.persistenceUnit.name}.`);
@@ -305441,40 +305735,87 @@ class Formatter {
         if (spec.revolutionConversion === undefined) {
             throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.MissingRequiredProperty, `Missing revolution unit conversion for calculating ${spec.name}'s revolution.`);
         }
-        const revolution = new _Quantity__WEBPACK_IMPORTED_MODULE_3__.Quantity(spec.format.revolutionUnit, 1.0);
+        const revolution = new _Quantity__WEBPACK_IMPORTED_MODULE_4__.Quantity(spec.format.revolutionUnit, 1.0);
         const converted = revolution.convertTo(spec.persistenceUnit, spec.revolutionConversion);
         if (converted === undefined || !converted.isValid) {
             throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.UnsupportedUnit, `Failed to convert revolution unit to ${spec.persistenceUnit.name}.`);
         }
         return converted.magnitude;
     }
+    static formatRatioPart(value, spec, side) {
+        const formatType = spec.format.ratioFormatType === "Fractional" ? _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Fractional : _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Decimal;
+        const tempFormat = spec.format.clone({ type: formatType });
+        const tempSpec = new _FormatterSpec__WEBPACK_IMPORTED_MODULE_2__.FormatterSpec(spec.name, tempFormat, spec.unitConversions, spec.persistenceUnit);
+        let formattedValue = this.formatMagnitude(value, tempSpec);
+        // For fractional ratio formatting, suppress leading "0" if the value is purely fractional
+        if (formatType === _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatType.Fractional && formattedValue.startsWith("0 ")) {
+            formattedValue = formattedValue.substring(2); // Remove "0 " prefix
+        }
+        // Add unit label if ShowUnitLabel trait is set
+        // unitConversions[0] = ratio scale factor, [1] = numerator unit, [2] = denominator unit
+        if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.ShowUnitLabel) && spec.unitConversions.length >= 3) {
+            const labelToAdd = side === "numerator" ? spec.unitConversions[1].label : spec.unitConversions[2].label;
+            formattedValue = formattedValue + labelToAdd;
+        }
+        return formattedValue;
+    }
+    /** Format a ratio quantity value (separate from composite formatting) */
+    static formatRatioQuantity(magnitude, spec) {
+        const unitConversion = spec.unitConversions[0].conversion;
+        let unitValue = 0.0;
+        try {
+            unitValue = (0,_Quantity__WEBPACK_IMPORTED_MODULE_4__.applyConversion)(magnitude, unitConversion) + this.FPV_MINTHRESHOLD;
+        }
+        catch (e) {
+            // The "InvertingZero" error is thrown when the value is zero and the conversion factor is inverted.
+            // For ratio, we return "1:0" as the formatted value.
+            if (e instanceof _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError && e.errorNumber === _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvertingZero) {
+                return { componentText: "1:0", isNegative: false };
+            }
+            throw e;
+        }
+        const componentText = this.formatRatio(unitValue, spec);
+        const isNegative = unitValue < 0;
+        return { componentText, isNegative };
+    }
     static formatRatio(magnitude, spec) {
         if (null === spec.format.ratioType)
             throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidCompositeFormat, `The Format ${spec.format.name} must have a ratio type specified.`);
         const precisionScale = Math.pow(10.0, spec.format.precision);
+        const separator = spec.format.ratioSeparator;
         let reciprocal = 0;
+        // Helper to get unit labels if ShowUnitLabel is set
+        const getUnitLabels = () => {
+            if (spec.format.hasFormatTraitSet(_FormatEnums__WEBPACK_IMPORTED_MODULE_3__.FormatTraits.ShowUnitLabel) && spec.unitConversions.length >= 3) {
+                return { numeratorLabel: spec.unitConversions[1].label, denominatorLabel: spec.unitConversions[2].label };
+            }
+            return { numeratorLabel: "", denominatorLabel: "" };
+        };
+        const { numeratorLabel, denominatorLabel } = getUnitLabels();
         if (magnitude === 0.0)
-            return "0:1";
+            return `0${separator}1`;
         else
             reciprocal = 1.0 / magnitude;
         switch (spec.format.ratioType) {
-            case _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.RatioType.OneToN:
-                return `1:${this.formatMagnitude(reciprocal, spec)}`;
-            case _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.RatioType.NToOne:
-                return `${this.formatMagnitude(magnitude, spec)}:1`;
-            case _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.RatioType.ValueBased:
-                if (magnitude > 1.0)
-                    return `${this.formatMagnitude(magnitude, spec)}:1`;
-                else
-                    return `1:${this.formatMagnitude(reciprocal, spec)}`;
-            case _FormatEnums__WEBPACK_IMPORTED_MODULE_2__.RatioType.UseGreatestCommonDivisor:
+            case _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.RatioType.OneToN:
+                return `1${numeratorLabel}${separator}${this.formatRatioPart(reciprocal, spec, "denominator")}`;
+            case _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.RatioType.NToOne:
+                return `${this.formatRatioPart(magnitude, spec, "numerator")}${separator}1${denominatorLabel}`;
+            case _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.RatioType.ValueBased:
+                if (magnitude > 1.0) {
+                    return `${this.formatRatioPart(magnitude, spec, "numerator")}${separator}1${denominatorLabel}`;
+                }
+                else {
+                    return `1${numeratorLabel}${separator}${this.formatRatioPart(reciprocal, spec, "denominator")}`;
+                }
+            case _FormatEnums__WEBPACK_IMPORTED_MODULE_3__.RatioType.UseGreatestCommonDivisor:
                 magnitude = Math.round(magnitude * precisionScale) / precisionScale;
                 let numerator = magnitude * precisionScale;
                 let denominator = precisionScale;
                 const gcd = FractionalNumeric.getGreatestCommonFactor(numerator, denominator);
                 numerator /= gcd;
                 denominator /= gcd;
-                return `${this.formatMagnitude(numerator, spec)}:${this.formatMagnitude(denominator, spec)}`;
+                return `${this.formatRatioPart(numerator, spec, "numerator")}${separator}${this.formatRatioPart(denominator, spec, "denominator")}`;
             default:
                 throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvalidCompositeFormat, `The Format ${spec.format.name} has an invalid ratio type specified.`);
         }
@@ -305495,7 +305836,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   FormatterSpec: () => (/* binding */ FormatterSpec)
 /* harmony export */ });
-/* harmony import */ var _Formatter__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Formatter */ "../../core/quantity/lib/esm/Formatter/Formatter.js");
+/* harmony import */ var _FormatEnums__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./FormatEnums */ "../../core/quantity/lib/esm/Formatter/FormatEnums.js");
+/* harmony import */ var _Formatter__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Formatter */ "../../core/quantity/lib/esm/Formatter/Formatter.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -305504,6 +305846,7 @@ __webpack_require__.r(__webpack_exports__);
  * @module Quantity
  */
 
+
 // cSpell:ignore ZERONORMALIZED, nosign, onlynegative, signalways, negativeparentheses
 // cSpell:ignore trailzeroes, keepsinglezero, zeroempty, keepdecimalpoint, applyrounding, fractiondash, showunitlabel, prependunitlabel, exponentonlynegative
 /** A class that contains both formatting information and the conversion factors necessary to convert from an input unit to the units specified in the format.
@@ -305550,6 +305893,49 @@ class FormatterSpec {
     get persistenceUnit() { return this._persistenceUnit; }
     get azimuthBaseConversion() { return this._azimuthBaseConversion; }
     get revolutionConversion() { return this._revolutionConversion; }
+    /** Build conversion specs for ratio format with 2 composite units (numerator/denominator). */
+    static async getRatioUnitConversions(units, unitsProvider, persistenceUnit) {
+        const conversions = [];
+        const [numeratorUnit, numeratorLabel] = units[0];
+        const [denominatorUnit, denominatorLabel] = units[1];
+        // Compute ratio scale: how many numerator units per denominator unit (e.g., IN:FT = 12)
+        const denominatorToNumerator = await unitsProvider.getConversion(denominatorUnit, numeratorUnit);
+        const displayRatioScale = denominatorToNumerator.factor;
+        // Avoid double-scaling: if persistence unit already encodes the display ratio, use factor 1.
+        // Check by name heuristic (e.g., IN_PER_FT with ratioUnits [IN, FT] → no scaling needed)
+        const persistenceName = persistenceUnit.name.toUpperCase();
+        const numName = numeratorUnit.name.toUpperCase().split(".").pop() ?? "";
+        const denName = denominatorUnit.name.toUpperCase().split(".").pop() ?? "";
+        // Split by word boundaries (underscores, dots) and check for exact token matches
+        const persistenceTokens = persistenceName.split(/[._]/);
+        const isPersistenceMatchingRatio = persistenceTokens.includes(numName) && persistenceTokens.includes(denName);
+        const ratioScaleFactor = isPersistenceMatchingRatio ? 1.0 : displayRatioScale;
+        // First conversion spec: effective ratio unit conversion
+        const ratioConversionSpec = {
+            name: `${numeratorUnit.name}_per_${denominatorUnit.name}`,
+            label: "",
+            system: numeratorUnit.system,
+            conversion: { factor: ratioScaleFactor, offset: 0.0 },
+        };
+        conversions.push(ratioConversionSpec);
+        // Numerator unit for label lookup
+        const numeratorSpec = {
+            name: numeratorUnit.name,
+            label: numeratorLabel?.length ? numeratorLabel : numeratorUnit.label,
+            system: numeratorUnit.system,
+            conversion: { factor: 1.0, offset: 0.0 },
+        };
+        conversions.push(numeratorSpec);
+        // Denominator unit for label lookup
+        const denominatorSpec = {
+            name: denominatorUnit.name,
+            label: denominatorLabel?.length ? denominatorLabel : denominatorUnit.label,
+            system: denominatorUnit.system,
+            conversion: { factor: 1.0, offset: 0.0 },
+        };
+        conversions.push(denominatorSpec);
+        return conversions;
+    }
     /** Get an array of UnitConversionSpecs, one for each unit that is to be shown in the formatted quantity string. */
     static async getUnitConversions(format, unitsProvider, inputUnit) {
         const conversions = [];
@@ -305563,6 +305949,10 @@ class FormatterSpec {
                 throw new Error("Formatter Spec needs persistence unit to be specified");
             }
         }
+        // Handle 2-unit composite for ratio formats (scale factors)
+        if (format.type === _FormatEnums__WEBPACK_IMPORTED_MODULE_0__.FormatType.Ratio && format.units && format.units.length === 2) {
+            return FormatterSpec.getRatioUnitConversions(format.units, unitsProvider, persistenceUnit);
+        }
         if (format.units) {
             let convertFromUnit = inputUnit;
             for (const unit of format.units) {
@@ -305619,7 +306009,7 @@ class FormatterSpec {
     }
     /** Format a quantity value. */
     applyFormatting(magnitude) {
-        return _Formatter__WEBPACK_IMPORTED_MODULE_0__.Formatter.formatQuantity(magnitude, this);
+        return _Formatter__WEBPACK_IMPORTED_MODULE_1__.Formatter.formatQuantity(magnitude, this);
     }
 }
 
@@ -305727,13 +306117,14 @@ var ParseError;
     ParseError[ParseError["BearingPrefixOrSuffixMissing"] = 7] = "BearingPrefixOrSuffixMissing";
     ParseError[ParseError["MathematicOperationFoundButIsNotAllowed"] = 8] = "MathematicOperationFoundButIsNotAllowed";
     ParseError[ParseError["BearingAngleOutOfRange"] = 9] = "BearingAngleOutOfRange";
+    ParseError[ParseError["InvalidMathResult"] = 10] = "InvalidMathResult";
 })(ParseError || (ParseError = {}));
 var Operator;
 (function (Operator) {
     Operator["addition"] = "+";
     Operator["subtraction"] = "-";
     Operator["multiplication"] = "*";
-    Operator["division"] = "/"; // unsupported but we recognize it during parsing
+    Operator["division"] = "/";
 })(Operator || (Operator = {}));
 function isOperator(char) {
     if (typeof char === "number") {
@@ -306488,36 +306879,107 @@ class Parser {
         magnitude = this.normalizeAngle(magnitude, revolution);
         return { ok: true, value: magnitude };
     }
+    /**
+     * Parse a ratio part string (numerator or denominator) to extract the numeric value and optional unit label.
+     * This method processes tokens without applying unit conversions, allowing the ratio format
+     * handler to manage conversions at the ratio level.
+     *
+     *
+     * @note Fractions are already handled by parseQuantitySpecification, which converts them to
+     * single numeric tokens (e.g., "1/2" becomes 0.5).
+     *
+     * @param partStr The string to parse, which may contain a number, fraction, or mixed fraction with optional unit label.
+     * @param format The format specification used for token parsing.
+     * @returns An object containing the parsed numeric value and optional unit label. Returns NaN for value if no number is found.
+     */
+    static parseRatioPart(partStr, format) {
+        partStr = partStr.trim();
+        // Parse tokens - fractions are automatically converted to decimal values by parseQuantitySpecification
+        const tempFormat = format.clone({ type: _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_2__.FormatType.Decimal });
+        const tokens = Parser.parseQuantitySpecification(partStr, tempFormat);
+        let value = NaN;
+        let unitLabel;
+        // Pre-process: merge negative operators with following numbers
+        const processedTokens = [];
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (token.isOperator && i === 0 && token.value === "-" &&
+                i + 1 < tokens.length && tokens[i + 1].isNumber) {
+                // Merge negative sign with number
+                processedTokens.push(new ParseToken(-tokens[i + 1].value));
+                i++; // Skip the number token since we consumed it
+            }
+            else {
+                processedTokens.push(token);
+            }
+        }
+        // Extract numeric value and unit label from processed tokens
+        for (const token of processedTokens) {
+            if (token.isNumber && isNaN(value)) {
+                value = token.value;
+            }
+            else if (token.isString && !token.isOperator) {
+                // String token that's not an operator - treat as unit label
+                unitLabel = token.value;
+            }
+        }
+        return { value, unitLabel };
+    }
     static parseRatioFormat(inString, spec) {
         if (!inString)
             return { ok: false, error: ParseError.NoValueOrUnitFoundInString };
-        const parts = inString.split(":");
+        const separator = spec.format.ratioSeparator ?? ":";
+        const parts = inString.split(separator);
         if (parts.length > 2)
             return { ok: false, error: ParseError.UnableToConvertParseTokensToQuantity };
-        const numerator = parseFloat(parts[0]);
-        let denominator;
-        if (parts.length === 1) {
-            denominator = 1.0;
-        }
-        else {
-            denominator = parseFloat(parts[1]);
+        // If the string doesn't contain the expected separator but contains other ratio-like separators,
+        // return an error since the wrong separator was used
+        if (parts.length === 1 && !inString.includes(separator)) {
+            // Check if the string contains other common ratio separators
+            const otherSeparators = [":", "=", "/"];
+            for (const otherSep of otherSeparators) {
+                if (otherSep !== separator && inString.includes(otherSep)) {
+                    // The string looks like a ratio but uses the wrong separator
+                    return { ok: false, error: ParseError.UnableToConvertParseTokensToQuantity };
+                }
+            }
+            // Parse as a regular quantity value (numerator only, denominator = 1)
+            const result = this.parseAndProcessTokens(inString, spec.format, spec.unitConversions);
+            return result;
         }
-        if (isNaN(numerator) || isNaN(denominator))
+        // Parse numerator and denominator parts which may include unit labels
+        const numeratorPart = this.parseRatioPart(parts[0], spec.format);
+        const denominatorPart = parts.length === 1 ? { value: 1.0 } : this.parseRatioPart(parts[1], spec.format);
+        if (isNaN(numeratorPart.value) || isNaN(denominatorPart.value))
             return { ok: false, error: ParseError.NoValueOrUnitFoundInString };
+        // Handle 2-unit composite case - simpler conversion using the pre-computed scale factor
+        if (spec.format.units && spec.format.units.length === 2 && spec.unitConversions.length >= 3) {
+            const ratioConvSpec = spec.unitConversions[0];
+            const scaleFactor = ratioConvSpec.conversion.factor;
+            if (denominatorPart.value === 0) {
+                return { ok: false, error: ParseError.InvalidMathResult };
+            }
+            // The ratio value is numerator/denominator in the display units (e.g., 12 for 12"=1')
+            // Divide by scale factor to get persistence unit value (e.g., 12/12 = 1.0)
+            const ratioValue = numeratorPart.value / denominatorPart.value;
+            const convertedValue = ratioValue / scaleFactor;
+            return { ok: true, value: convertedValue };
+        }
+        // Original flow for 1-unit composite - use Quantity.convertTo for proper unit conversion
         const defaultUnit = spec.format.units && spec.format.units.length > 0 ? spec.format.units[0][0] : undefined;
         const unitConversion = defaultUnit ? Parser.tryFindUnitConversion(defaultUnit.label, spec.unitConversions, defaultUnit) : undefined;
         if (!unitConversion) {
             throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.MissingRequiredProperty, `Missing input unit or unit conversion for interpreting ${spec.format.name}.`);
         }
-        if (denominator === 0) {
-            if (unitConversion.inversion && numerator === 1)
+        if (denominatorPart.value === 0) {
+            if (unitConversion.inversion && numeratorPart.value === 1)
                 return { ok: true, value: 0.0 };
             else
-                return { ok: false, error: ParseError.MathematicOperationFoundButIsNotAllowed };
+                return { ok: false, error: ParseError.InvalidMathResult };
         }
         let quantity;
         if (spec.format.units && spec.outUnit) {
-            quantity = new _Quantity__WEBPACK_IMPORTED_MODULE_3__.Quantity(spec.format.units[0][0], numerator / denominator);
+            quantity = new _Quantity__WEBPACK_IMPORTED_MODULE_3__.Quantity(spec.format.units[0][0], numeratorPart.value / denominatorPart.value);
         }
         else {
             throw new _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError(_Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.MissingRequiredProperty, "Missing presentation unit or persistence unit for ratio format.");
@@ -306529,7 +306991,7 @@ class Parser {
         catch (err) {
             // for input of "0:N" with reversed unit
             if (err instanceof _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError && err.errorNumber === _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus.InvertingZero) {
-                return { ok: false, error: ParseError.MathematicOperationFoundButIsNotAllowed };
+                return { ok: false, error: ParseError.InvalidMathResult };
             }
         }
         if (converted === undefined || !converted.isValid) {
@@ -306655,7 +307117,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   ParserSpec: () => (/* binding */ ParserSpec)
 /* harmony export */ });
-/* harmony import */ var _Parser__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Parser */ "../../core/quantity/lib/esm/Parser.js");
+/* harmony import */ var _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Formatter/FormatEnums */ "../../core/quantity/lib/esm/Formatter/FormatEnums.js");
+/* harmony import */ var _Parser__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Parser */ "../../core/quantity/lib/esm/Parser.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -306664,6 +307127,7 @@ __webpack_require__.r(__webpack_exports__);
  * @module Quantity
  */
 
+
 /** A ParserSpec holds information needed to parse a string into a quantity synchronously.
  * @beta
  */
@@ -306689,6 +307153,51 @@ class ParserSpec {
     get outUnit() { return this._outUnit; }
     get azimuthBaseConversion() { return this._azimuthBaseConversion; }
     get revolutionConversion() { return this._revolutionConversion; }
+    /** Build conversion specs for ratio format with 2 composite units (numerator/denominator). */
+    static async getRatioUnitConversions(units, unitsProvider, outUnit, altUnitLabelsProvider) {
+        const conversions = [];
+        const [numeratorUnit, numeratorLabel] = units[0];
+        const [denominatorUnit, denominatorLabel] = units[1];
+        // Compute ratio scale: how many numerator units per denominator unit (e.g., IN:FT = 12)
+        const denominatorToNumerator = await unitsProvider.getConversion(denominatorUnit, numeratorUnit);
+        const displayRatioScale = denominatorToNumerator.factor;
+        // Avoid double-scaling: if persistence unit already encodes the display ratio, use factor 1.
+        // Check by name heuristic (e.g., IN_PER_FT with ratioUnits [IN, FT] → no scaling needed)
+        const persistenceName = outUnit.name.toUpperCase();
+        const numName = numeratorUnit.name.toUpperCase().split(".").pop() ?? "";
+        const denName = denominatorUnit.name.toUpperCase().split(".").pop() ?? "";
+        // Split by word boundaries (underscores, dots) and check for exact token matches
+        const persistenceTokens = persistenceName.split(/[._]/);
+        const isPersistenceMatchingRatio = persistenceTokens.includes(numName) && persistenceTokens.includes(denName);
+        const ratioScaleFactor = isPersistenceMatchingRatio ? 1.0 : displayRatioScale;
+        // First conversion spec: effective ratio unit conversion
+        const ratioConversionSpec = {
+            name: `${numeratorUnit.name}_per_${denominatorUnit.name}`,
+            label: "",
+            system: numeratorUnit.system,
+            conversion: { factor: ratioScaleFactor, offset: 0.0 },
+        };
+        conversions.push(ratioConversionSpec);
+        // Numerator unit for label lookup
+        const numeratorSpec = {
+            name: numeratorUnit.name,
+            label: numeratorLabel?.length ? numeratorLabel : numeratorUnit.label,
+            system: numeratorUnit.system,
+            conversion: { factor: 1.0, offset: 0.0 },
+            parseLabels: altUnitLabelsProvider?.getAlternateUnitLabels(numeratorUnit),
+        };
+        conversions.push(numeratorSpec);
+        // Denominator unit for label lookup
+        const denominatorSpec = {
+            name: denominatorUnit.name,
+            label: denominatorLabel?.length ? denominatorLabel : denominatorUnit.label,
+            system: denominatorUnit.system,
+            conversion: { factor: 1.0, offset: 0.0 },
+            parseLabels: altUnitLabelsProvider?.getAlternateUnitLabels(denominatorUnit),
+        };
+        conversions.push(denominatorSpec);
+        return conversions;
+    }
     /** Static async method to create a ParserSpec given the format and unit of the quantity that will be passed to the Parser. The input unit will
      * be used to generate conversion information for each unit specified in the Format. This method is async due to the fact that the units provider must make
      * async calls to lookup unit definitions.
@@ -306697,7 +307206,14 @@ class ParserSpec {
      *  @param outUnit The unit a value will be formatted to. This unit is often referred to as persistence unit.
      */
     static async create(format, unitsProvider, outUnit, altUnitLabelsProvider) {
-        const conversions = await _Parser__WEBPACK_IMPORTED_MODULE_0__.Parser.createUnitConversionSpecsForUnit(unitsProvider, outUnit, altUnitLabelsProvider);
+        let conversions;
+        // For ratio formats with 2 composite units, use private helper method
+        if (format.type === _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_0__.FormatType.Ratio && format.units && format.units.length === 2) {
+            conversions = await ParserSpec.getRatioUnitConversions(format.units, unitsProvider, outUnit, altUnitLabelsProvider);
+        }
+        else {
+            conversions = await _Parser__WEBPACK_IMPORTED_MODULE_1__.Parser.createUnitConversionSpecsForUnit(unitsProvider, outUnit, altUnitLabelsProvider);
+        }
         const spec = new ParserSpec(outUnit, format, conversions);
         if (format.azimuthBaseUnit !== undefined) {
             if (outUnit !== undefined) {
@@ -306719,7 +307235,7 @@ class ParserSpec {
     }
     /** Do the parsing. Done this way to allow Custom Parser Specs to parse custom formatted strings into their quantities. */
     parseToQuantityValue(inString) {
-        return _Parser__WEBPACK_IMPORTED_MODULE_0__.Parser.parseQuantityString(inString, this);
+        return _Parser__WEBPACK_IMPORTED_MODULE_1__.Parser.parseQuantityString(inString, this);
     }
 }
 
@@ -306917,6 +307433,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   QuantityConstants: () => (/* reexport safe */ _Constants__WEBPACK_IMPORTED_MODULE_0__.QuantityConstants),
 /* harmony export */   QuantityError: () => (/* reexport safe */ _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityError),
 /* harmony export */   QuantityStatus: () => (/* reexport safe */ _Exception__WEBPACK_IMPORTED_MODULE_1__.QuantityStatus),
+/* harmony export */   RatioFormatType: () => (/* reexport safe */ _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_9__.RatioFormatType),
 /* harmony export */   RatioType: () => (/* reexport safe */ _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_9__.RatioType),
 /* harmony export */   ScientificType: () => (/* reexport safe */ _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_9__.ScientificType),
 /* harmony export */   ShowSignOption: () => (/* reexport safe */ _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_9__.ShowSignOption),
@@ -306935,6 +307452,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   parseFormatType: () => (/* reexport safe */ _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_9__.parseFormatType),
 /* harmony export */   parseFractionalPrecision: () => (/* reexport safe */ _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_9__.parseFractionalPrecision),
 /* harmony export */   parsePrecision: () => (/* reexport safe */ _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_9__.parsePrecision),
+/* harmony export */   parseRatioFormatType: () => (/* reexport safe */ _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_9__.parseRatioFormatType),
 /* harmony export */   parseRatioType: () => (/* reexport safe */ _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_9__.parseRatioType),
 /* harmony export */   parseScientificType: () => (/* reexport safe */ _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_9__.parseScientificType),
 /* harmony export */   parseShowSignOption: () => (/* reexport safe */ _Formatter_FormatEnums__WEBPACK_IMPORTED_MODULE_9__.parseShowSignOption),
@@ -320644,7 +321162,7 @@ var loadLanguages = instance.loadLanguages;
 /***/ ((module) => {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"name":"@itwin/core-frontend","version":"5.6.0-dev.7","description":"iTwin.js frontend components","main":"lib/cjs/core-frontend.js","module":"lib/esm/core-frontend.js","typings":"lib/cjs/core-frontend","license":"MIT","scripts":{"build":"npm run -s copy:public && npm run -s build:cjs && npm run -s build:esm && npm run -s webpackWorkers && npm run -s copy:workers && npm run -s copy:draco","build:cjs":"npm run -s copy:js:cjs && tsc 1>&2 --outDir lib/cjs","build:esm":"npm run -s copy:js:esm && tsc 1>&2 --module ES2022 --outDir lib/esm","clean":"rimraf -g lib .rush/temp/package-deps*.json","copy:public":"cpx \\"./src/public/**/*\\" ./lib/public","copy:js:cjs":"cpx \\"./src/**/*.js\\" ./lib/cjs","copy:js:esm":"cpx \\"./src/**/*.js\\" ./lib/esm","copy:workers":"cpx \\"./lib/workers/webpack/parse-imdl-worker.js\\" ./lib/public/scripts","copy:draco":"cpx \\"./node_modules/@loaders.gl/draco/dist/libs/*\\" ./lib/public/scripts","docs":"betools docs --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint --no-inline-config -c extraction.eslint.config.js  \\"./src/**/*.ts\\" 1>&2","lint":"eslint \\"./src/**/*.ts\\" 1>&2","lint-fix":"eslint --fix -f visualstudio \\"./src/**/*.ts\\" 1>&2","lint-deprecation":"eslint --fix -f visualstudio --no-inline-config -c ../../common/config/eslint/eslint.config.deprecation-policy.js \\"./src/**/*.ts\\"","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run webpackTestWorker && vitest --run","cover":"npm run webpackTestWorker && vitest --run","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2 && npm run -s webpackTestWorker","webpackTestWorker":"webpack --config ./src/test/worker/webpack.config.js 1>&2 && cpx \\"./lib/test/test-worker.js\\" ./lib/test","webpackWorkers":"webpack --config ./src/workers/ImdlParser/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core.git","directory":"core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/ecschema-metadata":"workspace:*","@itwin/ecschema-rpcinterface-common":"workspace:*"},"//devDependencies":["NOTE: All peerDependencies should also be listed as devDependencies since peerDependencies are not considered by npm install","NOTE: All tools used by scripts in this package must be listed as devDependencies"],"devDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/build-tools":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/ecschema-metadata":"workspace:*","@itwin/ecschema-rpcinterface-common":"workspace:*","@itwin/object-storage-core":"^3.0.4","@itwin/eslint-plugin":"5.2.2-dev.2","@types/chai-as-promised":"^7","@types/draco3d":"^1.4.10","@types/sinon":"^17.0.2","@vitest/browser":"^3.0.6","@vitest/coverage-v8":"^3.0.6","cpx2":"^8.0.0","eslint":"^9.31.0","glob":"^10.5.0","playwright":"~1.56.1","rimraf":"^6.0.1","sinon":"^17.0.2","source-map-loader":"^5.0.0","typescript":"~5.6.2","typemoq":"^2.1.0","vitest":"^3.0.6","vite-multiple-assets":"^1.3.1","vite-plugin-static-copy":"2.2.0","webpack":"^5.97.1"},"//dependencies":["NOTE: these dependencies should be only for things that DO NOT APPEAR IN THE API","NOTE: core-frontend should remain UI technology agnostic, so no react/angular dependencies are allowed"],"dependencies":{"@itwin/core-i18n":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/draco":"^4.3.4","fuse.js":"^3.3.0","wms-capabilities":"0.4.0"}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"@itwin/core-frontend","version":"5.7.0-dev.1","description":"iTwin.js frontend components","main":"lib/cjs/core-frontend.js","module":"lib/esm/core-frontend.js","typings":"lib/cjs/core-frontend","license":"MIT","scripts":{"build":"npm run -s copy:public && npm run -s build:cjs && npm run -s build:esm && npm run -s webpackWorkers && npm run -s copy:workers && npm run -s copy:draco","build:cjs":"npm run -s copy:js:cjs && tsc 1>&2 --outDir lib/cjs","build:esm":"npm run -s copy:js:esm && tsc 1>&2 --module ES2022 --outDir lib/esm","clean":"rimraf -g lib .rush/temp/package-deps*.json","copy:public":"cpx \\"./src/public/**/*\\" ./lib/public","copy:js:cjs":"cpx \\"./src/**/*.js\\" ./lib/cjs","copy:js:esm":"cpx \\"./src/**/*.js\\" ./lib/esm","copy:workers":"cpx \\"./lib/workers/webpack/parse-imdl-worker.js\\" ./lib/public/scripts","copy:draco":"cpx \\"./node_modules/@loaders.gl/draco/dist/libs/*\\" ./lib/public/scripts","docs":"betools docs --json=../../generated-docs/core/core-frontend/file.json --tsIndexFile=./core-frontend.ts --onlyJson --excludes=webgl/**/*,**/map/*.d.ts,**/tile/*.d.ts,**/*-css.ts","extract-api":"betools extract-api --entry=core-frontend && npm run extract-extension-api","extract-extension-api":"eslint --no-inline-config -c extraction.eslint.config.js  \\"./src/**/*.ts\\" 1>&2","lint":"eslint \\"./src/**/*.ts\\" 1>&2","lint-fix":"eslint --fix -f visualstudio \\"./src/**/*.ts\\" 1>&2","lint-deprecation":"eslint --fix -f visualstudio --no-inline-config -c ../../common/config/eslint/eslint.config.deprecation-policy.js \\"./src/**/*.ts\\"","pseudolocalize":"betools pseudolocalize --englishDir ./src/public/locales/en --out ./public/locales/en-PSEUDO","test":"npm run webpackTestWorker && vitest --run","cover":"npm run webpackTestWorker && vitest --run","webpackTests":"webpack --config ./src/test/utils/webpack.config.js 1>&2 && npm run -s webpackTestWorker","webpackTestWorker":"webpack --config ./src/test/worker/webpack.config.js 1>&2 && cpx \\"./lib/test/test-worker.js\\" ./lib/test","webpackWorkers":"webpack --config ./src/workers/ImdlParser/webpack.config.js 1>&2"},"repository":{"type":"git","url":"https://github.com/iTwin/itwinjs-core.git","directory":"core/frontend"},"keywords":["Bentley","BIM","iModel","digital-twin","iTwin"],"author":{"name":"Bentley Systems, Inc.","url":"http://www.bentley.com"},"peerDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/ecschema-metadata":"workspace:*","@itwin/ecschema-rpcinterface-common":"workspace:*"},"//devDependencies":["NOTE: All peerDependencies should also be listed as devDependencies since peerDependencies are not considered by npm install","NOTE: All tools used by scripts in this package must be listed as devDependencies"],"devDependencies":{"@itwin/appui-abstract":"workspace:*","@itwin/build-tools":"workspace:*","@itwin/core-bentley":"workspace:*","@itwin/core-common":"workspace:*","@itwin/core-geometry":"workspace:*","@itwin/core-orbitgt":"workspace:*","@itwin/core-quantity":"workspace:*","@itwin/ecschema-metadata":"workspace:*","@itwin/ecschema-rpcinterface-common":"workspace:*","@itwin/object-storage-core":"^3.0.4","@itwin/eslint-plugin":"^6.0.0","@types/chai-as-promised":"^7","@types/draco3d":"^1.4.10","@types/sinon":"^17.0.2","@vitest/browser":"^3.0.6","@vitest/coverage-v8":"^3.0.6","cpx2":"^8.0.0","eslint":"^9.31.0","glob":"^10.5.0","playwright":"~1.56.1","rimraf":"^6.0.1","sinon":"^17.0.2","source-map-loader":"^5.0.0","typescript":"~5.6.2","typemoq":"^2.1.0","vitest":"^3.0.6","vite-multiple-assets":"^1.3.1","vite-plugin-static-copy":"2.2.0","webpack":"^5.97.1"},"//dependencies":["NOTE: these dependencies should be only for things that DO NOT APPEAR IN THE API","NOTE: core-frontend should remain UI technology agnostic, so no react/angular dependencies are allowed"],"dependencies":{"@itwin/core-i18n":"workspace:*","@itwin/webgl-compatibility":"workspace:*","@loaders.gl/core":"^4.3.4","@loaders.gl/draco":"^4.3.4","fuse.js":"^3.3.0","wms-capabilities":"0.4.0"}}');
 
 /***/ })