fix: PR #4039 2026-05-20 review items 1 & 2 — doc/regex alignment + drop AsyncLocal table-name smuggle

Item 1 — IAmARelationalDatabaseConfiguration.SchemaName XML doc previously claimed
Identifiers.AssertSafe enforced a 64-char limit and reserved-prefix collision check,
but the regex enforces neither. Trim the doc to describe what is actually enforced
(^[A-Za-z][A-Za-z0-9_]*$) and rephrase the leading-underscore note in terms of the
first-character letter class, which is what the regex really requires.

Item 2 — MySqlBoxMigrationRunner used AsyncLocal<string?> to smuggle the per-invocation
tableName from LockResourceFor into CreateUnitOfWorkAsync (needed so the UoW could surface
the raw name in its tri-state RELEASE_LOCK Warning, since MySqlMigrationLockName.For
hash-truncates long composites). Change the base abstract signature to pass
(schemaName, tableName) explicitly into CreateUnitOfWorkAsync; the MySQL override reads
the parameter directly and the AsyncLocal field is gone. Removes an implicit cross-hook
coupling.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: iancooper

src/Paramore.Brighter.BoxProvisioning.MsSql/MsSqlBoxMigrationRunner.cs

@@ -101,7 +101,7 @@ protected override async Task<SqlConnection> OpenConnectionAsync(CancellationTok
     }
 
     protected override Task<IAmAProvisioningUnitOfWork<SqlTransaction>> CreateUnitOfWorkAsync(
-        SqlConnection connection, CancellationToken cancellationToken)
+        SqlConnection connection, string? schemaName, string tableName, CancellationToken cancellationToken)
         => Task.FromResult<IAmAProvisioningUnitOfWork<SqlTransaction>>(
             new MsSqlProvisioningUnitOfWork(connection, _advisoryLock, Logger));
 

src/Paramore.Brighter.BoxProvisioning.MySql/MySqlBoxMigrationRunner.cs

@@ -54,13 +54,6 @@ public class MySqlBoxMigrationRunner : SqlBoxMigrationRunner<MySqlConnection, My
 
     private readonly IMySqlAdvisoryLock _advisoryLock;
 
-    // Threaded through the base's LockResourceFor → CreateUnitOfWorkAsync sequence so the
-    // per-invocation tableName reaches MySqlProvisioningUnitOfWork's ctor for NF1-faithful
-    // tri-state RELEASE_LOCK Warning emission (MySqlMigrationLockName.For hash-truncates the
-    // raw tableName for long composites, so lockResource alone cannot surface it). AsyncLocal
-    // preserves correctness under concurrent MigrateAsync invocations on the same instance.
-    private readonly AsyncLocal<string?> _activeTableName = new();
-
     /// <summary>
     /// Initialises the runner with an explicit detection helper and optional UoW dependencies.
     /// </summary>
@@ -108,32 +101,20 @@ protected override async Task<MySqlConnection> OpenConnectionAsync(CancellationT
     }
 
     protected override Task<IAmAProvisioningUnitOfWork<MySqlTransaction>> CreateUnitOfWorkAsync(
-        MySqlConnection connection, CancellationToken cancellationToken)
+        MySqlConnection connection, string? schemaName, string tableName, CancellationToken cancellationToken)
     {
-        // Capture _activeTableName.Value into the UoW ctor and immediately clear the
-        // AsyncLocal so the value does not leak onto the ExecutionContext of any continuation
-        // observed after MigrateAsync returns — per PR #4039 reviewer item M4-4. The base
-        // runner's hook sequence guarantees LockResourceFor (which sets the value) runs
-        // exactly once before CreateUnitOfWorkAsync (which reads it), so clearing here is
-        // safe: no other hook reads _activeTableName, and the UoW has already captured the
-        // string into its `_tableName` field by the time the AsyncLocal is reset.
-        try
-        {
-            return Task.FromResult<IAmAProvisioningUnitOfWork<MySqlTransaction>>(
-                new MySqlProvisioningUnitOfWork(connection, _advisoryLock, Logger, _activeTableName.Value));
-        }
-        finally
-        {
-            _activeTableName.Value = null;
-        }
+        _ = schemaName;
+        // The raw tableName threads into the UoW ctor for NF1-faithful tri-state RELEASE_LOCK
+        // Warning emission — MySqlMigrationLockName.For hash-truncates long composites for the
+        // GET_LOCK 64-char limit, so the lockResource string alone cannot surface the original
+        // name. The base runner passes it explicitly per the LockResourceFor → CreateUnitOfWorkAsync
+        // sequence; no cross-hook state is needed.
+        return Task.FromResult<IAmAProvisioningUnitOfWork<MySqlTransaction>>(
+            new MySqlProvisioningUnitOfWork(connection, _advisoryLock, Logger, tableName));
     }
 
     protected override string LockResourceFor(string? schemaName, string tableName)
     {
-        // Capture the per-invocation table name so CreateUnitOfWorkAsync can thread it into
-        // the UoW ctor for NF1-faithful tri-state Warning emission — MySqlMigrationLockName.For
-        // hash-truncates long composites and would otherwise lose the raw tableName.
-        _activeTableName.Value = tableName;
         // The schema is folded into the lock name so two same-named tables in different schemas
         // acquire distinct advisory locks. MySQL's GET_LOCK has a 64-char limit; the helper
         // hashes names exceeding it (long form) and otherwise preserves the simple form for

src/Paramore.Brighter.BoxProvisioning.PostgreSql/PostgreSqlBoxMigrationRunner.cs

@@ -99,7 +99,7 @@ protected override async Task<NpgsqlConnection> OpenConnectionAsync(Cancellation
     }
 
     protected override Task<IAmAProvisioningUnitOfWork<NpgsqlTransaction>> CreateUnitOfWorkAsync(
-        NpgsqlConnection connection, CancellationToken cancellationToken)
+        NpgsqlConnection connection, string? schemaName, string tableName, CancellationToken cancellationToken)
         => Task.FromResult<IAmAProvisioningUnitOfWork<NpgsqlTransaction>>(
             new PostgreSqlProvisioningUnitOfWork(connection, _advisoryLock, Logger));
 

src/Paramore.Brighter.BoxProvisioning.Sqlite/SqliteBoxMigrationRunner.cs

@@ -151,8 +151,10 @@ protected override async Task<SqliteConnection> OpenConnectionAsync(Cancellation
     }
 
     protected override Task<IAmAProvisioningUnitOfWork<SqliteTransaction>> CreateUnitOfWorkAsync(
-        SqliteConnection connection, CancellationToken cancellationToken)
+        SqliteConnection connection, string? schemaName, string tableName, CancellationToken cancellationToken)
     {
+        _ = schemaName;
+        _ = tableName;
         _ = cancellationToken;
         return Task.FromResult<IAmAProvisioningUnitOfWork<SqliteTransaction>>(
             new SqliteProvisioningUnitOfWork(connection, Logger));

src/Paramore.Brighter.BoxProvisioning/SqlBoxMigrationRunner.cs

@@ -192,7 +192,7 @@ public async Task MigrateAsync(
             {
                 connection = await OpenConnectionAsync(cancellationToken);
                 var lockResource = LockResourceFor(schemaName, tableName);
-                uow = await CreateUnitOfWorkAsync(connection, cancellationToken);
+                uow = await CreateUnitOfWorkAsync(connection, schemaName, tableName, cancellationToken);
                 await uow.BeginAsync(lockResource, _lockTimeout, cancellationToken);
             }
             catch (Exception ex)
@@ -316,10 +316,14 @@ await RunNormalPathAsync(
     /// Constructs the per-backend <see cref="IAmAProvisioningUnitOfWork{TTransaction}"/> over
     /// <paramref name="connection"/>. The runner declares the result with <c>await using</c>
     /// and immediately calls <c>BeginAsync</c>; the implementation should NOT begin the
-    /// lock+transaction here, only construct the UoW.
+    /// lock+transaction here, only construct the UoW. The per-invocation
+    /// <paramref name="schemaName"/> and <paramref name="tableName"/> are passed explicitly
+    /// so backend UoWs that need them at construction (e.g. MySQL's tri-state RELEASE_LOCK
+    /// warning emission, which surfaces the raw table name lost to MySqlMigrationLockName.For's
+    /// hash-truncation) can capture them directly instead of via cross-hook state.
     /// </summary>
     protected abstract Task<IAmAProvisioningUnitOfWork<TTransaction>> CreateUnitOfWorkAsync(
-        TConnection connection, CancellationToken cancellationToken);
+        TConnection connection, string? schemaName, string tableName, CancellationToken cancellationToken);
 
     /// <summary>
     /// Computes the backend-specific advisory lock resource string for the given table.

src/Paramore.Brighter/IAmARelationalDatabaseConfiguration.cs

@@ -46,15 +46,17 @@ public interface IAmARelationalDatabaseConfiguration
         /// </summary>
         /// <value>The schema name, or <c>null</c> for the backend's default schema.</value>
         /// <remarks>
-        /// Box-provisioning enforces a strict regex on identifier inputs (table, column, and
-        /// schema names) at the framework chokepoint via <c>Paramore.Brighter.BoxProvisioning.Identifiers.AssertSafe</c>:
-        /// the accepted character class is <c>[A-Za-z][A-Za-z0-9_]*</c> with length ≤ 64, no
-        /// leading underscore, and no reserved-prefix collisions. The rule is intentionally
-        /// over-restrictive — it applies the strictest-backend rule (Spanner's reserved
-        /// <c>_</c> prefix) uniformly so identifier validation is platform-portable. Schema
-        /// names that fail the regex will surface as <see cref="ConfigurationException"/>
-        /// at provisioning entry rather than as a downstream SQL error. Per PR #4039
-        /// reviewer item M2-7.
+        /// Box-provisioning enforces a regex on identifier inputs (table, column, and schema
+        /// names) at the framework chokepoint via
+        /// <c>Paramore.Brighter.BoxProvisioning.Identifiers.AssertSafe</c>: the accepted pattern
+        /// is <c>^[A-Za-z][A-Za-z0-9_]*$</c> (must start with an ASCII letter; remaining
+        /// characters are ASCII letters, digits, or underscore). The first-character letter
+        /// class excludes leading underscores — Spanner reserves <c>_</c>-prefixed names while
+        /// other backends accept them, so the regex picks the strictest backend's rule to keep
+        /// portable configuration safe. Schema names that fail the regex surface as
+        /// <see cref="ConfigurationException"/> at provisioning entry rather than as a
+        /// downstream SQL error. Per PR #4039 reviewer items M2-7 and the multi-part 2026-05-20
+        /// review item 1.
         /// </remarks>
         string? SchemaName { get; }
     }

tests/Paramore.Brighter.BoxProvisioning.Tests/When_relational_box_migration_runner_base_begin_async_throws_it_should_skip_commit_and_rollback_and_still_dispose.cs

@@ -118,7 +118,7 @@ protected override Task<FakeDbConnection> OpenConnectionAsync(CancellationToken
             => Task.FromResult(new FakeDbConnection());
 
         protected override Task<IAmAProvisioningUnitOfWork<FakeDbTransaction>> CreateUnitOfWorkAsync(
-            FakeDbConnection connection, CancellationToken cancellationToken)
+            FakeDbConnection connection, string? schemaName, string tableName, CancellationToken cancellationToken)
             => Task.FromResult<IAmAProvisioningUnitOfWork<FakeDbTransaction>>(_unitOfWork);
 
         protected override string LockResourceFor(string? schemaName, string tableName)

tests/Paramore.Brighter.BoxProvisioning.Tests/When_relational_box_migration_runner_base_hook_throws_it_should_rollback_with_cancellation_token_none_and_rethrow.cs

@@ -132,7 +132,7 @@ protected override Task<FakeDbConnection> OpenConnectionAsync(CancellationToken
             => Task.FromResult(new FakeDbConnection());
 
         protected override Task<IAmAProvisioningUnitOfWork<FakeDbTransaction>> CreateUnitOfWorkAsync(
-            FakeDbConnection connection, CancellationToken cancellationToken)
+            FakeDbConnection connection, string? schemaName, string tableName, CancellationToken cancellationToken)
             => Task.FromResult<IAmAProvisioningUnitOfWork<FakeDbTransaction>>(_unitOfWork);
 
         protected override string LockResourceFor(string? schemaName, string tableName)

tests/Paramore.Brighter.BoxProvisioning.Tests/When_relational_box_migration_runner_base_migrate_receives_non_monotonic_migrations_it_should_throw_before_opening_connection.cs

@@ -108,7 +108,7 @@ protected override Task<FakeDbConnection> OpenConnectionAsync(CancellationToken
         }
 
         protected override Task<IAmAProvisioningUnitOfWork<FakeDbTransaction>> CreateUnitOfWorkAsync(
-            FakeDbConnection connection, CancellationToken cancellationToken)
+            FakeDbConnection connection, string? schemaName, string tableName, CancellationToken cancellationToken)
             => throw new NotSupportedException("CreateUnitOfWorkAsync must not be reached when validation throws.");
 
         protected override string LockResourceFor(string? schemaName, string tableName)

tests/Paramore.Brighter.BoxProvisioning.Tests/When_relational_box_migration_runner_base_migrate_receives_null_migrations_it_should_throw_before_opening_connection.cs

@@ -105,7 +105,7 @@ protected override Task<FakeDbConnection> OpenConnectionAsync(CancellationToken
         }
 
         protected override Task<IAmAProvisioningUnitOfWork<FakeDbTransaction>> CreateUnitOfWorkAsync(
-            FakeDbConnection connection, CancellationToken cancellationToken)
+            FakeDbConnection connection, string? schemaName, string tableName, CancellationToken cancellationToken)
             => throw new NotSupportedException("CreateUnitOfWorkAsync must not be reached when null-migrations validation throws.");
 
         protected override string LockResourceFor(string? schemaName, string tableName)