@itwin/imodel-transformer 2.0.0-dev.12 → 2.0.0-dev.13

package/lib/cjs/IModelTransformer.js

@@ -21,13 +21,9 @@ const TransformerLoggerCategory_1 = require("./TransformerLoggerCategory");
 const IModelCloneContext_1 = require("./IModelCloneContext");
 const EntityUnifier_1 = require("./EntityUnifier");
 const Algo_1 = require("./Algo");
+const SyncTypeResolver_1 = require("./SyncTypeResolver");
+const ProvenanceManager_1 = require("./ProvenanceManager");
 const loggerCategory = TransformerLoggerCategory_1.TransformerLoggerCategory.IModelTransformer;
-const nullLastProvenanceEntityInfo = {
-    entityId: core_bentley_1.Id64.invalid,
-    aspectId: core_bentley_1.Id64.invalid,
-    aspectVersion: "",
-    aspectKind: core_backend_1.ExternalSourceAspect.Kind.Element,
-};
 /**
  * Apply a function to each Id64 in a supported container type of Id64s.
  * Currently only supports raw Id64String or RelatedElement-like objects containing an `id` property that is a Id64String,
@@ -86,7 +82,8 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @beta
      */
     _linearSpatialTransform;
-    _syncType;
+    _syncTypeResolver;
+    _provenanceManager;
     /** The Id of the Element in the **target** iModel that represents the **source** repository as a whole and scopes its [ExternalSourceAspect]($backend) instances. */
     get targetScopeElementId() {
         return this._options.targetScopeElementId;
@@ -95,112 +92,15 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     _elementsWithExplicitlyTrackedProvenance = new Set();
     _partiallyCommittedElementIds = new Set();
     _partiallyCommittedAspectIds = new Set();
-    /** the options that were used to initialize this transformer */
-    _options;
-    /**
-     * A private variable meant to be set by tests which have an outdated way of setting up transforms. In all synchronizations today we expect to find an ESA in the branch db which describes the master -> branch relationship.
-     * The exception to this is the first transform aka the provenance initializing transform which requires that the master imodel and the branch imodel are identical at the time of provenance initialization.
-     * A couple ofoutdated tests run their first transform providing a source and targetdb that are slightly different which is no longer supported. In order to not remove these tests which are still providing value
-     * this private property on the IModelTransformer exists.
-     */
-    _allowNoScopingESA = false;
-    static 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.";
     /**
-     * Queries for an esa which matches the props in the provided aspectProps.
-     * @param dbToQuery db to run the query on for scope external source
-     * @param aspectProps aspectProps to search for @see ExternalSourceAspectProps
+     * Tracks target element IDs that were imported (inserted or updated) during the current
+     * transformation pass. Used to prevent deletion of target elements that have been remapped
+     * to a new source element in the same pass (e.g., when a source element is deleted and a
+     * new one with the same properties is added, causing a remap to the same target).
      */
-    static async queryScopeExternalSourceAspect(dbToQuery, aspectProps) {
-        const sql = `
-      SELECT ECInstanceId, Version, JsonProperties
-      FROM ${core_backend_1.ExternalSourceAspect.classFullName}
-      WHERE Element.Id=:elementId
-        AND Scope.Id=:scopeId
-        AND Kind=:kind
-        AND Identifier=:identifier
-      LIMIT 1
-    `;
-        if (aspectProps.scope === undefined)
-            return undefined;
-        const params = new core_common_1.QueryBinder()
-            .bindId("elementId", aspectProps.element.id)
-            .bindId("scopeId", aspectProps.scope.id)
-            .bindString("kind", aspectProps.kind)
-            .bindString("identifier", aspectProps.identifier);
-        return dbToQuery.withQueryReader(sql, (reader) => {
-            if (!reader.step())
-                return undefined;
-            const aspectId = reader.current[0];
-            const version = reader.current[1];
-            const jsonProperties = reader.current[2];
-            return { aspectId, version, jsonProperties };
-        }, params);
-    }
-    /**
-     * Determines the sync direction "forward" or "reverse" of a given sourceDb and targetDb by looking for the scoping ESA.
-     * If the sourceDb's iModelId is found as the identifier of the expected scoping ESA in the targetDb, then it is a forward synchronization.
-     * If the targetDb's iModelId is found as the identifier of the expected scoping ESA in the sourceDb, then it is a reverse synchronization.
-     * @throws if no scoping ESA can be found in either the sourceDb or targetDb which describes a master branch relationship between the two databases.
-     * @returns "forward" or "reverse"
-     */
-    static async determineSyncType(sourceDb, targetDb, 
-    /** @see [[IModelTransformOptions.targetScopeElementId]] */
-    targetScopeElementId) {
-        const aspectProps = {
-            id: undefined,
-            version: undefined,
-            classFullName: core_backend_1.ExternalSourceAspect.classFullName,
-            element: {
-                id: targetScopeElementId,
-                relClassName: core_backend_1.ElementOwnsExternalSourceAspects.classFullName,
-            },
-            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,
-        };
-        /** First check if the targetDb is the branch (branch is the @see provenanceDb) */
-        const esaPropsFromTargetDb = await this.queryScopeExternalSourceAspect(targetDb, aspectProps);
-        if (esaPropsFromTargetDb !== undefined) {
-            return "forward"; // we found an esa assuming targetDb is the provenanceDb/branch so this is a forward sync.
-        }
-        // Now check if the sourceDb is the branch
-        aspectProps.identifier = targetDb.iModelId;
-        const esaPropsFromSourceDb = await this.queryScopeExternalSourceAspect(sourceDb, aspectProps);
-        if (esaPropsFromSourceDb !== undefined) {
-            return "reverse"; // we found an esa assuming sourceDb is the provenanceDb/branch so this is a reverse sync.
-        }
-        throw new Error(this.noEsaSyncDirectionErrorMessage);
-    }
-    async determineSyncType() {
-        if (this._isProvenanceInitTransform) {
-            return "forward";
-        }
-        if (!this._options.argsForProcessChanges) {
-            return "not-sync";
-        }
-        try {
-            return await IModelTransformer.determineSyncType(this.sourceDb, this.targetDb, this.targetScopeElementId);
-        }
-        catch (err) {
-            if (err instanceof Error &&
-                err.message === IModelTransformer.noEsaSyncDirectionErrorMessage &&
-                this._allowNoScopingESA) {
-                return "forward";
-            }
-            throw err;
-        }
-    }
-    async getIsReverseSynchronization() {
-        if (this._syncType === undefined)
-            this._syncType = await this.determineSyncType();
-        return this._syncType === "reverse";
-    }
-    async getIsForwardSynchronization() {
-        if (this._syncType === undefined)
-            this._syncType = await this.determineSyncType();
-        return this._syncType === "forward";
-    }
+    _targetElementsImportedInCurrentTransform = new Set();
+    /** the options that were used to initialize this transformer */
+    _options;
     _changesetRanges = undefined;
     /**
      * Set if the transformer is being used to perform the provenance initialization step of a fork initialization.
@@ -209,16 +109,11 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     _isProvenanceInitTransform;
     /** The element classes that are considered to define provenance in the iModel */
     static get provenanceElementClasses() {
-        return [
-            core_backend_1.FolderLink,
-            core_backend_1.SynchronizationConfigLink,
-            core_backend_1.ExternalSource,
-            core_backend_1.ExternalSourceAttachment,
-        ];
+        return ProvenanceManager_1.ProvenanceManager.provenanceElementClasses;
     }
     /** The element aspect classes that are considered to define provenance in the iModel */
     static get provenanceElementAspectClasses() {
-        return [core_backend_1.ExternalSourceAspect];
+        return ProvenanceManager_1.ProvenanceManager.provenanceElementAspectClasses;
     }
     /** Construct a new IModelTransformer
      * @param source Specifies the source IModelExporter or the source IModelDb that will be used to construct the source IModelExporter.
@@ -277,14 +172,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         this.targetDb = this.importer.targetDb;
         // create the IModelCloneContext, it must be initialized later
         this.context = new IModelCloneContext_1.IModelCloneContext(this.sourceDb, this.targetDb);
-        if (this.sourceDb.isBriefcase && this.targetDb.isBriefcase) {
-            nodeAssert(this.sourceDb.changeset.index !== undefined &&
-                this.targetDb.changeset.index !== undefined, "database has no changeset index");
-            this._startingChangesetIndices = {
-                target: this.targetDb.changeset.index,
-                source: this.sourceDb.changeset.index,
-            };
-        }
         // this internal is guaranteed stable for just transformer usage
         /* eslint-disable @itwin/no-internal */
         if (("codeValueBehavior" in this.sourceDb)) {
@@ -292,6 +179,8 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             this.targetDb.codeValueBehavior = "exact";
         }
         /* eslint-enable @itwin/no-internal */
+        this._syncTypeResolver = new SyncTypeResolver_1.SyncTypeResolver(this.context, this._options.targetScopeElementId, !!this._isProvenanceInitTransform, !!this._options.argsForProcessChanges);
+        this._provenanceManager = new ProvenanceManager_1.ProvenanceManager(this._options.targetScopeElementId, this._options, this._syncTypeResolver);
         if (this._options.tryAlignGeolocation) {
             if (this.sourceDb.geographicCoordinateSystem ||
                 this.targetDb.geographicCoordinateSystem) {
@@ -342,79 +231,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         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.
-     * @note This will be [[targetDb]] except when it is a reverse synchronization. In that case it be [[sourceDb]].
-     */
-    async getProvenanceDb() {
-        return (await this.getIsReverseSynchronization())
-            ? this.sourceDb
-            : this.targetDb;
-    }
-    /** Return the IModelDb where IModelTransformer looks for entities referred to by stored provenance.
-     * @note This will be [[sourceDb]] except when it is a reverse synchronization. In that case it be [[targetDb]].
-     */
-    async getProvenanceSourceDb() {
-        return (await this.getIsReverseSynchronization())
-            ? this.targetDb
-            : this.sourceDb;
-    }
-    /** Create an ExternalSourceAspectProps in a standard way for an Element in an iModel --> iModel transformation. */
-    static initElementProvenanceOptions(sourceElementId, targetElementId, args) {
-        const elementId = args.isReverseSynchronization
-            ? sourceElementId
-            : targetElementId;
-        const version = args.isReverseSynchronization
-            ? args.targetDb.elements.queryLastModifiedTime(targetElementId)
-            : args.sourceDb.elements.queryLastModifiedTime(sourceElementId);
-        const aspectIdentifier = args.isReverseSynchronization
-            ? targetElementId
-            : sourceElementId;
-        const aspectProps = {
-            classFullName: core_backend_1.ExternalSourceAspect.classFullName,
-            element: {
-                id: elementId,
-                relClassName: core_backend_1.ElementOwnsExternalSourceAspects.classFullName,
-            },
-            scope: { id: args.targetScopeElementId },
-            identifier: aspectIdentifier,
-            kind: core_backend_1.ExternalSourceAspect.Kind.Element,
-            version,
-        };
-        return aspectProps;
-    }
-    static async initRelationshipProvenanceOptions(sourceRelInstanceId, targetRelInstanceId, args) {
-        const provenanceDb = args.isReverseSynchronization
-            ? args.sourceDb
-            : args.targetDb;
-        const aspectIdentifier = args.isReverseSynchronization
-            ? targetRelInstanceId
-            : sourceRelInstanceId;
-        const provenanceRelInstanceId = args.isReverseSynchronization
-            ? sourceRelInstanceId
-            : targetRelInstanceId;
-        const sql = "SELECT SourceECInstanceId FROM bis.ElementRefersToElements WHERE ECInstanceId=?";
-        const params = new core_common_1.QueryBinder().bindId(1, provenanceRelInstanceId);
-        const reader = provenanceDb.createQueryReader(sql, params, {
-            usePrimaryConn: true,
-        });
-        nodeAssert(await reader.step(), "relationship provenance query returned no rows");
-        const elementId = reader.current[0];
-        const jsonProperties = args.forceOldRelationshipProvenanceMethod
-            ? { targetRelInstanceId }
-            : { provenanceRelInstanceId };
-        const aspectProps = {
-            classFullName: core_backend_1.ExternalSourceAspect.classFullName,
-            element: {
-                id: elementId,
-                relClassName: core_backend_1.ElementOwnsExternalSourceAspects.classFullName,
-            },
-            scope: { id: args.targetScopeElementId },
-            identifier: aspectIdentifier,
-            kind: core_backend_1.ExternalSourceAspect.Kind.Relationship,
-            jsonProperties: JSON.stringify(jsonProperties),
-        };
-        return aspectProps;
-    }
     /**
      * Previously the transformer would insert provenance always pointing to the "target" relationship.
      * It should (and now by default does) instead insert provenance pointing to the provenanceSource
@@ -424,42 +240,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
     _forceOldRelationshipProvenanceMethod = false;
     /** Create an ExternalSourceAspectProps in a standard way for an Element in an iModel --> iModel transformation. */
     async initElementProvenance(sourceElementId, targetElementId) {
-        return IModelTransformer.initElementProvenanceOptions(sourceElementId, targetElementId, {
-            isReverseSynchronization: await this.getIsReverseSynchronization(),
-            targetScopeElementId: this.targetScopeElementId,
-            sourceDb: this.sourceDb,
-            targetDb: this.targetDb,
-        });
-    }
-    /** Create an ExternalSourceAspectProps in a standard way for a Relationship in an iModel --> iModel transformations.
-     * The ExternalSourceAspect is meant to be owned by the Element in the target iModel that is the `sourceId` of transformed relationship.
-     * The `identifier` property of the ExternalSourceAspect will be the ECInstanceId of the relationship in the master iModel.
-     * The ECInstanceId of the relationship in the branch iModel will be stored in the JsonProperties of the ExternalSourceAspect.
-     */
-    async initRelationshipProvenance(sourceRelationship, targetRelInstanceId) {
-        return IModelTransformer.initRelationshipProvenanceOptions(sourceRelationship.id, targetRelInstanceId, {
-            sourceDb: this.sourceDb,
-            targetDb: this.targetDb,
-            isReverseSynchronization: await this.getIsReverseSynchronization(),
-            targetScopeElementId: this.targetScopeElementId,
-            forceOldRelationshipProvenanceMethod: this._forceOldRelationshipProvenanceMethod,
-        });
-    }
-    /** NOTE: the json properties must be converted to string before insertion */
-    _targetScopeProvenanceProps = undefined;
-    /**
-     * Index of the changeset that the transformer was at when the transformation begins (was constructed).
-     * Used to determine at the end which changesets were part of a synchronization.
-     */
-    _startingChangesetIndices = undefined;
-    _cachedSynchronizationVersion = undefined;
-    /**
-     * 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;
+        return this._provenanceManager.initElementProvenance(sourceElementId, targetElementId);
     }
     /** 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
@@ -469,394 +250,58 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @throws if the version is not found in a preexisting scope aspect and @see [[IModelTransformOptions.branchRelationshipDataBehavior]] !== "unsafe-migrate"
      */
     async getSynchronizationVersion() {
-        if (this._cachedSynchronizationVersion === undefined) {
-            const provenanceScopeAspect = await this.tryGetProvenanceScopeAspect();
-            if (!provenanceScopeAspect) {
-                return { index: -1, id: "" }; // first synchronization.
-            }
-            const version = (await this.getIsReverseSynchronization())
-                ? JSON.parse(provenanceScopeAspect.jsonProperties ?? "{}").reverseSyncVersion
-                : provenanceScopeAspect.version;
-            if (!version &&
-                this._options.branchRelationshipDataBehavior === "unsafe-migrate") {
-                return { index: -1, id: "" }; // previous synchronization was done before fed guid update.
-            }
-            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.
-        }
-        return this._cachedSynchronizationVersion;
+        return this._provenanceManager.getSynchronizationVersion();
     }
     /**
      * @returns provenance scope aspect if it exists in the provenanceDb.
      * Provenance scope aspect is created and inserted into provenanceDb when [[initScopeProvenance]] is invoked.
      */
     async tryGetProvenanceScopeAspect() {
-        const scopeProvenanceAspectProps = await IModelTransformer.queryScopeExternalSourceAspect(await this.getProvenanceDb(), {
-            id: undefined,
-            classFullName: core_backend_1.ExternalSourceAspect.classFullName,
-            scope: { id: core_common_1.IModel.rootSubjectId },
-            kind: core_backend_1.ExternalSourceAspect.Kind.Scope,
-            element: { id: this.targetScopeElementId ?? core_common_1.IModel.rootSubjectId },
-            identifier: (await this.getProvenanceSourceDb()).iModelId,
-        });
-        return scopeProvenanceAspectProps !== undefined
-            ? (await this.getProvenanceDb()).elements.getAspect(scopeProvenanceAspectProps.aspectId)
-            : undefined;
+        return this._provenanceManager.tryGetProvenanceScopeAspect();
     }
     /**
      * Make sure there are no conflicting other scope-type external source aspects on the *target scope element*,
      * If there are none at all, insert one, then this must be a first synchronization.
-     * @returns the last synced version (changesetId) on the target scope's external source aspect,
-     *          if this was a [BriefcaseDb]($backend)
      */
     async initScopeProvenance() {
-        const provenanceDb = await this.getProvenanceDb();
-        const sourceProvenanceDb = await this.getProvenanceSourceDb();
-        const aspectProps = {
-            id: undefined,
-            version: undefined,
-            classFullName: core_backend_1.ExternalSourceAspect.classFullName,
-            element: {
-                id: this.targetScopeElementId,
-                relClassName: core_backend_1.ElementOwnsExternalSourceAspects.classFullName,
-            },
-            scope: { id: core_common_1.IModel.rootSubjectId }, // the root Subject scopes scope elements
-            identifier: sourceProvenanceDb.iModelId,
-            kind: core_backend_1.ExternalSourceAspect.Kind.Scope,
-            jsonProperties: undefined,
-        };
-        const foundEsaProps = await IModelTransformer.queryScopeExternalSourceAspect(provenanceDb, aspectProps); // this query includes "identifier"
-        if (foundEsaProps === undefined) {
-            aspectProps.version = ""; // empty since never before transformed. Will be updated in [[finalizeTransformation]]
-            aspectProps.jsonProperties = {
-                pendingReverseSyncChangesetIndices: [],
-                pendingSyncChangesetIndices: [],
-                reverseSyncVersion: "", // empty since never before transformed. Will be updated in first reverse sync
-            };
-            // this query does not include "identifier" to find possible conflicts
-            const sql = `
-        SELECT ECInstanceId
-        FROM ${core_backend_1.ExternalSourceAspect.classFullName}
-        WHERE Element.Id=:elementId
-          AND Scope.Id=:scopeId
-          AND Kind=:kind
-        LIMIT 1
-      `;
-            const params = new core_common_1.QueryBinder();
-            params.bindId("elementId", aspectProps.element.id);
-            params.bindId("scopeId", aspectProps.scope.id); // this scope.id can never be invalid, we create it above
-            params.bindString("kind", aspectProps.kind);
-            const reader = provenanceDb.createQueryReader(sql, params, {
-                usePrimaryConn: true,
-            });
-            const hasConflictingScope = await reader.step();
-            if (hasConflictingScope) {
-                throw new core_common_1.IModelError(core_bentley_1.IModelStatus.InvalidId, "Provenance scope conflict");
-            }
-            if (!this._options.noProvenance) {
-                const id = provenanceDb.elements.insertAspect({
-                    ...aspectProps,
-                    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;
-            aspectProps.jsonProperties = foundEsaProps.jsonProperties
-                ? JSON.parse(foundEsaProps.jsonProperties)
-                : 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 });
-                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.argsForProcessChanges?.unsafeFallbackSyncVersion ?? "";
-        const fallbackReverseSyncVersionToUse = this._options.argsForProcessChanges?.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;
+        return this._provenanceManager.initScopeProvenance();
     }
     /**
-     * Iterate all matching federation guids and ExternalSourceAspects in the provenance iModel (target unless reverse sync)
-     * and call a function for each one.
-     * @note provenance is done by federation guids where possible
-     * @note this may execute on each element more than once! Only use in cases where that is handled
+     * Get the IModelDb where provenance (ExternalSourceAspects) is stored.
+     * This will be targetDb except when it is a reverse synchronization, in which case it will be sourceDb.
      */
-    static async forEachTrackedElement(args) {
-        if (args.provenanceDb === args.provenanceSourceDb)
-            return;
-        if (!args.provenanceDb.containsClass(core_backend_1.ExternalSourceAspect.classFullName)) {
-            throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadSchema, "The BisCore schema version of the target database is too old");
-        }
-        const sourceDb = args.isReverseSynchronization
-            ? args.provenanceDb
-            : args.provenanceSourceDb;
-        const targetDb = args.isReverseSynchronization
-            ? args.provenanceSourceDb
-            : args.provenanceDb;
-        // query for provenanceDb
-        const elementIdByFedGuidQuery = `
-      SELECT e.ECInstanceId, FederationGuid
-      FROM bis.Element e
-      ${args.skipPropagateChangesToRootElements
-            ? "WHERE e.ECInstanceId NOT IN (0x1, 0xe, 0x10) -- special static elements"
-            : ""}
-      ORDER BY FederationGuid
-    `;
-        // iterate through sorted list of fed guids from both dbs to get the intersection
-        // NOTE: if we exposed the native attach database support,
-        // we could get the intersection of fed guids in one query, not sure if it would be faster
-        // OR we could do a raw sqlite query...
-        const sourceReader = sourceDb.createQueryReader(elementIdByFedGuidQuery, undefined, { usePrimaryConn: true });
-        const targetReader = targetDb.createQueryReader(elementIdByFedGuidQuery, undefined, { usePrimaryConn: true });
-        let hasSourceRow = await sourceReader.step();
-        let hasTargetRow = await targetReader.step();
-        while (hasSourceRow && hasTargetRow) {
-            const sourceFedGuid = sourceReader.current.federationGuid;
-            const targetFedGuid = targetReader.current.federationGuid;
-            if (sourceFedGuid !== undefined &&
-                targetFedGuid !== undefined &&
-                sourceFedGuid === targetFedGuid) {
-                // data flow direction is always sourceDb -> targetDb and it does not depend on where the explicit element provenance is stored
-                args.fn(sourceReader.current.id, targetReader.current.id);
-            }
-            if (targetFedGuid === undefined ||
-                (sourceFedGuid !== undefined && sourceFedGuid >= targetFedGuid)) {
-                hasTargetRow = await targetReader.step();
-            }
-            if (sourceFedGuid === undefined ||
-                (targetFedGuid !== undefined && sourceFedGuid <= targetFedGuid)) {
-                hasSourceRow = await sourceReader.step();
-            }
-        }
-        // query for provenanceDb
-        const provenanceAspectsQuery = `
-      SELECT esa.Identifier, Element.Id
-      FROM bis.ExternalSourceAspect esa
-      WHERE Scope.Id=:scopeId
-        AND Kind=:kind
-    `;
-        // Technically this will a second time call the function (as documented) on
-        // victims of the old provenance method that have both fedguids and an inserted aspect.
-        // But this is a private function with one known caller where that doesn't matter
-        const runFnInDataFlowDirection = (sourceId, targetId) => args.isReverseSynchronization
-            ? args.fn(sourceId, targetId)
-            : args.fn(targetId, sourceId);
-        const params = new core_common_1.QueryBinder();
-        params.bindId("scopeId", args.targetScopeElementId);
-        params.bindString("kind", core_backend_1.ExternalSourceAspect.Kind.Element);
-        const provenanceReader = args.provenanceDb.createQueryReader(provenanceAspectsQuery, params, { usePrimaryConn: true });
-        for await (const row of provenanceReader) {
-            // ExternalSourceAspect.Identifier is of type string
-            const aspectIdentifier = row[0];
-            const elementId = row.id;
-            runFnInDataFlowDirection(elementId, aspectIdentifier);
-        }
-    }
-    async forEachTrackedElement(fn) {
-        return IModelTransformer.forEachTrackedElement({
-            provenanceSourceDb: await this.getProvenanceSourceDb(),
-            provenanceDb: await this.getProvenanceDb(),
-            targetScopeElementId: this.targetScopeElementId,
-            isReverseSynchronization: await this.getIsReverseSynchronization(),
-            fn,
-            skipPropagateChangesToRootElements: this._options.skipPropagateChangesToRootElements ?? true,
-        });
+    async getProvenanceDb() {
+        return (await this.getIsReverseSynchronization())
+            ? this.sourceDb
+            : this.targetDb;
     }
     /**
-     * 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
+     * Get whether this is a reverse synchronization.
      */
-    async _queryProvenanceForElement(entityInProvenanceSourceId) {
-        const sql = `
-        SELECT esa.Element.Id
-        FROM Bis.ExternalSourceAspect esa
-        WHERE esa.Kind=?
-          AND esa.Scope.Id=?
-          AND esa.Identifier=?
-      `;
-        const params = new core_common_1.QueryBinder();
-        params.bindString(1, core_backend_1.ExternalSourceAspect.Kind.Element);
-        params.bindId(2, this.targetScopeElementId);
-        params.bindString(3, entityInProvenanceSourceId);
-        const result = (await this.getProvenanceDb()).createQueryReader(sql, params, {
-            usePrimaryConn: true,
-        });
-        if (await result.step()) {
-            return result.current.id;
-        }
-        else
-            return undefined;
+    async getIsReverseSynchronization() {
+        return (await this._syncTypeResolver.getSyncType()) === "reverse";
     }
     /**
-     * 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
+     * Get whether this is a forward synchronization.
      */
-    async _queryProvenanceForRelationship(entityInProvenanceSourceId, sourceRelInfo) {
-        const sql = `
-      SELECT
-        ECInstanceId,
-        JSON_EXTRACT(JsonProperties, '$.provenanceRelInstanceId') AS provenanceRelInstId
-      FROM Bis.ExternalSourceAspect
-      WHERE Kind=?
-        AND Scope.Id=?
-        AND Identifier=?
-    `;
-        const params = new core_common_1.QueryBinder();
-        params.bindString(1, core_backend_1.ExternalSourceAspect.Kind.Relationship);
-        params.bindId(2, this.targetScopeElementId);
-        params.bindString(3, entityInProvenanceSourceId);
-        const result = (await this.getProvenanceDb()).createQueryReader(sql, params, {
-            usePrimaryConn: true,
-        });
-        if (await result.step()) {
-            const aspectId = result.current.id;
-            const provenanceRelInstId = result.current.provenanceRelInstId;
-            const provenanceRelInstanceId = provenanceRelInstId !== undefined
-                ? provenanceRelInstId
-                : await this._queryTargetRelId(sourceRelInfo);
-            return {
-                aspectId,
-                relationshipId: provenanceRelInstanceId,
-            };
-        }
-        else
-            return undefined;
+    async getIsForwardSynchronization() {
+        return (await this._syncTypeResolver.getSyncType()) === "forward";
     }
-    async _queryTargetRelId(sourceRelInfo) {
-        const targetRelInfo = {
-            sourceId: this.context.findTargetElementId(sourceRelInfo.sourceId),
-            targetId: this.context.findTargetElementId(sourceRelInfo.targetId),
-        };
-        if (targetRelInfo.sourceId === undefined ||
-            targetRelInfo.targetId === undefined)
-            return undefined; // couldn't find an element, rel is invalid or deleted
-        const sql = `
-      select ecinstanceid
-      from bis.elementreferstoelements
-      where sourceecinstanceid=?
-        and targetecinstanceid=?
-        and ecclassid=?
-    `;
-        const params = new core_common_1.QueryBinder();
-        params.bindId(1, targetRelInfo.sourceId);
-        params.bindId(2, targetRelInfo.targetId);
-        params.bindId(3, await this._targetClassNameToClassId(sourceRelInfo.classFullName));
-        const result = this.targetDb.createQueryReader(sql, params, {
-            usePrimaryConn: true,
+    /**
+     * Updates the synchronization version on the scope ESA.
+     */
+    async updateSynchronizationVersion({ initializeReverseSyncVersion = false, } = {}) {
+        return this._provenanceManager.updateSynchronizationVersion({
+            initializeReverseSyncVersion,
+            sourceChangeDataState: this._sourceChangeDataState,
         });
-        if (await result.step())
-            return result.current.id;
-        else
-            return undefined;
-    }
-    _targetClassNameToClassIdCache = new Map();
-    async _targetClassNameToClassId(classFullName) {
-        let classId = this._targetClassNameToClassIdCache.get(classFullName);
-        if (classId === undefined) {
-            classId = await this._getRelClassId(this.targetDb, classFullName);
-            this._targetClassNameToClassIdCache.set(classFullName, classId);
-        }
-        return classId;
-    }
-    // NOTE: this doesn't handle remapped element classes,
-    // but is only used for relationships rn
-    async _getRelClassId(db, classFullName) {
-        const sql = `
-      SELECT c.ECInstanceId
-      FROM ECDbMeta.ECClassDef c
-      JOIN ECDbMeta.ECSchemaDef s ON c.Schema.Id=s.ECInstanceId
-      WHERE s.Name=? AND c.Name=?
-    `;
-        const params = new core_common_1.QueryBinder();
-        const [schemaName, className] = classFullName.indexOf(".") !== -1
-            ? classFullName.split(".")
-            : classFullName.split(":");
-        params.bindString(1, schemaName);
-        params.bindString(2, className);
-        const result = db.createQueryReader(sql, params, { usePrimaryConn: true });
-        if (await result.step())
-            return result.current.id;
-        (0, core_bentley_1.assert)(false, "relationship was not found");
     }
     /** Returns `true` if *brute force* delete detections should be run.
      * @note This is only called if [[IModelTransformOptions.forceExternalSourceAspectProvenance]] option is true
      * @note Not relevant for [[process]] when [[IModelTransformOptions.argsForProcessChanges]] are provided and change history is known.
      */
     async shouldDetectDeletes() {
-        nodeAssert(this._syncType !== undefined);
-        return this._syncType === "not-sync";
+        return (await this._syncTypeResolver.getSyncType()) === "not-sync";
     }
     /** Transform the specified sourceElement into ElementProps for the target iModel.
      * @param sourceElement The Element from the source iModel to transform.
@@ -1134,6 +579,26 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
             (!isElemInTarget || !(await dbHasModel(this.targetDb, idOfElemInTarget)));
         return { needsElemImport: !isElemInTarget, needsModelImport };
     }
+    // In iTwin js 5.x Elements.queryElementIdByCode() uses Code class to query id:
+    // https://github.com/iTwin/itwinjs-core/blob/master/core/backend/src/IModelDb.ts#L2779
+    // Code class constructor trims white spaces from code value.
+    // Custom implementation of queryElementIdByCode() was added to support querying elements with code values that have trailing whitespaces.
+    // It mimicks 4.x implementation: https://github.com/iTwin/itwinjs-core/blob/9c8b394ec3878a39764be81f928fd8b0b9115d31/core/backend/src/IModelDb.ts#L1882
+    async queryElementIdByCode(iModel, code) {
+        if (core_bentley_1.Id64.isInvalid(code.spec))
+            throw new Error("Invalid CodeSpec");
+        if (code.value === undefined)
+            throw new Error("Invalid Code");
+        const query = "SELECT ECInstanceId FROM BisCore:Element WHERE CodeSpec.Id=? AND CodeScope.Id=? AND CodeValue=?";
+        const queryBinder = new core_common_1.QueryBinder()
+            .bindId(1, code.spec)
+            .bindId(2, core_bentley_1.Id64.fromString(code.scope))
+            .bindString(3, code.value);
+        const queryReader = iModel.createQueryReader(query, queryBinder, {
+            usePrimaryConn: true,
+        });
+        return (await queryReader.step()) ? queryReader.current[0] : undefined;
+    }
     /** Override of [IModelExportHandler.onExportElement]($transformer) that imports an element into the target iModel when it is exported from the source iModel.
      * This override calls [[onTransformElement]] and then [IModelImporter.importElement]($transformer) to update the target iModel.
      */
@@ -1217,6 +682,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         if (targetElementProps.id === undefined) {
             throw new core_common_1.IModelError(core_bentley_1.IModelStatus.BadElement, "targetElementProps.id should be assigned by importElement");
         }
+        this._targetElementsImportedInCurrentTransform.add(targetElementProps.id);
         this.context.remapElement(sourceElement.id, targetElementProps.id);
         // the transformer does not currently 'split' or 'join' any elements, therefore, it does not
         // insert external source aspects because federation guids are sufficient for this.
@@ -1227,13 +693,13 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         // FIXME: make public and improve `initElementProvenance` API for usage by consolidators
         const provenanceDb = await this.getProvenanceDb();
         if (!this._options.noProvenance) {
-            let provenance = this._options.forceExternalSourceAspectProvenance ||
+            const provenance = this._options.forceExternalSourceAspectProvenance ||
                 this._elementsWithExplicitlyTrackedProvenance.has(sourceElement.id)
                 ? undefined
                 : sourceElement.federationGuid;
             if (!provenance) {
                 const aspectProps = await this.initElementProvenance(sourceElement.id, targetElementProps.id);
-                const foundEsaProps = await IModelTransformer.queryScopeExternalSourceAspect(provenanceDb, aspectProps);
+                const foundEsaProps = await ProvenanceManager_1.ProvenanceManager.queryScopeExternalSourceAspect(provenanceDb, aspectProps);
                 if (foundEsaProps === undefined)
                     aspectProps.id = provenanceDb.elements.insertAspect(aspectProps);
                 else {
@@ -1241,38 +707,20 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                     aspectProps.id = foundEsaProps.aspectId;
                     provenanceDb.elements.updateAspect(aspectProps);
                 }
-                provenance = aspectProps;
             }
-            this.markLastProvenance(provenance, { isRelationship: false });
         }
     }
-    // In iTwin js 5.x Elements.queryElementIdByCode() uses Code class to query id:
-    // https://github.com/iTwin/itwinjs-core/blob/master/core/backend/src/IModelDb.ts#L2779
-    // Code class constructor trims white spaces from code value.
-    // Custom implementation of queryElementIdByCode() was added to support querying elements with code values that have trailing whitespaces.
-    // It mimicks 4.x implementation: https://github.com/iTwin/itwinjs-core/blob/9c8b394ec3878a39764be81f928fd8b0b9115d31/core/backend/src/IModelDb.ts#L1882
-    async queryElementIdByCode(iModel, code) {
-        if (core_bentley_1.Id64.isInvalid(code.spec))
-            throw new Error("Invalid CodeSpec");
-        if (code.value === undefined)
-            throw new Error("Invalid Code");
-        const query = "SELECT ECInstanceId FROM BisCore:Element WHERE CodeSpec.Id=? AND CodeScope.Id=? AND CodeValue=?";
-        const queryBinder = new core_common_1.QueryBinder()
-            .bindId(1, code.spec)
-            .bindId(2, core_bentley_1.Id64.fromString(code.scope))
-            .bindString(3, code.value);
-        const queryReader = iModel.createQueryReader(query, queryBinder, {
-            usePrimaryConn: true,
-        });
-        return (await queryReader.step()) ? queryReader.current[0] : undefined;
-    }
     /** Override of [IModelExportHandler.onDeleteElement]($transformer) that is called when [IModelExporter]($transformer) detects that an Element has been deleted from the source iModel.
      * This override propagates the delete to the target iModel via [IModelImporter.deleteElement]($transformer).
      */
     async onDeleteElement(sourceElementId) {
         const targetElementId = this.context.findTargetElementId(sourceElementId);
         if (core_bentley_1.Id64.isValidId64(targetElementId)) {
-            await this.importer.deleteElement(targetElementId);
+            // Skip deletion if this target element was already imported (inserted/updated) during
+            // this transformation pass.
+            if (!this._targetElementsImportedInCurrentTransform.has(targetElementId)) {
+                await this.importer.deleteElement(targetElementId);
+            }
         }
     }
     /** Override of [IModelExportHandler.onExportModel]($transformer) that is called when a Model should be exported from the source iModel.
@@ -1408,95 +856,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         targetModelProps.parentModel = this.context.findTargetElementId(targetModelProps.parentModel);
         return targetModelProps;
     }
-    /**
-     * 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
-     *
-     * You generally should not call this function yourself and use [[process]] with [[IModelTransformOptions.argsForProcessChanges]] provided instead.
-     * It is public for unsupported use cases of custom synchronization transforms.
-     * @note If [[IModelTransformOptions.argsForProcessChanges]] is not defined in this transformation, this function will return early without updating the sync version,
-     * unless the `initializeReverseSyncVersion` option is set to `true`
-     *
-     * The `initializeReverseSyncVersion` is added to set the reverse synchronization version during a forward synchronization.
-     * When set to `true`, it saves the reverse sync version as the current changeset of the targetDb. This is typically used for the first transformation between a master and branch iModel.
-     * Setting `initializeReverseSyncVersion` to `true` has the effect of making it so any changesets in the branch iModel at the time of the first transformation will be ignored during any future reverse synchronizations from the branch to the master iModel.
-     *
-     * Note that typically, the reverseSyncVersion is saved as the last changeset merged from the branch into master.
-     * Setting initializeReverseSyncVersion to true during a forward transformation could overwrite this correct reverseSyncVersion and should only be done during the first transformation between a master and branch iModel.
-     */
-    async updateSynchronizationVersion({ initializeReverseSyncVersion = false, } = {}) {
-        const shouldSkipSyncVersionUpdate = !initializeReverseSyncVersion &&
-            this._sourceChangeDataState !== "has-changes";
-        if (shouldSkipSyncVersionUpdate)
-            return;
-        nodeAssert(this._targetScopeProvenanceProps);
-        const sourceVersion = `${this.sourceDb.changeset.id};${this.sourceDb.changeset.index}`;
-        const targetVersion = `${this.targetDb.changeset.id};${this.targetDb.changeset.index}`;
-        if (await this.getIsReverseSynchronization()) {
-            const oldVersion = this._targetScopeProvenanceProps.jsonProperties.reverseSyncVersion;
-            core_bentley_1.Logger.logInfo(loggerCategory, `updating reverse version from ${oldVersion} to ${sourceVersion}`);
-            this._targetScopeProvenanceProps.jsonProperties.reverseSyncVersion =
-                sourceVersion;
-        }
-        else {
-            core_bentley_1.Logger.logInfo(loggerCategory, `updating sync version from ${this._targetScopeProvenanceProps.version} to ${sourceVersion}`);
-            this._targetScopeProvenanceProps.version = sourceVersion;
-            // save reverse sync version
-            if (initializeReverseSyncVersion) {
-                core_bentley_1.Logger.logInfo(loggerCategory, `updating reverse sync version from ${this._targetScopeProvenanceProps.jsonProperties.reverseSyncVersion} to ${targetVersion}`);
-                this._targetScopeProvenanceProps.jsonProperties.reverseSyncVersion =
-                    targetVersion;
-            }
-        }
-        if (this._options.argsForProcessChanges ||
-            (this._startingChangesetIndices && initializeReverseSyncVersion)) {
-            nodeAssert(this.targetDb.changeset.index !== undefined &&
-                this._startingChangesetIndices !== undefined, "updateSynchronizationVersion was called without change history");
-            // Store in a local variable, so typescript knows it's defined (due to the assert above)
-            const startingChangesetIndices = this._startingChangesetIndices;
-            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 pendingSyncChangesetIndicesKey = "pendingSyncChangesetIndices";
-            const pendingReverseSyncChangesetIndicesKey = "pendingReverseSyncChangesetIndices";
-            // Determine which keys to clear and update based on the synchronization direction
-            let syncChangesetsToClearKey;
-            let syncChangesetsToUpdateKey;
-            if (await this.getIsReverseSynchronization()) {
-                syncChangesetsToClearKey = pendingReverseSyncChangesetIndicesKey;
-                syncChangesetsToUpdateKey = pendingSyncChangesetIndicesKey;
-            }
-            else {
-                syncChangesetsToClearKey = pendingSyncChangesetIndicesKey;
-                syncChangesetsToUpdateKey = 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 = startingChangesetIndices.target + 1; i <= this.targetDb.changeset.index + 1; i++)
-                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 > startingChangesetIndices.source;
-            });
-            // if reverse sync then we may have received provenance changes which should be marked as sync changes
-            if (await this.getIsReverseSynchronization()) {
-                nodeAssert(this.sourceDb.changeset.index !== undefined, "changeset didn't exist");
-                for (let i = startingChangesetIndices.source + 1; i <= this.sourceDb.changeset.index + 1; i++)
-                    jsonProps.pendingReverseSyncChangesetIndices.push(i);
-            }
-            core_bentley_1.Logger.logTrace(loggerCategory, `new pendingReverseSyncChanges: ${jsonProps.pendingReverseSyncChangesetIndices}`);
-            core_bentley_1.Logger.logTrace(loggerCategory, `new pendingSyncChanges: ${jsonProps.pendingSyncChangesetIndices}`);
-        }
-        (await this.getProvenanceDb()).elements.updateAspect({
-            ...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() {
         this.importer.finalize();
@@ -1541,19 +900,18 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         const provenanceDb = await this.getProvenanceDb();
         if (!this._options.noProvenance &&
             core_bentley_1.Id64.isValid(targetRelationshipInstanceId)) {
-            let provenance = !this._options.forceExternalSourceAspectProvenance
-                ? sourceFedGuid && targetFedGuid && `${sourceFedGuid}/${targetFedGuid}`
-                : undefined;
-            if (!provenance) {
-                const aspectProps = await this.initRelationshipProvenance(sourceRelationship, targetRelationshipInstanceId);
-                const foundEsaProps = await IModelTransformer.queryScopeExternalSourceAspect(provenanceDb, aspectProps);
+            const needsEsaProvenance = !this._options
+                .forceExternalSourceAspectProvenance
+                ? !(sourceFedGuid && targetFedGuid)
+                : true;
+            if (needsEsaProvenance) {
+                const aspectProps = await this._provenanceManager.initRelationshipProvenance(sourceRelationship.id, targetRelationshipInstanceId, this._forceOldRelationshipProvenanceMethod);
+                const foundEsaProps = await ProvenanceManager_1.ProvenanceManager.queryScopeExternalSourceAspect(provenanceDb, aspectProps);
                 // onExportRelationship doesn't need to call updateAspect if esaProps were found, because relationship provenance doesn't have the same concept of a version as element provenance (which uses last mod time on the elements).
                 if (undefined === foundEsaProps) {
                     aspectProps.id = provenanceDb.elements.insertAspect(aspectProps);
                 }
-                provenance = aspectProps;
             }
-            this.markLastProvenance(provenance, { isRelationship: true });
         }
     }
     /** Override of [IModelExportHandler.onDeleteRelationship]($transformer) that is called when [IModelExporter]($transformer) detects that a [Relationship]($backend) has been deleted from the source iModel.
@@ -1816,7 +1174,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @returns void
      */
     async processChangesets() {
-        await this.forEachTrackedElement((sourceElementId, targetElementId) => {
+        await this._provenanceManager.forEachTrackedElement((sourceElementId, targetElementId) => {
             this.context.remapElement(sourceElementId, targetElementId);
         });
         if (this.exporter.sourceDbChanges)
@@ -1974,8 +1332,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                     targetIdInTarget: targetIdOfRelationshipInTarget,
                 });
             }
-            else if (this.sourceDb === (await this.getProvenanceSourceDb())) {
-                const relProvenance = await this._queryProvenanceForRelationship(changedInstanceId, {
+            else if (this.sourceDb ===
+                (await this._provenanceManager.getProvenanceSourceDb())) {
+                const relProvenance = await this._provenanceManager.queryProvenanceForRelationship(changedInstanceId, {
                     classFullName: classFullName ?? "",
                     sourceId: sourceIdOfRelationshipInSource,
                     targetId: targetIdOfRelationshipInSource,
@@ -1991,8 +1350,10 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         else {
             let targetId = await getTargetIdFromSourceId(changedInstanceId);
             if (targetId === undefined &&
-                this.sourceDb === (await this.getProvenanceSourceDb())) {
-                targetId = await this._queryProvenanceForElement(changedInstanceId);
+                this.sourceDb ===
+                    (await this._provenanceManager.getProvenanceSourceDb())) {
+                targetId =
+                    await this._provenanceManager.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
@@ -2051,12 +1412,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
                 ` which is changeset #${syncVersion.index}. The transformer expected` +
                 ` #${syncVersion.index + 1}.`);
         }
-        nodeAssert(this._targetScopeProvenanceProps, "_targetScopeProvenanceProps should be set by now");
-        const changesetsToSkip = (await this.getIsReverseSynchronization())
-            ? this._targetScopeProvenanceProps.jsonProperties
-                .pendingReverseSyncChangesetIndices
-            : this._targetScopeProvenanceProps.jsonProperties
-                .pendingSyncChangesetIndices;
+        const changesetsToSkip = await this._provenanceManager.getChangesetsToSkip();
         core_bentley_1.Logger.logTrace(loggerCategory, `changesets to skip: ${changesetsToSkip}`);
         this._changesetRanges = (0, Algo_1.rangesFromRangeAndSkipped)(startChangesetIndex, endChangesetIndex, changesetsToSkip);
         core_bentley_1.Logger.logTrace(loggerCategory, `ranges: ${this._changesetRanges}`);
@@ -2109,6 +1465,9 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @note [[processSchemas]] is not called automatically since the target iModel may want a different collection of schemas.
      */
     async processAll() {
+        this._targetElementsImportedInCurrentTransform.clear();
+        // processAll always has changes to process, so mark it as such for version tracking
+        this._sourceChangeDataState = "has-changes";
         await this.exporter.exportCodeSpecs();
         await this.exporter.exportFonts();
         if (this._options.skipPropagateChangesToRootElements) {
@@ -2133,21 +1492,6 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
         this.importer.computeProjectExtents();
         await this.finalizeTransformation();
     }
-    /** previous provenance, either a federation guid, a `${sourceFedGuid}/${targetFedGuid}` pair, or required aspect props */
-    _lastProvenanceEntityInfo = nullLastProvenanceEntityInfo;
-    markLastProvenance(sourceAspect, { isRelationship = false }) {
-        this._lastProvenanceEntityInfo =
-            typeof sourceAspect === "string"
-                ? sourceAspect
-                : {
-                    entityId: sourceAspect.element.id,
-                    aspectId: sourceAspect.id,
-                    aspectVersion: sourceAspect.version ?? "",
-                    aspectKind: isRelationship
-                        ? core_backend_1.ExternalSourceAspect.Kind.Relationship
-                        : core_backend_1.ExternalSourceAspect.Kind.Element,
-                };
-    }
     /** 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 assumes that you saveChanges after processing changes. You should not
@@ -2158,6 +1502,7 @@ class IModelTransformer extends IModelExporter_1.IModelExportHandler {
      * @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.
      */
     async processChanges(options) {
+        this._targetElementsImportedInCurrentTransform.clear();
         // must wait for initialization of synchronization provenance data
         await this.exporter.exportChanges(await this.getExportInitOpts(options));
         await this.completePartiallyCommittedElements();