Upload 4 files

server.py

@@ -10,8 +10,9 @@ Usage:
 """
 
 import hashlib
-import json
-import math
+import base64
+import json
+import math
 import random
 import re
 import secrets
@@ -94,18 +95,41 @@ CANDIDATE_SET_BY_DIFFICULTY: dict[str, set[str]] = {
 
 SECRET_WORD_SET = set(SECRET_CANDIDATES)
 SECRET_WORD_SEEDS_PATH = Path(__file__).parent / "secret_word_seeds.json"
-DEFAULT_CANONICAL_SEED_PREFIX = "w:"
+DEFAULT_CANONICAL_SEED_PREFIX = ""
+DEFAULT_CANONICAL_SEED_NAMESPACE = "semantick:secret-seed:v2"
+DEFAULT_CANONICAL_SEED_TOKEN_LEN = 6
+
+
+def _seed_for_word_with_nonce(word: str, seed_prefix: str, nonce: int) -> str:
+    payload = f"{DEFAULT_CANONICAL_SEED_NAMESPACE}|{word}|{nonce}".encode("utf-8")
+    digest = hashlib.blake2b(payload, digest_size=16).digest()
+    token = base64.b32encode(digest).decode("ascii").rstrip("=").lower()
+    return f"{seed_prefix}{token[:DEFAULT_CANONICAL_SEED_TOKEN_LEN]}"
 
 
 def _build_default_secret_seed_map(words: list[str], seed_prefix: str) -> dict[str, str]:
     unique_words = sorted(set(words))
-    return {word: f"{seed_prefix}{word}" for word in unique_words}
+    result: dict[str, str] = {}
+    used: set[str] = set()
+    for word in unique_words:
+        nonce = 0
+        while True:
+            seed = _seed_for_word_with_nonce(word, seed_prefix, nonce)
+            if len(word) >= 4 and word in seed:
+                nonce += 1
+                continue
+            if seed not in used:
+                used.add(seed)
+                result[word] = seed
+                break
+            nonce += 1
+    return result
 
 
 def _load_secret_seed_mapping() -> tuple[str, dict[str, str]]:
     """
     Load precomputed canonical seed mapping if available and valid.
-    Falls back to deterministic prefix-based mapping.
+    Falls back to deterministic opaque hash mapping.
     """
     fallback = _build_default_secret_seed_map(SECRET_CANDIDATES, DEFAULT_CANONICAL_SEED_PREFIX)
     if not SECRET_WORD_SEEDS_PATH.exists():
@@ -124,10 +148,7 @@ def _load_secret_seed_mapping() -> tuple[str, dict[str, str]]:
                 if word in SECRET_WORD_SET and seed:
                     loaded[word] = seed
         # Ensure complete coverage for current secret candidate set.
-        complete = {
-            word: loaded.get(word, f"{prefix}{word}")
-            for word in sorted(SECRET_WORD_SET)
-        }
+        complete = {word: loaded.get(word, fallback[word]) for word in sorted(SECRET_WORD_SET)}
         # Enforce 1:1 seed uniqueness; fallback if duplicates are present.
         if len(set(complete.values())) != len(complete):
             print("secret_word_seeds.json has duplicate seeds; using default canonical mapping")
@@ -497,14 +518,25 @@ def _word_from_canonical_seed(seed: str) -> str | None:
     mapped = CANONICAL_SEED_TO_WORD.get(raw)
     if mapped:
         return mapped
-    # Backward-compatible prefix parsing.
-    if raw.startswith(CANONICAL_SEED_PREFIX):
-        maybe = raw[len(CANONICAL_SEED_PREFIX):].strip().lower()
-        if maybe in SECRET_WORD_SET:
-            return maybe
     return None
 
 
+def _canonical_seed_fallback(word: str) -> str:
+    normalized = word.strip().lower()
+    if not normalized:
+        return ""
+    nonce = 0
+    while True:
+        seed = _seed_for_word_with_nonce(normalized, DEFAULT_CANONICAL_SEED_PREFIX, nonce)
+        if len(normalized) >= 4 and normalized in seed:
+            nonce += 1
+            continue
+        owner = CANONICAL_SEED_TO_WORD.get(seed)
+        if owner is None or owner == normalized:
+            return seed
+        nonce += 1
+
+
 def seed_to_word_filtered(seed: str, difficulty: str | None = None) -> str:
     """Deterministically pick a secret word, optionally filtered by difficulty."""
     if difficulty:
@@ -556,7 +588,7 @@ def seed_for_word(word: str = Query(...), difficulty: str | None = Query(None)):
             difficulty=difficulty,
         )
 
-    seed_value = canonical_seed_for_word(normalized) or f"{CANONICAL_SEED_PREFIX}{normalized}"
+    seed_value = canonical_seed_for_word(normalized) or _canonical_seed_fallback(normalized)
     return SeedLookupResponse(
         word=normalized,
         found=True,