Close legacy dry-run, empty-run and callback-context safety gaps

Defer legacy runner history access until navigation and use IMigrationHistory for read-only reads; constructors and DryRun no longer initialize history. Empty latest-version runs return before history access. Restore migration context around post-commit callbacks and clear it even when a callback fails. Update README scope semantics to match the explicitly requested effective-scope behavior.

Validation: solution build, Unit 70 passed, SQLite 145 passed with one pre-existing default-removal skip handled in the provider layer. New regressions cover legacy navigation, empty assemblies, callback context, durable history and callback failure cleanup. Addresses reviews 4071830715, 4071830792 and 4071830843; documents the deliberate scope policy discussed in 4071742900.

Author: jogibear9988

README.md

@@ -180,9 +180,9 @@ billingMigrator.MigrateToLastVersion();
 
 Important details:
 
-- A scope partitions **history**, not migration discovery. Passing a mixed assembly does not automatically filter it by scope.
-- Leave `MigrationAttribute.Scope` unset to inherit the provider scope. If you override it, it must align with the history the runner reads.
-- Duplicate versions are checked across the runner's whole loaded migration set. Separate scopes do not permit duplicate versions within one runner.
+- In the upgrade source, explicit scopes filter discovery; unscoped migrations inherit the runner scope. A scope partitions history, not database objects.
+- Leave `MigrationAttribute.Scope` unset to inherit the provider scope; set it to select a migration for one specific scope.
+- Duplicate versions are checked within the effective scope. Duplicate versions in distinct explicit scopes are independent.
 - Scopes do not isolate tables or data. Module migrations still need compatible table names and coordinated schema ownership.
 
 See [ProviderFactory](src/Migrator/ProviderFactory.cs), [MigrationLoader](src/Migrator/MigrationLoader.cs) and [history implementation](src/Migrator/Providers/TransformationProvider.cs).

src/Migrator.Tests/RunnerSafetyTests.cs

@@ -24,6 +24,47 @@ public class RunnerSafetyTests
         public override void Up() => throw new InvalidOperationException("original");
         public override void Down() => throw new InvalidOperationException("original");
     }
+    [Migration(4, Ignore = true)] public class CallbackContext : One
+    {
+        public override void AfterUp()
+        {
+            if (!ReferenceEquals(((TransformationProvider)Database).CurrentMigration, this)) throw new InvalidOperationException("Missing callback context.");
+            Database.ExecuteNonQuery("INSERT INTO Example VALUES (1)");
+        }
+    }
+    [Migration(5, Ignore = true)] public class FailedCallbackContext : CallbackContext
+    { public override void AfterUp() { base.AfterUp(); throw new InvalidOperationException("Callback failed."); } }
+
+    [Test, Category("SQLite")] public void LegacyDryRunConstructionAndNavigationAreReadOnly()
+    {
+        using var connection = new SqliteConnection("Data Source=:memory:;Foreign Keys=True"); connection.Open();
+        using var provider = ProviderFactory.Create(ProviderTypes.SQLite, connection, null);
+        var legacy = new MigrateAnywhere(new List<long> { 1 }, provider, new Logger(false)) { DryRun = true };
+        Assert.That(legacy.Current, Is.Zero);
+        Assert.That(legacy.AppliedVersions, Is.Empty);
+        Assert.That(legacy.Continue(1), Is.True);
+        legacy.Migrate(new One { Database = provider });
+        Assert.That(provider.TableExists("SchemaInfo"), Is.False);
+        Assert.That(provider.TableExists("Example"), Is.False);
+        Assert.That(((DotNetProjects.Migrator.Providers.Impl.SQLite.SQLiteTransformationProvider)provider).IsPragmaForeignKeysOn(), Is.True);
+    }
+    [Test, Category("SQLite")] public void EmptyLatestRunDoesNotCreateHistory()
+    {
+        using var provider = ProviderFactory.Create(ProviderTypes.SQLite, "Data Source=:memory:", null);
+        new DotNetProjects.Migrator.Migrator(provider, false, Array.Empty<Type>()).MigrateToLastVersion();
+        Assert.That(provider.TableExists("SchemaInfo"), Is.False);
+    }
+    [TestCase(false), TestCase(true), Category("SQLite")]
+    public void PostCommitCallbackHasContextAndAlwaysClearsIt(bool fail)
+    {
+        using var provider = ProviderFactory.Create(ProviderTypes.SQLite, "Data Source=:memory:", null);
+        var runner = new DotNetProjects.Migrator.Migrator(provider, false, fail ? typeof(FailedCallbackContext) : typeof(CallbackContext));
+        if (fail) Assert.That(Assert.Throws<InvalidOperationException>(runner.MigrateToLastVersion).Message, Is.EqualTo("Callback failed."));
+        else runner.MigrateToLastVersion();
+        Assert.That(((TransformationProvider)provider).CurrentMigration, Is.Null);
+        Assert.That(Convert.ToInt64(provider.ExecuteScalar("SELECT COUNT(*) FROM Example")), Is.EqualTo(1));
+        Assert.That(provider.AppliedMigrations, Has.Count.EqualTo(1));
+    }
     [Test] public void CustomProvidersRetainExplicitMigrationScope()
     {
         var provider = Substitute.For<ITransformationProvider>();

src/Migrator/BaseMigrate.cs

@@ -1,4 +1,6 @@
+using System;
 using System.Collections.Generic;
+using System.Linq;
 using DotNetProjects.Migrator.Framework;
 
 namespace DotNetProjects.Migrator;
@@ -11,24 +13,39 @@ public abstract class BaseMigrate
     protected bool _dryrun;
     protected ILogger _logger;
     protected List<long> _original;
+    private bool _initialized;
 
     protected BaseMigrate(List<long> availableMigrations, ITransformationProvider provider, ILogger logger)
     {
         _provider = provider;
-        _availableMigrations = availableMigrations;
-        _original = new List<long>(_provider.AppliedMigrations.ToArray()); //clone
+        _availableMigrations = availableMigrations.OrderBy(version => version).ToList();
         _logger = logger;
     }
 
+    protected IReadOnlyList<long> ReadHistory()
+    {
+        if (_provider is IMigrationHistory history) return history.ReadAppliedMigrations();
+        if (DryRun) throw new NotSupportedException("Legacy dry-run requires IMigrationHistory on custom providers.");
+        return _provider.AppliedMigrations;
+    }
+
+    private void InitializeHistory()
+    {
+        if (_initialized) return;
+        _original = new List<long>(ReadHistory());
+        _current = _original.DefaultIfEmpty(0).Max();
+        _initialized = true;
+    }
+
     public List<long> AppliedVersions
     {
-        get { return _original; }
+        get { InitializeHistory(); return _original; }
     }
 
     public virtual long Current
     {
-        get { return _current; }
-        protected set { _current = value; }
+        get { InitializeHistory(); return _current; }
+        protected set { InitializeHistory(); _current = value; }
     }
 
     public virtual bool DryRun
@@ -61,12 +78,13 @@ public void Iterate()
     /// <returns>The migration number of the next available Migration.</returns>
     protected long NextMigration()
     {
+        if (_availableMigrations.Count == 0) return 0;
         // Start searching at the current index
         var migrationSearch = _availableMigrations.IndexOf(Current) + 1;
 
         // See if we can find a migration that matches the requirement
         while (migrationSearch < _availableMigrations.Count
-               && _provider.AppliedMigrations.Contains(_availableMigrations[migrationSearch]))
+               && ReadHistory().Contains(_availableMigrations[migrationSearch]))
         {
             migrationSearch++;
         }
@@ -93,7 +111,7 @@ protected long PreviousMigration()
 
         // See if we can find a migration that matches the requirement
         while (migrationSearch > -1
-               && !_provider.AppliedMigrations.Contains(_availableMigrations[migrationSearch]))
+               && !ReadHistory().Contains(_availableMigrations[migrationSearch]))
         {
             migrationSearch--;
         }

src/Migrator/MigrateAnywhere.cs

@@ -17,11 +17,6 @@ public class MigrateAnywhere : BaseMigrate
     public MigrateAnywhere(List<long> availableMigrations, ITransformationProvider provider, ILogger logger)
         : base(availableMigrations, provider, logger)
     {
-        _current = 0;
-        if (provider.AppliedMigrations.Count > 0)
-        {
-            _current = provider.AppliedMigrations.Max();
-        }
         _goForward = false;
     }
 
@@ -47,6 +42,7 @@ public override long Previous
 
     public override bool Continue(long version)
     {
+        if (_availableMigrations.Count == 0) return false;
         // If we're going backwards and our current is less than the target, 
         // reverse direction.  Also, start over at zero to make sure we catch
         // any merged migrations that are less than the current target.

src/Migrator/MigrationExecution.cs

@@ -53,6 +53,15 @@ internal static void Execute(ITransformationProvider provider, IMigration migrat
             }
         }
         // These callbacks intentionally run after commit; failure cannot be rolled back.
-        if (step.IsUp) migration.AfterUp(); else migration.AfterDown();
+        After(provider, migration, step.IsUp);
     }
+    internal static void After(ITransformationProvider provider, IMigration migration, bool up)
+    {
+        var concrete = provider as TransformationProvider;
+        var previous = concrete?.CurrentMigration;
+        if (concrete != null) concrete.CurrentMigration = migration;
+        try { if (up) migration.AfterUp(); else migration.AfterDown(); }
+        finally { if (concrete != null) concrete.CurrentMigration = previous; }
+    }
+
 }

src/Migrator/Migrator.cs

@@ -182,6 +182,11 @@ public long? LastAppliedMigrationVersion
     /// </summary>
     public void MigrateToLastVersion()
     {
+        if (_migrationLoader.GetAvailableMigrations().Count == 0)
+        {
+            Logger.Warn("No migrations found for the effective scope.");
+            return;
+        }
         MigrateTo(_migrationLoader.LastVersion);
     }