@itwin/imodel-transformer 1.0.0-dev.1 → 1.0.0-dev.10

package/lib/cjs/IModelTransformer.js

@@ -13,6 +13,7 @@ const Semver = require("semver");
 const nodeAssert = require("assert");
 const core_bentley_1 = require("@itwin/core-bentley");
 const core_geometry_1 = require("@itwin/core-geometry");
+const coreBackendPkgJson = require("@itwin/core-backend/package.json");
 const core_backend_1 = require("@itwin/core-backend");
 const core_common_1 = require("@itwin/core-common");
 const IModelExporter_1 = require("./IModelExporter");
@@ -80,7 +81,7 @@ function mapId64(idContainer, func) {
     }
     else {
         throw Error([
-            `Id64 container '${idContainer}' is unsupported.`,
+            `Id64 container '${JSON.stringify(idContainer)}' is unsupported.`,
             "Currently only singular Id64 strings or prop-like objects containing an 'id' property are supported.",
         ].join("\n"));
     }
@@ -149,7 +150,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 id: targetScopeElementId,
                 relClassName: core_backend_1.ElementOwnsExternalSourceAspects.classFullName,
             },
-            scope: { id: core_common_1.IModel.rootSubjectId },
+            scope: { id: core_common_1.IModel.rootSubjectId }, // the root Subject scopes scope elements
             identifier: sourceDb.iModelId,
             kind: core_backend_1.ExternalSourceAspect.Kind.Scope,
             jsonProperties: undefined,
@@ -273,9 +274,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             cloneUsingBinaryGeometry: options?.cloneUsingBinaryGeometry ?? true,
             targetScopeElementId: options?.targetScopeElementId ?? core_common_1.IModel.rootSubjectId,
             // eslint-disable-next-line deprecation/deprecation
-            danglingReferencesBehavior: options?.danglingReferencesBehavior ??
-                options?.danglingPredecessorsBehavior ??
-                "reject",
+            danglingReferencesBehavior: options?.danglingReferencesBehavior ?? "reject",
             branchRelationshipDataBehavior: options?.branchRelationshipDataBehavior ?? "reject",
         };
         this._isProvenanceInitTransform = this._options
@@ -361,8 +360,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         core_bentley_1.Logger.logInfo(loggerCategory, `this._includeSourceProvenance=${this._options.includeSourceProvenance}`);
         core_bentley_1.Logger.logInfo(loggerCategory, `this._cloneUsingBinaryGeometry=${this._options.cloneUsingBinaryGeometry}`);
         core_bentley_1.Logger.logInfo(loggerCategory, `this._wasSourceIModelCopiedToTarget=${this._options.wasSourceIModelCopiedToTarget}`);
-        core_bentley_1.Logger.logInfo(loggerCategory, `this._isReverseSynchronization=${this._options.isReverseSynchronization}`);
-        core_bentley_1.Logger.logInfo(TransformerLoggerCategory_1.TransformerLoggerCategory.IModelImporter, `this.importer.autoExtendProjectExtents=${this.importer.options.autoExtendProjectExtents}`);
+        core_bentley_1.Logger.logInfo(loggerCategory, 
+        // eslint-disable-next-line deprecation/deprecation
+        `this._isReverseSynchronization=${this._options.isReverseSynchronization}`);
+        core_bentley_1.Logger.logInfo(TransformerLoggerCategory_1.TransformerLoggerCategory.IModelImporter, `this.importer.autoExtendProjectExtents=${JSON.stringify(this.importer.options.autoExtendProjectExtents)}`);
         core_bentley_1.Logger.logInfo(TransformerLoggerCategory_1.TransformerLoggerCategory.IModelImporter, `this.importer.simplifyElementGeometry=${this.importer.options.simplifyElementGeometry}`);
     }
     /** Return the IModelDb where IModelTransformer will store its provenance.
@@ -455,29 +456,30 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             forceOldRelationshipProvenanceMethod: this._forceOldRelationshipProvenanceMethod,
         });
     }
-    /** the changeset in the scoping element's source version found for this transformation
-     * @note: the version depends on whether this is a reverse synchronization or not, as
-     * it is stored separately for both synchronization directions.
-     * @note: must call [[initScopeProvenance]] before using this property.
-     * @note: empty string and -1 for changeset and index if it has never been transformed or was transformed before federation guid update (pre 1.x).
+    /**
+     * As of itwinjs 4.6.0, definitionContainers are now deleted as if they were DefinitionPartitions as opposed to Definitions.
+     * This variable being true will be used to special case the deletion of DefinitionContainers the same way DefinitionPartitions are deleted.
      */
-    get _synchronizationVersion() {
-        if (!this._cachedSynchronizationVersion) {
-            nodeAssert(this._targetScopeProvenanceProps, "_targetScopeProvenanceProps was not set yet");
-            const version = this.isReverseSynchronization
-                ? this._targetScopeProvenanceProps.jsonProperties?.reverseSyncVersion
-                : this._targetScopeProvenanceProps.version;
-            nodeAssert(version !== undefined, "no version contained in target scope");
-            const [id, index] = version === "" ? ["", -1] : version.split(";");
-            this._cachedSynchronizationVersion = { index: Number(index), id };
-            nodeAssert(!Number.isNaN(this._cachedSynchronizationVersion.index), "bad parse: invalid index in version");
+    get hasDefinitionContainerDeletionFeature() {
+        if (this._hasDefinitionContainerDeletionFeature === undefined) {
+            this._hasDefinitionContainerDeletionFeature = Semver.satisfies(coreBackendPkgJson.version, "^4.6.0");
         }
-        return this._cachedSynchronizationVersion;
+        return this._hasDefinitionContainerDeletionFeature;
+    }
+    /**
+     * We cache the synchronization version to avoid querying the target scoping ESA multiple times.
+     * If the target scoping ESA is ever updated we need to clear any potentially cached sync version otherwise we will get stale values.
+     * Sets this._cachedSynchronizationVersion to undefined.
+     */
+    clearCachedSynchronizationVersion() {
+        this._cachedSynchronizationVersion = undefined;
     }
     /** the changeset in the scoping element's source version found for this transformation
-     * @note: the version depends on whether this is a reverse synchronization or not, as
+     * @note the version depends on whether this is a reverse synchronization or not, as
      * it is stored separately for both synchronization directions.
-     * @note: empty string and -1 for changeset and index if it has never been transformed, or was transformed before federation guid update (pre 1.x).
+     * @note empty string and -1 for changeset and index if it has never been transformed
+     * @note empty string and -1 for changeset and index if it was transformed before federation guid update (pre 1.x) and @see [[IModelTransformOptions.branchRelationshipDataBehavior]] === "unsafe-migrate".
+     * @throws if the version is not found in a preexisting scope aspect and @see [[IModelTransformOptions.branchRelationshipDataBehavior]] !== "unsafe-migrate"
      */
     get synchronizationVersion() {
         if (this._cachedSynchronizationVersion === undefined) {
@@ -488,10 +490,15 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             const version = this.isReverseSynchronization
                 ? JSON.parse(provenanceScopeAspect.jsonProperties ?? "{}").reverseSyncVersion
                 : provenanceScopeAspect.version;
-            if (!version) {
+            if (!version &&
+                this._options.branchRelationshipDataBehavior === "unsafe-migrate") {
                 return { index: -1, id: "" }; // previous synchronization was done before fed guid update.
             }
-            const [id, index] = version.split(";");
+            if (version === undefined) {
+                throw new Error(`Could not find synchronization version in scope aspect. This may be due to the last successful run of the transformer being done with an older version.
+         Consider running the transformer with branchRelationshipDataBehavior set to 'unsafe-migrate'`);
+            }
+            const [id, index] = version === "" ? ["", -1] : version.split(";");
             if (Number.isNaN(Number(index)))
                 throw new Error("Could not parse version data from scope aspect");
             this._cachedSynchronizationVersion = { index: Number(index), id }; // synchronization version found and cached.
@@ -530,7 +537,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 id: this.targetScopeElementId,
                 relClassName: core_backend_1.ElementOwnsExternalSourceAspects.classFullName,
             },
-            scope: { id: core_common_1.IModel.rootSubjectId },
+            scope: { id: core_common_1.IModel.rootSubjectId }, // the root Subject scopes scope elements
             identifier: this.provenanceSourceDb.iModelId,
             kind: core_backend_1.ExternalSourceAspect.Kind.Scope,
             jsonProperties: undefined,
@@ -567,29 +574,81 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                     jsonProperties: JSON.stringify(aspectProps.jsonProperties),
                 });
                 aspectProps.id = id;
+                // Busting a potential cached version
+                this.clearCachedSynchronizationVersion();
             }
         }
         else {
             // foundEsaProps is defined.
             aspectProps.id = foundEsaProps.aspectId;
-            aspectProps.version =
-                foundEsaProps.version ??
-                    (this._options.branchRelationshipDataBehavior === "unsafe-migrate"
-                        ? ""
-                        : undefined);
+            aspectProps.version = foundEsaProps.version;
             aspectProps.jsonProperties = foundEsaProps.jsonProperties
                 ? JSON.parse(foundEsaProps.jsonProperties)
-                : this._options.branchRelationshipDataBehavior === "unsafe-migrate"
-                    ? {
-                        pendingReverseSyncChangesetIndices: [],
-                        pendingSyncChangesetIndices: [],
-                        reverseSyncVersion: "",
-                    }
-                    : undefined;
+                : undefined;
+            // Clone oldProps incase they're changed for logging purposes
+            const oldProps = JSON.parse(JSON.stringify(aspectProps));
+            if (this.handleUnsafeMigrate(aspectProps)) {
+                core_bentley_1.Logger.logInfo(loggerCategory, "Unsafe migrate made a change to the target scope's external source aspect. Updating aspect in database.", { oldProps, newProps: aspectProps });
+                this.provenanceDb.elements.updateAspect({
+                    ...aspectProps,
+                    jsonProperties: JSON.stringify(aspectProps.jsonProperties),
+                });
+                // Busting a potential cached version
+                this.clearCachedSynchronizationVersion();
+            }
         }
         this._targetScopeProvenanceProps =
             aspectProps;
     }
+    /** Returns true if a change was made to the aspectProps. */
+    handleUnsafeMigrate(aspectProps) {
+        let madeChange = false;
+        if (this._options.branchRelationshipDataBehavior !== "unsafe-migrate")
+            return madeChange;
+        const fallbackSyncVersionToUse = this._options.unsafeFallbackSyncVersion ?? "";
+        const fallbackReverseSyncVersionToUse = this._options.unsafeFallbackReverseSyncVersion ?? "";
+        if (aspectProps.version === undefined ||
+            (aspectProps.version === "" &&
+                aspectProps.version !== fallbackSyncVersionToUse)) {
+            aspectProps.version = fallbackSyncVersionToUse;
+            madeChange = true;
+        }
+        if (aspectProps.jsonProperties === undefined) {
+            aspectProps.jsonProperties = {
+                pendingReverseSyncChangesetIndices: [],
+                pendingSyncChangesetIndices: [],
+                reverseSyncVersion: fallbackReverseSyncVersionToUse,
+            };
+            madeChange = true;
+        }
+        else if (aspectProps.jsonProperties.reverseSyncVersion === undefined ||
+            (aspectProps.jsonProperties.reverseSyncVersion === "" &&
+                aspectProps.jsonProperties.reverseSyncVersion !==
+                    fallbackReverseSyncVersionToUse)) {
+            aspectProps.jsonProperties.reverseSyncVersion =
+                fallbackReverseSyncVersionToUse;
+            madeChange = true;
+        }
+        /**
+         * This case will only be hit when:
+         *  - first transformation was performed on pre-fedguid transformer.
+         *  - a second processAll transformation was performed on the same target-source iModels post-fedguid transformer.
+         *  - change processing was invoked on for the second 'initial' transformation.
+         *  NOTE: This case likely does not exist anymore, but we will keep it just to be sure.
+         */
+        if (aspectProps.jsonProperties.pendingReverseSyncChangesetIndices ===
+            undefined) {
+            core_bentley_1.Logger.logWarning(loggerCategory, "Property pendingReverseSyncChangesetIndices missing on the jsonProperties of the scoping ESA. Setting to [].");
+            aspectProps.jsonProperties.pendingReverseSyncChangesetIndices = [];
+            madeChange = true;
+        }
+        if (aspectProps.jsonProperties.pendingSyncChangesetIndices === undefined) {
+            core_bentley_1.Logger.logWarning(loggerCategory, "Property pendingSyncChangesetIndices missing on the jsonProperties of the scoping ESA. Setting to [].");
+            aspectProps.jsonProperties.pendingSyncChangesetIndices = [];
+            madeChange = true;
+        }
+        return madeChange;
+    }
     /**
      * Iterate all matching federation guids and ExternalSourceAspects in the provenance iModel (target unless reverse sync)
      * and call a function for each one.
@@ -688,6 +747,13 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             skipPropagateChangesToRootElements: this._options.skipPropagateChangesToRootElements ?? false,
         });
     }
+    /**
+     * Queries the provenanceDb for an ESA whose identifier is equal to the provided 'entityInProvenanceSourceId'.
+     * The identifier on the ESA is the id of the element in the [[IModelTransformer.provenanceSourceDb]]
+     * Therefore it only makes sense to call this function when you have an id in the provenanceSourceDb.
+     * @param entityInProvenanceSourceId
+     * @returns the elementId that the ESA is stored on, esa.Element.Id
+     */
     _queryProvenanceForElement(entityInProvenanceSourceId) {
         return this.provenanceDb.withPreparedStatement(`
         SELECT esa.Element.Id
@@ -705,6 +771,13 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 return undefined;
         });
     }
+    /**
+     * Queries the provenanceDb for an ESA whose identifier is equal to the provided 'entityInProvenanceSourceId'.
+     * The identifier on the ESA is the id of the relationship in the [[IModelTransformer.provenanceSourceDb]]
+     * Therefore it only makes sense to call this function when you have an id in the provenanceSourceDb.
+     * @param entityInProvenanceSourceId
+     * @returns
+     */
     _queryProvenanceForRelationship(entityInProvenanceSourceId, sourceRelInfo) {
         return this.provenanceDb.withPreparedStatement(`
         SELECT
@@ -850,6 +923,20 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     onTransformElement(sourceElement) {
         core_bentley_1.Logger.logTrace(loggerCategory, `onTransformElement(${sourceElement.id}) "${sourceElement.getDisplayLabel()}"`);
         const targetElementProps = this.context.cloneElement(sourceElement, { binaryGeometry: this._options.cloneUsingBinaryGeometry });
+        // Special case: source element is the root subject
+        if (sourceElement.id === core_common_1.IModel.rootSubjectId) {
+            const targetElementId = this.context.findTargetElementId(sourceElement.id);
+            // When remapping rootSubject from source to non root subject in target, the code.scope gets remapped incorrectly.
+            // This is because the rootSubject has no parent and its code.scope is unique in that it is the id of itself.
+            // For all other subjects which do have parents the code.scope and its parent should be in agreement.
+            if (targetElementId !== core_bentley_1.Id64.invalid &&
+                targetElementId !== core_common_1.IModel.rootSubjectId) {
+                const targetElement = this.targetDb.elements.getElement(targetElementId);
+                targetElementProps.parent =
+                    targetElement.parent ?? targetElementProps.parent;
+                targetElementProps.code.scope = targetElement.code.scope;
+            }
+        }
         if (sourceElement instanceof core_backend_1.Subject) {
             if (targetElementProps.jsonProperties?.Subject?.Job) {
                 // don't propagate source channels into target (legacy bridge case)
@@ -860,10 +947,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     }
     /** Returns true if a change within sourceElement is detected.
      * @param sourceElement The Element from the source iModel
-     * @param targetElementId The Element from the target iModel to compare against.
      * @note A subclass can override this method to provide custom change detection behavior.
      */
-    hasElementChanged(sourceElement, _targetElementId) {
+    hasElementChanged(sourceElement) {
         if (this._sourceChangeDataState === "no-changes")
             return false;
         if (this._sourceChangeDataState === "unconnected")
@@ -1098,8 +1184,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 }
             }
         }
-        if (core_bentley_1.Id64.isValid(targetElementId) &&
-            !this.hasElementChanged(sourceElement, targetElementId))
+        if (!this.hasElementChanged(sourceElement))
             return;
         this.collectUnmappedReferences(sourceElement);
         // targetElementId will be valid (indicating update) or undefined (indicating insert)
@@ -1168,7 +1253,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const targetModeledElementId = this.context.findTargetElementId(sourceModel.id);
         // there can only be one repositoryModel per database, so ignore the repo model on remapped subjects
         const isRemappedRootSubject = sourceModel.id === core_common_1.IModel.repositoryModelId &&
-            targetModeledElementId != sourceModel.id;
+            targetModeledElementId !== sourceModel.id;
         if (isRemappedRootSubject)
             return;
         const targetModelProps = this.onTransformModel(sourceModel, targetModeledElementId);
@@ -1183,13 +1268,28 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const targetModelId = this.context.findTargetElementId(sourceModelId);
         if (!core_bentley_1.Id64.isValidId64(targetModelId))
             return;
+        let sql;
+        if (this.hasDefinitionContainerDeletionFeature) {
+            sql = `
+      SELECT 1
+      FROM bis.DefinitionPartition
+      WHERE ECInstanceId=:targetModelId
+      UNION
+      SELECT 1
+      FROM bis.DefinitionContainer
+      WHERE ECInstanceId=:targetModelId
+    `;
+        }
+        else {
+            sql = `
+      SELECT 1
+      FROM bis.DefinitionPartition
+      WHERE ECInstanceId=:targetModelId
+    `;
+        }
         if (this.exporter.sourceDbChanges?.element.deleteIds.has(sourceModelId)) {
-            const isDefinitionPartition = this.targetDb.withPreparedStatement(`
-        SELECT 1
-        FROM bis.DefinitionPartition
-        WHERE ECInstanceId=?
-      `, (stmt) => {
-                stmt.bindId(1, targetModelId);
+            const isDefinitionPartition = this.targetDb.withPreparedStatement(sql, (stmt) => {
+                stmt.bindId("targetModelId", targetModelId);
                 const val = stmt.step();
                 switch (val) {
                     case core_bentley_1.DbResult.BE_SQLITE_ROW:
@@ -1197,7 +1297,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                     case core_bentley_1.DbResult.BE_SQLITE_DONE:
                         return false;
                     default:
-                        (0, core_bentley_1.assert)(false, `unexpected db result: '${stmt}'`);
+                        (0, core_bentley_1.assert)(false, `unexpected db result: '${JSON.stringify(stmt)}'`);
                 }
             });
             if (isDefinitionPartition) {
@@ -1303,7 +1403,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @deprecated in 3.x. This method is no longer necessary since the transformer no longer needs to defer elements
      */
     async processDeferredElements(_numRetries = 3) { }
-    /** called at the end ([[finalizeTransformation]]) of a transformation,
+    /** called at the end of a transformation,
      * updates the target scope element to say that transformation up through the
      * source's changeset has been performed. Also stores all changesets that occurred
      * during the transformation as "pending synchronization changeset indices" @see TargetScopeProvenanceJsonProps
@@ -1344,21 +1444,28 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             const jsonProps = this._targetScopeProvenanceProps.jsonProperties;
             core_bentley_1.Logger.logTrace(loggerCategory, `previous pendingReverseSyncChanges: ${jsonProps.pendingReverseSyncChangesetIndices}`);
             core_bentley_1.Logger.logTrace(loggerCategory, `previous pendingSyncChanges: ${jsonProps.pendingSyncChangesetIndices}`);
-            const [syncChangesetsToClear, syncChangesetsToUpdate] = this
+            const pendingSyncChangesetIndicesKey = "pendingSyncChangesetIndices";
+            const pendingReverseSyncChangesetIndicesKey = "pendingReverseSyncChangesetIndices";
+            const [syncChangesetsToClearKey, syncChangesetsToUpdateKey] = this
                 .isReverseSynchronization
                 ? [
-                    jsonProps.pendingReverseSyncChangesetIndices,
-                    jsonProps.pendingSyncChangesetIndices,
+                    pendingReverseSyncChangesetIndicesKey,
+                    pendingSyncChangesetIndicesKey,
                 ]
                 : [
-                    jsonProps.pendingSyncChangesetIndices,
-                    jsonProps.pendingReverseSyncChangesetIndices,
+                    pendingSyncChangesetIndicesKey,
+                    pendingReverseSyncChangesetIndicesKey,
                 ];
+            // NOTE that as documented in [[processChanges]], this assumes that right after
+            // transformation finalization, the work will be saved immediately, otherwise we've
+            // just marked this changeset as a synchronization to ignore, and the user can add other
+            // stuff to it which would break future synchronizations
             for (let i = this._startingChangesetIndices.target + 1; i <= this.targetDb.changeset.index + 1; i++)
-                syncChangesetsToUpdate.push(i);
-            // FIXME: add test to synchronize an iModel that is not at the tip, since then clearning syncChangesets is
-            // probably wrong, and we should filter it instead
-            syncChangesetsToClear.length = 0;
+                jsonProps[syncChangesetsToUpdateKey].push(i);
+            // Only keep the changeset indices which are greater than the source, this means they haven't been processed yet.
+            jsonProps[syncChangesetsToClearKey] = jsonProps[syncChangesetsToClearKey].filter((csIndex) => {
+                return csIndex > this._startingChangesetIndices.source;
+            });
             // if reverse sync then we may have received provenance changes which should be marked as sync changes
             if (this.isReverseSynchronization) {
                 nodeAssert(this.sourceDb.changeset.index !== undefined, "changeset didn't exist");
@@ -1372,9 +1479,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             ...this._targetScopeProvenanceProps,
             jsonProperties: JSON.stringify(this._targetScopeProvenanceProps.jsonProperties),
         });
+        this.clearCachedSynchronizationVersion();
     }
     // FIXME<MIKE>: is this necessary when manually using low level transform APIs? (document if so)
-    async finalizeTransformation(options) {
+    finalizeTransformation() {
         this.importer.finalize();
         this.updateSynchronizationVersion();
         if (this._partiallyCommittedEntities.size > 0) {
@@ -1403,31 +1511,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             this.targetDb.codeValueBehavior = "trim-unicode-whitespace";
         }
         /* eslint-enable @itwin/no-internal */
-        const defaultSaveTargetChanges = () => this.targetDb.saveChanges();
-        await (options?.saveTargetChanges ?? defaultSaveTargetChanges)(this);
-        if (this.isReverseSynchronization)
-            this.sourceDb.saveChanges();
-        const description = `${this._isProvenanceInitTransform
-            ? options?.provenanceInitTransformChangesetDescription ??
-                `initialized branch provenance with master iModel: ${this.sourceDb.iModelId}`
-            : this.isForwardSynchronization
-                ? options?.forwardSyncBranchChangesetDescription ??
-                    `Forward sync of iModel: ${this.sourceDb.iModelId}`
-                : options?.reverseSyncMasterChangesetDescription ??
-                    `Reverse sync of iModel: ${this.sourceDb.iModelId}`}`;
-        if (this.targetDb.isBriefcaseDb()) {
-            // This relies on authorizationClient on iModelHost being defined, otherwise this will fail
-            await this.targetDb.pushChanges({
-                description,
-            });
-        }
-        if (this.isReverseSynchronization && this.sourceDb.isBriefcaseDb()) {
-            // This relies on authorizationClient on iModelHost being defined, otherwise this will fail
-            await this.sourceDb.pushChanges({
-                description: options?.reverseSyncBranchChangesetDescription ??
-                    `Update provenance in response to a reverse sync to iModel: ${this.targetDb.iModelId}`,
-            });
-        }
     }
     /** Imports all relationships that subclass from the specified base class.
      * @param baseRelClassFullName The specified base relationship class.
@@ -1479,15 +1562,16 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             core_bentley_1.Logger.logWarning(loggerCategory, "tried to delete a relationship that wasn't in change data");
             return;
         }
-        const relArg = deletedRelData.relId ??
-            {
+        const id = deletedRelData.relId ??
+            this.targetDb.relationships.tryGetInstance(deletedRelData.classFullName, {
                 sourceId: deletedRelData.sourceIdInTarget,
                 targetId: deletedRelData.targetIdInTarget,
-            };
-        // FIXME: make importer.deleteRelationship not need full props
-        const targetRelationship = this.targetDb.relationships.tryGetInstance(deletedRelData.classFullName, relArg);
-        if (targetRelationship) {
-            this.importer.deleteRelationship(targetRelationship.toJSON());
+            })?.id;
+        if (id) {
+            this.importer.deleteRelationship({
+                id,
+                classFullName: deletedRelData.classFullName,
+            });
         }
         if (deletedRelData.provenanceAspectId) {
             try {
@@ -1531,8 +1615,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                     const json = JSON.parse(statement.getValue(2).getString());
                     const targetRelInstanceId = json.targetRelInstanceId ?? json.provenanceRelInstanceId;
                     if (targetRelInstanceId) {
-                        const targetRelationship = this.targetDb.relationships.getInstance(core_backend_1.ElementRefersToElements.classFullName, targetRelInstanceId);
-                        this.importer.deleteRelationship(targetRelationship.toJSON());
+                        this.importer.deleteRelationship({
+                            id: targetRelInstanceId,
+                            classFullName: core_backend_1.ElementRefersToElements.classFullName,
+                        });
                     }
                     aspectDeleteIds.push(statement.getValue(0).getId());
                 }
@@ -1629,7 +1715,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         let schemaFileName = schema.name + ext;
         // many file systems have a max file-name/path-segment size of 255, so we workaround that on all systems
         const systemMaxPathSegmentSize = 255;
-        if (schemaFileName.length > systemMaxPathSegmentSize) {
+        // windows usually has a limit for the total path length of 260
+        const windowsMaxPathLimit = 260;
+        if (schemaFileName.length > systemMaxPathSegmentSize ||
+            path.join(this._schemaExportDir, schemaFileName).length >=
+                windowsMaxPathLimit) {
             // this name should be well under 255 bytes
             // ( 100 + (Number.MAX_SAFE_INTEGER.toString().length = 16) + (ext.length = 13) ) = 129 which is less than 255
             // You'd have to be past 2**53-1 (Number.MAX_SAFE_INTEGER) long named schemas in order to hit decimal formatting,
@@ -1763,6 +1853,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         for await (const row of this.sourceDb.createQueryReader("SELECT ECInstanceId FROM ECDbMeta.ECClassDef where ECInstanceId IS (BisCore.ElementRefersToElements)")) {
             relationshipECClassIds.add(row.ECInstanceId);
         }
+        const elementECClassIds = new Set();
+        for await (const row of this.sourceDb.createQueryReader("SELECT ECInstanceId FROM ECDbMeta.ECClassDef where ECInstanceId IS (BisCore.Element)")) {
+            elementECClassIds.add(row.ECInstanceId);
+        }
         // For later use when processing deletes.
         const alreadyImportedElementInserts = new Set();
         const alreadyImportedModelInserts = new Set();
@@ -1801,7 +1895,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                     change.Scope.Id === this.targetScopeElementId) {
                     elemIdToScopeEsa.set(change.Element.Id, change);
                 }
-                else if (changeType === "Inserted" || changeType === "Updated")
+                else if ((changeType === "Inserted" || changeType === "Updated") &&
+                    change.ECClassId !== undefined &&
+                    elementECClassIds.has(change.ECClassId))
                     hasElementChangedCache.add(change.ECInstanceId);
             }
             // Loop to process deletes.
@@ -1815,7 +1911,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 if (changeType !== "Deleted" ||
                     relationshipECClassIdsToSkip.has(ecClassId))
                     continue;
-                this.processDeletedOp(change, elemIdToScopeEsa, relationshipECClassIds.has(ecClassId ?? ""), alreadyImportedElementInserts, alreadyImportedModelInserts);
+                await this.processDeletedOp(change, elemIdToScopeEsa, relationshipECClassIds.has(ecClassId ?? ""), alreadyImportedElementInserts, alreadyImportedModelInserts);
             }
             csReader.close();
         }
@@ -1832,116 +1928,98 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @param alreadyImportedModelInserts used to handle entity recreation and not delete already handled model inserts.
      * @returns void
      */
-    processDeletedOp(change, mapOfDeletedElemIdToScopeEsas, isRelationship, alreadyImportedElementInserts, alreadyImportedModelInserts) {
+    async processDeletedOp(change, mapOfDeletedElemIdToScopeEsas, isRelationship, alreadyImportedElementInserts, alreadyImportedModelInserts) {
         // we need a connected iModel with changes to remap elements with deletions
         const notConnectedModel = this.sourceDb.iTwinId === undefined;
-        const noChanges = this._synchronizationVersion.index === this.sourceDb.changeset.index;
+        const noChanges = this.synchronizationVersion.index === this.sourceDb.changeset.index;
         if (notConnectedModel || noChanges)
             return;
-        // optimization: if we have provenance, use it to avoid more querying later
-        // eventually when itwin.js supports attaching a second iModelDb in JS,
-        // this won't have to be a conditional part of the query, and we can always have it by attaching
-        const queryCanAccessProvenance = this.sourceDb === this.provenanceDb;
-        const instId = change.ECInstanceId;
-        if (!isRelationship) {
-            const sourceElemFedGuid = change.FederationGuid;
+        /**
+         * if our ChangedECInstance is in the provenanceDb, then we can use the ids we find in the ChangedECInstance to query for ESAs.
+         * This is because the ESAs are stored on an element Id thats present in the provenanceDb.
+         */
+        const changeDataInProvenanceDb = this.sourceDb === this.provenanceDb;
+        const getTargetIdFromSourceId = async (id) => {
             let identifierValue;
-            if (queryCanAccessProvenance) {
-                const aspects = this.sourceDb.elements.getAspects(instId, core_backend_1.ExternalSourceAspect.classFullName);
-                for (const aspect of aspects) {
-                    // look for aspect where the ecInstanceId = the aspect.element.id
-                    if (aspect.element.id === instId &&
-                        aspect.scope.id === this.targetScopeElementId)
-                        identifierValue = aspect.identifier;
+            let element;
+            if (isRelationship) {
+                element = this.sourceDb.elements.tryGetElement(id);
+            }
+            const fedGuid = isRelationship
+                ? element?.federationGuid
+                : change.FederationGuid;
+            if (changeDataInProvenanceDb) {
+                // TODO: clarify what happens if there are multiple (e.g. elements were merged)
+                for await (const row of this.sourceDb.createQueryReader("SELECT esa.Identifier FROM bis.ExternalSourceAspect esa WHERE Scope.Id=:scopeId AND Kind=:kind AND Element.Id=:relatedElementId LIMIT 1", core_common_1.QueryBinder.from([
+                    this.targetScopeElementId,
+                    core_backend_1.ExternalSourceAspect.Kind.Element,
+                    id,
+                ]))) {
+                    identifierValue = row.Identifier;
                 }
-                // Think I need to query the esas given the instId.. not sure what db to do it on though.. soruce or target.. or provenance?
-                // I need to know the id of the element dpeneding on which db its stored in.
+                identifierValue =
+                    identifierValue ?? mapOfDeletedElemIdToScopeEsas.get(id)?.Identifier;
             }
-            if (queryCanAccessProvenance && !identifierValue) {
-                if (mapOfDeletedElemIdToScopeEsas.get(instId) !== undefined)
-                    identifierValue =
-                        mapOfDeletedElemIdToScopeEsas.get(instId).Identifier;
+            // Check for targetId by an esa first
+            if (changeDataInProvenanceDb && identifierValue) {
+                const targetId = identifierValue;
+                return targetId;
             }
-            const targetId = (queryCanAccessProvenance && identifierValue) ||
-                // maybe batching these queries would perform better but we should
-                // try to attach the second db and query both together anyway
-                (sourceElemFedGuid &&
-                    this._queryElemIdByFedGuid(this.targetDb, sourceElemFedGuid)) ||
-                // FIXME<MIKE>: describe why it's safe to assume nothing has been deleted in provenanceDb
-                this._queryProvenanceForElement(instId);
-            // since we are processing one changeset at a time, we can see local source deletes
-            // of entities that were never synced and can be safely ignored
-            const deletionNotInTarget = !targetId;
-            if (deletionNotInTarget)
-                return;
-            this.context.remapElement(instId, targetId);
-            // If an entity insert and an entity delete both point to the same entity in target iModel, that means that entity was recreated.
-            // In such case an entity update will be triggered and we no longer need to delete the entity.
-            if (alreadyImportedElementInserts.has(targetId)) {
-                this.exporter.sourceDbChanges?.element.deleteIds.delete(instId);
-            }
-            if (alreadyImportedModelInserts.has(targetId)) {
-                this.exporter.sourceDbChanges?.model.deleteIds.delete(instId);
+            // Check for targetId using sourceId's fedguid if we didn't find an esa.
+            if (fedGuid) {
+                const targetId = this._queryElemIdByFedGuid(this.targetDb, fedGuid);
+                return targetId;
             }
-        }
-        else {
-            // is deleted relationship
-            const classFullName = change.$meta?.classFullName;
+            return undefined;
+        };
+        const changedInstanceId = change.ECInstanceId;
+        if (isRelationship) {
             const sourceIdOfRelationshipInSource = change.SourceECInstanceId;
             const targetIdOfRelationshipInSource = change.TargetECInstanceId;
-            const [sourceIdInTarget, targetIdInTarget] = [
-                sourceIdOfRelationshipInSource,
-                targetIdOfRelationshipInSource,
-            ].map((id) => {
-                let element;
-                try {
-                    element = this.sourceDb.elements.getElement(id);
-                }
-                catch (err) {
-                    return undefined;
-                }
-                const fedGuid = element.federationGuid;
-                let identifierValue;
-                if (queryCanAccessProvenance) {
-                    const aspects = this.sourceDb.elements.getAspects(id, core_backend_1.ExternalSourceAspect.classFullName);
-                    for (const aspect of aspects) {
-                        if (aspect.element.id === id &&
-                            aspect.scope.id === this.targetScopeElementId)
-                            identifierValue = aspect.identifier;
-                    }
-                    if (identifierValue === undefined) {
-                        if (mapOfDeletedElemIdToScopeEsas.get(id) !== undefined)
-                            identifierValue =
-                                mapOfDeletedElemIdToScopeEsas.get(id).Identifier;
-                    }
-                }
-                return ((queryCanAccessProvenance && identifierValue) ||
-                    // maybe batching these queries would perform better but we should
-                    // try to attach the second db and query both together anyway
-                    (fedGuid && this._queryElemIdByFedGuid(this.targetDb, fedGuid)));
-            });
-            if (sourceIdInTarget && targetIdInTarget) {
-                this._deletedSourceRelationshipData.set(instId, {
+            const classFullName = change.$meta?.classFullName;
+            const sourceIdOfRelationshipInTarget = await getTargetIdFromSourceId(sourceIdOfRelationshipInSource);
+            const targetIdOfRelationshipInTarget = await getTargetIdFromSourceId(targetIdOfRelationshipInSource);
+            if (sourceIdOfRelationshipInTarget && targetIdOfRelationshipInTarget) {
+                this._deletedSourceRelationshipData.set(changedInstanceId, {
                     classFullName: classFullName ?? "",
-                    sourceIdInTarget,
-                    targetIdInTarget,
+                    sourceIdInTarget: sourceIdOfRelationshipInTarget,
+                    targetIdInTarget: targetIdOfRelationshipInTarget,
                 });
             }
-            else {
-                // FIXME<MIKE>: describe why it's safe to assume nothing has been deleted in provenanceDb
-                const relProvenance = this._queryProvenanceForRelationship(instId, {
+            else if (this.sourceDb === this.provenanceSourceDb) {
+                const relProvenance = this._queryProvenanceForRelationship(changedInstanceId, {
                     classFullName: classFullName ?? "",
                     sourceId: sourceIdOfRelationshipInSource,
                     targetId: targetIdOfRelationshipInSource,
                 });
                 if (relProvenance && relProvenance.relationshipId)
-                    this._deletedSourceRelationshipData.set(instId, {
+                    this._deletedSourceRelationshipData.set(changedInstanceId, {
                         classFullName: classFullName ?? "",
                         relId: relProvenance.relationshipId,
                         provenanceAspectId: relProvenance.aspectId,
                     });
             }
         }
+        else {
+            let targetId = await getTargetIdFromSourceId(changedInstanceId);
+            if (targetId === undefined && this.sourceDb === this.provenanceSourceDb) {
+                targetId = this._queryProvenanceForElement(changedInstanceId);
+            }
+            // since we are processing one changeset at a time, we can see local source deletes
+            // of entities that were never synced and can be safely ignored
+            const deletionNotInTarget = !targetId;
+            if (deletionNotInTarget)
+                return;
+            this.context.remapElement(changedInstanceId, targetId);
+            // If an entity insert and an entity delete both point to the same entity in target iModel, that means that entity was recreated.
+            // In such case an entity update will be triggered and we no longer need to delete the entity.
+            if (alreadyImportedElementInserts.has(targetId)) {
+                this.exporter.sourceDbChanges?.element.deleteIds.delete(changedInstanceId);
+            }
+            if (alreadyImportedModelInserts.has(targetId)) {
+                this.exporter.sourceDbChanges?.model.deleteIds.delete(changedInstanceId);
+            }
+        }
     }
     async _tryInitChangesetData(args) {
         if (!args ||
@@ -1950,7 +2028,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             this._sourceChangeDataState = "unconnected";
             return;
         }
-        const noChanges = this._synchronizationVersion.index === this.sourceDb.changeset.index;
+        const noChanges = this.synchronizationVersion.index === this.sourceDb.changeset.index;
         if (noChanges) {
             this._sourceChangeDataState = "no-changes";
             this._csFileProps = [];
@@ -1960,7 +2038,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         // to ignore those already processed changes
         const startChangesetIndexOrId = args.startChangeset?.index ??
             args.startChangeset?.id ??
-            this._synchronizationVersion.index + 1;
+            this.synchronizationVersion.index + 1;
         const endChangesetId = this.sourceDb.changeset.id;
         const [startChangesetIndex, endChangesetIndex] = await Promise.all([startChangesetIndexOrId, endChangesetId].map(async (indexOrId) => typeof indexOrId === "number"
             ? indexOrId
@@ -1972,17 +2050,17 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 accessToken: args.accessToken,
             })
                 .then((changeset) => changeset.index)));
-        const missingChangesets = startChangesetIndex > this._synchronizationVersion.index + 1;
+        const missingChangesets = startChangesetIndex > this.synchronizationVersion.index + 1;
         if (!this._options.ignoreMissingChangesetsInSynchronizations &&
-            startChangesetIndex !== this._synchronizationVersion.index + 1 &&
-            this._synchronizationVersion.index !== -1) {
+            startChangesetIndex !== this.synchronizationVersion.index + 1 &&
+            this.synchronizationVersion.index !== -1) {
             throw Error(`synchronization is ${missingChangesets ? "missing changesets" : ""},` +
                 " startChangesetId should be" +
                 " exactly the first changeset *after* the previous synchronization to not miss data." +
                 ` You specified '${startChangesetIndexOrId}' which is changeset #${startChangesetIndex}` +
-                ` but the previous synchronization for this targetScopeElement was '${this._synchronizationVersion.id}'` +
-                ` which is changeset #${this._synchronizationVersion.index}. The transformer expected` +
-                ` #${this._synchronizationVersion.index + 1}.`);
+                ` but the previous synchronization for this targetScopeElement was '${this.synchronizationVersion.id}'` +
+                ` which is changeset #${this.synchronizationVersion.index}. The transformer expected` +
+                ` #${this.synchronizationVersion.index + 1}.`);
         }
         nodeAssert(this._targetScopeProvenanceProps, "_targetScopeProvenanceProps should be set by now");
         const changesetsToSkip = this.isReverseSynchronization
@@ -2004,19 +2082,20 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             csFileProps.push(...fileProps);
         }
         this._csFileProps = csFileProps;
-        this._sourceChangeDataState = "has-changes";
+        /** Theres a possibility that our csFileProps length is still 0 here, since we skip cs indices found in the pendingSync and pendingReverseSync indices arrays. */
+        this._sourceChangeDataState =
+            this._csFileProps.length === 0 ? "no-changes" : "has-changes";
     }
     /** Export everything from the source iModel and import the transformed entities into the target iModel.
      * @note [[processSchemas]] is not called automatically since the target iModel may want a different collection of schemas.
      */
-    async processAll(options) {
+    async processAll() {
         this.logSettings();
         this.initScopeProvenance();
         await this.initialize();
         await this.exporter.exportCodeSpecs();
         await this.exporter.exportFonts();
         if (this._options.skipPropagateChangesToRootElements) {
-            // FIXME<NICK>: This option in exportAll was a maybe.
             // The RepositoryModel and root Subject of the target iModel should not be transformed.
             await this.exporter.exportChildElements(core_common_1.IModel.rootSubjectId); // start below the root Subject
             await this.exporter.exportModelContents(core_common_1.IModel.repositoryModelId, core_backend_1.Element.classFullName, true); // after the Subject hierarchy, process the other elements of the RepositoryModel
@@ -2030,13 +2109,15 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         await this.processDeferredElements(); // eslint-disable-line deprecation/deprecation
         if (this._options.forceExternalSourceAspectProvenance &&
             this.shouldDetectDeletes()) {
+            // eslint-disable-next-line deprecation/deprecation
             await this.detectElementDeletes();
+            // eslint-disable-next-line deprecation/deprecation
             await this.detectRelationshipDeletes();
         }
         if (this._options.optimizeGeometry)
             this.importer.optimizeGeometry(this._options.optimizeGeometry);
         this.importer.computeProjectExtents();
-        await this.finalizeTransformation(options);
+        this.finalizeTransformation();
     }
     markLastProvenance(sourceAspect, { isRelationship = false }) {
         this._lastProvenanceEntityInfo =
@@ -2051,205 +2132,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                         : core_backend_1.ExternalSourceAspect.Kind.Element,
                 };
     }
-    /**
-     * Load the state of the active transformation from an open SQLiteDb
-     * You can override this if you'd like to load from custom tables in the resumable dump state, but you should call
-     * this super implementation
-     * @note the SQLiteDb must be open
-     */
-    loadStateFromDb(db) {
-        const lastProvenanceEntityInfo = db.withSqliteStatement(`SELECT entityId, aspectId, aspectVersion, aspectKind FROM ${IModelTransformer.lastProvenanceEntityInfoTable}`, (stmt) => {
-            if (core_bentley_1.DbResult.BE_SQLITE_ROW !== stmt.step())
-                throw Error("expected row when getting lastProvenanceEntityId from target state table");
-            const entityId = stmt.getValueString(0);
-            const isGuidOrGuidPair = entityId.includes("-");
-            return isGuidOrGuidPair
-                ? entityId
-                : {
-                    entityId,
-                    aspectId: stmt.getValueString(1),
-                    aspectVersion: stmt.getValueString(2),
-                    aspectKind: stmt.getValueString(3),
-                };
-        });
-        /*
-        // TODO: maybe save transformer state resumption state based on target changset and require calls
-        // to saveChanges
-        if () {
-          const [sourceFedGuid, targetFedGuid, relClassFullName] = lastProvenanceEntityInfo.split("/");
-          const isRelProvenance = targetFedGuid !== undefined;
-          const instanceId = isRelProvenance
-            ? this.targetDb.elements.getElement({federationGuid: sourceFedGuid})
-            : "";
-          //const classId =
-          if (isRelProvenance) {
-          }
-        }
-        */
-        const targetHasCorrectLastProvenance = typeof lastProvenanceEntityInfo === "string" ||
-            // ignore provenance check if it's null since we can't bind those ids
-            !core_bentley_1.Id64.isValidId64(lastProvenanceEntityInfo.entityId) ||
-            !core_bentley_1.Id64.isValidId64(lastProvenanceEntityInfo.aspectId) ||
-            this.provenanceDb.withPreparedStatement(`
-        SELECT Version FROM ${core_backend_1.ExternalSourceAspect.classFullName}
-        WHERE Scope.Id=:scopeId
-          AND ECInstanceId=:aspectId
-          AND Kind=:kind
-          AND Element.Id=:entityId
-      `, (statement) => {
-                statement.bindId("scopeId", this.targetScopeElementId);
-                statement.bindId("aspectId", lastProvenanceEntityInfo.aspectId);
-                statement.bindString("kind", lastProvenanceEntityInfo.aspectKind);
-                statement.bindId("entityId", lastProvenanceEntityInfo.entityId);
-                const stepResult = statement.step();
-                switch (stepResult) {
-                    case core_bentley_1.DbResult.BE_SQLITE_ROW:
-                        const version = statement.getValue(0).getString();
-                        return version === lastProvenanceEntityInfo.aspectVersion;
-                    case core_bentley_1.DbResult.BE_SQLITE_DONE:
-                        return false;
-                    default:
-                        throw new core_common_1.IModelError(core_bentley_1.IModelStatus.SQLiteError, `got sql error ${stepResult}`);
-                }
-            });
-        if (!targetHasCorrectLastProvenance)
-            throw Error([
-                "Target for resuming from does not have the expected provenance ",
-                "from the target that the resume state was made with",
-            ].join("\n"));
-        this._lastProvenanceEntityInfo = lastProvenanceEntityInfo;
-        const state = db.withSqliteStatement(`SELECT data FROM ${IModelTransformer.jsStateTable}`, (stmt) => {
-            if (core_bentley_1.DbResult.BE_SQLITE_ROW !== stmt.step())
-                throw Error("expected row when getting data from js state table");
-            return JSON.parse(stmt.getValueString(0));
-        });
-        if (state.transformerClass !== this.constructor.name)
-            throw Error("resuming from a differently named transformer class, it is not necessarily valid to resume with a different transformer class");
-        // force assign to readonly options since we do not know how the transformer subclass takes options to pass to the superclass
-        this._options = state.options;
-        this.context.loadStateFromDb(db);
-        this.importer.loadStateFromJson(state.importerState);
-        this.exporter.loadStateFromJson(state.exporterState);
-        this._elementsWithExplicitlyTrackedProvenance =
-            core_bentley_1.CompressedId64Set.decompressSet(state.explicitlyTrackedElements);
-        this.loadAdditionalStateJson(state.additionalState);
-    }
-    /**
-     * @deprecated in 0.1.x, this is buggy, and it is now equivalently efficient to simply restart the transformation
-     * from the original changeset
-     *
-     * Return a new transformer instance with the same remappings state as saved from a previous [[IModelTransformer.saveStateToFile]] call.
-     * This allows you to "resume" an iModel transformation, you will have to call [[IModelTransformer.processChanges]]/[[IModelTransformer.processAll]]
-     * again but the remapping state will cause already mapped elements to be skipped.
-     * To "resume" an iModel Transformation you need:
-     * - the sourceDb at the same changeset
-     * - the same targetDb in the state in which it was before
-     * @param statePath the path to the serialized state of the transformer, use [[IModelTransformer.saveStateToFile]] to get this from an existing transformer instance
-     * @param constructorArgs remaining arguments that you would normally pass to the Transformer subclass you are using, usually (sourceDb, targetDb)
-     * @note custom transformers with custom state may need to override this method in order to handle loading their own custom state somewhere
-     */
-    static resumeTransformation(statePath, ...constructorArgs) {
-        const transformer = new this(...constructorArgs);
-        const db = new core_backend_1.SQLiteDb();
-        db.openDb(statePath, core_bentley_1.OpenMode.Readonly);
-        try {
-            transformer.loadStateFromDb(db);
-        }
-        finally {
-            db.closeDb();
-        }
-        return transformer;
-    }
-    /**
-     * You may override this to store arbitrary json state in a transformer state dump, useful for some resumptions
-     * @see [[IModelTransformer.saveStateToFile]]
-     */
-    getAdditionalStateJson() {
-        return {};
-    }
-    /**
-     * You may override this to load arbitrary json state in a transformer state dump, useful for some resumptions
-     * @see [[IModelTransformer.loadStateFromFile]]
-     */
-    loadAdditionalStateJson(_additionalState) { }
-    /**
-     * Save the state of the active transformation to an open SQLiteDb
-     * You can override this if you'd like to write custom tables to the resumable dump state, but you should call
-     * this super implementation
-     * @note the SQLiteDb must be open
-     */
-    saveStateToDb(db) {
-        const jsonState = {
-            transformerClass: this.constructor.name,
-            options: this._options,
-            explicitlyTrackedElements: core_bentley_1.CompressedId64Set.compressSet(this._elementsWithExplicitlyTrackedProvenance),
-            importerState: this.importer.saveStateToJson(),
-            exporterState: this.exporter.saveStateToJson(),
-            additionalState: this.getAdditionalStateJson(),
-        };
-        this.context.saveStateToDb(db);
-        if (core_bentley_1.DbResult.BE_SQLITE_DONE !==
-            db.executeSQL(`CREATE TABLE ${IModelTransformer.jsStateTable} (data TEXT)`))
-            throw Error("Failed to create the js state table in the state database");
-        if (core_bentley_1.DbResult.BE_SQLITE_DONE !==
-            db.executeSQL(`
-      CREATE TABLE ${IModelTransformer.lastProvenanceEntityInfoTable} (
-        -- either the invalid id for null provenance state, federation guid (or pair for rels) of the entity, or a hex element id
-        entityId TEXT,
-        -- the following are only valid if the above entityId is a hex id representation
-        aspectId TEXT,
-        aspectVersion TEXT,
-        aspectKind TEXT
-      )
-    `))
-            throw Error("Failed to create the target state table in the state database");
-        db.saveChanges();
-        db.withSqliteStatement(`INSERT INTO ${IModelTransformer.jsStateTable} (data) VALUES (?)`, (stmt) => {
-            stmt.bindString(1, JSON.stringify(jsonState));
-            if (core_bentley_1.DbResult.BE_SQLITE_DONE !== stmt.step())
-                throw Error("Failed to insert options into the state database");
-        });
-        db.withSqliteStatement(`INSERT INTO ${IModelTransformer.lastProvenanceEntityInfoTable} (entityId, aspectId, aspectVersion, aspectKind) VALUES (?,?,?,?)`, (stmt) => {
-            const lastProvenanceEntityInfo = this
-                ._lastProvenanceEntityInfo;
-            stmt.bindString(1, lastProvenanceEntityInfo?.entityId ??
-                this._lastProvenanceEntityInfo);
-            stmt.bindString(2, lastProvenanceEntityInfo?.aspectId ?? "");
-            stmt.bindString(3, lastProvenanceEntityInfo?.aspectVersion ?? "");
-            stmt.bindString(4, lastProvenanceEntityInfo?.aspectKind ?? "");
-            if (core_bentley_1.DbResult.BE_SQLITE_DONE !== stmt.step())
-                throw Error("Failed to insert options into the state database");
-        });
-        db.saveChanges();
-    }
-    /**
-     * @deprecated in 0.1.x, this is buggy, and it is now equivalently efficient to simply restart the transformation
-     * from the original changeset
-     *
-     * Save the state of the active transformation to a file path, if a file at the path already exists, it will be overwritten
-     * This state can be used by [[IModelTransformer.resumeTransformation]] to resume a transformation from this point.
-     * The serialization format is a custom sqlite database.
-     * @note custom transformers with custom state may override [[IModelTransformer.saveStateToDb]] or [[IModelTransformer.getAdditionalStateJson]]
-     *       and [[IModelTransformer.loadStateFromDb]] (with a super call) or [[IModelTransformer.loadAdditionalStateJson]]
-     *       if they have custom state that needs to be stored with
-     *       potentially inside the same sqlite file in separate tables
-     */
-    saveStateToFile(nativeStatePath) {
-        const db = new core_backend_1.SQLiteDb();
-        if (core_backend_1.IModelJsFs.existsSync(nativeStatePath))
-            core_backend_1.IModelJsFs.unlinkSync(nativeStatePath);
-        db.createDb(nativeStatePath);
-        try {
-            this.saveStateToDb(db);
-            db.saveChanges();
-        }
-        finally {
-            db.closeDb();
-        }
-    }
     /** Export changes from the source iModel and import the transformed entities into the target iModel.
      * Inserts, updates, and deletes are determined by inspecting the changeset(s).
-     * @note the transformer saves and pushes changes when its work is complete.
+     * @note the transformer assumes that you saveChanges after processing changes. You should not
+     * modify the iModel after processChanges until saveChanges, failure to do so may result in corrupted
+     * data loss in future branch operations
      * @note if no startChangesetId or startChangeset option is provided as part of the ProcessChangesOptions, the next unsynchronized changeset
      * will automatically be determined and used
      * @note To form a range of versions to process, set `startChangesetId` for the start (inclusive) of the desired range and open the source iModel as of the end (inclusive) of the desired range.
@@ -2265,7 +2152,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         if (this._options.optimizeGeometry)
             this.importer.optimizeGeometry(this._options.optimizeGeometry);
         this.importer.computeProjectExtents();
-        await this.finalizeTransformation(options);
+        this.finalizeTransformation();
+        const defaultSaveTargetChanges = () => {
+            this.targetDb.saveChanges();
+        };
+        await (options.saveTargetChanges ?? defaultSaveTargetChanges)(this);
     }
     /** Changeset data must be initialized in order to build correct changeOptions.
      * Call [[IModelTransformer.initialize]] for initialization of synchronization provenance data
@@ -2284,7 +2175,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                         ? { startChangeset: opts.startChangeset }
                         : {
                             startChangeset: {
-                                index: this._synchronizationVersion.index + 1,
+                                index: this.synchronizationVersion.index + 1,
                             },
                         }),
         };
@@ -2303,10 +2194,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
 }
 exports.IModelTransformer = IModelTransformer;
 IModelTransformer.noEsaSyncDirectionErrorMessage = "Couldn't find an external source aspect to determine sync direction. This often means that the master->branch relationship has not been established. Consider running the transformer with wasSourceIModelCopiedToTarget set to true.";
-/** @internal the name of the table where javascript state of the transformer is serialized in transformer state dumps */
-IModelTransformer.jsStateTable = "TransformerJsState";
-/** @internal the name of the table where the target state heuristics is serialized in transformer state dumps */
-IModelTransformer.lastProvenanceEntityInfoTable = "LastProvenanceEntityInfo";
 /** IModelTransformer that clones the contents of a template model.
  * @beta
  */