diff --git a/.gitignore b/.gitignore
index fa11b45b..5688dff5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,8 +1,10 @@
-^build/
-^coverage/
-^fuzz/luau.pb.*
-^crash-*
-^default.prof*
-^fuzz-*
-^luau$
-/.vs
+/build/
+/build[.-]*/
+/coverage/
+/.vs/
+/.vscode/
+/fuzz/luau.pb.*
+/crash-*
+/default.prof*
+/fuzz-*
+/luau
diff --git a/Analysis/include/Luau/Frontend.h b/Analysis/include/Luau/Frontend.h
index 07a0296a..1f64db30 100644
--- a/Analysis/include/Luau/Frontend.h
+++ b/Analysis/include/Luau/Frontend.h
@@ -68,7 +68,7 @@ struct FrontendOptions
     // is complete.
     bool retainFullTypeGraphs = false;
 
-    // When true, we run typechecking twice, one in the regular mode, ond once in strict mode
+    // When true, we run typechecking twice, once in the regular mode, and once in strict mode
     // in order to get more precise type information (e.g. for autocomplete).
     bool typecheckTwice = false;
 };
@@ -109,18 +109,18 @@ struct Frontend
 
     Frontend(FileResolver* fileResolver, ConfigResolver* configResolver, const FrontendOptions& options = {});
 
-    CheckResult check(const ModuleName& name); // new shininess
-    LintResult lint(const ModuleName& name, std::optional<Luau::LintOptions> enabledLintWarnings = {});
+    CheckResult check(const ModuleName& name, std::optional<FrontendOptions> optionOverride = {}); // new shininess
+    LintResult lint(const ModuleName& name, std::optional<LintOptions> enabledLintWarnings = {});
 
     /** Lint some code that has no associated DataModel object
      *
      * Since this source fragment has no name, we cannot cache its AST.  Instead,
      * we return it to the caller to use as they wish.
      */
-    std::pair<SourceModule, LintResult> lintFragment(std::string_view source, std::optional<Luau::LintOptions> enabledLintWarnings = {});
+    std::pair<SourceModule, LintResult> lintFragment(std::string_view source, std::optional<LintOptions> enabledLintWarnings = {});
 
     CheckResult check(const SourceModule& module); // OLD.  TODO KILL
-    LintResult lint(const SourceModule& module, std::optional<Luau::LintOptions> enabledLintWarnings = {});
+    LintResult lint(const SourceModule& module, std::optional<LintOptions> enabledLintWarnings = {});
 
     bool isDirty(const ModuleName& name) const;
     void markDirty(const ModuleName& name, std::vector<ModuleName>* markedDirty = nullptr);
diff --git a/Analysis/include/Luau/TxnLog.h b/Analysis/include/Luau/TxnLog.h
index 29988a3b..dc45bebf 100644
--- a/Analysis/include/Luau/TxnLog.h
+++ b/Analysis/include/Luau/TxnLog.h
@@ -1,7 +1,11 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #pragma once
 
+#include <memory>
+#include <unordered_map>
+
 #include "Luau/TypeVar.h"
+#include "Luau/TypePack.h"
 
 LUAU_FASTFLAG(LuauShareTxnSeen);
 
@@ -9,27 +13,28 @@ namespace Luau
 {
 
 // Log of where what TypeIds we are rebinding and what they used to be
-struct TxnLog
+// Remove with LuauUseCommitTxnLog
+struct DEPRECATED_TxnLog
 {
-    TxnLog()
+    DEPRECATED_TxnLog()
         : originalSeenSize(0)
         , ownedSeen()
         , sharedSeen(&ownedSeen)
     {
     }
 
-    explicit TxnLog(std::vector<std::pair<TypeId, TypeId>>* sharedSeen)
+    explicit DEPRECATED_TxnLog(std::vector<std::pair<TypeId, TypeId>>* sharedSeen)
         : originalSeenSize(sharedSeen->size())
         , ownedSeen()
         , sharedSeen(sharedSeen)
     {
     }
 
-    TxnLog(const TxnLog&) = delete;
-    TxnLog& operator=(const TxnLog&) = delete;
+    DEPRECATED_TxnLog(const DEPRECATED_TxnLog&) = delete;
+    DEPRECATED_TxnLog& operator=(const DEPRECATED_TxnLog&) = delete;
 
-    TxnLog(TxnLog&&) = default;
-    TxnLog& operator=(TxnLog&&) = default;
+    DEPRECATED_TxnLog(DEPRECATED_TxnLog&&) = default;
+    DEPRECATED_TxnLog& operator=(DEPRECATED_TxnLog&&) = default;
 
     void operator()(TypeId a);
     void operator()(TypePackId a);
@@ -37,7 +42,7 @@ struct TxnLog
 
     void rollback();
 
-    void concat(TxnLog rhs);
+    void concat(DEPRECATED_TxnLog rhs);
 
     bool haveSeen(TypeId lhs, TypeId rhs);
     void pushSeen(TypeId lhs, TypeId rhs);
@@ -54,4 +59,263 @@ public:
     std::vector<std::pair<TypeId, TypeId>>* sharedSeen; // shared with all the descendent logs
 };
 
+// Pending state for a TypeVar. Generated by a TxnLog and committed via
+// TxnLog::commit.
+struct PendingType
+{
+    // The pending TypeVar state.
+    TypeVar pending;
+
+    explicit PendingType(TypeVar state)
+        : pending(std::move(state))
+    {
+    }
+};
+
+// Pending state for a TypePackVar. Generated by a TxnLog and committed via
+// TxnLog::commit.
+struct PendingTypePack
+{
+    // The pending TypePackVar state.
+    TypePackVar pending;
+
+    explicit PendingTypePack(TypePackVar state)
+        : pending(std::move(state))
+    {
+    }
+};
+
+template<typename T>
+T* getMutable(PendingType* pending)
+{
+    // We use getMutable here because this state is intended to be mutated freely.
+    return getMutable<T>(&pending->pending);
+}
+
+template<typename T>
+T* getMutable(PendingTypePack* pending)
+{
+    // We use getMutable here because this state is intended to be mutated freely.
+    return getMutable<T>(&pending->pending);
+}
+
+// Log of what TypeIds we are rebinding, to be committed later.
+struct TxnLog
+{
+    TxnLog()
+        : ownedSeen()
+        , sharedSeen(&ownedSeen)
+    {
+    }
+
+    explicit TxnLog(TxnLog* parent)
+        : parent(parent)
+    {
+        if (parent)
+        {
+            sharedSeen = parent->sharedSeen;
+        }
+        else
+        {
+            sharedSeen = &ownedSeen;
+        }
+    }
+
+    explicit TxnLog(std::vector<std::pair<TypeId, TypeId>>* sharedSeen)
+        : sharedSeen(sharedSeen)
+    {
+    }
+
+    TxnLog(TxnLog* parent, std::vector<std::pair<TypeId, TypeId>>* sharedSeen)
+        : parent(parent)
+        , sharedSeen(sharedSeen)
+    {
+    }
+
+    TxnLog(const TxnLog&) = delete;
+    TxnLog& operator=(const TxnLog&) = delete;
+
+    TxnLog(TxnLog&&) = default;
+    TxnLog& operator=(TxnLog&&) = default;
+
+    // Gets an empty TxnLog pointer. This is useful for constructs that
+    // take a TxnLog, like TypePackIterator - use the empty log if you
+    // don't have a TxnLog to give it.
+    static const TxnLog* empty();
+
+    // Joins another TxnLog onto this one. You should use std::move to avoid
+    // copying the rhs TxnLog.
+    //
+    // If both logs talk about the same type, pack, or table, the rhs takes
+    // priority.
+    void concat(TxnLog rhs);
+
+    // Commits the TxnLog, rebinding all type pointers to their pending states.
+    // Clears the TxnLog afterwards.
+    void commit();
+
+    // Clears the TxnLog without committing any pending changes.
+    void clear();
+
+    // Computes an inverse of this TxnLog at the current time.
+    // This method should be called before commit is called in order to give an
+    // accurate result. Committing the inverse of a TxnLog will undo the changes
+    // made by commit, assuming the inverse log is accurate.
+    TxnLog inverse();
+
+    bool haveSeen(TypeId lhs, TypeId rhs) const;
+    void pushSeen(TypeId lhs, TypeId rhs);
+    void popSeen(TypeId lhs, TypeId rhs);
+
+    // Queues a type for modification. The original type will not change until commit
+    // is called. Use pending to get the pending state.
+    //
+    // The pointer returned lives until `commit` or `clear` is called.
+    PendingType* queue(TypeId ty);
+
+    // Queues a type pack for modification. The original type pack will not change
+    // until commit is called. Use pending to get the pending state.
+    //
+    // The pointer returned lives until `commit` or `clear` is called.
+    PendingTypePack* queue(TypePackId tp);
+
+    // Returns the pending state of a type, or nullptr if there isn't any. It is important
+    // to note that this pending state is not transitive: the pending state may reference
+    // non-pending types freely, so you may need to call pending multiple times to view the
+    // entire pending state of a type graph.
+    //
+    // The pointer returned lives until `commit` or `clear` is called.
+    PendingType* pending(TypeId ty) const;
+
+    // Returns the pending state of a type pack, or nullptr if there isn't any. It is
+    // important to note that this pending state is not transitive: the pending state may
+    // reference non-pending types freely, so you may need to call pending multiple times
+    // to view the entire pending state of a type graph.
+    //
+    // The pointer returned lives until `commit` or `clear` is called.
+    PendingTypePack* pending(TypePackId tp) const;
+
+    // Queues a replacement of a type with another type.
+    //
+    // The pointer returned lives until `commit` or `clear` is called.
+    PendingType* replace(TypeId ty, TypeVar replacement);
+
+    // Queues a replacement of a type pack with another type pack.
+    //
+    // The pointer returned lives until `commit` or `clear` is called.
+    PendingTypePack* replace(TypePackId tp, TypePackVar replacement);
+
+    // Queues a replacement of a table type with another table type that is bound
+    // to a specific value.
+    //
+    // The pointer returned lives until `commit` or `clear` is called.
+    PendingType* bindTable(TypeId ty, std::optional<TypeId> newBoundTo);
+
+    // Queues a replacement of a type with a level with a duplicate of that type
+    // with a new type level.
+    //
+    // The pointer returned lives until `commit` or `clear` is called.
+    PendingType* changeLevel(TypeId ty, TypeLevel newLevel);
+
+    // Queues a replacement of a type pack with a level with a duplicate of that
+    // type pack with a new type level.
+    //
+    // The pointer returned lives until `commit` or `clear` is called.
+    PendingTypePack* changeLevel(TypePackId tp, TypeLevel newLevel);
+
+    // Queues a replacement of a table type with another table type with a new
+    // indexer.
+    //
+    // The pointer returned lives until `commit` or `clear` is called.
+    PendingType* changeIndexer(TypeId ty, std::optional<TableIndexer> indexer);
+
+    // Returns the type level of the pending state of the type, or the level of that
+    // type, if no pending state exists. If the type doesn't have a notion of a level,
+    // returns nullopt. If the pending state doesn't have a notion of a level, but the
+    // original state does, returns nullopt.
+    std::optional<TypeLevel> getLevel(TypeId ty) const;
+
+    // Follows a type, accounting for pending type states. The returned type may have
+    // pending state; you should use `pending` or `get` to find out.
+    TypeId follow(TypeId ty);
+
+    // Follows a type pack, accounting for pending type states. The returned type pack
+    // may have pending state; you should use `pending` or `get` to find out.
+    TypePackId follow(TypePackId tp) const;
+
+    // Replaces a given type's state with a new variant. Returns the new pending state
+    // of that type.
+    //
+    // The pointer returned lives until `commit` or `clear` is called.
+    template<typename T>
+    PendingType* replace(TypeId ty, T replacement)
+    {
+        return replace(ty, TypeVar(replacement));
+    }
+
+    // Replaces a given type pack's state with a new variant. Returns the new
+    // pending state of that type pack.
+    //
+    // The pointer returned lives until `commit` or `clear` is called.
+    template<typename T>
+    PendingTypePack* replace(TypePackId tp, T replacement)
+    {
+        return replace(tp, TypePackVar(replacement));
+    }
+
+    // Returns T if a given type or type pack is this variant, respecting the
+    // log's pending state.
+    //
+    // Do not retain this pointer; it has the potential to be invalidated when
+    // commit or clear is called.
+    template<typename T, typename TID>
+    T* getMutable(TID ty) const
+    {
+        auto* pendingTy = pending(ty);
+        if (pendingTy)
+            return Luau::getMutable<T>(pendingTy);
+
+        return Luau::getMutable<T>(ty);
+    }
+
+    // Returns whether a given type or type pack is a given state, respecting the
+    // log's pending state.
+    //
+    // This method will not assert if called on a BoundTypeVar or BoundTypePack.
+    template<typename T, typename TID>
+    bool is(TID ty) const
+    {
+        // We do not use getMutable here because this method can be called on
+        // BoundTypeVars, which triggers an assertion.
+        auto* pendingTy = pending(ty);
+        if (pendingTy)
+            return Luau::get_if<T>(&pendingTy->pending.ty) != nullptr;
+
+        return Luau::get_if<T>(&ty->ty) != nullptr;
+    }
+
+private:
+    // unique_ptr is used to give us stable pointers across insertions into the
+    // map. Otherwise, it would be really easy to accidentally invalidate the
+    // pointers returned from queue/pending.
+    //
+    // We can't use a DenseHashMap here because we need a non-const iterator
+    // over the map when we concatenate.
+    std::unordered_map<TypeId, std::unique_ptr<PendingType>> typeVarChanges;
+    std::unordered_map<TypePackId, std::unique_ptr<PendingTypePack>> typePackChanges;
+
+    TxnLog* parent = nullptr;
+
+    // Owned version of sharedSeen. This should not be accessed directly in
+    // TxnLogs; use sharedSeen instead. This field exists because in the tree
+    // of TxnLogs, the root must own its seen set. In all descendant TxnLogs,
+    // this is an empty vector.
+    std::vector<std::pair<TypeId, TypeId>> ownedSeen;
+
+public:
+    // Used to avoid infinite recursion when types are cyclic.
+    // Shared with all the descendent TxnLogs.
+    std::vector<std::pair<TypeId, TypeId>>* sharedSeen;
+};
+
 } // namespace Luau
diff --git a/Analysis/include/Luau/TypeInfer.h b/Analysis/include/Luau/TypeInfer.h
index 862f50d7..312283b0 100644
--- a/Analysis/include/Luau/TypeInfer.h
+++ b/Analysis/include/Luau/TypeInfer.h
@@ -198,32 +198,32 @@ struct TypeChecker
      */
     TypeId anyIfNonstrict(TypeId ty) const;
 
-    /** Attempt to unify the types left and right.  Treat any failures as type errors
-     * in the final typecheck report.
+    /** Attempt to unify the types.
+     * Treat any failures as type errors in the final typecheck report.
      */
-    bool unify(TypeId left, TypeId right, const Location& location);
-    bool unify(TypePackId left, TypePackId right, const Location& location, CountMismatch::Context ctx = CountMismatch::Context::Arg);
+    bool unify(TypeId subTy, TypeId superTy, const Location& location);
+    bool unify(TypePackId subTy, TypePackId superTy, const Location& location, CountMismatch::Context ctx = CountMismatch::Context::Arg);
 
-    /** Attempt to unify the types left and right.
-     * If this fails, and the right type can be instantiated, do so and try unification again.
+    /** Attempt to unify the types.
+     * If this fails, and the subTy type can be instantiated, do so and try unification again.
      */
-    bool unifyWithInstantiationIfNeeded(const ScopePtr& scope, TypeId left, TypeId right, const Location& location);
-    void unifyWithInstantiationIfNeeded(const ScopePtr& scope, TypeId left, TypeId right, Unifier& state);
+    bool unifyWithInstantiationIfNeeded(const ScopePtr& scope, TypeId subTy, TypeId superTy, const Location& location);
+    void unifyWithInstantiationIfNeeded(const ScopePtr& scope, TypeId subTy, TypeId superTy, Unifier& state);
 
-    /** Attempt to unify left with right.
+    /** Attempt to unify.
      * If there are errors, undo everything and return the errors.
      * If there are no errors, commit and return an empty error vector.
      */
-    ErrorVec tryUnify(TypeId left, TypeId right, const Location& location);
-    ErrorVec tryUnify(TypePackId left, TypePackId right, const Location& location);
+    template<typename Id>
+    ErrorVec tryUnify_(Id subTy, Id superTy, const Location& location);
+    ErrorVec tryUnify(TypeId subTy, TypeId superTy, const Location& location);
+    ErrorVec tryUnify(TypePackId subTy, TypePackId superTy, const Location& location);
 
     // Test whether the two type vars unify.  Never commits the result.
-    ErrorVec canUnify(TypeId superTy, TypeId subTy, const Location& location);
-    ErrorVec canUnify(TypePackId superTy, TypePackId subTy, const Location& location);
-
-    // Variant that takes a preexisting 'seen' set.  We need this in certain cases to avoid infinitely recursing
-    // into cyclic types.
-    ErrorVec canUnify(const std::vector<std::pair<TypeId, TypeId>>& seen, TypeId left, TypeId right, const Location& location);
+    template<typename Id>
+    ErrorVec canUnify_(Id subTy, Id superTy, const Location& location);
+    ErrorVec canUnify(TypeId subTy, TypeId superTy, const Location& location);
+    ErrorVec canUnify(TypePackId subTy, TypePackId superTy, const Location& location);
 
     std::optional<TypeId> findMetatableEntry(TypeId type, std::string entry, const Location& location);
     std::optional<TypeId> findTablePropertyRespectingMeta(TypeId lhsType, Name name, const Location& location);
@@ -237,12 +237,6 @@ struct TypeChecker
     std::optional<TypeId> tryStripUnionFromNil(TypeId ty);
     TypeId stripFromNilAndReport(TypeId ty, const Location& location);
 
-    template<typename Id>
-    ErrorVec tryUnify_(Id left, Id right, const Location& location);
-
-    template<typename Id>
-    ErrorVec canUnify_(Id left, Id right, const Location& location);
-
 public:
     /*
      * Convert monotype into a a polytype, by replacing any metavariables in descendant scopes
diff --git a/Analysis/include/Luau/TypePack.h b/Analysis/include/Luau/TypePack.h
index e72808da..ca588ccb 100644
--- a/Analysis/include/Luau/TypePack.h
+++ b/Analysis/include/Luau/TypePack.h
@@ -18,6 +18,8 @@ struct VariadicTypePack;
 
 struct TypePackVar;
 
+struct TxnLog;
+
 using TypePackId = const TypePackVar*;
 using FreeTypePack = Unifiable::Free;
 using BoundTypePack = Unifiable::Bound<TypePackId>;
@@ -84,6 +86,7 @@ struct TypePackIterator
 
     TypePackIterator() = default;
     explicit TypePackIterator(TypePackId tp);
+    TypePackIterator(TypePackId tp, const TxnLog* log);
 
     TypePackIterator& operator++();
     TypePackIterator operator++(int);
@@ -104,9 +107,13 @@ private:
     TypePackId currentTypePack = nullptr;
     const TypePack* tp = nullptr;
     size_t currentIndex = 0;
+
+    // Only used if LuauUseCommittingTxnLog is true.
+    const TxnLog* log;
 };
 
 TypePackIterator begin(TypePackId tp);
+TypePackIterator begin(TypePackId tp, TxnLog* log);
 TypePackIterator end(TypePackId tp);
 
 using SeenSet = std::set<std::pair<void*, void*>>;
@@ -114,6 +121,7 @@ using SeenSet = std::set<std::pair<void*, void*>>;
 bool areEqual(SeenSet& seen, const TypePackVar& lhs, const TypePackVar& rhs);
 
 TypePackId follow(TypePackId tp);
+TypePackId follow(TypePackId tp, std::function<TypePackId(TypePackId)> mapper);
 
 size_t size(TypePackId tp);
 bool finite(TypePackId tp);
diff --git a/Analysis/include/Luau/TypeVar.h b/Analysis/include/Luau/TypeVar.h
index f6829ec3..d6e17714 100644
--- a/Analysis/include/Luau/TypeVar.h
+++ b/Analysis/include/Luau/TypeVar.h
@@ -453,6 +453,7 @@ bool areEqual(SeenSet& seen, const TypeVar& lhs, const TypeVar& rhs);
 
 // Follow BoundTypeVars until we get to something real
 TypeId follow(TypeId t);
+TypeId follow(TypeId t, std::function<TypeId(TypeId)> mapper);
 
 std::vector<TypeId> flattenIntersection(TypeId ty);
 
diff --git a/Analysis/include/Luau/TypedAllocator.h b/Analysis/include/Luau/TypedAllocator.h
index 0ded1489..64227e7c 100644
--- a/Analysis/include/Luau/TypedAllocator.h
+++ b/Analysis/include/Luau/TypedAllocator.h
@@ -6,6 +6,8 @@
 #include <vector>
 #include <memory>
 
+LUAU_FASTFLAG(LuauTypedAllocatorZeroStart)
+
 namespace Luau
 {
 
@@ -20,7 +22,10 @@ class TypedAllocator
 public:
     TypedAllocator()
     {
-        appendBlock();
+        if (FFlag::LuauTypedAllocatorZeroStart)
+            currentBlockSize = kBlockSize;
+        else
+            appendBlock();
     }
 
     ~TypedAllocator()
@@ -59,12 +64,18 @@ public:
 
     bool empty() const
     {
-        return stuff.size() == 1 && currentBlockSize == 0;
+        if (FFlag::LuauTypedAllocatorZeroStart)
+            return stuff.empty();
+        else
+            return stuff.size() == 1 && currentBlockSize == 0;
     }
 
     size_t size() const
     {
-        return kBlockSize * (stuff.size() - 1) + currentBlockSize;
+        if (FFlag::LuauTypedAllocatorZeroStart)
+            return stuff.empty() ? 0 : kBlockSize * (stuff.size() - 1) + currentBlockSize;
+        else
+            return kBlockSize * (stuff.size() - 1) + currentBlockSize;
     }
 
     void clear()
@@ -72,7 +83,11 @@ public:
         if (frozen)
             unfreeze();
         free();
-        appendBlock();
+
+        if (FFlag::LuauTypedAllocatorZeroStart)
+            currentBlockSize = kBlockSize;
+        else
+            appendBlock();
     }
 
     void freeze()
diff --git a/Analysis/include/Luau/Unifier.h b/Analysis/include/Luau/Unifier.h
index 7681b966..a3be739a 100644
--- a/Analysis/include/Luau/Unifier.h
+++ b/Analysis/include/Luau/Unifier.h
@@ -25,6 +25,7 @@ struct Unifier
     Mode mode;
     ScopePtr globalScope; // sigh.  Needed solely to get at string's metatable.
 
+    DEPRECATED_TxnLog DEPRECATED_log;
     TxnLog log;
     ErrorVec errors;
     Location location;
@@ -33,44 +34,45 @@ struct Unifier
 
     UnifierSharedState& sharedState;
 
-    Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, const Location& location, Variance variance, UnifierSharedState& sharedState);
+    Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, const Location& location, Variance variance, UnifierSharedState& sharedState,
+        TxnLog* parentLog = nullptr);
     Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, std::vector<std::pair<TypeId, TypeId>>* sharedSeen, const Location& location,
-        Variance variance, UnifierSharedState& sharedState);
+        Variance variance, UnifierSharedState& sharedState, TxnLog* parentLog = nullptr);
 
     // Test whether the two type vars unify.  Never commits the result.
-    ErrorVec canUnify(TypeId superTy, TypeId subTy);
-    ErrorVec canUnify(TypePackId superTy, TypePackId subTy, bool isFunctionCall = false);
+    ErrorVec canUnify(TypeId subTy, TypeId superTy);
+    ErrorVec canUnify(TypePackId subTy, TypePackId superTy, bool isFunctionCall = false);
 
-    /** Attempt to unify left with right.
+    /** Attempt to unify.
      * Populate the vector errors with any type errors that may arise.
      * Populate the transaction log with the set of TypeIds that need to be reset to undo the unification attempt.
      */
-    void tryUnify(TypeId superTy, TypeId subTy, bool isFunctionCall = false, bool isIntersection = false);
+    void tryUnify(TypeId subTy, TypeId superTy, bool isFunctionCall = false, bool isIntersection = false);
 
 private:
-    void tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall = false, bool isIntersection = false);
-    void tryUnifyPrimitives(TypeId superTy, TypeId subTy);
-    void tryUnifySingletons(TypeId superTy, TypeId subTy);
-    void tryUnifyFunctions(TypeId superTy, TypeId subTy, bool isFunctionCall = false);
-    void tryUnifyTables(TypeId left, TypeId right, bool isIntersection = false);
-    void DEPRECATED_tryUnifyTables(TypeId left, TypeId right, bool isIntersection = false);
-    void tryUnifyFreeTable(TypeId free, TypeId other);
-    void tryUnifySealedTables(TypeId left, TypeId right, bool isIntersection);
-    void tryUnifyWithMetatable(TypeId metatable, TypeId other, bool reversed);
-    void tryUnifyWithClass(TypeId superTy, TypeId subTy, bool reversed);
-    void tryUnify(const TableIndexer& superIndexer, const TableIndexer& subIndexer);
+    void tryUnify_(TypeId subTy, TypeId superTy, bool isFunctionCall = false, bool isIntersection = false);
+    void tryUnifyPrimitives(TypeId subTy, TypeId superTy);
+    void tryUnifySingletons(TypeId subTy, TypeId superTy);
+    void tryUnifyFunctions(TypeId subTy, TypeId superTy, bool isFunctionCall = false);
+    void tryUnifyTables(TypeId subTy, TypeId superTy, bool isIntersection = false);
+    void DEPRECATED_tryUnifyTables(TypeId subTy, TypeId superTy, bool isIntersection = false);
+    void tryUnifyFreeTable(TypeId subTy, TypeId superTy);
+    void tryUnifySealedTables(TypeId subTy, TypeId superTy, bool isIntersection);
+    void tryUnifyWithMetatable(TypeId subTy, TypeId superTy, bool reversed);
+    void tryUnifyWithClass(TypeId subTy, TypeId superTy, bool reversed);
+    void tryUnifyIndexer(const TableIndexer& subIndexer, const TableIndexer& superIndexer);
     TypeId deeplyOptional(TypeId ty, std::unordered_map<TypeId, TypeId> seen = {});
-    void cacheResult(TypeId superTy, TypeId subTy);
+    void cacheResult(TypeId subTy, TypeId superTy);
 
 public:
-    void tryUnify(TypePackId superTy, TypePackId subTy, bool isFunctionCall = false);
+    void tryUnify(TypePackId subTy, TypePackId superTy, bool isFunctionCall = false);
 
 private:
-    void tryUnify_(TypePackId superTy, TypePackId subTy, bool isFunctionCall = false);
-    void tryUnifyVariadics(TypePackId superTy, TypePackId subTy, bool reversed, int subOffset = 0);
+    void tryUnify_(TypePackId subTy, TypePackId superTy, bool isFunctionCall = false);
+    void tryUnifyVariadics(TypePackId subTy, TypePackId superTy, bool reversed, int subOffset = 0);
 
-    void tryUnifyWithAny(TypeId any, TypeId ty);
-    void tryUnifyWithAny(TypePackId any, TypePackId ty);
+    void tryUnifyWithAny(TypeId subTy, TypeId anyTy);
+    void tryUnifyWithAny(TypePackId subTy, TypePackId anyTp);
 
     std::optional<TypeId> findTablePropertyRespectingMeta(TypeId lhsType, Name name);
 
diff --git a/Analysis/src/Autocomplete.cpp b/Analysis/src/Autocomplete.cpp
index 4b583792..67ebd075 100644
--- a/Analysis/src/Autocomplete.cpp
+++ b/Analysis/src/Autocomplete.cpp
@@ -12,10 +12,12 @@
 #include <unordered_set>
 #include <utility>
 
+LUAU_FASTFLAG(LuauUseCommittingTxnLog)
 LUAU_FASTFLAG(LuauIfElseExpressionAnalysisSupport)
 LUAU_FASTFLAGVARIABLE(LuauAutocompleteAvoidMutation, false);
 LUAU_FASTFLAGVARIABLE(LuauAutocompletePreferToCallFunctions, false);
 LUAU_FASTFLAGVARIABLE(LuauAutocompleteFirstArg, false);
+LUAU_FASTFLAGVARIABLE(LuauCompleteBrokenStringParams, false);
 
 static const std::unordered_set<std::string> kStatementStartingKeywords = {
     "while", "if", "local", "repeat", "function", "do", "for", "return", "break", "continue", "type", "export"};
@@ -236,28 +238,31 @@ static TypeCorrectKind checkTypeCorrectKind(const Module& module, TypeArena* typ
 {
     ty = follow(ty);
 
-    auto canUnify = [&typeArena, &module](TypeId expectedType, TypeId actualType) {
+    auto canUnify = [&typeArena, &module](TypeId subTy, TypeId superTy) {
         InternalErrorReporter iceReporter;
         UnifierSharedState unifierState(&iceReporter);
         Unifier unifier(typeArena, Mode::Strict, module.getModuleScope(), Location(), Variance::Covariant, unifierState);
 
-        if (FFlag::LuauAutocompleteAvoidMutation)
+        if (FFlag::LuauAutocompleteAvoidMutation && !FFlag::LuauUseCommittingTxnLog)
         {
             SeenTypes seenTypes;
             SeenTypePacks seenTypePacks;
             CloneState cloneState;
-            expectedType = clone(expectedType, *typeArena, seenTypes, seenTypePacks, cloneState);
-            actualType = clone(actualType, *typeArena, seenTypes, seenTypePacks, cloneState);
+            superTy = clone(superTy, *typeArena, seenTypes, seenTypePacks, cloneState);
+            subTy = clone(subTy, *typeArena, seenTypes, seenTypePacks, cloneState);
 
-            auto errors = unifier.canUnify(expectedType, actualType);
+            auto errors = unifier.canUnify(subTy, superTy);
             return errors.empty();
         }
         else
         {
-            unifier.tryUnify(expectedType, actualType);
+            unifier.tryUnify(subTy, superTy);
 
             bool ok = unifier.errors.empty();
-            unifier.log.rollback();
+
+            if (!FFlag::LuauUseCommittingTxnLog)
+                unifier.DEPRECATED_log.rollback();
+
             return ok;
         }
     };
@@ -293,22 +298,22 @@ static TypeCorrectKind checkTypeCorrectKind(const Module& module, TypeArena* typ
         {
             auto [retHead, retTail] = flatten(ftv->retType);
 
-            if (!retHead.empty() && canUnify(expectedType, retHead.front()))
+            if (!retHead.empty() && canUnify(retHead.front(), expectedType))
                 return TypeCorrectKind::CorrectFunctionResult;
 
             // We might only have a variadic tail pack, check if the element is compatible
             if (retTail)
             {
-                if (const VariadicTypePack* vtp = get<VariadicTypePack>(follow(*retTail)); vtp && canUnify(expectedType, vtp->ty))
+                if (const VariadicTypePack* vtp = get<VariadicTypePack>(follow(*retTail)); vtp && canUnify(vtp->ty, expectedType))
                     return TypeCorrectKind::CorrectFunctionResult;
             }
         }
 
-        return canUnify(expectedType, ty) ? TypeCorrectKind::Correct : TypeCorrectKind::None;
+        return canUnify(ty, expectedType) ? TypeCorrectKind::Correct : TypeCorrectKind::None;
     }
     else
     {
-        if (canUnify(expectedType, ty))
+        if (canUnify(ty, expectedType))
             return TypeCorrectKind::Correct;
 
         // We also want to suggest functions that return compatible result
@@ -320,13 +325,13 @@ static TypeCorrectKind checkTypeCorrectKind(const Module& module, TypeArena* typ
         auto [retHead, retTail] = flatten(ftv->retType);
 
         if (!retHead.empty())
-            return canUnify(expectedType, retHead.front()) ? TypeCorrectKind::CorrectFunctionResult : TypeCorrectKind::None;
+            return canUnify(retHead.front(), expectedType) ? TypeCorrectKind::CorrectFunctionResult : TypeCorrectKind::None;
 
         // We might only have a variadic tail pack, check if the element is compatible
         if (retTail)
         {
             if (const VariadicTypePack* vtp = get<VariadicTypePack>(follow(*retTail)))
-                return canUnify(expectedType, vtp->ty) ? TypeCorrectKind::CorrectFunctionResult : TypeCorrectKind::None;
+                return canUnify(vtp->ty, expectedType) ? TypeCorrectKind::CorrectFunctionResult : TypeCorrectKind::None;
         }
 
         return TypeCorrectKind::None;
@@ -1319,7 +1324,7 @@ static std::optional<AutocompleteEntryMap> autocompleteStringParams(const Source
         return std::nullopt;
     }
 
-    if (!nodes.back()->is<AstExprConstantString>())
+    if (!nodes.back()->is<AstExprConstantString>() && (!FFlag::LuauCompleteBrokenStringParams || !nodes.back()->is<AstExprError>()))
     {
         return std::nullopt;
     }
diff --git a/Analysis/src/EmbeddedBuiltinDefinitions.cpp b/Analysis/src/EmbeddedBuiltinDefinitions.cpp
index d0afa742..24982506 100644
--- a/Analysis/src/EmbeddedBuiltinDefinitions.cpp
+++ b/Analysis/src/EmbeddedBuiltinDefinitions.cpp
@@ -138,12 +138,7 @@ declare function gcinfo(): number
             -- (nil, string).
             declare function loadstring<A...>(src: string, chunkname: string?): (((A...) -> any)?, string?)
 
-            -- a userdata object is "roughly" the same as a sealed empty table
-            -- except `type(newproxy(false))` evaluates to "userdata" so we may need another special type here too.
-            -- another important thing to note: the value passed in conditionally creates an empty metatable, and you have to use getmetatable, NOT
-            -- setmetatable.
-            -- FIXME: change this to something Luau can understand how to reject `setmetatable(newproxy(false or true), {})`.
-            declare function newproxy(mt: boolean?): {}
+            declare function newproxy(mt: boolean?): any
 
             declare coroutine: {
                 create: <A..., R...>((A...) -> R...) -> thread,
diff --git a/Analysis/src/Frontend.cpp b/Analysis/src/Frontend.cpp
index e332f07d..fe4b6529 100644
--- a/Analysis/src/Frontend.cpp
+++ b/Analysis/src/Frontend.cpp
@@ -351,7 +351,7 @@ FrontendModuleResolver::FrontendModuleResolver(Frontend* frontend)
 {
 }
 
-CheckResult Frontend::check(const ModuleName& name)
+CheckResult Frontend::check(const ModuleName& name, std::optional<FrontendOptions> optionOverride)
 {
     LUAU_TIMETRACE_SCOPE("Frontend::check", "Frontend");
     LUAU_TIMETRACE_ARGUMENT("name", name.c_str());
@@ -372,6 +372,8 @@ CheckResult Frontend::check(const ModuleName& name)
     std::vector<ModuleName> buildQueue;
     bool cycleDetected = parseGraph(buildQueue, checkResult, name);
 
+    FrontendOptions frontendOptions = optionOverride.value_or(options);
+
     // Keep track of which AST nodes we've reported cycles in
     std::unordered_set<AstNode*> reportedCycles;
 
@@ -411,31 +413,11 @@ CheckResult Frontend::check(const ModuleName& name)
         // If we're typechecking twice, we do so.
         // The second typecheck is always in strict mode with DM awareness
         // to provide better typen information for IDE features.
-        if (options.typecheckTwice)
+        if (frontendOptions.typecheckTwice)
         {
             ModulePtr moduleForAutocomplete = typeCheckerForAutocomplete.check(sourceModule, Mode::Strict);
             moduleResolverForAutocomplete.modules[moduleName] = moduleForAutocomplete;
         }
-        else if (options.retainFullTypeGraphs && options.typecheckTwice && mode != Mode::Strict)
-        {
-            ModulePtr strictModule = typeChecker.check(sourceModule, Mode::Strict, environmentScope);
-            module->astTypes.clear();
-            module->astOriginalCallTypes.clear();
-            module->astExpectedTypes.clear();
-
-            SeenTypes seenTypes;
-            SeenTypePacks seenTypePacks;
-            CloneState cloneState;
-
-            for (const auto& [expr, strictTy] : strictModule->astTypes)
-                module->astTypes[expr] = clone(strictTy, module->interfaceTypes, seenTypes, seenTypePacks, cloneState);
-
-            for (const auto& [expr, strictTy] : strictModule->astOriginalCallTypes)
-                module->astOriginalCallTypes[expr] = clone(strictTy, module->interfaceTypes, seenTypes, seenTypePacks, cloneState);
-
-            for (const auto& [expr, strictTy] : strictModule->astExpectedTypes)
-                module->astExpectedTypes[expr] = clone(strictTy, module->interfaceTypes, seenTypes, seenTypePacks, cloneState);
-        }
 
         stats.timeCheck += getTimestamp() - timestamp;
         stats.filesStrict += mode == Mode::Strict;
@@ -444,7 +426,7 @@ CheckResult Frontend::check(const ModuleName& name)
         if (module == nullptr)
             throw std::runtime_error("Frontend::check produced a nullptr module for " + moduleName);
 
-        if (!options.retainFullTypeGraphs)
+        if (!frontendOptions.retainFullTypeGraphs)
         {
             // copyErrors needs to allocate into interfaceTypes as it copies
             // types out of internalTypes, so we unfreeze it here.
diff --git a/Analysis/src/Module.cpp b/Analysis/src/Module.cpp
index e1e53c97..cff85897 100644
--- a/Analysis/src/Module.cpp
+++ b/Analysis/src/Module.cpp
@@ -13,7 +13,7 @@
 
 LUAU_FASTFLAGVARIABLE(DebugLuauFreezeArena, false)
 LUAU_FASTFLAGVARIABLE(DebugLuauTrackOwningArena, false)
-LUAU_FASTINTVARIABLE(LuauTypeCloneRecursionLimit, 0)
+LUAU_FASTINTVARIABLE(LuauTypeCloneRecursionLimit, 300)
 
 namespace Luau
 {
diff --git a/Analysis/src/Quantify.cpp b/Analysis/src/Quantify.cpp
index c773e208..04ebffc1 100644
--- a/Analysis/src/Quantify.cpp
+++ b/Analysis/src/Quantify.cpp
@@ -4,8 +4,6 @@
 
 #include "Luau/VisitTypeVar.h"
 
-LUAU_FASTFLAGVARIABLE(LuauQuantifyVisitOnce, false)
-
 namespace Luau
 {
 
@@ -81,16 +79,8 @@ struct Quantifier
 void quantify(ModulePtr module, TypeId ty, TypeLevel level)
 {
     Quantifier q{std::move(module), level};
-
-    if (FFlag::LuauQuantifyVisitOnce)
-    {
-        DenseHashSet<void*> seen{nullptr};
-        visitTypeVarOnce(ty, q, seen);
-    }
-    else
-    {
-        visitTypeVar(ty, q);
-    }
+    DenseHashSet<void*> seen{nullptr};
+    visitTypeVarOnce(ty, q, seen);
 
     FunctionTypeVar* ftv = getMutable<FunctionTypeVar>(ty);
     LUAU_ASSERT(ftv);
diff --git a/Analysis/src/ToString.cpp b/Analysis/src/ToString.cpp
index a6be5348..889dd6dc 100644
--- a/Analysis/src/ToString.cpp
+++ b/Analysis/src/ToString.cpp
@@ -11,7 +11,6 @@
 #include <stdexcept>
 
 LUAU_FASTFLAG(LuauOccursCheckOkWithRecursiveFunctions)
-LUAU_FASTFLAGVARIABLE(LuauFunctionArgumentNameSize, false)
 
 /*
  * Prefix generic typenames with gen-
@@ -766,24 +765,12 @@ struct TypePackStringifier
             else
                 state.emit(", ");
 
-            if (FFlag::LuauFunctionArgumentNameSize)
+            if (elemIndex < elemNames.size() && elemNames[elemIndex])
             {
-                if (elemIndex < elemNames.size() && elemNames[elemIndex])
-                {
-                    state.emit(elemNames[elemIndex]->name);
-                    state.emit(": ");
-                }
+                state.emit(elemNames[elemIndex]->name);
+                state.emit(": ");
             }
-            else
-            {
-                LUAU_ASSERT(elemNames.empty() || elemIndex < elemNames.size());
 
-                if (!elemNames.empty() && elemNames[elemIndex])
-                {
-                    state.emit(elemNames[elemIndex]->name);
-                    state.emit(": ");
-                }
-            }
             elemIndex++;
 
             stringify(typeId);
@@ -1151,38 +1138,19 @@ std::string toStringNamedFunction(const std::string& prefix, const FunctionTypeV
             s += ", ";
         first = false;
 
-        if (FFlag::LuauFunctionArgumentNameSize)
+        // We don't currently respect opts.functionTypeArguments. I don't think this function should.
+        if (argNameIter != ftv.argNames.end())
         {
-            // We don't currently respect opts.functionTypeArguments. I don't think this function should.
-            if (argNameIter != ftv.argNames.end())
-            {
-                s += (*argNameIter ? (*argNameIter)->name : "_") + ": ";
-                ++argNameIter;
-            }
-            else
-            {
-                s += "_: ";
-            }
+            s += (*argNameIter ? (*argNameIter)->name : "_") + ": ";
+            ++argNameIter;
         }
         else
         {
-            // argNames is guaranteed to be equal to argTypes iff argNames is not empty.
-            // We don't currently respect opts.functionTypeArguments. I don't think this function should.
-            if (!ftv.argNames.empty())
-                s += (*argNameIter ? (*argNameIter)->name : "_") + ": ";
+            s += "_: ";
         }
 
         s += toString_(*argPackIter);
         ++argPackIter;
-
-        if (!FFlag::LuauFunctionArgumentNameSize)
-        {
-            if (!ftv.argNames.empty())
-            {
-                LUAU_ASSERT(argNameIter != ftv.argNames.end());
-                ++argNameIter;
-            }
-        }
     }
 
     if (argPackIter.tail())
diff --git a/Analysis/src/TxnLog.cpp b/Analysis/src/TxnLog.cpp
index f6a61581..a46ac0c3 100644
--- a/Analysis/src/TxnLog.cpp
+++ b/Analysis/src/TxnLog.cpp
@@ -4,27 +4,34 @@
 #include "Luau/TypePack.h"
 
 #include <algorithm>
+#include <stdexcept>
+
+LUAU_FASTFLAGVARIABLE(LuauUseCommittingTxnLog, false)
 
 namespace Luau
 {
 
-void TxnLog::operator()(TypeId a)
+void DEPRECATED_TxnLog::operator()(TypeId a)
 {
+    LUAU_ASSERT(!FFlag::LuauUseCommittingTxnLog);
     typeVarChanges.emplace_back(a, *a);
 }
 
-void TxnLog::operator()(TypePackId a)
+void DEPRECATED_TxnLog::operator()(TypePackId a)
 {
+    LUAU_ASSERT(!FFlag::LuauUseCommittingTxnLog);
     typePackChanges.emplace_back(a, *a);
 }
 
-void TxnLog::operator()(TableTypeVar* a)
+void DEPRECATED_TxnLog::operator()(TableTypeVar* a)
 {
+    LUAU_ASSERT(!FFlag::LuauUseCommittingTxnLog);
     tableChanges.emplace_back(a, a->boundTo);
 }
 
-void TxnLog::rollback()
+void DEPRECATED_TxnLog::rollback()
 {
+    LUAU_ASSERT(!FFlag::LuauUseCommittingTxnLog);
     for (auto it = typeVarChanges.rbegin(); it != typeVarChanges.rend(); ++it)
         std::swap(*asMutable(it->first), it->second);
 
@@ -38,8 +45,9 @@ void TxnLog::rollback()
     sharedSeen->resize(originalSeenSize);
 }
 
-void TxnLog::concat(TxnLog rhs)
+void DEPRECATED_TxnLog::concat(DEPRECATED_TxnLog rhs)
 {
+    LUAU_ASSERT(!FFlag::LuauUseCommittingTxnLog);
     typeVarChanges.insert(typeVarChanges.end(), rhs.typeVarChanges.begin(), rhs.typeVarChanges.end());
     rhs.typeVarChanges.clear();
 
@@ -50,23 +58,298 @@ void TxnLog::concat(TxnLog rhs)
     rhs.tableChanges.clear();
 }
 
-bool TxnLog::haveSeen(TypeId lhs, TypeId rhs)
+bool DEPRECATED_TxnLog::haveSeen(TypeId lhs, TypeId rhs)
 {
+    LUAU_ASSERT(!FFlag::LuauUseCommittingTxnLog);
     const std::pair<TypeId, TypeId> sortedPair = (lhs > rhs) ? std::make_pair(lhs, rhs) : std::make_pair(rhs, lhs);
     return (sharedSeen->end() != std::find(sharedSeen->begin(), sharedSeen->end(), sortedPair));
 }
 
+void DEPRECATED_TxnLog::pushSeen(TypeId lhs, TypeId rhs)
+{
+    LUAU_ASSERT(!FFlag::LuauUseCommittingTxnLog);
+    const std::pair<TypeId, TypeId> sortedPair = (lhs > rhs) ? std::make_pair(lhs, rhs) : std::make_pair(rhs, lhs);
+    sharedSeen->push_back(sortedPair);
+}
+
+void DEPRECATED_TxnLog::popSeen(TypeId lhs, TypeId rhs)
+{
+    LUAU_ASSERT(!FFlag::LuauUseCommittingTxnLog);
+    const std::pair<TypeId, TypeId> sortedPair = (lhs > rhs) ? std::make_pair(lhs, rhs) : std::make_pair(rhs, lhs);
+    LUAU_ASSERT(sortedPair == sharedSeen->back());
+    sharedSeen->pop_back();
+}
+
+static const TxnLog emptyLog;
+
+const TxnLog* TxnLog::empty()
+{
+    return &emptyLog;
+}
+
+void TxnLog::concat(TxnLog rhs)
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
+    for (auto& [ty, rep] : rhs.typeVarChanges)
+        typeVarChanges[ty] = std::move(rep);
+
+    for (auto& [tp, rep] : rhs.typePackChanges)
+        typePackChanges[tp] = std::move(rep);
+}
+
+void TxnLog::commit()
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
+    for (auto& [ty, rep] : typeVarChanges)
+        *asMutable(ty) = rep.get()->pending;
+
+    for (auto& [tp, rep] : typePackChanges)
+        *asMutable(tp) = rep.get()->pending;
+
+    clear();
+}
+
+void TxnLog::clear()
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
+    typeVarChanges.clear();
+    typePackChanges.clear();
+}
+
+TxnLog TxnLog::inverse()
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
+    TxnLog inversed(sharedSeen);
+
+    for (auto& [ty, _rep] : typeVarChanges)
+        inversed.typeVarChanges[ty] = std::make_unique<PendingType>(*ty);
+
+    for (auto& [tp, _rep] : typePackChanges)
+        inversed.typePackChanges[tp] = std::make_unique<PendingTypePack>(*tp);
+
+    return inversed;
+}
+
+bool TxnLog::haveSeen(TypeId lhs, TypeId rhs) const
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
+    const std::pair<TypeId, TypeId> sortedPair = (lhs > rhs) ? std::make_pair(lhs, rhs) : std::make_pair(rhs, lhs);
+    if (sharedSeen->end() != std::find(sharedSeen->begin(), sharedSeen->end(), sortedPair))
+    {
+        return true;
+    }
+
+    if (parent)
+    {
+        return parent->haveSeen(lhs, rhs);
+    }
+
+    return false;
+}
+
 void TxnLog::pushSeen(TypeId lhs, TypeId rhs)
 {
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
     const std::pair<TypeId, TypeId> sortedPair = (lhs > rhs) ? std::make_pair(lhs, rhs) : std::make_pair(rhs, lhs);
     sharedSeen->push_back(sortedPair);
 }
 
 void TxnLog::popSeen(TypeId lhs, TypeId rhs)
 {
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
     const std::pair<TypeId, TypeId> sortedPair = (lhs > rhs) ? std::make_pair(lhs, rhs) : std::make_pair(rhs, lhs);
     LUAU_ASSERT(sortedPair == sharedSeen->back());
     sharedSeen->pop_back();
 }
 
+PendingType* TxnLog::queue(TypeId ty)
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+    LUAU_ASSERT(!ty->persistent);
+
+    // Explicitly don't look in ancestors. If we have discovered something new
+    // about this type, we don't want to mutate the parent's state.
+    auto& pending = typeVarChanges[ty];
+    if (!pending)
+        pending = std::make_unique<PendingType>(*ty);
+
+    return pending.get();
+}
+
+PendingTypePack* TxnLog::queue(TypePackId tp)
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+    LUAU_ASSERT(!tp->persistent);
+
+    // Explicitly don't look in ancestors. If we have discovered something new
+    // about this type, we don't want to mutate the parent's state.
+    auto& pending = typePackChanges[tp];
+    if (!pending)
+        pending = std::make_unique<PendingTypePack>(*tp);
+
+    return pending.get();
+}
+
+PendingType* TxnLog::pending(TypeId ty) const
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
+    for (const TxnLog* current = this; current; current = current->parent)
+    {
+        if (auto it = current->typeVarChanges.find(ty); it != current->typeVarChanges.end())
+            return it->second.get();
+    }
+
+    return nullptr;
+}
+
+PendingTypePack* TxnLog::pending(TypePackId tp) const
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
+    for (const TxnLog* current = this; current; current = current->parent)
+    {
+        if (auto it = current->typePackChanges.find(tp); it != current->typePackChanges.end())
+            return it->second.get();
+    }
+
+    return nullptr;
+}
+
+PendingType* TxnLog::replace(TypeId ty, TypeVar replacement)
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
+    PendingType* newTy = queue(ty);
+    newTy->pending = replacement;
+    return newTy;
+}
+
+PendingTypePack* TxnLog::replace(TypePackId tp, TypePackVar replacement)
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
+    PendingTypePack* newTp = queue(tp);
+    newTp->pending = replacement;
+    return newTp;
+}
+
+PendingType* TxnLog::bindTable(TypeId ty, std::optional<TypeId> newBoundTo)
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+    LUAU_ASSERT(get<TableTypeVar>(ty));
+
+    PendingType* newTy = queue(ty);
+    if (TableTypeVar* ttv = Luau::getMutable<TableTypeVar>(newTy))
+        ttv->boundTo = newBoundTo;
+
+    return newTy;
+}
+
+PendingType* TxnLog::changeLevel(TypeId ty, TypeLevel newLevel)
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+    LUAU_ASSERT(get<FreeTypeVar>(ty) || get<TableTypeVar>(ty) || get<FunctionTypeVar>(ty));
+
+    PendingType* newTy = queue(ty);
+    if (FreeTypeVar* ftv = Luau::getMutable<FreeTypeVar>(newTy))
+    {
+        ftv->level = newLevel;
+    }
+    else if (TableTypeVar* ttv = Luau::getMutable<TableTypeVar>(newTy))
+    {
+        LUAU_ASSERT(ttv->state == TableState::Free || ttv->state == TableState::Generic);
+        ttv->level = newLevel;
+    }
+    else if (FunctionTypeVar* ftv = Luau::getMutable<FunctionTypeVar>(newTy))
+    {
+        ftv->level = newLevel;
+    }
+
+    return newTy;
+}
+
+PendingTypePack* TxnLog::changeLevel(TypePackId tp, TypeLevel newLevel)
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+    LUAU_ASSERT(get<FreeTypePack>(tp));
+
+    PendingTypePack* newTp = queue(tp);
+    if (FreeTypePack* ftp = Luau::getMutable<FreeTypePack>(newTp))
+    {
+        ftp->level = newLevel;
+    }
+
+    return newTp;
+}
+
+PendingType* TxnLog::changeIndexer(TypeId ty, std::optional<TableIndexer> indexer)
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+    LUAU_ASSERT(get<TableTypeVar>(ty));
+
+    PendingType* newTy = queue(ty);
+    if (TableTypeVar* ttv = Luau::getMutable<TableTypeVar>(newTy))
+    {
+        ttv->indexer = indexer;
+    }
+
+    return newTy;
+}
+
+std::optional<TypeLevel> TxnLog::getLevel(TypeId ty) const
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
+    if (FreeTypeVar* ftv = getMutable<FreeTypeVar>(ty))
+        return ftv->level;
+    else if (TableTypeVar* ttv = getMutable<TableTypeVar>(ty); ttv && (ttv->state == TableState::Free || ttv->state == TableState::Generic))
+        return ttv->level;
+    else if (FunctionTypeVar* ftv = getMutable<FunctionTypeVar>(ty))
+        return ftv->level;
+
+    return std::nullopt;
+}
+
+TypeId TxnLog::follow(TypeId ty)
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
+    return Luau::follow(ty, [this](TypeId ty) {
+        PendingType* state = this->pending(ty);
+
+        if (state == nullptr)
+            return ty;
+
+        // Ugly: Fabricate a TypeId that doesn't adhere to most of the invariants
+        // that normally apply. This is safe because follow will only call get<>
+        // on the returned pointer.
+        return const_cast<const TypeVar*>(&state->pending);
+    });
+}
+
+TypePackId TxnLog::follow(TypePackId tp) const
+{
+    LUAU_ASSERT(FFlag::LuauUseCommittingTxnLog);
+
+    return Luau::follow(tp, [this](TypePackId tp) {
+        PendingTypePack* state = this->pending(tp);
+
+        if (state == nullptr)
+            return tp;
+
+        // Ugly: Fabricate a TypePackId that doesn't adhere to most of the
+        // invariants that normally apply. This is safe because follow will
+        // only call get<> on the returned pointer.
+        return const_cast<const TypePackVar*>(&state->pending);
+    });
+}
+
 } // namespace Luau
diff --git a/Analysis/src/TypeInfer.cpp b/Analysis/src/TypeInfer.cpp
index e29b6ec6..1689a5c3 100644
--- a/Analysis/src/TypeInfer.cpp
+++ b/Analysis/src/TypeInfer.cpp
@@ -27,15 +27,16 @@ LUAU_FASTFLAGVARIABLE(LuauEqConstraint, false)
 LUAU_FASTFLAGVARIABLE(LuauWeakEqConstraint, false) // Eventually removed as false.
 LUAU_FASTFLAGVARIABLE(LuauCloneCorrectlyBeforeMutatingTableType, false)
 LUAU_FASTFLAGVARIABLE(LuauStoreMatchingOverloadFnType, false)
+LUAU_FASTFLAG(LuauUseCommittingTxnLog)
+LUAU_FASTFLAGVARIABLE(DebugLuauFreezeDuringUnification, false)
 LUAU_FASTFLAGVARIABLE(LuauRecursiveTypeParameterRestriction, false)
 LUAU_FASTFLAGVARIABLE(LuauIfElseExpressionAnalysisSupport, false)
 LUAU_FASTFLAGVARIABLE(LuauQuantifyInPlace2, false)
+LUAU_FASTFLAGVARIABLE(LuauSealExports, false)
 LUAU_FASTFLAGVARIABLE(LuauSingletonTypes, false)
 LUAU_FASTFLAGVARIABLE(LuauExpectedTypesOfProperties, false)
 LUAU_FASTFLAGVARIABLE(LuauErrorRecoveryType, false)
 LUAU_FASTFLAGVARIABLE(LuauPropertiesGetExpectedType, false)
-LUAU_FASTFLAGVARIABLE(LuauTailArgumentTypeInfo, false)
-LUAU_FASTFLAGVARIABLE(LuauModuleRequireErrorPack, false)
 LUAU_FASTFLAGVARIABLE(LuauLValueAsKey, false)
 LUAU_FASTFLAGVARIABLE(LuauRefiLookupFromIndexExpr, false)
 LUAU_FASTFLAGVARIABLE(LuauProperTypeLevels, false)
@@ -450,7 +451,7 @@ void TypeChecker::checkBlock(const ScopePtr& scope, const AstStatBlock& block)
             ++subLevel;
 
             TypeId leftType = checkFunctionName(scope, *fun->name, funScope->level);
-            unify(leftType, funTy, fun->location);
+            unify(funTy, leftType, fun->location);
         }
         else if (auto fun = (*protoIter)->as<AstStatLocalFunction>())
         {
@@ -556,21 +557,21 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatIf& statement)
     }
 }
 
-ErrorVec TypeChecker::canUnify(TypeId left, TypeId right, const Location& location)
-{
-    return canUnify_(left, right, location);
-}
-
-ErrorVec TypeChecker::canUnify(TypePackId left, TypePackId right, const Location& location)
-{
-    return canUnify_(left, right, location);
-}
-
 template<typename Id>
-ErrorVec TypeChecker::canUnify_(Id superTy, Id subTy, const Location& location)
+ErrorVec TypeChecker::canUnify_(Id subTy, Id superTy, const Location& location)
 {
     Unifier state = mkUnifier(location);
-    return state.canUnify(superTy, subTy);
+    return state.canUnify(subTy, superTy);
+}
+
+ErrorVec TypeChecker::canUnify(TypeId subTy, TypeId superTy, const Location& location)
+{
+    return canUnify_(subTy, superTy, location);
+}
+
+ErrorVec TypeChecker::canUnify(TypePackId subTy, TypePackId superTy, const Location& location)
+{
+    return canUnify_(subTy, superTy, location);
 }
 
 void TypeChecker::check(const ScopePtr& scope, const AstStatWhile& statement)
@@ -619,7 +620,7 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatReturn& return_)
     // start typechecking everything across module boundaries.
     if (isNonstrictMode() && follow(scope->returnType) == follow(currentModule->getModuleScope()->returnType))
     {
-        ErrorVec errors = tryUnify(scope->returnType, retPack, return_.location);
+        ErrorVec errors = tryUnify(retPack, scope->returnType, return_.location);
 
         if (!errors.empty())
             currentModule->getModuleScope()->returnType = addTypePack({anyType});
@@ -627,31 +628,41 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatReturn& return_)
         return;
     }
 
-    unify(scope->returnType, retPack, return_.location, CountMismatch::Context::Return);
-}
-
-ErrorVec TypeChecker::tryUnify(TypeId left, TypeId right, const Location& location)
-{
-    return tryUnify_(left, right, location);
-}
-
-ErrorVec TypeChecker::tryUnify(TypePackId left, TypePackId right, const Location& location)
-{
-    return tryUnify_(left, right, location);
+    unify(retPack, scope->returnType, return_.location, CountMismatch::Context::Return);
 }
 
 template<typename Id>
-ErrorVec TypeChecker::tryUnify_(Id left, Id right, const Location& location)
+ErrorVec TypeChecker::tryUnify_(Id subTy, Id superTy, const Location& location)
 {
     Unifier state = mkUnifier(location);
-    state.tryUnify(left, right);
 
-    if (!state.errors.empty())
-        state.log.rollback();
+    if (FFlag::LuauUseCommittingTxnLog && FFlag::DebugLuauFreezeDuringUnification)
+        freeze(currentModule->internalTypes);
+
+    state.tryUnify(subTy, superTy);
+
+    if (FFlag::LuauUseCommittingTxnLog && FFlag::DebugLuauFreezeDuringUnification)
+        unfreeze(currentModule->internalTypes);
+
+    if (!state.errors.empty() && !FFlag::LuauUseCommittingTxnLog)
+        state.DEPRECATED_log.rollback();
+
+    if (state.errors.empty() && FFlag::LuauUseCommittingTxnLog)
+        state.log.commit();
 
     return state.errors;
 }
 
+ErrorVec TypeChecker::tryUnify(TypeId subTy, TypeId superTy, const Location& location)
+{
+    return tryUnify_(subTy, superTy, location);
+}
+
+ErrorVec TypeChecker::tryUnify(TypePackId subTy, TypePackId superTy, const Location& location)
+{
+    return tryUnify_(subTy, superTy, location);
+}
+
 void TypeChecker::check(const ScopePtr& scope, const AstStatAssign& assign)
 {
     std::vector<std::optional<TypeId>> expectedTypes;
@@ -743,9 +754,9 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatAssign& assign)
             {
                 // In nonstrict mode, any assignments where the lhs is free and rhs isn't a function, we give it any typevar.
                 if (isNonstrictMode() && get<FreeTypeVar>(follow(left)) && !get<FunctionTypeVar>(follow(right)))
-                    unify(left, anyType, loc);
+                    unify(anyType, left, loc);
                 else
-                    unify(left, right, loc);
+                    unify(right, left, loc);
             }
         }
     }
@@ -760,7 +771,7 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatCompoundAssign& assi
 
     TypeId result = checkBinaryOperation(scope, expr, left, right);
 
-    unify(left, result, assign.location);
+    unify(result, left, assign.location);
 }
 
 void TypeChecker::check(const ScopePtr& scope, const AstStatLocal& local)
@@ -817,9 +828,12 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatLocal& local)
 
         Unifier state = mkUnifier(local.location);
         state.ctx = CountMismatch::Result;
-        state.tryUnify(variablePack, valuePack);
+        state.tryUnify(valuePack, variablePack);
         reportErrors(state.errors);
 
+        if (FFlag::LuauUseCommittingTxnLog)
+            state.log.commit();
+
         // In the code 'local T = {}', we wish to ascribe the name 'T' to the type of the table for error-reporting purposes.
         // We also want to do this for 'local T = setmetatable(...)'.
         if (local.vars.size == 1 && local.values.size == 1)
@@ -889,7 +903,7 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatFor& expr)
 
     TypeId loopVarType = numberType;
     if (expr.var->annotation)
-        unify(resolveType(scope, *expr.var->annotation), loopVarType, expr.location);
+        unify(loopVarType, resolveType(scope, *expr.var->annotation), expr.location);
 
     loopScope->bindings[expr.var] = {loopVarType, expr.var->location};
 
@@ -899,11 +913,11 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatFor& expr)
     if (!expr.to)
         ice("Bad AstStatFor has no to expr");
 
-    unify(loopVarType, checkExpr(loopScope, *expr.from).type, expr.from->location);
-    unify(loopVarType, checkExpr(loopScope, *expr.to).type, expr.to->location);
+    unify(checkExpr(loopScope, *expr.from).type, loopVarType, expr.from->location);
+    unify(checkExpr(loopScope, *expr.to).type, loopVarType, expr.to->location);
 
     if (expr.step)
-        unify(loopVarType, checkExpr(loopScope, *expr.step).type, expr.step->location);
+        unify(checkExpr(loopScope, *expr.step).type, loopVarType, expr.step->location);
 
     check(loopScope, *expr.body);
 }
@@ -956,12 +970,12 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatForIn& forin)
         if (get<Unifiable::Free>(callRetPack))
         {
             iterTy = freshType(scope);
-            unify(addTypePack({{iterTy}, freshTypePack(scope)}), callRetPack, forin.location);
+            unify(callRetPack, addTypePack({{iterTy}, freshTypePack(scope)}), forin.location);
         }
         else if (get<Unifiable::Error>(callRetPack) || !first(callRetPack))
         {
             for (TypeId var : varTypes)
-                unify(var, errorRecoveryType(scope), forin.location);
+                unify(errorRecoveryType(scope), var, forin.location);
 
             return check(loopScope, *forin.body);
         }
@@ -982,7 +996,7 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatForIn& forin)
         TypeId varTy = get<AnyTypeVar>(iterTy) ? anyType : errorRecoveryType(loopScope);
 
         for (TypeId var : varTypes)
-            unify(var, varTy, forin.location);
+            unify(varTy, var, forin.location);
 
         if (!get<ErrorTypeVar>(iterTy) && !get<AnyTypeVar>(iterTy) && !get<FreeTypeVar>(iterTy))
             reportError(TypeError{firstValue->location, TypeMismatch{globalScope->bindings[AstName{"next"}].typeId, iterTy}});
@@ -1010,6 +1024,9 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatForIn& forin)
         Unifier state = mkUnifier(firstValue->location);
         checkArgumentList(loopScope, state, argPack, iterFunc->argTypes, /*argLocations*/ {});
 
+        if (FFlag::LuauUseCommittingTxnLog)
+            state.log.commit();
+
         reportErrors(state.errors);
     }
 
@@ -1024,10 +1041,10 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatForIn& forin)
         AstExprCall exprCall{Location(start, end), firstValue, arguments, /* self= */ false, Location()};
 
         TypePackId retPack = checkExprPack(scope, exprCall).type;
-        unify(varPack, retPack, forin.location);
+        unify(retPack, varPack, forin.location);
     }
     else
-        unify(varPack, iterFunc->retType, forin.location);
+        unify(iterFunc->retType, varPack, forin.location);
 
     check(loopScope, *forin.body);
 }
@@ -1112,7 +1129,7 @@ void TypeChecker::check(const ScopePtr& scope, TypeId ty, const ScopePtr& funSco
 
         checkFunctionBody(funScope, ty, *function.func);
 
-        unify(leftType, ty, function.location);
+        unify(ty, leftType, function.location);
 
         if (FFlag::LuauUpdateFunctionNameBinding)
         {
@@ -1242,7 +1259,7 @@ void TypeChecker::check(const ScopePtr& scope, const AstStatTypeAlias& typealias
         else if (auto mtv = getMutable<MetatableTypeVar>(follow(ty)))
             mtv->syntheticName = name;
 
-        unify(bindingsMap[name].type, ty, typealias.location);
+        unify(ty, bindingsMap[name].type, typealias.location);
     }
 }
 
@@ -1526,7 +1543,7 @@ ExprResult<TypeId> TypeChecker::checkExpr(const ScopePtr& scope, const AstExprCa
     {
         TypeId head = freshType(scope);
         TypePackId pack = addTypePack(TypePackVar{TypePack{{head}, freshTypePack(scope)}});
-        unify(retPack, pack, expr.location);
+        unify(pack, retPack, expr.location);
         return {head, std::move(result.predicates)};
     }
     if (get<Unifiable::Error>(retPack))
@@ -1598,7 +1615,7 @@ std::optional<TypeId> TypeChecker::getIndexTypeFromType(
             return it->second.type;
         else if (auto indexer = tableType->indexer)
         {
-            tryUnify(indexer->indexType, stringType, location);
+            tryUnify(stringType, indexer->indexType, location);
             return indexer->indexResultType;
         }
         else if (tableType->state == TableState::Free)
@@ -1824,7 +1841,7 @@ TypeId TypeChecker::checkExprTable(
                 indexer = expectedTable->indexer;
 
             if (indexer)
-                unify(indexer->indexResultType, valueType, value->location);
+                unify(valueType, indexer->indexResultType, value->location);
             else
                 indexer = TableIndexer{numberType, anyIfNonstrict(valueType)};
         }
@@ -1842,13 +1859,13 @@ TypeId TypeChecker::checkExprTable(
                     if (it != expectedTable->props.end())
                     {
                         Property expectedProp = it->second;
-                        ErrorVec errors = tryUnify(expectedProp.type, exprType, k->location);
+                        ErrorVec errors = tryUnify(exprType, expectedProp.type, k->location);
                         if (errors.empty())
                             exprType = expectedProp.type;
                     }
                     else if (expectedTable->indexer && isString(expectedTable->indexer->indexType))
                     {
-                        ErrorVec errors = tryUnify(expectedTable->indexer->indexResultType, exprType, k->location);
+                        ErrorVec errors = tryUnify(exprType, expectedTable->indexer->indexResultType, k->location);
                         if (errors.empty())
                             exprType = expectedTable->indexer->indexResultType;
                     }
@@ -1863,8 +1880,8 @@ TypeId TypeChecker::checkExprTable(
 
                 if (indexer)
                 {
-                    unify(indexer->indexType, keyType, k->location);
-                    unify(indexer->indexResultType, valueType, value->location);
+                    unify(keyType, indexer->indexType, k->location);
+                    unify(valueType, indexer->indexResultType, value->location);
                 }
                 else if (isNonstrictMode())
                 {
@@ -1992,7 +2009,10 @@ ExprResult<TypeId> TypeChecker::checkExpr(const ScopePtr& scope, const AstExprUn
                 TypeId expectedFunctionType = addType(FunctionTypeVar(scope->level, arguments, retTypePack));
 
                 Unifier state = mkUnifier(expr.location);
-                state.tryUnify(expectedFunctionType, actualFunctionType, /*isFunctionCall*/ true);
+                state.tryUnify(actualFunctionType, expectedFunctionType, /*isFunctionCall*/ true);
+
+                if (FFlag::LuauUseCommittingTxnLog)
+                    state.log.commit();
 
                 TypeId retType = first(retTypePack).value_or(nilType);
                 if (!state.errors.empty())
@@ -2006,7 +2026,7 @@ ExprResult<TypeId> TypeChecker::checkExpr(const ScopePtr& scope, const AstExprUn
             return {errorRecoveryType(scope)};
         }
 
-        reportErrors(tryUnify(numberType, operandType, expr.location));
+        reportErrors(tryUnify(operandType, numberType, expr.location));
         return {numberType};
     }
     case AstExprUnary::Len:
@@ -2072,7 +2092,7 @@ TypeId TypeChecker::unionOfTypes(TypeId a, TypeId b, const Location& location, b
 {
     if (unifyFreeTypes && (get<FreeTypeVar>(a) || get<FreeTypeVar>(b)))
     {
-        if (unify(a, b, location))
+        if (unify(b, a, location))
             return a;
 
         return errorRecoveryType(anyType);
@@ -2175,7 +2195,13 @@ TypeId TypeChecker::checkRelationalOperation(
          */
         Unifier state = mkUnifier(expr.location);
         if (!isEquality)
-            state.tryUnify(lhsType, rhsType);
+        {
+            state.tryUnify(rhsType, lhsType);
+
+            if (FFlag::LuauUseCommittingTxnLog)
+                state.log.commit();
+        }
+
 
         bool needsMetamethod = !isEquality;
 
@@ -2216,13 +2242,16 @@ TypeId TypeChecker::checkRelationalOperation(
                     if (isEquality)
                     {
                         Unifier state = mkUnifier(expr.location);
-                        state.tryUnify(ftv->retType, addTypePack({booleanType}));
+                        state.tryUnify(addTypePack({booleanType}), ftv->retType);
 
                         if (!state.errors.empty())
                         {
                             reportError(expr.location, GenericError{format("Metamethod '%s' must return type 'boolean'", metamethodName.c_str())});
                             return errorRecoveryType(booleanType);
                         }
+
+                        if (FFlag::LuauUseCommittingTxnLog)
+                            state.log.commit();
                     }
                 }
 
@@ -2230,7 +2259,10 @@ TypeId TypeChecker::checkRelationalOperation(
 
                 TypeId actualFunctionType = addType(FunctionTypeVar(scope->level, addTypePack({lhsType, rhsType}), addTypePack({booleanType})));
                 state.tryUnify(
-                    instantiate(scope, *metamethod, expr.location), instantiate(scope, actualFunctionType, expr.location), /*isFunctionCall*/ true);
+                    instantiate(scope, actualFunctionType, expr.location), instantiate(scope, *metamethod, expr.location), /*isFunctionCall*/ true);
+
+                if (FFlag::LuauUseCommittingTxnLog)
+                    state.log.commit();
 
                 reportErrors(state.errors);
                 return booleanType;
@@ -2323,7 +2355,7 @@ TypeId TypeChecker::checkBinaryOperation(
     }
 
     if (get<FreeTypeVar>(rhsType))
-        unify(lhsType, rhsType, expr.location);
+        unify(rhsType, lhsType, expr.location);
 
     if (typeCouldHaveMetatable(lhsType) || typeCouldHaveMetatable(rhsType))
     {
@@ -2334,7 +2366,7 @@ TypeId TypeChecker::checkBinaryOperation(
             TypeId expectedFunctionType = addType(FunctionTypeVar(scope->level, arguments, retTypePack));
 
             Unifier state = mkUnifier(expr.location);
-            state.tryUnify(expectedFunctionType, actualFunctionType, /*isFunctionCall*/ true);
+            state.tryUnify(actualFunctionType, expectedFunctionType, /*isFunctionCall*/ true);
 
             reportErrors(state.errors);
             bool hasErrors = !state.errors.empty();
@@ -2345,11 +2377,28 @@ TypeId TypeChecker::checkBinaryOperation(
                 // so we loosen the argument types to see if that helps.
                 TypePackId fallbackArguments = freshTypePack(scope);
                 TypeId fallbackFunctionType = addType(FunctionTypeVar(scope->level, fallbackArguments, retTypePack));
-                state.log.rollback();
                 state.errors.clear();
-                state.tryUnify(fallbackFunctionType, actualFunctionType, /*isFunctionCall*/ true);
-                if (!state.errors.empty())
-                    state.log.rollback();
+
+                if (FFlag::LuauUseCommittingTxnLog)
+                {
+                    state.log.clear();
+                }
+                else
+                {
+                    state.DEPRECATED_log.rollback();
+                }
+
+                state.tryUnify(actualFunctionType, fallbackFunctionType, /*isFunctionCall*/ true);
+
+                if (FFlag::LuauUseCommittingTxnLog && state.errors.empty())
+                    state.log.commit();
+                else if (!state.errors.empty() && !FFlag::LuauUseCommittingTxnLog)
+                    state.DEPRECATED_log.rollback();
+            }
+
+            if (FFlag::LuauUseCommittingTxnLog && !hasErrors)
+            {
+                state.log.commit();
             }
 
             TypeId retType = first(retTypePack).value_or(nilType);
@@ -2377,8 +2426,8 @@ TypeId TypeChecker::checkBinaryOperation(
     switch (expr.op)
     {
     case AstExprBinary::Concat:
-        reportErrors(tryUnify(addType(UnionTypeVar{{stringType, numberType}}), lhsType, expr.left->location));
-        reportErrors(tryUnify(addType(UnionTypeVar{{stringType, numberType}}), rhsType, expr.right->location));
+        reportErrors(tryUnify(lhsType, addType(UnionTypeVar{{stringType, numberType}}), expr.left->location));
+        reportErrors(tryUnify(rhsType, addType(UnionTypeVar{{stringType, numberType}}), expr.right->location));
         return stringType;
     case AstExprBinary::Add:
     case AstExprBinary::Sub:
@@ -2386,8 +2435,8 @@ TypeId TypeChecker::checkBinaryOperation(
     case AstExprBinary::Div:
     case AstExprBinary::Mod:
     case AstExprBinary::Pow:
-        reportErrors(tryUnify(numberType, lhsType, expr.left->location));
-        reportErrors(tryUnify(numberType, rhsType, expr.right->location));
+        reportErrors(tryUnify(lhsType, numberType, expr.left->location));
+        reportErrors(tryUnify(rhsType, numberType, expr.right->location));
         return numberType;
     default:
         // These should have been handled with checkRelationalOperation
@@ -2466,10 +2515,10 @@ ExprResult<TypeId> TypeChecker::checkExpr(const ScopePtr& scope, const AstExprTy
     if (FFlag::LuauBidirectionalAsExpr)
     {
         // Note: As an optimization, we try 'number <: number | string' first, as that is the more likely case.
-        if (canUnify(result.type, annotationType, expr.location).empty())
+        if (canUnify(annotationType, result.type, expr.location).empty())
             return {annotationType, std::move(result.predicates)};
 
-        if (canUnify(annotationType, result.type, expr.location).empty())
+        if (canUnify(result.type, annotationType, expr.location).empty())
             return {annotationType, std::move(result.predicates)};
 
         reportError(expr.location, TypesAreUnrelated{result.type, annotationType});
@@ -2477,7 +2526,7 @@ ExprResult<TypeId> TypeChecker::checkExpr(const ScopePtr& scope, const AstExprTy
     }
     else
     {
-        ErrorVec errorVec = canUnify(result.type, annotationType, expr.location);
+        ErrorVec errorVec = canUnify(annotationType, result.type, expr.location);
         reportErrors(errorVec);
         if (!errorVec.empty())
             annotationType = errorRecoveryType(annotationType);
@@ -2512,7 +2561,7 @@ ExprResult<TypeId> TypeChecker::checkExpr(const ScopePtr& scope, const AstExprIf
     resolve(result.predicates, falseScope, false);
     ExprResult<TypeId> falseType = checkExpr(falseScope, *expr.falseExpr);
 
-    unify(trueType.type, falseType.type, expr.location);
+    unify(falseType.type, trueType.type, expr.location);
 
     // TODO: normalize(UnionTypeVar{{trueType, falseType}})
     // For now both trueType and falseType must be the same type.
@@ -2607,14 +2656,18 @@ std::pair<TypeId, TypeId*> TypeChecker::checkLValueBinding(const ScopePtr& scope
         else if (auto indexer = lhsTable->indexer)
         {
             Unifier state = mkUnifier(expr.location);
-            state.tryUnify(indexer->indexType, stringType);
+            state.tryUnify(stringType, indexer->indexType);
             TypeId retType = indexer->indexResultType;
             if (!state.errors.empty())
             {
-                state.log.rollback();
+                if (!FFlag::LuauUseCommittingTxnLog)
+                    state.DEPRECATED_log.rollback();
+
                 reportError(expr.location, UnknownProperty{lhs, name});
                 retType = errorRecoveryType(retType);
             }
+            else if (FFlag::LuauUseCommittingTxnLog)
+                state.log.commit();
 
             return std::pair(retType, nullptr);
         }
@@ -2713,7 +2766,7 @@ std::pair<TypeId, TypeId*> TypeChecker::checkLValueBinding(const ScopePtr& scope
     if (exprTable->indexer)
     {
         const TableIndexer& indexer = *exprTable->indexer;
-        unify(indexer.indexType, indexType, expr.index->location);
+        unify(indexType, indexer.indexType, expr.index->location);
         return std::pair(indexer.indexResultType, nullptr);
     }
     else if (exprTable->state == TableState::Unsealed || exprTable->state == TableState::Free)
@@ -3106,204 +3159,402 @@ void TypeChecker::checkArgumentList(
      * A function requires parameters.
      * To call a function, you supply arguments.
      */
-    TypePackIterator argIter = begin(argPack);
-    TypePackIterator paramIter = begin(paramPack);
+    TypePackIterator argIter = begin(argPack, &state.log);
+    TypePackIterator paramIter = begin(paramPack, &state.log);
     TypePackIterator endIter = end(argPack); // Important subtlety: All end TypePackIterators are equivalent
 
     size_t paramIndex = 0;
 
     size_t minParams = getMinParameterCount(paramPack);
 
-    while (true)
+    if (FFlag::LuauUseCommittingTxnLog)
     {
-        state.location = paramIndex < argLocations.size() ? argLocations[paramIndex] : state.location;
-
-        if (argIter == endIter && paramIter == endIter)
+        while (true)
         {
-            std::optional<TypePackId> argTail = argIter.tail();
-            std::optional<TypePackId> paramTail = paramIter.tail();
+            state.location = paramIndex < argLocations.size() ? argLocations[paramIndex] : state.location;
 
-            // If we hit the end of both type packs simultaneously, then there are definitely no further type
-            // errors to report.  All we need to do is tie up any free tails.
-            //
-            // If one side has a free tail and the other has none at all, we create an empty pack and bind the
-            // free tail to that.
-
-            if (argTail)
+            if (argIter == endIter && paramIter == endIter)
             {
-                if (get<Unifiable::Free>(*argTail))
+                std::optional<TypePackId> argTail = argIter.tail();
+                std::optional<TypePackId> paramTail = paramIter.tail();
+
+                // If we hit the end of both type packs simultaneously, then there are definitely no further type
+                // errors to report.  All we need to do is tie up any free tails.
+                //
+                // If one side has a free tail and the other has none at all, we create an empty pack and bind the
+                // free tail to that.
+
+                if (argTail)
                 {
-                    if (paramTail)
-                        state.tryUnify(*argTail, *paramTail);
+                    if (state.log.getMutable<Unifiable::Free>(state.log.follow(*argTail)))
+                    {
+                        if (paramTail)
+                            state.tryUnify(*paramTail, *argTail);
+                        else
+                            state.log.replace(*argTail, TypePackVar(TypePack{{}}));
+                    }
+                }
+                else if (paramTail)
+                {
+                    // argTail is definitely empty
+                    if (state.log.getMutable<Unifiable::Free>(state.log.follow(*paramTail)))
+                        state.log.replace(*paramTail, TypePackVar(TypePack{{}}));
+                }
+
+                return;
+            }
+            else if (argIter == endIter)
+            {
+                // Not enough arguments.
+
+                // Might be ok if we are forwarding a vararg along.  This is a common thing to occur in nonstrict mode.
+                if (argIter.tail())
+                {
+                    TypePackId tail = *argIter.tail();
+                    if (state.log.getMutable<Unifiable::Error>(tail))
+                    {
+                        // Unify remaining parameters so we don't leave any free-types hanging around.
+                        while (paramIter != endIter)
+                        {
+                            state.tryUnify(errorRecoveryType(anyType), *paramIter);
+                            ++paramIter;
+                        }
+                        return;
+                    }
+                    else if (auto vtp = state.log.getMutable<VariadicTypePack>(tail))
+                    {
+                        while (paramIter != endIter)
+                        {
+                            state.tryUnify(vtp->ty, *paramIter);
+                            ++paramIter;
+                        }
+
+                        return;
+                    }
+                    else if (state.log.getMutable<FreeTypePack>(tail))
+                    {
+                        std::vector<TypeId> rest;
+                        rest.reserve(std::distance(paramIter, endIter));
+                        while (paramIter != endIter)
+                        {
+                            rest.push_back(*paramIter);
+                            ++paramIter;
+                        }
+
+                        TypePackId varPack = addTypePack(TypePackVar{TypePack{rest, paramIter.tail()}});
+                        state.tryUnify(varPack, tail);
+                        return;
+                    }
+                }
+
+                // If any remaining unfulfilled parameters are nonoptional, this is a problem.
+                while (paramIter != endIter)
+                {
+                    TypeId t = state.log.follow(*paramIter);
+                    if (isOptional(t))
+                    {
+                    } // ok
+                    else if (state.log.getMutable<ErrorTypeVar>(t))
+                    {
+                    } // ok
+                    else if (isNonstrictMode() && state.log.getMutable<AnyTypeVar>(t))
+                    {
+                    } // ok
                     else
                     {
-                        state.log(*argTail);
-                        *asMutable(*argTail) = TypePack{{}};
+                        state.errors.push_back(TypeError{state.location, CountMismatch{minParams, paramIndex}});
+                        return;
+                    }
+                    ++paramIter;
+                }
+            }
+            else if (paramIter == endIter)
+            {
+                // too many parameters passed
+                if (!paramIter.tail())
+                {
+                    while (argIter != endIter)
+                    {
+                        // The use of unify here is deliberate. We don't want this unification
+                        // to be undoable.
+                        unify(errorRecoveryType(scope), *argIter, state.location);
+                        ++argIter;
+                    }
+                    // For this case, we want the error span to cover every errant extra parameter
+                    Location location = state.location;
+                    if (!argLocations.empty())
+                        location = {state.location.begin, argLocations.back().end};
+                    state.errors.push_back(TypeError{location, CountMismatch{minParams, std::distance(begin(argPack), end(argPack))}});
+                    return;
+                }
+                TypePackId tail = state.log.follow(*paramIter.tail());
+
+                if (state.log.getMutable<Unifiable::Error>(tail))
+                {
+                    // Function is variadic.  Ok.
+                    return;
+                }
+                else if (auto vtp = state.log.getMutable<VariadicTypePack>(tail))
+                {
+                    // Function is variadic and requires that all subsequent parameters
+                    // be compatible with a type.
+                    size_t argIndex = paramIndex;
+                    while (argIter != endIter)
+                    {
+                        Location location = state.location;
+
+                        if (argIndex < argLocations.size())
+                            location = argLocations[argIndex];
+
+                        unify(*argIter, vtp->ty, location);
+                        ++argIter;
+                        ++argIndex;
+                    }
+
+                    return;
+                }
+                else if (state.log.getMutable<FreeTypePack>(tail))
+                {
+                    // Create a type pack out of the remaining argument types
+                    // and unify it with the tail.
+                    std::vector<TypeId> rest;
+                    rest.reserve(std::distance(argIter, endIter));
+                    while (argIter != endIter)
+                    {
+                        rest.push_back(*argIter);
+                        ++argIter;
+                    }
+
+                    TypePackId varPack = addTypePack(TypePackVar{TypePack{rest, argIter.tail()}});
+                    state.tryUnify(varPack, tail);
+                    return;
+                }
+                else if (state.log.getMutable<FreeTypePack>(tail))
+                {
+                    state.log.replace(tail, TypePackVar(TypePack{{}}));
+                    return;
+                }
+                else if (state.log.getMutable<GenericTypePack>(tail))
+                {
+                    // For this case, we want the error span to cover every errant extra parameter
+                    Location location = state.location;
+                    if (!argLocations.empty())
+                        location = {state.location.begin, argLocations.back().end};
+                    // TODO: Better error message?
+                    state.errors.push_back(TypeError{location, CountMismatch{minParams, std::distance(begin(argPack), end(argPack))}});
+                    return;
+                }
+            }
+            else
+            {
+                unifyWithInstantiationIfNeeded(scope, *argIter, *paramIter, state);
+                ++argIter;
+                ++paramIter;
+            }
+
+            ++paramIndex;
+        }
+    }
+    else
+    {
+        while (true)
+        {
+            state.location = paramIndex < argLocations.size() ? argLocations[paramIndex] : state.location;
+
+            if (argIter == endIter && paramIter == endIter)
+            {
+                std::optional<TypePackId> argTail = argIter.tail();
+                std::optional<TypePackId> paramTail = paramIter.tail();
+
+                // If we hit the end of both type packs simultaneously, then there are definitely no further type
+                // errors to report.  All we need to do is tie up any free tails.
+                //
+                // If one side has a free tail and the other has none at all, we create an empty pack and bind the
+                // free tail to that.
+
+                if (argTail)
+                {
+                    if (get<Unifiable::Free>(*argTail))
+                    {
+                        if (paramTail)
+                            state.tryUnify(*paramTail, *argTail);
+                        else
+                        {
+                            state.DEPRECATED_log(*argTail);
+                            *asMutable(*argTail) = TypePack{{}};
+                        }
                     }
                 }
-            }
-            else if (paramTail)
-            {
-                // argTail is definitely empty
-                if (get<Unifiable::Free>(*paramTail))
+                else if (paramTail)
                 {
-                    state.log(*paramTail);
-                    *asMutable(*paramTail) = TypePack{{}};
+                    // argTail is definitely empty
+                    if (get<Unifiable::Free>(*paramTail))
+                    {
+                        state.DEPRECATED_log(*paramTail);
+                        *asMutable(*paramTail) = TypePack{{}};
+                    }
+                }
+
+                return;
+            }
+            else if (argIter == endIter)
+            {
+                // Not enough arguments.
+
+                // Might be ok if we are forwarding a vararg along.  This is a common thing to occur in nonstrict mode.
+                if (argIter.tail())
+                {
+                    TypePackId tail = *argIter.tail();
+                    if (get<Unifiable::Error>(tail))
+                    {
+                        // Unify remaining parameters so we don't leave any free-types hanging around.
+                        while (paramIter != endIter)
+                        {
+                            state.tryUnify(*paramIter, errorRecoveryType(anyType));
+                            ++paramIter;
+                        }
+                        return;
+                    }
+                    else if (auto vtp = get<VariadicTypePack>(tail))
+                    {
+                        while (paramIter != endIter)
+                        {
+                            state.tryUnify(*paramIter, vtp->ty);
+                            ++paramIter;
+                        }
+
+                        return;
+                    }
+                    else if (get<FreeTypePack>(tail))
+                    {
+                        std::vector<TypeId> rest;
+                        rest.reserve(std::distance(paramIter, endIter));
+                        while (paramIter != endIter)
+                        {
+                            rest.push_back(*paramIter);
+                            ++paramIter;
+                        }
+
+                        TypePackId varPack = addTypePack(TypePackVar{TypePack{rest, paramIter.tail()}});
+                        state.tryUnify(varPack, tail);
+                        return;
+                    }
+                }
+
+                // If any remaining unfulfilled parameters are nonoptional, this is a problem.
+                while (paramIter != endIter)
+                {
+                    TypeId t = follow(*paramIter);
+                    if (isOptional(t))
+                    {
+                    } // ok
+                    else if (get<ErrorTypeVar>(t))
+                    {
+                    } // ok
+                    else if (isNonstrictMode() && get<AnyTypeVar>(t))
+                    {
+                    } // ok
+                    else
+                    {
+                        state.errors.push_back(TypeError{state.location, CountMismatch{minParams, paramIndex}});
+                        return;
+                    }
+                    ++paramIter;
                 }
             }
-
-            return;
-        }
-        else if (argIter == endIter)
-        {
-            // Not enough arguments.
-
-            // Might be ok if we are forwarding a vararg along.  This is a common thing to occur in nonstrict mode.
-            if (argIter.tail())
+            else if (paramIter == endIter)
             {
-                TypePackId tail = *argIter.tail();
+                // too many parameters passed
+                if (!paramIter.tail())
+                {
+                    while (argIter != endIter)
+                    {
+                        unify(*argIter, errorRecoveryType(scope), state.location);
+                        ++argIter;
+                    }
+                    // For this case, we want the error span to cover every errant extra parameter
+                    Location location = state.location;
+                    if (!argLocations.empty())
+                        location = {state.location.begin, argLocations.back().end};
+                    state.errors.push_back(TypeError{location, CountMismatch{minParams, std::distance(begin(argPack), end(argPack))}});
+                    return;
+                }
+                TypePackId tail = *paramIter.tail();
+
                 if (get<Unifiable::Error>(tail))
                 {
-                    // Unify remaining parameters so we don't leave any free-types hanging around.
-                    while (paramIter != endIter)
-                    {
-                        state.tryUnify(*paramIter, errorRecoveryType(anyType));
-                        ++paramIter;
-                    }
+                    // Function is variadic.  Ok.
                     return;
                 }
                 else if (auto vtp = get<VariadicTypePack>(tail))
                 {
-                    while (paramIter != endIter)
+                    // Function is variadic and requires that all subsequent parameters
+                    // be compatible with a type.
+                    size_t argIndex = paramIndex;
+                    while (argIter != endIter)
                     {
-                        state.tryUnify(*paramIter, vtp->ty);
-                        ++paramIter;
+                        Location location = state.location;
+
+                        if (argIndex < argLocations.size())
+                            location = argLocations[argIndex];
+
+                        unify(*argIter, vtp->ty, location);
+                        ++argIter;
+                        ++argIndex;
                     }
 
                     return;
                 }
                 else if (get<FreeTypePack>(tail))
                 {
+                    // Create a type pack out of the remaining argument types
+                    // and unify it with the tail.
                     std::vector<TypeId> rest;
-                    rest.reserve(std::distance(paramIter, endIter));
-                    while (paramIter != endIter)
+                    rest.reserve(std::distance(argIter, endIter));
+                    while (argIter != endIter)
                     {
-                        rest.push_back(*paramIter);
-                        ++paramIter;
+                        rest.push_back(*argIter);
+                        ++argIter;
                     }
 
-                    TypePackId varPack = addTypePack(TypePackVar{TypePack{rest, paramIter.tail()}});
+                    TypePackId varPack = addTypePack(TypePackVar{TypePack{rest, argIter.tail()}});
                     state.tryUnify(tail, varPack);
                     return;
                 }
-            }
+                else if (get<FreeTypePack>(tail))
+                {
+                    if (FFlag::LuauUseCommittingTxnLog)
+                    {
+                        state.log.replace(tail, TypePackVar(TypePack{{}}));
+                    }
+                    else
+                    {
+                        state.DEPRECATED_log(tail);
+                        *asMutable(tail) = TypePack{};
+                    }
 
-            // If any remaining unfulfilled parameters are nonoptional, this is a problem.
-            while (paramIter != endIter)
-            {
-                TypeId t = follow(*paramIter);
-                if (isOptional(t))
-                {
-                } // ok
-                else if (get<ErrorTypeVar>(t))
-                {
-                } // ok
-                else if (isNonstrictMode() && get<AnyTypeVar>(t))
-                {
-                } // ok
-                else
-                {
-                    state.errors.push_back(TypeError{state.location, CountMismatch{minParams, paramIndex}});
                     return;
                 }
+                else if (get<GenericTypePack>(tail))
+                {
+                    // For this case, we want the error span to cover every errant extra parameter
+                    Location location = state.location;
+                    if (!argLocations.empty())
+                        location = {state.location.begin, argLocations.back().end};
+                    // TODO: Better error message?
+                    state.errors.push_back(TypeError{location, CountMismatch{minParams, std::distance(begin(argPack), end(argPack))}});
+                    return;
+                }
+            }
+            else
+            {
+                unifyWithInstantiationIfNeeded(scope, *argIter, *paramIter, state);
+                ++argIter;
                 ++paramIter;
             }
+
+            ++paramIndex;
         }
-        else if (paramIter == endIter)
-        {
-            // too many parameters passed
-            if (!paramIter.tail())
-            {
-                while (argIter != endIter)
-                {
-                    unify(*argIter, errorRecoveryType(scope), state.location);
-                    ++argIter;
-                }
-                // For this case, we want the error span to cover every errant extra parameter
-                Location location = state.location;
-                if (!argLocations.empty())
-                    location = {state.location.begin, argLocations.back().end};
-                state.errors.push_back(TypeError{location, CountMismatch{minParams, std::distance(begin(argPack), end(argPack))}});
-                return;
-            }
-            TypePackId tail = *paramIter.tail();
-
-            if (get<Unifiable::Error>(tail))
-            {
-                // Function is variadic.  Ok.
-                return;
-            }
-            else if (auto vtp = get<VariadicTypePack>(tail))
-            {
-                // Function is variadic and requires that all subsequent parameters
-                // be compatible with a type.
-                size_t argIndex = paramIndex;
-                while (argIter != endIter)
-                {
-                    Location location = state.location;
-
-                    if (argIndex < argLocations.size())
-                        location = argLocations[argIndex];
-
-                    unify(vtp->ty, *argIter, location);
-                    ++argIter;
-                    ++argIndex;
-                }
-
-                return;
-            }
-            else if (get<FreeTypePack>(tail))
-            {
-                // Create a type pack out of the remaining argument types
-                // and unify it with the tail.
-                std::vector<TypeId> rest;
-                rest.reserve(std::distance(argIter, endIter));
-                while (argIter != endIter)
-                {
-                    rest.push_back(*argIter);
-                    ++argIter;
-                }
-
-                TypePackId varPack = addTypePack(TypePackVar{TypePack{rest, argIter.tail()}});
-                state.tryUnify(tail, varPack);
-                return;
-            }
-            else if (get<FreeTypePack>(tail))
-            {
-                state.log(tail);
-                *asMutable(tail) = TypePack{};
-
-                return;
-            }
-            else if (get<GenericTypePack>(tail))
-            {
-                // For this case, we want the error span to cover every errant extra parameter
-                Location location = state.location;
-                if (!argLocations.empty())
-                    location = {state.location.begin, argLocations.back().end};
-                // TODO: Better error message?
-                state.errors.push_back(TypeError{location, CountMismatch{minParams, std::distance(begin(argPack), end(argPack))}});
-                return;
-            }
-        }
-        else
-        {
-            unifyWithInstantiationIfNeeded(scope, *paramIter, *argIter, state);
-            ++argIter;
-            ++paramIter;
-        }
-
-        ++paramIndex;
     }
 }
 
@@ -3475,7 +3726,7 @@ std::optional<ExprResult<TypePackId>> TypeChecker::checkCallOverload(const Scope
 
     if (get<AnyTypeVar>(fn))
     {
-        unify(argPack, anyTypePack, expr.location);
+        unify(anyTypePack, argPack, expr.location);
         return {{anyTypePack}};
     }
 
@@ -3490,7 +3741,7 @@ std::optional<ExprResult<TypePackId>> TypeChecker::checkCallOverload(const Scope
         // has been instantiated, so is a monotype. We can therefore
         // unify it with a monomorphic function.
         TypeId r = addType(FunctionTypeVar(scope->level, argPack, retPack));
-        unify(r, fn, expr.location);
+        unify(fn, r, expr.location);
         return {{retPack}};
     }
 
@@ -3533,7 +3784,7 @@ std::optional<ExprResult<TypePackId>> TypeChecker::checkCallOverload(const Scope
     if (!ftv)
     {
         reportError(TypeError{expr.func->location, CannotCallNonFunction{fn}});
-        unify(retPack, errorRecoveryTypePack(scope), expr.func->location);
+        unify(errorRecoveryTypePack(scope), retPack, expr.func->location);
         return {{errorRecoveryTypePack(retPack)}};
     }
 
@@ -3552,7 +3803,9 @@ std::optional<ExprResult<TypePackId>> TypeChecker::checkCallOverload(const Scope
     checkArgumentList(scope, state, retPack, ftv->retType, /*argLocations*/ {});
     if (!state.errors.empty())
     {
-        state.log.rollback();
+        if (!FFlag::LuauUseCommittingTxnLog)
+            state.DEPRECATED_log.rollback();
+
         return {};
     }
 
@@ -3580,10 +3833,15 @@ std::optional<ExprResult<TypePackId>> TypeChecker::checkCallOverload(const Scope
             overloadsThatDont.push_back(fn);
 
         errors.emplace_back(std::move(state.errors), args->head, ftv);
-        state.log.rollback();
+
+        if (!FFlag::LuauUseCommittingTxnLog)
+            state.DEPRECATED_log.rollback();
     }
     else
     {
+        if (FFlag::LuauUseCommittingTxnLog)
+            state.log.commit();
+
         if (isNonstrictMode() && !expr.self && expr.func->is<AstExprIndexName>() && ftv->hasSelf)
         {
             // If we are running in nonstrict mode, passing fewer arguments than the function is declared to take AND
@@ -3640,6 +3898,9 @@ bool TypeChecker::handleSelfCallMismatch(const ScopePtr& scope, const AstExprCal
 
             if (editedState.errors.empty())
             {
+                if (FFlag::LuauUseCommittingTxnLog)
+                    editedState.log.commit();
+
                 reportError(TypeError{expr.location, FunctionDoesNotTakeSelf{}});
                 // This is a little bit suspect: If this overload would work with a . replaced by a :
                 // we eagerly assume that that's what you actually meant and we commit to it.
@@ -3648,8 +3909,8 @@ bool TypeChecker::handleSelfCallMismatch(const ScopePtr& scope, const AstExprCal
                 // checkArgumentList(scope, editedState, retPack, ftv->retType, retLocations, CountMismatch::Return);
                 return true;
             }
-            else
-                editedState.log.rollback();
+            else if (!FFlag::LuauUseCommittingTxnLog)
+                editedState.DEPRECATED_log.rollback();
         }
         else if (ftv->hasSelf)
         {
@@ -3671,6 +3932,9 @@ bool TypeChecker::handleSelfCallMismatch(const ScopePtr& scope, const AstExprCal
 
                 if (editedState.errors.empty())
                 {
+                    if (FFlag::LuauUseCommittingTxnLog)
+                        editedState.log.commit();
+
                     reportError(TypeError{expr.location, FunctionRequiresSelf{}});
                     // This is a little bit suspect: If this overload would work with a : replaced by a .
                     // we eagerly assume that that's what you actually meant and we commit to it.
@@ -3679,8 +3943,8 @@ bool TypeChecker::handleSelfCallMismatch(const ScopePtr& scope, const AstExprCal
                     // checkArgumentList(scope, editedState, retPack, ftv->retType, retLocations, CountMismatch::Return);
                     return true;
                 }
-                else
-                    editedState.log.rollback();
+                else if (!FFlag::LuauUseCommittingTxnLog)
+                    editedState.DEPRECATED_log.rollback();
             }
         }
     }
@@ -3740,6 +4004,9 @@ void TypeChecker::reportOverloadResolutionError(const ScopePtr& scope, const Ast
             checkArgumentList(scope, state, argPack, ftv->argTypes, argLocations);
         }
 
+        if (FFlag::LuauUseCommittingTxnLog && state.errors.empty())
+            state.log.commit();
+
         if (i > 0)
             s += "; ";
 
@@ -3748,7 +4015,8 @@ void TypeChecker::reportOverloadResolutionError(const ScopePtr& scope, const Ast
 
         s += toString(overload);
 
-        state.log.rollback();
+        if (!FFlag::LuauUseCommittingTxnLog)
+            state.DEPRECATED_log.rollback();
     }
 
     if (overloadsThatMatchArgCount.size() == 0)
@@ -3781,6 +4049,8 @@ ExprResult<TypePackId> TypeChecker::checkExprList(const ScopePtr& scope, const L
 
     Unifier state = mkUnifier(location);
 
+    std::vector<TxnLog> inverseLogs;
+
     for (size_t i = 0; i < exprs.size; ++i)
     {
         AstExpr* expr = exprs.data[i];
@@ -3791,18 +4061,15 @@ ExprResult<TypePackId> TypeChecker::checkExprList(const ScopePtr& scope, const L
             auto [typePack, exprPredicates] = checkExprPack(scope, *expr);
             insert(exprPredicates);
 
-            if (FFlag::LuauTailArgumentTypeInfo)
+            if (std::optional<TypeId> firstTy = first(typePack))
             {
-                if (std::optional<TypeId> firstTy = first(typePack))
-                {
-                    if (!currentModule->astTypes.find(expr))
-                        currentModule->astTypes[expr] = follow(*firstTy);
-                }
-
-                if (expectedType)
-                    currentModule->astExpectedTypes[expr] = *expectedType;
+                if (!currentModule->astTypes.find(expr))
+                    currentModule->astTypes[expr] = follow(*firstTy);
             }
 
+            if (expectedType)
+                currentModule->astExpectedTypes[expr] = *expectedType;
+
             tp->tail = typePack;
         }
         else
@@ -3816,13 +4083,31 @@ ExprResult<TypePackId> TypeChecker::checkExprList(const ScopePtr& scope, const L
                 actualType = instantiate(scope, actualType, expr->location);
 
             if (expectedType)
-                state.tryUnify(*expectedType, actualType);
+            {
+                state.tryUnify(actualType, *expectedType);
+
+                // Ugly: In future iterations of the loop, we might need the state of the unification we
+                // just performed. There's not a great way to pass that into checkExpr. Instead, we store
+                // the inverse of the current log, and commit it. When we're done, we'll commit all the
+                // inverses. This isn't optimal, and a better solution is welcome here.
+                if (FFlag::LuauUseCommittingTxnLog)
+                {
+                    inverseLogs.push_back(state.log.inverse());
+                    state.log.commit();
+                }
+            }
 
             tp->head.push_back(actualType);
         }
     }
 
-    state.log.rollback();
+    if (FFlag::LuauUseCommittingTxnLog)
+    {
+        for (TxnLog& log : inverseLogs)
+            log.commit();
+    }
+    else
+        state.DEPRECATED_log.rollback();
 
     return {pack, predicates};
 }
@@ -3884,7 +4169,7 @@ TypeId TypeChecker::checkRequire(const ScopePtr& scope, const ModuleInfo& module
 
     TypePackId modulePack = module->getModuleScope()->returnType;
 
-    if (FFlag::LuauModuleRequireErrorPack && get<Unifiable::Error>(modulePack))
+    if (get<Unifiable::Error>(modulePack))
         return errorRecoveryType(scope);
 
     std::optional<TypeId> moduleType = first(modulePack);
@@ -3917,72 +4202,94 @@ TypeId TypeChecker::anyIfNonstrict(TypeId ty) const
         return ty;
 }
 
-bool TypeChecker::unify(TypeId left, TypeId right, const Location& location)
+bool TypeChecker::unify(TypeId subTy, TypeId superTy, const Location& location)
 {
     Unifier state = mkUnifier(location);
-    state.tryUnify(left, right);
+    state.tryUnify(subTy, superTy);
+
+    if (FFlag::LuauUseCommittingTxnLog)
+        state.log.commit();
 
     reportErrors(state.errors);
 
     return state.errors.empty();
 }
 
-bool TypeChecker::unify(TypePackId left, TypePackId right, const Location& location, CountMismatch::Context ctx)
+bool TypeChecker::unify(TypePackId subTy, TypePackId superTy, const Location& location, CountMismatch::Context ctx)
 {
     Unifier state = mkUnifier(location);
     state.ctx = ctx;
-    state.tryUnify(left, right);
+    state.tryUnify(subTy, superTy);
+
+    if (FFlag::LuauUseCommittingTxnLog)
+        state.log.commit();
 
     reportErrors(state.errors);
 
     return state.errors.empty();
 }
 
-bool TypeChecker::unifyWithInstantiationIfNeeded(const ScopePtr& scope, TypeId left, TypeId right, const Location& location)
+bool TypeChecker::unifyWithInstantiationIfNeeded(const ScopePtr& scope, TypeId subTy, TypeId superTy, const Location& location)
 {
     Unifier state = mkUnifier(location);
-    unifyWithInstantiationIfNeeded(scope, left, right, state);
+    unifyWithInstantiationIfNeeded(scope, subTy, superTy, state);
+
+    if (FFlag::LuauUseCommittingTxnLog)
+        state.log.commit();
 
     reportErrors(state.errors);
 
     return state.errors.empty();
 }
 
-void TypeChecker::unifyWithInstantiationIfNeeded(const ScopePtr& scope, TypeId left, TypeId right, Unifier& state)
+void TypeChecker::unifyWithInstantiationIfNeeded(const ScopePtr& scope, TypeId subTy, TypeId superTy, Unifier& state)
 {
-    if (!maybeGeneric(right))
+    if (!maybeGeneric(subTy))
         // Quick check to see if we definitely can't instantiate
-        state.tryUnify(left, right, /*isFunctionCall*/ false);
-    else if (!maybeGeneric(left) && isGeneric(right))
+        state.tryUnify(subTy, superTy, /*isFunctionCall*/ false);
+    else if (!maybeGeneric(superTy) && isGeneric(subTy))
     {
         // Quick check to see if we definitely have to instantiate
-        TypeId instantiated = instantiate(scope, right, state.location);
-        state.tryUnify(left, instantiated, /*isFunctionCall*/ false);
+        TypeId instantiated = instantiate(scope, subTy, state.location);
+        state.tryUnify(instantiated, superTy, /*isFunctionCall*/ false);
     }
     else
     {
         // First try unifying with the original uninstantiated type
         // but if that fails, try the instantiated one.
         Unifier child = state.makeChildUnifier();
-        child.tryUnify(left, right, /*isFunctionCall*/ false);
+        child.tryUnify(subTy, superTy, /*isFunctionCall*/ false);
         if (!child.errors.empty())
         {
-            TypeId instantiated = instantiate(scope, right, state.location);
-            if (right == instantiated)
+            TypeId instantiated = instantiate(scope, subTy, state.location);
+            if (subTy == instantiated)
             {
                 // Instantiating the argument made no difference, so just report any child errors
-                state.log.concat(std::move(child.log));
+                if (FFlag::LuauUseCommittingTxnLog)
+                    state.log.concat(std::move(child.log));
+                else
+                    state.DEPRECATED_log.concat(std::move(child.DEPRECATED_log));
+
                 state.errors.insert(state.errors.end(), child.errors.begin(), child.errors.end());
             }
             else
             {
-                child.log.rollback();
-                state.tryUnify(left, instantiated, /*isFunctionCall*/ false);
+                if (!FFlag::LuauUseCommittingTxnLog)
+                    child.DEPRECATED_log.rollback();
+
+                state.tryUnify(instantiated, superTy, /*isFunctionCall*/ false);
             }
         }
         else
         {
-            state.log.concat(std::move(child.log));
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                state.log.concat(std::move(child.log));
+            }
+            else
+            {
+                state.DEPRECATED_log.concat(std::move(child.DEPRECATED_log));
+            }
         }
     }
 }
@@ -4139,7 +4446,7 @@ TypePackId Quantification::clean(TypePackId tp)
 bool Anyification::isDirty(TypeId ty)
 {
     if (const TableTypeVar* ttv = get<TableTypeVar>(ty))
-        return (ttv->state == TableState::Free);
+        return (ttv->state == TableState::Free || (FFlag::LuauSealExports && ttv->state == TableState::Unsealed));
     else if (get<FreeTypeVar>(ty))
         return true;
     else
@@ -4162,6 +4469,12 @@ TypeId Anyification::clean(TypeId ty)
         TableTypeVar clone = TableTypeVar{ttv->props, ttv->indexer, ttv->level, TableState::Sealed};
         clone.methodDefinitionLocations = ttv->methodDefinitionLocations;
         clone.definitionModuleName = ttv->definitionModuleName;
+        if (FFlag::LuauSealExports)
+        {
+            clone.name = ttv->name;
+            clone.syntheticName = ttv->syntheticName;
+            clone.tags = ttv->tags;
+        }
         return addType(std::move(clone));
     }
     else
@@ -5194,8 +5507,8 @@ void TypeChecker::resolve(const IsAPredicate& isaP, ErrorVec& errVec, Refinement
         // This by itself is not truly enough to determine that A is stronger than B or vice versa.
         // The best unambiguous way about this would be to have a function that returns the relationship ordering of a pair.
         // i.e. TypeRelationship relationshipOf(TypeId superTy, TypeId subTy)
-        bool optionIsSubtype = canUnify(isaP.ty, option, isaP.location).empty();
-        bool targetIsSubtype = canUnify(option, isaP.ty, isaP.location).empty();
+        bool optionIsSubtype = canUnify(option, isaP.ty, isaP.location).empty();
+        bool targetIsSubtype = canUnify(isaP.ty, option, isaP.location).empty();
 
         // If A is a superset of B, then if sense is true, we promote A to B, otherwise we keep A.
         if (!optionIsSubtype && targetIsSubtype)
@@ -5379,7 +5692,7 @@ void TypeChecker::resolve(const EqPredicate& eqP, ErrorVec& errVec, RefinementMa
             for (TypeId right : rhs)
             {
                 // When singleton types arrive, `isNil` here probably should be replaced with `isLiteral`.
-                if (canUnify(left, right, eqP.location).empty() == sense || (!sense && !isNil(left)))
+                if (canUnify(right, left, eqP.location).empty() == sense || (!sense && !isNil(left)))
                     set.insert(left);
             }
         }
@@ -5406,7 +5719,7 @@ std::vector<TypeId> TypeChecker::unTypePack(const ScopePtr& scope, TypePackId tp
     for (size_t i = 0; i < expectedLength; ++i)
         expectedPack->head.push_back(freshType(scope));
 
-    unify(expectedTypePack, tp, location);
+    unify(tp, expectedTypePack, location);
 
     for (TypeId& tp : expectedPack->head)
         tp = follow(tp);
diff --git a/Analysis/src/TypePack.cpp b/Analysis/src/TypePack.cpp
index d3221c73..b15548a8 100644
--- a/Analysis/src/TypePack.cpp
+++ b/Analysis/src/TypePack.cpp
@@ -1,8 +1,12 @@
 // This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
 #include "Luau/TypePack.h"
 
+#include "Luau/TxnLog.h"
+
 #include <stdexcept>
 
+LUAU_FASTFLAG(LuauUseCommittingTxnLog)
+
 namespace Luau
 {
 
@@ -35,14 +39,28 @@ TypePackVar& TypePackVar::operator=(TypePackVariant&& tp)
 }
 
 TypePackIterator::TypePackIterator(TypePackId typePack)
+    : TypePackIterator(typePack, TxnLog::empty())
+{
+}
+
+TypePackIterator::TypePackIterator(TypePackId typePack, const TxnLog* log)
     : currentTypePack(follow(typePack))
     , tp(get<TypePack>(currentTypePack))
     , currentIndex(0)
+    , log(log)
 {
     while (tp && tp->head.empty())
     {
-        currentTypePack = tp->tail ? follow(*tp->tail) : nullptr;
-        tp = currentTypePack ? get<TypePack>(currentTypePack) : nullptr;
+        if (FFlag::LuauUseCommittingTxnLog)
+        {
+            currentTypePack = tp->tail ? log->follow(*tp->tail) : nullptr;
+            tp = currentTypePack ? log->getMutable<TypePack>(currentTypePack) : nullptr;
+        }
+        else
+        {
+            currentTypePack = tp->tail ? follow(*tp->tail) : nullptr;
+            tp = currentTypePack ? get<TypePack>(currentTypePack) : nullptr;
+        }
     }
 }
 
@@ -53,8 +71,17 @@ TypePackIterator& TypePackIterator::operator++()
     ++currentIndex;
     while (tp && currentIndex >= tp->head.size())
     {
-        currentTypePack = tp->tail ? follow(*tp->tail) : nullptr;
-        tp = currentTypePack ? get<TypePack>(currentTypePack) : nullptr;
+        if (FFlag::LuauUseCommittingTxnLog)
+        {
+            currentTypePack = tp->tail ? log->follow(*tp->tail) : nullptr;
+            tp = currentTypePack ? log->getMutable<TypePack>(currentTypePack) : nullptr;
+        }
+        else
+        {
+            currentTypePack = tp->tail ? follow(*tp->tail) : nullptr;
+            tp = currentTypePack ? get<TypePack>(currentTypePack) : nullptr;
+        }
+
         currentIndex = 0;
     }
 
@@ -95,6 +122,11 @@ TypePackIterator begin(TypePackId tp)
     return TypePackIterator{tp};
 }
 
+TypePackIterator begin(TypePackId tp, TxnLog* log)
+{
+    return TypePackIterator{tp, log};
+}
+
 TypePackIterator end(TypePackId tp)
 {
     return TypePackIterator{};
@@ -160,8 +192,15 @@ bool areEqual(SeenSet& seen, const TypePackVar& lhs, const TypePackVar& rhs)
 
 TypePackId follow(TypePackId tp)
 {
-    auto advance = [](TypePackId ty) -> std::optional<TypePackId> {
-        if (const Unifiable::Bound<TypePackId>* btv = get<Unifiable::Bound<TypePackId>>(ty))
+    return follow(tp, [](TypePackId t) {
+        return t;
+    });
+}
+
+TypePackId follow(TypePackId tp, std::function<TypePackId(TypePackId)> mapper)
+{
+    auto advance = [&mapper](TypePackId ty) -> std::optional<TypePackId> {
+        if (const Unifiable::Bound<TypePackId>* btv = get<Unifiable::Bound<TypePackId>>(mapper(ty)))
             return btv->boundTo;
         else
             return std::nullopt;
diff --git a/Analysis/src/TypeVar.cpp b/Analysis/src/TypeVar.cpp
index fb75aa02..4cab79c8 100644
--- a/Analysis/src/TypeVar.cpp
+++ b/Analysis/src/TypeVar.cpp
@@ -31,17 +31,24 @@ std::optional<ExprResult<TypePackId>> magicFunctionFormat(
 
 TypeId follow(TypeId t)
 {
-    auto advance = [](TypeId ty) -> std::optional<TypeId> {
-        if (auto btv = get<Unifiable::Bound<TypeId>>(ty))
+    return follow(t, [](TypeId t) {
+        return t;
+    });
+}
+
+TypeId follow(TypeId t, std::function<TypeId(TypeId)> mapper)
+{
+    auto advance = [&mapper](TypeId ty) -> std::optional<TypeId> {
+        if (auto btv = get<Unifiable::Bound<TypeId>>(mapper(ty)))
             return btv->boundTo;
-        else if (auto ttv = get<TableTypeVar>(ty))
+        else if (auto ttv = get<TableTypeVar>(mapper(ty)))
             return ttv->boundTo;
         else
             return std::nullopt;
     };
 
-    auto force = [](TypeId ty) {
-        if (auto ltv = get_if<LazyTypeVar>(&ty->ty))
+    auto force = [&mapper](TypeId ty) {
+        if (auto ltv = get_if<LazyTypeVar>(&mapper(ty)->ty))
         {
             TypeId res = ltv->thunk();
             if (get<LazyTypeVar>(res))
@@ -1004,7 +1011,7 @@ std::optional<ExprResult<TypePackId>> magicFunctionFormat(
     {
         Location location = expr.args.data[std::min(i + dataOffset, expr.args.size - 1)]->location;
 
-        typechecker.unify(expected[i], params[i + paramOffset], location);
+        typechecker.unify(params[i + paramOffset], expected[i], location);
     }
 
     // if we know the argument count or if we have too many arguments for sure, we can issue an error
diff --git a/Analysis/src/TypedAllocator.cpp b/Analysis/src/TypedAllocator.cpp
index f037351e..1f7ef8c2 100644
--- a/Analysis/src/TypedAllocator.cpp
+++ b/Analysis/src/TypedAllocator.cpp
@@ -20,6 +20,7 @@ const size_t kPageSize = sysconf(_SC_PAGESIZE);
 #include <stdlib.h>
 
 LUAU_FASTFLAG(DebugLuauFreezeArena)
+LUAU_FASTFLAGVARIABLE(LuauTypedAllocatorZeroStart, false)
 
 namespace Luau
 {
diff --git a/Analysis/src/Unifier.cpp b/Analysis/src/Unifier.cpp
index 43ea37e7..393a84a7 100644
--- a/Analysis/src/Unifier.cpp
+++ b/Analysis/src/Unifier.cpp
@@ -13,6 +13,7 @@
 
 LUAU_FASTINT(LuauTypeInferRecursionLimit);
 LUAU_FASTINT(LuauTypeInferTypePackLoopLimit);
+LUAU_FASTFLAG(LuauUseCommittingTxnLog)
 LUAU_FASTINTVARIABLE(LuauTypeInferIterationLimit, 2000);
 LUAU_FASTFLAGVARIABLE(LuauTableSubtypingVariance2, false);
 LUAU_FASTFLAGVARIABLE(LuauUnionHeuristic, false)
@@ -29,27 +30,39 @@ namespace Luau
 
 struct PromoteTypeLevels
 {
+    DEPRECATED_TxnLog& DEPRECATED_log;
     TxnLog& log;
     TypeLevel minLevel;
 
-    explicit PromoteTypeLevels(TxnLog& log, TypeLevel minLevel)
-        : log(log)
+    explicit PromoteTypeLevels(DEPRECATED_TxnLog& DEPRECATED_log, TxnLog& log, TypeLevel minLevel)
+        : DEPRECATED_log(DEPRECATED_log)
+        , log(log)
         , minLevel(minLevel)
-    {}
+    {
+    }
 
-    template <typename TID, typename T>
+    template<typename TID, typename T>
     void promote(TID ty, T* t)
     {
         LUAU_ASSERT(t);
         if (minLevel.subsumesStrict(t->level))
         {
-            log(ty);
-            t->level = minLevel;
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                log.changeLevel(ty, minLevel);
+            }
+            else
+            {
+                DEPRECATED_log(ty);
+                t->level = minLevel;
+            }
         }
     }
 
     template<typename TID>
-    void cycle(TID) {}
+    void cycle(TID)
+    {
+    }
 
     template<typename TID, typename T>
     bool operator()(TID, const T&)
@@ -59,39 +72,47 @@ struct PromoteTypeLevels
 
     bool operator()(TypeId ty, const FreeTypeVar&)
     {
-        promote(ty, getMutable<FreeTypeVar>(ty));
+        // Surprise, it's actually a BoundTypeVar that hasn't been committed yet.
+        // Calling getMutable on this will trigger an assertion.
+        if (FFlag::LuauUseCommittingTxnLog && !log.is<FreeTypeVar>(ty))
+            return true;
+
+        promote(ty, FFlag::LuauUseCommittingTxnLog ? log.getMutable<FreeTypeVar>(ty) : getMutable<FreeTypeVar>(ty));
         return true;
     }
 
     bool operator()(TypeId ty, const FunctionTypeVar&)
     {
-        promote(ty, getMutable<FunctionTypeVar>(ty));
+        promote(ty, FFlag::LuauUseCommittingTxnLog ? log.getMutable<FunctionTypeVar>(ty) : getMutable<FunctionTypeVar>(ty));
         return true;
     }
 
-    bool operator()(TypeId ty, const TableTypeVar&)
+    bool operator()(TypeId ty, const TableTypeVar& ttv)
     {
-        promote(ty, getMutable<TableTypeVar>(ty));
+        if (ttv.state != TableState::Free && ttv.state != TableState::Generic)
+            return true;
+
+        promote(ty, FFlag::LuauUseCommittingTxnLog ? log.getMutable<TableTypeVar>(ty) : getMutable<TableTypeVar>(ty));
         return true;
     }
 
     bool operator()(TypePackId tp, const FreeTypePack&)
     {
-        promote(tp, getMutable<FreeTypePack>(tp));
+        promote(tp, FFlag::LuauUseCommittingTxnLog ? log.getMutable<FreeTypePack>(tp) : getMutable<FreeTypePack>(tp));
         return true;
     }
 };
 
-void promoteTypeLevels(TxnLog& log, TypeLevel minLevel, TypeId ty)
+void promoteTypeLevels(DEPRECATED_TxnLog& DEPRECATED_log, TxnLog& log, TypeLevel minLevel, TypeId ty)
 {
-    PromoteTypeLevels ptl{log, minLevel};
+    PromoteTypeLevels ptl{DEPRECATED_log, log, minLevel};
     DenseHashSet<void*> seen{nullptr};
     visitTypeVarOnce(ty, ptl, seen);
 }
 
-void promoteTypeLevels(TxnLog& log, TypeLevel minLevel, TypePackId tp)
+void promoteTypeLevels(DEPRECATED_TxnLog& DEPRECATED_log, TxnLog& log, TypeLevel minLevel, TypePackId tp)
 {
-    PromoteTypeLevels ptl{log, minLevel};
+    PromoteTypeLevels ptl{DEPRECATED_log, log, minLevel};
     DenseHashSet<void*> seen{nullptr};
     visitTypeVarOnce(tp, ptl, seen);
 }
@@ -221,10 +242,12 @@ static std::optional<std::pair<Luau::Name, const SingletonTypeVar*>> getTableMat
     return std::nullopt;
 }
 
-Unifier::Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, const Location& location, Variance variance, UnifierSharedState& sharedState)
+Unifier::Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, const Location& location, Variance variance, UnifierSharedState& sharedState,
+    TxnLog* parentLog)
     : types(types)
     , mode(mode)
     , globalScope(std::move(globalScope))
+    , log(parentLog)
     , location(location)
     , variance(variance)
     , sharedState(sharedState)
@@ -233,11 +256,12 @@ Unifier::Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, const Locati
 }
 
 Unifier::Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, std::vector<std::pair<TypeId, TypeId>>* sharedSeen, const Location& location,
-    Variance variance, UnifierSharedState& sharedState)
+    Variance variance, UnifierSharedState& sharedState, TxnLog* parentLog)
     : types(types)
     , mode(mode)
     , globalScope(std::move(globalScope))
-    , log(sharedSeen)
+    , DEPRECATED_log(sharedSeen)
+    , log(parentLog, sharedSeen)
     , location(location)
     , variance(variance)
     , sharedState(sharedState)
@@ -245,14 +269,14 @@ Unifier::Unifier(TypeArena* types, Mode mode, ScopePtr globalScope, std::vector<
     LUAU_ASSERT(sharedState.iceHandler);
 }
 
-void Unifier::tryUnify(TypeId superTy, TypeId subTy, bool isFunctionCall, bool isIntersection)
+void Unifier::tryUnify(TypeId subTy, TypeId superTy, bool isFunctionCall, bool isIntersection)
 {
     sharedState.counters.iterationCount = 0;
 
-    tryUnify_(superTy, subTy, isFunctionCall, isIntersection);
+    tryUnify_(subTy, superTy, isFunctionCall, isIntersection);
 }
 
-void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool isIntersection)
+void Unifier::tryUnify_(TypeId subTy, TypeId superTy, bool isFunctionCall, bool isIntersection)
 {
     RecursionLimiter _ra(&sharedState.counters.recursionCount, FInt::LuauTypeInferRecursionLimit);
 
@@ -264,55 +288,112 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
         return;
     }
 
-    superTy = follow(superTy);
-    subTy = follow(subTy);
+    if (FFlag::LuauUseCommittingTxnLog)
+    {
+        superTy = log.follow(superTy);
+        subTy = log.follow(subTy);
+    }
+    else
+    {
+        superTy = follow(superTy);
+        subTy = follow(subTy);
+    }
 
     if (superTy == subTy)
         return;
 
-    auto l = getMutable<FreeTypeVar>(superTy);
-    auto r = getMutable<FreeTypeVar>(subTy);
+    auto superFree = getMutable<FreeTypeVar>(superTy);
+    auto subFree = getMutable<FreeTypeVar>(subTy);
 
-    if (l && r && l->level.subsumes(r->level))
+    if (FFlag::LuauUseCommittingTxnLog)
+    {
+        superFree = log.getMutable<FreeTypeVar>(superTy);
+        subFree = log.getMutable<FreeTypeVar>(subTy);
+    }
+
+    if (superFree && subFree && superFree->level.subsumes(subFree->level))
     {
         occursCheck(subTy, superTy);
 
         // The occurrence check might have caused superTy no longer to be a free type
-        if (!get<ErrorTypeVar>(subTy))
+        bool occursFailed = false;
+        if (FFlag::LuauUseCommittingTxnLog)
+            occursFailed = bool(log.getMutable<ErrorTypeVar>(subTy));
+        else
+            occursFailed = bool(get<ErrorTypeVar>(subTy));
+
+        if (!occursFailed)
         {
-            log(subTy);
-            *asMutable(subTy) = BoundTypeVar(superTy);
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                log.replace(subTy, BoundTypeVar(superTy));
+            }
+            else
+            {
+                DEPRECATED_log(subTy);
+                *asMutable(subTy) = BoundTypeVar(superTy);
+            }
         }
 
         return;
     }
-    else if (l && r)
+    else if (superFree && subFree)
     {
-        if (!FFlag::LuauErrorRecoveryType)
-            log(superTy);
-        occursCheck(superTy, subTy);
-        r->level = min(r->level, l->level);
-
-        // The occurrence check might have caused superTy no longer to be a free type
-        if (!FFlag::LuauErrorRecoveryType)
-            *asMutable(superTy) = BoundTypeVar(subTy);
-        else if (!get<ErrorTypeVar>(superTy))
+        if (!FFlag::LuauErrorRecoveryType && !FFlag::LuauUseCommittingTxnLog)
+        {
+            DEPRECATED_log(superTy);
+            subFree->level = min(subFree->level, superFree->level);
+        }
+
+        occursCheck(superTy, subTy);
+
+        bool occursFailed = false;
+        if (FFlag::LuauUseCommittingTxnLog)
+            occursFailed = bool(log.getMutable<ErrorTypeVar>(superTy));
+        else
+            occursFailed = bool(get<ErrorTypeVar>(superTy));
+
+        if (!FFlag::LuauErrorRecoveryType && !FFlag::LuauUseCommittingTxnLog)
         {
-            log(superTy);
             *asMutable(superTy) = BoundTypeVar(subTy);
+            return;
+        }
+
+        if (!occursFailed)
+        {
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                if (superFree->level.subsumes(subFree->level))
+                {
+                    log.changeLevel(subTy, superFree->level);
+                }
+
+                log.replace(superTy, BoundTypeVar(subTy));
+            }
+            else
+            {
+                DEPRECATED_log(superTy);
+                *asMutable(superTy) = BoundTypeVar(subTy);
+                subFree->level = min(subFree->level, superFree->level);
+            }
         }
 
         return;
     }
-    else if (l)
+    else if (superFree)
     {
         occursCheck(superTy, subTy);
+        bool occursFailed = false;
+        if (FFlag::LuauUseCommittingTxnLog)
+            occursFailed = bool(log.getMutable<ErrorTypeVar>(superTy));
+        else
+            occursFailed = bool(get<ErrorTypeVar>(superTy));
 
-        TypeLevel superLevel = l->level;
+        TypeLevel superLevel = superFree->level;
 
         // Unification can't change the level of a generic.
-        auto rightGeneric = get<GenericTypeVar>(subTy);
-        if (rightGeneric && !rightGeneric->level.subsumes(superLevel))
+        auto subGeneric = FFlag::LuauUseCommittingTxnLog ? log.getMutable<GenericTypeVar>(subTy) : get<GenericTypeVar>(subTy);
+        if (subGeneric && !subGeneric->level.subsumes(superLevel))
         {
             // TODO: a more informative error message? CLI-39912
             errors.push_back(TypeError{location, GenericError{"Generic subtype escaping scope"}});
@@ -320,63 +401,83 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
         }
 
         // The occurrence check might have caused superTy no longer to be a free type
-        if (!get<ErrorTypeVar>(superTy))
+        if (!occursFailed)
         {
-            if (FFlag::LuauProperTypeLevels)
-                promoteTypeLevels(log, superLevel, subTy);
-            else if (auto rightLevel = getMutableLevel(subTy))
+            if (FFlag::LuauUseCommittingTxnLog)
             {
-                if (!rightLevel->subsumes(l->level))
-                    *rightLevel = l->level;
+                promoteTypeLevels(DEPRECATED_log, log, superLevel, subTy);
+                log.replace(superTy, BoundTypeVar(subTy));
             }
+            else
+            {
+                if (FFlag::LuauProperTypeLevels)
+                    promoteTypeLevels(DEPRECATED_log, log, superLevel, subTy);
+                else if (auto subLevel = getMutableLevel(subTy))
+                {
+                    if (!subLevel->subsumes(superFree->level))
+                        *subLevel = superFree->level;
+                }
 
-            log(superTy);
-            *asMutable(superTy) = BoundTypeVar(subTy);
+                DEPRECATED_log(superTy);
+                *asMutable(superTy) = BoundTypeVar(subTy);
+            }
         }
 
         return;
     }
-    else if (r)
+    else if (subFree)
     {
-        TypeLevel subLevel = r->level;
+        TypeLevel subLevel = subFree->level;
 
         occursCheck(subTy, superTy);
+        bool occursFailed = false;
+        if (FFlag::LuauUseCommittingTxnLog)
+            occursFailed = bool(log.getMutable<ErrorTypeVar>(subTy));
+        else
+            occursFailed = bool(get<ErrorTypeVar>(subTy));
 
         // Unification can't change the level of a generic.
-        auto leftGeneric = get<GenericTypeVar>(superTy);
-        if (leftGeneric && !leftGeneric->level.subsumes(r->level))
+        auto superGeneric = FFlag::LuauUseCommittingTxnLog ? log.getMutable<GenericTypeVar>(superTy) : get<GenericTypeVar>(superTy);
+        if (superGeneric && !superGeneric->level.subsumes(subFree->level))
         {
             // TODO: a more informative error message? CLI-39912
             errors.push_back(TypeError{location, GenericError{"Generic supertype escaping scope"}});
             return;
         }
 
-        if (!get<ErrorTypeVar>(subTy))
+        if (!occursFailed)
         {
-            if (FFlag::LuauProperTypeLevels)
-                promoteTypeLevels(log, subLevel, superTy);
-
-            if (auto superLevel = getMutableLevel(superTy))
+            if (FFlag::LuauUseCommittingTxnLog)
             {
-                if (!superLevel->subsumes(r->level))
-                {
-                    log(superTy);
-                    *superLevel = r->level;
-                }
+                promoteTypeLevels(DEPRECATED_log, log, subLevel, superTy);
+                log.replace(subTy, BoundTypeVar(superTy));
             }
+            else
+            {
+                if (FFlag::LuauProperTypeLevels)
+                    promoteTypeLevels(DEPRECATED_log, log, subLevel, superTy);
+                else if (auto superLevel = getMutableLevel(superTy))
+                {
+                    if (!superLevel->subsumes(subFree->level))
+                    {
+                        DEPRECATED_log(superTy);
+                        *superLevel = subFree->level;
+                    }
+                }
 
-            log(subTy);
-            *asMutable(subTy) = BoundTypeVar(superTy);
+                DEPRECATED_log(subTy);
+                *asMutable(subTy) = BoundTypeVar(superTy);
+            }
         }
 
         return;
     }
 
     if (get<ErrorTypeVar>(superTy) || get<AnyTypeVar>(superTy))
-        return tryUnifyWithAny(superTy, subTy);
+        return tryUnifyWithAny(subTy, superTy);
 
     if (get<ErrorTypeVar>(subTy) || get<AnyTypeVar>(subTy))
-        return tryUnifyWithAny(subTy, superTy);
+        return tryUnifyWithAny(superTy, subTy);
 
     bool cacheEnabled = !isFunctionCall && !isIntersection;
     auto& cache = sharedState.cachedUnify;
@@ -389,12 +490,22 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
     // Here, we assume that the types unify.  If they do not, we will find out as we roll back
     // the stack.
 
-    if (log.haveSeen(superTy, subTy))
-        return;
+    if (FFlag::LuauUseCommittingTxnLog)
+    {
+        if (log.haveSeen(superTy, subTy))
+            return;
 
-    log.pushSeen(superTy, subTy);
+        log.pushSeen(superTy, subTy);
+    }
+    else
+    {
+        if (DEPRECATED_log.haveSeen(superTy, subTy))
+            return;
 
-    if (const UnionTypeVar* uv = get<UnionTypeVar>(subTy))
+        DEPRECATED_log.pushSeen(superTy, subTy);
+    }
+
+    if (const UnionTypeVar* uv = FFlag::LuauUseCommittingTxnLog ? log.getMutable<UnionTypeVar>(subTy) : get<UnionTypeVar>(subTy))
     {
         // A | B <: T if A <: T and B <: T
         bool failed = false;
@@ -407,7 +518,7 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
         for (TypeId type : uv->options)
         {
             Unifier innerState = makeChildUnifier();
-            innerState.tryUnify_(superTy, type);
+            innerState.tryUnify_(type, superTy);
 
             if (auto e = hasUnificationTooComplex(innerState.errors))
                 unificationTooComplex = e;
@@ -420,10 +531,24 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
                 failed = true;
             }
 
-            if (i != count - 1)
-                innerState.log.rollback();
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                if (i == count - 1)
+                {
+                    log.concat(std::move(innerState.log));
+                }
+            }
             else
-                log.concat(std::move(innerState.log));
+            {
+                if (i != count - 1)
+                {
+                    innerState.DEPRECATED_log.rollback();
+                }
+                else
+                {
+                    DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
+                }
+            }
 
             ++i;
         }
@@ -438,7 +563,7 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
                 errors.push_back(TypeError{location, TypeMismatch{superTy, subTy}});
         }
     }
-    else if (const UnionTypeVar* uv = get<UnionTypeVar>(superTy))
+    else if (const UnionTypeVar* uv = FFlag::LuauUseCommittingTxnLog ? log.getMutable<UnionTypeVar>(superTy) : get<UnionTypeVar>(superTy))
     {
         // T <: A | B if T <: A or T <: B
         bool found = false;
@@ -502,12 +627,16 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
         {
             TypeId type = uv->options[(i + startIndex) % uv->options.size()];
             Unifier innerState = makeChildUnifier();
-            innerState.tryUnify_(type, subTy, isFunctionCall);
+            innerState.tryUnify_(subTy, type, isFunctionCall);
 
             if (innerState.errors.empty())
             {
                 found = true;
-                log.concat(std::move(innerState.log));
+                if (FFlag::LuauUseCommittingTxnLog)
+                    log.concat(std::move(innerState.log));
+                else
+                    DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
+
                 break;
             }
             else if (auto e = hasUnificationTooComplex(innerState.errors))
@@ -522,7 +651,8 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
                     failedOption = {innerState.errors.front()};
             }
 
-            innerState.log.rollback();
+            if (!FFlag::LuauUseCommittingTxnLog)
+                innerState.DEPRECATED_log.rollback();
         }
 
         if (unificationTooComplex)
@@ -538,7 +668,8 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
                 errors.push_back(TypeError{location, TypeMismatch{superTy, subTy, "none of the union options are compatible"}});
         }
     }
-    else if (const IntersectionTypeVar* uv = get<IntersectionTypeVar>(superTy))
+    else if (const IntersectionTypeVar* uv =
+                 FFlag::LuauUseCommittingTxnLog ? log.getMutable<IntersectionTypeVar>(superTy) : get<IntersectionTypeVar>(superTy))
     {
         std::optional<TypeError> unificationTooComplex;
         std::optional<TypeError> firstFailedOption;
@@ -547,7 +678,7 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
         for (TypeId type : uv->parts)
         {
             Unifier innerState = makeChildUnifier();
-            innerState.tryUnify_(type, subTy, /*isFunctionCall*/ false, /*isIntersection*/ true);
+            innerState.tryUnify_(subTy, type, /*isFunctionCall*/ false, /*isIntersection*/ true);
 
             if (auto e = hasUnificationTooComplex(innerState.errors))
                 unificationTooComplex = e;
@@ -557,7 +688,10 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
                     firstFailedOption = {innerState.errors.front()};
             }
 
-            log.concat(std::move(innerState.log));
+            if (FFlag::LuauUseCommittingTxnLog)
+                log.concat(std::move(innerState.log));
+            else
+                DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
         }
 
         if (unificationTooComplex)
@@ -565,7 +699,8 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
         else if (firstFailedOption)
             errors.push_back(TypeError{location, TypeMismatch{superTy, subTy, "Not all intersection parts are compatible.", *firstFailedOption}});
     }
-    else if (const IntersectionTypeVar* uv = get<IntersectionTypeVar>(subTy))
+    else if (const IntersectionTypeVar* uv =
+                 FFlag::LuauUseCommittingTxnLog ? log.getMutable<IntersectionTypeVar>(subTy) : get<IntersectionTypeVar>(subTy))
     {
         // A & B <: T if T <: A or T <: B
         bool found = false;
@@ -591,12 +726,15 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
         {
             TypeId type = uv->parts[(i + startIndex) % uv->parts.size()];
             Unifier innerState = makeChildUnifier();
-            innerState.tryUnify_(superTy, type, isFunctionCall);
+            innerState.tryUnify_(type, superTy, isFunctionCall);
 
             if (innerState.errors.empty())
             {
                 found = true;
-                log.concat(std::move(innerState.log));
+                if (FFlag::LuauUseCommittingTxnLog)
+                    log.concat(std::move(innerState.log));
+                else
+                    DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
                 break;
             }
             else if (auto e = hasUnificationTooComplex(innerState.errors))
@@ -604,7 +742,8 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
                 unificationTooComplex = e;
             }
 
-            innerState.log.rollback();
+            if (!FFlag::LuauUseCommittingTxnLog)
+                innerState.DEPRECATED_log.rollback();
         }
 
         if (unificationTooComplex)
@@ -614,44 +753,56 @@ void Unifier::tryUnify_(TypeId superTy, TypeId subTy, bool isFunctionCall, bool
             errors.push_back(TypeError{location, TypeMismatch{superTy, subTy, "none of the intersection parts are compatible"}});
         }
     }
-    else if (get<PrimitiveTypeVar>(superTy) && get<PrimitiveTypeVar>(subTy))
-        tryUnifyPrimitives(superTy, subTy);
+    else if ((FFlag::LuauUseCommittingTxnLog && log.getMutable<PrimitiveTypeVar>(superTy) && log.getMutable<PrimitiveTypeVar>(subTy)) ||
+             (!FFlag::LuauUseCommittingTxnLog && get<PrimitiveTypeVar>(superTy) && get<PrimitiveTypeVar>(subTy)))
+        tryUnifyPrimitives(subTy, superTy);
 
-    else if (FFlag::LuauSingletonTypes && (get<PrimitiveTypeVar>(superTy) || get<SingletonTypeVar>(superTy)) && get<SingletonTypeVar>(subTy))
-        tryUnifySingletons(superTy, subTy);
+    else if (FFlag::LuauSingletonTypes &&
+             ((FFlag::LuauUseCommittingTxnLog ? log.getMutable<PrimitiveTypeVar>(superTy) : get<PrimitiveTypeVar>(superTy)) ||
+                 (FFlag::LuauUseCommittingTxnLog ? log.getMutable<SingletonTypeVar>(superTy) : get<SingletonTypeVar>(superTy))) &&
+             (FFlag::LuauUseCommittingTxnLog ? log.getMutable<SingletonTypeVar>(subTy) : get<SingletonTypeVar>(subTy)))
+        tryUnifySingletons(subTy, superTy);
 
-    else if (get<FunctionTypeVar>(superTy) && get<FunctionTypeVar>(subTy))
-        tryUnifyFunctions(superTy, subTy, isFunctionCall);
+    else if ((FFlag::LuauUseCommittingTxnLog && log.getMutable<FunctionTypeVar>(superTy) && log.getMutable<FunctionTypeVar>(subTy)) ||
+             (!FFlag::LuauUseCommittingTxnLog && get<FunctionTypeVar>(superTy) && get<FunctionTypeVar>(subTy)))
+        tryUnifyFunctions(subTy, superTy, isFunctionCall);
 
-    else if (get<TableTypeVar>(superTy) && get<TableTypeVar>(subTy))
+    else if ((FFlag::LuauUseCommittingTxnLog && log.getMutable<TableTypeVar>(superTy) && log.getMutable<TableTypeVar>(subTy)) ||
+             (!FFlag::LuauUseCommittingTxnLog && get<TableTypeVar>(superTy) && get<TableTypeVar>(subTy)))
     {
-        tryUnifyTables(superTy, subTy, isIntersection);
+        tryUnifyTables(subTy, superTy, isIntersection);
 
         if (cacheEnabled && errors.empty())
-            cacheResult(superTy, subTy);
+            cacheResult(subTy, superTy);
     }
 
     // tryUnifyWithMetatable assumes its first argument is a MetatableTypeVar. The check is otherwise symmetrical.
-    else if (get<MetatableTypeVar>(superTy))
-        tryUnifyWithMetatable(superTy, subTy, /*reversed*/ false);
-    else if (get<MetatableTypeVar>(subTy))
-        tryUnifyWithMetatable(subTy, superTy, /*reversed*/ true);
+    else if ((FFlag::LuauUseCommittingTxnLog && log.getMutable<MetatableTypeVar>(superTy)) ||
+             (!FFlag::LuauUseCommittingTxnLog && get<MetatableTypeVar>(superTy)))
+        tryUnifyWithMetatable(subTy, superTy, /*reversed*/ false);
+    else if ((FFlag::LuauUseCommittingTxnLog && log.getMutable<MetatableTypeVar>(subTy)) ||
+             (!FFlag::LuauUseCommittingTxnLog && get<MetatableTypeVar>(subTy)))
+        tryUnifyWithMetatable(superTy, subTy, /*reversed*/ true);
 
-    else if (get<ClassTypeVar>(superTy))
-        tryUnifyWithClass(superTy, subTy, /*reversed*/ false);
+    else if ((FFlag::LuauUseCommittingTxnLog && log.getMutable<ClassTypeVar>(superTy)) ||
+             (!FFlag::LuauUseCommittingTxnLog && get<ClassTypeVar>(superTy)))
+        tryUnifyWithClass(subTy, superTy, /*reversed*/ false);
 
     // Unification of nonclasses with classes is almost, but not quite symmetrical.
     // The order in which we perform this test is significant in the case that both types are classes.
-    else if (get<ClassTypeVar>(subTy))
-        tryUnifyWithClass(superTy, subTy, /*reversed*/ true);
+    else if ((FFlag::LuauUseCommittingTxnLog && log.getMutable<ClassTypeVar>(subTy)) || (!FFlag::LuauUseCommittingTxnLog && get<ClassTypeVar>(subTy)))
+        tryUnifyWithClass(subTy, superTy, /*reversed*/ true);
 
     else
         errors.push_back(TypeError{location, TypeMismatch{superTy, subTy}});
 
-    log.popSeen(superTy, subTy);
+    if (FFlag::LuauUseCommittingTxnLog)
+        log.popSeen(superTy, subTy);
+    else
+        DEPRECATED_log.popSeen(superTy, subTy);
 }
 
-void Unifier::cacheResult(TypeId superTy, TypeId subTy)
+void Unifier::cacheResult(TypeId subTy, TypeId superTy)
 {
     bool* superTyInfo = sharedState.skipCacheForType.find(superTy);
 
@@ -684,7 +835,7 @@ void Unifier::cacheResult(TypeId superTy, TypeId subTy)
         sharedState.cachedUnify.insert({subTy, superTy});
 }
 
-struct WeirdIter
+struct DEPRECATED_WeirdIter
 {
     TypePackId packId;
     const TypePack* pack;
@@ -692,7 +843,7 @@ struct WeirdIter
     bool growing;
     TypeLevel level;
 
-    WeirdIter(TypePackId packId)
+    DEPRECATED_WeirdIter(TypePackId packId)
         : packId(packId)
         , pack(get<TypePack>(packId))
         , index(0)
@@ -705,7 +856,7 @@ struct WeirdIter
         }
     }
 
-    WeirdIter(const WeirdIter&) = default;
+    DEPRECATED_WeirdIter(const DEPRECATED_WeirdIter&) = default;
 
     const TypeId& operator*()
     {
@@ -756,34 +907,152 @@ struct WeirdIter
     }
 };
 
-ErrorVec Unifier::canUnify(TypeId superTy, TypeId subTy)
+struct WeirdIter
+{
+    TypePackId packId;
+    TxnLog& log;
+    TypePack* pack;
+    size_t index;
+    bool growing;
+    TypeLevel level;
+
+    WeirdIter(TypePackId packId, TxnLog& log)
+        : packId(packId)
+        , log(log)
+        , pack(log.getMutable<TypePack>(packId))
+        , index(0)
+        , growing(false)
+    {
+        while (pack && pack->head.empty() && pack->tail)
+        {
+            packId = *pack->tail;
+            pack = log.getMutable<TypePack>(packId);
+        }
+    }
+
+    WeirdIter(const WeirdIter&) = default;
+
+    TypeId& operator*()
+    {
+        LUAU_ASSERT(good());
+        return pack->head[index];
+    }
+
+    bool good() const
+    {
+        return pack != nullptr && index < pack->head.size();
+    }
+
+    bool advance()
+    {
+        if (!pack)
+            return good();
+
+        if (index < pack->head.size())
+            ++index;
+
+        if (growing || index < pack->head.size())
+            return good();
+
+        if (pack->tail)
+        {
+            packId = log.follow(*pack->tail);
+            pack = log.getMutable<TypePack>(packId);
+            index = 0;
+        }
+
+        return good();
+    }
+
+    bool canGrow() const
+    {
+        return nullptr != log.getMutable<Unifiable::Free>(packId);
+    }
+
+    void grow(TypePackId newTail)
+    {
+        LUAU_ASSERT(canGrow());
+        LUAU_ASSERT(log.getMutable<TypePack>(newTail));
+
+        level = log.getMutable<Unifiable::Free>(packId)->level;
+        log.replace(packId, Unifiable::Bound<TypePackId>(newTail));
+        packId = newTail;
+        pack = log.getMutable<TypePack>(newTail);
+        index = 0;
+        growing = true;
+    }
+
+    void pushType(TypeId ty)
+    {
+        LUAU_ASSERT(pack);
+        PendingTypePack* pendingPack = log.queue(packId);
+        if (TypePack* pending = getMutable<TypePack>(pendingPack))
+        {
+            pending->head.push_back(ty);
+            // We've potentially just replaced the TypePack* that we need to look
+            // in. We need to replace pack.
+            pack = pending;
+        }
+        else
+        {
+            LUAU_ASSERT(!"Pending state for this pack was not a TypePack");
+        }
+    }
+};
+
+ErrorVec Unifier::canUnify(TypeId subTy, TypeId superTy)
 {
     Unifier s = makeChildUnifier();
-    s.tryUnify_(superTy, subTy);
-    s.log.rollback();
+    s.tryUnify_(subTy, superTy);
+
+    if (!FFlag::LuauUseCommittingTxnLog)
+        s.DEPRECATED_log.rollback();
+
     return s.errors;
 }
 
-ErrorVec Unifier::canUnify(TypePackId superTy, TypePackId subTy, bool isFunctionCall)
+ErrorVec Unifier::canUnify(TypePackId subTy, TypePackId superTy, bool isFunctionCall)
 {
     Unifier s = makeChildUnifier();
-    s.tryUnify_(superTy, subTy, isFunctionCall);
-    s.log.rollback();
+    s.tryUnify_(subTy, superTy, isFunctionCall);
+
+    if (!FFlag::LuauUseCommittingTxnLog)
+        s.DEPRECATED_log.rollback();
+
     return s.errors;
 }
 
-void Unifier::tryUnify(TypePackId superTp, TypePackId subTp, bool isFunctionCall)
+void Unifier::tryUnify(TypePackId subTp, TypePackId superTp, bool isFunctionCall)
 {
     sharedState.counters.iterationCount = 0;
 
-    tryUnify_(superTp, subTp, isFunctionCall);
+    tryUnify_(subTp, superTp, isFunctionCall);
+}
+
+static std::pair<std::vector<TypeId>, std::optional<TypePackId>> logAwareFlatten(TypePackId tp, const TxnLog& log)
+{
+    tp = log.follow(tp);
+
+    std::vector<TypeId> flattened;
+    std::optional<TypePackId> tail = std::nullopt;
+
+    TypePackIterator it(tp, &log);
+
+    for (; it != end(tp); ++it)
+    {
+        flattened.push_back(*it);
+    }
+
+    tail = it.tail();
+
+    return {flattened, tail};
 }
 
 /*
  * This is quite tricky: we are walking two rope-like structures and unifying corresponding elements.
  * If one is longer than the other, but the short end is free, we grow it to the required length.
  */
-void Unifier::tryUnify_(TypePackId superTp, TypePackId subTp, bool isFunctionCall)
+void Unifier::tryUnify_(TypePackId subTp, TypePackId superTp, bool isFunctionCall)
 {
     RecursionLimiter _ra(&sharedState.counters.recursionCount, FInt::LuauTypeInferRecursionLimit);
 
@@ -795,252 +1064,458 @@ void Unifier::tryUnify_(TypePackId superTp, TypePackId subTp, bool isFunctionCal
         return;
     }
 
-    superTp = follow(superTp);
-    subTp = follow(subTp);
-
-    while (auto r = get<TypePack>(subTp))
+    if (FFlag::LuauUseCommittingTxnLog)
     {
-        if (r->head.empty() && r->tail)
-            subTp = follow(*r->tail);
-        else
-            break;
-    }
+        superTp = log.follow(superTp);
+        subTp = log.follow(subTp);
 
-    while (auto l = get<TypePack>(superTp))
-    {
-        if (l->head.empty() && l->tail)
-            superTp = follow(*l->tail);
-        else
-            break;
-    }
-
-    if (superTp == subTp)
-        return;
-
-    if (get<Unifiable::Free>(superTp))
-    {
-        occursCheck(superTp, subTp);
-
-        // The occurrence check might have caused superTp no longer to be a free type
-        if (!get<ErrorTypeVar>(superTp))
+        while (auto tp = log.getMutable<TypePack>(subTp))
         {
-            log(superTp);
-            *asMutable(superTp) = Unifiable::Bound<TypePackId>(subTp);
-        }
-    }
-    else if (get<Unifiable::Free>(subTp))
-    {
-        occursCheck(subTp, superTp);
-
-        // The occurrence check might have caused superTp no longer to be a free type
-        if (!get<ErrorTypeVar>(subTp))
-        {
-            log(subTp);
-            *asMutable(subTp) = Unifiable::Bound<TypePackId>(superTp);
-        }
-    }
-
-    else if (get<Unifiable::Error>(superTp))
-        tryUnifyWithAny(superTp, subTp);
-
-    else if (get<Unifiable::Error>(subTp))
-        tryUnifyWithAny(subTp, superTp);
-
-    else if (get<VariadicTypePack>(superTp))
-        tryUnifyVariadics(superTp, subTp, false);
-    else if (get<VariadicTypePack>(subTp))
-        tryUnifyVariadics(subTp, superTp, true);
-
-    else if (get<TypePack>(superTp) && get<TypePack>(subTp))
-    {
-        auto l = get<TypePack>(superTp);
-        auto r = get<TypePack>(subTp);
-
-        // If the size of two heads does not match, but both packs have free tail
-        // We set the sentinel variable to say so to avoid growing it forever.
-        auto [superTypes, superTail] = flatten(superTp);
-        auto [subTypes, subTail] = flatten(subTp);
-
-        bool noInfiniteGrowth =
-            (superTypes.size() != subTypes.size()) && (superTail && get<FreeTypePack>(*superTail)) && (subTail && get<FreeTypePack>(*subTail));
-
-        auto superIter = WeirdIter{superTp};
-        auto subIter = WeirdIter{subTp};
-
-        auto mkFreshType = [this](TypeLevel level) {
-            return types->freshType(level);
-        };
-
-        const TypePackId emptyTp = types->addTypePack(TypePack{{}, std::nullopt});
-
-        int loopCount = 0;
-
-        do
-        {
-            if (FInt::LuauTypeInferTypePackLoopLimit > 0 && loopCount >= FInt::LuauTypeInferTypePackLoopLimit)
-                ice("Detected possibly infinite TypePack growth");
-
-            ++loopCount;
-
-            if (superIter.good() && subIter.growing)
-                asMutable(subIter.pack)->head.push_back(mkFreshType(subIter.level));
-
-            if (subIter.good() && superIter.growing)
-                asMutable(superIter.pack)->head.push_back(mkFreshType(superIter.level));
-
-            if (superIter.good() && subIter.good())
-            {
-                tryUnify_(*superIter, *subIter);
-
-                if (FFlag::LuauExtendedFunctionMismatchError && !errors.empty() && !firstPackErrorPos)
-                    firstPackErrorPos = loopCount;
-
-                superIter.advance();
-                subIter.advance();
-                continue;
-            }
-
-            // If both are at the end, we're done
-            if (!superIter.good() && !subIter.good())
-            {
-                const bool lFreeTail = l->tail && get<FreeTypePack>(follow(*l->tail)) != nullptr;
-                const bool rFreeTail = r->tail && get<FreeTypePack>(follow(*r->tail)) != nullptr;
-                if (lFreeTail && rFreeTail)
-                    tryUnify_(*l->tail, *r->tail);
-                else if (lFreeTail)
-                    tryUnify_(*l->tail, emptyTp);
-                else if (rFreeTail)
-                    tryUnify_(*r->tail, emptyTp);
-
-                break;
-            }
-
-            // If both tails are free, bind one to the other and call it a day
-            if (superIter.canGrow() && subIter.canGrow())
-                return tryUnify_(*superIter.pack->tail, *subIter.pack->tail);
-
-            // If just one side is free on its tail, grow it to fit the other side.
-            // FIXME: The tail-most tail of the growing pack should be the same as the tail-most tail of the non-growing pack.
-            if (superIter.canGrow())
-                superIter.grow(types->addTypePack(TypePackVar(TypePack{})));
-
-            else if (subIter.canGrow())
-                subIter.grow(types->addTypePack(TypePackVar(TypePack{})));
-
+            if (tp->head.empty() && tp->tail)
+                subTp = log.follow(*tp->tail);
             else
+                break;
+        }
+
+        while (auto tp = log.getMutable<TypePack>(superTp))
+        {
+            if (tp->head.empty() && tp->tail)
+                superTp = log.follow(*tp->tail);
+            else
+                break;
+        }
+
+        if (superTp == subTp)
+            return;
+
+        if (log.getMutable<Unifiable::Free>(superTp))
+        {
+            occursCheck(superTp, subTp);
+
+            if (!log.getMutable<ErrorTypeVar>(superTp))
             {
-                // A union type including nil marks an optional argument
-                if (superIter.good() && isOptional(*superIter))
-                {
-                    superIter.advance();
-                    continue;
-                }
-                else if (subIter.good() && isOptional(*subIter))
-                {
-                    subIter.advance();
-                    continue;
-                }
-
-                // In nonstrict mode, any also marks an optional argument.
-                else if (superIter.good() && isNonstrictMode() && get<AnyTypeVar>(follow(*superIter)))
-                {
-                    superIter.advance();
-                    continue;
-                }
-
-                if (get<VariadicTypePack>(superIter.packId))
-                {
-                    tryUnifyVariadics(superIter.packId, subIter.packId, false, int(subIter.index));
-                    return;
-                }
-
-                if (get<VariadicTypePack>(subIter.packId))
-                {
-                    tryUnifyVariadics(subIter.packId, superIter.packId, true, int(superIter.index));
-                    return;
-                }
-
-                if (!isFunctionCall && subIter.good())
-                {
-                    // Sometimes it is ok to pass too many arguments
-                    return;
-                }
-
-                // This is a bit weird because we don't actually know expected vs actual.  We just know
-                // subtype vs supertype.  If we are checking the values returned by a function, we swap
-                // these to produce the expected error message.
-                size_t expectedSize = size(superTp);
-                size_t actualSize = size(subTp);
-                if (ctx == CountMismatch::Result)
-                    std::swap(expectedSize, actualSize);
-                errors.push_back(TypeError{location, CountMismatch{expectedSize, actualSize, ctx}});
-
-                while (superIter.good())
-                {
-                    tryUnify_(getSingletonTypes().errorRecoveryType(), *superIter);
-                    superIter.advance();
-                }
-
-                while (subIter.good())
-                {
-                    tryUnify_(getSingletonTypes().errorRecoveryType(), *subIter);
-                    subIter.advance();
-                }
-
-                return;
+                log.replace(superTp, Unifiable::Bound<TypePackId>(subTp));
             }
+        }
+        else if (log.getMutable<Unifiable::Free>(subTp))
+        {
+            occursCheck(subTp, superTp);
 
-        } while (!noInfiniteGrowth);
+            if (!log.getMutable<ErrorTypeVar>(subTp))
+            {
+                log.replace(subTp, Unifiable::Bound<TypePackId>(superTp));
+            }
+        }
+        else if (log.getMutable<Unifiable::Error>(superTp))
+            tryUnifyWithAny(subTp, superTp);
+        else if (log.getMutable<Unifiable::Error>(subTp))
+            tryUnifyWithAny(superTp, subTp);
+        else if (log.getMutable<VariadicTypePack>(superTp))
+            tryUnifyVariadics(subTp, superTp, false);
+        else if (log.getMutable<VariadicTypePack>(subTp))
+            tryUnifyVariadics(superTp, subTp, true);
+        else if (log.getMutable<TypePack>(superTp) && log.getMutable<TypePack>(subTp))
+        {
+            auto superTpv = log.getMutable<TypePack>(superTp);
+            auto subTpv = log.getMutable<TypePack>(subTp);
+
+            // If the size of two heads does not match, but both packs have free tail
+            // We set the sentinel variable to say so to avoid growing it forever.
+            auto [superTypes, superTail] = logAwareFlatten(superTp, log);
+            auto [subTypes, subTail] = logAwareFlatten(subTp, log);
+
+            bool noInfiniteGrowth =
+                (superTypes.size() != subTypes.size()) && (superTail && get<FreeTypePack>(*superTail)) && (subTail && get<FreeTypePack>(*subTail));
+
+            auto superIter = WeirdIter(superTp, log);
+            auto subIter = WeirdIter(subTp, log);
+
+            auto mkFreshType = [this](TypeLevel level) {
+                return types->freshType(level);
+            };
+
+            const TypePackId emptyTp = types->addTypePack(TypePack{{}, std::nullopt});
+
+            int loopCount = 0;
+
+            do
+            {
+                if (FInt::LuauTypeInferTypePackLoopLimit > 0 && loopCount >= FInt::LuauTypeInferTypePackLoopLimit)
+                    ice("Detected possibly infinite TypePack growth");
+
+                ++loopCount;
+
+                if (superIter.good() && subIter.growing)
+                {
+                    subIter.pushType(mkFreshType(subIter.level));
+                }
+
+                if (subIter.good() && superIter.growing)
+                {
+                    superIter.pushType(mkFreshType(superIter.level));
+                }
+
+                if (superIter.good() && subIter.good())
+                {
+                    tryUnify_(*subIter, *superIter);
+
+                    if (FFlag::LuauExtendedFunctionMismatchError && !errors.empty() && !firstPackErrorPos)
+                        firstPackErrorPos = loopCount;
+
+                    superIter.advance();
+                    subIter.advance();
+                    continue;
+                }
+
+                // If both are at the end, we're done
+                if (!superIter.good() && !subIter.good())
+                {
+                    const bool lFreeTail = superTpv->tail && log.getMutable<FreeTypePack>(log.follow(*superTpv->tail)) != nullptr;
+                    const bool rFreeTail = subTpv->tail && log.getMutable<FreeTypePack>(log.follow(*subTpv->tail)) != nullptr;
+                    if (lFreeTail && rFreeTail)
+                        tryUnify_(*subTpv->tail, *superTpv->tail);
+                    else if (lFreeTail)
+                        tryUnify_(emptyTp, *superTpv->tail);
+                    else if (rFreeTail)
+                        tryUnify_(emptyTp, *subTpv->tail);
+
+                    break;
+                }
+
+                // If both tails are free, bind one to the other and call it a day
+                if (superIter.canGrow() && subIter.canGrow())
+                    return tryUnify_(*subIter.pack->tail, *superIter.pack->tail);
+
+                // If just one side is free on its tail, grow it to fit the other side.
+                // FIXME: The tail-most tail of the growing pack should be the same as the tail-most tail of the non-growing pack.
+                if (superIter.canGrow())
+                    superIter.grow(types->addTypePack(TypePackVar(TypePack{})));
+                else if (subIter.canGrow())
+                    subIter.grow(types->addTypePack(TypePackVar(TypePack{})));
+                else
+                {
+                    // A union type including nil marks an optional argument
+                    if (superIter.good() && isOptional(*superIter))
+                    {
+                        superIter.advance();
+                        continue;
+                    }
+                    else if (subIter.good() && isOptional(*subIter))
+                    {
+                        subIter.advance();
+                        continue;
+                    }
+
+                    // In nonstrict mode, any also marks an optional argument.
+                    else if (superIter.good() && isNonstrictMode() && log.getMutable<AnyTypeVar>(log.follow(*superIter)))
+                    {
+                        superIter.advance();
+                        continue;
+                    }
+
+                    if (log.getMutable<VariadicTypePack>(superIter.packId))
+                    {
+                        tryUnifyVariadics(subIter.packId, superIter.packId, false, int(subIter.index));
+                        return;
+                    }
+
+                    if (log.getMutable<VariadicTypePack>(subIter.packId))
+                    {
+                        tryUnifyVariadics(superIter.packId, subIter.packId, true, int(superIter.index));
+                        return;
+                    }
+
+                    if (!isFunctionCall && subIter.good())
+                    {
+                        // Sometimes it is ok to pass too many arguments
+                        return;
+                    }
+
+                    // This is a bit weird because we don't actually know expected vs actual.  We just know
+                    // subtype vs supertype.  If we are checking the values returned by a function, we swap
+                    // these to produce the expected error message.
+                    size_t expectedSize = size(superTp);
+                    size_t actualSize = size(subTp);
+                    if (ctx == CountMismatch::Result)
+                        std::swap(expectedSize, actualSize);
+                    errors.push_back(TypeError{location, CountMismatch{expectedSize, actualSize, ctx}});
+
+                    while (superIter.good())
+                    {
+                        tryUnify_(*superIter, getSingletonTypes().errorRecoveryType());
+                        superIter.advance();
+                    }
+
+                    while (subIter.good())
+                    {
+                        tryUnify_(*subIter, getSingletonTypes().errorRecoveryType());
+                        subIter.advance();
+                    }
+
+                    return;
+                }
+
+            } while (!noInfiniteGrowth);
+        }
+        else
+        {
+            errors.push_back(TypeError{location, GenericError{"Failed to unify type packs"}});
+        }
     }
     else
     {
-        errors.push_back(TypeError{location, GenericError{"Failed to unify type packs"}});
+        superTp = follow(superTp);
+        subTp = follow(subTp);
+
+        while (auto tp = get<TypePack>(subTp))
+        {
+            if (tp->head.empty() && tp->tail)
+                subTp = follow(*tp->tail);
+            else
+                break;
+        }
+
+        while (auto tp = get<TypePack>(superTp))
+        {
+            if (tp->head.empty() && tp->tail)
+                superTp = follow(*tp->tail);
+            else
+                break;
+        }
+
+        if (superTp == subTp)
+            return;
+
+        if (get<Unifiable::Free>(superTp))
+        {
+            occursCheck(superTp, subTp);
+
+            if (!get<ErrorTypeVar>(superTp))
+            {
+                DEPRECATED_log(superTp);
+                *asMutable(superTp) = Unifiable::Bound<TypePackId>(subTp);
+            }
+        }
+        else if (get<Unifiable::Free>(subTp))
+        {
+            occursCheck(subTp, superTp);
+
+            if (!get<ErrorTypeVar>(subTp))
+            {
+                DEPRECATED_log(subTp);
+                *asMutable(subTp) = Unifiable::Bound<TypePackId>(superTp);
+            }
+        }
+
+        else if (get<Unifiable::Error>(superTp))
+            tryUnifyWithAny(subTp, superTp);
+
+        else if (get<Unifiable::Error>(subTp))
+            tryUnifyWithAny(superTp, subTp);
+
+        else if (get<VariadicTypePack>(superTp))
+            tryUnifyVariadics(subTp, superTp, false);
+        else if (get<VariadicTypePack>(subTp))
+            tryUnifyVariadics(superTp, subTp, true);
+
+        else if (get<TypePack>(superTp) && get<TypePack>(subTp))
+        {
+            auto superTpv = get<TypePack>(superTp);
+            auto subTpv = get<TypePack>(subTp);
+
+            // If the size of two heads does not match, but both packs have free tail
+            // We set the sentinel variable to say so to avoid growing it forever.
+            auto [superTypes, superTail] = flatten(superTp);
+            auto [subTypes, subTail] = flatten(subTp);
+
+            bool noInfiniteGrowth =
+                (superTypes.size() != subTypes.size()) && (superTail && get<FreeTypePack>(*superTail)) && (subTail && get<FreeTypePack>(*subTail));
+
+            auto superIter = DEPRECATED_WeirdIter{superTp};
+            auto subIter = DEPRECATED_WeirdIter{subTp};
+
+            auto mkFreshType = [this](TypeLevel level) {
+                return types->freshType(level);
+            };
+
+            const TypePackId emptyTp = types->addTypePack(TypePack{{}, std::nullopt});
+
+            int loopCount = 0;
+
+            do
+            {
+                if (FInt::LuauTypeInferTypePackLoopLimit > 0 && loopCount >= FInt::LuauTypeInferTypePackLoopLimit)
+                    ice("Detected possibly infinite TypePack growth");
+
+                ++loopCount;
+
+                if (superIter.good() && subIter.growing)
+                    asMutable(subIter.pack)->head.push_back(mkFreshType(subIter.level));
+
+                if (subIter.good() && superIter.growing)
+                    asMutable(superIter.pack)->head.push_back(mkFreshType(superIter.level));
+
+                if (superIter.good() && subIter.good())
+                {
+                    tryUnify_(*subIter, *superIter);
+
+                    if (FFlag::LuauExtendedFunctionMismatchError && !errors.empty() && !firstPackErrorPos)
+                        firstPackErrorPos = loopCount;
+
+                    superIter.advance();
+                    subIter.advance();
+                    continue;
+                }
+
+                // If both are at the end, we're done
+                if (!superIter.good() && !subIter.good())
+                {
+                    const bool lFreeTail = superTpv->tail && get<FreeTypePack>(follow(*superTpv->tail)) != nullptr;
+                    const bool rFreeTail = subTpv->tail && get<FreeTypePack>(follow(*subTpv->tail)) != nullptr;
+                    if (lFreeTail && rFreeTail)
+                        tryUnify_(*subTpv->tail, *superTpv->tail);
+                    else if (lFreeTail)
+                        tryUnify_(emptyTp, *superTpv->tail);
+                    else if (rFreeTail)
+                        tryUnify_(emptyTp, *subTpv->tail);
+
+                    break;
+                }
+
+                // If both tails are free, bind one to the other and call it a day
+                if (superIter.canGrow() && subIter.canGrow())
+                    return tryUnify_(*subIter.pack->tail, *superIter.pack->tail);
+
+                // If just one side is free on its tail, grow it to fit the other side.
+                // FIXME: The tail-most tail of the growing pack should be the same as the tail-most tail of the non-growing pack.
+                if (superIter.canGrow())
+                    superIter.grow(types->addTypePack(TypePackVar(TypePack{})));
+
+                else if (subIter.canGrow())
+                    subIter.grow(types->addTypePack(TypePackVar(TypePack{})));
+
+                else
+                {
+                    // A union type including nil marks an optional argument
+                    if (superIter.good() && isOptional(*superIter))
+                    {
+                        superIter.advance();
+                        continue;
+                    }
+                    else if (subIter.good() && isOptional(*subIter))
+                    {
+                        subIter.advance();
+                        continue;
+                    }
+
+                    // In nonstrict mode, any also marks an optional argument.
+                    else if (superIter.good() && isNonstrictMode() && get<AnyTypeVar>(follow(*superIter)))
+                    {
+                        superIter.advance();
+                        continue;
+                    }
+
+                    if (get<VariadicTypePack>(superIter.packId))
+                    {
+                        tryUnifyVariadics(subIter.packId, superIter.packId, false, int(subIter.index));
+                        return;
+                    }
+
+                    if (get<VariadicTypePack>(subIter.packId))
+                    {
+                        tryUnifyVariadics(superIter.packId, subIter.packId, true, int(superIter.index));
+                        return;
+                    }
+
+                    if (!isFunctionCall && subIter.good())
+                    {
+                        // Sometimes it is ok to pass too many arguments
+                        return;
+                    }
+
+                    // This is a bit weird because we don't actually know expected vs actual.  We just know
+                    // subtype vs supertype.  If we are checking the values returned by a function, we swap
+                    // these to produce the expected error message.
+                    size_t expectedSize = size(superTp);
+                    size_t actualSize = size(subTp);
+                    if (ctx == CountMismatch::Result)
+                        std::swap(expectedSize, actualSize);
+                    errors.push_back(TypeError{location, CountMismatch{expectedSize, actualSize, ctx}});
+
+                    while (superIter.good())
+                    {
+                        tryUnify_(*superIter, getSingletonTypes().errorRecoveryType());
+                        superIter.advance();
+                    }
+
+                    while (subIter.good())
+                    {
+                        tryUnify_(*subIter, getSingletonTypes().errorRecoveryType());
+                        subIter.advance();
+                    }
+
+                    return;
+                }
+
+            } while (!noInfiniteGrowth);
+        }
+        else
+        {
+            errors.push_back(TypeError{location, GenericError{"Failed to unify type packs"}});
+        }
     }
 }
 
-void Unifier::tryUnifyPrimitives(TypeId superTy, TypeId subTy)
+void Unifier::tryUnifyPrimitives(TypeId subTy, TypeId superTy)
 {
-    const PrimitiveTypeVar* lp = get<PrimitiveTypeVar>(superTy);
-    const PrimitiveTypeVar* rp = get<PrimitiveTypeVar>(subTy);
-    if (!lp || !rp)
+    const PrimitiveTypeVar* superPrim = get<PrimitiveTypeVar>(superTy);
+    const PrimitiveTypeVar* subPrim = get<PrimitiveTypeVar>(subTy);
+    if (!superPrim || !subPrim)
         ice("passed non primitive types to unifyPrimitives");
 
-    if (lp->type != rp->type)
+    if (superPrim->type != subPrim->type)
         errors.push_back(TypeError{location, TypeMismatch{superTy, subTy}});
 }
 
-void Unifier::tryUnifySingletons(TypeId superTy, TypeId subTy)
+void Unifier::tryUnifySingletons(TypeId subTy, TypeId superTy)
 {
-    const PrimitiveTypeVar* lp = get<PrimitiveTypeVar>(superTy);
-    const SingletonTypeVar* ls = get<SingletonTypeVar>(superTy);
-    const SingletonTypeVar* rs = get<SingletonTypeVar>(subTy);
+    const PrimitiveTypeVar* superPrim = get<PrimitiveTypeVar>(superTy);
+    const SingletonTypeVar* superSingleton = get<SingletonTypeVar>(superTy);
+    const SingletonTypeVar* subSingleton = get<SingletonTypeVar>(subTy);
 
-    if ((!lp && !ls) || !rs)
+    if ((!superPrim && !superSingleton) || !subSingleton)
         ice("passed non singleton/primitive types to unifySingletons");
 
-    if (ls && *ls == *rs)
+    if (superSingleton && *superSingleton == *subSingleton)
         return;
 
-    if (lp && lp->type == PrimitiveTypeVar::Boolean && get<BoolSingleton>(rs) && variance == Covariant)
+    if (superPrim && superPrim->type == PrimitiveTypeVar::Boolean && get<BoolSingleton>(subSingleton) && variance == Covariant)
         return;
 
-    if (lp && lp->type == PrimitiveTypeVar::String && get<StringSingleton>(rs) && variance == Covariant)
+    if (superPrim && superPrim->type == PrimitiveTypeVar::String && get<StringSingleton>(subSingleton) && variance == Covariant)
         return;
 
     errors.push_back(TypeError{location, TypeMismatch{superTy, subTy}});
 }
 
-void Unifier::tryUnifyFunctions(TypeId superTy, TypeId subTy, bool isFunctionCall)
+void Unifier::tryUnifyFunctions(TypeId subTy, TypeId superTy, bool isFunctionCall)
 {
-    FunctionTypeVar* lf = getMutable<FunctionTypeVar>(superTy);
-    FunctionTypeVar* rf = getMutable<FunctionTypeVar>(subTy);
-    if (!lf || !rf)
+    FunctionTypeVar* superFunction = getMutable<FunctionTypeVar>(superTy);
+    FunctionTypeVar* subFunction = getMutable<FunctionTypeVar>(subTy);
+
+    if (FFlag::LuauUseCommittingTxnLog)
+    {
+        superFunction = log.getMutable<FunctionTypeVar>(superTy);
+        subFunction = log.getMutable<FunctionTypeVar>(subTy);
+    }
+
+    if (!superFunction || !subFunction)
         ice("passed non-function types to unifyFunction");
 
-    size_t numGenerics = lf->generics.size();
-    if (numGenerics != rf->generics.size())
+    size_t numGenerics = superFunction->generics.size();
+    if (numGenerics != subFunction->generics.size())
     {
-        numGenerics = std::min(lf->generics.size(), rf->generics.size());
+        numGenerics = std::min(superFunction->generics.size(), subFunction->generics.size());
 
         if (FFlag::LuauExtendedFunctionMismatchError)
             errors.push_back(TypeError{location, TypeMismatch{superTy, subTy, "different number of generic type parameters"}});
@@ -1048,10 +1523,10 @@ void Unifier::tryUnifyFunctions(TypeId superTy, TypeId subTy, bool isFunctionCal
             errors.push_back(TypeError{location, TypeMismatch{superTy, subTy}});
     }
 
-    size_t numGenericPacks = lf->genericPacks.size();
-    if (numGenericPacks != rf->genericPacks.size())
+    size_t numGenericPacks = superFunction->genericPacks.size();
+    if (numGenericPacks != subFunction->genericPacks.size())
     {
-        numGenericPacks = std::min(lf->genericPacks.size(), rf->genericPacks.size());
+        numGenericPacks = std::min(superFunction->genericPacks.size(), subFunction->genericPacks.size());
 
         if (FFlag::LuauExtendedFunctionMismatchError)
             errors.push_back(TypeError{location, TypeMismatch{superTy, subTy, "different number of generic type pack parameters"}});
@@ -1060,7 +1535,12 @@ void Unifier::tryUnifyFunctions(TypeId superTy, TypeId subTy, bool isFunctionCal
     }
 
     for (size_t i = 0; i < numGenerics; i++)
-        log.pushSeen(lf->generics[i], rf->generics[i]);
+    {
+        if (FFlag::LuauUseCommittingTxnLog)
+            log.pushSeen(superFunction->generics[i], subFunction->generics[i]);
+        else
+            DEPRECATED_log.pushSeen(superFunction->generics[i], subFunction->generics[i]);
+    }
 
     CountMismatch::Context context = ctx;
 
@@ -1071,7 +1551,7 @@ void Unifier::tryUnifyFunctions(TypeId superTy, TypeId subTy, bool isFunctionCal
         if (FFlag::LuauExtendedFunctionMismatchError)
         {
             innerState.ctx = CountMismatch::Arg;
-            innerState.tryUnify_(rf->argTypes, lf->argTypes, isFunctionCall);
+            innerState.tryUnify_(superFunction->argTypes, subFunction->argTypes, isFunctionCall);
 
             bool reported = !innerState.errors.empty();
 
@@ -1085,13 +1565,13 @@ void Unifier::tryUnifyFunctions(TypeId superTy, TypeId subTy, bool isFunctionCal
                 errors.push_back(TypeError{location, TypeMismatch{superTy, subTy, "", innerState.errors.front()}});
 
             innerState.ctx = CountMismatch::Result;
-            innerState.tryUnify_(lf->retType, rf->retType);
+            innerState.tryUnify_(subFunction->retType, superFunction->retType);
 
             if (!reported)
             {
                 if (auto e = hasUnificationTooComplex(innerState.errors))
                     errors.push_back(*e);
-                else if (!innerState.errors.empty() && size(lf->retType) == 1 && finite(lf->retType))
+                else if (!innerState.errors.empty() && size(superFunction->retType) == 1 && finite(superFunction->retType))
                     errors.push_back(TypeError{location, TypeMismatch{superTy, subTy, "Return type is not compatible.", innerState.errors.front()}});
                 else if (!innerState.errors.empty() && innerState.firstPackErrorPos)
                     errors.push_back(
@@ -1104,38 +1584,70 @@ void Unifier::tryUnifyFunctions(TypeId superTy, TypeId subTy, bool isFunctionCal
         else
         {
             ctx = CountMismatch::Arg;
-            innerState.tryUnify_(rf->argTypes, lf->argTypes, isFunctionCall);
+            innerState.tryUnify_(superFunction->argTypes, subFunction->argTypes, isFunctionCall);
 
             ctx = CountMismatch::Result;
-            innerState.tryUnify_(lf->retType, rf->retType);
+            innerState.tryUnify_(subFunction->retType, superFunction->retType);
 
             checkChildUnifierTypeMismatch(innerState.errors, superTy, subTy);
         }
 
-        log.concat(std::move(innerState.log));
+        if (FFlag::LuauUseCommittingTxnLog)
+        {
+            log.concat(std::move(innerState.log));
+        }
+        else
+        {
+            DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
+        }
     }
     else
     {
         ctx = CountMismatch::Arg;
-        tryUnify_(rf->argTypes, lf->argTypes, isFunctionCall);
+        tryUnify_(superFunction->argTypes, subFunction->argTypes, isFunctionCall);
 
         ctx = CountMismatch::Result;
-        tryUnify_(lf->retType, rf->retType);
+        tryUnify_(subFunction->retType, superFunction->retType);
     }
 
-    if (lf->definition && !rf->definition && !subTy->persistent)
+    if (FFlag::LuauUseCommittingTxnLog)
     {
-        rf->definition = lf->definition;
+        if (superFunction->definition && !subFunction->definition && !subTy->persistent)
+        {
+            PendingType* newSubTy = log.queue(subTy);
+            FunctionTypeVar* newSubFtv = getMutable<FunctionTypeVar>(newSubTy);
+            LUAU_ASSERT(newSubFtv);
+            newSubFtv->definition = superFunction->definition;
+        }
+        else if (!superFunction->definition && subFunction->definition && !superTy->persistent)
+        {
+            PendingType* newSuperTy = log.queue(superTy);
+            FunctionTypeVar* newSuperFtv = getMutable<FunctionTypeVar>(newSuperTy);
+            LUAU_ASSERT(newSuperFtv);
+            newSuperFtv->definition = subFunction->definition;
+        }
     }
-    else if (!lf->definition && rf->definition && !superTy->persistent)
+    else
     {
-        lf->definition = rf->definition;
+        if (superFunction->definition && !subFunction->definition && !subTy->persistent)
+        {
+            subFunction->definition = superFunction->definition;
+        }
+        else if (!superFunction->definition && subFunction->definition && !superTy->persistent)
+        {
+            superFunction->definition = subFunction->definition;
+        }
     }
 
     ctx = context;
 
     for (int i = int(numGenerics) - 1; 0 <= i; i--)
-        log.popSeen(lf->generics[i], rf->generics[i]);
+    {
+        if (FFlag::LuauUseCommittingTxnLog)
+            log.popSeen(superFunction->generics[i], subFunction->generics[i]);
+        else
+            DEPRECATED_log.popSeen(superFunction->generics[i], subFunction->generics[i]);
+    }
 }
 
 namespace
@@ -1160,77 +1672,84 @@ struct Resetter
 
 } // namespace
 
-void Unifier::tryUnifyTables(TypeId left, TypeId right, bool isIntersection)
+void Unifier::tryUnifyTables(TypeId subTy, TypeId superTy, bool isIntersection)
 {
     if (!FFlag::LuauTableSubtypingVariance2)
-        return DEPRECATED_tryUnifyTables(left, right, isIntersection);
+        return DEPRECATED_tryUnifyTables(subTy, superTy, isIntersection);
 
-    TableTypeVar* lt = getMutable<TableTypeVar>(left);
-    TableTypeVar* rt = getMutable<TableTypeVar>(right);
-    if (!lt || !rt)
+    TableTypeVar* superTable = getMutable<TableTypeVar>(superTy);
+    TableTypeVar* subTable = getMutable<TableTypeVar>(subTy);
+    if (!superTable || !subTable)
         ice("passed non-table types to unifyTables");
 
     std::vector<std::string> missingProperties;
     std::vector<std::string> extraProperties;
 
     // Optimization: First test that the property sets are compatible without doing any recursive unification
-    if (FFlag::LuauTableUnificationEarlyTest && !rt->indexer && rt->state != TableState::Free)
+    if (FFlag::LuauTableUnificationEarlyTest && !subTable->indexer && subTable->state != TableState::Free)
     {
-        for (const auto& [propName, superProp] : lt->props)
+        for (const auto& [propName, superProp] : superTable->props)
         {
-            auto subIter = rt->props.find(propName);
-            if (subIter == rt->props.end() && !isOptional(superProp.type) && !get<AnyTypeVar>(follow(superProp.type)))
+            auto subIter = subTable->props.find(propName);
+            if (subIter == subTable->props.end() && !isOptional(superProp.type) && !get<AnyTypeVar>(follow(superProp.type)))
                 missingProperties.push_back(propName);
         }
 
         if (!missingProperties.empty())
         {
-            errors.push_back(TypeError{location, MissingProperties{left, right, std::move(missingProperties)}});
+            errors.push_back(TypeError{location, MissingProperties{superTy, subTy, std::move(missingProperties)}});
             return;
         }
     }
 
     // And vice versa if we're invariant
-    if (FFlag::LuauTableUnificationEarlyTest && variance == Invariant && !lt->indexer && lt->state != TableState::Unsealed &&
-        lt->state != TableState::Free)
+    if (FFlag::LuauTableUnificationEarlyTest && variance == Invariant && !superTable->indexer && superTable->state != TableState::Unsealed &&
+        superTable->state != TableState::Free)
     {
-        for (const auto& [propName, subProp] : rt->props)
+        for (const auto& [propName, subProp] : subTable->props)
         {
-            auto superIter = lt->props.find(propName);
-            if (superIter == lt->props.end() && !isOptional(subProp.type) && !get<AnyTypeVar>(follow(subProp.type)))
+            auto superIter = superTable->props.find(propName);
+            if (superIter == superTable->props.end() && !isOptional(subProp.type) && !get<AnyTypeVar>(follow(subProp.type)))
                 extraProperties.push_back(propName);
         }
 
         if (!extraProperties.empty())
         {
-            errors.push_back(TypeError{location, MissingProperties{left, right, std::move(extraProperties), MissingProperties::Extra}});
+            errors.push_back(TypeError{location, MissingProperties{superTy, subTy, std::move(extraProperties), MissingProperties::Extra}});
             return;
         }
     }
 
-    // Reminder: left is the supertype, right is the subtype.
     // Width subtyping: any property in the supertype must be in the subtype,
     // and the types must agree.
-    for (const auto& [name, prop] : lt->props)
+    for (const auto& [name, prop] : superTable->props)
     {
-        const auto& r = rt->props.find(name);
-        if (r != rt->props.end())
+        const auto& r = subTable->props.find(name);
+        if (r != subTable->props.end())
         {
             // TODO: read-only properties don't need invariance
             Resetter resetter{&variance};
             variance = Invariant;
 
             Unifier innerState = makeChildUnifier();
-            innerState.tryUnify_(prop.type, r->second.type);
+            innerState.tryUnify_(r->second.type, prop.type);
 
-            checkChildUnifierTypeMismatch(innerState.errors, name, left, right);
+            checkChildUnifierTypeMismatch(innerState.errors, name, superTy, subTy);
 
-            if (innerState.errors.empty())
-                log.concat(std::move(innerState.log));
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                if (innerState.errors.empty())
+                    log.concat(std::move(innerState.log));
+            }
             else
-                innerState.log.rollback();
+            {
+                if (innerState.errors.empty())
+                    DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
+                else
+                    innerState.DEPRECATED_log.rollback();
+            }
         }
-        else if (rt->indexer && isString(rt->indexer->indexType))
+        else if (subTable->indexer && isString(subTable->indexer->indexType))
         {
             // TODO: read-only indexers don't need invariance
             // TODO: really we should only allow this if prop.type is optional.
@@ -1238,37 +1757,55 @@ void Unifier::tryUnifyTables(TypeId left, TypeId right, bool isIntersection)
             variance = Invariant;
 
             Unifier innerState = makeChildUnifier();
-            innerState.tryUnify_(prop.type, rt->indexer->indexResultType);
+            innerState.tryUnify_(subTable->indexer->indexResultType, prop.type);
 
-            checkChildUnifierTypeMismatch(innerState.errors, name, left, right);
+            checkChildUnifierTypeMismatch(innerState.errors, name, superTy, subTy);
 
-            if (innerState.errors.empty())
-                log.concat(std::move(innerState.log));
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                if (innerState.errors.empty())
+                    log.concat(std::move(innerState.log));
+            }
             else
-                innerState.log.rollback();
+            {
+                if (innerState.errors.empty())
+                    DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
+                else
+                    innerState.DEPRECATED_log.rollback();
+            }
         }
         else if (isOptional(prop.type) || get<AnyTypeVar>(follow(prop.type)))
         // TODO: this case is unsound, but without it our test suite fails. CLI-46031
         // TODO: should isOptional(anyType) be true?
         {
         }
-        else if (rt->state == TableState::Free)
+        else if (subTable->state == TableState::Free)
         {
-            log(rt);
-            rt->props[name] = prop;
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                PendingType* pendingSub = log.queue(subTy);
+                TableTypeVar* ttv = getMutable<TableTypeVar>(pendingSub);
+                LUAU_ASSERT(ttv);
+                ttv->props[name] = prop;
+            }
+            else
+            {
+                DEPRECATED_log(subTy);
+                subTable->props[name] = prop;
+            }
         }
         else
             missingProperties.push_back(name);
     }
 
-    for (const auto& [name, prop] : rt->props)
+    for (const auto& [name, prop] : subTable->props)
     {
-        if (lt->props.count(name))
+        if (superTable->props.count(name))
         {
             // If both lt and rt contain the property, then
             // we're done since we already unified them above
         }
-        else if (lt->indexer && isString(lt->indexer->indexType))
+        else if (superTable->indexer && isString(superTable->indexer->indexType))
         {
             // TODO: read-only indexers don't need invariance
             // TODO: really we should only allow this if prop.type is optional.
@@ -1276,24 +1813,42 @@ void Unifier::tryUnifyTables(TypeId left, TypeId right, bool isIntersection)
             variance = Invariant;
 
             Unifier innerState = makeChildUnifier();
-            innerState.tryUnify_(prop.type, lt->indexer->indexResultType);
+            innerState.tryUnify_(superTable->indexer->indexResultType, prop.type);
 
-            checkChildUnifierTypeMismatch(innerState.errors, name, left, right);
+            checkChildUnifierTypeMismatch(innerState.errors, name, superTy, subTy);
 
-            if (innerState.errors.empty())
-                log.concat(std::move(innerState.log));
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                if (innerState.errors.empty())
+                    log.concat(std::move(innerState.log));
+            }
             else
-                innerState.log.rollback();
+            {
+                if (innerState.errors.empty())
+                    DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
+                else
+                    innerState.DEPRECATED_log.rollback();
+            }
         }
-        else if (lt->state == TableState::Unsealed)
+        else if (superTable->state == TableState::Unsealed)
         {
             // TODO: this case is unsound when variance is Invariant, but without it lua-apps fails to typecheck.
             // TODO: file a JIRA
             // TODO: hopefully readonly/writeonly properties will fix this.
             Property clone = prop;
             clone.type = deeplyOptional(clone.type);
-            log(left);
-            lt->props[name] = clone;
+
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                PendingType* pendingSuper = log.queue(superTy);
+                TableTypeVar* pendingSuperTtv = getMutable<TableTypeVar>(pendingSuper);
+                pendingSuperTtv->props[name] = clone;
+            }
+            else
+            {
+                DEPRECATED_log(superTy);
+                superTable->props[name] = clone;
+            }
         }
         else if (variance == Covariant)
         {
@@ -1303,61 +1858,93 @@ void Unifier::tryUnifyTables(TypeId left, TypeId right, bool isIntersection)
         // TODO: should isOptional(anyType) be true?
         {
         }
-        else if (lt->state == TableState::Free)
+        else if (superTable->state == TableState::Free)
         {
-            log(left);
-            lt->props[name] = prop;
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                PendingType* pendingSuper = log.queue(superTy);
+                TableTypeVar* pendingSuperTtv = getMutable<TableTypeVar>(pendingSuper);
+                pendingSuperTtv->props[name] = prop;
+            }
+            else
+            {
+                DEPRECATED_log(superTy);
+                superTable->props[name] = prop;
+            }
         }
         else
             extraProperties.push_back(name);
     }
 
     // Unify indexers
-    if (lt->indexer && rt->indexer)
+    if (superTable->indexer && subTable->indexer)
     {
         // TODO: read-only indexers don't need invariance
         Resetter resetter{&variance};
         variance = Invariant;
 
         Unifier innerState = makeChildUnifier();
-        innerState.tryUnify(*lt->indexer, *rt->indexer);
-        checkChildUnifierTypeMismatch(innerState.errors, left, right);
-        if (innerState.errors.empty())
-            log.concat(std::move(innerState.log));
+        innerState.tryUnifyIndexer(*subTable->indexer, *superTable->indexer);
+        checkChildUnifierTypeMismatch(innerState.errors, superTy, subTy);
+
+        if (FFlag::LuauUseCommittingTxnLog)
+        {
+            if (innerState.errors.empty())
+                log.concat(std::move(innerState.log));
+        }
         else
-            innerState.log.rollback();
+        {
+            if (innerState.errors.empty())
+                DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
+            else
+                innerState.DEPRECATED_log.rollback();
+        }
     }
-    else if (lt->indexer)
+    else if (superTable->indexer)
     {
-        if (rt->state == TableState::Unsealed || rt->state == TableState::Free)
+        if (subTable->state == TableState::Unsealed || subTable->state == TableState::Free)
         {
             // passing/assigning a table without an indexer to something that has one
             // e.g. table.insert(t, 1) where t is a non-sealed table and doesn't have an indexer.
             // TODO: we only need to do this if the supertype's indexer is read/write
             // since that can add indexed elements.
-            log(right);
-            rt->indexer = lt->indexer;
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                log.changeIndexer(subTy, superTable->indexer);
+            }
+            else
+            {
+                DEPRECATED_log(subTy);
+                subTable->indexer = superTable->indexer;
+            }
         }
     }
-    else if (rt->indexer && variance == Invariant)
+    else if (subTable->indexer && variance == Invariant)
     {
         // Symmetric if we are invariant
-        if (lt->state == TableState::Unsealed || lt->state == TableState::Free)
+        if (superTable->state == TableState::Unsealed || superTable->state == TableState::Free)
         {
-            log(left);
-            lt->indexer = rt->indexer;
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                log.changeIndexer(superTy, subTable->indexer);
+            }
+            else
+            {
+                DEPRECATED_log(superTy);
+                superTable->indexer = subTable->indexer;
+            }
         }
     }
 
     if (!missingProperties.empty())
     {
-        errors.push_back(TypeError{location, MissingProperties{left, right, std::move(missingProperties)}});
+        errors.push_back(TypeError{location, MissingProperties{superTy, subTy, std::move(missingProperties)}});
         return;
     }
 
     if (!extraProperties.empty())
     {
-        errors.push_back(TypeError{location, MissingProperties{left, right, std::move(extraProperties), MissingProperties::Extra}});
+        errors.push_back(TypeError{location, MissingProperties{superTy, subTy, std::move(extraProperties), MissingProperties::Extra}});
         return;
     }
 
@@ -1369,18 +1956,32 @@ void Unifier::tryUnifyTables(TypeId left, TypeId right, bool isIntersection)
      * I believe this is guaranteed to terminate eventually because this will
      * only happen when a free table is bound to another table.
      */
-    if (lt->boundTo || rt->boundTo)
-        return tryUnify_(left, right);
+    if (superTable->boundTo || subTable->boundTo)
+        return tryUnify_(subTy, superTy);
 
-    if (lt->state == TableState::Free)
+    if (superTable->state == TableState::Free)
     {
-        log(lt);
-        lt->boundTo = right;
+        if (FFlag::LuauUseCommittingTxnLog)
+        {
+            log.bindTable(superTy, subTy);
+        }
+        else
+        {
+            DEPRECATED_log(superTable);
+            superTable->boundTo = subTy;
+        }
     }
-    else if (rt->state == TableState::Free)
+    else if (subTable->state == TableState::Free)
     {
-        log(rt);
-        rt->boundTo = left;
+        if (FFlag::LuauUseCommittingTxnLog)
+        {
+            log.bindTable(subTy, superTy);
+        }
+        else
+        {
+            DEPRECATED_log(subTy);
+            subTable->boundTo = superTy;
+        }
     }
 }
 
@@ -1406,99 +2007,129 @@ TypeId Unifier::deeplyOptional(TypeId ty, std::unordered_map<TypeId, TypeId> see
         return types->addType(UnionTypeVar{{getSingletonTypes().nilType, ty}});
 }
 
-void Unifier::DEPRECATED_tryUnifyTables(TypeId left, TypeId right, bool isIntersection)
+void Unifier::DEPRECATED_tryUnifyTables(TypeId subTy, TypeId superTy, bool isIntersection)
 {
     LUAU_ASSERT(!FFlag::LuauTableSubtypingVariance2);
     Resetter resetter{&variance};
     variance = Invariant;
 
-    TableTypeVar* lt = getMutable<TableTypeVar>(left);
-    TableTypeVar* rt = getMutable<TableTypeVar>(right);
-    if (!lt || !rt)
+    TableTypeVar* superTable = getMutable<TableTypeVar>(superTy);
+    TableTypeVar* subTable = getMutable<TableTypeVar>(subTy);
+
+    if (FFlag::LuauUseCommittingTxnLog)
+    {
+        superTable = log.getMutable<TableTypeVar>(superTy);
+        subTable = log.getMutable<TableTypeVar>(subTy);
+    }
+
+    if (!superTable || !subTable)
         ice("passed non-table types to unifyTables");
 
-    if (lt->state == TableState::Sealed && rt->state == TableState::Sealed)
-        return tryUnifySealedTables(left, right, isIntersection);
-    else if ((lt->state == TableState::Sealed && rt->state == TableState::Unsealed) ||
-             (lt->state == TableState::Unsealed && rt->state == TableState::Sealed))
-        return tryUnifySealedTables(left, right, isIntersection);
-    else if ((lt->state == TableState::Sealed && rt->state == TableState::Generic) ||
-             (lt->state == TableState::Generic && rt->state == TableState::Sealed))
-        errors.push_back(TypeError{location, TypeMismatch{left, right}});
-    else if ((lt->state == TableState::Free) != (rt->state == TableState::Free)) // one table is free and the other is not
+    if (superTable->state == TableState::Sealed && subTable->state == TableState::Sealed)
+        return tryUnifySealedTables(subTy, superTy, isIntersection);
+    else if ((superTable->state == TableState::Sealed && subTable->state == TableState::Unsealed) ||
+             (superTable->state == TableState::Unsealed && subTable->state == TableState::Sealed))
+        return tryUnifySealedTables(subTy, superTy, isIntersection);
+    else if ((superTable->state == TableState::Sealed && subTable->state == TableState::Generic) ||
+             (superTable->state == TableState::Generic && subTable->state == TableState::Sealed))
+        errors.push_back(TypeError{location, TypeMismatch{superTy, subTy}});
+    else if ((superTable->state == TableState::Free) != (subTable->state == TableState::Free)) // one table is free and the other is not
     {
-        TypeId freeTypeId = rt->state == TableState::Free ? right : left;
-        TypeId otherTypeId = rt->state == TableState::Free ? left : right;
+        TypeId freeTypeId = subTable->state == TableState::Free ? subTy : superTy;
+        TypeId otherTypeId = subTable->state == TableState::Free ? superTy : subTy;
 
-        return tryUnifyFreeTable(freeTypeId, otherTypeId);
+        return tryUnifyFreeTable(otherTypeId, freeTypeId);
     }
-    else if (lt->state == TableState::Free && rt->state == TableState::Free)
+    else if (superTable->state == TableState::Free && subTable->state == TableState::Free)
     {
-        tryUnifyFreeTable(left, right);
+        tryUnifyFreeTable(subTy, superTy);
 
         // avoid creating a cycle when the types are already pointing at each other
-        if (follow(left) != follow(right))
+        if (follow(superTy) != follow(subTy))
         {
-            log(lt);
-            lt->boundTo = right;
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                log.bindTable(superTy, subTy);
+            }
+            else
+            {
+                DEPRECATED_log(superTable);
+                superTable->boundTo = subTy;
+            }
         }
         return;
     }
-    else if (lt->state != TableState::Sealed && rt->state != TableState::Sealed)
+    else if (superTable->state != TableState::Sealed && subTable->state != TableState::Sealed)
     {
         // All free tables are checked in one of the branches above
-        LUAU_ASSERT(lt->state != TableState::Free);
-        LUAU_ASSERT(rt->state != TableState::Free);
+        LUAU_ASSERT(superTable->state != TableState::Free);
+        LUAU_ASSERT(subTable->state != TableState::Free);
 
         // Tables must have exactly the same props and their types must all unify
         // I honestly have no idea if this is remotely close to reasonable.
-        for (const auto& [name, prop] : lt->props)
+        for (const auto& [name, prop] : superTable->props)
         {
-            const auto& r = rt->props.find(name);
-            if (r == rt->props.end())
-                errors.push_back(TypeError{location, UnknownProperty{right, name}});
+            const auto& r = subTable->props.find(name);
+            if (r == subTable->props.end())
+                errors.push_back(TypeError{location, UnknownProperty{subTy, name}});
             else
-                tryUnify_(prop.type, r->second.type);
+                tryUnify_(r->second.type, prop.type);
         }
 
-        if (lt->indexer && rt->indexer)
-            tryUnify(*lt->indexer, *rt->indexer);
-        else if (lt->indexer)
+        if (superTable->indexer && subTable->indexer)
+            tryUnifyIndexer(*subTable->indexer, *superTable->indexer);
+        else if (superTable->indexer)
         {
             // passing/assigning a table without an indexer to something that has one
             // e.g. table.insert(t, 1) where t is a non-sealed table and doesn't have an indexer.
-            if (rt->state == TableState::Unsealed)
-                rt->indexer = lt->indexer;
+            if (subTable->state == TableState::Unsealed)
+            {
+                if (FFlag::LuauUseCommittingTxnLog)
+                {
+                    log.changeIndexer(subTy, superTable->indexer);
+                }
+                else
+                {
+                    subTable->indexer = superTable->indexer;
+                }
+            }
             else
-                errors.push_back(TypeError{location, CannotExtendTable{right, CannotExtendTable::Indexer}});
+                errors.push_back(TypeError{location, CannotExtendTable{subTy, CannotExtendTable::Indexer}});
         }
     }
-    else if (lt->state == TableState::Sealed)
+    else if (superTable->state == TableState::Sealed)
     {
         // lt is sealed and so it must be possible for rt to have precisely the same shape
         // Verify that this is the case, then bind rt to lt.
         ice("unsealed tables are not working yet", location);
     }
-    else if (rt->state == TableState::Sealed)
-        return tryUnifyTables(right, left, isIntersection);
+    else if (subTable->state == TableState::Sealed)
+        return tryUnifyTables(superTy, subTy, isIntersection);
     else
         ice("tryUnifyTables");
 }
 
-void Unifier::tryUnifyFreeTable(TypeId freeTypeId, TypeId otherTypeId)
+void Unifier::tryUnifyFreeTable(TypeId subTy, TypeId superTy)
 {
-    TableTypeVar* freeTable = getMutable<TableTypeVar>(freeTypeId);
-    TableTypeVar* otherTable = getMutable<TableTypeVar>(otherTypeId);
-    if (!freeTable || !otherTable)
+    TableTypeVar* freeTable = getMutable<TableTypeVar>(superTy);
+    TableTypeVar* subTable = getMutable<TableTypeVar>(subTy);
+
+    if (FFlag::LuauUseCommittingTxnLog)
+    {
+        freeTable = log.getMutable<TableTypeVar>(superTy);
+        subTable = log.getMutable<TableTypeVar>(subTy);
+    }
+
+    if (!freeTable || !subTable)
         ice("passed non-table types to tryUnifyFreeTable");
 
     // Any properties in freeTable must unify with those in otherTable.
     // Then bind freeTable to otherTable.
     for (const auto& [freeName, freeProp] : freeTable->props)
     {
-        if (auto otherProp = findTablePropertyRespectingMeta(otherTypeId, freeName))
+        if (auto subProp = findTablePropertyRespectingMeta(subTy, freeName))
         {
-            tryUnify_(*otherProp, freeProp.type);
+            tryUnify_(freeProp.type, *subProp);
 
             /*
              * TypeVars are commonly cyclic, so it is entirely possible
@@ -1508,84 +2139,133 @@ void Unifier::tryUnifyFreeTable(TypeId freeTypeId, TypeId otherTypeId)
              * I believe this is guaranteed to terminate eventually because this will
              * only happen when a free table is bound to another table.
              */
-            if (!get<TableTypeVar>(freeTypeId) || !get<TableTypeVar>(otherTypeId))
-                return tryUnify_(freeTypeId, otherTypeId);
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                if (!log.getMutable<TableTypeVar>(superTy) || !log.getMutable<TableTypeVar>(subTy))
+                    return tryUnify_(subTy, superTy);
 
-            if (freeTable->boundTo)
-                return tryUnify_(freeTypeId, otherTypeId);
+                if (TableTypeVar* pendingFreeTtv = log.getMutable<TableTypeVar>(superTy); pendingFreeTtv && pendingFreeTtv->boundTo)
+                    return tryUnify_(subTy, superTy);
+            }
+            else
+            {
+                if (!get<TableTypeVar>(superTy) || !get<TableTypeVar>(subTy))
+                    return tryUnify_(subTy, superTy);
+
+                if (freeTable->boundTo)
+                    return tryUnify_(subTy, superTy);
+            }
         }
         else
         {
             // If the other table is also free, then we are learning that it has more
             // properties than we previously thought.  Else, it is an error.
-            if (otherTable->state == TableState::Free)
-                otherTable->props.insert({freeName, freeProp});
+            if (subTable->state == TableState::Free)
+            {
+                if (FFlag::LuauUseCommittingTxnLog)
+                {
+                    PendingType* pendingSub = log.queue(subTy);
+                    TableTypeVar* pendingSubTtv = getMutable<TableTypeVar>(pendingSub);
+                    LUAU_ASSERT(pendingSubTtv);
+                    pendingSubTtv->props.insert({freeName, freeProp});
+                }
+                else
+                {
+                    subTable->props.insert({freeName, freeProp});
+                }
+            }
             else
-                errors.push_back(TypeError{location, UnknownProperty{otherTypeId, freeName}});
+                errors.push_back(TypeError{location, UnknownProperty{subTy, freeName}});
         }
     }
 
-    if (freeTable->indexer && otherTable->indexer)
+    if (freeTable->indexer && subTable->indexer)
     {
         Unifier innerState = makeChildUnifier();
-        innerState.tryUnify(*freeTable->indexer, *otherTable->indexer);
+        innerState.tryUnifyIndexer(*subTable->indexer, *freeTable->indexer);
 
-        checkChildUnifierTypeMismatch(innerState.errors, freeTypeId, otherTypeId);
+        checkChildUnifierTypeMismatch(innerState.errors, superTy, subTy);
 
-        log.concat(std::move(innerState.log));
+        if (FFlag::LuauUseCommittingTxnLog)
+            log.concat(std::move(innerState.log));
+        else
+            DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
     }
-    else if (otherTable->state == TableState::Free && freeTable->indexer)
-        freeTable->indexer = otherTable->indexer;
-
-    if (!freeTable->boundTo && otherTable->state != TableState::Free)
+    else if (subTable->state == TableState::Free && freeTable->indexer)
     {
-        log(freeTable);
-        freeTable->boundTo = otherTypeId;
+        if (FFlag::LuauUseCommittingTxnLog)
+        {
+            log.changeIndexer(superTy, subTable->indexer);
+        }
+        else
+        {
+            freeTable->indexer = subTable->indexer;
+        }
+    }
+
+    if (!freeTable->boundTo && subTable->state != TableState::Free)
+    {
+        if (FFlag::LuauUseCommittingTxnLog)
+        {
+            log.bindTable(superTy, subTy);
+        }
+        else
+        {
+            DEPRECATED_log(freeTable);
+            freeTable->boundTo = subTy;
+        }
     }
 }
 
-void Unifier::tryUnifySealedTables(TypeId left, TypeId right, bool isIntersection)
+void Unifier::tryUnifySealedTables(TypeId subTy, TypeId superTy, bool isIntersection)
 {
-    TableTypeVar* lt = getMutable<TableTypeVar>(left);
-    TableTypeVar* rt = getMutable<TableTypeVar>(right);
-    if (!lt || !rt)
+    TableTypeVar* superTable = getMutable<TableTypeVar>(superTy);
+    TableTypeVar* subTable = getMutable<TableTypeVar>(subTy);
+
+    if (FFlag::LuauUseCommittingTxnLog)
+    {
+        superTable = log.getMutable<TableTypeVar>(superTy);
+        subTable = log.getMutable<TableTypeVar>(subTy);
+    }
+
+    if (!superTable || !subTable)
         ice("passed non-table types to unifySealedTables");
 
     Unifier innerState = makeChildUnifier();
 
     std::vector<std::string> missingPropertiesInSuper;
-    bool isUnnamedTable = rt->name == std::nullopt && rt->syntheticName == std::nullopt;
+    bool isUnnamedTable = subTable->name == std::nullopt && subTable->syntheticName == std::nullopt;
     bool errorReported = false;
 
     // Optimization: First test that the property sets are compatible without doing any recursive unification
-    if (FFlag::LuauTableUnificationEarlyTest && !rt->indexer)
+    if (FFlag::LuauTableUnificationEarlyTest && !subTable->indexer)
     {
-        for (const auto& [propName, superProp] : lt->props)
+        for (const auto& [propName, superProp] : superTable->props)
         {
-            auto subIter = rt->props.find(propName);
-            if (subIter == rt->props.end() && !isOptional(superProp.type))
+            auto subIter = subTable->props.find(propName);
+            if (subIter == subTable->props.end() && !isOptional(superProp.type))
                 missingPropertiesInSuper.push_back(propName);
         }
 
         if (!missingPropertiesInSuper.empty())
         {
-            errors.push_back(TypeError{location, MissingProperties{left, right, std::move(missingPropertiesInSuper)}});
+            errors.push_back(TypeError{location, MissingProperties{superTy, subTy, std::move(missingPropertiesInSuper)}});
             return;
         }
     }
 
     // Tables must have exactly the same props and their types must all unify
-    for (const auto& it : lt->props)
+    for (const auto& it : superTable->props)
     {
-        const auto& r = rt->props.find(it.first);
-        if (r == rt->props.end())
+        const auto& r = subTable->props.find(it.first);
+        if (r == subTable->props.end())
         {
             if (isOptional(it.second.type))
                 continue;
 
             missingPropertiesInSuper.push_back(it.first);
 
-            innerState.errors.push_back(TypeError{location, TypeMismatch{left, right}});
+            innerState.errors.push_back(TypeError{location, TypeMismatch{superTy, subTy}});
         }
         else
         {
@@ -1594,7 +2274,7 @@ void Unifier::tryUnifySealedTables(TypeId left, TypeId right, bool isIntersectio
                 size_t oldErrorSize = innerState.errors.size();
                 Location old = innerState.location;
                 innerState.location = *r->second.location;
-                innerState.tryUnify_(it.second.type, r->second.type);
+                innerState.tryUnify_(r->second.type, it.second.type);
                 innerState.location = old;
 
                 if (oldErrorSize != innerState.errors.size() && !errorReported)
@@ -1605,113 +2285,165 @@ void Unifier::tryUnifySealedTables(TypeId left, TypeId right, bool isIntersectio
             }
             else
             {
-                innerState.tryUnify_(it.second.type, r->second.type);
+                innerState.tryUnify_(r->second.type, it.second.type);
             }
         }
     }
 
-    if (lt->indexer || rt->indexer)
+    if (superTable->indexer || subTable->indexer)
     {
-        if (lt->indexer && rt->indexer)
-            innerState.tryUnify(*lt->indexer, *rt->indexer);
-        else if (rt->state == TableState::Unsealed)
+        if (FFlag::LuauUseCommittingTxnLog)
         {
-            if (lt->indexer && !rt->indexer)
-                rt->indexer = lt->indexer;
-        }
-        else if (lt->state == TableState::Unsealed)
-        {
-            if (rt->indexer && !lt->indexer)
-                lt->indexer = rt->indexer;
-        }
-        else if (lt->indexer)
-        {
-            innerState.tryUnify_(lt->indexer->indexType, getSingletonTypes().stringType);
-            // We already try to unify properties in both tables.
-            // Skip those and just look for the ones remaining and see if they fit into the indexer.
-            for (const auto& [name, type] : rt->props)
+            if (superTable->indexer && subTable->indexer)
+                innerState.tryUnifyIndexer(*subTable->indexer, *superTable->indexer);
+            else if (subTable->state == TableState::Unsealed)
             {
-                const auto& it = lt->props.find(name);
-                if (it == lt->props.end())
-                    innerState.tryUnify_(lt->indexer->indexResultType, type.type);
+                if (superTable->indexer && !subTable->indexer)
+                {
+                    log.changeIndexer(subTy, superTable->indexer);
+                }
             }
+            else if (superTable->state == TableState::Unsealed)
+            {
+                if (subTable->indexer && !superTable->indexer)
+                {
+                    log.changeIndexer(superTy, subTable->indexer);
+                }
+            }
+            else if (superTable->indexer)
+            {
+                innerState.tryUnify_(getSingletonTypes().stringType, superTable->indexer->indexType);
+                for (const auto& [name, type] : subTable->props)
+                {
+                    const auto& it = superTable->props.find(name);
+                    if (it == superTable->props.end())
+                        innerState.tryUnify_(type.type, superTable->indexer->indexResultType);
+                }
+            }
+            else
+                innerState.errors.push_back(TypeError{location, TypeMismatch{superTy, subTy}});
         }
         else
-            innerState.errors.push_back(TypeError{location, TypeMismatch{left, right}});
+        {
+            if (superTable->indexer && subTable->indexer)
+                innerState.tryUnifyIndexer(*subTable->indexer, *superTable->indexer);
+            else if (subTable->state == TableState::Unsealed)
+            {
+                if (superTable->indexer && !subTable->indexer)
+                    subTable->indexer = superTable->indexer;
+            }
+            else if (superTable->state == TableState::Unsealed)
+            {
+                if (subTable->indexer && !superTable->indexer)
+                    superTable->indexer = subTable->indexer;
+            }
+            else if (superTable->indexer)
+            {
+                innerState.tryUnify_(getSingletonTypes().stringType, superTable->indexer->indexType);
+                // We already try to unify properties in both tables.
+                // Skip those and just look for the ones remaining and see if they fit into the indexer.
+                for (const auto& [name, type] : subTable->props)
+                {
+                    const auto& it = superTable->props.find(name);
+                    if (it == superTable->props.end())
+                        innerState.tryUnify_(type.type, superTable->indexer->indexResultType);
+                }
+            }
+            else
+                innerState.errors.push_back(TypeError{location, TypeMismatch{superTy, subTy}});
+        }
     }
 
-    log.concat(std::move(innerState.log));
+    if (FFlag::LuauUseCommittingTxnLog)
+    {
+        if (!errorReported)
+            log.concat(std::move(innerState.log));
+    }
+    else
+        DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
 
     if (errorReported)
         return;
 
     if (!missingPropertiesInSuper.empty())
     {
-        errors.push_back(TypeError{location, MissingProperties{left, right, std::move(missingPropertiesInSuper)}});
+        errors.push_back(TypeError{location, MissingProperties{superTy, subTy, std::move(missingPropertiesInSuper)}});
         return;
     }
 
-    // If the superTy/left is an immediate part of an intersection type, do not do extra-property check.
+    // If the superTy is an immediate part of an intersection type, do not do extra-property check.
     // Otherwise, we would falsely generate an extra-property-error for 's' in this code:
     // local a: {n: number} & {s: string} = {n=1, s=""}
     // When checking against the table '{n: number}'.
-    if (!isIntersection && lt->state != TableState::Unsealed && !lt->indexer)
+    if (!isIntersection && superTable->state != TableState::Unsealed && !superTable->indexer)
     {
         // Check for extra properties in the subTy
         std::vector<std::string> extraPropertiesInSub;
 
-        for (const auto& it : rt->props)
+        for (const auto& [subKey, subProp] : subTable->props)
         {
-            const auto& r = lt->props.find(it.first);
-            if (r == lt->props.end())
+            const auto& superIt = superTable->props.find(subKey);
+            if (superIt == superTable->props.end())
             {
-                if (isOptional(it.second.type))
+                if (isOptional(subProp.type))
                     continue;
 
-                extraPropertiesInSub.push_back(it.first);
+                extraPropertiesInSub.push_back(subKey);
             }
         }
 
         if (!extraPropertiesInSub.empty())
         {
-            errors.push_back(TypeError{location, MissingProperties{left, right, std::move(extraPropertiesInSub), MissingProperties::Extra}});
+            errors.push_back(TypeError{location, MissingProperties{superTy, subTy, std::move(extraPropertiesInSub), MissingProperties::Extra}});
             return;
         }
     }
 
-    checkChildUnifierTypeMismatch(innerState.errors, left, right);
+    checkChildUnifierTypeMismatch(innerState.errors, superTy, subTy);
 }
 
-void Unifier::tryUnifyWithMetatable(TypeId metatable, TypeId other, bool reversed)
+void Unifier::tryUnifyWithMetatable(TypeId subTy, TypeId superTy, bool reversed)
 {
-    const MetatableTypeVar* lhs = get<MetatableTypeVar>(metatable);
-    if (!lhs)
+    const MetatableTypeVar* superMetatable = get<MetatableTypeVar>(superTy);
+    if (!superMetatable)
         ice("tryUnifyMetatable invoked with non-metatable TypeVar");
 
-    TypeError mismatchError = TypeError{location, TypeMismatch{reversed ? other : metatable, reversed ? metatable : other}};
+    TypeError mismatchError = TypeError{location, TypeMismatch{reversed ? subTy : superTy, reversed ? superTy : subTy}};
 
-    if (const MetatableTypeVar* rhs = get<MetatableTypeVar>(other))
+    if (const MetatableTypeVar* subMetatable =
+            FFlag::LuauUseCommittingTxnLog ? log.getMutable<MetatableTypeVar>(subTy) : get<MetatableTypeVar>(subTy))
     {
         Unifier innerState = makeChildUnifier();
-        innerState.tryUnify_(lhs->table, rhs->table);
-        innerState.tryUnify_(lhs->metatable, rhs->metatable);
+        innerState.tryUnify_(subMetatable->table, superMetatable->table);
+        innerState.tryUnify_(subMetatable->metatable, superMetatable->metatable);
 
         if (auto e = hasUnificationTooComplex(innerState.errors))
             errors.push_back(*e);
         else if (!innerState.errors.empty())
             errors.push_back(
-                TypeError{location, TypeMismatch{reversed ? other : metatable, reversed ? metatable : other, "", innerState.errors.front()}});
+                TypeError{location, TypeMismatch{reversed ? subTy : superTy, reversed ? superTy : subTy, "", innerState.errors.front()}});
 
-        log.concat(std::move(innerState.log));
+        if (FFlag::LuauUseCommittingTxnLog)
+            log.concat(std::move(innerState.log));
+        else
+            DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
     }
-    else if (TableTypeVar* rhs = getMutable<TableTypeVar>(other))
+    else if (TableTypeVar* subTable = FFlag::LuauUseCommittingTxnLog ? log.getMutable<TableTypeVar>(subTy) : getMutable<TableTypeVar>(subTy))
     {
-        switch (rhs->state)
+        switch (subTable->state)
         {
         case TableState::Free:
         {
-            tryUnify_(lhs->table, other);
-            rhs->boundTo = metatable;
+            tryUnify_(subTy, superMetatable->table);
+
+            if (FFlag::LuauUseCommittingTxnLog)
+            {
+                log.bindTable(subTy, superTy);
+            }
+            else
+            {
+                subTable->boundTo = superTy;
+            }
 
             break;
         }
@@ -1722,7 +2454,8 @@ void Unifier::tryUnifyWithMetatable(TypeId metatable, TypeId other, bool reverse
             errors.push_back(mismatchError);
         }
     }
-    else if (get<AnyTypeVar>(other) || get<ErrorTypeVar>(other))
+    else if (FFlag::LuauUseCommittingTxnLog ? (log.getMutable<AnyTypeVar>(subTy) || log.getMutable<ErrorTypeVar>(subTy))
+                                            : (get<AnyTypeVar>(subTy) || get<ErrorTypeVar>(subTy)))
     {
     }
     else
@@ -1732,7 +2465,7 @@ void Unifier::tryUnifyWithMetatable(TypeId metatable, TypeId other, bool reverse
 }
 
 // Class unification is almost, but not quite symmetrical.  We use the 'reversed' boolean to indicate which scenario we are evaluating.
-void Unifier::tryUnifyWithClass(TypeId superTy, TypeId subTy, bool reversed)
+void Unifier::tryUnifyWithClass(TypeId subTy, TypeId superTy, bool reversed)
 {
     if (reversed)
         std::swap(superTy, subTy);
@@ -1763,7 +2496,7 @@ void Unifier::tryUnifyWithClass(TypeId superTy, TypeId subTy, bool reversed)
         }
         ice("Illegal variance setting!");
     }
-    else if (TableTypeVar* table = getMutable<TableTypeVar>(subTy))
+    else if (TableTypeVar* subTable = getMutable<TableTypeVar>(subTy))
     {
         /**
          * A free table is something whose shape we do not exactly know yet.
@@ -1775,12 +2508,12 @@ void Unifier::tryUnifyWithClass(TypeId superTy, TypeId subTy, bool reversed)
          *
          * Tables that are not free are known to be actual tables.
          */
-        if (table->state != TableState::Free)
+        if (subTable->state != TableState::Free)
             return fail();
 
         bool ok = true;
 
-        for (const auto& [propName, prop] : table->props)
+        for (const auto& [propName, prop] : subTable->props)
         {
             const Property* classProp = lookupClassProp(superClass, propName);
             if (!classProp)
@@ -1791,23 +2524,37 @@ void Unifier::tryUnifyWithClass(TypeId superTy, TypeId subTy, bool reversed)
             else
             {
                 Unifier innerState = makeChildUnifier();
-                innerState.tryUnify_(prop.type, classProp->type);
+                innerState.tryUnify_(classProp->type, prop.type);
 
                 checkChildUnifierTypeMismatch(innerState.errors, propName, reversed ? subTy : superTy, reversed ? superTy : subTy);
 
-                if (innerState.errors.empty())
+                if (FFlag::LuauUseCommittingTxnLog)
                 {
-                    log.concat(std::move(innerState.log));
+                    if (innerState.errors.empty())
+                    {
+                        log.concat(std::move(innerState.log));
+                    }
+                    else
+                    {
+                        ok = false;
+                    }
                 }
                 else
                 {
-                    ok = false;
-                    innerState.log.rollback();
+                    if (innerState.errors.empty())
+                    {
+                        DEPRECATED_log.concat(std::move(innerState.DEPRECATED_log));
+                    }
+                    else
+                    {
+                        ok = false;
+                        innerState.DEPRECATED_log.rollback();
+                    }
                 }
             }
         }
 
-        if (table->indexer)
+        if (subTable->indexer)
         {
             ok = false;
             std::string msg = "Class " + superClass->name + " does not have an indexer";
@@ -1817,17 +2564,24 @@ void Unifier::tryUnifyWithClass(TypeId superTy, TypeId subTy, bool reversed)
         if (!ok)
             return;
 
-        log(table);
-        table->boundTo = superTy;
+        if (FFlag::LuauUseCommittingTxnLog)
+        {
+            log.bindTable(subTy, superTy);
+        }
+        else
+        {
+            DEPRECATED_log(subTable);
+            subTable->boundTo = superTy;
+        }
     }
     else
         return fail();
 }
 
-void Unifier::tryUnify(const TableIndexer& superIndexer, const TableIndexer& subIndexer)
+void Unifier::tryUnifyIndexer(const TableIndexer& subIndexer, const TableIndexer& superIndexer)
 {
-    tryUnify_(superIndexer.indexType, subIndexer.indexType);
-    tryUnify_(superIndexer.indexResultType, subIndexer.indexResultType);
+    tryUnify_(subIndexer.indexType, superIndexer.indexType);
+    tryUnify_(subIndexer.indexResultType, superIndexer.indexResultType);
 }
 
 static void queueTypePack(std::vector<TypeId>& queue, DenseHashSet<TypePackId>& seenTypePacks, Unifier& state, TypePackId a, TypePackId anyTypePack)
@@ -1840,54 +2594,85 @@ static void queueTypePack(std::vector<TypeId>& queue, DenseHashSet<TypePackId>&
             break;
         seenTypePacks.insert(a);
 
-        if (get<Unifiable::Free>(a))
+        if (FFlag::LuauUseCommittingTxnLog)
         {
-            state.log(a);
-            *asMutable(a) = Unifiable::Bound{anyTypePack};
+            if (state.log.getMutable<Unifiable::Free>(a))
+            {
+                state.log.replace(a, Unifiable::Bound{anyTypePack});
+            }
+            else if (auto tp = state.log.getMutable<TypePack>(a))
+            {
+                queue.insert(queue.end(), tp->head.begin(), tp->head.end());
+                if (tp->tail)
+                    a = *tp->tail;
+                else
+                    break;
+            }
         }
-        else if (auto tp = get<TypePack>(a))
+        else
         {
-            queue.insert(queue.end(), tp->head.begin(), tp->head.end());
-            if (tp->tail)
-                a = *tp->tail;
-            else
-                break;
+            if (get<Unifiable::Free>(a))
+            {
+                state.DEPRECATED_log(a);
+                *asMutable(a) = Unifiable::Bound{anyTypePack};
+            }
+            else if (auto tp = get<TypePack>(a))
+            {
+                queue.insert(queue.end(), tp->head.begin(), tp->head.end());
+                if (tp->tail)
+                    a = *tp->tail;
+                else
+                    break;
+            }
         }
     }
 }
 
-void Unifier::tryUnifyVariadics(TypePackId superTp, TypePackId subTp, bool reversed, int subOffset)
+void Unifier::tryUnifyVariadics(TypePackId subTp, TypePackId superTp, bool reversed, int subOffset)
 {
-    const VariadicTypePack* lv = get<VariadicTypePack>(superTp);
-    if (!lv)
+    const VariadicTypePack* superVariadic = get<VariadicTypePack>(superTp);
+
+    if (FFlag::LuauUseCommittingTxnLog)
+    {
+        superVariadic = log.getMutable<VariadicTypePack>(superTp);
+    }
+
+    if (!superVariadic)
         ice("passed non-variadic pack to tryUnifyVariadics");
 
-    if (const VariadicTypePack* rv = get<VariadicTypePack>(subTp))
-        tryUnify_(reversed ? rv->ty : lv->ty, reversed ? lv->ty : rv->ty);
+    if (const VariadicTypePack* subVariadic = get<VariadicTypePack>(subTp))
+        tryUnify_(reversed ? superVariadic->ty : subVariadic->ty, reversed ? subVariadic->ty : superVariadic->ty);
     else if (get<TypePack>(subTp))
     {
-        TypePackIterator rIter = begin(subTp);
-        TypePackIterator rEnd = end(subTp);
+        TypePackIterator subIter = begin(subTp, &log);
+        TypePackIterator subEnd = end(subTp);
 
-        std::advance(rIter, subOffset);
+        std::advance(subIter, subOffset);
 
-        while (rIter != rEnd)
+        while (subIter != subEnd)
         {
-            tryUnify_(reversed ? *rIter : lv->ty, reversed ? lv->ty : *rIter);
-            ++rIter;
+            tryUnify_(reversed ? superVariadic->ty : *subIter, reversed ? *subIter : superVariadic->ty);
+            ++subIter;
         }
 
-        if (std::optional<TypePackId> maybeTail = rIter.tail())
+        if (std::optional<TypePackId> maybeTail = subIter.tail())
         {
             TypePackId tail = follow(*maybeTail);
             if (get<FreeTypePack>(tail))
             {
-                log(tail);
-                *asMutable(tail) = BoundTypePack{superTp};
+                if (FFlag::LuauUseCommittingTxnLog)
+                {
+                    log.replace(tail, BoundTypePack(superTp));
+                }
+                else
+                {
+                    DEPRECATED_log(tail);
+                    *asMutable(tail) = BoundTypePack{superTp};
+                }
             }
             else if (const VariadicTypePack* vtp = get<VariadicTypePack>(tail))
             {
-                tryUnify_(lv->ty, vtp->ty);
+                tryUnify_(vtp->ty, superVariadic->ty);
             }
             else if (get<Unifiable::Generic>(tail))
             {
@@ -1914,65 +2699,113 @@ static void tryUnifyWithAny(std::vector<TypeId>& queue, Unifier& state, DenseHas
 {
     while (!queue.empty())
     {
-        TypeId ty = follow(queue.back());
-        queue.pop_back();
-        if (seen.find(ty))
-            continue;
-        seen.insert(ty);
+        if (FFlag::LuauUseCommittingTxnLog)
+        {
+            TypeId ty = state.log.follow(queue.back());
+            queue.pop_back();
+            if (seen.find(ty))
+                continue;
+            seen.insert(ty);
 
-        if (get<FreeTypeVar>(ty))
-        {
-            state.log(ty);
-            *asMutable(ty) = BoundTypeVar{anyType};
-        }
-        else if (auto fun = get<FunctionTypeVar>(ty))
-        {
-            queueTypePack(queue, seenTypePacks, state, fun->argTypes, anyTypePack);
-            queueTypePack(queue, seenTypePacks, state, fun->retType, anyTypePack);
-        }
-        else if (auto table = get<TableTypeVar>(ty))
-        {
-            for (const auto& [_name, prop] : table->props)
-                queue.push_back(prop.type);
-
-            if (table->indexer)
+            if (state.log.getMutable<FreeTypeVar>(ty))
             {
-                queue.push_back(table->indexer->indexType);
-                queue.push_back(table->indexer->indexResultType);
+                state.log.replace(ty, BoundTypeVar{anyType});
             }
+            else if (auto fun = state.log.getMutable<FunctionTypeVar>(ty))
+            {
+                queueTypePack(queue, seenTypePacks, state, fun->argTypes, anyTypePack);
+                queueTypePack(queue, seenTypePacks, state, fun->retType, anyTypePack);
+            }
+            else if (auto table = state.log.getMutable<TableTypeVar>(ty))
+            {
+                for (const auto& [_name, prop] : table->props)
+                    queue.push_back(prop.type);
+
+                if (table->indexer)
+                {
+                    queue.push_back(table->indexer->indexType);
+                    queue.push_back(table->indexer->indexResultType);
+                }
+            }
+            else if (auto mt = state.log.getMutable<MetatableTypeVar>(ty))
+            {
+                queue.push_back(mt->table);
+                queue.push_back(mt->metatable);
+            }
+            else if (state.log.getMutable<ClassTypeVar>(ty))
+            {
+                // ClassTypeVars never contain free typevars.
+            }
+            else if (auto union_ = state.log.getMutable<UnionTypeVar>(ty))
+                queue.insert(queue.end(), union_->options.begin(), union_->options.end());
+            else if (auto intersection = state.log.getMutable<IntersectionTypeVar>(ty))
+                queue.insert(queue.end(), intersection->parts.begin(), intersection->parts.end());
+            else
+            {
+            } // Primitives, any, errors, and generics are left untouched.
         }
-        else if (auto mt = get<MetatableTypeVar>(ty))
-        {
-            queue.push_back(mt->table);
-            queue.push_back(mt->metatable);
-        }
-        else if (get<ClassTypeVar>(ty))
-        {
-            // ClassTypeVars never contain free typevars.
-        }
-        else if (auto union_ = get<UnionTypeVar>(ty))
-            queue.insert(queue.end(), union_->options.begin(), union_->options.end());
-        else if (auto intersection = get<IntersectionTypeVar>(ty))
-            queue.insert(queue.end(), intersection->parts.begin(), intersection->parts.end());
         else
         {
-        } // Primitives, any, errors, and generics are left untouched.
+            TypeId ty = follow(queue.back());
+            queue.pop_back();
+            if (seen.find(ty))
+                continue;
+            seen.insert(ty);
+
+            if (get<FreeTypeVar>(ty))
+            {
+                state.DEPRECATED_log(ty);
+                *asMutable(ty) = BoundTypeVar{anyType};
+            }
+            else if (auto fun = get<FunctionTypeVar>(ty))
+            {
+                queueTypePack(queue, seenTypePacks, state, fun->argTypes, anyTypePack);
+                queueTypePack(queue, seenTypePacks, state, fun->retType, anyTypePack);
+            }
+            else if (auto table = get<TableTypeVar>(ty))
+            {
+                for (const auto& [_name, prop] : table->props)
+                    queue.push_back(prop.type);
+
+                if (table->indexer)
+                {
+                    queue.push_back(table->indexer->indexType);
+                    queue.push_back(table->indexer->indexResultType);
+                }
+            }
+            else if (auto mt = get<MetatableTypeVar>(ty))
+            {
+                queue.push_back(mt->table);
+                queue.push_back(mt->metatable);
+            }
+            else if (get<ClassTypeVar>(ty))
+            {
+                // ClassTypeVars never contain free typevars.
+            }
+            else if (auto union_ = get<UnionTypeVar>(ty))
+                queue.insert(queue.end(), union_->options.begin(), union_->options.end());
+            else if (auto intersection = get<IntersectionTypeVar>(ty))
+                queue.insert(queue.end(), intersection->parts.begin(), intersection->parts.end());
+            else
+            {
+            } // Primitives, any, errors, and generics are left untouched.
+        }
     }
 }
 
-void Unifier::tryUnifyWithAny(TypeId any, TypeId ty)
+void Unifier::tryUnifyWithAny(TypeId subTy, TypeId anyTy)
 {
-    LUAU_ASSERT(get<AnyTypeVar>(any) || get<ErrorTypeVar>(any));
+    LUAU_ASSERT(get<AnyTypeVar>(anyTy) || get<ErrorTypeVar>(anyTy));
 
     // These types are not visited in general loop below
-    if (get<PrimitiveTypeVar>(ty) || get<AnyTypeVar>(ty) || get<ClassTypeVar>(ty))
+    if (get<PrimitiveTypeVar>(subTy) || get<AnyTypeVar>(subTy) || get<ClassTypeVar>(subTy))
         return;
 
     const TypePackId anyTypePack = types->addTypePack(TypePackVar{VariadicTypePack{getSingletonTypes().anyType}});
 
-    const TypePackId anyTP = get<AnyTypeVar>(any) ? anyTypePack : types->addTypePack(TypePackVar{Unifiable::Error{}});
+    const TypePackId anyTP = get<AnyTypeVar>(anyTy) ? anyTypePack : types->addTypePack(TypePackVar{Unifiable::Error{}});
 
-    std::vector<TypeId> queue = {ty};
+    std::vector<TypeId> queue = {subTy};
 
     sharedState.tempSeenTy.clear();
     sharedState.tempSeenTp.clear();
@@ -1980,9 +2813,9 @@ void Unifier::tryUnifyWithAny(TypeId any, TypeId ty)
     Luau::tryUnifyWithAny(queue, *this, sharedState.tempSeenTy, sharedState.tempSeenTp, getSingletonTypes().anyType, anyTP);
 }
 
-void Unifier::tryUnifyWithAny(TypePackId any, TypePackId ty)
+void Unifier::tryUnifyWithAny(TypePackId subTy, TypePackId anyTp)
 {
-    LUAU_ASSERT(get<Unifiable::Error>(any));
+    LUAU_ASSERT(get<Unifiable::Error>(anyTp));
 
     const TypeId anyTy = getSingletonTypes().errorRecoveryType();
 
@@ -1991,9 +2824,9 @@ void Unifier::tryUnifyWithAny(TypePackId any, TypePackId ty)
     sharedState.tempSeenTy.clear();
     sharedState.tempSeenTp.clear();
 
-    queueTypePack(queue, sharedState.tempSeenTp, *this, ty, any);
+    queueTypePack(queue, sharedState.tempSeenTp, *this, subTy, anyTp);
 
-    Luau::tryUnifyWithAny(queue, *this, sharedState.tempSeenTy, sharedState.tempSeenTp, anyTy, any);
+    Luau::tryUnifyWithAny(queue, *this, sharedState.tempSeenTy, sharedState.tempSeenTp, anyTy, anyTp);
 }
 
 std::optional<TypeId> Unifier::findTablePropertyRespectingMeta(TypeId lhsType, Name name)
@@ -2012,54 +2845,105 @@ void Unifier::occursCheck(DenseHashSet<TypeId>& seen, TypeId needle, TypeId hays
 {
     RecursionLimiter _ra(&sharedState.counters.recursionCount, FInt::LuauTypeInferRecursionLimit);
 
-    needle = follow(needle);
-    haystack = follow(haystack);
-
-    if (seen.find(haystack))
-        return;
-
-    seen.insert(haystack);
-
-    if (get<Unifiable::Error>(needle))
-        return;
-
-    if (!get<Unifiable::Free>(needle))
-        ice("Expected needle to be free");
-
-    if (needle == haystack)
-    {
-        errors.push_back(TypeError{location, OccursCheckFailed{}});
-        log(needle);
-        *asMutable(needle) = *getSingletonTypes().errorRecoveryType();
-        return;
-    }
-
     auto check = [&](TypeId tv) {
         occursCheck(seen, needle, tv);
     };
 
-    if (get<FreeTypeVar>(haystack))
-        return;
-    else if (auto a = get<FunctionTypeVar>(haystack))
+    if (FFlag::LuauUseCommittingTxnLog)
     {
-        if (!FFlag::LuauOccursCheckOkWithRecursiveFunctions)
-        {
-            for (TypeId ty : a->argTypes)
-                check(ty);
+        needle = log.follow(needle);
+        haystack = log.follow(haystack);
 
-            for (TypeId ty : a->retType)
+        if (seen.find(haystack))
+            return;
+
+        seen.insert(haystack);
+
+        if (log.getMutable<Unifiable::Error>(needle))
+            return;
+
+        if (!log.getMutable<Unifiable::Free>(needle))
+            ice("Expected needle to be free");
+
+        if (needle == haystack)
+        {
+            errors.push_back(TypeError{location, OccursCheckFailed{}});
+            log.replace(needle, *getSingletonTypes().errorRecoveryType());
+
+            return;
+        }
+
+        if (log.getMutable<FreeTypeVar>(haystack))
+            return;
+        else if (auto a = log.getMutable<FunctionTypeVar>(haystack))
+        {
+            if (!FFlag::LuauOccursCheckOkWithRecursiveFunctions)
+            {
+                for (TypePackIterator it(a->argTypes, &log); it != end(a->argTypes); ++it)
+                    check(*it);
+
+                for (TypePackIterator it(a->retType, &log); it != end(a->retType); ++it)
+                    check(*it);
+            }
+        }
+        else if (auto a = log.getMutable<UnionTypeVar>(haystack))
+        {
+            for (TypeId ty : a->options)
+                check(ty);
+        }
+        else if (auto a = log.getMutable<IntersectionTypeVar>(haystack))
+        {
+            for (TypeId ty : a->parts)
                 check(ty);
         }
     }
-    else if (auto a = get<UnionTypeVar>(haystack))
+    else
     {
-        for (TypeId ty : a->options)
-            check(ty);
-    }
-    else if (auto a = get<IntersectionTypeVar>(haystack))
-    {
-        for (TypeId ty : a->parts)
-            check(ty);
+        needle = follow(needle);
+        haystack = follow(haystack);
+
+        if (seen.find(haystack))
+            return;
+
+        seen.insert(haystack);
+
+        if (get<Unifiable::Error>(needle))
+            return;
+
+        if (!get<Unifiable::Free>(needle))
+            ice("Expected needle to be free");
+
+        if (needle == haystack)
+        {
+            errors.push_back(TypeError{location, OccursCheckFailed{}});
+            DEPRECATED_log(needle);
+            *asMutable(needle) = *getSingletonTypes().errorRecoveryType();
+            return;
+        }
+
+        if (get<FreeTypeVar>(haystack))
+            return;
+        else if (auto a = get<FunctionTypeVar>(haystack))
+        {
+            if (!FFlag::LuauOccursCheckOkWithRecursiveFunctions)
+            {
+                for (TypeId ty : a->argTypes)
+                    check(ty);
+
+                for (TypeId ty : a->retType)
+                    check(ty);
+            }
+        }
+        else if (auto a = get<UnionTypeVar>(haystack))
+        {
+            for (TypeId ty : a->options)
+                check(ty);
+        }
+        else if (auto a = get<IntersectionTypeVar>(haystack))
+        {
+            for (TypeId ty : a->parts)
+                check(ty);
+        }
     }
 }
 
@@ -2072,59 +2956,115 @@ void Unifier::occursCheck(TypePackId needle, TypePackId haystack)
 
 void Unifier::occursCheck(DenseHashSet<TypePackId>& seen, TypePackId needle, TypePackId haystack)
 {
-    needle = follow(needle);
-    haystack = follow(haystack);
-
-    if (seen.find(haystack))
-        return;
-
-    seen.insert(haystack);
-
-    if (get<Unifiable::Error>(needle))
-        return;
-
-    if (!get<Unifiable::Free>(needle))
-        ice("Expected needle pack to be free");
-
-    RecursionLimiter _ra(&sharedState.counters.recursionCount, FInt::LuauTypeInferRecursionLimit);
-
-    while (!get<ErrorTypeVar>(haystack))
+    if (FFlag::LuauUseCommittingTxnLog)
     {
-        if (needle == haystack)
-        {
-            errors.push_back(TypeError{location, OccursCheckFailed{}});
-            log(needle);
-            *asMutable(needle) = *getSingletonTypes().errorRecoveryTypePack();
-            return;
-        }
+        needle = log.follow(needle);
+        haystack = log.follow(haystack);
 
-        if (auto a = get<TypePack>(haystack))
+        if (seen.find(haystack))
+            return;
+
+        seen.insert(haystack);
+
+        if (log.getMutable<Unifiable::Error>(needle))
+            return;
+
+        if (!get<Unifiable::Free>(needle))
+            ice("Expected needle pack to be free");
+
+        RecursionLimiter _ra(&sharedState.counters.recursionCount, FInt::LuauTypeInferRecursionLimit);
+
+        while (!log.getMutable<ErrorTypeVar>(haystack))
         {
-            if (!FFlag::LuauOccursCheckOkWithRecursiveFunctions)
+            if (needle == haystack)
+            {
+                errors.push_back(TypeError{location, OccursCheckFailed{}});
+                log.replace(needle, *getSingletonTypes().errorRecoveryTypePack());
+
+                return;
+            }
+
+            if (auto a = get<TypePack>(haystack))
             {
                 for (const auto& ty : a->head)
                 {
-                    if (auto f = get<FunctionTypeVar>(follow(ty)))
+                    if (!FFlag::LuauOccursCheckOkWithRecursiveFunctions)
                     {
-                        occursCheck(seen, needle, f->argTypes);
-                        occursCheck(seen, needle, f->retType);
+                        if (auto f = log.getMutable<FunctionTypeVar>(log.follow(ty)))
+                        {
+                            occursCheck(seen, needle, f->argTypes);
+                            occursCheck(seen, needle, f->retType);
+                        }
                     }
                 }
+
+                if (a->tail)
+                {
+                    haystack = follow(*a->tail);
+                    continue;
+                }
+            }
+            break;
+        }
+    }
+    else
+    {
+        needle = follow(needle);
+        haystack = follow(haystack);
+
+        if (seen.find(haystack))
+            return;
+
+        seen.insert(haystack);
+
+        if (get<Unifiable::Error>(needle))
+            return;
+
+        if (!get<Unifiable::Free>(needle))
+            ice("Expected needle pack to be free");
+
+        RecursionLimiter _ra(&sharedState.counters.recursionCount, FInt::LuauTypeInferRecursionLimit);
+
+        while (!get<ErrorTypeVar>(haystack))
+        {
+            if (needle == haystack)
+            {
+                errors.push_back(TypeError{location, OccursCheckFailed{}});
+                DEPRECATED_log(needle);
+                *asMutable(needle) = *getSingletonTypes().errorRecoveryTypePack();
             }
 
-            if (a->tail)
+            if (auto a = get<TypePack>(haystack))
             {
-                haystack = follow(*a->tail);
-                continue;
+                if (!FFlag::LuauOccursCheckOkWithRecursiveFunctions)
+                {
+                    for (const auto& ty : a->head)
+                    {
+                        if (auto f = get<FunctionTypeVar>(follow(ty)))
+                        {
+                            occursCheck(seen, needle, f->argTypes);
+                            occursCheck(seen, needle, f->retType);
+                        }
+                    }
+                }
+
+                if (a->tail)
+                {
+                    haystack = follow(*a->tail);
+                    continue;
+                }
             }
+            break;
         }
-        break;
     }
 }
 
 Unifier Unifier::makeChildUnifier()
 {
-    return Unifier{types, mode, globalScope, log.sharedSeen, location, variance, sharedState};
+    if (FFlag::LuauUseCommittingTxnLog)
+        return Unifier{types, mode, globalScope, log.sharedSeen, location, variance, sharedState, &log};
+    else
+        return Unifier{types, mode, globalScope, DEPRECATED_log.sharedSeen, location, variance, sharedState, &log};
 }
 
 bool Unifier::isNonstrictMode() const
diff --git a/Ast/include/Luau/Common.h b/Ast/include/Luau/Common.h
index 63cd3df4..fbb03a9e 100644
--- a/Ast/include/Luau/Common.h
+++ b/Ast/include/Luau/Common.h
@@ -29,7 +29,7 @@
 namespace Luau
 {
 
-using AssertHandler = int (*)(const char* expression, const char* file, int line);
+using AssertHandler = int (*)(const char* expression, const char* file, int line, const char* function);
 
 inline AssertHandler& assertHandler()
 {
@@ -37,10 +37,10 @@ inline AssertHandler& assertHandler()
     return handler;
 }
 
-inline int assertCallHandler(const char* expression, const char* file, int line)
+inline int assertCallHandler(const char* expression, const char* file, int line, const char* function)
 {
     if (AssertHandler handler = assertHandler())
-        return handler(expression, file, line);
+        return handler(expression, file, line, function);
 
     return 1;
 }
@@ -48,7 +48,7 @@ inline int assertCallHandler(const char* expression, const char* file, int line)
 } // namespace Luau
 
 #if !defined(NDEBUG) || defined(LUAU_ENABLE_ASSERT)
-#define LUAU_ASSERT(expr) ((void)(!!(expr) || (Luau::assertCallHandler(#expr, __FILE__, __LINE__) && (LUAU_DEBUGBREAK(), 0))))
+#define LUAU_ASSERT(expr) ((void)(!!(expr) || (Luau::assertCallHandler(#expr, __FILE__, __LINE__, __FUNCTION__) && (LUAU_DEBUGBREAK(), 0))))
 #define LUAU_ASSERTENABLED
 #else
 #define LUAU_ASSERT(expr) (void)sizeof(!!(expr))
diff --git a/CLI/Analyze.cpp b/CLI/Analyze.cpp
index 5318044b..1375f414 100644
--- a/CLI/Analyze.cpp
+++ b/CLI/Analyze.cpp
@@ -107,7 +107,7 @@ static void displayHelp(const char* argv0)
     printf("  --formatter=gnu: report analysis errors in GNU-compatible format\n");
 }
 
-static int assertionHandler(const char* expr, const char* file, int line)
+static int assertionHandler(const char* expr, const char* file, int line, const char* function)
 {
     printf("%s(%d): ASSERTION FAILED: %s\n", file, line, expr);
     return 1;
diff --git a/CLI/Repl.cpp b/CLI/Repl.cpp
index 5d3324ab..35fbf309 100644
--- a/CLI/Repl.cpp
+++ b/CLI/Repl.cpp
@@ -235,11 +235,14 @@ static void completeIndexer(lua_State* L, const char* editBuffer, size_t start,
 
             while (lua_next(L, -2) != 0)
             {
-                // table, key, value
-                std::string_view key = lua_tostring(L, -2);
+                if (lua_type(L, -2) == LUA_TSTRING)
+                {
+                    // table, key, value
+                    std::string_view key = lua_tostring(L, -2);
 
-                if (!key.empty() && Luau::startsWith(key, prefix))
-                    completions.push_back(editBuffer + std::string(key.substr(prefix.size())));
+                    if (!key.empty() && Luau::startsWith(key, prefix))
+                        completions.push_back(editBuffer + std::string(key.substr(prefix.size())));
+                }
 
                 lua_pop(L, 1);
             }
@@ -253,7 +256,7 @@ static void completeIndexer(lua_State* L, const char* editBuffer, size_t start,
             lua_rawget(L, -2);
             lua_remove(L, -2);
 
-            if (lua_isnil(L, -1))
+            if (!lua_istable(L, -1))
                 break;
 
             lookup.remove_prefix(dot + 1);
@@ -266,7 +269,7 @@ static void completeIndexer(lua_State* L, const char* editBuffer, size_t start,
 static void completeRepl(lua_State* L, const char* editBuffer, std::vector<std::string>& completions)
 {
     size_t start = strlen(editBuffer);
-    while (start > 0 && (isalnum(editBuffer[start - 1]) || editBuffer[start - 1] == '.'))
+    while (start > 0 && (isalnum(editBuffer[start - 1]) || editBuffer[start - 1] == '.' || editBuffer[start - 1] == '_'))
         start--;
 
     // look the value up in current global table first
@@ -278,6 +281,34 @@ static void completeRepl(lua_State* L, const char* editBuffer, std::vector<std::
     completeIndexer(L, editBuffer, start, completions);
 }
 
+struct LinenoiseScopedHistory
+{
+    LinenoiseScopedHistory()
+    {
+        const std::string name(".luau_history");
+
+        if (const char* home = getenv("HOME"))
+        {
+            historyFilepath = joinPaths(home, name);
+        }
+        else if (const char* userProfile = getenv("USERPROFILE"))
+        {
+            historyFilepath = joinPaths(userProfile, name);
+        }
+
+        if (!historyFilepath.empty())
+            linenoise::LoadHistory(historyFilepath.c_str());
+    }
+
+    ~LinenoiseScopedHistory()
+    {
+        if (!historyFilepath.empty())
+            linenoise::SaveHistory(historyFilepath.c_str());
+    }
+
+    std::string historyFilepath;
+};
+
 static void runRepl()
 {
     std::unique_ptr<lua_State, void (*)(lua_State*)> globalState(luaL_newstate(), lua_close);
@@ -292,6 +323,7 @@ static void runRepl()
     });
 
     std::string buffer;
+    LinenoiseScopedHistory scopedHistory;
 
     for (;;)
     {
@@ -457,7 +489,7 @@ static void displayHelp(const char* argv0)
     printf("  --coverage: collect code coverage while running the code and output results to coverage.out\n");
 }
 
-static int assertionHandler(const char* expr, const char* file, int line)
+static int assertionHandler(const char* expr, const char* file, int line, const char* function)
 {
     printf("%s(%d): ASSERTION FAILED: %s\n", file, line, expr);
     return 1;
diff --git a/CLI/Web.cpp b/CLI/Web.cpp
index cf5c831e..416a79f2 100644
--- a/CLI/Web.cpp
+++ b/CLI/Web.cpp
@@ -53,30 +53,38 @@ static std::string runCode(lua_State* L, const std::string& source)
             lua_insert(T, 1);
             lua_pcall(T, n, 0, 0);
         }
+
+        lua_pop(L, 1); // pop T
+        return std::string();
     }
     else
     {
         std::string error;
 
+        lua_Debug ar;
+        if (lua_getinfo(L, 0, "sln", &ar))
+        {
+            error += ar.short_src;
+            error += ':';
+            error += std::to_string(ar.currentline);
+            error += ": ";
+        }
+
         if (status == LUA_YIELD)
         {
-            error = "thread yielded unexpectedly";
+            error += "thread yielded unexpectedly";
         }
         else if (const char* str = lua_tostring(T, -1))
         {
-            error = str;
+            error += str;
         }
 
         error += "\nstack backtrace:\n";
         error += lua_debugtrace(T);
 
-        error = "Error:" + error;
-
-        fprintf(stdout, "%s", error.c_str());
+        lua_pop(L, 1); // pop T
+        return error;
     }
-
-    lua_pop(L, 1);
-    return std::string();
 }
 
 extern "C" const char* executeScript(const char* source)
diff --git a/Compiler/include/Luau/Bytecode.h b/Compiler/include/Luau/Bytecode.h
index 71631d10..d9694d7d 100644
--- a/Compiler/include/Luau/Bytecode.h
+++ b/Compiler/include/Luau/Bytecode.h
@@ -377,6 +377,7 @@ enum LuauBytecodeTag
 {
     // Bytecode version
     LBC_VERSION = 1,
+    LBC_VERSION_FUTURE = 2, // TODO: This will be removed in favor of LBC_VERSION with LuauBytecodeV2Force
     // Types of constant table entries
     LBC_CONSTANT_NIL = 0,
     LBC_CONSTANT_BOOLEAN,
diff --git a/Compiler/include/Luau/BytecodeBuilder.h b/Compiler/include/Luau/BytecodeBuilder.h
index d4ebad6b..287bf4ee 100644
--- a/Compiler/include/Luau/BytecodeBuilder.h
+++ b/Compiler/include/Luau/BytecodeBuilder.h
@@ -74,6 +74,7 @@ public:
     void expandJumps();
 
     void setDebugFunctionName(StringRef name);
+    void setDebugFunctionLineDefined(int line);
     void setDebugLine(int line);
     void pushDebugLocal(StringRef name, uint8_t reg, uint32_t startpc, uint32_t endpc);
     void pushDebugUpval(StringRef name);
@@ -162,6 +163,7 @@ private:
         bool isvararg = false;
 
         unsigned int debugname = 0;
+        int debuglinedefined = 0;
 
         std::string dump;
         std::string dumpname;
diff --git a/Compiler/src/BytecodeBuilder.cpp b/Compiler/src/BytecodeBuilder.cpp
index 3280c8a4..2d31c409 100644
--- a/Compiler/src/BytecodeBuilder.cpp
+++ b/Compiler/src/BytecodeBuilder.cpp
@@ -6,6 +6,8 @@
 #include <algorithm>
 #include <string.h>
 
+LUAU_FASTFLAGVARIABLE(LuauBytecodeV2Write, false)
+
 namespace Luau
 {
 
@@ -81,6 +83,52 @@ static int getOpLength(LuauOpcode op)
     }
 }
 
+inline bool isJumpD(LuauOpcode op)
+{
+    switch (op)
+    {
+    case LOP_JUMP:
+    case LOP_JUMPIF:
+    case LOP_JUMPIFNOT:
+    case LOP_JUMPIFEQ:
+    case LOP_JUMPIFLE:
+    case LOP_JUMPIFLT:
+    case LOP_JUMPIFNOTEQ:
+    case LOP_JUMPIFNOTLE:
+    case LOP_JUMPIFNOTLT:
+    case LOP_FORNPREP:
+    case LOP_FORNLOOP:
+    case LOP_FORGLOOP:
+    case LOP_FORGPREP_INEXT:
+    case LOP_FORGLOOP_INEXT:
+    case LOP_FORGPREP_NEXT:
+    case LOP_FORGLOOP_NEXT:
+    case LOP_JUMPBACK:
+    case LOP_JUMPIFEQK:
+    case LOP_JUMPIFNOTEQK:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
+inline bool isSkipC(LuauOpcode op)
+{
+    switch (op)
+    {
+    case LOP_LOADB:
+    case LOP_FASTCALL:
+    case LOP_FASTCALL1:
+    case LOP_FASTCALL2:
+    case LOP_FASTCALL2K:
+        return true;
+
+    default:
+        return false;
+    }
+}
+
 bool BytecodeBuilder::StringRef::operator==(const StringRef& other) const
 {
     return (data && other.data) ? (length == other.length && memcmp(data, other.data, length) == 0) : (data == other.data);
@@ -365,13 +413,7 @@ bool BytecodeBuilder::patchJumpD(size_t jumpLabel, size_t targetLabel)
     unsigned int jumpInsn = insns[jumpLabel];
     (void)jumpInsn;
 
-    LUAU_ASSERT(LUAU_INSN_OP(jumpInsn) == LOP_JUMP || LUAU_INSN_OP(jumpInsn) == LOP_JUMPIF || LUAU_INSN_OP(jumpInsn) == LOP_JUMPIFNOT ||
-                LUAU_INSN_OP(jumpInsn) == LOP_JUMPIFEQ || LUAU_INSN_OP(jumpInsn) == LOP_JUMPIFLE || LUAU_INSN_OP(jumpInsn) == LOP_JUMPIFLT ||
-                LUAU_INSN_OP(jumpInsn) == LOP_JUMPIFNOTEQ || LUAU_INSN_OP(jumpInsn) == LOP_JUMPIFNOTLE || LUAU_INSN_OP(jumpInsn) == LOP_JUMPIFNOTLT ||
-                LUAU_INSN_OP(jumpInsn) == LOP_FORNPREP || LUAU_INSN_OP(jumpInsn) == LOP_FORNLOOP || LUAU_INSN_OP(jumpInsn) == LOP_FORGLOOP ||
-                LUAU_INSN_OP(jumpInsn) == LOP_FORGPREP_INEXT || LUAU_INSN_OP(jumpInsn) == LOP_FORGLOOP_INEXT ||
-                LUAU_INSN_OP(jumpInsn) == LOP_FORGPREP_NEXT || LUAU_INSN_OP(jumpInsn) == LOP_FORGLOOP_NEXT ||
-                LUAU_INSN_OP(jumpInsn) == LOP_JUMPBACK || LUAU_INSN_OP(jumpInsn) == LOP_JUMPIFEQK || LUAU_INSN_OP(jumpInsn) == LOP_JUMPIFNOTEQK);
+    LUAU_ASSERT(isJumpD(LuauOpcode(LUAU_INSN_OP(jumpInsn))));
     LUAU_ASSERT(LUAU_INSN_D(jumpInsn) == 0);
 
     LUAU_ASSERT(targetLabel <= insns.size());
@@ -403,8 +445,7 @@ bool BytecodeBuilder::patchSkipC(size_t jumpLabel, size_t targetLabel)
     unsigned int jumpInsn = insns[jumpLabel];
     (void)jumpInsn;
 
-    LUAU_ASSERT(LUAU_INSN_OP(jumpInsn) == LOP_FASTCALL || LUAU_INSN_OP(jumpInsn) == LOP_FASTCALL1 || LUAU_INSN_OP(jumpInsn) == LOP_FASTCALL2 ||
-                LUAU_INSN_OP(jumpInsn) == LOP_FASTCALL2K);
+    LUAU_ASSERT(isSkipC(LuauOpcode(LUAU_INSN_OP(jumpInsn))));
     LUAU_ASSERT(LUAU_INSN_C(jumpInsn) == 0);
 
     int offset = int(targetLabel) - int(jumpLabel) - 1;
@@ -428,6 +469,11 @@ void BytecodeBuilder::setDebugFunctionName(StringRef name)
         functions[currentFunction].dumpname = std::string(name.data, name.length);
 }
 
+void BytecodeBuilder::setDebugFunctionLineDefined(int line)
+{
+    functions[currentFunction].debuglinedefined = line;
+}
+
 void BytecodeBuilder::setDebugLine(int line)
 {
     debugLine = line;
@@ -464,7 +510,7 @@ uint32_t BytecodeBuilder::getDebugPC() const
 void BytecodeBuilder::finalize()
 {
     LUAU_ASSERT(bytecode.empty());
-    bytecode = char(LBC_VERSION);
+    bytecode = char(FFlag::LuauBytecodeV2Write ? LBC_VERSION_FUTURE : LBC_VERSION);
 
     writeStringTable(bytecode);
 
@@ -565,6 +611,9 @@ void BytecodeBuilder::writeFunction(std::string& ss, uint32_t id) const
         writeVarInt(ss, child);
 
     // debug info
+    if (FFlag::LuauBytecodeV2Write)
+        writeVarInt(ss, func.debuglinedefined);
+
     writeVarInt(ss, func.debugname);
 
     bool hasLines = true;
diff --git a/Compiler/src/Compiler.cpp b/Compiler/src/Compiler.cpp
index 8f74ffed..6ae49027 100644
--- a/Compiler/src/Compiler.cpp
+++ b/Compiler/src/Compiler.cpp
@@ -11,7 +11,6 @@
 #include <math.h>
 
 LUAU_FASTFLAG(LuauIfElseExpressionBaseSupport)
-LUAU_FASTFLAGVARIABLE(LuauBit32CountBuiltin, false)
 
 namespace Luau
 {
@@ -179,6 +178,8 @@ struct Compiler
         if (options.optimizationLevel >= 1 && options.debugLevel >= 2)
             gatherConstUpvals(func);
 
+        bytecode.setDebugFunctionLineDefined(func->location.begin.line + 1);
+
         if (options.debugLevel >= 1 && func->debugname.value)
             bytecode.setDebugFunctionName(sref(func->debugname));
 
@@ -3626,9 +3627,9 @@ struct Compiler
                 return LBF_BIT32_RROTATE;
             if (builtin.method == "rshift")
                 return LBF_BIT32_RSHIFT;
-            if (builtin.method == "countlz" && FFlag::LuauBit32CountBuiltin)
+            if (builtin.method == "countlz")
                 return LBF_BIT32_COUNTLZ;
-            if (builtin.method == "countrz" && FFlag::LuauBit32CountBuiltin)
+            if (builtin.method == "countrz")
                 return LBF_BIT32_COUNTRZ;
         }
 
diff --git a/Sources.cmake b/Sources.cmake
index a7153eb3..5dd486aa 100644
--- a/Sources.cmake
+++ b/Sources.cmake
@@ -125,6 +125,7 @@ target_sources(Luau.VM PRIVATE
     VM/src/linit.cpp
     VM/src/lmathlib.cpp
     VM/src/lmem.cpp
+    VM/src/lnumprint.cpp
     VM/src/lobject.cpp
     VM/src/loslib.cpp
     VM/src/lperf.cpp
diff --git a/VM/include/luaconf.h b/VM/include/luaconf.h
index a01a1481..7e0832e7 100644
--- a/VM/include/luaconf.h
+++ b/VM/include/luaconf.h
@@ -138,10 +138,6 @@
 
 /* }================================================================== */
 
-/* Default number printing format and the string length limit */
-#define LUA_NUMBER_FMT "%.14g"
-#define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */
-
 /*
 @@ LUAI_USER_ALIGNMENT_T is a type that requires maximum alignment.
 ** CHANGE it if your system requires alignments larger than double. (For
diff --git a/VM/src/lapi.cpp b/VM/src/lapi.cpp
index a65b0325..c98b9590 100644
--- a/VM/src/lapi.cpp
+++ b/VM/src/lapi.cpp
@@ -14,8 +14,6 @@
 
 #include <string.h>
 
-LUAU_FASTFLAG(LuauActivateBeforeExec)
-
 const char* lua_ident = "$Lua: Lua 5.1.4 Copyright (C) 1994-2008 Lua.org, PUC-Rio $\n"
                         "$Authors: R. Ierusalimschy, L. H. de Figueiredo & W. Celes $\n"
                         "$URL: www.lua.org $\n";
@@ -939,21 +937,7 @@ void lua_call(lua_State* L, int nargs, int nresults)
     checkresults(L, nargs, nresults);
     func = L->top - (nargs + 1);
 
-    if (FFlag::LuauActivateBeforeExec)
-    {
-        luaD_call(L, func, nresults);
-    }
-    else
-    {
-        int oldactive = luaC_threadactive(L);
-        l_setbit(L->stackstate, THREAD_ACTIVEBIT);
-        luaC_checkthreadsleep(L);
-
-        luaD_call(L, func, nresults);
-
-        if (!oldactive)
-            resetbit(L->stackstate, THREAD_ACTIVEBIT);
-    }
+    luaD_call(L, func, nresults);
 
     adjustresults(L, nresults);
     return;
@@ -994,21 +978,7 @@ int lua_pcall(lua_State* L, int nargs, int nresults, int errfunc)
     c.func = L->top - (nargs + 1); /* function to be called */
     c.nresults = nresults;
 
-    if (FFlag::LuauActivateBeforeExec)
-    {
-        status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
-    }
-    else
-    {
-        int oldactive = luaC_threadactive(L);
-        l_setbit(L->stackstate, THREAD_ACTIVEBIT);
-        luaC_checkthreadsleep(L);
-
-        status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
-
-        if (!oldactive)
-            resetbit(L->stackstate, THREAD_ACTIVEBIT);
-    }
+    status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
 
     adjustresults(L, nresults);
     return status;
diff --git a/VM/src/laux.cpp b/VM/src/laux.cpp
index 7ed2a62e..71975a52 100644
--- a/VM/src/laux.cpp
+++ b/VM/src/laux.cpp
@@ -7,9 +7,12 @@
 #include "lstring.h"
 #include "lapi.h"
 #include "lgc.h"
+#include "lnumutils.h"
 
 #include <string.h>
 
+LUAU_FASTFLAG(LuauSchubfach)
+
 /* convert a stack index to positive */
 #define abs_index(L, i) ((i) > 0 || (i) <= LUA_REGISTRYINDEX ? (i) : lua_gettop(L) + (i) + 1)
 
@@ -477,7 +480,17 @@ const char* luaL_tolstring(lua_State* L, int idx, size_t* len)
     switch (lua_type(L, idx))
     {
     case LUA_TNUMBER:
-        lua_pushstring(L, lua_tostring(L, idx));
+        if (FFlag::LuauSchubfach)
+        {
+            double n = lua_tonumber(L, idx);
+            char s[LUAI_MAXNUM2STR];
+            char* e = luai_num2str(s, n);
+            lua_pushlstring(L, s, e - s);
+        }
+        else
+        {
+            lua_pushstring(L, lua_tostring(L, idx));
+        }
         break;
     case LUA_TSTRING:
         lua_pushvalue(L, idx);
@@ -491,11 +504,30 @@ const char* luaL_tolstring(lua_State* L, int idx, size_t* len)
     case LUA_TVECTOR:
     {
         const float* v = lua_tovector(L, idx);
+
+        if (FFlag::LuauSchubfach)
+        {
+            char s[LUAI_MAXNUM2STR * LUA_VECTOR_SIZE];
+            char* e = s;
+            for (int i = 0; i < LUA_VECTOR_SIZE; ++i)
+            {
+                if (i != 0)
+                {
+                    *e++ = ',';
+                    *e++ = ' ';
+                }
+                e = luai_num2str(e, v[i]);
+            }
+            lua_pushlstring(L, s, e - s);
+        }
+        else
+        {
 #if LUA_VECTOR_SIZE == 4
-        lua_pushfstring(L, LUA_NUMBER_FMT ", " LUA_NUMBER_FMT ", " LUA_NUMBER_FMT ", " LUA_NUMBER_FMT, v[0], v[1], v[2], v[3]);
+            lua_pushfstring(L, LUA_NUMBER_FMT ", " LUA_NUMBER_FMT ", " LUA_NUMBER_FMT ", " LUA_NUMBER_FMT, v[0], v[1], v[2], v[3]);
 #else
-        lua_pushfstring(L, LUA_NUMBER_FMT ", " LUA_NUMBER_FMT ", " LUA_NUMBER_FMT, v[0], v[1], v[2]);
+            lua_pushfstring(L, LUA_NUMBER_FMT ", " LUA_NUMBER_FMT ", " LUA_NUMBER_FMT, v[0], v[1], v[2]);
 #endif
+        }
         break;
     }
     default:
diff --git a/VM/src/lbitlib.cpp b/VM/src/lbitlib.cpp
index 8b511edf..093400f2 100644
--- a/VM/src/lbitlib.cpp
+++ b/VM/src/lbitlib.cpp
@@ -5,8 +5,6 @@
 #include "lcommon.h"
 #include "lnumutils.h"
 
-LUAU_FASTFLAGVARIABLE(LuauBit32Count, false)
-
 #define ALLONES ~0u
 #define NBITS int(8 * sizeof(unsigned))
 
@@ -182,9 +180,6 @@ static int b_replace(lua_State* L)
 
 static int b_countlz(lua_State* L)
 {
-    if (!FFlag::LuauBit32Count)
-        luaL_error(L, "bit32.countlz isn't enabled");
-
     b_uint v = luaL_checkunsigned(L, 1);
 
     b_uint r = NBITS;
@@ -201,9 +196,6 @@ static int b_countlz(lua_State* L)
 
 static int b_countrz(lua_State* L)
 {
-    if (!FFlag::LuauBit32Count)
-        luaL_error(L, "bit32.countrz isn't enabled");
-
     b_uint v = luaL_checkunsigned(L, 1);
 
     b_uint r = NBITS;
diff --git a/VM/src/ldebug.cpp b/VM/src/ldebug.cpp
index 9fe1885f..2b5382bb 100644
--- a/VM/src/ldebug.cpp
+++ b/VM/src/ldebug.cpp
@@ -12,6 +12,9 @@
 #include <string.h>
 #include <stdio.h>
 
+LUAU_FASTFLAG(LuauBytecodeV2Read)
+LUAU_FASTFLAG(LuauBytecodeV2Force)
+
 static const char* getfuncname(Closure* f);
 
 static int currentpc(lua_State* L, CallInfo* ci)
@@ -89,6 +92,16 @@ const char* lua_setlocal(lua_State* L, int level, int n)
     return name;
 }
 
+static int getlinedefined(Proto* p)
+{
+    if (FFlag::LuauBytecodeV2Force)
+        return p->linedefined;
+    else if (FFlag::LuauBytecodeV2Read && p->linedefined >= 0)
+        return p->linedefined;
+    else
+        return luaG_getline(p, 0);
+}
+
 static int auxgetinfo(lua_State* L, const char* what, lua_Debug* ar, Closure* f, CallInfo* ci)
 {
     int status = 1;
@@ -108,7 +121,7 @@ static int auxgetinfo(lua_State* L, const char* what, lua_Debug* ar, Closure* f,
             {
                 ar->source = getstr(f->l.p->source);
                 ar->what = "Lua";
-                ar->linedefined = luaG_getline(f->l.p, 0);
+                ar->linedefined = getlinedefined(f->l.p);
             }
             luaO_chunkid(ar->short_src, ar->source, LUA_IDSIZE);
             break;
@@ -121,7 +134,7 @@ static int auxgetinfo(lua_State* L, const char* what, lua_Debug* ar, Closure* f,
             }
             else
             {
-                ar->currentline = f->isC ? -1 : luaG_getline(f->l.p, 0);
+                ar->currentline = f->isC ? -1 : getlinedefined(f->l.p);
             }
 
             break;
diff --git a/VM/src/ldo.cpp b/VM/src/ldo.cpp
index 43289ab4..eb47971a 100644
--- a/VM/src/ldo.cpp
+++ b/VM/src/ldo.cpp
@@ -19,7 +19,6 @@
 
 LUAU_FASTFLAGVARIABLE(LuauCcallRestoreFix, false)
 LUAU_FASTFLAG(LuauCoroutineClose)
-LUAU_FASTFLAGVARIABLE(LuauActivateBeforeExec, true)
 
 /*
 ** {======================================================
@@ -228,21 +227,14 @@ void luaD_call(lua_State* L, StkId func, int nResults)
     {                                        /* is a Lua function? */
         L->ci->flags |= LUA_CALLINFO_RETURN; /* luau_execute will stop after returning from the stack frame */
 
-        if (FFlag::LuauActivateBeforeExec)
-        {
-            int oldactive = luaC_threadactive(L);
-            l_setbit(L->stackstate, THREAD_ACTIVEBIT);
-            luaC_checkthreadsleep(L);
+        int oldactive = luaC_threadactive(L);
+        l_setbit(L->stackstate, THREAD_ACTIVEBIT);
+        luaC_checkthreadsleep(L);
 
-            luau_execute(L); /* call it */
+        luau_execute(L); /* call it */
 
-            if (!oldactive)
-                resetbit(L->stackstate, THREAD_ACTIVEBIT);
-        }
-        else
-        {
-            luau_execute(L); /* call it */
-        }
+        if (!oldactive)
+            resetbit(L->stackstate, THREAD_ACTIVEBIT);
     }
     L->nCcalls--;
     luaC_checkGC(L);
@@ -549,12 +541,9 @@ int luaD_pcall(lua_State* L, Pfunc func, void* u, ptrdiff_t old_top, ptrdiff_t e
                 status = LUA_ERRERR;
         }
 
-        if (FFlag::LuauActivateBeforeExec)
-        {
-            // since the call failed with an error, we might have to reset the 'active' thread state
-            if (!oldactive)
-                resetbit(L->stackstate, THREAD_ACTIVEBIT);
-        }
+        // since the call failed with an error, we might have to reset the 'active' thread state
+        if (!oldactive)
+            resetbit(L->stackstate, THREAD_ACTIVEBIT);
 
         if (FFlag::LuauCcallRestoreFix)
         {
diff --git a/VM/src/lgc.cpp b/VM/src/lgc.cpp
index 7393fc74..76ef7a06 100644
--- a/VM/src/lgc.cpp
+++ b/VM/src/lgc.cpp
@@ -12,8 +12,6 @@
 
 #include <string.h>
 
-LUAU_FASTFLAG(LuauArrayBoundary)
-
 #define GC_SWEEPMAX 40
 #define GC_SWEEPCOST 10
 
diff --git a/VM/src/lgcdebug.cpp b/VM/src/lgcdebug.cpp
index f6f7a878..c66de9c1 100644
--- a/VM/src/lgcdebug.cpp
+++ b/VM/src/lgcdebug.cpp
@@ -12,8 +12,6 @@
 #include <string.h>
 #include <stdio.h>
 
-LUAU_FASTFLAG(LuauArrayBoundary)
-
 static void validateobjref(global_State* g, GCObject* f, GCObject* t)
 {
     LUAU_ASSERT(!isdead(g, t));
@@ -38,10 +36,7 @@ static void validatetable(global_State* g, Table* h)
 {
     int sizenode = 1 << h->lsizenode;
 
-    if (FFlag::LuauArrayBoundary)
-        LUAU_ASSERT(h->lastfree <= sizenode);
-    else
-        LUAU_ASSERT(h->lastfree >= 0 && h->lastfree <= sizenode);
+    LUAU_ASSERT(h->lastfree <= sizenode);
 
     if (h->metatable)
         validateobjref(g, obj2gco(h), obj2gco(h->metatable));
diff --git a/VM/src/lnumprint.cpp b/VM/src/lnumprint.cpp
new file mode 100644
index 00000000..2fd0f1bb
--- /dev/null
+++ b/VM/src/lnumprint.cpp
@@ -0,0 +1,375 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+// This code is based on Lua 5.x implementation licensed under MIT License; see lua_LICENSE.txt for details
+#include "luaconf.h"
+#include "lnumutils.h"
+
+#include "lcommon.h"
+
+#include <string.h>
+#include <stdio.h> // TODO: Remove with LuauSchubfach
+
+#ifdef _MSC_VER
+#include <intrin.h>
+#endif
+
+// This work is based on:
+// Raffaello Giulietti. The Schubfach way to render doubles. 2021
+// https://drive.google.com/file/d/1IEeATSVnEE6TkrHlCYNY2GjaraBjOT4f/edit
+
+// The code uses the notation from the paper for local variables where appropriate, and refers to paper sections/figures/results.
+
+LUAU_FASTFLAGVARIABLE(LuauSchubfach, false)
+
+// 9.8.2. Precomputed table for 128-bit overestimates of powers of 10 (see figure 3 for table bounds)
+// To avoid storing 616 128-bit numbers directly we use a technique inspired by Dragonbox implementation and store 16 consecutive
+// powers using a 128-bit baseline and a bitvector with 1-bit scale and 3-bit offset for the delta between each entry and base*5^k
+static const int kPow10TableMin = -292;
+static const int kPow10TableMax = 324;
+
+// clang-format off
+static const uint64_t kPow5Table[16] = {
+    0x8000000000000000, 0xa000000000000000, 0xc800000000000000, 0xfa00000000000000, 0x9c40000000000000, 0xc350000000000000,
+    0xf424000000000000, 0x9896800000000000, 0xbebc200000000000, 0xee6b280000000000, 0x9502f90000000000, 0xba43b74000000000,
+    0xe8d4a51000000000, 0x9184e72a00000000, 0xb5e620f480000000, 0xe35fa931a0000000,
+};
+static const uint64_t kPow10Table[(kPow10TableMax - kPow10TableMin + 1 + 15) / 16][3] = {
+    {0xff77b1fcbebcdc4f, 0x25e8e89c13bb0f7b, 0x333443443333443b}, {0x8dd01fad907ffc3b, 0xae3da7d97f6792e4, 0xbbb3ab3cb3ba3cbc},
+    {0x9d71ac8fada6c9b5, 0x6f773fc3603db4aa, 0x4ba4bc4bb4bb4bcc}, {0xaecc49914078536d, 0x58fae9f773886e19, 0x3ba3bc33b43b43bb},
+    {0xc21094364dfb5636, 0x985915fc12f542e5, 0x33b43b43a33b33cb}, {0xd77485cb25823ac7, 0x7d633293366b828c, 0x34b44c444343443c},
+    {0xef340a98172aace4, 0x86fb897116c87c35, 0x333343333343334b}, {0x84c8d4dfd2c63f3b, 0x29ecd9f40041e074, 0xccaccbbcbcbb4bbc},
+    {0x936b9fcebb25c995, 0xcab10dd900beec35, 0x3ab3ab3ab3bb3bbb}, {0xa3ab66580d5fdaf5, 0xc13e60d0d2e0ebbb, 0x4cc3dc4db4db4dbb},
+    {0xb5b5ada8aaff80b8, 0x0d819992132456bb, 0x33b33a34c33b34ab}, {0xc9bcff6034c13052, 0xfc89b393dd02f0b6, 0x33c33b44b43c34bc},
+    {0xdff9772470297ebd, 0x59787e2b93bc56f8, 0x43b444444443434c}, {0xf8a95fcf88747d94, 0x75a44c6397ce912b, 0x443334343443343b},
+    {0x8a08f0f8bf0f156b, 0x1b8e9ecb641b5900, 0xbbabab3aa3ab4ccc}, {0x993fe2c6d07b7fab, 0xe546a8038efe402a, 0x4cb4bc4db4db4bcc},
+    {0xaa242499697392d2, 0xdde50bd1d5d0b9ea, 0x3ba3ba3bb33b33bc}, {0xbce5086492111aea, 0x88f4bb1ca6bcf585, 0x44b44c44c44c43cb},
+    {0xd1b71758e219652b, 0xd3c36113404ea4a9, 0x44c44c44c444443b}, {0xe8d4a51000000000, 0x0000000000000000, 0x444444444444444c},
+    {0x813f3978f8940984, 0x4000000000000000, 0xcccccccccccccccc}, {0x8f7e32ce7bea5c6f, 0xe4820023a2000000, 0xbba3bc4cc4cc4ccc},
+    {0x9f4f2726179a2245, 0x01d762422c946591, 0x4aa3bb3aa3ba3bab}, {0xb0de65388cc8ada8, 0x3b25a55f43294bcc, 0x3ca33b33b44b43bc},
+    {0xc45d1df942711d9a, 0x3ba5d0bd324f8395, 0x44c44c34c44b44cb}, {0xda01ee641a708de9, 0xe80e6f4820cc9496, 0x33b33b343333333c},
+    {0xf209787bb47d6b84, 0xc0678c5dbd23a49b, 0x443444444443443b}, {0x865b86925b9bc5c2, 0x0b8a2392ba45a9b3, 0xdbccbcccb4cb3bbb},
+    {0x952ab45cfa97a0b2, 0xdd945a747bf26184, 0x3bc4bb4ab3ca3cbc}, {0xa59bc234db398c25, 0x43fab9837e699096, 0x3bb3ac3ab3bb33ac},
+    {0xb7dcbf5354e9bece, 0x0c11ed6d538aeb30, 0x33b43b43b34c34dc}, {0xcc20ce9bd35c78a5, 0x31ec038df7b441f5, 0x34c44c43c44b44cb},
+    {0xe2a0b5dc971f303a, 0x2e44ae64840fd61e, 0x333333333333333c}, {0xfb9b7cd9a4a7443c, 0x169840ef017da3b2, 0x433344443333344c},
+    {0x8bab8eefb6409c1a, 0x1ad089b6c2f7548f, 0xdcbdcc3cc4cc4bcb}, {0x9b10a4e5e9913128, 0xca7cf2b4191c8327, 0x3ab3cb3bc3bb4bbb},
+    {0xac2820d9623bf429, 0x546345fa9fbdcd45, 0x3bb3cc43c43c43cb}, {0xbf21e44003acdd2c, 0xe0470a63e6bd56c4, 0x44b34a43b44c44bc},
+    {0xd433179d9c8cb841, 0x5fa60692a46151ec, 0x43a33a33a333333c},
+};
+// clang-format on
+
+static const char kDigitTable[] = "0001020304050607080910111213141516171819202122232425262728293031323334353637383940414243444546474849"
+                                  "5051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899";
+
+// x*y => 128-bit product (lo+hi)
+inline uint64_t mul128(uint64_t x, uint64_t y, uint64_t* hi)
+{
+#if defined(_MSC_VER) && defined(_M_X64)
+    return _umul128(x, y, hi);
+#elif defined(__SIZEOF_INT128__)
+    unsigned __int128 r = x;
+    r *= y;
+    *hi = uint64_t(r >> 64);
+    return uint64_t(r);
+#else
+    uint32_t x0 = uint32_t(x), x1 = uint32_t(x >> 32);
+    uint32_t y0 = uint32_t(y), y1 = uint32_t(y >> 32);
+    uint64_t p11 = uint64_t(x1) * y1, p01 = uint64_t(x0) * y1;
+    uint64_t p10 = uint64_t(x1) * y0, p00 = uint64_t(x0) * y0;
+    uint64_t mid = p10 + (p00 >> 32) + uint32_t(p01);
+    uint64_t r0 = (mid << 32) | uint32_t(p00);
+    uint64_t r1 = p11 + (mid >> 32) + (p01 >> 32);
+    *hi = r1;
+    return r0;
+#endif
+}
+
+// (x*y)>>64 => 128-bit product (lo+hi)
+inline uint64_t mul192hi(uint64_t xhi, uint64_t xlo, uint64_t y, uint64_t* hi)
+{
+    uint64_t z2;
+    uint64_t z1 = mul128(xhi, y, &z2);
+
+    uint64_t z1c;
+    uint64_t z0 = mul128(xlo, y, &z1c);
+    (void)z0;
+
+    z1 += z1c;
+    z2 += (z1 < z1c);
+
+    *hi = z2;
+    return z1;
+}
+
+// 9.3. Rounding to odd (+ figure 8 + result 23)
+inline uint64_t roundodd(uint64_t ghi, uint64_t glo, uint64_t cp)
+{
+    uint64_t xhi;
+    uint64_t xlo = mul128(glo, cp, &xhi);
+    (void)xlo;
+
+    uint64_t yhi;
+    uint64_t ylo = mul128(ghi, cp, &yhi);
+
+    uint64_t z = ylo + xhi;
+    return (yhi + (z < xhi)) | (z > 1);
+}
+
+struct Decimal
+{
+    uint64_t s;
+    int k;
+};
+
+static Decimal schubfach(int exponent, uint64_t fraction)
+{
+    // Extract c & q such that c*2^q == |v|
+    uint64_t c = fraction;
+    int q = exponent - 1023 - 51;
+
+    if (exponent != 0) // normal numbers have implicit leading 1
+    {
+        c |= (1ull << 52);
+        q--;
+    }
+
+    // 8.3. Fast path for integers
+    if (unsigned(-q) < 53 && (c & ((1ull << (-q)) - 1)) == 0)
+        return {c >> (-q), 0};
+
+    // 5. Rounding interval
+    int irr = (c == (1ull << 52) && q != -1074); // Qmin
+    int out = int(c & 1);
+
+    // 9.8.1. Boundaries for c
+    uint64_t cbl = 4 * c - 2 + irr;
+    uint64_t cb = 4 * c;
+    uint64_t cbr = 4 * c + 2;
+
+    // 9.1. Computing k and h
+    const int Q = 20;
+    const int C = 315652;   // floor(2^Q * log10(2))
+    const int A = -131008;  // floor(2^Q * log10(3/4))
+    const int C2 = 3483294; // floor(2^Q * log2(10))
+    int k = (q * C + (irr ? A : 0)) >> Q;
+    int h = q + ((-k * C2) >> Q) + 1; // see (9) in 9.9
+
+    // 9.8.2. Overestimates of powers of 10
+    // Recover 10^-k fraction using compact tables generated by tools/numutils.py
+    // The 128-bit fraction is encoded as 128-bit baseline * power-of-5 * scale + offset
+    LUAU_ASSERT(-k >= kPow10TableMin && -k <= kPow10TableMax);
+    int gtoff = -k - kPow10TableMin;
+    const uint64_t* gt = kPow10Table[gtoff >> 4];
+
+    uint64_t ghi;
+    uint64_t glo = mul192hi(gt[0], gt[1], kPow5Table[gtoff & 15], &ghi);
+
+    // Apply 1-bit scale + 3-bit offset; note, offset is intentionally applied without carry, numutils.py validates that this is sufficient
+    int gterr = (gt[2] >> ((gtoff & 15) * 4)) & 15;
+    int gtscale = gterr >> 3;
+
+    ghi <<= gtscale;
+    ghi += (glo >> 63) & gtscale;
+    glo <<= gtscale;
+    glo -= (gterr & 7) - 4;
+
+    // 9.9. Boundaries for v
+    uint64_t vbl = roundodd(ghi, glo, cbl << h);
+    uint64_t vb = roundodd(ghi, glo, cb << h);
+    uint64_t vbr = roundodd(ghi, glo, cbr << h);
+
+    // Main algorithm; see figure 7 + figure 9
+    uint64_t s = vb / 4;
+
+    if (s >= 10)
+    {
+        uint64_t sp = s / 10;
+
+        bool upin = vbl + out <= 40 * sp;
+        bool wpin = vbr >= 40 * sp + 40 + out;
+
+        if (upin != wpin)
+            return {sp + wpin, k + 1};
+    }
+
+    // Figure 7 contains the algorithm to select between u (s) and w (s+1)
+    // rup computes the last 4 conditions in that algorithm
+    // rup is only used when uin == win, but since these branches predict poorly we use branchless selects
+    bool uin = vbl + out <= 4 * s;
+    bool win = 4 * s + 4 + out <= vbr;
+    bool rup = vb >= 4 * s + 2 + 1 - (s & 1);
+
+    return {s + (uin != win ? win : rup), k};
+}
+
+static char* printspecial(char* buf, int sign, uint64_t fraction)
+{
+    if (fraction == 0)
+    {
+        memcpy(buf, ("-inf") + (1 - sign), 4);
+        return buf + 3 + sign;
+    }
+    else
+    {
+        memcpy(buf, "nan", 4);
+        return buf + 3;
+    }
+}
+
+static char* printunsignedrev(char* end, uint64_t num)
+{
+    while (num >= 10000)
+    {
+        unsigned int tail = unsigned(num % 10000);
+
+        memcpy(end - 4, &kDigitTable[int(tail / 100) * 2], 2);
+        memcpy(end - 2, &kDigitTable[int(tail % 100) * 2], 2);
+        num /= 10000;
+        end -= 4;
+    }
+
+    unsigned int rest = unsigned(num);
+
+    while (rest >= 10)
+    {
+        memcpy(end - 2, &kDigitTable[int(rest % 100) * 2], 2);
+        rest /= 100;
+        end -= 2;
+    }
+
+    if (rest)
+    {
+        end[-1] = '0' + int(rest);
+        end -= 1;
+    }
+
+    return end;
+}
+
+static char* printexp(char* buf, int num)
+{
+    *buf++ = 'e';
+    *buf++ = num < 0 ? '-' : '+';
+
+    int v = num < 0 ? -num : num;
+
+    if (v >= 100)
+    {
+        *buf++ = '0' + (v / 100);
+        v %= 100;
+    }
+
+    memcpy(buf, &kDigitTable[v * 2], 2);
+    return buf + 2;
+}
+
+inline char* trimzero(char* end)
+{
+    while (end[-1] == '0')
+        end--;
+
+    return end;
+}
+
+// We use fixed-length memcpy/memset since they lower to fast SIMD+scalar writes; the target buffers should have padding space
+#define fastmemcpy(dst, src, size, sizefast) check_exp((size) <= sizefast, memcpy(dst, src, sizefast))
+#define fastmemset(dst, val, size, sizefast) check_exp((size) <= sizefast, memset(dst, val, sizefast))
+
+char* luai_num2str(char* buf, double n)
+{
+    if (!FFlag::LuauSchubfach)
+    {
+        snprintf(buf, LUAI_MAXNUM2STR, LUA_NUMBER_FMT, n);
+        return buf + strlen(buf);
+    }
+
+    // IEEE-754
+    union
+    {
+        double v;
+        uint64_t bits;
+    } v = {n};
+    int sign = int(v.bits >> 63);
+    int exponent = int(v.bits >> 52) & 2047;
+    uint64_t fraction = v.bits & ((1ull << 52) - 1);
+
+    // specials
+    if (LUAU_UNLIKELY(exponent == 0x7ff))
+        return printspecial(buf, sign, fraction);
+
+    // sign bit
+    *buf = '-';
+    buf += sign;
+
+    // zero
+    if (exponent == 0 && fraction == 0)
+    {
+        buf[0] = '0';
+        return buf + 1;
+    }
+
+    // convert binary to decimal using Schubfach
+    Decimal d = schubfach(exponent, fraction);
+    LUAU_ASSERT(d.s < uint64_t(1e17));
+
+    // print the decimal to a temporary buffer; we'll need to insert the decimal point and figure out the format
+    char decbuf[40];
+    char* decend = decbuf + 20; // significand needs at most 17 digits; the rest of the buffer may be copied using fixed length memcpy
+    char* dec = printunsignedrev(decend, d.s);
+
+    int declen = int(decend - dec);
+    LUAU_ASSERT(declen <= 17);
+
+    int dot = declen + d.k;
+
+    // the limits are somewhat arbitrary but changing them may require changing fastmemset/fastmemcpy sizes below
+    if (dot >= -5 && dot <= 21)
+    {
+        // fixed point format
+        if (dot <= 0)
+        {
+            buf[0] = '0';
+            buf[1] = '.';
+
+            fastmemset(buf + 2, '0', -dot, 5);
+            fastmemcpy(buf + 2 + (-dot), dec, declen, 17);
+
+            return trimzero(buf + 2 + (-dot) + declen);
+        }
+        else if (dot == declen)
+        {
+            // no dot
+            fastmemcpy(buf, dec, dot, 17);
+
+            return buf + dot;
+        }
+        else if (dot < declen)
+        {
+            // dot in the middle
+            fastmemcpy(buf, dec, dot, 16);
+
+            buf[dot] = '.';
+
+            fastmemcpy(buf + dot + 1, dec + dot, declen - dot, 16);
+
+            return trimzero(buf + declen + 1);
+        }
+        else
+        {
+            // no dot, zero padding
+            fastmemcpy(buf, dec, declen, 17);
+            fastmemset(buf + declen, '0', dot - declen, 8);
+
+            return buf + dot;
+        }
+    }
+    else
+    {
+        // scientific format
+        buf[0] = dec[0];
+        buf[1] = '.';
+        fastmemcpy(buf + 2, dec + 1, declen - 1, 16);
+
+        char* exp = trimzero(buf + declen + 1);
+
+        return printexp(exp, dot - 1);
+    }
+}
diff --git a/VM/src/lnumutils.h b/VM/src/lnumutils.h
index 67f832dc..fba07bc3 100644
--- a/VM/src/lnumutils.h
+++ b/VM/src/lnumutils.h
@@ -3,7 +3,6 @@
 #pragma once
 
 #include <math.h>
-#include <stdio.h>
 
 #define luai_numadd(a, b) ((a) + (b))
 #define luai_numsub(a, b) ((a) - (b))
@@ -56,5 +55,9 @@ LUAU_FASTMATH_END
 #define luai_num2unsigned(i, n) ((i) = (unsigned)(long long)(n))
 #endif
 
-#define luai_num2str(s, n) snprintf((s), sizeof(s), LUA_NUMBER_FMT, (n))
+#define LUA_NUMBER_FMT "%.14g" /* TODO: Remove with LuauSchubfach */
+#define LUAI_MAXNUM2STR 48
+
+LUAI_FUNC char* luai_num2str(char* buf, double n);
+
 #define luai_str2num(s, p) strtod((s), (p))
diff --git a/VM/src/lobject.h b/VM/src/lobject.h
index fd0a15b7..b642cf78 100644
--- a/VM/src/lobject.h
+++ b/VM/src/lobject.h
@@ -289,6 +289,7 @@ typedef struct Proto
     int sizek;
     int sizelineinfo;
     int linegaplog2;
+    int linedefined;
 
 
     uint8_t nups; /* number of upvalues */
diff --git a/VM/src/ltable.cpp b/VM/src/ltable.cpp
index 0b55fcea..83b59f3f 100644
--- a/VM/src/ltable.cpp
+++ b/VM/src/ltable.cpp
@@ -24,8 +24,6 @@
 
 #include <string.h>
 
-LUAU_FASTFLAGVARIABLE(LuauArrayBoundary, false)
-
 // max size of both array and hash part is 2^MAXBITS
 #define MAXBITS 26
 #define MAXSIZE (1 << MAXBITS)
@@ -222,7 +220,7 @@ int luaH_next(lua_State* L, Table* t, StkId key)
 
 #define maybesetaboundary(t, boundary) \
     { \
-        if (FFlag::LuauArrayBoundary && t->aboundary <= 0) \
+        if (t->aboundary <= 0) \
             t->aboundary = -int(boundary); \
     }
 
@@ -705,7 +703,7 @@ int luaH_getn(Table* t)
 {
     int boundary = getaboundary(t);
 
-    if (FFlag::LuauArrayBoundary && boundary > 0)
+    if (boundary > 0)
     {
         if (!ttisnil(&t->array[t->sizearray - 1]) && t->node == dummynode)
             return t->sizearray; /* fast-path: the end of the array in `t' already refers to a boundary */
diff --git a/VM/src/lvmload.cpp b/VM/src/lvmload.cpp
index add3588d..7839c68c 100644
--- a/VM/src/lvmload.cpp
+++ b/VM/src/lvmload.cpp
@@ -13,6 +13,9 @@
 
 #include <string.h>
 
+LUAU_FASTFLAGVARIABLE(LuauBytecodeV2Read, true)
+LUAU_FASTFLAGVARIABLE(LuauBytecodeV2Force, false)
+
 // TODO: RAII deallocation doesn't work for longjmp builds if a memory error happens
 template<typename T>
 struct TempBuffer
@@ -146,15 +149,19 @@ int luau_load(lua_State* L, const char* chunkname, const char* data, size_t size
     uint8_t version = read<uint8_t>(data, size, offset);
 
     // 0 means the rest of the bytecode is the error message
-    if (version == 0 || version != LBC_VERSION)
+    if (version == 0)
     {
         char chunkid[LUA_IDSIZE];
         luaO_chunkid(chunkid, chunkname, LUA_IDSIZE);
+        lua_pushfstring(L, "%s%.*s", chunkid, int(size - offset), data + offset);
+        return 1;
+    }
 
-        if (version == 0)
-            lua_pushfstring(L, "%s%.*s", chunkid, int(size - offset), data + offset);
-        else
-            lua_pushfstring(L, "%s: bytecode version mismatch", chunkid);
+    if (FFlag::LuauBytecodeV2Force ? (version != LBC_VERSION_FUTURE) : FFlag::LuauBytecodeV2Read ? (version != LBC_VERSION && version != LBC_VERSION_FUTURE) : (version != LBC_VERSION))
+    {
+        char chunkid[LUA_IDSIZE];
+        luaO_chunkid(chunkid, chunkname, LUA_IDSIZE);
+        lua_pushfstring(L, "%s: bytecode version mismatch (expected %d, got %d)", chunkid, FFlag::LuauBytecodeV2Force ? LBC_VERSION_FUTURE : LBC_VERSION, version);
         return 1;
     }
 
@@ -285,6 +292,11 @@ int luau_load(lua_State* L, const char* chunkname, const char* data, size_t size
             p->p[j] = protos[fid];
         }
 
+        if (FFlag::LuauBytecodeV2Force || (FFlag::LuauBytecodeV2Read && version == LBC_VERSION_FUTURE))
+            p->linedefined = readVarInt(data, size, offset);
+        else
+            p->linedefined = -1;
+
         p->debugname = readString(strings, data, size, offset);
 
         uint8_t lineinfo = read<uint8_t>(data, size, offset);
@@ -307,11 +319,11 @@ int luau_load(lua_State* L, const char* chunkname, const char* data, size_t size
                 p->lineinfo[j] = lastoffset;
             }
 
-            int lastLine = 0;
+            int lastline = 0;
             for (int j = 0; j < intervals; ++j)
             {
-                lastLine += read<int32_t>(data, size, offset);
-                p->abslineinfo[j] = lastLine;
+                lastline += read<int32_t>(data, size, offset);
+                p->abslineinfo[j] = lastline;
             }
         }
 
diff --git a/VM/src/lvmutils.cpp b/VM/src/lvmutils.cpp
index 5d802277..31dd59c8 100644
--- a/VM/src/lvmutils.cpp
+++ b/VM/src/lvmutils.cpp
@@ -34,10 +34,11 @@ int luaV_tostring(lua_State* L, StkId obj)
         return 0;
     else
     {
-        char s[LUAI_MAXNUMBER2STR];
+        char s[LUAI_MAXNUM2STR];
         double n = nvalue(obj);
-        luai_num2str(s, n);
-        setsvalue2s(L, obj, luaS_new(L, s));
+        char* e = luai_num2str(s, n);
+        LUAU_ASSERT(e < s + sizeof(s));
+        setsvalue2s(L, obj, luaS_newlstr(L, s, e - s));
         return 1;
     }
 }
diff --git a/fuzz/number.cpp b/fuzz/number.cpp
new file mode 100644
index 00000000..70447409
--- /dev/null
+++ b/fuzz/number.cpp
@@ -0,0 +1,35 @@
+// This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+#include "Luau/Common.h"
+
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+#include <stdlib.h>
+
+LUAU_FASTFLAG(LuauSchubfach);
+
+#define LUAI_MAXNUM2STR 48
+
+char* luai_num2str(char* buf, double n);
+
+extern "C" int LLVMFuzzerTestOneInput(const uint8_t* Data, size_t Size)
+{
+    if (Size < 8)
+        return 0;
+
+    FFlag::LuauSchubfach.value = true;
+
+    double num;
+    memcpy(&num, Data, 8);
+
+    char buf[LUAI_MAXNUM2STR];
+    char* end = luai_num2str(buf, num);
+    LUAU_ASSERT(end < buf + sizeof(buf));
+
+    *end = 0;
+
+    double rec = strtod(buf, nullptr);
+
+    LUAU_ASSERT(rec == num || (rec != rec && num != num));
+    return 0;
+}
diff --git a/tests/AstQuery.test.cpp b/tests/AstQuery.test.cpp
index 2090b014..41b553b5 100644
--- a/tests/AstQuery.test.cpp
+++ b/tests/AstQuery.test.cpp
@@ -83,8 +83,6 @@ TEST_SUITE_BEGIN("AstQuery");
 
 TEST_CASE_FIXTURE(Fixture, "last_argument_function_call_type")
 {
-    ScopedFastFlag luauTailArgumentTypeInfo{"LuauTailArgumentTypeInfo", true};
-
     check(R"(
 local function foo() return 2 end
 local function bar(a: number) return -a end
diff --git a/tests/Autocomplete.test.cpp b/tests/Autocomplete.test.cpp
index 8ca09c0e..210db7ee 100644
--- a/tests/Autocomplete.test.cpp
+++ b/tests/Autocomplete.test.cpp
@@ -15,6 +15,7 @@
 
 LUAU_FASTFLAG(LuauTraceTypesInNonstrictMode2)
 LUAU_FASTFLAG(LuauSetMetatableDoesNotTimeTravel)
+LUAU_FASTFLAG(LuauUseCommittingTxnLog)
 
 using namespace Luau;
 
@@ -1911,11 +1912,14 @@ local bar: @1= foo
     CHECK(!ac.entryMap.count("foo"));
 }
 
-TEST_CASE_FIXTURE(ACFixture, "type_correct_function_no_parenthesis")
+// Switch back to TEST_CASE_FIXTURE with regular ACFixture when removing the
+// LuauUseCommittingTxnLog flag.
+TEST_CASE("type_correct_function_no_parenthesis")
 {
-    ScopedFastFlag luauAutocompleteAvoidMutation("LuauAutocompleteAvoidMutation", true);
+    ScopedFastFlag sff_LuauUseCommittingTxnLog = ScopedFastFlag("LuauUseCommittingTxnLog", true);
+    ACFixture fix;
 
-    check(R"(
+    fix.check(R"(
 local function target(a: (number) -> number) return a(4) end
 local function bar1(a: number) return -a end
 local function bar2(a: string) return a .. 'x' end
@@ -1923,7 +1927,7 @@ local function bar2(a: string) return a .. 'x' end
 return target(b@1
     )");
 
-    auto ac = autocomplete('1');
+    auto ac = fix.autocomplete('1');
 
     CHECK(ac.entryMap.count("bar1"));
     CHECK(ac.entryMap["bar1"].typeCorrect == TypeCorrectKind::Correct);
@@ -1976,11 +1980,14 @@ local fp: @1= f
     CHECK(ac.entryMap.count("({ x: number, y: number }) -> number"));
 }
 
-TEST_CASE_FIXTURE(ACFixture, "type_correct_keywords")
+// Switch back to TEST_CASE_FIXTURE with regular ACFixture when removing the
+// LuauUseCommittingTxnLog flag.
+TEST_CASE("type_correct_keywords")
 {
-    ScopedFastFlag luauAutocompleteAvoidMutation("LuauAutocompleteAvoidMutation", true);
+    ScopedFastFlag sff_LuauUseCommittingTxnLog = ScopedFastFlag("LuauUseCommittingTxnLog", true);
+    ACFixture fix;
 
-    check(R"(
+    fix.check(R"(
 local function a(x: boolean) end
 local function b(x: number?) end
 local function c(x: (number) -> string) end
@@ -1997,26 +2004,26 @@ local dc = d(f@4)
 local ec = e(f@5)
     )");
 
-    auto ac = autocomplete('1');
+    auto ac = fix.autocomplete('1');
     CHECK(ac.entryMap.count("tru"));
     CHECK(ac.entryMap["tru"].typeCorrect == TypeCorrectKind::None);
     CHECK(ac.entryMap["true"].typeCorrect == TypeCorrectKind::Correct);
     CHECK(ac.entryMap["false"].typeCorrect == TypeCorrectKind::Correct);
 
-    ac = autocomplete('2');
+    ac = fix.autocomplete('2');
     CHECK(ac.entryMap.count("ni"));
     CHECK(ac.entryMap["ni"].typeCorrect == TypeCorrectKind::None);
     CHECK(ac.entryMap["nil"].typeCorrect == TypeCorrectKind::Correct);
 
-    ac = autocomplete('3');
+    ac = fix.autocomplete('3');
     CHECK(ac.entryMap.count("false"));
     CHECK(ac.entryMap["false"].typeCorrect == TypeCorrectKind::None);
     CHECK(ac.entryMap["function"].typeCorrect == TypeCorrectKind::Correct);
 
-    ac = autocomplete('4');
+    ac = fix.autocomplete('4');
     CHECK(ac.entryMap["function"].typeCorrect == TypeCorrectKind::Correct);
 
-    ac = autocomplete('5');
+    ac = fix.autocomplete('5');
     CHECK(ac.entryMap["function"].typeCorrect == TypeCorrectKind::Correct);
 }
 
@@ -2507,21 +2514,23 @@ local t = {
     CHECK(ac.entryMap.count("second"));
 }
 
-TEST_CASE_FIXTURE(UnfrozenFixture, "autocomplete_documentation_symbols")
+TEST_CASE("autocomplete_documentation_symbols")
 {
-    loadDefinition(R"(
+    Fixture fix(FFlag::LuauUseCommittingTxnLog);
+
+    fix.loadDefinition(R"(
         declare y: {
             x: number,
         }
     )");
 
-    fileResolver.source["Module/A"] = R"(
+    fix.fileResolver.source["Module/A"] = R"(
         local a = y.
     )";
 
-    frontend.check("Module/A");
+    fix.frontend.check("Module/A");
 
-    auto ac = autocomplete(frontend, "Module/A", Position{1, 21}, nullCallback);
+    auto ac = autocomplete(fix.frontend, "Module/A", Position{1, 21}, nullCallback);
 
     REQUIRE(ac.entryMap.count("x"));
     CHECK_EQ(ac.entryMap["x"].documentationSymbol, "@test/global/y.x");
diff --git a/tests/Conformance.test.cpp b/tests/Conformance.test.cpp
index b055a38e..663b329e 100644
--- a/tests/Conformance.test.cpp
+++ b/tests/Conformance.test.cpp
@@ -13,8 +13,11 @@
 #include "ScopedFlags.h"
 
 #include <fstream>
+#include <vector>
 #include <math.h>
 
+extern bool verbose;
+
 static int lua_collectgarbage(lua_State* L)
 {
     static const char* const opts[] = {"stop", "restart", "collect", "count", "isrunning", "step", "setgoal", "setstepmul", "setstepsize", nullptr};
@@ -146,15 +149,21 @@ static StateRef runConformance(const char* name, void (*setup)(lua_State* L) = n
     luaL_openlibs(L);
 
     // Register a few global functions for conformance tests
-    static const luaL_Reg funcs[] = {
+    std::vector<luaL_Reg> funcs = {
         {"collectgarbage", lua_collectgarbage},
         {"loadstring", lua_loadstring},
-        {"print", lua_silence}, // Disable print() by default; comment this out to enable debug prints in tests
-        {nullptr, nullptr},
     };
 
+    if (!verbose)
+    {
+        funcs.push_back({"print", lua_silence});
+    }
+
+    // "null" terminate the list of functions to register
+    funcs.push_back({nullptr, nullptr});
+
     lua_pushvalue(L, LUA_GLOBALSINDEX);
-    luaL_register(L, nullptr, funcs);
+    luaL_register(L, nullptr, funcs.data());
     lua_pop(L, 1);
 
     // In some configurations we have a larger C stack consumption which trips some conformance tests
@@ -312,8 +321,6 @@ TEST_CASE("GC")
 
 TEST_CASE("Bitwise")
 {
-    ScopedFastFlag sff("LuauBit32Count", true);
-
     runConformance("bitwise.lua");
 }
 
@@ -491,6 +498,9 @@ TEST_CASE("DateTime")
 
 TEST_CASE("Debug")
 {
+    ScopedFastFlag sffr("LuauBytecodeV2Read", true);
+    ScopedFastFlag sffw("LuauBytecodeV2Write", true);
+
     runConformance("debug.lua");
 }
 
@@ -738,8 +748,6 @@ TEST_CASE("ApiFunctionCalls")
 
     // lua_equal with a sleeping thread wake up
     {
-        ScopedFastFlag luauActivateBeforeExec("LuauActivateBeforeExec", true);
-
         lua_State* L2 = lua_newthread(L);
 
         lua_getfield(L2, LUA_GLOBALSINDEX, "create_with_tm");
@@ -913,4 +921,11 @@ TEST_CASE("Coverage")
         nullptr, nullptr, &copts);
 }
 
+TEST_CASE("StringConversion")
+{
+    ScopedFastFlag sff{"LuauSchubfach", true};
+
+    runConformance("strconv.lua");
+}
+
 TEST_SUITE_END();
diff --git a/tests/Fixture.cpp b/tests/Fixture.cpp
index 36d6f561..ca4281a0 100644
--- a/tests/Fixture.cpp
+++ b/tests/Fixture.cpp
@@ -103,11 +103,6 @@ Fixture::~Fixture()
     Luau::resetPrintLine();
 }
 
-UnfrozenFixture::UnfrozenFixture()
-    : Fixture(false)
-{
-}
-
 AstStatBlock* Fixture::parse(const std::string& source, const ParseOptions& parseOptions)
 {
     sourceModule.reset(new SourceModule);
diff --git a/tests/Fixture.h b/tests/Fixture.h
index de2b7381..e01632ea 100644
--- a/tests/Fixture.h
+++ b/tests/Fixture.h
@@ -152,15 +152,6 @@ struct Fixture
     LoadDefinitionFileResult loadDefinition(const std::string& source);
 };
 
-// Disables arena freezing for a given test case.
-// Do not use this in new tests. If you are running into access violations, you
-// are violating Luau's memory model - the fix is not to use UnfrozenFixture.
-// Related: CLI-45692
-struct UnfrozenFixture : Fixture
-{
-    UnfrozenFixture();
-};
-
 ModuleName fromString(std::string_view name);
 
 template<typename T>
diff --git a/tests/Frontend.test.cpp b/tests/Frontend.test.cpp
index 51fcd3d6..405f26e0 100644
--- a/tests/Frontend.test.cpp
+++ b/tests/Frontend.test.cpp
@@ -914,6 +914,8 @@ TEST_CASE_FIXTURE(FrontendFixture, "typecheck_twice_for_ast_types")
 
 TEST_CASE_FIXTURE(FrontendFixture, "imported_table_modification_2")
 {
+    ScopedFastFlag sffs("LuauSealExports", true);
+
     frontend.options.retainFullTypeGraphs = false;
 
     fileResolver.source["Module/A"] = R"(
@@ -927,7 +929,7 @@ return a;
 --!nonstrict
 local a = require(script.Parent.A)
 local b = {}
-function a:b() end -- this should error, but doesn't
+function a:b() end -- this should error, since A doesn't define a:b()
 return b
     )";
 
@@ -942,8 +944,7 @@ a:b() -- this should error, since A doesn't define a:b()
     LUAU_REQUIRE_NO_ERRORS(resultA);
 
     CheckResult resultB = frontend.check("Module/B");
-    // TODO (CLI-45592): this should error, since we shouldn't be adding properties to objects from other modules
-    LUAU_REQUIRE_NO_ERRORS(resultB);
+    LUAU_REQUIRE_ERRORS(resultB);
 
     CheckResult resultC = frontend.check("Module/C");
     LUAU_REQUIRE_ERRORS(resultC);
diff --git a/tests/TypeInfer.annotations.test.cpp b/tests/TypeInfer.annotations.test.cpp
index 71ff4e1b..275782b3 100644
--- a/tests/TypeInfer.annotations.test.cpp
+++ b/tests/TypeInfer.annotations.test.cpp
@@ -620,7 +620,7 @@ struct AssertionCatcher
     {
         tripped = 0;
         oldhook = Luau::assertHandler();
-        Luau::assertHandler() = [](const char* expr, const char* file, int line) -> int {
+        Luau::assertHandler() = [](const char* expr, const char* file, int line, const char* function) -> int {
             ++tripped;
             return 0;
         };
diff --git a/tests/TypeInfer.builtins.test.cpp b/tests/TypeInfer.builtins.test.cpp
index 506279b9..5e08654a 100644
--- a/tests/TypeInfer.builtins.test.cpp
+++ b/tests/TypeInfer.builtins.test.cpp
@@ -11,6 +11,8 @@ LUAU_FASTFLAG(LuauFixTonumberReturnType)
 
 using namespace Luau;
 
+LUAU_FASTFLAG(LuauUseCommittingTxnLog)
+
 TEST_SUITE_BEGIN("BuiltinTests");
 
 TEST_CASE_FIXTURE(Fixture, "math_things_are_defined")
@@ -444,19 +446,28 @@ TEST_CASE_FIXTURE(Fixture, "os_time_takes_optional_date_table")
     CHECK_EQ(*typeChecker.numberType, *requireType("n3"));
 }
 
-TEST_CASE_FIXTURE(Fixture, "thread_is_a_type")
+// Switch back to TEST_CASE_FIXTURE with regular Fixture when removing the
+// LuauUseCommittingTxnLog flag.
+TEST_CASE("thread_is_a_type")
 {
-    CheckResult result = check(R"(
+    Fixture fix(FFlag::LuauUseCommittingTxnLog);
+
+    CheckResult result = fix.check(R"(
         local co = coroutine.create(function() end)
     )");
 
-    LUAU_REQUIRE_NO_ERRORS(result);
-    CHECK_EQ(*typeChecker.threadType, *requireType("co"));
+    // Replace with LUAU_REQUIRE_NO_ERRORS(result) when using TEST_CASE_FIXTURE.
+    CHECK(result.errors.size() == 0);
+    CHECK_EQ(*fix.typeChecker.threadType, *fix.requireType("co"));
 }
 
-TEST_CASE_FIXTURE(Fixture, "coroutine_resume_anything_goes")
+// Switch back to TEST_CASE_FIXTURE with regular Fixture when removing the
+// LuauUseCommittingTxnLog flag.
+TEST_CASE("coroutine_resume_anything_goes")
 {
-    CheckResult result = check(R"(
+    Fixture fix(FFlag::LuauUseCommittingTxnLog);
+
+    CheckResult result = fix.check(R"(
         local function nifty(x, y)
             print(x, y)
             local z = coroutine.yield(1, 2)
@@ -469,12 +480,17 @@ TEST_CASE_FIXTURE(Fixture, "coroutine_resume_anything_goes")
         local answer = coroutine.resume(co, 3)
     )");
 
-    LUAU_REQUIRE_NO_ERRORS(result);
+    // Replace with LUAU_REQUIRE_NO_ERRORS(result) when using TEST_CASE_FIXTURE.
+    CHECK(result.errors.size() == 0);
 }
 
-TEST_CASE_FIXTURE(Fixture, "coroutine_wrap_anything_goes")
+// Switch back to TEST_CASE_FIXTURE with regular Fixture when removing the
+// LuauUseCommittingTxnLog flag.
+TEST_CASE("coroutine_wrap_anything_goes")
 {
-    CheckResult result = check(R"(
+    Fixture fix(FFlag::LuauUseCommittingTxnLog);
+
+    CheckResult result = fix.check(R"(
         --!nonstrict
         local function nifty(x, y)
             print(x, y)
@@ -488,7 +504,8 @@ TEST_CASE_FIXTURE(Fixture, "coroutine_wrap_anything_goes")
         local answer = f(3)
     )");
 
-    LUAU_REQUIRE_NO_ERRORS(result);
+    // Replace with LUAU_REQUIRE_NO_ERRORS(result) when using TEST_CASE_FIXTURE.
+    CHECK(result.errors.size() == 0);
 }
 
 TEST_CASE_FIXTURE(Fixture, "setmetatable_should_not_mutate_persisted_types")
diff --git a/tests/TypeInfer.generics.test.cpp b/tests/TypeInfer.generics.test.cpp
index b62044fa..114679e3 100644
--- a/tests/TypeInfer.generics.test.cpp
+++ b/tests/TypeInfer.generics.test.cpp
@@ -629,8 +629,6 @@ return exports
 
 TEST_CASE_FIXTURE(Fixture, "instantiated_function_argument_names")
 {
-    ScopedFastFlag luauFunctionArgumentNameSize{"LuauFunctionArgumentNameSize", true};
-
     CheckResult result = check(R"(
 local function f<T, U...>(a: T, ...: U...) end
 
diff --git a/tests/TypeInfer.test.cpp b/tests/TypeInfer.test.cpp
index 76324556..f70f3b1c 100644
--- a/tests/TypeInfer.test.cpp
+++ b/tests/TypeInfer.test.cpp
@@ -4803,8 +4803,6 @@ local bar = foo.nutrition + 100
 
 TEST_CASE_FIXTURE(Fixture, "require_failed_module")
 {
-    ScopedFastFlag luauModuleRequireErrorPack{"LuauModuleRequireErrorPack", true};
-
     fileResolver.source["game/A"] = R"(
 return unfortunately()
     )";
diff --git a/tests/TypeInfer.tryUnify.test.cpp b/tests/TypeInfer.tryUnify.test.cpp
index f55b46a4..1e790eba 100644
--- a/tests/TypeInfer.tryUnify.test.cpp
+++ b/tests/TypeInfer.tryUnify.test.cpp
@@ -12,6 +12,8 @@ LUAU_FASTFLAG(LuauQuantifyInPlace2);
 
 using namespace Luau;
 
+LUAU_FASTFLAG(LuauUseCommittingTxnLog)
+
 struct TryUnifyFixture : Fixture
 {
     TypeArena arena;
@@ -28,7 +30,7 @@ TEST_CASE_FIXTURE(TryUnifyFixture, "primitives_unify")
     TypeVar numberOne{TypeVariant{PrimitiveTypeVar{PrimitiveTypeVar::Number}}};
     TypeVar numberTwo = numberOne;
 
-    state.tryUnify(&numberOne, &numberTwo);
+    state.tryUnify(&numberTwo, &numberOne);
 
     CHECK(state.errors.empty());
 }
@@ -41,9 +43,12 @@ TEST_CASE_FIXTURE(TryUnifyFixture, "compatible_functions_are_unified")
     TypeVar functionTwo{TypeVariant{
         FunctionTypeVar(arena.addTypePack({arena.freshType(globalScope->level)}), arena.addTypePack({arena.freshType(globalScope->level)}))}};
 
-    state.tryUnify(&functionOne, &functionTwo);
+    state.tryUnify(&functionTwo, &functionOne);
     CHECK(state.errors.empty());
 
+    if (FFlag::LuauUseCommittingTxnLog)
+        state.log.commit();
+
     CHECK_EQ(functionOne, functionTwo);
 }
 
@@ -61,7 +66,7 @@ TEST_CASE_FIXTURE(TryUnifyFixture, "incompatible_functions_are_preserved")
 
     TypeVar functionTwoSaved = functionTwo;
 
-    state.tryUnify(&functionOne, &functionTwo);
+    state.tryUnify(&functionTwo, &functionOne);
     CHECK(!state.errors.empty());
 
     CHECK_EQ(functionOne, functionOneSaved);
@@ -80,10 +85,13 @@ TEST_CASE_FIXTURE(TryUnifyFixture, "tables_can_be_unified")
 
     CHECK_NE(*getMutable<TableTypeVar>(&tableOne)->props["foo"].type, *getMutable<TableTypeVar>(&tableTwo)->props["foo"].type);
 
-    state.tryUnify(&tableOne, &tableTwo);
+    state.tryUnify(&tableTwo, &tableOne);
 
     CHECK(state.errors.empty());
 
+    if (FFlag::LuauUseCommittingTxnLog)
+        state.log.commit();
+
     CHECK_EQ(*getMutable<TableTypeVar>(&tableOne)->props["foo"].type, *getMutable<TableTypeVar>(&tableTwo)->props["foo"].type);
 }
 
@@ -101,11 +109,12 @@ TEST_CASE_FIXTURE(TryUnifyFixture, "incompatible_tables_are_preserved")
 
     CHECK_NE(*getMutable<TableTypeVar>(&tableOne)->props["foo"].type, *getMutable<TableTypeVar>(&tableTwo)->props["foo"].type);
 
-    state.tryUnify(&tableOne, &tableTwo);
+    state.tryUnify(&tableTwo, &tableOne);
 
     CHECK_EQ(1, state.errors.size());
 
-    state.log.rollback();
+    if (!FFlag::LuauUseCommittingTxnLog)
+        state.DEPRECATED_log.rollback();
 
     CHECK_NE(*getMutable<TableTypeVar>(&tableOne)->props["foo"].type, *getMutable<TableTypeVar>(&tableTwo)->props["foo"].type);
 }
@@ -170,7 +179,7 @@ TEST_CASE_FIXTURE(TryUnifyFixture, "variadic_type_pack_unification")
     TypePackVar testPack{TypePack{{typeChecker.numberType, typeChecker.stringType}, std::nullopt}};
     TypePackVar variadicPack{VariadicTypePack{typeChecker.numberType}};
 
-    state.tryUnify(&variadicPack, &testPack);
+    state.tryUnify(&testPack, &variadicPack);
     CHECK(!state.errors.empty());
 }
 
@@ -180,7 +189,7 @@ TEST_CASE_FIXTURE(TryUnifyFixture, "variadic_tails_respect_progress")
     TypePackVar a{TypePack{{typeChecker.numberType, typeChecker.stringType, typeChecker.booleanType, typeChecker.booleanType}}};
     TypePackVar b{TypePack{{typeChecker.numberType, typeChecker.stringType}, &variadicPack}};
 
-    state.tryUnify(&a, &b);
+    state.tryUnify(&b, &a);
     CHECK(state.errors.empty());
 }
 
@@ -214,32 +223,41 @@ TEST_CASE_FIXTURE(TryUnifyFixture, "cli_41095_concat_log_in_sealed_table_unifica
     CHECK_EQ(toString(result.errors[1]), "Available overloads: ({a}, a) -> (); and ({a}, number, a) -> ()");
 }
 
-TEST_CASE_FIXTURE(TryUnifyFixture, "undo_new_prop_on_unsealed_table")
+TEST_CASE("undo_new_prop_on_unsealed_table")
 {
     ScopedFastFlag flags[] = {
         {"LuauTableSubtypingVariance2", true},
+        // This test makes no sense with a committing TxnLog.
+        {"LuauUseCommittingTxnLog", false},
     };
     // I am not sure how to make this happen in Luau code.
 
-    TypeId unsealedTable = arena.addType(TableTypeVar{TableState::Unsealed, TypeLevel{}});
-    TypeId sealedTable = arena.addType(TableTypeVar{
-        {{"prop", Property{getSingletonTypes().numberType}}},
-        std::nullopt,
-        TypeLevel{},
-        TableState::Sealed
-    });
+    TryUnifyFixture fix;
+
+    TypeId unsealedTable = fix.arena.addType(TableTypeVar{TableState::Unsealed, TypeLevel{}});
+    TypeId sealedTable =
+        fix.arena.addType(TableTypeVar{{{"prop", Property{getSingletonTypes().numberType}}}, std::nullopt, TypeLevel{}, TableState::Sealed});
 
     const TableTypeVar* ttv = get<TableTypeVar>(unsealedTable);
     REQUIRE(ttv);
 
-    state.tryUnify(unsealedTable, sealedTable);
+    fix.state.tryUnify(sealedTable, unsealedTable);
 
     // To be honest, it's really quite spooky here that we're amending an unsealed table in this case.
     CHECK(!ttv->props.empty());
 
-    state.log.rollback();
+    fix.state.DEPRECATED_log.rollback();
 
     CHECK(ttv->props.empty());
 }
 
+TEST_CASE_FIXTURE(TryUnifyFixture, "free_tail_is_grown_properly")
+{
+    TypePackId threeNumbers = arena.addTypePack(TypePack{{typeChecker.numberType, typeChecker.numberType, typeChecker.numberType}, std::nullopt});
+    TypePackId numberAndFreeTail = arena.addTypePack(TypePack{{typeChecker.numberType}, arena.addTypePack(TypePackVar{FreeTypePack{TypeLevel{}}})});
+
+    ErrorVec unifyErrors = state.canUnify(numberAndFreeTail, threeNumbers);
+    CHECK(unifyErrors.size() == 0);
+}
+
 TEST_SUITE_END();
diff --git a/tests/TypeInfer.typePacks.cpp b/tests/TypeInfer.typePacks.cpp
index 3f4420cd..5d37b032 100644
--- a/tests/TypeInfer.typePacks.cpp
+++ b/tests/TypeInfer.typePacks.cpp
@@ -10,6 +10,8 @@
 
 using namespace Luau;
 
+LUAU_FASTFLAG(LuauUseCommittingTxnLog)
+
 TEST_SUITE_BEGIN("TypePackTests");
 
 TEST_CASE_FIXTURE(Fixture, "infer_multi_return")
@@ -263,10 +265,13 @@ TEST_CASE_FIXTURE(Fixture, "variadic_pack_syntax")
     CHECK_EQ(toString(requireType("foo")), "(...number) -> ()");
 }
 
-// CLI-45791
-TEST_CASE_FIXTURE(UnfrozenFixture, "type_pack_hidden_free_tail_infinite_growth")
+// Switch back to TEST_CASE_FIXTURE with regular Fixture when removing the
+// LuauUseCommittingTxnLog flag.
+TEST_CASE("type_pack_hidden_free_tail_infinite_growth")
 {
-    CheckResult result = check(R"(
+    Fixture fix(FFlag::LuauUseCommittingTxnLog);
+
+    CheckResult result = fix.check(R"(
 --!nonstrict
 if _ then
     _[function(l0)end],l0 = _
@@ -278,7 +283,8 @@ elseif _ then
 end
     )");
 
-    LUAU_REQUIRE_ERRORS(result);
+    // Switch back to LUAU_REQUIRE_ERRORS(result) when using TEST_CASE_FIXTURE.
+    CHECK(result.errors.size() > 0);
 }
 
 TEST_CASE_FIXTURE(Fixture, "variadic_argument_tail")
diff --git a/tests/TypeInfer.unionTypes.test.cpp b/tests/TypeInfer.unionTypes.test.cpp
index 2357869e..b54ba996 100644
--- a/tests/TypeInfer.unionTypes.test.cpp
+++ b/tests/TypeInfer.unionTypes.test.cpp
@@ -8,6 +8,7 @@
 #include "doctest.h"
 
 LUAU_FASTFLAG(LuauEqConstraint)
+LUAU_FASTFLAG(LuauUseCommittingTxnLog)
 
 using namespace Luau;
 
@@ -282,16 +283,19 @@ local c = b:foo(1, 2)
     CHECK_EQ("Value of type 'A?' could be nil", toString(result.errors[0]));
 }
 
-TEST_CASE_FIXTURE(UnfrozenFixture, "optional_union_follow")
+TEST_CASE("optional_union_follow")
 {
-    CheckResult result = check(R"(
+    Fixture fix(FFlag::LuauUseCommittingTxnLog);
+
+    CheckResult result = fix.check(R"(
 local y: number? = 2
 local x = y
 local function f(a: number, b: typeof(x), c: typeof(x)) return -a end
 return f()
     )");
 
-    LUAU_REQUIRE_ERROR_COUNT(1, result);
+    REQUIRE_EQ(result.errors.size(), 1);
+    // LUAU_REQUIRE_ERROR_COUNT(1, result);
 
     auto acm = get<CountMismatch>(result.errors[0]);
     REQUIRE(acm);
diff --git a/tests/TypeVar.test.cpp b/tests/TypeVar.test.cpp
index 13db923e..2e0d149e 100644
--- a/tests/TypeVar.test.cpp
+++ b/tests/TypeVar.test.cpp
@@ -185,6 +185,8 @@ TEST_CASE_FIXTURE(Fixture, "UnionTypeVarIterator_with_empty_union")
 
 TEST_CASE_FIXTURE(Fixture, "substitution_skip_failure")
 {
+    ScopedFastFlag sff{"LuauSealExports", true};
+
     TypeVar ftv11{FreeTypeVar{TypeLevel{}}};
 
     TypePackVar tp24{TypePack{{&ftv11}}};
@@ -261,7 +263,7 @@ TEST_CASE_FIXTURE(Fixture, "substitution_skip_failure")
 
     TypeId result = typeChecker.anyify(typeChecker.globalScope, root, Location{});
 
-    CHECK_EQ("{ f: t1 } where t1 = () -> { f: () -> { f: ({ f: t1 }) -> (), signal: { f: (any) -> () } } }", toString(result));
+    CHECK_EQ("{| f: t1 |} where t1 = () -> {| f: () -> {| f: ({| f: t1 |}) -> (), signal: {| f: (any) -> () |} |} |}", toString(result));
 }
 
 TEST_CASE("tagging_tables")
diff --git a/tests/conformance/debug.lua b/tests/conformance/debug.lua
index 9cf3c742..8c96ab33 100644
--- a/tests/conformance/debug.lua
+++ b/tests/conformance/debug.lua
@@ -98,4 +98,13 @@ assert(quuz(function(...) end) == "0 true")
 assert(quuz(function(a, b) end) == "2 false")
 assert(quuz(function(a, b, ...) end) == "2 true")
 
+-- info linedefined & line
+function testlinedefined()
+	local line = debug.info(1, "l")
+	local linedefined = debug.info(testlinedefined, "l")
+	assert(linedefined + 1 == line)
+end
+
+testlinedefined()
+
 return 'OK'
diff --git a/tests/conformance/strconv.lua b/tests/conformance/strconv.lua
new file mode 100644
index 00000000..85ad0295
--- /dev/null
+++ b/tests/conformance/strconv.lua
@@ -0,0 +1,51 @@
+-- This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+-- This file is based on Lua 5.x tests -- https://github.com/lua/lua/tree/master/testes
+print("testing string-number conversion")
+
+-- zero
+assert(tostring(0) == "0")
+assert(tostring(0/-1) == "-0")
+
+-- specials
+assert(tostring(1/0) == "inf")
+assert(tostring(-1/0) == "-inf")
+assert(tostring(0/0) == "nan")
+
+-- integers
+assert(tostring(1) == "1")
+assert(tostring(42) == "42")
+assert(tostring(-4294967296) == "-4294967296")
+assert(tostring(9007199254740991) == "9007199254740991")
+
+-- decimals
+assert(tostring(0.5) == "0.5")
+assert(tostring(0.1) == "0.1")
+assert(tostring(-0.17) == "-0.17")
+assert(tostring(math.pi) == "3.141592653589793")
+
+-- fuzzing corpus
+assert(tostring(5.4536123983019448e-311) == "5.453612398302e-311")
+assert(tostring(5.4834368411298348e-311) == "5.48343684113e-311")
+assert(tostring(4.4154895841930002e-305) == "4.415489584193e-305")
+assert(tostring(1125968630513728) == "1125968630513728")
+assert(tostring(3.3951932655938423e-313) == "3.3951932656e-313")
+assert(tostring(1.625) == "1.625")
+assert(tostring(4.9406564584124654e-324) == "5.e-324")
+assert(tostring(2.0049288280105384) == "2.0049288280105384")
+assert(tostring(3.0517578125e-05) == "0.000030517578125")
+assert(tostring(1.383544921875) == "1.383544921875")
+assert(tostring(3.0053350932691001) == "3.0053350932691")
+assert(tostring(0.0001373291015625) == "0.0001373291015625")
+assert(tostring(-1.9490628022799998e+289) == "-1.94906280228e+289")
+assert(tostring(-0.00610404721867928) == "-0.00610404721867928")
+assert(tostring(0.00014495849609375) == "0.00014495849609375")
+assert(tostring(0.453125) == "0.453125")
+assert(tostring(-4.2375343999999997e+73) == "-4.2375344e+73")
+assert(tostring(1.3202313930270133e-192) == "1.3202313930270133e-192")
+assert(tostring(3.6984408976312836e+19) == "36984408976312840000")
+assert(tostring(2.0563000527063302) == "2.05630005270633")
+assert(tostring(4.8970527433648997e-260) == "4.8970527433649e-260")
+assert(tostring(1.62890625) == "1.62890625")
+assert(tostring(1.1295093211933533e+65) == "1.1295093211933533e+65")
+
+return "OK"
diff --git a/tests/main.cpp b/tests/main.cpp
index ed17070c..cd24e100 100644
--- a/tests/main.cpp
+++ b/tests/main.cpp
@@ -2,6 +2,8 @@
 #include "Luau/Common.h"
 
 #define DOCTEST_CONFIG_IMPLEMENT
+// Our calls to parseOption/parseFlag don't provide a prefix so set the prefix to the empty string.
+#define DOCTEST_CONFIG_OPTIONS_PREFIX ""
 #include "doctest.h"
 
 #ifdef _WIN32
@@ -18,6 +20,10 @@
 
 #include <optional>
 
+// Indicates if verbose output is enabled.
+// Currently, this enables  output from lua's 'print', but other verbose output could be enabled eventually.
+bool verbose = false;
+
 static bool skipFastFlag(const char* flagName)
 {
     if (strncmp(flagName, "Test", 4) == 0)
@@ -46,7 +52,7 @@ static bool debuggerPresent()
 #endif
 }
 
-static int assertionHandler(const char* expr, const char* file, int line)
+static int assertionHandler(const char* expr, const char* file, int line, const char* function)
 {
     if (debuggerPresent())
         LUAU_DEBUGBREAK();
@@ -235,6 +241,11 @@ int main(int argc, char** argv)
         return 0;
     }
 
+    if (doctest::parseFlag(argc, argv, "--verbose"))
+    {
+        verbose = true;
+    }
+
     if (std::vector<doctest::String> flags; doctest::parseCommaSepArgs(argc, argv, "--fflags=", flags))
         setFastFlags(flags);
 
@@ -261,7 +272,15 @@ int main(int argc, char** argv)
         }
     }
 
-    return context.run();
+    int result = context.run();
+    if (doctest::parseFlag(argc, argv, "--help") || doctest::parseFlag(argc, argv, "-h"))
+    {
+        printf("Additional command line options:\n");
+        printf(" --verbose                             Enables verbose output (e.g. lua 'print' statements)\n");
+        printf(" --fflags=                             Sets specified fast flags\n");
+        printf(" --list-fflags                         List all fast flags\n");
+    }
+    return result;
 }
 
 
diff --git a/tools/numprint.py b/tools/numprint.py
new file mode 100644
index 00000000..47ad36d9
--- /dev/null
+++ b/tools/numprint.py
@@ -0,0 +1,82 @@
+#!/usr/bin/python
+# This file is part of the Luau programming language and is licensed under MIT License; see LICENSE.txt for details
+
+# This code can be used to generate power tables for Schubfach algorithm (see lnumprint.cpp)
+
+import math
+import sys
+
+(_, pow10min, pow10max, compact) = sys.argv
+pow10min = int(pow10min)
+pow10max = int(pow10max)
+compact = compact == "True"
+
+# extract high 128 bits of the value
+def high128(n, roundup):
+	L = math.ceil(math.log2(n))
+
+	r = 0
+	for i in range(L - 128, L):
+		if i >= 0 and (n & (1 << i)) != 0:
+			r |= (1 << (i - L + 128))
+
+	return r + (1 if roundup else 0)
+
+def pow10approx(n):
+	if n == 0:
+		return 1 << 127
+	elif n > 0:
+		return high128(10**n, 5**n >= 2**128)
+	else:
+		# 10^-n is a binary fraction that can't be represented in floating point
+		# we need to extract top 128 bits of the fraction starting from the first 1
+		# to get there, we need to divide 2^k by 10^n for a sufficiently large k and repeat the extraction process
+		p = 10**-n
+		k = 2**128 * 16**-n # this guarantees that the fraction has more than 128 extra bits
+		return high128(k // p, True)
+
+def pow5_64(n):
+	assert(n >= 0)
+	if n == 0:
+		return 1 << 63
+	else:
+		return high128(5**n, False) >> 64
+
+if not compact:
+	print("// kPow10Table", pow10min, "..", pow10max)
+	print("{")
+	for p in range(pow10min, pow10max + 1):
+		h = hex(pow10approx(p))[2:]
+		assert(len(h) == 32)
+		print("    {0x%s, 0x%s}," % (h[0:16].upper(), h[16:32].upper()))
+	print("}")
+else:
+	print("// kPow5Table")
+	print("{")
+	for i in range(16):
+		print("    " + hex(pow5_64(i)) + ",")
+	print("}")
+	print("// kPow10Table", pow10min, "..", pow10max)
+	print("{")
+	for p in range(pow10min, pow10max + 1, 16):
+		base = pow10approx(p)
+		errw = 0
+		for i in range(16):
+			real = pow10approx(p + i)
+			appr = (base * pow5_64(i)) >> 64
+			scale = 1 if appr < (1 << 127) else 0 # 1-bit scale
+
+			offset = (appr << scale) - real
+			assert(offset >= -4 and offset <= 3) # 3-bit offset
+			assert((appr << scale) >> 64 == real >> 64) # offset only affects low half
+			assert((appr << scale) - offset == real) # validate full reconstruction
+
+			err = (scale << 3) | (offset + 4)
+			errw |= err << (i * 4)
+
+		hbase = hex(base)[2:]
+		assert(len(hbase) == 32)
+		assert(errw < 1 << 64)
+
+		print("    {0x%s, 0x%s, 0x%16x}," % (hbase[0:16], hbase[16:32], errw))
+	print("}")