@itwin/ecschema-rpcinterface-tests 5.10.0-dev.18 → 5.10.0-dev.20

package/lib/dist/bundled-tests.js

@@ -75423,6 +75423,1931 @@ class SchemaPartVisitorDelegate {
 }
 
 
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/SchemaView.js":
+/*!**********************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/SchemaView.js ***!
+  \**********************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   SchemaView: () => (/* binding */ SchemaView),
+/* harmony export */   SchemaViewBuilder: () => (/* binding */ SchemaViewBuilder)
+/* harmony export */ });
+/* harmony import */ var _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./SchemaViewInterfaces */ "../../core/ecschema-metadata/lib/esm/SchemaViewInterfaces.js");
+/* harmony import */ var _SchemaViewBinaryReader__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./SchemaViewBinaryReader */ "../../core/ecschema-metadata/lib/esm/SchemaViewBinaryReader.js");
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Schema
+ */
+
+
+// Module-local symbol used as the storage key on SchemaView instances. Mirrors the pattern in
+// core-backend/src/internal/Symbols.ts (e.g. `_nativeDb` on IModelDb): the data is reachable
+// only by code in this module, since the symbol is not exported and not registered globally.
+// The flyweight view classes (SchemaView.Schema, SchemaView.Class, etc.) live in the same file
+// and access the storage through this symbol.
+const _storage = Symbol("SchemaView.storage");
+/** Read-only schema metadata view. Optimized for fast lookup and low memory usage.
+ *
+ * All data is stored in flat arrays. View objects (`SchemaView.Schema`, `SchemaView.Class`, etc.) are
+ * stateless wrappers that hold a reference to this view plus an index. They allocate nothing
+ * and cache nothing.
+ *
+ * The view is immutable after construction. Build it via `SchemaViewBuilder` or parse
+ * from a binary blob via `fromBinary`.
+ * @beta
+ */
+class SchemaView {
+    /** @internal */
+    [_storage];
+    _schemaToken;
+    _outdated = false;
+    /** @internal */
+    constructor(data, schemaToken) {
+        this[_storage] = {
+            ...data,
+            transitiveBaseCache: new Map(),
+            derivedClassMap: undefined,
+        };
+        this._schemaToken = schemaToken ?? "";
+    }
+    /** SHA3-256 content hash of the ec_ schema tables at the time this view was built.
+     * Empty string if not set (e.g., when built from a builder without a token).
+     * @beta
+     */
+    get schemaToken() { return this._schemaToken; }
+    /** True if the host (`IModelDb` / `IModelConnection`) has replaced this view with a newer one.
+     * The view remains fully functional - it returns stale data rather than throwing.
+     * Consumers who stored a reference can check this flag for diagnostics.
+     * @beta
+     */
+    get isOutdated() { return this._outdated; }
+    /** Mark this view as outdated. Called by the host when a newer view replaces it.
+     * @internal
+     */
+    markOutdated() { this._outdated = true; }
+    /** Number of schemas in the view. */
+    get schemaCount() { return this[_storage].schemas.length; }
+    /** Number of classes across all schemas. */
+    get classCount() { return this[_storage].classes.length; }
+    /** Get a schema by name (case-insensitive). */
+    getSchema(name) {
+        const idx = this[_storage].schemaByName.get(name.toLowerCase());
+        return idx !== undefined ? new SchemaView.Schema(this, idx) : undefined;
+    }
+    /** Get a schema by alias (case-insensitive). */
+    getSchemaByAlias(alias) {
+        const idx = this[_storage].schemaByAlias.get(alias.toLowerCase());
+        return idx !== undefined ? new SchemaView.Schema(this, idx) : undefined;
+    }
+    /** Iterate all schemas. */
+    *getSchemas() {
+        for (let i = 0; i < this[_storage].schemas.length; i++)
+            yield new SchemaView.Schema(this, i);
+    }
+    /** Find a class by qualified name ("SchemaName:ClassName" or "SchemaName.ClassName").
+     * The namespace part matches schema name first, then alias. Case-insensitive.
+     */
+    findClass(qualifiedName) {
+        const idx = this.resolveClassIdx(qualifiedName);
+        return idx !== -1 ? SchemaView.createClass(this, idx) : undefined;
+    }
+    /** Find an enumeration by qualified name ("SchemaName:EnumName" or "SchemaName.EnumName").
+     * The namespace part matches schema name first, then alias. Case-insensitive.
+     */
+    findEnumeration(qualifiedName) {
+        const idx = this._resolveSchemaItemIdx(qualifiedName, this[_storage].enumByName);
+        return idx !== undefined ? new SchemaView.Enumeration(this, idx) : undefined;
+    }
+    /** Find a KindOfQuantity by qualified name ("SchemaName:KoqName" or "SchemaName.KoqName").
+     * The namespace part matches schema name first, then alias. Case-insensitive.
+     */
+    findKindOfQuantity(qualifiedName) {
+        const idx = this._resolveSchemaItemIdx(qualifiedName, this[_storage].koqByName);
+        return idx !== undefined ? new SchemaView.KindOfQuantity(this, idx) : undefined;
+    }
+    /** Find a PropertyCategory by qualified name ("SchemaName:CategoryName" or "SchemaName.CategoryName").
+     * The namespace part matches schema name first, then alias. Case-insensitive.
+     */
+    findPropertyCategory(qualifiedName) {
+        const idx = this._resolveSchemaItemIdx(qualifiedName, this[_storage].catByName);
+        return idx !== undefined ? new SchemaView.PropertyCategory(this, idx) : undefined;
+    }
+    /** Parse a binary blob into a SchemaView. Synchronous.
+     * @param blob - The binary blob from `PRAGMA schema_view`.
+     * @param schemaToken - Optional SHA3-256 content hash for cache invalidation.
+     * @beta
+     */
+    static fromBinary(blob, schemaToken) {
+        return (0,_SchemaViewBinaryReader__WEBPACK_IMPORTED_MODULE_1__.parseSchemaViewBlob)(blob, schemaToken);
+    }
+    /** Build from a pre-populated builder (used by the binary parser).
+     * @internal
+     */
+    static fromBuilder(builder, schemaToken) {
+        return builder.build(schemaToken);
+    }
+    // --- Internal helpers used by view objects ---
+    /** Resolve a qualified "SchemaName:ItemName" (or dot-separated) to an index using the given
+     * per-schema name map. Returns undefined if not found. @internal */
+    _resolveSchemaItemIdx(qualifiedName, itemByName) {
+        const sep = qualifiedName.indexOf(":");
+        const dotSep = sep === -1 ? qualifiedName.indexOf(".") : -1;
+        const splitAt = sep !== -1 ? sep : dotSep;
+        if (splitAt === -1)
+            return undefined;
+        const ns = qualifiedName.substring(0, splitAt).toLowerCase();
+        const itemName = qualifiedName.substring(splitAt + 1).toLowerCase();
+        let schemaIdx = this[_storage].schemaByName.get(ns);
+        if (schemaIdx === undefined)
+            schemaIdx = this[_storage].schemaByAlias.get(ns);
+        if (schemaIdx === undefined)
+            return undefined;
+        return itemByName.get(schemaIdx)?.get(itemName);
+    }
+    /** @internal */
+    resolveClassIdx(qualifiedName) {
+        const sep = qualifiedName.indexOf(":");
+        const dotSep = sep === -1 ? qualifiedName.indexOf(".") : -1;
+        const splitAt = sep !== -1 ? sep : dotSep;
+        if (splitAt === -1)
+            return -1;
+        const ns = qualifiedName.substring(0, splitAt).toLowerCase();
+        const cn = qualifiedName.substring(splitAt + 1).toLowerCase();
+        let schemaIdx = this[_storage].schemaByName.get(ns);
+        if (schemaIdx === undefined)
+            schemaIdx = this[_storage].schemaByAlias.get(ns);
+        if (schemaIdx === undefined)
+            return -1;
+        const classMap = this[_storage].classByName.get(schemaIdx);
+        const classIdx = classMap?.get(cn);
+        return classIdx ?? -1;
+    }
+    /** @internal */
+    getTransitiveBases(classIdx) {
+        const cached = this[_storage].transitiveBaseCache.get(classIdx);
+        if (cached !== undefined)
+            return cached;
+        const result = new Set();
+        this._buildTransitiveBases(classIdx, result);
+        this[_storage].transitiveBaseCache.set(classIdx, result);
+        return result;
+    }
+    _buildTransitiveBases(classIdx, result) {
+        const cls = this[_storage].classes[classIdx];
+        if (cls === undefined)
+            return; // safety: dangling index from excluded schema
+        if (cls.baseClassIdx !== -1 && !result.has(cls.baseClassIdx)) {
+            result.add(cls.baseClassIdx);
+            this._buildTransitiveBases(cls.baseClassIdx, result);
+        }
+        for (let i = 0; i < cls.mixinCount; i++) {
+            const mixinIdx = this[_storage].classMixins[cls.mixinStartIdx + i];
+            if (mixinIdx === -1 || mixinIdx === undefined)
+                continue; // safety: dangling mixin ref
+            if (!result.has(mixinIdx)) {
+                result.add(mixinIdx);
+                this._buildTransitiveBases(mixinIdx, result);
+            }
+        }
+    }
+    /** @internal */
+    resolveAllProperties(classIdx) {
+        const cls = this[_storage].classes[classIdx];
+        if (cls.type === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.ClassType.View) {
+            // Views don't participate in property inheritance - own properties only
+            const result = [];
+            for (let i = 0; i < cls.ownPropCount; i++) {
+                const ref = this[_storage].propertyRefs[cls.ownPropStart + i];
+                result.push({ ref, classIdx: -1 });
+            }
+            return result;
+        }
+        const merged = new Map();
+        this._collectProperties(classIdx, merged);
+        return Array.from(merged.values());
+    }
+    _collectProperties(classIdx, merged) {
+        const cls = this[_storage].classes[classIdx];
+        if (cls === undefined)
+            return; // safety: dangling index from excluded schema
+        // 1. Base class (recursive, depth-first)
+        if (cls.baseClassIdx !== -1)
+            this._collectProperties(cls.baseClassIdx, merged);
+        // 2. Mixins in declaration order
+        for (let i = 0; i < cls.mixinCount; i++) {
+            const mixinIdx = this[_storage].classMixins[cls.mixinStartIdx + i];
+            if (mixinIdx === -1 || mixinIdx === undefined)
+                continue; // safety: dangling mixin ref
+            this._collectMixinProperties(mixinIdx, merged);
+        }
+        // 3. Own properties - always override
+        for (let i = 0; i < cls.ownPropCount; i++) {
+            const ref = this[_storage].propertyRefs[cls.ownPropStart + i];
+            const nameKey = this[_storage].lowerStrings[this[_storage].propDefs[ref.defIdx].nameStringIdx];
+            merged.set(nameKey, { ref, classIdx });
+        }
+    }
+    _collectMixinProperties(mixinIdx, merged) {
+        const mixin = this[_storage].classes[mixinIdx];
+        if (mixin === undefined)
+            return; // safety: dangling index from excluded schema
+        // Walk mixin's own base chain (mixins can extend other mixins)
+        if (mixin.baseClassIdx !== -1)
+            this._collectMixinProperties(mixin.baseClassIdx, merged);
+        // Mixin's own mixins
+        for (let i = 0; i < mixin.mixinCount; i++) {
+            const subMixinIdx = this[_storage].classMixins[mixin.mixinStartIdx + i];
+            if (subMixinIdx === -1 || subMixinIdx === undefined)
+                continue; // safety: dangling mixin ref
+            this._collectMixinProperties(subMixinIdx, merged);
+        }
+        // Mixin's own properties - only set if not already present (first mixin wins)
+        for (let i = 0; i < mixin.ownPropCount; i++) {
+            const ref = this[_storage].propertyRefs[mixin.ownPropStart + i];
+            const nameKey = this[_storage].lowerStrings[this[_storage].propDefs[ref.defIdx].nameStringIdx];
+            if (!merged.has(nameKey))
+                merged.set(nameKey, { ref, classIdx: mixinIdx });
+        }
+    }
+    /** @internal */
+    buildDerivedClassMap() {
+        if (this[_storage].derivedClassMap !== undefined)
+            return this[_storage].derivedClassMap;
+        const map = new Map();
+        for (let i = 0; i < this[_storage].classes.length; i++) {
+            const baseIdx = this[_storage].classes[i].baseClassIdx;
+            if (baseIdx !== -1) {
+                let arr = map.get(baseIdx);
+                if (arr === undefined) {
+                    arr = [];
+                    map.set(baseIdx, arr);
+                }
+                arr.push(i);
+            }
+        }
+        this[_storage].derivedClassMap = map;
+        return map;
+    }
+}
+// =====================================================================================
+// SchemaView namespace - flyweight view types
+// =====================================================================================
+/** @beta */
+(function (SchemaView) {
+    /** Lightweight view over a schema in a `SchemaView`. Holds only a view reference and
+     * an index - no data duplication, no mutable state.
+     * @beta
+     */
+    class Schema {
+        _ctx;
+        idx;
+        /** @internal */
+        constructor(_ctx, 
+        /** @internal */ idx) {
+            this._ctx = _ctx;
+            this.idx = idx;
+        }
+        get _data() { return this._ctx[_storage].schemas[this.idx]; }
+        /** Row ID from ec_Schema. Matches `ECInstanceId` in ECDbMeta views, e.g.
+         * `SELECT * FROM meta.ECSchemaDef WHERE ECInstanceId = ?`.
+         *
+         * This is not an array index or internal handle - it is the database row ID from the ec_Schema
+         * table, carried through the binary blob so consumers can fall back to ECSQL meta-queries for
+         * data not included in the schema view (custom attributes, schema references, etc.).
+         */
+        get ecInstanceId() { return this._data.ecInstanceId; }
+        get name() { return this._ctx[_storage].strings[this._data.nameStringIdx]; }
+        get alias() { return this._ctx[_storage].strings[this._data.aliasStringIdx]; }
+        get label() {
+            const sid = this._data.labelStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : this.name;
+        }
+        get description() {
+            const sid = this._data.descriptionStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : "";
+        }
+        get readVersion() { return this._data.versionRead; }
+        get writeVersion() { return this._data.versionWrite; }
+        get minorVersion() { return this._data.versionMinor; }
+        /** Reflects the `HiddenSchema` custom attribute from `CoreCustomAttributes`.
+         * Schemas marked hidden are typically excluded from UI display but remain accessible programmatically. */
+        get isHidden() { return this._data.isHidden; }
+        /** "SchemaName.RR.WW.mm" - dot-separated, matching the EC schema versioning convention. */
+        get fullName() {
+            const d = this._data;
+            return `${this._ctx[_storage].strings[d.nameStringIdx]}.${String(d.versionRead).padStart(2, "0")}.${String(d.versionWrite).padStart(2, "0")}.${String(d.versionMinor).padStart(2, "0")}`;
+        }
+        /** Find a class by name within this schema (case-insensitive). */
+        getClass(name) {
+            const classMap = this._ctx[_storage].classByName.get(this.idx);
+            const classIdx = classMap?.get(name.toLowerCase());
+            return classIdx !== undefined ? createClass(this._ctx, classIdx) : undefined;
+        }
+        /** Iterate classes in this schema. Pass a `ClassType` to filter to a single kind
+         * (e.g. `getClasses(ClassType.View)`). Omit the argument to iterate every class
+         * regardless of type.
+         */
+        *getClasses(filter) {
+            const d = this._data;
+            const classes = this._ctx[_storage].classes;
+            for (let i = d.classRangeStart; i < d.classRangeStart + d.classCount; i++) {
+                if (filter === undefined || classes[i].type === filter)
+                    yield createClass(this._ctx, i);
+            }
+        }
+        /** Find an enumeration by name within this schema (case-insensitive). */
+        getEnumeration(name) {
+            const map = this._ctx[_storage].enumByName.get(this.idx);
+            const idx = map?.get(name.toLowerCase());
+            return idx !== undefined ? new Enumeration(this._ctx, idx) : undefined;
+        }
+        /** Find a KindOfQuantity by name within this schema (case-insensitive). */
+        getKindOfQuantity(name) {
+            const map = this._ctx[_storage].koqByName.get(this.idx);
+            const idx = map?.get(name.toLowerCase());
+            return idx !== undefined ? new KindOfQuantity(this._ctx, idx) : undefined;
+        }
+        /** Find a PropertyCategory by name within this schema (case-insensitive). */
+        getPropertyCategory(name) {
+            const map = this._ctx[_storage].catByName.get(this.idx);
+            const idx = map?.get(name.toLowerCase());
+            return idx !== undefined ? new PropertyCategory(this._ctx, idx) : undefined;
+        }
+        /** Iterate all enumerations in this schema. */
+        *getEnumerations() {
+            const d = this._data;
+            for (let i = d.enumRangeStart; i < d.enumRangeStart + d.enumCount; i++)
+                yield new Enumeration(this._ctx, i);
+        }
+        /** Iterate all KindOfQuantity items in this schema. */
+        *getKindOfQuantities() {
+            const d = this._data;
+            for (let i = d.koqRangeStart; i < d.koqRangeStart + d.koqCount; i++)
+                yield new KindOfQuantity(this._ctx, i);
+        }
+        /** Iterate all PropertyCategory items in this schema. */
+        *getPropertyCategories() {
+            const d = this._data;
+            for (let i = d.catRangeStart; i < d.catRangeStart + d.catCount; i++)
+                yield new PropertyCategory(this._ctx, i);
+        }
+    }
+    SchemaView.Schema = Schema;
+    /** Lightweight view over a class in a `SchemaView`. For relationship-specific
+     * fields (strength, direction, source/target constraints), narrow via `isRelationship()`
+     * or `assertRelationship()` to get a `SchemaView.RelationshipClass`.
+     * @beta
+     */
+    class Class {
+        _ctx;
+        idx;
+        /** @internal */
+        constructor(_ctx, 
+        /** @internal */ idx) {
+            this._ctx = _ctx;
+            this.idx = idx;
+        }
+        /** @internal */
+        get _data() { return this._ctx[_storage].classes[this.idx]; }
+        /** Row ID from ec_Class. Matches `ECInstanceId` in ECDbMeta views, e.g.
+         * `SELECT * FROM meta.ECClassDef WHERE ECInstanceId = ?`.
+         */
+        get ecInstanceId() { return this._data.ecInstanceId; }
+        get name() { return this._ctx[_storage].strings[this._data.nameStringIdx]; }
+        get label() {
+            const sid = this._data.labelStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : this.name;
+        }
+        get description() {
+            const sid = this._data.descriptionStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : "";
+        }
+        /** "SchemaName:ClassName" - colon-separated, matching the EC class full name convention.
+         * Use either ":" or "." as separator when passing to `findClass()`. */
+        get fullName() {
+            const d = this._data;
+            return `${this._ctx[_storage].strings[this._ctx[_storage].schemas[d.schemaIdx].nameStringIdx]}:${this._ctx[_storage].strings[d.nameStringIdx]}`;
+        }
+        get schema() { return new Schema(this._ctx, this._data.schemaIdx); }
+        get type() { return this._data.type; }
+        get modifier() { return this._data.modifier; }
+        // Type check methods
+        // disabling lint rule for these because we explicitly want them to mirror same methods in ecschema-metadata, to make the APIs more compatible
+        // eslint-disable-next-line @itwin/prefer-get
+        isEntity() { return this._data.type === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.ClassType.Entity; }
+        /** Type predicate - narrows to `SchemaView.RelationshipClass` for access to strength, direction,
+         * source, and target constraint fields. */
+        isRelationship() { return this._data.type === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.ClassType.Relationship; }
+        // eslint-disable-next-line @itwin/prefer-get
+        isStruct() { return this._data.type === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.ClassType.Struct; }
+        // eslint-disable-next-line @itwin/prefer-get
+        isMixin() { return this._data.type === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.ClassType.Mixin; }
+        // eslint-disable-next-line @itwin/prefer-get
+        isCustomAttribute() { return this._data.type === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.ClassType.CustomAttribute; }
+        // eslint-disable-next-line @itwin/prefer-get
+        isView() { return this._data.type === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.ClassType.View; }
+        /** @see isRelationship */
+        assertRelationship() {
+            if (!this.isRelationship())
+                throw new Error(`Expected a relationship class, got type ${this.type} for "${this.fullName}"`);
+        }
+        // Modifier checks
+        get isAbstract() { return this._data.modifier === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.ClassModifier.Abstract; }
+        get isSealed() { return this._data.modifier === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.ClassModifier.Sealed; }
+        /** Reflects the `HiddenClass` custom attribute from `CoreCustomAttributes`.
+         * Returns `true` when this class is directly hidden (via `HiddenClass(Show!=true)` or
+         * schema-level `HiddenSchema(ShowClasses!=true)`). Does NOT consider base class inheritance -
+         * use `isEffectivelyHidden` for that.
+         *
+         * Note: `false` means explicitly shown via `HiddenClass(Show=true)`. `undefined` means
+         * no `HiddenClass` CA and the schema does not hide its classes. Both are "not hidden" for
+         * this property, but `isEffectivelyHidden` distinguishes them when walking the hierarchy. */
+        get isHidden() { return this._data.isHidden; }
+        /** Computed hidden status that walks the base class chain (not mixins).
+         *
+         * Returns `true` if this class is hidden or any ancestor in the base class chain is hidden,
+         * unless this class or an intermediate class explicitly breaks the chain with
+         * `HiddenClass(Show=true)` (i.e. `isHidden === false`).
+         *
+         * Mixins are intentionally excluded - a hidden mixin represents a hidden capability,
+         * not a hidden identity. */
+        get isEffectivelyHidden() {
+            let data = this._data;
+            while (data !== undefined) {
+                if (data.isHidden === false)
+                    return false; // explicit Show=true breaks the chain
+                if (data.isHidden === true)
+                    return true;
+                // undefined: walk to base class via internal array (avoids allocating Class objects)
+                data = data.baseClassIdx !== -1 ? this._ctx[_storage].classes[data.baseClassIdx] : undefined;
+            }
+            return false;
+        }
+        // Hierarchy
+        /** Single base class. undefined for root classes. */
+        get baseClass() {
+            const idx = this._data.baseClassIdx;
+            return idx !== -1 ? createClass(this._ctx, idx) : undefined;
+        }
+        /** Applied mixins in declaration order. Only meaningful for entity classes. */
+        get mixins() {
+            const d = this._data;
+            if (d.mixinCount === 0)
+                return [];
+            const result = [];
+            for (let i = 0; i < d.mixinCount; i++) {
+                const mixinIdx = this._ctx[_storage].classMixins[d.mixinStartIdx + i];
+                if (mixinIdx === -1 || mixinIdx === undefined)
+                    continue; // safety: dangling mixin ref from excluded schema
+                result.push(createClass(this._ctx, mixinIdx));
+            }
+            return result;
+        }
+        /** IS-A check. Returns true if this class is, or derives from, `other` (transitively, including mixins).
+         * Accepts a `SchemaView.Class` or a qualified name string ("SchemaName:ClassName").
+         */
+        is(classOrName) {
+            let targetIdx;
+            if (typeof classOrName === "string") {
+                targetIdx = this._ctx.resolveClassIdx(classOrName);
+            }
+            else if (classOrName._ctx === this._ctx) {
+                targetIdx = classOrName.idx;
+            }
+            else {
+                // Cross-view input: indices are not comparable across SchemaView instances.
+                // Resolve by qualified name against this view.
+                targetIdx = this._ctx.resolveClassIdx(classOrName.fullName);
+            }
+            if (targetIdx === -1)
+                return false;
+            if (this.idx === targetIdx)
+                return true;
+            return this._ctx.getTransitiveBases(this.idx).has(targetIdx);
+        }
+        /** Direct derived classes. Expensive on first call (builds reverse map across all classes). */
+        get derivedClasses() {
+            const map = this._ctx.buildDerivedClassMap();
+            const indices = map.get(this.idx);
+            if (indices === undefined)
+                return [];
+            return indices.map((i) => createClass(this._ctx, i));
+        }
+        // Properties
+        /** Find a property by name (case-insensitive). Searches own + inherited.
+         *
+         * Note: this resolves the full property list and linear-scans it on every call. For workloads
+         * that hit `getProperty` repeatedly on the same class with different names, a per-class
+         * resolved-property map cache could be added on the view. Not done now - measure before
+         * optimizing. */
+        getProperty(name) {
+            const allProps = this._ctx.resolveAllProperties(this.idx);
+            const lowerName = name.toLowerCase();
+            for (const rp of allProps) {
+                if (this._ctx[_storage].lowerStrings[this._ctx[_storage].propDefs[rp.ref.defIdx].nameStringIdx] === lowerName)
+                    return createProperty(this._ctx, rp.ref, rp.classIdx);
+            }
+            return undefined;
+        }
+        /** All properties including inherited, in inheritance order (base first, then mixins, then own). */
+        getProperties() {
+            const allRefs = this._ctx.resolveAllProperties(this.idx);
+            return allRefs.map((rp) => createProperty(this._ctx, rp.ref, rp.classIdx));
+        }
+        /** Own properties only (not inherited), in ordinal order. */
+        getOwnProperties() {
+            const d = this._data;
+            const result = [];
+            for (let i = 0; i < d.ownPropCount; i++) {
+                const ref = this._ctx[_storage].propertyRefs[d.ownPropStart + i];
+                result.push(createProperty(this._ctx, ref, this.idx));
+            }
+            return result;
+        }
+    }
+    SchemaView.Class = Class;
+    /** A relationship class with constraint and strength metadata. Created by `createClass()`
+     * when the underlying `ClassType` is `Relationship`. Use `cls.isRelationship()` to narrow a
+     * `SchemaView.Class` to this type.
+     * @beta
+     */
+    class RelationshipClass extends Class {
+        get strength() { return this._data.strength; }
+        get strengthDirection() { return this._data.strengthDirection; }
+        get source() {
+            const idx = this._data.sourceConstraintIdx;
+            return idx !== -1 ? new RelConstraint(this._ctx, idx) : undefined;
+        }
+        get target() {
+            const idx = this._data.targetConstraintIdx;
+            return idx !== -1 ? new RelConstraint(this._ctx, idx) : undefined;
+        }
+    }
+    SchemaView.RelationshipClass = RelationshipClass;
+    /** @internal */
+    function createClass(ctx, idx) {
+        if (ctx[_storage].classes[idx].type === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.ClassType.Relationship)
+            return new RelationshipClass(ctx, idx);
+        return new Class(ctx, idx);
+    }
+    SchemaView.createClass = createClass;
+    /** Lightweight view over a property in a `SchemaView`. Subclasses provide
+     * type-safe access to kind-specific fields. Use `isPrimitive()`, `isStruct()`,
+     * `isArray()`, or `isNavigation()` to narrow, or the corresponding `assert*()` methods.
+     * @beta
+     */
+    class Property {
+        _ctx;
+        _ref;
+        _classIdx;
+        /** @internal */
+        constructor(_ctx, _ref, 
+        /** Index of the class that declared or contributed this property through inheritance.
+         * For own properties, this is the class itself. For inherited properties, this is the
+         * base class or mixin that introduced it. -1 for view properties. */
+        _classIdx) {
+            this._ctx = _ctx;
+            this._ref = _ref;
+            this._classIdx = _classIdx;
+        }
+        /** @internal */
+        get _def() { return this._ctx[_storage].propDefs[this._ref.defIdx]; }
+        /** Row ID from ec_Property. Matches `ECInstanceId` in ECDbMeta views, e.g.
+         * `SELECT * FROM meta.ECPropertyDef WHERE ECInstanceId = ?`.
+         *
+         * Stored per-reference (not per-definition) because each class-property pair has a unique
+         * ec_Property row even when the structural definition is deduplicated.
+         */
+        get ecInstanceId() { return this._ref.ecInstanceId; }
+        get name() { return this._ctx[_storage].strings[this._def.nameStringIdx]; }
+        /** Display label. Falls back to the property name if no explicit label is set.
+         * Labels are stored per-reference (not per-definition) because EC allows class overrides. */
+        get label() {
+            const labelStringIdx = this._ref.labelStringIdx;
+            return labelStringIdx !== 0 ? this._ctx[_storage].strings[labelStringIdx] : this.name;
+        }
+        get description() {
+            const sid = this._def.descriptionStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : "";
+        }
+        get kind() { return this._def.kind; }
+        get isReadOnly() { return this._def.isReadOnly; }
+        /** Reflects the `HiddenProperty` custom attribute from `CoreCustomAttributes`.
+         * Properties marked hidden are typically excluded from UI display but remain accessible programmatically. */
+        get isHidden() { return this._def.isHidden; }
+        /** Display priority. Higher values should be displayed more prominently. 0 means default. */
+        get priority() { return this._ref.priority; }
+        /** The class that declared or contributed this property through inheritance.
+         * For own properties, returns the class itself. For inherited properties, returns the
+         * base class or mixin that introduced it. Returns `undefined` for view properties.
+         * This is the class array index, not the ec_Class.Id from the database.
+         * @beta
+         */
+        get declaringClass() {
+            return this._classIdx !== -1 ? createClass(this._ctx, this._classIdx) : undefined;
+        }
+        /** Property category, or undefined if none assigned. Available on all property kinds. */
+        get category() {
+            const idx = this._def.categoryIdx;
+            return idx !== -1 ? new PropertyCategory(this._ctx, idx) : undefined;
+        }
+        // Type guards - real type predicates that narrow `this`
+        /** True for `SchemaView.PrimitiveProperty` and `SchemaView.PrimitiveArrayProperty`.
+         * Matches ecschema-metadata behavior where `isPrimitive()` includes primitive arrays. */
+        isPrimitive() {
+            return this._def.kind === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind.Primitive || this._def.kind === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind.PrimitiveArray;
+        }
+        /** True for `SchemaView.StructProperty` and `SchemaView.StructArrayProperty`. */
+        isStruct() {
+            return this._def.kind === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind.Struct || this._def.kind === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind.StructArray;
+        }
+        /** True for `SchemaView.PrimitiveArrayProperty` and `SchemaView.StructArrayProperty`. */
+        isArray() {
+            return this._def.kind === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind.PrimitiveArray || this._def.kind === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind.StructArray;
+        }
+        /** True for `SchemaView.NavigationProperty`. */
+        isNavigation() {
+            return this._def.kind === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind.Navigation;
+        }
+        /** True if this property is backed by an enumeration. Enumerations are a facet of primitive
+         * properties - an enum property IS a primitive property with an enum binding. Narrows to
+         * `AnyPrimitiveProperty` so you can access `enumeration`, `primitiveType`, etc. */
+        isEnumeration() {
+            return this._def.enumIdx !== -1;
+        }
+        // Assert methods - throw on mismatch, narrow `this`
+        /** @see isPrimitive */
+        assertPrimitive() {
+            if (!this.isPrimitive())
+                throw new Error(`Expected a primitive property, got ${_SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind[this.kind]}`);
+        }
+        /** @see isStruct */
+        assertStruct() {
+            if (!this.isStruct())
+                throw new Error(`Expected a struct property, got ${_SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind[this.kind]}`);
+        }
+        /** @see isArray */
+        assertArray() {
+            if (!this.isArray())
+                throw new Error(`Expected an array property, got ${_SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind[this.kind]}`);
+        }
+        /** @see isNavigation */
+        assertNavigation() {
+            if (!this.isNavigation())
+                throw new Error(`Expected a navigation property, got ${_SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind[this.kind]}`);
+        }
+    }
+    SchemaView.Property = Property;
+    /** A scalar primitive property. May optionally be backed by an enumeration -
+     * check `isEnumeration()` or `enumeration`.
+     * @beta
+     */
+    class PrimitiveProperty extends Property {
+        get primitiveType() { return this._def.primitiveType; }
+        get extendedTypeName() {
+            const sid = this._def.extTypeStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : undefined;
+        }
+        get enumeration() {
+            const idx = this._def.enumIdx;
+            return idx !== -1 ? new Enumeration(this._ctx, idx) : undefined;
+        }
+        get kindOfQuantity() {
+            const idx = this._def.koqIdx;
+            return idx !== -1 ? new KindOfQuantity(this._ctx, idx) : undefined;
+        }
+    }
+    SchemaView.PrimitiveProperty = PrimitiveProperty;
+    /** An array of primitive values. Same primitive/enum fields as `PrimitiveProperty`,
+     * plus array bounds.
+     * @beta
+     */
+    class PrimitiveArrayProperty extends Property {
+        get primitiveType() { return this._def.primitiveType; }
+        get extendedTypeName() {
+            const sid = this._def.extTypeStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : undefined;
+        }
+        get enumeration() {
+            const idx = this._def.enumIdx;
+            return idx !== -1 ? new Enumeration(this._ctx, idx) : undefined;
+        }
+        get kindOfQuantity() {
+            const idx = this._def.koqIdx;
+            return idx !== -1 ? new KindOfQuantity(this._ctx, idx) : undefined;
+        }
+        get arrayMinOccurs() { return this._def.arrayMinOccurs; }
+        get arrayMaxOccurs() { return this._def.arrayMaxOccurs; }
+    }
+    SchemaView.PrimitiveArrayProperty = PrimitiveArrayProperty;
+    /** A scalar struct property. `structClass` is non-nullable - the binary parser drops
+     * properties whose struct class can't be resolved (e.g. from excluded schemas).
+     * @beta
+     */
+    class StructProperty extends Property {
+        get structClass() {
+            return createClass(this._ctx, this._def.structClassIdx);
+        }
+    }
+    SchemaView.StructProperty = StructProperty;
+    /** An array of struct values. Same struct field as `StructProperty`, plus array bounds.
+     * @beta
+     */
+    class StructArrayProperty extends Property {
+        get structClass() {
+            return createClass(this._ctx, this._def.structClassIdx);
+        }
+        get arrayMinOccurs() { return this._def.arrayMinOccurs; }
+        get arrayMaxOccurs() { return this._def.arrayMaxOccurs; }
+    }
+    SchemaView.StructArrayProperty = StructArrayProperty;
+    /** A navigation property. `relationshipClass` is non-nullable - the binary parser drops
+     * properties whose relationship class can't be resolved.
+     * @beta
+     */
+    class NavigationProperty extends Property {
+        get direction() { return this._def.navDirection; }
+        get relationshipClass() {
+            return createClass(this._ctx, this._def.navRelClassIdx);
+        }
+    }
+    SchemaView.NavigationProperty = NavigationProperty;
+    /** @internal */
+    function createProperty(ctx, ref, classIdx) {
+        const kind = ctx[_storage].propDefs[ref.defIdx].kind;
+        switch (kind) {
+            case _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind.Primitive: return new PrimitiveProperty(ctx, ref, classIdx);
+            case _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind.PrimitiveArray: return new PrimitiveArrayProperty(ctx, ref, classIdx);
+            case _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind.Struct: return new StructProperty(ctx, ref, classIdx);
+            case _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind.StructArray: return new StructArrayProperty(ctx, ref, classIdx);
+            case _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_0__.PropertyKind.Navigation: return new NavigationProperty(ctx, ref, classIdx);
+            default: throw new Error(`Unknown PropertyKind ${kind} for property "${ctx[_storage].strings[ctx[_storage].propDefs[ref.defIdx].nameStringIdx]}"`);
+        }
+    }
+    SchemaView.createProperty = createProperty;
+    /** Lightweight view over an enumeration in a `SchemaView`.
+     * @beta
+     */
+    class Enumeration {
+        _ctx;
+        idx;
+        /** @internal */
+        constructor(_ctx, 
+        /** @internal */ idx) {
+            this._ctx = _ctx;
+            this.idx = idx;
+        }
+        get _data() { return this._ctx[_storage].enumerations[this.idx]; }
+        /** Row ID from ec_Enumeration. Matches `ECInstanceId` in ECDbMeta views, e.g.
+         * `SELECT * FROM meta.ECEnumerationDef WHERE ECInstanceId = ?`.
+         */
+        get ecInstanceId() { return this._data.ecInstanceId; }
+        get name() { return this._ctx[_storage].strings[this._data.nameStringIdx]; }
+        get label() {
+            const sid = this._data.labelStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : this.name;
+        }
+        get description() {
+            const sid = this._data.descriptionStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : "";
+        }
+        /** "SchemaName:EnumName" - colon-separated. */
+        get fullName() {
+            const d = this._data;
+            return `${this._ctx[_storage].strings[this._ctx[_storage].schemas[d.schemaIdx].nameStringIdx]}:${this._ctx[_storage].strings[d.nameStringIdx]}`;
+        }
+        get schema() { return new Schema(this._ctx, this._data.schemaIdx); }
+        get primitiveType() { return this._data.primitiveType; }
+        get isStrict() { return this._data.isStrict; }
+        /** Iterate enumerators in declaration order. */
+        *getEnumerators() {
+            const d = this._data;
+            for (let i = d.enumeratorStart; i < d.enumeratorStart + d.enumeratorCount; i++)
+                yield new Enumerator(this._ctx, i);
+        }
+        /** Find enumerator by name (case-insensitive). */
+        getEnumeratorByName(name) {
+            const lower = name.toLowerCase();
+            const d = this._data;
+            for (let i = d.enumeratorStart; i < d.enumeratorStart + d.enumeratorCount; i++) {
+                if (this._ctx[_storage].lowerStrings[this._ctx[_storage].enumerators[i].nameStringIdx] === lower)
+                    return new Enumerator(this._ctx, i);
+            }
+            return undefined;
+        }
+        /** Find enumerator by value. */
+        getEnumerator(value) {
+            const d = this._data;
+            for (let i = d.enumeratorStart; i < d.enumeratorStart + d.enumeratorCount; i++) {
+                if (this._ctx[_storage].enumerators[i].value === value)
+                    return new Enumerator(this._ctx, i);
+            }
+            return undefined;
+        }
+    }
+    SchemaView.Enumeration = Enumeration;
+    /** Thin view over an enumerator.
+     * @beta
+     */
+    class Enumerator {
+        _ctx;
+        idx;
+        /** @internal */
+        constructor(_ctx, 
+        /** @internal */ idx) {
+            this._ctx = _ctx;
+            this.idx = idx;
+        }
+        get _data() { return this._ctx[_storage].enumerators[this.idx]; }
+        get name() { return this._ctx[_storage].strings[this._data.nameStringIdx]; }
+        get label() {
+            const sid = this._data.labelStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : this.name;
+        }
+        get description() {
+            const sid = this._data.descriptionStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : "";
+        }
+        get value() { return this._data.value; }
+    }
+    SchemaView.Enumerator = Enumerator;
+    /** Parse a single format override string into a `PresentationFormat`.
+     * @internal
+     */
+    function parseFormatString(formatString) {
+        const nameMatch = /^([\w.:]+)/.exec(formatString);
+        if (!nameMatch)
+            return { name: formatString };
+        const name = nameMatch[1];
+        const precMatch = /\((\d+)\)/.exec(formatString);
+        const precision = precMatch ? parseInt(precMatch[1], 10) : undefined;
+        const bracketRgx = /\[([^\]]+)\]/g;
+        const units = [];
+        let m;
+        while ((m = bracketRgx.exec(formatString)) !== null) {
+            const pipeIdx = m[1].indexOf("|");
+            units.push(pipeIdx < 0 ? [m[1], undefined] : [m[1].substring(0, pipeIdx), m[1].substring(pipeIdx + 1)]);
+        }
+        return { name, precision, unitAndLabels: units.length > 0 ? units : undefined };
+    }
+    SchemaView.parseFormatString = parseFormatString;
+    /** Lightweight view over a KindOfQuantity in a `SchemaView`.
+     * @beta
+     */
+    class KindOfQuantity {
+        _ctx;
+        idx;
+        /** @internal */
+        constructor(_ctx, 
+        /** @internal */ idx) {
+            this._ctx = _ctx;
+            this.idx = idx;
+        }
+        get _data() { return this._ctx[_storage].koqs[this.idx]; }
+        /** Row ID from ec_KindOfQuantity. Matches `ECInstanceId` in ECDbMeta views, e.g.
+         * `SELECT * FROM meta.ECKindOfQuantityDef WHERE ECInstanceId = ?`.
+         */
+        get ecInstanceId() { return this._data.ecInstanceId; }
+        get name() { return this._ctx[_storage].strings[this._data.nameStringIdx]; }
+        get label() {
+            const sid = this._data.labelStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : this.name;
+        }
+        get description() {
+            const sid = this._data.descriptionStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : "";
+        }
+        /** "SchemaName:KoqName" - colon-separated. */
+        get fullName() {
+            const d = this._data;
+            return `${this._ctx[_storage].strings[this._ctx[_storage].schemas[d.schemaIdx].nameStringIdx]}:${this._ctx[_storage].strings[d.nameStringIdx]}`;
+        }
+        get schema() { return new Schema(this._ctx, this._data.schemaIdx); }
+        get relativeError() { return this._data.relativeError; }
+        /** Persistence unit as a full name string, e.g. "Units:M".
+         *
+         * On iModels still on ECDb profile `4.0.0.1` (predates the 2018 EC3.2 Units/Formats migration)
+         * this string is in legacy FUS format rather than the EC3.2 alias-qualified form.
+         * Upgrade the iModel's ECDb profile to get EC3.2 strings.
+         */
+        get persistenceUnit() {
+            const sid = this._data.persistenceUnitStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : "";
+        }
+        // EC XML serializes this as "presentationUnits"; we use "presentationFormats" to align with KindOfQuantity.presentationFormats in ecschema-metadata.
+        /** Raw presentation format string as stored in ECDb (`ec_KindOfQuantity.PresentationUnits`).
+         * This is a JSON array of format override strings. Empty string if none are defined.
+         * Prefer `presentationFormats` for structured access.
+         *
+         * On iModels still on ECDb profile `4.0.0.1` (predates the 2018 EC3.2 Units/Formats migration)
+         * the strings are in legacy FUS format and will not parse via `presentationFormats`.
+         * Upgrade the iModel's ECDb profile to get EC3.2 strings.
+         */
+        get presentationFormatsRaw() {
+            const sid = this._data.presentationFormatsStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : "";
+        }
+        /** Presentation formats parsed into structured overrides. Each entry has the format name
+         * (alias-qualified, e.g. `"f:DefaultRealU"`), optional precision override, and optional
+         * unit-and-label overrides. Returns an empty array if no presentation formats are defined.
+         *
+         * Example - given a raw string of `["f:DefaultRealU(4)[u:M_PER_SEC_SQ]","f:DefaultRealU(4)[u:CM_PER_SEC_SQ]"]`:
+         * ```ts
+         * // [
+         * //   { name: "f:DefaultRealU", precision: 4, unitAndLabels: [["u:M_PER_SEC_SQ", undefined]] },
+         * //   { name: "f:DefaultRealU", precision: 4, unitAndLabels: [["u:CM_PER_SEC_SQ", undefined]] },
+         * // ]
+         * ```
+         */
+        get presentationFormats() {
+            const raw = this.presentationFormatsRaw;
+            if (raw === "")
+                return [];
+            const formats = JSON.parse(raw);
+            return formats.map((f) => parseFormatString(f));
+        }
+    }
+    SchemaView.KindOfQuantity = KindOfQuantity;
+    /** Lightweight view over a PropertyCategory in a `SchemaView`.
+     * @beta
+     */
+    class PropertyCategory {
+        _ctx;
+        idx;
+        /** @internal */
+        constructor(_ctx, 
+        /** @internal */ idx) {
+            this._ctx = _ctx;
+            this.idx = idx;
+        }
+        get _data() { return this._ctx[_storage].propCategories[this.idx]; }
+        /** Row ID from ec_PropertyCategory. Matches `ECInstanceId` in ECDbMeta views, e.g.
+         * `SELECT * FROM meta.ECPropertyCategoryDef WHERE ECInstanceId = ?`.
+         */
+        get ecInstanceId() { return this._data.ecInstanceId; }
+        get name() { return this._ctx[_storage].strings[this._data.nameStringIdx]; }
+        get label() {
+            const sid = this._data.labelStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : this.name;
+        }
+        get description() {
+            const sid = this._data.descriptionStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : "";
+        }
+        /** "SchemaName:CategoryName" - colon-separated. */
+        get fullName() {
+            const d = this._data;
+            return `${this._ctx[_storage].strings[this._ctx[_storage].schemas[d.schemaIdx].nameStringIdx]}:${this._ctx[_storage].strings[d.nameStringIdx]}`;
+        }
+        get schema() { return new Schema(this._ctx, this._data.schemaIdx); }
+        get priority() { return this._data.priority; }
+    }
+    SchemaView.PropertyCategory = PropertyCategory;
+    /** Lightweight view over a relationship constraint in a `SchemaView`.
+     * @beta
+     */
+    class RelConstraint {
+        _ctx;
+        _idx;
+        /** @internal */
+        constructor(_ctx, _idx) {
+            this._ctx = _ctx;
+            this._idx = _idx;
+        }
+        get _data() { return this._ctx[_storage].relConstraints[this._idx]; }
+        get abstractConstraint() {
+            const idx = this._data.abstractConstraintIdx;
+            return idx !== -1 ? createClass(this._ctx, idx) : undefined;
+        }
+        get polymorphic() { return this._data.polymorphic; }
+        /** Multiplicity lower bound (0 = unbounded). */
+        get multiplicityLower() { return this._data.multiplicityLower; }
+        /** Multiplicity upper bound (0 = unbounded). */
+        get multiplicityUpper() { return this._data.multiplicityUpper; }
+        /** Role label string, or empty if not set. */
+        get roleLabel() {
+            const sid = this._data.roleLabelStringIdx;
+            return sid !== 0 ? this._ctx[_storage].strings[sid] : "";
+        }
+        get constraintClasses() {
+            const d = this._data;
+            const result = [];
+            for (let i = 0; i < d.classRefCount; i++)
+                result.push(createClass(this._ctx, this._ctx[_storage].constraintClassRefs[d.classRefStart + i]));
+            return result;
+        }
+    }
+    SchemaView.RelConstraint = RelConstraint;
+})(SchemaView || (SchemaView = {}));
+// =====================================================================================
+// SchemaViewBuilder
+// =====================================================================================
+/** Builder for constructing an immutable `SchemaView`.
+ *
+ * Collects data during binary blob parsing, then freezes it into a view.
+ * Handles string interning and property definition deduplication.
+ *
+ * Consumers should not use this directly - read views via `IModelDb.getSchemaView`
+ * / `IModelConnection.getSchemaView` (or `SchemaView.fromBinary` if you have a raw blob).
+ * @internal
+ */
+class SchemaViewBuilder {
+    _strings = [""]; // SID 0 = empty string
+    _lowerStrings = [""];
+    _stringMap = new Map(); // original value -> SID
+    _schemas = [];
+    _classes = [];
+    _classMixins = [];
+    _propDefs = [];
+    _propertyRefs = [];
+    _relConstraints = [];
+    _constraintClassRefs = [];
+    _enumerations = [];
+    _enumerators = [];
+    _koqs = [];
+    _propCategories = [];
+    // For PropertyDef dedup
+    _propDefMap = new Map(); // signature string -> defIdx
+    /** Intern a string, returning its SID. Empty/undefined strings return 0.
+     * Interning is case-sensitive - "MyLabel" and "MYLABEL" get distinct SIDs.
+     * The `lowerStrings` array provides case-insensitive lookup without mutating display values.
+     */
+    internString(value) {
+        if (value === undefined || value === "")
+            return 0;
+        const existing = this._stringMap.get(value);
+        if (existing !== undefined)
+            return existing;
+        const sid = this._strings.length;
+        this._strings.push(value);
+        this._lowerStrings.push(value.toLowerCase());
+        this._stringMap.set(value, sid);
+        return sid;
+    }
+    /** Add a schema. Returns its index. */
+    addSchema(data) {
+        const idx = this._schemas.length;
+        this._schemas.push(data);
+        return idx;
+    }
+    /** Add a class. Returns its index. Must be called after the owning schema. */
+    addClass(data) {
+        const idx = this._classes.length;
+        this._classes.push(data);
+        return idx;
+    }
+    /** Add a property definition with deduplication. Returns the def index (possibly existing). */
+    addPropertyDef(data) {
+        const sig = this._propDefSignature(data);
+        const existing = this._propDefMap.get(sig);
+        if (existing !== undefined)
+            return existing;
+        const idx = this._propDefs.length;
+        this._propDefs.push(data);
+        this._propDefMap.set(sig, idx);
+        return idx;
+    }
+    /** Append a property reference to the flat refs array. */
+    addPropertyRef(ref) {
+        this._propertyRefs.push(ref);
+    }
+    /** Add an enumeration. Returns its index. */
+    addEnumeration(data) {
+        const idx = this._enumerations.length;
+        this._enumerations.push(data);
+        return idx;
+    }
+    /** Append an enumerator to the flat enumerators array. */
+    addEnumerator(data) {
+        this._enumerators.push(data);
+    }
+    /** Add a KindOfQuantity. Returns its index. */
+    addKoq(data) {
+        const idx = this._koqs.length;
+        this._koqs.push(data);
+        return idx;
+    }
+    /** Add a PropertyCategory. Returns its index. */
+    addPropertyCategory(data) {
+        const idx = this._propCategories.length;
+        this._propCategories.push(data);
+        return idx;
+    }
+    /** Add a relationship constraint. Returns its index. */
+    addRelConstraint(data) {
+        const idx = this._relConstraints.length;
+        this._relConstraints.push(data);
+        return idx;
+    }
+    /** Append a constraint class reference to the flat array. */
+    addConstraintClassRef(classIdx) {
+        this._constraintClassRefs.push(classIdx);
+    }
+    /** Append a mixin class reference to the flat array. */
+    addClassMixin(classIdx) {
+        this._classMixins.push(classIdx);
+    }
+    /** The current count of property refs (used to set ownPropStart on ClassData). */
+    get propertyRefCount() { return this._propertyRefs.length; }
+    /** The current count of enumerators (used to set enumeratorStart on EnumerationData). */
+    get enumeratorCount() { return this._enumerators.length; }
+    /** The current count of constraint class refs (used to set classRefStart). */
+    get constraintClassRefCount() { return this._constraintClassRefs.length; }
+    /** The current count of class mixins (used to set mixinStartIdx). */
+    get classMixinCount() { return this._classMixins.length; }
+    /** Get a string by SID. @internal */
+    getString(sid) { return this._strings[sid]; }
+    /** Replace class data at the given index (used during deferred cross-ref resolution). @internal */
+    updateClass(classIdx, data) { this._classes[classIdx] = data; }
+    /** Update range fields on a schema (used after all items for a schema are collected). @internal */
+    updateSchemaRanges(schemaIdx, ranges) {
+        const s = this._schemas[schemaIdx];
+        this._schemas[schemaIdx] = { ...s, ...ranges };
+    }
+    /** Freeze all data and produce an immutable SchemaView. */
+    build(schemaToken) {
+        const schemaByName = new Map();
+        const schemaByAlias = new Map();
+        const classByName = new Map();
+        const enumByName = new Map();
+        const koqByName = new Map();
+        const catByName = new Map();
+        // Build schema lookup maps
+        for (let i = 0; i < this._schemas.length; i++) {
+            const s = this._schemas[i];
+            schemaByName.set(this._lowerStrings[s.nameStringIdx], i);
+            if (s.aliasStringIdx !== 0)
+                schemaByAlias.set(this._lowerStrings[s.aliasStringIdx], i);
+            // Build class-by-name map for this schema
+            const classMap = new Map();
+            for (let c = s.classRangeStart; c < s.classRangeStart + s.classCount; c++)
+                classMap.set(this._lowerStrings[this._classes[c].nameStringIdx], c);
+            classByName.set(i, classMap);
+            // Build enum-by-name map for this schema
+            const eMap = new Map();
+            for (let e = s.enumRangeStart; e < s.enumRangeStart + s.enumCount; e++)
+                eMap.set(this._lowerStrings[this._enumerations[e].nameStringIdx], e);
+            enumByName.set(i, eMap);
+            // Build koq-by-name map for this schema
+            const kMap = new Map();
+            for (let k = s.koqRangeStart; k < s.koqRangeStart + s.koqCount; k++)
+                kMap.set(this._lowerStrings[this._koqs[k].nameStringIdx], k);
+            koqByName.set(i, kMap);
+            // Build category-by-name map for this schema
+            const cMap = new Map();
+            for (let p = s.catRangeStart; p < s.catRangeStart + s.catCount; p++)
+                cMap.set(this._lowerStrings[this._propCategories[p].nameStringIdx], p);
+            catByName.set(i, cMap);
+        }
+        return new SchemaView({
+            strings: this._strings,
+            lowerStrings: this._lowerStrings,
+            schemas: this._schemas,
+            classes: this._classes,
+            classMixins: this._classMixins,
+            propDefs: this._propDefs,
+            propertyRefs: this._propertyRefs,
+            relConstraints: this._relConstraints,
+            constraintClassRefs: this._constraintClassRefs,
+            enumerations: this._enumerations,
+            enumerators: this._enumerators,
+            koqs: this._koqs,
+            propCategories: this._propCategories,
+            schemaByName,
+            schemaByAlias,
+            classByName,
+            enumByName,
+            koqByName,
+            catByName,
+        }, schemaToken);
+    }
+    /** Produce a dedup signature for a PropertyDef. Label and priority are excluded because
+     * they are per-PropertyRef overrides, not part of the structural definition.
+     * Uses SIDs (not lowercase strings) for name/description so that case-preserving names
+     * stay distinct - matching the C++ writer's dedup behavior. */
+    _propDefSignature(def) {
+        return `${def.nameStringIdx}|${def.kind}|${def.primitiveType}|${def.extTypeStringIdx}|${def.enumIdx}|${def.koqIdx}|${def.structClassIdx}|${def.navRelClassIdx}|${def.navDirection}|${def.categoryIdx}|${def.isReadOnly ? 1 : 0}|${def.isHidden ? 1 : 0}|${def.arrayMinOccurs}|${def.arrayMaxOccurs}|${def.descriptionStringIdx}`;
+    }
+}
+
+
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/SchemaViewBinaryReader.js":
+/*!**********************************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/SchemaViewBinaryReader.js ***!
+  \**********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   parseSchemaViewBlob: () => (/* binding */ parseSchemaViewBlob)
+/* harmony export */ });
+/* harmony import */ var _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @itwin/core-bentley */ "../../core/bentley/lib/esm/core-bentley.js");
+/* harmony import */ var _SchemaView__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./SchemaView */ "../../core/ecschema-metadata/lib/esm/SchemaView.js");
+/* harmony import */ var _ECObjects__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ECObjects */ "../../core/ecschema-metadata/lib/esm/ECObjects.js");
+/* harmony import */ var _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./SchemaViewInterfaces */ "../../core/ecschema-metadata/lib/esm/SchemaViewInterfaces.js");
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Schema
+ */
+
+
+
+
+/** Binary record tags for the SchemaView blob format.
+ * Each tag marks a flat, count-prefixed table. Must stay in sync with the C++ writer. */
+var Tag;
+(function (Tag) {
+    Tag[Tag["PropertyDefTable"] = 10] = "PropertyDefTable";
+    Tag[Tag["SchemaTable"] = 16] = "SchemaTable";
+    Tag[Tag["EnumTable"] = 32] = "EnumTable";
+    Tag[Tag["KoQTable"] = 48] = "KoQTable";
+    Tag[Tag["PropCatTable"] = 49] = "PropCatTable";
+    Tag[Tag["ClassTable"] = 64] = "ClassTable";
+})(Tag || (Tag = {}));
+const MAGIC = 0x43534348; // "CSCH"
+/** Low-level binary reader for the SchemaView blob. */
+class BinaryReader {
+    _view;
+    _bytes;
+    _pos;
+    _strings;
+    constructor(data) {
+        this._bytes = data;
+        this._view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+        this._pos = 0;
+        this._strings = [];
+    }
+    readU8() {
+        if (this._pos >= this._bytes.length)
+            throw new Error(`SchemaView blob truncated: cannot read u8 at offset ${this._pos} (length ${this._bytes.length})`);
+        return this._bytes[this._pos++];
+    }
+    readU16() { const v = this._view.getUint16(this._pos, true); this._pos += 2; return v; }
+    readU32() { const v = this._view.getUint32(this._pos, true); this._pos += 4; return v; }
+    readI32() { const v = this._view.getInt32(this._pos, true); this._pos += 4; return v; }
+    readF64() { const v = this._view.getFloat64(this._pos, true); this._pos += 8; return v; }
+    get pos() { return this._pos; }
+    set pos(v) { this._pos = v; }
+    /** Read a string-table reference (U32 index) and return the original string. */
+    readSRef() {
+        const idx = this.readU32();
+        if (idx >= this._strings.length)
+            throw new Error(`SchemaView blob: string reference ${idx} out of range (string table size ${this._strings.length})`);
+        return this._strings[idx];
+    }
+    /** Validate a count-prefixed table header: the declared count cannot exceed what the remaining
+     *  buffer could plausibly hold. Each entry consumes at least `minBytesPerEntry` bytes. */
+    validateCount(count, minBytesPerEntry, tableName) {
+        const remaining = this._bytes.length - this._pos;
+        if (count > remaining / Math.max(1, minBytesPerEntry))
+            throw new Error(`SchemaView blob: ${tableName} count ${count} exceeds remaining buffer (${remaining} bytes)`);
+    }
+    /** Parse the string table at the given offset. */
+    parseStringTable(offset) {
+        if (offset > this._bytes.length)
+            throw new Error(`SchemaView blob: stringTable offset ${offset} is past end of blob (length ${this._bytes.length})`);
+        const saved = this._pos;
+        this._pos = offset;
+        const count = this.readU32();
+        // Each entry is at minimum a 4-byte length prefix - a count larger than the remaining bytes
+        // cannot possibly be valid and would cause a huge `new Array` allocation on a malformed blob.
+        const remaining = this._bytes.length - this._pos;
+        if (count > remaining / 4)
+            throw new Error(`SchemaView blob: stringTable count ${count} exceeds remaining buffer (${remaining} bytes)`);
+        this._strings = new Array(count);
+        const decoder = new TextDecoder();
+        for (let i = 0; i < count; i++) {
+            const len = this.readU32();
+            if (len === 0) {
+                this._strings[i] = "";
+            }
+            else {
+                if (len > this._bytes.length - this._pos)
+                    throw new Error(`SchemaView blob: string entry ${i} has length ${len} but only ${this._bytes.length - this._pos} bytes remain`);
+                this._strings[i] = decoder.decode(this._bytes.subarray(this._pos, this._pos + len));
+                this._pos += len;
+            }
+        }
+        this._pos = saved;
+    }
+}
+/** Read a U32 that uses 0xFFFFFFFF as a sentinel for "not set". */
+function readOptionalU32(reader) {
+    const v = reader.readU32();
+    return v === 0xFFFFFFFF ? undefined : v;
+}
+/** Helper: read a tag byte and validate it matches the expected tag. */
+function expectTag(reader, expected) {
+    const tag = reader.readU8();
+    if (tag !== expected)
+        throw new Error(`Expected tag 0x${expected.toString(16)} but found 0x${tag.toString(16)} at offset ${reader.pos - 1}`);
+}
+/** Parse a schema view blob (binary format) into a `SchemaView`.
+ *
+ * Layout: Header, PropertyDefTable, SchemaTable, EnumTable, KoQTable, PropCatTable, ClassTable, StringTable.
+ * Each table is count-prefixed. Schema items carry their schema's ecInstanceId for ownership resolution.
+ * Classes have count-prefixed inline sub-items (base classes, property refs, constraints).
+ *
+ * Consumers should call `SchemaView.fromBinary` instead - this function is the low-level
+ * implementation behind it.
+ * @internal
+ */
+function parseSchemaViewBlob(data, schemaToken) {
+    const reader = new BinaryReader(data);
+    // Header: magic(4) + version(1) + stringTableOffset(4)
+    const magic = reader.readU32();
+    if (magic !== MAGIC)
+        throw new Error(`Invalid SchemaView blob magic: 0x${magic.toString(16)}, expected 0x${MAGIC.toString(16)}`);
+    const version = reader.readU8();
+    if (version !== _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_3__.schemaViewFormatVersion)
+        throw new Error(`Unsupported schema view format version: ${version}, expected ${_SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_3__.schemaViewFormatVersion}`);
+    const stOffset = reader.readU32();
+    reader.parseStringTable(stOffset);
+    const builder = new _SchemaView__WEBPACK_IMPORTED_MODULE_1__.SchemaViewBuilder();
+    // Cross-reference maps (ecInstanceId -> builder array index)
+    const schemaEcIdToIdx = new Map();
+    const enumRowIdToIdx = new Map();
+    const koqRowIdToIdx = new Map();
+    const catRowIdToIdx = new Map();
+    const classRowIdToIdx = new Map();
+    // Per-schema metadata for name-based class resolution
+    const schemaInfos = [];
+    // Per-schema item range tracking (indexed by schemaIdx)
+    const schemaEnumStarts = [];
+    const schemaEnumCounts = [];
+    const schemaKoqStarts = [];
+    const schemaKoqCounts = [];
+    const schemaCatStarts = [];
+    const schemaCatCounts = [];
+    const schemaClassStarts = [];
+    const schemaClassCounts = [];
+    // Deferred class data for cross-reference resolution
+    const pendingClasses = [];
+    // ---- PropertyDefTable ----
+    expectTag(reader, Tag.PropertyDefTable);
+    const defCount = reader.readU32();
+    // Each PreParsedDef consumes at least ~30 bytes (mix of u8/u16/u32 fields + string refs).
+    // Use a conservative lower bound of 8 bytes to catch wildly oversized counts on malformed blobs.
+    reader.validateCount(defCount, 8, "PropertyDefTable");
+    const preParsedDefs = new Array(defCount);
+    for (let i = 0; i < defCount; i++) {
+        preParsedDefs[i] = {
+            name: reader.readSRef(),
+            kind: reader.readU8(),
+            primitiveType: reader.readU16(),
+            extType: reader.readSRef(),
+            enumRowId: reader.readU32(),
+            structClassRowId: reader.readU32(),
+            koqRowId: reader.readU32(),
+            catRowId: reader.readU32(),
+            arrayMinOccurs: readOptionalU32(reader),
+            arrayMaxOccurs: readOptionalU32(reader),
+            navRelClassRowId: reader.readU32(),
+            navDirection: reader.readU8(),
+            isReadonly: reader.readU8() !== 0,
+            isHidden: reader.readU8() !== 0,
+            description: reader.readSRef(),
+        };
+    }
+    // ---- SchemaTable ----
+    expectTag(reader, Tag.SchemaTable);
+    const schemaCount = reader.readU32();
+    reader.validateCount(schemaCount, 8, "SchemaTable");
+    for (let i = 0; i < schemaCount; i++) {
+        const name = reader.readSRef();
+        const vRead = reader.readU16();
+        const vWrite = reader.readU16();
+        const vMinor = reader.readU16();
+        const alias = reader.readSRef();
+        const label = reader.readSRef();
+        const description = reader.readSRef();
+        const ecInstanceId = reader.readU32();
+        const isHidden = reader.readU8() !== 0;
+        const schemaIdx = builder.addSchema({
+            ecInstanceId,
+            nameStringIdx: builder.internString(name),
+            aliasStringIdx: builder.internString(alias),
+            labelStringIdx: builder.internString(label),
+            descriptionStringIdx: builder.internString(description),
+            versionRead: vRead,
+            versionWrite: vWrite,
+            versionMinor: vMinor,
+            classRangeStart: 0, classCount: 0,
+            enumRangeStart: 0, enumCount: 0,
+            koqRangeStart: 0, koqCount: 0,
+            catRangeStart: 0, catCount: 0,
+            isHidden,
+        });
+        schemaEcIdToIdx.set(ecInstanceId, schemaIdx);
+        schemaInfos.push({ name, schemaIdx, classNameToIdx: new Map() });
+        schemaEnumStarts.push(0);
+        schemaEnumCounts.push(0);
+        schemaKoqStarts.push(0);
+        schemaKoqCounts.push(0);
+        schemaCatStarts.push(0);
+        schemaCatCounts.push(0);
+        schemaClassStarts.push(0);
+        schemaClassCounts.push(0);
+    }
+    /** Track an item's schema ownership and update range counters. */
+    function trackItem(schemaEcId, globalIdx, starts, counts) {
+        const schemaIdx = schemaEcIdToIdx.get(schemaEcId);
+        if (schemaIdx === undefined)
+            throw new Error(`SchemaView blob: unknown schema ecInstanceId ${schemaEcId}`);
+        if (counts[schemaIdx] === 0)
+            starts[schemaIdx] = globalIdx;
+        counts[schemaIdx]++;
+        return schemaIdx;
+    }
+    // ---- EnumTable ----
+    expectTag(reader, Tag.EnumTable);
+    const enumTotalCount = reader.readU32();
+    reader.validateCount(enumTotalCount, 8, "EnumTable");
+    for (let i = 0; i < enumTotalCount; i++) {
+        const schemaEcId = reader.readU32();
+        const schemaIdx = trackItem(schemaEcId, i, schemaEnumStarts, schemaEnumCounts);
+        const eName = reader.readSRef();
+        const ePrimType = reader.readU8();
+        const eIsStrict = reader.readU8() !== 0;
+        const eLabel = reader.readSRef();
+        const eDesc = reader.readSRef();
+        const eValuesJson = reader.readSRef();
+        const eEcInstanceId = reader.readU32();
+        const enumeratorStart = builder.enumeratorCount;
+        let enumeratorCount = 0;
+        if (eValuesJson) {
+            try {
+                // eslint-disable-next-line @typescript-eslint/naming-convention
+                const values = JSON.parse(eValuesJson);
+                for (const v of values) {
+                    const value = v.IntValue !== undefined ? v.IntValue : (v.StringValue ?? "");
+                    const name = v.Name ?? (typeof value === "string" ? value : `${eName}${value}`);
+                    builder.addEnumerator({
+                        nameStringIdx: builder.internString(name),
+                        labelStringIdx: builder.internString(v.DisplayLabel),
+                        descriptionStringIdx: builder.internString(v.Description),
+                        value,
+                    });
+                    enumeratorCount++;
+                }
+            }
+            catch (e) {
+                _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.Logger.logWarning("ecschema-metadata.SchemaView", `Malformed EnumValues JSON for enumeration "${eName}": ${_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.BentleyError.getErrorMessage(e)}`);
+            }
+        }
+        const eIdx = builder.addEnumeration({
+            ecInstanceId: eEcInstanceId,
+            schemaIdx,
+            nameStringIdx: builder.internString(eName),
+            labelStringIdx: builder.internString(eLabel),
+            descriptionStringIdx: builder.internString(eDesc),
+            primitiveType: ePrimType,
+            isStrict: eIsStrict,
+            enumeratorStart,
+            enumeratorCount,
+        });
+        enumRowIdToIdx.set(eEcInstanceId, eIdx);
+    }
+    // ---- KoQTable ----
+    expectTag(reader, Tag.KoQTable);
+    const koqTotalCount = reader.readU32();
+    reader.validateCount(koqTotalCount, 8, "KoQTable");
+    for (let i = 0; i < koqTotalCount; i++) {
+        const schemaEcId = reader.readU32();
+        const schemaIdx = trackItem(schemaEcId, i, schemaKoqStarts, schemaKoqCounts);
+        const kName = reader.readSRef();
+        const kLabel = reader.readSRef();
+        const kDesc = reader.readSRef();
+        const kPersUnit = reader.readSRef();
+        const kRelError = reader.readF64();
+        const kPresUnits = reader.readSRef();
+        const kEcInstanceId = reader.readU32();
+        const kIdx = builder.addKoq({
+            ecInstanceId: kEcInstanceId,
+            schemaIdx,
+            nameStringIdx: builder.internString(kName),
+            labelStringIdx: builder.internString(kLabel),
+            descriptionStringIdx: builder.internString(kDesc),
+            persistenceUnitStringIdx: builder.internString(kPersUnit),
+            presentationFormatsStringIdx: builder.internString(kPresUnits),
+            relativeError: kRelError,
+        });
+        koqRowIdToIdx.set(kEcInstanceId, kIdx);
+    }
+    // ---- PropCatTable ----
+    expectTag(reader, Tag.PropCatTable);
+    const catTotalCount = reader.readU32();
+    reader.validateCount(catTotalCount, 8, "PropCatTable");
+    for (let i = 0; i < catTotalCount; i++) {
+        const schemaEcId = reader.readU32();
+        const schemaIdx = trackItem(schemaEcId, i, schemaCatStarts, schemaCatCounts);
+        const pcName = reader.readSRef();
+        const pcLabel = reader.readSRef();
+        const pcDesc = reader.readSRef();
+        const pcPriority = reader.readI32();
+        const pcEcInstanceId = reader.readU32();
+        const pcIdx = builder.addPropertyCategory({
+            ecInstanceId: pcEcInstanceId,
+            schemaIdx,
+            nameStringIdx: builder.internString(pcName),
+            labelStringIdx: builder.internString(pcLabel),
+            descriptionStringIdx: builder.internString(pcDesc),
+            priority: pcPriority,
+        });
+        catRowIdToIdx.set(pcEcInstanceId, pcIdx);
+    }
+    // ---- ClassTable ----
+    expectTag(reader, Tag.ClassTable);
+    const classTotalCount = reader.readU32();
+    reader.validateCount(classTotalCount, 8, "ClassTable");
+    for (let i = 0; i < classTotalCount; i++) {
+        const schemaEcId = reader.readU32();
+        const schemaIdx = trackItem(schemaEcId, i, schemaClassStarts, schemaClassCounts);
+        const schemaInfo = schemaInfos[schemaIdx];
+        const cName = reader.readSRef();
+        const cType = reader.readU8();
+        const cModifier = reader.readU8();
+        const cLabel = reader.readSRef();
+        const cDesc = reader.readSRef();
+        let relStrength = _ECObjects__WEBPACK_IMPORTED_MODULE_2__.StrengthType.Referencing;
+        let relStrengthDir = _ECObjects__WEBPACK_IMPORTED_MODULE_2__.StrengthDirection.Forward;
+        if (cType === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_3__.ClassType.Relationship) {
+            relStrength = reader.readU8();
+            relStrengthDir = reader.readU8();
+        }
+        const cEcInstanceId = reader.readU32();
+        // Tri-state hidden: 0=undefined (no CA, schema doesn't hide), 1=true (hidden), 2=false (explicitly shown)
+        const cHiddenByte = reader.readU8();
+        const cIsHidden = cHiddenByte === 1 ? true : cHiddenByte === 2 ? false : undefined;
+        // Base classes (count-prefixed)
+        const baseCount = reader.readU16();
+        const baseClasses = [];
+        for (let b = 0; b < baseCount; b++) {
+            baseClasses.push({
+                schemaName: reader.readSRef(),
+                className: reader.readSRef(),
+                ordinal: reader.readU8(),
+            });
+        }
+        // Property refs (count-prefixed)
+        const propRefCount = reader.readU16();
+        const propRefs = [];
+        for (let p = 0; p < propRefCount; p++) {
+            propRefs.push({
+                preDefIdx: reader.readU32(),
+                labelStringIdx: builder.internString(reader.readSRef()),
+                priority: reader.readI32(),
+                ecInstanceId: reader.readU32(),
+            });
+        }
+        // Constraints (count-prefixed, only for relationships)
+        const constraints = [];
+        if (cType === _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_3__.ClassType.Relationship) {
+            const constrCount = reader.readU8();
+            for (let c = 0; c < constrCount; c++) {
+                const rcEnd = reader.readU8();
+                const rcMultLower = reader.readU32();
+                const rcMultUpper = reader.readU32();
+                const rcIsPoly = reader.readU8() !== 0;
+                const rcRoleLabel = reader.readSRef();
+                const rcAbsSchema = reader.readSRef();
+                const rcAbsClass = reader.readSRef();
+                // Constraint classes (count-prefixed)
+                const ccCount = reader.readU8();
+                const constraintClasses = [];
+                for (let cc = 0; cc < ccCount; cc++) {
+                    constraintClasses.push({
+                        schemaName: reader.readSRef(),
+                        className: reader.readSRef(),
+                    });
+                }
+                constraints.push({
+                    relEnd: rcEnd,
+                    isPolymorphic: rcIsPoly,
+                    multiplicityLower: rcMultLower,
+                    multiplicityUpper: rcMultUpper,
+                    roleLabel: rcRoleLabel,
+                    abstractSchemaName: rcAbsSchema,
+                    abstractClassName: rcAbsClass,
+                    constraintClasses,
+                });
+            }
+        }
+        const nameStringIdx = builder.internString(cName);
+        const classIdx = builder.addClass({
+            ecInstanceId: cEcInstanceId,
+            schemaIdx,
+            nameStringIdx,
+            labelStringIdx: builder.internString(cLabel),
+            descriptionStringIdx: builder.internString(cDesc),
+            type: cType,
+            modifier: cModifier,
+            baseClassIdx: -1,
+            mixinStartIdx: -1,
+            mixinCount: 0,
+            ownPropStart: 0,
+            ownPropCount: 0,
+            strength: relStrength,
+            strengthDirection: relStrengthDir,
+            sourceConstraintIdx: -1,
+            targetConstraintIdx: -1,
+            isHidden: cIsHidden,
+        });
+        schemaInfo.classNameToIdx.set(cName.toLowerCase(), classIdx);
+        classRowIdToIdx.set(cEcInstanceId, classIdx);
+        pendingClasses.push({
+            schemaIdx,
+            classIdx,
+            ecInstanceId: cEcInstanceId,
+            nameStringIdx,
+            labelStringIdx: builder.internString(cLabel),
+            descriptionStringIdx: builder.internString(cDesc),
+            type: cType,
+            modifier: cModifier,
+            relStrength,
+            relStrengthDir,
+            baseClasses,
+            propRefs,
+            constraints,
+            schemaName: schemaInfo.name,
+            isHidden: cIsHidden,
+        });
+    }
+    // ---- Finalize per-schema item ranges ----
+    for (let i = 0; i < schemaCount; i++) {
+        builder.updateSchemaRanges(i, {
+            classRangeStart: schemaClassStarts[i] ?? 0,
+            classCount: schemaClassCounts[i] ?? 0,
+            enumRangeStart: schemaEnumStarts[i] ?? 0,
+            enumCount: schemaEnumCounts[i] ?? 0,
+            koqRangeStart: schemaKoqStarts[i] ?? 0,
+            koqCount: schemaKoqCounts[i] ?? 0,
+            catRangeStart: schemaCatStarts[i] ?? 0,
+            catCount: schemaCatCounts[i] ?? 0,
+        });
+    }
+    // Build a global name resolver: "SchemaName:ClassName" -> classIdx
+    const classResolver = new Map();
+    for (const s of schemaInfos) {
+        for (const [lowerName, idx] of s.classNameToIdx)
+            classResolver.set(`${s.name.toLowerCase()}:${lowerName}`, idx);
+    }
+    // Resolve pre-parsed defs to PropertyDef objects. Maps preParsedDef index -> builder defIdx.
+    const danglingRefs = [];
+    const resolvedDefMap = new Map();
+    const brokenDefs = new Set();
+    for (let i = 0; i < preParsedDefs.length; i++) {
+        const prDef = preParsedDefs[i];
+        let structClassIdx = -1;
+        if (prDef.structClassRowId !== 0) {
+            structClassIdx = classRowIdToIdx.get(prDef.structClassRowId) ?? -1;
+            if (structClassIdx === -1) {
+                brokenDefs.add(i);
+                danglingRefs.push(`Dropped properties with struct class rowId ${prDef.structClassRowId}`);
+                continue;
+            }
+        }
+        let navRelClassIdx = -1;
+        if (prDef.navRelClassRowId !== 0) {
+            navRelClassIdx = classRowIdToIdx.get(prDef.navRelClassRowId) ?? -1;
+            if (navRelClassIdx === -1) {
+                brokenDefs.add(i);
+                danglingRefs.push(`Dropped properties with nav relationship rowId ${prDef.navRelClassRowId}`);
+                continue;
+            }
+        }
+        let enumIdx = -1;
+        if (prDef.enumRowId !== 0) {
+            enumIdx = enumRowIdToIdx.get(prDef.enumRowId) ?? -1;
+            if (enumIdx === -1)
+                danglingRefs.push(`Unresolved enum rowId ${prDef.enumRowId}`);
+        }
+        let koqIdx = -1;
+        if (prDef.koqRowId !== 0)
+            koqIdx = koqRowIdToIdx.get(prDef.koqRowId) ?? -1;
+        let categoryIdx = -1;
+        if (prDef.catRowId !== 0)
+            categoryIdx = catRowIdToIdx.get(prDef.catRowId) ?? -1;
+        const def = {
+            nameStringIdx: builder.internString(prDef.name),
+            descriptionStringIdx: builder.internString(prDef.description),
+            kind: prDef.kind,
+            primitiveType: prDef.primitiveType,
+            extTypeStringIdx: builder.internString(prDef.extType),
+            enumIdx,
+            koqIdx,
+            structClassIdx,
+            navRelClassIdx,
+            navDirection: prDef.navDirection,
+            categoryIdx,
+            isReadOnly: prDef.isReadonly,
+            isHidden: prDef.isHidden,
+            arrayMinOccurs: prDef.arrayMinOccurs,
+            arrayMaxOccurs: prDef.arrayMaxOccurs,
+        };
+        resolvedDefMap.set(i, builder.addPropertyDef(def));
+    }
+    // Resolve cross-references and finalize classes
+    for (const pc of pendingClasses) {
+        pc.baseClasses.sort((a, b) => a.ordinal - b.ordinal);
+        const classFullName = `${pc.schemaName}:${builder.getString(pc.nameStringIdx)}`;
+        let baseClassIdx = -1;
+        const mixinStartIdx = pc.baseClasses.length > 1 ? builder.classMixinCount : -1;
+        let mixinCount = 0;
+        for (const bc of pc.baseClasses) {
+            const bcKey = `${bc.schemaName.toLowerCase()}:${bc.className.toLowerCase()}`;
+            const bcIdx = classResolver.get(bcKey) ?? -1;
+            if (bc.ordinal === 0) {
+                if (bcIdx === -1 && bc.schemaName)
+                    danglingRefs.push(`${classFullName} -> base class ${bc.schemaName}:${bc.className}`);
+                baseClassIdx = bcIdx;
+            }
+            else {
+                if (bcIdx === -1) {
+                    danglingRefs.push(`${classFullName} -> mixin ${bc.schemaName}:${bc.className}`);
+                    continue;
+                }
+                builder.addClassMixin(bcIdx);
+                mixinCount++;
+            }
+        }
+        const ownPropStart = builder.propertyRefCount;
+        for (const pr of pc.propRefs) {
+            if (brokenDefs.has(pr.preDefIdx))
+                continue;
+            const defIdx = resolvedDefMap.get(pr.preDefIdx);
+            if (defIdx === undefined)
+                continue;
+            builder.addPropertyRef({
+                ecInstanceId: pr.ecInstanceId,
+                defIdx,
+                labelStringIdx: pr.labelStringIdx,
+                priority: pr.priority,
+            });
+        }
+        let sourceConstraintIdx = -1;
+        let targetConstraintIdx = -1;
+        for (const con of pc.constraints) {
+            const absKey = con.abstractSchemaName && con.abstractClassName
+                ? `${con.abstractSchemaName.toLowerCase()}:${con.abstractClassName.toLowerCase()}`
+                : "";
+            const absClassIdx = absKey ? (classResolver.get(absKey) ?? -1) : -1;
+            if (absClassIdx === -1 && absKey)
+                danglingRefs.push(`${classFullName} constraint -> abstract ${con.abstractSchemaName}:${con.abstractClassName}`);
+            const classRefStart = builder.constraintClassRefCount;
+            let classRefCount = 0;
+            for (const cc of con.constraintClasses) {
+                const ccKey = `${cc.schemaName.toLowerCase()}:${cc.className.toLowerCase()}`;
+                const ccIdx = classResolver.get(ccKey) ?? -1;
+                if (ccIdx === -1) {
+                    danglingRefs.push(`${classFullName} constraint -> class ${cc.schemaName}:${cc.className}`);
+                    continue;
+                }
+                builder.addConstraintClassRef(ccIdx);
+                classRefCount++;
+            }
+            const constraintIdx = builder.addRelConstraint({
+                abstractConstraintIdx: absClassIdx,
+                polymorphic: con.isPolymorphic,
+                multiplicityLower: con.multiplicityLower,
+                multiplicityUpper: con.multiplicityUpper,
+                roleLabelStringIdx: builder.internString(con.roleLabel),
+                classRefStart,
+                classRefCount,
+            });
+            if (con.relEnd === 0)
+                sourceConstraintIdx = constraintIdx;
+            else
+                targetConstraintIdx = constraintIdx;
+        }
+        const updatedClass = {
+            ecInstanceId: pc.ecInstanceId,
+            schemaIdx: pc.schemaIdx,
+            nameStringIdx: pc.nameStringIdx,
+            labelStringIdx: pc.labelStringIdx,
+            descriptionStringIdx: pc.descriptionStringIdx,
+            type: pc.type,
+            modifier: pc.modifier,
+            baseClassIdx,
+            mixinStartIdx,
+            mixinCount,
+            ownPropStart,
+            ownPropCount: builder.propertyRefCount - ownPropStart,
+            strength: pc.relStrength,
+            strengthDirection: pc.relStrengthDir,
+            sourceConstraintIdx,
+            targetConstraintIdx,
+            isHidden: pc.isHidden,
+        };
+        builder.updateClass(pc.classIdx, updatedClass);
+    }
+    if (danglingRefs.length > 0) {
+        const cap = 20;
+        const lines = danglingRefs.length <= cap ? danglingRefs : [...danglingRefs.slice(0, cap), `... and ${danglingRefs.length - cap} more`];
+        _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.Logger.logWarning("ecschema-metadata.SchemaView", `${danglingRefs.length} unresolved cross-reference(s) in schema view blob (likely from excluded schemas):\n  ${lines.join("\n  ")}`);
+    }
+    return builder.build(schemaToken);
+}
+
+
+/***/ }),
+
+/***/ "../../core/ecschema-metadata/lib/esm/SchemaViewInterfaces.js":
+/*!********************************************************************!*\
+  !*** ../../core/ecschema-metadata/lib/esm/SchemaViewInterfaces.js ***!
+  \********************************************************************/
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ClassModifier: () => (/* binding */ ClassModifier),
+/* harmony export */   ClassType: () => (/* binding */ ClassType),
+/* harmony export */   PropertyKind: () => (/* binding */ PropertyKind),
+/* harmony export */   SchemaViewPrimitiveType: () => (/* binding */ SchemaViewPrimitiveType),
+/* harmony export */   schemaViewFormatVersion: () => (/* binding */ schemaViewFormatVersion)
+/* harmony export */ });
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+/** @packageDocumentation
+ * @module Schema
+ */
+/** The binary format version that this TS reader supports.
+ * The C++ writer in imodel-native must produce this version (or negotiate down to it).
+ * Frontend callers should always request this version explicitly via `PRAGMA schema_view(N)`.
+ * Backend callers may omit it since native and backend are bundled together.
+ * @beta
+ */
+const schemaViewFormatVersion = 1;
+/** Matches ec_Class.Type values in ECDb.
+ * @beta
+ */
+var ClassType;
+(function (ClassType) {
+    ClassType[ClassType["Entity"] = 0] = "Entity";
+    ClassType[ClassType["Relationship"] = 1] = "Relationship";
+    ClassType[ClassType["Struct"] = 2] = "Struct";
+    ClassType[ClassType["CustomAttribute"] = 3] = "CustomAttribute";
+    /** Not stored in ec_Class.Type - synthesized from IsMixin CA during cache population. */
+    ClassType[ClassType["Mixin"] = 4] = "Mixin";
+    /** Synthesized from the QueryView custom attribute. */
+    ClassType[ClassType["View"] = 5] = "View";
+})(ClassType || (ClassType = {}));
+/** Matches ec_Class.Modifier values.
+ * @beta
+ */
+var ClassModifier;
+(function (ClassModifier) {
+    ClassModifier[ClassModifier["None"] = 0] = "None";
+    ClassModifier[ClassModifier["Abstract"] = 1] = "Abstract";
+    ClassModifier[ClassModifier["Sealed"] = 2] = "Sealed";
+})(ClassModifier || (ClassModifier = {}));
+/** Matches ec_Property.Kind values.
+ * @beta
+ */
+var PropertyKind;
+(function (PropertyKind) {
+    PropertyKind[PropertyKind["Primitive"] = 0] = "Primitive";
+    PropertyKind[PropertyKind["Struct"] = 1] = "Struct";
+    PropertyKind[PropertyKind["PrimitiveArray"] = 2] = "PrimitiveArray";
+    PropertyKind[PropertyKind["StructArray"] = 3] = "StructArray";
+    PropertyKind[PropertyKind["Navigation"] = 4] = "Navigation";
+})(PropertyKind || (PropertyKind = {}));
+/** Matches ec_ PrimitiveType values.
+ * @beta
+ */
+var SchemaViewPrimitiveType;
+(function (SchemaViewPrimitiveType) {
+    SchemaViewPrimitiveType[SchemaViewPrimitiveType["Uninitialized"] = 0] = "Uninitialized";
+    SchemaViewPrimitiveType[SchemaViewPrimitiveType["Binary"] = 257] = "Binary";
+    SchemaViewPrimitiveType[SchemaViewPrimitiveType["Boolean"] = 513] = "Boolean";
+    SchemaViewPrimitiveType[SchemaViewPrimitiveType["DateTime"] = 769] = "DateTime";
+    SchemaViewPrimitiveType[SchemaViewPrimitiveType["Double"] = 1025] = "Double";
+    SchemaViewPrimitiveType[SchemaViewPrimitiveType["Integer"] = 1281] = "Integer";
+    SchemaViewPrimitiveType[SchemaViewPrimitiveType["Long"] = 1537] = "Long";
+    SchemaViewPrimitiveType[SchemaViewPrimitiveType["Point2d"] = 1793] = "Point2d";
+    SchemaViewPrimitiveType[SchemaViewPrimitiveType["Point3d"] = 2049] = "Point3d";
+    SchemaViewPrimitiveType[SchemaViewPrimitiveType["String"] = 2305] = "String";
+    SchemaViewPrimitiveType[SchemaViewPrimitiveType["IGeometry"] = 2561] = "IGeometry";
+})(SchemaViewPrimitiveType || (SchemaViewPrimitiveType = {}));
+
+
 /***/ }),
 
 /***/ "../../core/ecschema-metadata/lib/esm/UnitConversion/UnitConverter.js":
@@ -76133,6 +78058,8 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   AbstractSchemaItemType: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.AbstractSchemaItemType),
 /* harmony export */   ArrayProperty: () => (/* reexport safe */ _Metadata_Property__WEBPACK_IMPORTED_MODULE_22__.ArrayProperty),
+/* harmony export */   ClassModifier: () => (/* reexport safe */ _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_44__.ClassModifier),
+/* harmony export */   ClassType: () => (/* reexport safe */ _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_44__.ClassType),
 /* harmony export */   Constant: () => (/* reexport safe */ _Metadata_Constant__WEBPACK_IMPORTED_MODULE_12__.Constant),
 /* harmony export */   CustomAttributeClass: () => (/* reexport safe */ _Metadata_CustomAttributeClass__WEBPACK_IMPORTED_MODULE_13__.CustomAttributeClass),
 /* harmony export */   CustomAttributeContainerType: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.CustomAttributeContainerType),
@@ -76166,6 +78093,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   PrimitiveType: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.PrimitiveType),
 /* harmony export */   Property: () => (/* reexport safe */ _Metadata_Property__WEBPACK_IMPORTED_MODULE_22__.Property),
 /* harmony export */   PropertyCategory: () => (/* reexport safe */ _Metadata_PropertyCategory__WEBPACK_IMPORTED_MODULE_23__.PropertyCategory),
+/* harmony export */   PropertyKind: () => (/* reexport safe */ _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_44__.PropertyKind),
 /* harmony export */   PropertyType: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.PropertyType),
 /* harmony export */   PropertyTypeUtils: () => (/* reexport safe */ _PropertyTypes__WEBPACK_IMPORTED_MODULE_29__.PropertyTypeUtils),
 /* harmony export */   RelationshipClass: () => (/* reexport safe */ _Metadata_RelationshipClass__WEBPACK_IMPORTED_MODULE_24__.RelationshipClass),
@@ -76188,6 +78116,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   SchemaPartVisitorDelegate: () => (/* reexport safe */ _SchemaPartVisitorDelegate__WEBPACK_IMPORTED_MODULE_36__.SchemaPartVisitorDelegate),
 /* harmony export */   SchemaReadHelper: () => (/* reexport safe */ _Deserialization_Helper__WEBPACK_IMPORTED_MODULE_5__.SchemaReadHelper),
 /* harmony export */   SchemaUnitProvider: () => (/* reexport safe */ _UnitProvider_SchemaUnitProvider__WEBPACK_IMPORTED_MODULE_34__.SchemaUnitProvider),
+/* harmony export */   SchemaView: () => (/* reexport safe */ _SchemaView__WEBPACK_IMPORTED_MODULE_43__.SchemaView),
+/* harmony export */   SchemaViewBuilder: () => (/* reexport safe */ _SchemaView__WEBPACK_IMPORTED_MODULE_43__.SchemaViewBuilder),
+/* harmony export */   SchemaViewPrimitiveType: () => (/* reexport safe */ _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_44__.SchemaViewPrimitiveType),
 /* harmony export */   SchemaWalker: () => (/* reexport safe */ _Validation_SchemaWalker__WEBPACK_IMPORTED_MODULE_35__.SchemaWalker),
 /* harmony export */   StrengthDirection: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.StrengthDirection),
 /* harmony export */   StrengthType: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.StrengthType),
@@ -76207,6 +78138,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   parsePrimitiveType: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.parsePrimitiveType),
 /* harmony export */   parseRelationshipEnd: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.parseRelationshipEnd),
 /* harmony export */   parseSchemaItemType: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.parseSchemaItemType),
+/* harmony export */   parseSchemaViewBlob: () => (/* reexport safe */ _SchemaViewBinaryReader__WEBPACK_IMPORTED_MODULE_42__.parseSchemaViewBlob),
 /* harmony export */   parseStrength: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.parseStrength),
 /* harmony export */   parseStrengthDirection: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.parseStrengthDirection),
 /* harmony export */   primitiveTypeToString: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.primitiveTypeToString),
@@ -76214,6 +78146,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   relationshipEndToString: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.relationshipEndToString),
 /* harmony export */   schemaItemTypeToString: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.schemaItemTypeToString),
 /* harmony export */   schemaItemTypeToXmlString: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.schemaItemTypeToXmlString),
+/* harmony export */   schemaViewFormatVersion: () => (/* reexport safe */ _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_44__.schemaViewFormatVersion),
 /* harmony export */   strengthDirectionToString: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.strengthDirectionToString),
 /* harmony export */   strengthToString: () => (/* reexport safe */ _ECObjects__WEBPACK_IMPORTED_MODULE_8__.strengthToString)
 /* harmony export */ });
@@ -76259,6 +78192,9 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _IncrementalLoading_ECSqlSchemaLocater__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__(/*! ./IncrementalLoading/ECSqlSchemaLocater */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/ECSqlSchemaLocater.js");
 /* harmony import */ var _IncrementalLoading_IncrementalSchemaLocater__WEBPACK_IMPORTED_MODULE_40__ = __webpack_require__(/*! ./IncrementalLoading/IncrementalSchemaLocater */ "../../core/ecschema-metadata/lib/esm/IncrementalLoading/IncrementalSchemaLocater.js");
 /* harmony import */ var _utils_SchemaGraph__WEBPACK_IMPORTED_MODULE_41__ = __webpack_require__(/*! ./utils/SchemaGraph */ "../../core/ecschema-metadata/lib/esm/utils/SchemaGraph.js");
+/* harmony import */ var _SchemaViewBinaryReader__WEBPACK_IMPORTED_MODULE_42__ = __webpack_require__(/*! ./SchemaViewBinaryReader */ "../../core/ecschema-metadata/lib/esm/SchemaViewBinaryReader.js");
+/* harmony import */ var _SchemaView__WEBPACK_IMPORTED_MODULE_43__ = __webpack_require__(/*! ./SchemaView */ "../../core/ecschema-metadata/lib/esm/SchemaView.js");
+/* harmony import */ var _SchemaViewInterfaces__WEBPACK_IMPORTED_MODULE_44__ = __webpack_require__(/*! ./SchemaViewInterfaces */ "../../core/ecschema-metadata/lib/esm/SchemaViewInterfaces.js");
 /*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
@@ -76301,6 +78237,9 @@ __webpack_require__.r(__webpack_exports__);
 
 
 
+
+
+
 
 
 
@@ -82739,6 +84678,7 @@ class BriefcaseConnection extends _IModelConnection__WEBPACK_IMPORTED_MODULE_5__
         finally {
             removeListeners.forEach((remove) => remove());
         }
+        await this.invalidateSchemaViewIfChanged();
     }
     /** Create a changeset from local Txns and push to iModelHub. On success, clear Txn table.
      * @param description The description for the changeset
@@ -89399,6 +91339,7 @@ class IModelConnection extends _itwin_core_common__WEBPACK_IMPORTED_MODULE_1__.I
      */
     fontMap; // eslint-disable-line @typescript-eslint/no-deprecated
     _schemaContext;
+    _schemasPromise;
     /** Load the FontMap for this IModelConnection.
      * @returns Returns a Promise<FontMap> that is fulfilled when the FontMap member of this IModelConnection is valid.
      * @deprecated in 5.0.0 - will not be removed until after 2026-06-13. If you need font Ids on the front-end for some reason, write an Ipc method that queries [IModelDb.fonts]($backend).
@@ -89792,6 +91733,10 @@ class IModelConnection extends _itwin_core_common__WEBPACK_IMPORTED_MODULE_1__.I
      * This means to correctly access schema context, client-side applications must register `ECSchemaRpcInterface` following instructions for [RPC configuration]($docs/learning/rpcinterface/#client-side-configuration).
      * Server-side applications would also [configure RPC]($docs/learning/rpcinterface/#server-side-configuration) as needed.
      *
+     * For runtime read-only access - class/property iteration, IS-A checks, navigating relationships, KOQ lookups -
+     * prefer [[getSchemaView]]. `schemaContext` remains the right choice when you need custom-attribute deserialization
+     * or the full ecschema-metadata object graph.
+     *
      * @note While a `BlankConnection` returns a valid `schemaContext`, it has an invalid locater registered by default, and will throw an error when trying to call it's methods.
      * @beta
      */
@@ -89808,6 +91753,111 @@ class IModelConnection extends _itwin_core_common__WEBPACK_IMPORTED_MODULE_1__.I
         }
         return this._schemaContext;
     }
+    /** Get the schema view for this iModel. The view is built lazily on
+     * first call by fetching compact binary schema data via `PRAGMA schema_view` through
+     * the existing queryRows RPC (ConcurrentQuery). Subsequent calls return the cached view.
+     * Multiple concurrent callers share a single in-flight fetch.
+     *
+     * The returned `SchemaView` is a lightweight, read-only, synchronous API for
+     * navigating schema metadata - classes, properties, relationships, enumerations, etc.
+     * It is the recommended default for runtime read-only metadata access and is significantly
+     * faster and lower-memory than [[schemaContext]]. Use [[schemaContext]] for custom-attribute
+     * deserialization or anywhere you need the full ecschema-metadata object graph.
+     * @beta
+     */
+    async getSchemaView() {
+        if (this._schemasPromise) {
+            const ctx = await this._schemasPromise;
+            if (!ctx.isOutdated)
+                return ctx;
+        }
+        // Capture the in-flight promise locally so the rejection handler only clears
+        // `_schemasPromise` if it still points at this build. A concurrent invalidation +
+        // re-fetch could otherwise replace the field before our fetch fails, and a naive
+        // `_schemasPromise = undefined` would clobber that newer reference.
+        const inflight = this._fetchSchemas();
+        this._schemasPromise = inflight;
+        inflight.catch(() => {
+            if (this._schemasPromise === inflight)
+                this._schemasPromise = undefined;
+        });
+        return inflight;
+    }
+    /**
+     * Checks whether the iModel's schemas have changed since the current cached [[SchemaView]] was
+     * built, and discards the cache only if they have.
+     *
+     * Frontend code paths that may affect schemas - such as [[BriefcaseConnection.pullChanges]], or
+     * application-specific IPC calls that import or upgrade schemas - cannot reliably determine
+     * whether the operation actually modified any schemas. The IPC response for a pull, for example,
+     * returns only the new changeset id, not the list of applied changesets with their types.
+     * Unconditionally discarding the cached [[SchemaView]] after every such operation would cause
+     * unnecessary reloads in the common case where schemas are unchanged. This method avoids that
+     * cost by fetching a lightweight schema checksum via `PRAGMA checksum(ecdb_schema)` and
+     * comparing it against the token stored in the cached view. Only when the token differs is the
+     * cache discarded.
+     *
+     * Subclasses that expose operations which may modify schemas should await this method after the
+     * operation completes to ensure [[getSchemaView]] returns a fresh view if needed.
+     * @internal
+     */
+    async invalidateSchemaViewIfChanged() {
+        if (!this._schemasPromise)
+            return;
+        const existingPromise = this._schemasPromise;
+        let existing;
+        try {
+            existing = await existingPromise;
+        }
+        catch {
+            // The cached promise itself failed; drop it so the next getSchemaView() retries.
+            if (this._schemasPromise === existingPromise)
+                this._schemasPromise = undefined;
+            return;
+        }
+        if (!existing.schemaToken)
+            return;
+        try {
+            const reader = this.createQueryReader("PRAGMA checksum(ecdb_schema)");
+            const result = await reader.next();
+            if (result.done)
+                throw new Error("PRAGMA checksum(ecdb_schema) returned no rows");
+            const liveToken = result.value.sha3_256;
+            if (liveToken !== existing.schemaToken) {
+                if (this._schemasPromise === existingPromise)
+                    this._schemasPromise = undefined;
+                existing.markOutdated();
+            }
+        }
+        catch {
+            // The checksum check is called right after operations that may have changed schemas
+            // (e.g., pullChanges). If we cannot verify the cached view is still current, drop it
+            // rather than risk returning stale metadata indefinitely. The next getSchemaView() call
+            // will reload. We also mark the existing view outdated so any retained references can
+            // observe the invalidation.
+            if (this._schemasPromise === existingPromise) {
+                this._schemasPromise = undefined;
+                existing.markOutdated();
+            }
+        }
+    }
+    async _fetchSchemas() {
+        // PRAGMA returns exactly one row with format, formatVersion, data (binary), schemaToken.
+        // Important: only call reader.next() once - do NOT use `for await` on PRAGMA results.
+        // ConcurrentQuery wraps regular ECSQL in LIMIT/OFFSET for pagination but skips this for
+        // PRAGMAs. If the serialized result exceeds the memory threshold, the response is marked
+        // "Partial", and a `for await` loop would re-issue the same PRAGMA forever since PRAGMAs
+        // don't support OFFSET-based pagination.
+        const reader = this.createQueryReader(`PRAGMA schema_view(${_itwin_ecschema_metadata__WEBPACK_IMPORTED_MODULE_15__.schemaViewFormatVersion})`);
+        const result = await reader.next();
+        if (result.done)
+            throw new _itwin_core_common__WEBPACK_IMPORTED_MODULE_1__.IModelError(_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.IModelStatus.BadRequest, "PRAGMA schema_view returned no rows");
+        const data = result.value.data;
+        const token = result.value.schemaToken;
+        if (data === undefined || data === null)
+            throw new _itwin_core_common__WEBPACK_IMPORTED_MODULE_1__.IModelError(_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.IModelStatus.BadRequest, "PRAGMA schema_view returned null data column");
+        return _itwin_ecschema_metadata__WEBPACK_IMPORTED_MODULE_15__.SchemaView.fromBinary(data, token ?? "");
+    }
 }
 /** A connection that exists without an iModel. Useful for connecting to Reality Data services.
  * @note This class exists because our display system requires an IModelConnection type even if only reality data is drawn.
@@ -190311,6 +192361,13 @@ class Geometry {
         // Line equation is fTarget-f0 = (f1-f0)*x so x = (fTarget-f0)/(f1-f0)
         return Geometry.conditionalDivideFraction(fTarget - f0, f1 - f0);
     }
+    /**
+     * Return `true` if `a` is a finite number.
+     * @param a value to test
+     */
+    static isNumber(a) {
+        return Number.isFinite(a);
+    }
     /**
      * Return `true` if `json` is an array with at least `minEntries` entries and all entries are numbers (including
      * those beyond minEntries).
@@ -206200,11 +208257,18 @@ class CurveCurve {
      * an `AnyRegion`, then close approaches are computed only to the defining curves, not to the area they enclose.
      * @param curveA first curve
      * @param curveB second curve
-     * @param maxDistance maximum xy-distance to consider between the curves.
+     * @param maxDistanceOrOptions maximum xy-distance to consider between the curves, or a list of extended options.
      * Close approaches further than this xy-distance are not returned.
-     */
-    static closeApproachProjectedXYPairs(curveA, curveB, maxDistance) {
-        const handler = new _internalContexts_CurveCurveCloseApproachXY__WEBPACK_IMPORTED_MODULE_3__.CurveCurveCloseApproachXY(curveB);
+     * @return array of detail pairs of close xy-approaches. XY-length of the returned close approach is set in `detailA.a`
+     * and `detailB.a`.
+     */
+    static closeApproachProjectedXYPairs(curveA, curveB, maxDistanceOrOptions = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.largeCoordinateResult) {
+        const optionIsNumber = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.isNumber(maxDistanceOrOptions);
+        const maxDistance = optionIsNumber ? maxDistanceOrOptions : maxDistanceOrOptions.maxDistance ?? _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.largeCoordinateResult;
+        const xyTolerance = optionIsNumber ? undefined : maxDistanceOrOptions.xyTolerance;
+        const newtonTolerance = optionIsNumber ? undefined : maxDistanceOrOptions.newtonTolerance;
+        const maxIterations = optionIsNumber ? undefined : maxDistanceOrOptions.maxIterations;
+        const handler = new _internalContexts_CurveCurveCloseApproachXY__WEBPACK_IMPORTED_MODULE_3__.CurveCurveCloseApproachXY(curveB, xyTolerance, newtonTolerance, maxIterations);
         handler.maxDistanceToAccept = maxDistance;
         curveA.dispatchToGeometryHandler(handler);
         return handler.grabPairedResults();
@@ -206218,20 +208282,20 @@ class CurveCurve {
      * found among the pairs.
      * @param curveA first curve
      * @param curveB second curve
-     * @return detail pair of closest xy-approach, undefined if not found
+     * @param options optional parameters for close approach calculation
+     * @return detail pair of closest xy-approach, undefined if not found. XY-length of the returned close approach is
+     * set in `detailA.a` and `detailB.a`.
      */
-    static closestApproachProjectedXYPair(curveA, curveB) {
-        const range = curveA.range();
-        range.extendRange(curveB.range());
-        const maxDistance = range.low.distanceXY(range.high);
-        const closeApproaches = this.closeApproachProjectedXYPairs(curveA, curveB, maxDistance);
+    static closestApproachProjectedXYPair(curveA, curveB, options) {
+        if (options === undefined)
+            options = { maxDistance: _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.largeCoordinateResult };
+        const closeApproaches = this.closeApproachProjectedXYPairs(curveA, curveB, options);
         if (!closeApproaches.length)
             return undefined;
         let iMin = 0;
-        let minDistXY = 2 * maxDistance;
+        let minDistXY = _Geometry__WEBPACK_IMPORTED_MODULE_0__.Geometry.largeCoordinateResult;
         for (let i = 0; i < closeApproaches.length; ++i) {
-            // TODO: this distance should already be in detail.a. Verify this, then just use it instead of recomputing below.
-            const distXY = closeApproaches[i].detailA.point.distanceXY(closeApproaches[i].detailB.point);
+            const distXY = closeApproaches[i].detailA.a;
             if (distXY < minDistXY) {
                 iMin = i;
                 minDistXY = distXY;
@@ -217377,6 +219441,7 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
     _maxDistanceSquared;
     _xyTolerance;
     _newtonTolerance;
+    _maxIterations;
     /**
      * Start and end points of line segments that meet closest approach criteria, i.e., they are perpendicular to
      * both curves and their length is smaller than _maxDistanceToAccept.
@@ -217392,13 +219457,16 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
      * @param geometryB second curve for intersection. Saved for reference by specific handler methods.
      * @param xyTolerance optional tolerance for comparing xy points (default [[Geometry.smallMetricDistance]]).
      * @param newtonTolerance optional relative fraction tolerance for Newton iteration (default [[Geometry.smallNewtonStep]]).
+     * @param maxIterations optional max iterations for Newton iteration (default 50).
      */
-    constructor(geometryB, xyTolerance = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.smallMetricDistance, newtonTolerance = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.smallNewtonStep) {
+    constructor(geometryB, xyTolerance = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.smallMetricDistance, newtonTolerance = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.smallNewtonStep, maxIterations = 50 // seen: 47
+    ) {
         super();
         this._geometryB = geometryB instanceof _ProxyCurve__WEBPACK_IMPORTED_MODULE_4__.ProxyCurve ? geometryB.proxyCurve : geometryB;
         this._maxDistanceSquared = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.smallMetricDistanceSquared;
         this._xyTolerance = xyTolerance;
         this._newtonTolerance = newtonTolerance;
+        this._maxIterations = maxIterations;
         const compare = _CurveLocationDetail__WEBPACK_IMPORTED_MODULE_5__.CurveLocationDetailPair.comparePairsByPoints(xyTolerance, true);
         this._results = new _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.SortedArray(compare, _itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.DuplicatePolicy.Retain);
     }
@@ -217917,21 +219985,27 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
         return curve instanceof _bspline_BSplineCurve__WEBPACK_IMPORTED_MODULE_15__.BSplineCurve3dBase || curve instanceof _spiral_TransitionSpiral3d__WEBPACK_IMPORTED_MODULE_16__.TransitionSpiral3d;
     }
     /**
-     * Process seeds for xy close approach between one curve and another curve to be stroked.
+     * Process seeds for xy close approach between one curve and another curve.
+     * * Seeds typically result from solving a discrete close approach problem, where one or both curves have been stroked.
      * * Refine each result via Newton iteration. If it doesn't converge, remove it.
      * @param seeds the initial seed results to refine.
      * @param curveA curve to find its XY close approach with curveB.
-     * @param curveB the other curve to be stroked.
+     * @param curveAIsStroked whether `seeds` contains results from a linestring approximation to `curveA`
+     * @param curveB the other curve.
+     * @param curveBIsStroked whether `seeds` contains results from a linestring approximation to `curveB`
      * @param reversed whether `curveB` data is in `detailA` of each recorded pair, and `curveA` data in `detailB`.
      */
-    refineStrokedResultsByNewton(seeds, curveA, curveB, reversed = false) {
+    refineStrokedResultsByNewton(seeds, curveA, curveAIsStroked, curveB, curveBIsStroked, reversed = false) {
         const xyMatchingFunction = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_10__.CurveCurveCloseApproachXYRRtoRRD(curveA, curveB);
-        const newtonSearcher = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_10__.Newton2dUnboundedWithDerivative(xyMatchingFunction, 50, this._newtonTolerance); // seen: 47
+        const newtonSearcher = new _numerics_Newton__WEBPACK_IMPORTED_MODULE_10__.Newton2dUnboundedWithDerivative(xyMatchingFunction, this._maxIterations, this._newtonTolerance);
         for (const seed of seeds) {
             const detailA = reversed ? seed.detailB : seed.detailA;
             const detailB = reversed ? seed.detailA : seed.detailB;
             (0,_itwin_core_bentley__WEBPACK_IMPORTED_MODULE_0__.assert)(detailB.curve instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_17__.LineString3d, "Caller has discretized the curve");
-            newtonSearcher.setUV(detailA.fraction, detailB.fraction); // use the linestring fraction as initial curveB fraction (ASSUME it's close enough)
+            // when the curve is stroked, project the discrete seed to compute a fraction in the original curve's parameter space
+            const u = curveAIsStroked ? curveA.closestPointXY(detailA.point)?.fraction ?? detailA.fraction : detailA.fraction;
+            const v = curveBIsStroked ? curveB.closestPointXY(detailB.point)?.fraction ?? detailB.fraction : detailB.fraction;
+            newtonSearcher.setUV(u, v);
             if (newtonSearcher.runIterations()) {
                 const fractionA = newtonSearcher.getU();
                 const fractionB = newtonSearcher.getV();
@@ -217974,7 +220048,7 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
     /**
      * Compute the XY close approach of a curve and another curve to be stroked.
      * @param curveA curve to find its XY close approach with curveB.
-     * @param curveB the other curve to be stroked.
+     * @param curveB the other curve, to be stroked.
      * @param reversed whether `curveB` data will be recorded in `detailA` of each result, and `curveA` data in `detailB`.
      */
     dispatchCurveStrokedCurve(curveA, curveB, reversed) {
@@ -217983,12 +220057,11 @@ class CurveCurveCloseApproachXY extends _geometry3d_GeometryHandler__WEBPACK_IMP
         for (const intersection of intersections)
             this.testAndRecordPair(intersection, reversed);
         // append seeds computed by solving the discretized spiral close approach problem, then refine the seeds via Newton
-        let cpA = curveA;
-        if (this.needsStroking(curveA))
-            cpA = this.strokeCurve(curveA);
+        const curveAIsStroked = this.needsStroking(curveA);
+        const cpA = curveAIsStroked ? this.strokeCurve(curveA) : curveA;
         const cpB = this.strokeCurve(curveB);
         const seeds = this.computeDiscreteCloseApproachResults(cpA, cpB, reversed);
-        this.refineStrokedResultsByNewton(seeds, curveA, curveB, reversed);
+        this.refineStrokedResultsByNewton(seeds, curveA, curveAIsStroked, curveB, true, reversed);
         if (curveA instanceof _LineString3d__WEBPACK_IMPORTED_MODULE_17__.LineString3d) { // explicitly test corners (where Newton converges too slowly)
             const fStep = _Geometry__WEBPACK_IMPORTED_MODULE_3__.Geometry.safeDivideFraction(1.0, curveA.numEdges(), 0);
             const v0 = CurveCurveCloseApproachXY._workPointBB0;
@@ -253351,7 +255424,8 @@ class UnivariateBezier extends BezierCoffs {
         const order = this.order;
         const coffs = this.coffs;
         const orderD = order - 1;
-        for (let iterations = 0; iterations++ < 20;) {
+        const maxIterations = 20;
+        for (let iterations = 0; iterations < maxIterations; iterations++) {
             UnivariateBezier._basisBuffer = _PascalCoefficients__WEBPACK_IMPORTED_MODULE_1__.PascalCoefficients.getBezierBasisValues(order, u, UnivariateBezier._basisBuffer);
             f = 0;
             for (let i = 0; i < order; i++)
@@ -329265,7 +331339,7 @@ var loadLanguages = instance.loadLanguages;
 /***/ ((module) => {
 
 "use strict";
-module.exports = /*#__PURE__*/JSON.parse('{"name":"@itwin/core-frontend","version":"5.10.0-dev.18","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 && npm run -s extract","extract":"betools extract --fileExt=ts --extractFrom=./src/test/example-code --recursive --out=../../generated-docs/extract","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":{"@bentley/aec-units-schema":"^1.0.3","@bentley/formats-schema":"^1.0.0","@bentley/units-schema":"^1.0.10","@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","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"}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"@itwin/core-frontend","version":"5.10.0-dev.20","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 && npm run -s extract","extract":"betools extract --fileExt=ts --extractFrom=./src/test/example-code --recursive --out=../../generated-docs/extract","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":{"@bentley/aec-units-schema":"^1.0.3","@bentley/formats-schema":"^1.0.0","@bentley/units-schema":"^1.0.10","@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","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"}}');
 
 /***/ })