@@ -27,8 +27,8 @@ protected override Size BindValue(in BindContext context, Stream value, ref obje
             return checked((int)(value.Length - value.Position));
 
         var memoryStream = new MemoryStream();
-        value.CopyTo(memoryStream);
         writeState = memoryStream;
+        value.CopyTo(memoryStream);
         return checked((int)memoryStream.Length);
     }
 
 
@@ -203,7 +203,10 @@ public Size BindAsObject(in BindContext context, object? value, ref object? writ
             // writeState pointing at a half-disposed object — they'd dispose it again.
             (var current, writeState) = (writeState, null);
             (current as IDisposable)?.Dispose();
-            if (!ReferenceEquals(current, originalWriteState))
+            // current==null with original!=null means an inner safety net (transparent wrapper case)
+            // already disposed the original. Disposing again would double-dispose. The non-null branch
+            // handles the genuine lifecycle-violation swap where current and original differ.
+            if (current is not null && !ReferenceEquals(current, originalWriteState))
                 (originalWriteState as IDisposable)?.Dispose();
             throw;
         }
@@ -377,7 +380,10 @@ public Size Bind(in BindContext context,
             // writeState pointing at a half-disposed object — they'd dispose it again.
             (var current, writeState) = (writeState, null);
             (current as IDisposable)?.Dispose();
-            if (!ReferenceEquals(current, originalWriteState))
+            // current==null with original!=null means an inner safety net (transparent wrapper case)
+            // already disposed the original. Disposing again would double-dispose. The non-null branch
+            // handles the genuine lifecycle-violation swap where current and original differ.
+            if (current is not null && !ReferenceEquals(current, originalWriteState))
                 (originalWriteState as IDisposable)?.Dispose();
             throw;
         }
 
@@ -752,7 +752,20 @@ internal void Bind(out DataFormat format, out Size size, DataFormat? requiredFor
         // the type info may still support the required format, just not the format the cached
         // binding chose. Re-running Bind with the new preference can produce a satisfying binding.
         if (_isBound && requiredFormat is not null && _binding.DataFormat != requiredFormat.GetValueOrDefault())
+        {
             DisposeBindingState();
+            // First Bind consumed _providerWriteState into _binding. Re-resolve so the rebuild has
+            // the state late-bound paths (ObjectConverter.BindValue) require — without this the
+            // re-bind would hit "Invalid state" before the format-mismatch error could surface.
+            // Typed-concrete paths re-resolve to default state, harmless.
+            if (TypeInfo is not null && _providerWriteState is null)
+            {
+                var resolveContext = new ProviderValueContext { NestedObjectDbNullHandling = ParameterDbNullHandling };
+                _ = StaticValueType == typeof(object)
+                    ? TypeInfo.MakeConcreteForValueAsObject(resolveContext, Value is DBNull ? null : Value, out _providerWriteState)
+                    : MakeConcreteForTypedValue(TypeInfo, out _providerWriteState);
+            }
+        }
 
         // Idempotent — validation pass and WriteBind both call this; first wins.
         if (!_isBound)
Original file line number	Diff line number	Diff line change
`@@ -27,8 +27,8 @@ protected override Size BindValue(in BindContext context, Stream value, ref obje`
`27`	`27`	`return checked((int)(value.Length - value.Position));`
`28`	`28`
`29`	`29`	`var memoryStream = new MemoryStream();`
`30`		`- value.CopyTo(memoryStream);`
`31`	`30`	`writeState = memoryStream;`
	`31`	`+ value.CopyTo(memoryStream);`
`32`	`32`	`return checked((int)memoryStream.Length);`
`33`	`33`	`}`
`34`	`34`