@itwin/core-backend 5.12.0-dev.6 → 5.12.0-dev.8

package/lib/esm/test/standalone/ChangesetReader.test.js

@@ -3279,6 +3279,61 @@ describe("ChangesetReader — openFile + openGroup", () => {
             }
         }
     });
+    it("openGroup: insert in one changeset then delete in another yields no instances for the element (net no-op)", async () => {
+        const adminToken = "super manager token";
+        const targetDir = path.join(KnownTestLocations.outputDir, rwIModelId, "changesets");
+        // Record how many changesets already exist so we can identify the new ones by index
+        let changesets = await HubMock.downloadChangesets({ iModelId: rwIModelId, targetDir });
+        const baseCount = changesets.length;
+        // Wait so that LastMod on bis_Model gets a distinct timestamp before the insert txn
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        // --- Push baseCount+1: insert a brand-new element ---
+        await rwIModel.locks.acquireLocks({ shared: drawingModelId });
+        const noOpElementId = txn.insertElement({
+            classFullName: "TestDomain:SimpleElement",
+            model: drawingModelId,
+            category: drawingCategoryId,
+            code: Code.createEmpty(),
+            BinProp: new Uint8Array([0xde, 0xad, 0xbe, 0xef]),
+        });
+        txn.saveChanges("insert no-op element");
+        await rwIModel.pushChanges({ description: "insert no-op element", accessToken: adminToken });
+        changesets = await HubMock.downloadChangesets({ iModelId: rwIModelId, targetDir });
+        expect(changesets.length).to.equal(baseCount + 1);
+        const insertCs = changesets[baseCount];
+        // Wait so that LastMod on bis_Model gets a distinct timestamp before the delete txn
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        // --- Push baseCount+2: delete the same element ---
+        await rwIModel.locks.acquireLocks({ exclusive: noOpElementId });
+        txn.deleteElement(noOpElementId);
+        txn.saveChanges("delete no-op element");
+        await rwIModel.pushChanges({ description: "delete no-op element", accessToken: adminToken });
+        changesets = await HubMock.downloadChangesets({ iModelId: rwIModelId, targetDir });
+        expect(changesets.length).to.equal(baseCount + 2);
+        const deleteCs = changesets[baseCount + 1];
+        // === openGroup: insert + delete streamed together — element never existed net, so no instances ===
+        {
+            const env_18 = { stack: [], error: void 0, hasError: false };
+            try {
+                const reader = __addDisposableResource(env_18, ChangesetReader.openGroup({ db: rwIModel, changesetFiles: [insertCs.pathname, deleteCs.pathname] }), false);
+                const pcu = __addDisposableResource(env_18, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
+                while (reader.step())
+                    pcu.appendFrom(reader);
+                const instances = Array.from(pcu.instances);
+                // Insert followed immediately by delete cancels out: the unifier must produce zero instances
+                // for this element because the net effect on the database is nothing changed.
+                const elemInstances = instances.filter((i) => i.ECInstanceId === noOpElementId);
+                expect(elemInstances).to.have.length(0, `expected no-op for element ${noOpElementId} but got ${elemInstances.length} instance(s)`);
+            }
+            catch (e_18) {
+                env_18.error = e_18;
+                env_18.hasError = true;
+            }
+            finally {
+                __disposeResources(env_18);
+            }
+        }
+    });
 });
 describe("ChangesetReader — openLocalChanges + openInmemoryChanges", () => {
     let rwIModel;
@@ -3341,10 +3396,10 @@ describe("ChangesetReader — openLocalChanges + openInmemoryChanges", () => {
         });
         txn.saveChanges("insert element");
         {
-            const env_18 = { stack: [], error: void 0, hasError: false };
+            const env_19 = { stack: [], error: void 0, hasError: false };
             try {
-                const reader = __addDisposableResource(env_18, ChangesetReader.openLocalChanges({ db: rwIModel, rowOptions: { abbreviateBlobs: false } }), false);
-                const pcu = __addDisposableResource(env_18, new PartialChangeUnifier(ChangeUnifierCache.createSqliteBackedCache()), false);
+                const reader = __addDisposableResource(env_19, ChangesetReader.openLocalChanges({ db: rwIModel, rowOptions: { abbreviateBlobs: false } }), false);
+                const pcu = __addDisposableResource(env_19, new PartialChangeUnifier(ChangeUnifierCache.createSqliteBackedCache()), false);
                 while (reader.step())
                     pcu.appendFrom(reader);
                 const instances = Array.from(pcu.instances);
@@ -3380,12 +3435,12 @@ describe("ChangesetReader — openLocalChanges + openInmemoryChanges", () => {
                     'JsonProperties', 'LastMod', 'Model.Id', 'Origin', 'Parent', 'Pt3dProp', 'Rotation',
                     'TypeDefinition', 'UserLabel'].sort());
             }
-            catch (e_18) {
-                env_18.error = e_18;
-                env_18.hasError = true;
+            catch (e_19) {
+                env_19.error = e_19;
+                env_19.hasError = true;
             }
             finally {
-                __disposeResources(env_18);
+                __disposeResources(env_19);
             }
         }
         // Wait so that LastMod on bis_Model gets a distinct timestamp before the update txn
@@ -3400,10 +3455,10 @@ describe("ChangesetReader — openLocalChanges + openInmemoryChanges", () => {
             ],
         });
         {
-            const env_19 = { stack: [], error: void 0, hasError: false };
+            const env_20 = { stack: [], error: void 0, hasError: false };
             try {
-                const reader = __addDisposableResource(env_19, ChangesetReader.openInMemoryChanges({ db: rwIModel, rowOptions: { abbreviateBlobs: false } }), false);
-                const pcu = __addDisposableResource(env_19, new PartialChangeUnifier(ChangeUnifierCache.createSqliteBackedCache()), false);
+                const reader = __addDisposableResource(env_20, ChangesetReader.openInMemoryChanges({ db: rwIModel, rowOptions: { abbreviateBlobs: false } }), false);
+                const pcu = __addDisposableResource(env_20, new PartialChangeUnifier(ChangeUnifierCache.createSqliteBackedCache()), false);
                 while (reader.step())
                     pcu.appendFrom(reader);
                 const instances = Array.from(pcu.instances);
@@ -3441,20 +3496,20 @@ describe("ChangesetReader — openLocalChanges + openInmemoryChanges", () => {
                 assert.equal(elemOld.$meta.isIndirectChange, false);
                 assert.deepEqual(elemOld.$meta.changeFetchedPropNames.sort(), ['BBoxHigh', 'BBoxLow', 'BinProp', 'ECInstanceId', 'GuidArrProp', 'LastMod', 'Origin', 'Pt3dProp', 'Rotation'].sort());
             }
-            catch (e_19) {
-                env_19.error = e_19;
-                env_19.hasError = true;
+            catch (e_20) {
+                env_20.error = e_20;
+                env_20.hasError = true;
             }
             finally {
-                __disposeResources(env_19);
+                __disposeResources(env_20);
             }
         }
         // === openLocalChanges: insert + update as a single stream so becomes insert ===
         {
-            const env_20 = { stack: [], error: void 0, hasError: false };
+            const env_21 = { stack: [], error: void 0, hasError: false };
             try {
-                const reader = __addDisposableResource(env_20, ChangesetReader.openLocalChanges({ db: rwIModel, includeInMemoryChanges: true, rowOptions: { abbreviateBlobs: false } }), false);
-                const pcu = __addDisposableResource(env_20, new PartialChangeUnifier(ChangeUnifierCache.createSqliteBackedCache()), false);
+                const reader = __addDisposableResource(env_21, ChangesetReader.openLocalChanges({ db: rwIModel, includeInMemoryChanges: true, rowOptions: { abbreviateBlobs: false } }), false);
+                const pcu = __addDisposableResource(env_21, new PartialChangeUnifier(ChangeUnifierCache.createSqliteBackedCache()), false);
                 while (reader.step())
                     pcu.appendFrom(reader);
                 const instances = Array.from(pcu.instances);
@@ -3494,12 +3549,12 @@ describe("ChangesetReader — openLocalChanges + openInmemoryChanges", () => {
                     'Rotation', 'TypeDefinition', 'UserLabel'].sort());
                 assert.equal(elemNew.$meta.isIndirectChange, false);
             }
-            catch (e_20) {
-                env_20.error = e_20;
-                env_20.hasError = true;
+            catch (e_21) {
+                env_21.error = e_21;
+                env_21.hasError = true;
             }
             finally {
-                __disposeResources(env_20);
+                __disposeResources(env_21);
             }
         }
     });
@@ -3548,7 +3603,7 @@ describe("ChangesetReader: behaviour in case imodel is not in sync with changese
         HubMock.shutdown();
     });
     it("openFile() reads the middle changeset of an insert → update → delete lifecycle", async () => {
-        const env_21 = { stack: [], error: void 0, hasError: false };
+        const env_22 = { stack: [], error: void 0, hasError: false };
         try {
             const adminToken = "super manager token";
             // Push 2 (insert): insert element with category1
@@ -3596,8 +3651,8 @@ describe("ChangesetReader: behaviour in case imodel is not in sync with changese
             const changesets = await HubMock.downloadChangesets({ iModelId: rwIModelId, targetDir });
             expect(changesets.length).to.equal(4);
             const middleChangeset = changesets[Math.floor(changesets.length / 2)]; // index 2 = update
-            const reader = __addDisposableResource(env_21, ChangesetReader.openFile({ db: rwIModel, fileName: middleChangeset.pathname, propFilter: PropertyFilter.InstanceKey, rowOptions: { classIdsToClassNames: true } }), false);
-            const pcu = __addDisposableResource(env_21, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
+            const reader = __addDisposableResource(env_22, ChangesetReader.openFile({ db: rwIModel, fileName: middleChangeset.pathname, propFilter: PropertyFilter.InstanceKey, rowOptions: { classIdsToClassNames: true } }), false);
+            const pcu = __addDisposableResource(env_22, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
             while (reader.step())
                 pcu.appendFrom(reader);
             const instances = Array.from(pcu.instances);
@@ -3616,16 +3671,16 @@ describe("ChangesetReader: behaviour in case imodel is not in sync with changese
             expect(bisElementNew.map((i => i.ECClassId)).sort()).to.deep.equal(["BisCore.GeometricElement2d", "BisCore.Element"].sort());
             expect(bisElementOld.map((i => i.ECClassId)).sort()).to.deep.equal(["BisCore.GeometricElement2d", "BisCore.Element"].sort());
         }
-        catch (e_21) {
-            env_21.error = e_21;
-            env_21.hasError = true;
+        catch (e_22) {
+            env_22.error = e_22;
+            env_22.hasError = true;
         }
         finally {
-            __disposeResources(env_21);
+            __disposeResources(env_22);
         }
     });
     it("openTxn() reads the middle txn of an insert → update → update lifecycle", async () => {
-        const env_22 = { stack: [], error: void 0, hasError: false };
+        const env_23 = { stack: [], error: void 0, hasError: false };
         try {
             // Push 2 (insert): insert element with category1
             const geomArray = [
@@ -3667,8 +3722,8 @@ describe("ChangesetReader: behaviour in case imodel is not in sync with changese
                 s: { x: 100.0, y: 200.0 },
             });
             txn.saveChanges("update element");
-            const reader = __addDisposableResource(env_22, ChangesetReader.openTxn({ db: rwIModel, txnId }), false);
-            const pcu = __addDisposableResource(env_22, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
+            const reader = __addDisposableResource(env_23, ChangesetReader.openTxn({ db: rwIModel, txnId }), false);
+            const pcu = __addDisposableResource(env_23, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
             while (reader.step())
                 pcu.appendFrom(reader);
             const instances = Array.from(pcu.instances);
@@ -3690,12 +3745,12 @@ describe("ChangesetReader: behaviour in case imodel is not in sync with changese
             expect(elementOld.$meta.changeFetchedPropNames).to.include("s.X");
             expect(elementOld.$meta.changeFetchedPropNames).to.not.include("s.Y");
         }
-        catch (e_22) {
-            env_22.error = e_22;
-            env_22.hasError = true;
+        catch (e_23) {
+            env_23.error = e_23;
+            env_23.hasError = true;
         }
         finally {
-            __disposeResources(env_22);
+            __disposeResources(env_23);
         }
     });
 });
@@ -3778,7 +3833,7 @@ describe("ChangesetReader: overflow table graceful recovery when ExclusiveRootCl
         HubMock.shutdown();
     });
     it("openFile() recovers gracefully when ExclusiveRootClassId is NULL for overflow table", () => {
-        const env_23 = { stack: [], error: void 0, hasError: false };
+        const env_24 = { stack: [], error: void 0, hasError: false };
         try {
             /**
              * Simulate the broken state: clear ExclusiveRootClassId so the reader cannot
@@ -3788,7 +3843,7 @@ describe("ChangesetReader: overflow table graceful recovery when ExclusiveRootCl
              */
             expect(rwIModel[_nativeDb].executeSql("UPDATE ec_Table SET ExclusiveRootClassId=NULL WHERE Name='bis_GeometricElement2d_Overflow'")).to.equal(DbResult.BE_SQLITE_OK);
             let assertedOnOverflowTable = false;
-            const reader = __addDisposableResource(env_23, ChangesetReader.openFile({ db: rwIModel, fileName: updateChangesetPathname }), false);
+            const reader = __addDisposableResource(env_24, ChangesetReader.openFile({ db: rwIModel, fileName: updateChangesetPathname }), false);
             while (reader.step()) {
                 if (reader.tableName !== "bis_GeometricElement2d_Overflow")
                     continue;
@@ -3811,21 +3866,21 @@ describe("ChangesetReader: overflow table graceful recovery when ExclusiveRootCl
             }
             assert.isTrue(assertedOnOverflowTable, "Expected at least one row from the overflow table");
         }
-        catch (e_23) {
-            env_23.error = e_23;
-            env_23.hasError = true;
+        catch (e_24) {
+            env_24.error = e_24;
+            env_24.hasError = true;
         }
         finally {
-            __disposeResources(env_23);
+            __disposeResources(env_24);
         }
     });
 });
 describe("ChangesetReader: instance reused with a different class (class change in Updated row)", () => {
     it("openFile() correctly identifies ECClassId change from T1 to T2 in a buggy changeset", async () => {
-        const env_24 = { stack: [], error: void 0, hasError: false };
+        const env_25 = { stack: [], error: void 0, hasError: false };
         try {
             /**
-             * Same scenario as ChangesetReader.test.ts: "Instance update to a different class (bug)".
+             * Same scenario as SQliteChangesetReaderAndChangesetECAdaptor.test.ts: "Instance update to a different class (bug)".
              * Verifies ChangesetReader behaviour when an instance ID is reused with a different class.
              *
              * Steps:
@@ -3927,7 +3982,7 @@ describe("ChangesetReader: instance reused with a different class (class change
             // so it correctly sees T2 for the new (inserted) side and T1 for the old (deleted) side.
             let bisElementAsserted = false;
             let bisGeomElement2dAsserted = false;
-            const reader = __addDisposableResource(env_24, ChangesetReader.openFile({ db: b1, fileName: changesets[1].pathname }), false);
+            const reader = __addDisposableResource(env_25, ChangesetReader.openFile({ db: b1, fileName: changesets[1].pathname }), false);
             while (reader.step()) {
                 if (reader.tableName === "bis_Element" && reader.op === "Updated") {
                     bisElementAsserted = true;
@@ -3957,12 +4012,12 @@ describe("ChangesetReader: instance reused with a different class (class change
             b1.close();
             HubMock.shutdown();
         }
-        catch (e_24) {
-            env_24.error = e_24;
-            env_24.hasError = true;
+        catch (e_25) {
+            env_25.error = e_25;
+            env_25.hasError = true;
         }
         finally {
-            __disposeResources(env_24);
+            __disposeResources(env_25);
         }
     });
 });
@@ -4256,7 +4311,7 @@ describe("ChangesetReader: invalid inputs", () => {
         expect(() => ChangesetReader.openFile({ db: iModel, fileName: KnownTestLocations.outputDir })).to.throw();
     });
     it("openFile: path points to a plain text file (not .changeset) throws", () => {
-        const env_25 = { stack: [], error: void 0, hasError: false };
+        const env_26 = { stack: [], error: void 0, hasError: false };
         try {
             const txtFile = path.join(KnownTestLocations.outputDir, "not_a_changeset.txt");
             if (fs.existsSync(txtFile))
@@ -4264,19 +4319,19 @@ describe("ChangesetReader: invalid inputs", () => {
             // Write a small non-changeset file and expect the reader to reject it.
             fs.writeFileSync(txtFile, "this is not a changeset");
             // The native code asserts on an invalid changeset file. Suppress this.
-            const _disableAssertions = __addDisposableResource(env_25, new DisableNativeAssertions(), false);
-            const reader = __addDisposableResource(env_25, ChangesetReader.openFile({ db: iModel, fileName: txtFile }), false);
+            const _disableAssertions = __addDisposableResource(env_26, new DisableNativeAssertions(), false);
+            const reader = __addDisposableResource(env_26, ChangesetReader.openFile({ db: iModel, fileName: txtFile }), false);
             assert.equal(reader.step(), false, "Expected step() to return false for an invalid changeset file");
             assert.equal(reader.step(), false, "Expected step() to return false for an invalid changeset file");
             assert.equal(reader.step(), false, "Expected step() to return false for an invalid changeset file");
             assert.equal(reader.step(), false, "Expected step() to return false for an invalid changeset file");
         }
-        catch (e_25) {
-            env_25.error = e_25;
-            env_25.hasError = true;
+        catch (e_26) {
+            env_26.error = e_26;
+            env_26.hasError = true;
         }
         finally {
-            __disposeResources(env_25);
+            __disposeResources(env_26);
         }
     });
     // --- openGroup ---
@@ -4296,17 +4351,17 @@ describe("ChangesetReader: invalid inputs", () => {
         // Passing the same changeset file twice is unusual but not necessarily an error at open time.
         // The reader should open and step without throwing; the caller is responsible for any semantic issues.
         expect(() => {
-            const env_26 = { stack: [], error: void 0, hasError: false };
+            const env_27 = { stack: [], error: void 0, hasError: false };
             try {
-                const reader = __addDisposableResource(env_26, ChangesetReader.openGroup({ db: iModel, changesetFiles: [validChangesetPath, validChangesetPath] }), false);
+                const reader = __addDisposableResource(env_27, ChangesetReader.openGroup({ db: iModel, changesetFiles: [validChangesetPath, validChangesetPath] }), false);
                 while (reader.step()) { /* drain */ }
             }
-            catch (e_26) {
-                env_26.error = e_26;
-                env_26.hasError = true;
+            catch (e_27) {
+                env_27.error = e_27;
+                env_27.hasError = true;
             }
             finally {
-                __disposeResources(env_26);
+                __disposeResources(env_27);
             }
         }).to.not.throw();
     });
@@ -4319,24 +4374,10 @@ describe("ChangesetReader: invalid inputs", () => {
     });
     // --- property accessors before step() ---
     it("accessing tableName before step() throws", () => {
-        const env_27 = { stack: [], error: void 0, hasError: false };
-        try {
-            const reader = __addDisposableResource(env_27, ChangesetReader.openFile({ db: iModel, fileName: validChangesetPath }), false);
-            expect(() => reader.tableName).to.throw();
-        }
-        catch (e_27) {
-            env_27.error = e_27;
-            env_27.hasError = true;
-        }
-        finally {
-            __disposeResources(env_27);
-        }
-    });
-    it("accessing isECTable before step() throws", () => {
         const env_28 = { stack: [], error: void 0, hasError: false };
         try {
             const reader = __addDisposableResource(env_28, ChangesetReader.openFile({ db: iModel, fileName: validChangesetPath }), false);
-            expect(() => reader.isECTable).to.throw();
+            expect(() => reader.tableName).to.throw();
         }
         catch (e_28) {
             env_28.error = e_28;
@@ -4346,11 +4387,11 @@ describe("ChangesetReader: invalid inputs", () => {
             __disposeResources(env_28);
         }
     });
-    it("accessing isIndirectChange before step() throws", () => {
+    it("accessing isECTable before step() throws", () => {
         const env_29 = { stack: [], error: void 0, hasError: false };
         try {
             const reader = __addDisposableResource(env_29, ChangesetReader.openFile({ db: iModel, fileName: validChangesetPath }), false);
-            expect(() => reader.isIndirectChange).to.throw();
+            expect(() => reader.isECTable).to.throw();
         }
         catch (e_29) {
             env_29.error = e_29;
@@ -4360,6 +4401,20 @@ describe("ChangesetReader: invalid inputs", () => {
             __disposeResources(env_29);
         }
     });
+    it("accessing isIndirectChange before step() throws", () => {
+        const env_30 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_30, ChangesetReader.openFile({ db: iModel, fileName: validChangesetPath }), false);
+            expect(() => reader.isIndirectChange).to.throw();
+        }
+        catch (e_30) {
+            env_30.error = e_30;
+            env_30.hasError = true;
+        }
+        finally {
+            __disposeResources(env_30);
+        }
+    });
     it("openGroup: should throw if spillThresholdInBytes is negative", () => {
         expect(() => {
             ChangesetReader.openGroup({ db: iModel, changesetFiles: [validChangesetPath, validChangesetPath], spillThresholdInBytes: -1 });
@@ -4471,19 +4526,19 @@ describe("ChangesetReader — spillThresholdInBytes (spill-to-disk)", () => {
     }
     /** Reads all instances from a reader using an in-memory unifier cache. */
     function drainReader(reader) {
-        const env_30 = { stack: [], error: void 0, hasError: false };
+        const env_31 = { stack: [], error: void 0, hasError: false };
         try {
-            const pcu = __addDisposableResource(env_30, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
+            const pcu = __addDisposableResource(env_31, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
             while (reader.step())
                 pcu.appendFrom(reader);
             return Array.from(pcu.instances);
         }
-        catch (e_30) {
-            env_30.error = e_30;
-            env_30.hasError = true;
+        catch (e_31) {
+            env_31.error = e_31;
+            env_31.hasError = true;
         }
         finally {
-            __disposeResources(env_30);
+            __disposeResources(env_31);
         }
     }
     /** Sorts instances by a stable key for deterministic deep-equality comparisons. */
@@ -4711,26 +4766,26 @@ describe("ChangesetReader: strict mode (column-count mismatch)", () => {
             await importSchemaStrings(txn, [STRICT_MODE_SCHEMA_V2]);
             // Strict mode ON: binary has one column less than the live table.
             {
-                const env_31 = { stack: [], error: void 0, hasError: false };
+                const env_32 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const reader = __addDisposableResource(env_31, ChangesetReader.openTxn({ db, txnId }), false);
+                    const reader = __addDisposableResource(env_32, ChangesetReader.openTxn({ db, txnId }), false);
                     reader.enableStrictMode();
                     expect(() => { while (reader.step()) { /* drain */ } }).to.throw();
                 }
-                catch (e_31) {
-                    env_31.error = e_31;
-                    env_31.hasError = true;
+                catch (e_32) {
+                    env_32.error = e_32;
+                    env_32.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_31);
+                    __disposeResources(env_32);
                 }
             }
             {
-                const env_32 = { stack: [], error: void 0, hasError: false };
+                const env_33 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const reader = __addDisposableResource(env_32, ChangesetReader.openTxn({ db, txnId }), false);
+                    const reader = __addDisposableResource(env_33, ChangesetReader.openTxn({ db, txnId }), false);
                     reader.disableStrictMode(); // no-op when already off — verifies the API does not throw
-                    const pcu = __addDisposableResource(env_32, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
+                    const pcu = __addDisposableResource(env_33, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
                     while (reader.step())
                         pcu.appendFrom(reader);
                     const instances = Array.from(pcu.instances);
@@ -4816,12 +4871,12 @@ describe("ChangesetReader: strict mode (column-count mismatch)", () => {
                     ].sort());
                     assert.equal(elemNew.$meta.isIndirectChange, false);
                 }
-                catch (e_32) {
-                    env_32.error = e_32;
-                    env_32.hasError = true;
+                catch (e_33) {
+                    env_33.error = e_33;
+                    env_33.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_32);
+                    __disposeResources(env_33);
                 }
             }
         }
@@ -4877,26 +4932,26 @@ describe("ChangesetReader: strict mode (column-count mismatch)", () => {
             const newCs = changesets[changesets.length - 1];
             // Strict mode ON: binary has more cols, throws.
             {
-                const env_33 = { stack: [], error: void 0, hasError: false };
+                const env_34 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const reader = __addDisposableResource(env_33, ChangesetReader.openFile({ db: b1, fileName: newCs.pathname }), false);
+                    const reader = __addDisposableResource(env_34, ChangesetReader.openFile({ db: b1, fileName: newCs.pathname }), false);
                     reader.enableStrictMode();
                     expect(() => { while (reader.step()) { /* drain */ } }).to.throw();
                 }
-                catch (e_33) {
-                    env_33.error = e_33;
-                    env_33.hasError = true;
+                catch (e_34) {
+                    env_34.error = e_34;
+                    env_34.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_33);
+                    __disposeResources(env_34);
                 }
             }
             // Strict mode OFF: binary has more cols, does not throw.
             {
-                const env_34 = { stack: [], error: void 0, hasError: false };
+                const env_35 = { stack: [], error: void 0, hasError: false };
                 try {
-                    const reader = __addDisposableResource(env_34, ChangesetReader.openFile({ db: b1, fileName: newCs.pathname }), false);
-                    const pcu = __addDisposableResource(env_34, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
+                    const reader = __addDisposableResource(env_35, ChangesetReader.openFile({ db: b1, fileName: newCs.pathname }), false);
+                    const pcu = __addDisposableResource(env_35, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
                     while (reader.step())
                         pcu.appendFrom(reader);
                     const instances = Array.from(pcu.instances);
@@ -4982,12 +5037,12 @@ describe("ChangesetReader: strict mode (column-count mismatch)", () => {
                     ].sort());
                     assert.equal(elemNew.$meta.isIndirectChange, false);
                 }
-                catch (e_34) {
-                    env_34.error = e_34;
-                    env_34.hasError = true;
+                catch (e_35) {
+                    env_35.error = e_35;
+                    env_35.hasError = true;
                 }
                 finally {
-                    __disposeResources(env_34);
+                    __disposeResources(env_35);
                 }
             }
         }
@@ -4998,4 +5053,564 @@ describe("ChangesetReader: strict mode (column-count mismatch)", () => {
         }
     });
 });
+describe("ChangesetReader: throwIfAlreadyStepped guard", () => {
+    let iModel;
+    let txn;
+    let txnId;
+    before(async () => {
+        HubMock.startup("ChangesetReaderThrowGuard", KnownTestLocations.outputDir);
+        const adminToken = "super manager token";
+        const iTwinId = HubMock.iTwinId;
+        const iModelId = await HubMock.createNewIModel({ iTwinId, iModelName: "throwGuard", accessToken: adminToken });
+        iModel = await HubWrappers.downloadAndOpenBriefcase({ iTwinId, iModelId, accessToken: adminToken });
+        txn = startTestTxn(iModel, "throwGuard setup");
+        iModel.channels.addAllowedChannel(ChannelControl.sharedChannelName);
+        await iModel.locks.acquireLocks({ shared: IModel.dictionaryId });
+        IModelTestUtils.createAndInsertDrawingPartitionAndModel(txn, Code.createEmpty(), true);
+        txn.saveChanges("setup");
+        txnId = iModel.txns.getLastSavedTxnProps().id;
+    });
+    after(() => {
+        txn.end();
+        iModel?.close();
+        HubMock.shutdown();
+    });
+    it("setTableNameFilters throws after step()", () => {
+        const env_36 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_36, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            assert.isTrue(reader.step());
+            expect(() => reader.setTableNameFilters(new Set(["bis_Element"]))).to.throw("filters and strict mode and batch size must be configured before the first call to step()");
+        }
+        catch (e_36) {
+            env_36.error = e_36;
+            env_36.hasError = true;
+        }
+        finally {
+            __disposeResources(env_36);
+        }
+    });
+    it("setOpCodeFilters throws after step()", () => {
+        const env_37 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_37, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            assert.isTrue(reader.step());
+            expect(() => reader.setOpCodeFilters(new Set(["Inserted"]))).to.throw("filters and strict mode and batch size must be configured before the first call to step()");
+        }
+        catch (e_37) {
+            env_37.error = e_37;
+            env_37.hasError = true;
+        }
+        finally {
+            __disposeResources(env_37);
+        }
+    });
+    it("setClassNameFilters throws after step()", () => {
+        const env_38 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_38, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            assert.isTrue(reader.step());
+            expect(() => reader.setClassNameFilters(new Set(["BisCore:Element"]))).to.throw("filters and strict mode and batch size must be configured before the first call to step()");
+        }
+        catch (e_38) {
+            env_38.error = e_38;
+            env_38.hasError = true;
+        }
+        finally {
+            __disposeResources(env_38);
+        }
+    });
+    it("clearTableNameFilters throws after step()", () => {
+        const env_39 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_39, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            assert.isTrue(reader.step());
+            expect(() => reader.clearTableNameFilters()).to.throw("filters and strict mode and batch size must be configured before the first call to step()");
+        }
+        catch (e_39) {
+            env_39.error = e_39;
+            env_39.hasError = true;
+        }
+        finally {
+            __disposeResources(env_39);
+        }
+    });
+    it("clearOpCodeFilters throws after step()", () => {
+        const env_40 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_40, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            assert.isTrue(reader.step());
+            expect(() => reader.clearOpCodeFilters()).to.throw("filters and strict mode and batch size must be configured before the first call to step()");
+        }
+        catch (e_40) {
+            env_40.error = e_40;
+            env_40.hasError = true;
+        }
+        finally {
+            __disposeResources(env_40);
+        }
+    });
+    it("clearClassNameFilters throws after step()", () => {
+        const env_41 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_41, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            assert.isTrue(reader.step());
+            expect(() => reader.clearClassNameFilters()).to.throw("filters and strict mode and batch size must be configured before the first call to step()");
+        }
+        catch (e_41) {
+            env_41.error = e_41;
+            env_41.hasError = true;
+        }
+        finally {
+            __disposeResources(env_41);
+        }
+    });
+    it("enableStrictMode throws after step()", () => {
+        const env_42 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_42, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            assert.isTrue(reader.step());
+            expect(() => reader.enableStrictMode()).to.throw("filters and strict mode and batch size must be configured before the first call to step()");
+        }
+        catch (e_42) {
+            env_42.error = e_42;
+            env_42.hasError = true;
+        }
+        finally {
+            __disposeResources(env_42);
+        }
+    });
+    it("disableStrictMode throws after step()", () => {
+        const env_43 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_43, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            assert.isTrue(reader.step());
+            expect(() => reader.disableStrictMode()).to.throw("filters and strict mode and batch size must be configured before the first call to step()");
+        }
+        catch (e_43) {
+            env_43.error = e_43;
+            env_43.hasError = true;
+        }
+        finally {
+            __disposeResources(env_43);
+        }
+    });
+    it("setBatchSize throws after step()", () => {
+        const env_44 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_44, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            assert.isTrue(reader.step());
+            expect(() => reader.setBatchSize(10)).to.throw("filters and strict mode and batch size must be configured before the first call to step()");
+        }
+        catch (e_44) {
+            env_44.error = e_44;
+            env_44.hasError = true;
+        }
+        finally {
+            __disposeResources(env_44);
+        }
+    });
+    it("setBatchSize throws with zero or negative value", () => {
+        const env_45 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_45, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            expect(() => reader.setBatchSize(0)).to.throw("batchSize must be a positive integer");
+            expect(() => reader.setBatchSize(-1)).to.throw("batchSize must be a positive integer");
+        }
+        catch (e_45) {
+            env_45.error = e_45;
+            env_45.hasError = true;
+        }
+        finally {
+            __disposeResources(env_45);
+        }
+    });
+    it("filters can be set before any step()", () => {
+        const env_46 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_46, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            // None of these should throw before step() is called
+            expect(() => reader.setTableNameFilters(new Set(["bis_Element"]))).to.not.throw();
+            expect(() => reader.setOpCodeFilters(new Set(["Inserted"]))).to.not.throw();
+            expect(() => reader.setClassNameFilters(new Set(["BisCore:Element"]))).to.not.throw();
+            expect(() => reader.clearTableNameFilters()).to.not.throw();
+            expect(() => reader.clearOpCodeFilters()).to.not.throw();
+            expect(() => reader.clearClassNameFilters()).to.not.throw();
+            expect(() => reader.enableStrictMode()).to.not.throw();
+            expect(() => reader.disableStrictMode()).to.not.throw();
+            expect(() => reader.setBatchSize(5)).to.not.throw();
+        }
+        catch (e_46) {
+            env_46.error = e_46;
+            env_46.hasError = true;
+        }
+        finally {
+            __disposeResources(env_46);
+        }
+    });
+});
+describe("ChangesetReader: batched stepping behavior", () => {
+    let iModel;
+    let txn;
+    let txnId;
+    before(async () => {
+        HubMock.startup("ChangesetReaderBatchStep", KnownTestLocations.outputDir);
+        const adminToken = "super manager token";
+        const iTwinId = HubMock.iTwinId;
+        const iModelId = await HubMock.createNewIModel({ iTwinId, iModelName: "batchStep", accessToken: adminToken });
+        iModel = await HubWrappers.downloadAndOpenBriefcase({ iTwinId, iModelId, accessToken: adminToken });
+        txn = startTestTxn(iModel, "batchStep setup");
+        iModel.channels.addAllowedChannel(ChannelControl.sharedChannelName);
+        await iModel.locks.acquireLocks({ shared: IModel.dictionaryId });
+        IModelTestUtils.createAndInsertDrawingPartitionAndModel(txn, Code.createEmpty(), true);
+        txn.saveChanges("setup");
+        txnId = iModel.txns.getLastSavedTxnProps().id;
+    });
+    after(() => {
+        txn.end();
+        iModel?.close();
+        HubMock.shutdown();
+    });
+    it("step() returns false when no rows remain", () => {
+        const env_47 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_47, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            // Drain all rows
+            while (reader.step()) { /* consume */ }
+            // The next call must also return false
+            assert.isFalse(reader.step());
+        }
+        catch (e_47) {
+            env_47.error = e_47;
+            env_47.hasError = true;
+        }
+        finally {
+            __disposeResources(env_47);
+        }
+    });
+    it("step() returns false repeatedly after exhaustion", () => {
+        const env_48 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_48, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            while (reader.step()) { /* consume */ }
+            assert.isFalse(reader.step());
+            assert.isFalse(reader.step());
+            assert.isFalse(reader.step());
+        }
+        catch (e_48) {
+            env_48.error = e_48;
+            env_48.hasError = true;
+        }
+        finally {
+            __disposeResources(env_48);
+        }
+    });
+    it("inserted/deleted are undefined after exhaustion", () => {
+        const env_49 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_49, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            while (reader.step()) { /* consume */ }
+            assert.isUndefined(reader.inserted);
+            assert.isUndefined(reader.deleted);
+        }
+        catch (e_49) {
+            env_49.error = e_49;
+            env_49.hasError = true;
+        }
+        finally {
+            __disposeResources(env_49);
+        }
+    });
+    it("op throws after exhaustion", () => {
+        const env_50 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_50, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            while (reader.step()) { /* consume */ }
+            expect(() => reader.op).to.throw("no current row");
+        }
+        catch (e_50) {
+            env_50.error = e_50;
+            env_50.hasError = true;
+        }
+        finally {
+            __disposeResources(env_50);
+        }
+    });
+    it("setBatchSize(1) produces same instances as default batch size", () => {
+        const defaultInstances = [];
+        {
+            const env_51 = { stack: [], error: void 0, hasError: false };
+            try {
+                const reader = __addDisposableResource(env_51, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+                const pcu = __addDisposableResource(env_51, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
+                while (reader.step())
+                    pcu.appendFrom(reader);
+                for (const inst of pcu.instances)
+                    defaultInstances.push(inst.ECInstanceId);
+            }
+            catch (e_51) {
+                env_51.error = e_51;
+                env_51.hasError = true;
+            }
+            finally {
+                __disposeResources(env_51);
+            }
+        }
+        defaultInstances.sort();
+        const batchOneInstances = [];
+        {
+            const env_52 = { stack: [], error: void 0, hasError: false };
+            try {
+                const reader = __addDisposableResource(env_52, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+                reader.setBatchSize(1);
+                const pcu = __addDisposableResource(env_52, new PartialChangeUnifier(ChangeUnifierCache.createInMemoryCache()), false);
+                while (reader.step())
+                    pcu.appendFrom(reader);
+                for (const inst of pcu.instances)
+                    batchOneInstances.push(inst.ECInstanceId);
+            }
+            catch (e_52) {
+                env_52.error = e_52;
+                env_52.hasError = true;
+            }
+            finally {
+                __disposeResources(env_52);
+            }
+        }
+        batchOneInstances.sort();
+        assert.deepEqual(batchOneInstances, defaultInstances);
+    });
+});
+describe("ChangesetReader: lazy inserted/deleted getters", () => {
+    let iModel;
+    let txn;
+    let txnId;
+    before(async () => {
+        HubMock.startup("ChangesetReaderLazyGetters", KnownTestLocations.outputDir);
+        const adminToken = "super manager token";
+        const iTwinId = HubMock.iTwinId;
+        const iModelId = await HubMock.createNewIModel({ iTwinId, iModelName: "lazyGetters", accessToken: adminToken });
+        iModel = await HubWrappers.downloadAndOpenBriefcase({ iTwinId, iModelId, accessToken: adminToken });
+        txn = startTestTxn(iModel, "lazyGetters setup");
+        iModel.channels.addAllowedChannel(ChannelControl.sharedChannelName);
+        await iModel.locks.acquireLocks({ shared: IModel.dictionaryId });
+        IModelTestUtils.createAndInsertDrawingPartitionAndModel(txn, Code.createEmpty(), true);
+        txn.saveChanges("setup");
+        txnId = iModel.txns.getLastSavedTxnProps().id;
+    });
+    after(() => {
+        txn.end();
+        iModel?.close();
+        HubMock.shutdown();
+    });
+    it("inserted is undefined before step()", () => {
+        const env_53 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_53, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            assert.isUndefined(reader.inserted);
+        }
+        catch (e_53) {
+            env_53.error = e_53;
+            env_53.hasError = true;
+        }
+        finally {
+            __disposeResources(env_53);
+        }
+    });
+    it("deleted is undefined before step()", () => {
+        const env_54 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_54, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            assert.isUndefined(reader.deleted);
+        }
+        catch (e_54) {
+            env_54.error = e_54;
+            env_54.hasError = true;
+        }
+        finally {
+            __disposeResources(env_54);
+        }
+    });
+    it("inserted returns a fresh object on first access, cached object on subsequent access", () => {
+        const env_55 = { stack: [], error: void 0, hasError: false };
+        try {
+            const reader = __addDisposableResource(env_55, ChangesetReader.openTxn({ db: iModel, txnId }), false);
+            // Find an Inserted row
+            let found = false;
+            while (reader.step()) {
+                if (reader.inserted) {
+                    const first = reader.inserted;
+                    const second = reader.inserted;
+                    assert.strictEqual(first, second);
+                    assert.deepEqual(first, second);
+                    found = true;
+                    break;
+                }
+            }
+            assert.isTrue(found, "Expected at least one row with an inserted value");
+        }
+        catch (e_55) {
+            env_55.error = e_55;
+            env_55.hasError = true;
+        }
+        finally {
+            __disposeResources(env_55);
+        }
+    });
+});
+describe("ChangesetReader insert-many (53 elements)", () => {
+    let rwIModel;
+    const elementIds = [];
+    let drawingModelId;
+    let drawingCategoryId;
+    let txnId;
+    let txn;
+    const ELEMENT_COUNT = 53;
+    before(async () => {
+        HubMock.startup("ECChangesetInsertMany", KnownTestLocations.outputDir);
+        const adminToken = "super manager token";
+        const iTwinId = HubMock.iTwinId;
+        const rwIModelId = await HubMock.createNewIModel({ iTwinId, iModelName: "insertMany", description: "insertMany", accessToken: adminToken });
+        rwIModel = await HubWrappers.downloadAndOpenBriefcase({ iTwinId, iModelId: rwIModelId, accessToken: adminToken });
+        txn = startTestTxn(rwIModel, "ChangesetReader insert-many setup");
+        const schema = `<?xml version="1.0" encoding="UTF-8"?>
+  <ECSchema schemaName="TestDomain" alias="ts" version="01.00" xmlns="http://www.bentley.com/schemas/Bentley.ECXML.3.1">
+      <ECSchemaReference name="BisCore" version="01.00" alias="bis"/>
+      <ECStructClass typeName="RichPoint" modifier="Sealed">
+          <ECProperty propertyName="X"     typeName="double"/>
+          <ECProperty propertyName="Y"     typeName="double"/>
+          <ECProperty propertyName="Z"     typeName="double"/>
+          <ECProperty propertyName="Label" typeName="string"/>
+      </ECStructClass>
+      <ECEntityClass typeName="Test2dElement">
+          <BaseClass>bis:GraphicalElement2d</BaseClass>
+          <ECProperty propertyName="StrProp"        typeName="string"/>
+          <ECProperty propertyName="IntProp"        typeName="int"/>
+          <ECProperty propertyName="DblProp"        typeName="double"/>
+          <ECStructProperty propertyName="StructProp" typeName="RichPoint"/>
+          <ECArrayProperty propertyName="IntArrProp"  typeName="int" minOccurs="0" maxOccurs="unbounded"/>
+      </ECEntityClass>
+  </ECSchema>`;
+        await importSchemaStrings(txn, [schema]);
+        rwIModel.channels.addAllowedChannel(ChannelControl.sharedChannelName);
+        await rwIModel.locks.acquireLocks({ shared: IModel.dictionaryId });
+        const codeProps = Code.createEmpty();
+        codeProps.value = "DrillDownDrawing";
+        [, drawingModelId] = IModelTestUtils.createAndInsertDrawingPartitionAndModel(txn, codeProps, true);
+        const foundCat = DrawingCategory.queryCategoryIdByName(rwIModel, IModel.dictionaryId, "DrillDownCategory");
+        drawingCategoryId = foundCat ?? DrawingCategory.insert(txn, IModel.dictionaryId, "DrillDownCategory", new SubCategoryAppearance({ color: ColorDef.fromString("rgb(255,0,0)").toJSON() }));
+        txn.saveChanges("setup");
+        // Wait so that LastMod on bis_Model gets a distinct timestamp before the insert txn
+        await new Promise((resolve) => setTimeout(resolve, 300));
+        // Txn 2: insert 53 elements
+        await rwIModel.locks.acquireLocks({ shared: drawingModelId });
+        for (let i = 0; i < ELEMENT_COUNT; i++) {
+            const id = txn.insertElement({
+                classFullName: "TestDomain:Test2dElement",
+                model: drawingModelId,
+                category: drawingCategoryId,
+                code: Code.createEmpty(),
+                StrProp: `element_${i}`,
+                IntProp: i,
+                DblProp: i * 1.5,
+                StructProp: { X: i, Y: i + 1, Z: i + 2, Label: `pt_${i}` },
+                IntArrProp: [i, i * 10, i * 100],
+            });
+            elementIds.push(id);
+        }
+        txn.saveChanges("insert 53 elements");
+        txnId = rwIModel.txns.getLastSavedTxnProps().id;
+    });
+    after(() => {
+        txn.end();
+        rwIModel?.close();
+        HubMock.shutdown();
+    });
+    it("All_Properties: returns all 53 inserted elements", () => {
+        const instances = readTxn(rwIModel, txnId);
+        // 53 inserted elements (New) + 1 model update (New + Old) = 55
+        const elemInstances = instances.filter((i) => i.$meta.op === "Inserted" && i.$meta.stage === "New");
+        assert.equal(elemInstances.length, ELEMENT_COUNT);
+        // Verify the model indirect change is present
+        const modelNew = instances.find((i) => i.ECInstanceId === drawingModelId && i.$meta.stage === "New");
+        const modelOld = instances.find((i) => i.ECInstanceId === drawingModelId && i.$meta.stage === "Old");
+        expect(modelNew).to.exist;
+        expect(modelOld).to.exist;
+        assert.equal(modelNew.$meta.op, "Updated");
+        assert.equal(modelOld.$meta.op, "Updated");
+        assert.equal(modelNew.$meta.isIndirectChange, true);
+        assert.equal(modelOld.$meta.isIndirectChange, true);
+        // Total: 53 elements + 2 model entries
+        assert.equal(instances.length, ELEMENT_COUNT + 2);
+        // Verify each element is present and has the correct props
+        for (let i = 0; i < ELEMENT_COUNT; i++) {
+            const elem = elemInstances.find((inst) => inst.ECInstanceId === elementIds[i]);
+            expect(elem, `element ${i} not found`).to.exist;
+            assert.equal(elem.$meta.op, "Inserted");
+            assert.equal(elem.$meta.stage, "New");
+            assert.equal(elem.$meta.propFilter, PropertyFilter.All);
+            assert.equal(elem.$meta.isIndirectChange, false);
+            assert.equal(elem.StrProp, `element_${i}`);
+            assert.equal(elem.IntProp, i);
+            assert.closeTo(elem.DblProp, i * 1.5, 1e-10);
+            assert.deepEqual(elem.StructProp, { X: i, Y: i + 1, Z: i + 2, Label: `pt_${i}` });
+            assert.deepEqual(elem.IntArrProp, [i, i * 10, i * 100]);
+            assert.equal(elem.Model.Id, drawingModelId);
+            assert.equal(elem.Category.Id, drawingCategoryId);
+        }
+    });
+    it("BisCoreElement: returns all 53 elements without custom props", () => {
+        const instances = readTxn(rwIModel, txnId, PropertyFilter.BisCoreElement, { classIdsToClassNames: true });
+        const elemInstances = instances.filter((i) => i.$meta.op === "Inserted" && i.$meta.stage === "New");
+        assert.equal(elemInstances.length, ELEMENT_COUNT);
+        assert.equal(instances.length, ELEMENT_COUNT + 2);
+        for (let i = 0; i < ELEMENT_COUNT; i++) {
+            const elem = elemInstances.find((inst) => inst.ECInstanceId === elementIds[i]);
+            expect(elem, `element ${i} not found`).to.exist;
+            assert.equal(elem.$meta.op, "Inserted");
+            assert.equal(elem.$meta.stage, "New");
+            assert.equal(elem.$meta.propFilter, PropertyFilter.BisCoreElement);
+            assert.equal(elem.$meta.isIndirectChange, false);
+            assert.equal(elem.ECClassId, "TestDomain.Test2dElement");
+            assert.equal(elem.Model.Id, drawingModelId);
+            // BisCoreElement filter: no custom domain props
+            assert.isUndefined(elem.StrProp);
+            assert.isUndefined(elem.IntProp);
+            assert.isUndefined(elem.DblProp);
+            assert.isUndefined(elem.StructProp);
+            assert.isUndefined(elem.IntArrProp);
+            // BIS core element props are present
+            expect(elem.Model).to.exist;
+            expect(elem.LastMod).to.exist;
+            expect(elem.CodeSpec).to.exist;
+            expect(elem.CodeScope).to.exist;
+            expect(elem.FederationGuid).to.exist;
+        }
+    });
+    it("InstanceKey: returns all 53 elements with only ECInstanceId and ECClassId", () => {
+        const instances = readTxn(rwIModel, txnId, PropertyFilter.InstanceKey);
+        const elemInstances = instances.filter((i) => i.$meta.op === "Inserted" && i.$meta.stage === "New");
+        assert.equal(elemInstances.length, ELEMENT_COUNT);
+        assert.equal(instances.length, ELEMENT_COUNT + 2);
+        for (let i = 0; i < ELEMENT_COUNT; i++) {
+            const elem = elemInstances.find((inst) => inst.ECInstanceId === elementIds[i]);
+            expect(elem, `element ${i} not found`).to.exist;
+            assert.equal(elem.$meta.op, "Inserted");
+            assert.equal(elem.$meta.stage, "New");
+            assert.equal(elem.$meta.propFilter, PropertyFilter.InstanceKey);
+            assert.equal(elem.$meta.isIndirectChange, false);
+            assert.equal("TestDomain:Test2dElement", rwIModel.getClassNameFromId(elem.ECClassId));
+            // InstanceKey: only ECInstanceId + ECClassId, no other props
+            assert.isUndefined(elem.StrProp);
+            assert.isUndefined(elem.IntProp);
+            assert.isUndefined(elem.DblProp);
+            assert.isUndefined(elem.StructProp);
+            assert.isUndefined(elem.IntArrProp);
+            assert.isUndefined(elem.Model);
+            assert.isUndefined(elem.Category);
+            assert.isUndefined(elem.LastMod);
+            assert.deepEqual(Object.keys(elem).sort(), ["ECInstanceId", "ECClassId", "$meta"].sort());
+        }
+    });
+});
 //# sourceMappingURL=ChangesetReader.test.js.map