fix(disk): cap build memory, document close() and build cost

README.md

@@ -404,7 +404,9 @@ it** for the life of the process rather than reconstructing it per query.
 `WordlistQuery(disk=True)` for the middle ground: a one-time build of a persistent indexed file
 (~500 MB, written to `wordlist-index.duckdb` in the working directory — pass `disk="/path/to/index.duckdb"`
 to place it elsewhere), then fast index-seek queries (~tens of ms) at that same low footprint. The file
-is rebuilt automatically when a new release changes the data.
+is rebuilt automatically when a new release changes the data; note the one-time build peaks above the
+steady-state footprint (it is not itself a low-memory operation). Call `.close()` to release the file
+handle when done (needed on Windows before an in-process rebuild).
 
 Each result is a `Match(prefix, wordform, function, row, morph_anchor, spelling, anchor_genres)`:
 - `prefix` — the attached prefix letters (`""` if none).

wordlist_query.py

@@ -41,7 +41,10 @@ Pass `disk=True` (or `disk="/path/to/index.duckdb"`) for the middle ground: a on
 persistent, indexed DuckDB file (inverted spelling->id index), then opened read-only with a capped
 buffer pool. Resident RAM stays near the low_memory baseline, but queries are index seeks (~tens of
 ms) instead of scans (~1s). Best for bulk programmatic lookups where eager's RAM is too much. The
-on-disk file (~500 MB) is rebuilt automatically when the dataset content changes (new release).
+on-disk file (~500 MB) is rebuilt automatically when the dataset content changes (new release); that
+one-time build peaks above the steady-state footprint (capped, spills to disk), so it is not itself a
+low-memory operation. Call `.close()` to release the file handle (only needed in low_memory/disk mode;
+required on Windows before the file can be rebuilt in-process); the instance is unusable afterward.
 """
 from dataclasses import dataclass
 from enum import Enum
@@ -191,10 +194,15 @@ class WordlistQuery:
             # and a reader opening `path` sees either the whole old index or the whole new one.
             # (os.replace is atomic on POSIX; on Windows it still raises if another process holds `path`.)
             self._log(f"building disk index at {path} (one-time) …")
+            # ponytail: fixed temp name — a second process building the same `path` at once would collide;
+            # fine for a single-user helper, add a pid/lock if concurrent first-time builds matter.
             tmp = f"{path}.tmp"
             for p in (tmp, f"{tmp}.wal"):
                 if os.path.exists(p): os.remove(p)
-            b = duckdb.connect(tmp)
+            # Cap the one-time build too (DuckDB spills to disk when capped) so it doesn't briefly grab
+            # ~80% of RAM on the very box where disk mode was chosen to avoid eager's footprint. The build
+            # still peaks above steady-state; it just won't balloon.
+            b = duckdb.connect(tmp, config={"memory_limit": "1GB"})
             try:
                 b.register("wl", getattr(self.ds.data, "table", self.ds.data))
                 b.register("att", getattr(self.ads.data, "table", self.ads.data))