@@ -8,15 +8,19 @@
 namespace Basis.Network.Server.Generic
 {
     /// <summary>
-    /// Keeps the bytes of every shared image in server RAM so a joining player can be handed the
-    /// images already in the instance, instead of the original sharer having to send them all over
-    /// again to each arrival.
+    /// Keeps the bytes of every shared image in server RAM so the rest of the room can be given a
+    /// picture the sharer only sent to the players standing near it, instead of the sharer having to
+    /// send it again to every arrival.
     ///
     /// The cache is deliberately dumb about what an image *is*: it retains the client's own scene
     /// payloads verbatim and replays them stamped with the original owner's player id. A receiving
     /// client therefore sees exactly the OpSpawn/OpChunk stream it would have got from the owner,
     /// and needs no knowledge that the server answered instead.
     ///
+    /// It is just as dumb about *where* an image is. What it hands a player first is an offer - the
+    /// sharer's own spawn header, opcode swapped - and the position inside is bytes it copies without
+    /// reading. Nothing moves until that client measures the distance for itself and asks.
+    ///
     /// Lifetime matches what clients already do with images, so the cache can never show a joiner
     /// something the room cannot see: an entry is dropped on despawn and when its owner disconnects.
     /// </summary>
 
@@ -63,7 +63,6 @@ public class BasisNetworkImageCacheTests : IDisposable
 
     private const byte OpSpawn = 1;
     private const byte OpChunk = 2;
-    private const byte OpTransform = 3;
     private const byte OpDespawn = 4;
     private const byte OpAnimationSpawn = 6;
     private const byte OpAnimationChunk = 7;
@@ -165,25 +164,6 @@ private static byte[] EncodeSpawn(
         return stream.ToArray();
     }
 
-    /// <summary>OpTransform as the client encodes it: pose then uniform scale.</summary>
-    private static byte[] EncodeTransform(Guid id, float x, float y, float z)
-    {
-        using MemoryStream stream = new MemoryStream();
-        using BinaryWriter writer = new BinaryWriter(stream, Encoding.UTF8);
-        writer.Write(OpTransform);
-        writer.Write(id.ToByteArray());
-        writer.Write(x);
-        writer.Write(y);
-        writer.Write(z);
-        for (int axis = 0; axis < 4; axis++)
-        {
-            writer.Write(0f);
-        }
-        writer.Write(1f);
-        writer.Flush();
-        return stream.ToArray();
-    }
-
     private static byte[] EncodeChunk(Guid id, int chunkIndex, int payloadBytes, byte opcode = OpChunk)
     {
         using MemoryStream stream = new MemoryStream();
 
@@ -22,9 +22,10 @@ namespace Basis.ImagePickup
 {
     /// <summary>
     /// Per-client image pickup service. It shares a deterministic network identity across all clients, so any
-    /// client can message the others. The server (or the P2P link) relays the bytes and never stores them: an
-    /// image exists only while its spawner is connected, and a late joiner is served by the owner re-sending.
-    /// Anyone may delete any image for everyone.
+    /// client can message the others. A sharer sends the picture only to the players it judges close enough;
+    /// the server keeps a copy and offers it to everyone else, who measure the distance themselves and ask for
+    /// it once they are near enough to want it. An image exists only while its spawner is connected, and
+    /// anyone may delete any image for everyone.
     ///
     /// The animation scheduler lives here too. It advances image-pickup animations only while their front face
     /// is visible to a gameplay camera: a per-frame CPU facing/frustum broad phase rejects cards before depth,
@@ -2019,8 +2020,8 @@ private static void RefreshRangeRecipients(float now)
                 if (owned?.Object == null)
                     continue;
 
-                // The server holds this one and hands it to arrivals itself, range-filtered the same
-                // way we filter, so re-uploading it is pure waste.
+                // The server holds this one and offers it to everyone else itself, so re-uploading it
+                // is pure waste. It tells us the moment it stops holding it and we start providing again.
                 if (_serverHeldImages.Contains(entry.Key))
                     continue;
 
 
@@ -8,15 +8,19 @@
 namespace Basis.Network.Server.Generic
 {
     /// <summary>
-    /// Keeps the bytes of every shared image in server RAM so a joining player can be handed the
-    /// images already in the instance, instead of the original sharer having to send them all over
-    /// again to each arrival.
+    /// Keeps the bytes of every shared image in server RAM so the rest of the room can be given a
+    /// picture the sharer only sent to the players standing near it, instead of the sharer having to
+    /// send it again to every arrival.
     ///
     /// The cache is deliberately dumb about what an image *is*: it retains the client's own scene
     /// payloads verbatim and replays them stamped with the original owner's player id. A receiving
     /// client therefore sees exactly the OpSpawn/OpChunk stream it would have got from the owner,
     /// and needs no knowledge that the server answered instead.
     ///
+    /// It is just as dumb about *where* an image is. What it hands a player first is an offer - the
+    /// sharer's own spawn header, opcode swapped - and the position inside is bytes it copies without
+    /// reading. Nothing moves until that client measures the distance for itself and asks.
+    ///
     /// Lifetime matches what clients already do with images, so the cache can never show a joiner
     /// something the room cannot see: an entry is dropped on despawn and when its owner disconnects.
     /// </summary>