@@ -1,6 +1,6 @@
 ## Unreleased
 
-Ten changes from [@brettwooldridge](https://github.com/brettwooldridge), most of them found on a production system. Four are data-integrity fixes, three of which can end with a store that will not reopen or a query that quietly returns the wrong rows.
+Eleven changes from [@brettwooldridge](https://github.com/brettwooldridge), most of them found on a production system. Four are data-integrity fixes, three of which can end with a store that will not reopen or a query that quietly returns the wrong rows.
 
 ### Issue Fixes
 
@@ -27,6 +27,11 @@ Ten changes from [@brettwooldridge](https://github.com/brettwooldridge), most of
 - **`clear()` and `dropIndex()` reach every layout map an index occupies** ([#1295](https://github.com/nitrite/nitrite-java/pull/1295))
   - `IndexManager.close()`, `clearAll()` and `dropIndexDescriptor()` acted only on the map name recorded in `IndexMeta`, which is the classic one. That already missed the composite map of a non-unique index: after `collection.clear()` its rows survived, and a query on that index returned the ids of the cleared documents alongside the new ones - two live documents, four results. It also broke `ChangeIdField`, whose `createIndex` found the previous index map still populated and rebuilt over it.
 
+- **The first concurrent read of an index after a restart no longer fails dropping its legacy map** ([#1309](https://github.com/nitrite/nitrite-java/pull/1309))
+  - The first read of an index still in a legacy layout migrates it and drops the legacy map, once per index instance. `ComparableIndexer` created those instances with an unsynchronized check-then-act, so threads arriving together could each get an instance of their own and each run the migration. On MVStore the second drop asked `MVMap.getName()` for a map that was already gone, got `null`, and failed with `NullPointerException` in `NitriteMVStore.removeMap`; the same race also threw from `Attributes.set` through `NitriteMap.updateLastModifiedTime`.
+  - Observed on a production system on the first multi-threaded lookup after every restart, because every close before [#1295](https://github.com/nitrite/nitrite-java/pull/1295) left an empty map under the legacy name for the next start to drop.
+  - The indexer and the MVStore map and R-tree registries now create their entries with `computeIfAbsent`, so there is one index instance and one map wrapper per name. `NitriteMVMap` keeps the name it was opened with and acts only when its compare-and-set wins, so `drop()` and `close()` run once; `removeMap` ignores a null name and no longer creates an empty map only to remove it.
+
 - **A unique index no longer rejects a document over a key that document already holds** ([#1295](https://github.com/nitrite/nitrite-java/pull/1295))
   - `addNitriteIds` treated any existing id under the key as a violation, so it counted the writer's own id against it. Another document under the key is a violation; the same document again is not - which is what a unique index over an array field with a repeated element does, and what an index rebuild or a replayed write does.
 
 
@@ -23,21 +23,38 @@
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
+import static org.dizitart.no2.common.util.IndexUtils.deriveIndexMapName;
+import static org.dizitart.no2.filters.FluentFilter.where;
 import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 
 import java.lang.reflect.Field;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 
+import org.dizitart.no2.NitriteConfig;
+import org.dizitart.no2.collection.FindPlan;
+import org.dizitart.no2.collection.NitriteId;
+import org.dizitart.no2.common.DBValue;
+import org.dizitart.no2.common.Fields;
 import org.dizitart.no2.exceptions.NitriteIOException;
+import org.dizitart.no2.filters.ComparableFilter;
+import org.dizitart.no2.filters.IndexScanFilter;
+import org.dizitart.no2.index.IndexDescriptor;
+import org.dizitart.no2.index.IndexType;
+import org.dizitart.no2.index.NonUniqueIndexer;
 import org.dizitart.no2.store.NitriteMap;
 import org.h2.mvstore.MVStore;
 import org.junit.Test;
@@ -167,6 +184,78 @@ public void testCompactingClosesAreSerialized() throws Exception {
         }
     }
 
+    @Test
+    public void testDropThroughAWrapperWhoseMapIsAlreadyGone() {
+        // MVMap.getName() answers null once the map is removed, so a second holder's drop()
+        // used to hand removeMap a null name and fail
+        final NitriteMVStore store = openInMemoryStore();
+        try {
+            NitriteMap<String, String> stale = store.openMap("m", String.class, String.class);
+            stale.close();
+            NitriteMap<String, String> current = store.openMap("m", String.class, String.class);
+            current.drop();
+
+            stale.drop();
+            assertEquals("m", stale.getName());
+            assertFalse(store.hasMap("m"));
+        } finally {
+            store.close();
+        }
+    }
+
+    @Test
+    public void testConcurrentFirstReadOfALegacyIndexMigratesOnce() throws Exception {
+        // the first multi-threaded read after a reopen used to build one index instance per
+        // thread, each migrating and dropping the legacy map; the second drop failed
+        final int threads = 16;
+        final ExecutorService executorService = Executors.newFixedThreadPool(threads);
+        try {
+            for (int round = 0; round < 50; round++) {
+                final NitriteMVStore store = openInMemoryStore();
+                try {
+                    final IndexDescriptor desc = new IndexDescriptor(IndexType.NON_UNIQUE,
+                        Fields.withNames("a"), "c");
+                    final NitriteId id = NitriteId.createId(1L);
+                    store.openMap(deriveIndexMapName(desc), DBValue.class, ArrayList.class)
+                        .put(new DBValue("k"), new ArrayList<>(Collections.singletonList(id)));
+
+                    final NitriteConfig config = mock(NitriteConfig.class);
+                    doReturn(store).when(config).getNitriteStore();
+                    final FindPlan plan = new FindPlan();
+                    plan.setIndexDescriptor(desc);
+                    plan.setIndexScanFilter(new IndexScanFilter(Collections.singletonList(
+                        (ComparableFilter) where("a").eq("k"))));
+
+                    final NonUniqueIndexer indexer = new NonUniqueIndexer();
+                    final CountDownLatch start = new CountDownLatch(1);
+                    final List<Future<Set<NitriteId>>> reads = new ArrayList<>();
+                    for (int t = 0; t < threads; t++) {
+                        reads.add(executorService.submit(() -> {
+                            start.await();
+                            return indexer.findByFilter(plan, config);
+                        }));
+                    }
+                    start.countDown();
+                    for (Future<Set<NitriteId>> read : reads) {
+                        assertEquals(Collections.singleton(id), read.get(5, TimeUnit.SECONDS));
+                    }
+                    assertFalse(store.hasMap(deriveIndexMapName(desc)));
+                } finally {
+                    store.close();
+                }
+            }
+        } finally {
+            executorService.shutdownNow();
+        }
+    }
+
+    private NitriteMVStore openInMemoryStore() {
+        final NitriteMVStore store = new NitriteMVStore();
+        store.setStoreConfig(new MVStoreConfig());
+        store.openOrCreate();
+        return store;
+    }
+
     private NitriteMVStore createCompactingStore(final MVStore mvStore) throws Exception {
         final NitriteMVStore nitriteMVStore = new NitriteMVStore();
         final MVStoreConfig config = new MVStoreConfig();